Python numpy.max() Examples
The following are 30
code examples of numpy.max().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.

Example #1
Source File: spectrum_painter.py From spectrum_painter with MIT License | 7 votes |
def convert_image(self, filename): pic = img.imread(filename) # Set FFT size to be double the image size so that the edge of the spectrum stays clear # preventing some bandfilter artifacts self.NFFT = 2*pic.shape[1] # Repeat image lines until each one comes often enough to reach the desired line time ffts = (np.flipud(np.repeat(pic[:, :, 0], self.repetitions, axis=0) / 16.)**2.) / 256. # Embed image in center bins of the FFT fftall = np.zeros((ffts.shape[0], self.NFFT)) startbin = int(self.NFFT/4) fftall[:, startbin:(startbin+pic.shape[1])] = ffts # Generate random phase vectors for the FFT bins, this is important to prevent high peaks in the output # The phases won't be visible in the spectrum phases = 2*np.pi*np.random.rand(*fftall.shape) rffts = fftall * np.exp(1j*phases) # Perform the FFT per image line, then concatenate them to form the final signal timedata = np.fft.ifft(np.fft.ifftshift(rffts, axes=1), axis=1) / np.sqrt(float(self.NFFT)) linear = timedata.flatten() linear = linear / np.max(np.abs(linear)) return linear
Example #2
Source File: vertcoord.py From aospy with Apache License 2.0 | 6 votes |
def to_radians(arr, is_delta=False): """Force data with units either degrees or radians to be radians.""" # Infer the units from embedded metadata, if it's there. try: units = arr.units except AttributeError: pass else: if units.lower().startswith('degrees'): warn_msg = ("Conversion applied: degrees -> radians to array: " "{}".format(arr)) logging.debug(warn_msg) return np.deg2rad(arr) # Otherwise, assume degrees if the values are sufficiently large. threshold = 0.1*np.pi if is_delta else 4*np.pi if np.max(np.abs(arr)) > threshold: warn_msg = ("Conversion applied: degrees -> radians to array: " "{}".format(arr)) logging.debug(warn_msg) return np.deg2rad(arr) return arr
Example #3
Source File: dataset_tool.py From disentangling_conditional_gans with MIT License | 6 votes |
def create_mnist(tfrecord_dir, mnist_dir): print('Loading MNIST from "%s"' % mnist_dir) import gzip with gzip.open(os.path.join(mnist_dir, 'train-images-idx3-ubyte.gz'), 'rb') as file: images = np.frombuffer(file.read(), np.uint8, offset=16) with gzip.open(os.path.join(mnist_dir, 'train-labels-idx1-ubyte.gz'), 'rb') as file: labels = np.frombuffer(file.read(), np.uint8, offset=8) images = images.reshape(-1, 1, 28, 28) images = np.pad(images, [(0,0), (0,0), (2,2), (2,2)], 'constant', constant_values=0) assert images.shape == (60000, 1, 32, 32) and images.dtype == np.uint8 assert labels.shape == (60000,) and labels.dtype == np.uint8 assert np.min(images) == 0 and np.max(images) == 255 assert np.min(labels) == 0 and np.max(labels) == 9 onehot = np.zeros((labels.size, np.max(labels) + 1), dtype=np.float32) onehot[np.arange(labels.size), labels] = 1.0 with TFRecordExporter(tfrecord_dir, images.shape[0]) as tfr: order = tfr.choose_shuffled_order() for idx in range(order.size): tfr.add_image(images[order[idx]]) tfr.add_labels(onehot[order]) #----------------------------------------------------------------------------
Example #4
Source File: dataset_tool.py From disentangling_conditional_gans with MIT License | 6 votes |
def create_mnistrgb(tfrecord_dir, mnist_dir, num_images=1000000, random_seed=123): print('Loading MNIST from "%s"' % mnist_dir) import gzip with gzip.open(os.path.join(mnist_dir, 'train-images-idx3-ubyte.gz'), 'rb') as file: images = np.frombuffer(file.read(), np.uint8, offset=16) images = images.reshape(-1, 28, 28) images = np.pad(images, [(0,0), (2,2), (2,2)], 'constant', constant_values=0) assert images.shape == (60000, 32, 32) and images.dtype == np.uint8 assert np.min(images) == 0 and np.max(images) == 255 with TFRecordExporter(tfrecord_dir, num_images) as tfr: rnd = np.random.RandomState(random_seed) for idx in range(num_images): tfr.add_image(images[rnd.randint(images.shape[0], size=3)]) #----------------------------------------------------------------------------
Example #5
Source File: dataset_tool.py From disentangling_conditional_gans with MIT License | 6 votes |
def create_cifar100(tfrecord_dir, cifar100_dir): print('Loading CIFAR-100 from "%s"' % cifar100_dir) import pickle with open(os.path.join(cifar100_dir, 'train'), 'rb') as file: data = pickle.load(file, encoding='latin1') images = data['data'].reshape(-1, 3, 32, 32) labels = np.array(data['fine_labels']) assert images.shape == (50000, 3, 32, 32) and images.dtype == np.uint8 assert labels.shape == (50000,) and labels.dtype == np.int32 assert np.min(images) == 0 and np.max(images) == 255 assert np.min(labels) == 0 and np.max(labels) == 99 onehot = np.zeros((labels.size, np.max(labels) + 1), dtype=np.float32) onehot[np.arange(labels.size), labels] = 1.0 with TFRecordExporter(tfrecord_dir, images.shape[0]) as tfr: order = tfr.choose_shuffled_order() for idx in range(order.size): tfr.add_image(images[order[idx]]) tfr.add_labels(onehot[order]) #----------------------------------------------------------------------------
Example #6
Source File: dataset.py From Deep_VoiceChanger with MIT License | 6 votes |
def wave2input_image(wave, window, pos=0, pad=0): wave_image = np.hstack([wave[pos+i*sride:pos+(i+pad*2)*sride+dif].reshape(height+pad*2, sride) for i in range(256//sride)])[:,:254] wave_image *= window spectrum_image = np.fft.fft(wave_image, axis=1) input_image = np.abs(spectrum_image[:,:128].reshape(1, height+pad*2, 128), dtype=np.float32) np.clip(input_image, 1000, None, out=input_image) np.log(input_image, out=input_image) input_image += bias input_image /= scale if np.max(input_image) > 0.95: print('input image max bigger than 0.95', np.max(input_image)) if np.min(input_image) < 0.05: print('input image min smaller than 0.05', np.min(input_image)) return input_image
Example #7
Source File: layers.py From deep-learning-note with MIT License | 6 votes |
def forward(self, x): N, C, H, W = x.shape out_h = int(1 + (H - self.pool_h) / self.stride) out_w = int(1 + (W - self.pool_w) / self.stride) col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad) col = col.reshape(-1, self.pool_h * self.pool_w) arg_max = np.argmax(col, axis=1) out = np.max(col, axis=1) out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2) self.x = x self.arg_max = arg_max return out
Example #8
Source File: feature_extraction.py From Sound-Recognition-Tutorial with Apache License 2.0 | 6 votes |
def extract_logmel(y, sr, size=3): """ extract log mel spectrogram feature :param y: the input signal (audio time series) :param sr: sample rate of 'y' :param size: the length (seconds) of random crop from original audio, default as 3 seconds :return: log-mel spectrogram feature """ # normalization y = y.astype(np.float32) normalization_factor = 1 / np.max(np.abs(y)) y = y * normalization_factor # random crop start = random.randint(0, len(y) - size * sr) y = y[start: start + size * sr] # extract log mel spectrogram ##### melspectrogram = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=2048, hop_length=1024, n_mels=60) logmelspec = librosa.power_to_db(melspectrogram) return logmelspec
Example #9
Source File: feature_extraction.py From Sound-Recognition-Tutorial with Apache License 2.0 | 6 votes |
def extract_mfcc(y, sr, size=3): """ extract MFCC feature :param y: np.ndarray [shape=(n,)], real-valued the input signal (audio time series) :param sr: sample rate of 'y' :param size: the length (seconds) of random crop from original audio, default as 3 seconds :return: MFCC feature """ # normalization y = y.astype(np.float32) normalization_factor = 1 / np.max(np.abs(y)) y = y * normalization_factor # random crop start = random.randint(0, len(y) - size * sr) y = y[start: start + size * sr] # extract log mel spectrogram ##### melspectrogram = librosa.feature.melspectrogram(y=y, sr=sr, n_fft=2048, hop_length=1024) mfcc = librosa.feature.mfcc(S=librosa.power_to_db(melspectrogram), n_mfcc=20) mfcc_delta = librosa.feature.delta(mfcc) mfcc_delta_delta = librosa.feature.delta(mfcc_delta) mfcc_comb = np.concatenate([mfcc, mfcc_delta, mfcc_delta_delta], axis=0) return mfcc_comb
Example #10
Source File: core.py From neuropythy with GNU Affero General Public License v3.0 | 6 votes |
def cortex_cmap_plot_2D(the_map, zs, cmap, vmin=None, vmax=None, axes=None, triangulation=None): ''' cortex_cmap_plot_2D(map, zs, cmap, axes) plots the given cortical map values zs on the given axes using the given given color map and yields the resulting polygon collection object. cortex_cmap_plot_2D(map, zs, cmap) uses matplotlib.pyplot.gca() for the axes. The following options may be passed: * triangulation (None) may specify the triangularion object for the mesh if it has already been created; otherwise it is generated fresh. * axes (None) specify the axes on which to plot; if None, then matplotlib.pyplot.gca() is used. If Ellipsis, then a tuple (triangulation, z, cmap) is returned; to recreate the plot, one would call: axes.tripcolor(triangulation, z, cmap, shading='gouraud', vmin=vmin, vmax=vmax) * vmin (default: None) specifies the minimum value for scaling the property when one is passed as the color option. None means to use the min value of the property. * vmax (default: None) specifies the maximum value for scaling the property when one is passed as the color option. None means to use the max value of the property. ''' if triangulation is None: triangulation = matplotlib.tri.Triangulation(the_map.coordinates[0], the_map.coordinates[1], triangles=the_map.tess.indexed_faces.T) if axes is Ellipsis: return (triangulation, zs, cmap) return axes.tripcolor(triangulation, zs, cmap=cmap, shading='gouraud', vmin=vmin, vmax=vmax)
Example #11
Source File: run_audio_attack.py From Black-Box-Audio with MIT License | 5 votes |
def db(audio): if len(audio.shape) > 1: maxx = np.max(np.abs(audio), axis=1) return 20 * np.log10(maxx) if np.any(maxx != 0) else np.array([0]) maxx = np.max(np.abs(audio)) return 20 * np.log10(maxx) if maxx != 0 else np.array([0])
Example #12
Source File: run_audio_attack.py From Black-Box-Audio with MIT License | 5 votes |
def get_new_pop(elite_pop, elite_pop_scores, pop_size): scores_logits = np.exp(elite_pop_scores - elite_pop_scores.max()) elite_pop_probs = scores_logits / scores_logits.sum() cand1 = elite_pop[np.random.choice(len(elite_pop), p=elite_pop_probs, size=pop_size)] cand2 = elite_pop[np.random.choice(len(elite_pop), p=elite_pop_probs, size=pop_size)] mask = np.random.rand(pop_size, elite_pop.shape[1]) < 0.5 next_pop = mask * cand1 + (1 - mask) * cand2 return next_pop
Example #13
Source File: rba.py From libTLDA with MIT License | 5 votes |
def posterior(self, psi): """ Class-posterior estimation. Parameters ---------- psi : array weighted data-classifier output (N samples by K classes) Returns ------- pyx : array class-posterior estimation (N samples by K classes) """ # Data shape N, K = psi.shape # Preallocate array pyx = np.zeros((N, K)) # Subtract maximum value for numerical stability psi = (psi.T - np.max(psi, axis=1).T).T # Loop over classes for k in range(K): # Estimate posterior p^(Y=y | x_i) pyx[:, k] = np.exp(psi[:, k]) / np.sum(np.exp(psi), axis=1) return pyx
Example #14
Source File: rba.py From libTLDA with MIT License | 5 votes |
def predict(self, Z): """ Make predictions on new dataset. Parameters ---------- Z : array new data set (M samples by D features) Returns ------- preds : array label predictions (M samples by 1) """ # Data shape M, D = Z.shape # If classifier is trained, check for same dimensionality if self.is_trained: if not self.train_data_dim == D: raise ValueError('''Test data is of different dimensionality than training data.''') # Compute posteriors post = self.predict_proba(Z) # Predictions through max-posteriors preds = np.argmax(post, axis=1) # Map predictions back to original labels return self.classes[preds]
Example #15
Source File: dkt.py From dkt with MIT License | 5 votes |
def pad_sequences(sequences, maxlen=None, dim=1, dtype='int32', padding='pre', truncating='pre', value=0.): ''' Override keras method to allow multiple feature dimensions. @dim: input feature dimension (number of features per timestep) ''' lengths = [len(s) for s in sequences] nb_samples = len(sequences) if maxlen is None: maxlen = np.max(lengths) x = (np.ones((nb_samples, maxlen, dim)) * value).astype(dtype) for idx, s in enumerate(sequences): if truncating == 'pre': trunc = s[-maxlen:] elif truncating == 'post': trunc = s[:maxlen] else: raise ValueError("Truncating type '%s' not understood" % padding) if padding == 'post': x[idx, :len(trunc)] = trunc elif padding == 'pre': x[idx, -len(trunc):] = trunc else: raise ValueError("Padding type '%s' not understood" % padding) return x
Example #16
Source File: plotting.py From cat-bbs with MIT License | 5 votes |
def get_max_x(self): return max([group.get_max_x() for group in self.line_groups.itervalues()])
Example #17
Source File: plotting.py From cat-bbs with MIT License | 5 votes |
def get_max_x(self): return max([max(line.xs) if len(line.xs) > 0 else 0 for line in self.lines.itervalues()])
Example #18
Source File: plotting.py From cat-bbs with MIT License | 5 votes |
def __init__(self, titles, increasing, save_to_fp): assert len(titles) == len(increasing) n_plots = len(titles) self.titles = titles self.increasing = dict([(title, incr) for title, incr in zip(titles, increasing)]) self.colors = ["red", "blue", "cyan", "magenta", "orange", "black"] self.nb_points_max = 500 self.save_to_fp = save_to_fp self.start_batch_idx = 0 self.autolimit_y = False self.autolimit_y_multiplier = 5 #self.fig, self.axes = plt.subplots(nrows=2, ncols=2, figsize=(20, 20)) nrows = max(1, int(math.sqrt(n_plots))) ncols = int(math.ceil(n_plots / nrows)) width = ncols * 10 height = nrows * 10 self.fig, self.axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=(width, height)) if nrows == 1 and ncols == 1: self.axes = [self.axes] else: self.axes = self.axes.flat title_to_ax = dict() for idx, (title, ax) in enumerate(zip(self.titles, self.axes)): title_to_ax[title] = ax self.title_to_ax = title_to_ax self.fig.tight_layout() self.fig.subplots_adjust(left=0.05)
Example #19
Source File: plotting.py From cat-bbs with MIT License | 5 votes |
def _line_to_xy(self, line_x, line_y, limit_y_min=None, limit_y_max=None): point_every = max(1, int(len(line_x) / self.nb_points_max)) points_x = [] points_y = [] curr_sum = 0 counter = 0 last_idx = len(line_x) - 1 for i in range(len(line_x)): batch_idx = line_x[i] if batch_idx > self.start_batch_idx: curr_sum += line_y[i] counter += 1 if counter >= point_every or i == last_idx: points_x.append(batch_idx) y = curr_sum / counter if limit_y_min is not None and limit_y_max is not None: y = np.clip(y, limit_y_min, limit_y_max) elif limit_y_min is not None: y = max(y, limit_y_min) elif limit_y_max is not None: y = min(y, limit_y_max) points_y.append(y) counter = 0 curr_sum = 0 return points_x, points_y
Example #20
Source File: vertcoord.py From aospy with Apache License 2.0 | 5 votes |
def to_pascal(arr, is_dp=False): """Force data with units either hPa or Pa to be in Pa.""" threshold = 400 if is_dp else 1200 if np.max(np.abs(arr)) < threshold: warn_msg = "Conversion applied: hPa -> Pa to array: {}".format(arr) logging.debug(warn_msg) return arr*100. return arr
Example #21
Source File: vertcoord.py From aospy with Apache License 2.0 | 5 votes |
def to_hpa(arr): """Convert pressure array from Pa to hPa (if needed).""" if np.max(np.abs(arr)) > 1200.: warn_msg = "Conversion applied: Pa -> hPa to array: {}".format(arr) logging.debug(warn_msg) return arr / 100. return arr
Example #22
Source File: var.py From aospy with Apache License 2.0 | 5 votes |
def mask_unphysical(self, data): """Mask data array where values are outside physically valid range.""" if not self.valid_range: return data else: return np.ma.masked_outside(data, np.min(self.valid_range), np.max(self.valid_range))
Example #23
Source File: gui.py From RF-Monitor with GNU General Public License v2.0 | 5 votes |
def __on_scan_data(self, event): levels = numpy.log10(event['l']) levels *= 10 self._levels = levels noise = numpy.percentile(levels, self._toolbar.get_dynamic_percentile()) updated = False for monitor in self._monitors: freq = monitor.get_frequency() if monitor.get_enabled(): monitor.set_noise(noise) index = numpy.where(freq == event['f'])[0] signal = monitor.set_level(levels[index][0], event['timestamp'], self._location) if signal is not None: updated = True if signal.end is not None: recording = format_recording(freq, signal) if self._settings.get_push_enable(): self._push.send(self._settings.get_push_uri(), recording) if self._server is not None: self._server.send(recording) if updated: if self._isSaved: self._isSaved = False self.__set_title() self.__set_timeline() self.__set_spectrum(noise) self._rssi.set_noise(numpy.mean(levels)) self._rssi.set_level(numpy.max(levels))
Example #24
Source File: blob.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 5 votes |
def im_list_to_blob(ims): """Convert a list of images into a network input. Assumes images are already prepared (means subtracted, BGR order, ...). """ max_shape = np.array([im.shape for im in ims]).max(axis=0) num_images = len(ims) blob = np.zeros((num_images, max_shape[0], max_shape[1], 3), dtype=np.float32) for i in range(num_images): im = ims[i] blob[i, 0:im.shape[0], 0:im.shape[1], :] = im return blob
Example #25
Source File: blob.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 5 votes |
def prep_im_for_blob(im, pixel_means, target_size, max_size): """Mean subtract and scale an image for use in a blob.""" im = im.astype(np.float32, copy=False) im -= pixel_means im_shape = im.shape im_size_min = np.min(im_shape[0:2]) im_size_max = np.max(im_shape[0:2]) im_scale = float(target_size) / float(im_size_min) # Prevent the biggest axis from being more than MAX_SIZE if np.round(im_scale * im_size_max) > max_size: im_scale = float(max_size) / float(im_size_max) im = cv2.resize(im, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR) return im, im_scale
Example #26
Source File: test.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 5 votes |
def _get_image_blob(im): """Converts an image into a network input. Arguments: im (ndarray): a color image in BGR order Returns: blob (ndarray): a data blob holding an image pyramid im_scale_factors (list): list of image scales (relative to im) used in the image pyramid """ im_orig = im.astype(np.float32, copy=True) im_orig -= cfg.PIXEL_MEANS im_shape = im_orig.shape im_size_min = np.min(im_shape[0:2]) im_size_max = np.max(im_shape[0:2]) processed_ims = [] im_scale_factors = [] for target_size in cfg.TEST.SCALES: im_scale = float(target_size) / float(im_size_min) # Prevent the biggest axis from being more than MAX_SIZE if np.round(im_scale * im_size_max) > cfg.TEST.MAX_SIZE: im_scale = float(cfg.TEST.MAX_SIZE) / float(im_size_max) im = cv2.resize(im_orig, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR) im_scale_factors.append(im_scale) processed_ims.append(im) # Create a blob to hold the input images blob = im_list_to_blob(processed_ims) return blob, np.array(im_scale_factors)
Example #27
Source File: test_train.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 5 votes |
def _get_image_blob(im): """Converts an image into a network input. Arguments: im (ndarray): a color image in BGR order Returns: blob (ndarray): a data blob holding an image pyramid im_scale_factors (list): list of image scales (relative to im) used in the image pyramid """ im_orig = im.astype(np.float32, copy=True) im_orig -= cfg.PIXEL_MEANS im_shape = im_orig.shape im_size_min = np.min(im_shape[0:2]) im_size_max = np.max(im_shape[0:2]) processed_ims = [] im_scale_factors = [] for target_size in cfg.TEST.SCALES: im_scale = float(target_size) / float(im_size_min) # Prevent the biggest axis from being more than MAX_SIZE if np.round(im_scale * im_size_max) > cfg.TEST.MAX_SIZE: im_scale = float(cfg.TEST.MAX_SIZE) / float(im_size_max) im = cv2.resize(im_orig, None, None, fx=im_scale, fy=im_scale, interpolation=cv2.INTER_LINEAR) im_scale_factors.append(im_scale) processed_ims.append(im) # Create a blob to hold the input images blob = im_list_to_blob(processed_ims) return blob, np.array(im_scale_factors)
Example #28
Source File: voc_eval.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 5 votes |
def voc_ap(rec, prec, use_07_metric=False): """ ap = voc_ap(rec, prec, [use_07_metric]) Compute VOC AP given precision and recall. If use_07_metric is true, uses the VOC 07 11 point method (default:False). """ if use_07_metric: # 11 point metric ap = 0. for t in np.arange(0., 1.1, 0.1): if np.sum(rec >= t) == 0: p = 0 else: p = np.max(prec[rec >= t]) ap = ap + p / 11. else: # correct AP calculation # first append sentinel values at the end mrec = np.concatenate(([0.], rec, [1.])) mpre = np.concatenate(([0.], prec, [0.])) # compute the precision envelope for i in range(mpre.size - 1, 0, -1): mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i]) # to calculate area under PR curve, look for points # where X axis (recall) changes value i = np.where(mrec[1:] != mrec[:-1])[0] # and sum (\Delta recall) * prec ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1]) return ap
Example #29
Source File: coco.py From Collaborative-Learning-for-Weakly-Supervised-Object-Detection with MIT License | 5 votes |
def _print_detection_eval_metrics(self, coco_eval): IoU_lo_thresh = 0.5 IoU_hi_thresh = 0.95 def _get_thr_ind(coco_eval, thr): ind = np.where((coco_eval.params.iouThrs > thr - 1e-5) & (coco_eval.params.iouThrs < thr + 1e-5))[0][0] iou_thr = coco_eval.params.iouThrs[ind] assert np.isclose(iou_thr, thr) return ind ind_lo = _get_thr_ind(coco_eval, IoU_lo_thresh) ind_hi = _get_thr_ind(coco_eval, IoU_hi_thresh) # precision has dims (iou, recall, cls, area range, max dets) # area range index 0: all area ranges # max dets index 2: 100 per image precision = \ coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, :, 0, 2] ap_default = np.mean(precision[precision > -1]) print(('~~~~ Mean and per-category AP @ IoU=[{:.2f},{:.2f}] ' '~~~~').format(IoU_lo_thresh, IoU_hi_thresh)) print('{:.1f}'.format(100 * ap_default)) for cls_ind, cls in enumerate(self.classes): if cls == '__background__': continue # minus 1 because of __background__ precision = coco_eval.eval['precision'][ind_lo:(ind_hi + 1), :, cls_ind - 1, 0, 2] ap = np.mean(precision[precision > -1]) print('{:.1f}'.format(100 * ap)) print('~~~~ Summary metrics ~~~~') coco_eval.summarize()
Example #30
Source File: cgp_config.py From cgp-cnn with MIT License | 5 votes |
def __init__(self, rows=30, cols=40, level_back=40, min_active_num=8, max_active_num=50): # network configurations depending on the problem self.input_num = 1 self.func_type = ['ConvBlock32_3', 'ConvBlock32_5', 'ConvBlock64_3', 'ConvBlock64_5', 'ConvBlock128_3', 'ConvBlock128_5', 'pool_max', 'pool_ave', 'concat', 'sum'] self.func_in_num = [1, 1, 1, 1, 1, 1, 1, 1, 2, 2] self.out_num = 1 self.out_type = ['full'] self.out_in_num = [1] # CGP network configuration self.rows = rows self.cols = cols self.node_num = rows * cols self.level_back = level_back self.min_active_num = min_active_num self.max_active_num = max_active_num self.func_type_num = len(self.func_type) self.out_type_num = len(self.out_type) self.max_in_num = np.max([np.max(self.func_in_num), np.max(self.out_in_num)])