我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用numpy.amin()。
def min_side(_, pos): """ Given an object pixels' positions, return the minimum side length of its bounding box :param _: pixel values (unused) :param pos: pixel position (1-D) :return: minimum bounding box side length """ xs = np.array([i / SSIZE for i in pos]) ys = np.array([i % SSIZE for i in pos]) minx = np.amin(xs) miny = np.amin(ys) maxx = np.amax(xs) maxy = np.amax(ys) ct1 = compute_line(np.array([minx, miny]), np.array([minx, maxy])) ct2 = compute_line(np.array([minx, miny]), np.array([maxx, miny])) return min(ct1, ct2)
def generate_patch_probs(path, patch_locations, patch_size, im_size): x, y, z = patch_locations seg = nib.load(glob.glob(os.path.join(path, '*_seg.nii.gz'))[0]).get_data().astype(np.float32) p = [] for i in range(len(x)): for j in range(len(y)): for k in range(len(z)): patch = seg[int(x[i] - patch_size / 2) : int(x[i] + patch_size / 2), int(y[j] - patch_size / 2) : int(y[j] + patch_size / 2), int(z[k] - patch_size / 2) : int(z[k] + patch_size / 2)] patch = (patch > 0).astype(np.float32) percent = np.sum(patch) / (patch_size * patch_size * patch_size) p.append((1 - np.abs(percent - 0.5)) * percent) p = np.asarray(p, dtype=np.float32) p[p == 0] = np.amin(p[np.nonzero(p)]) p = p / np.sum(p) return p
def view_trigger_snippets_bis(trigger_snippets, elec_index, save=None): fig = pylab.figure() ax = fig.add_subplot(1, 1, 1) for n in xrange(0, trigger_snippets.shape[2]): y = trigger_snippets[:, elec_index, n] x = numpy.arange(- (y.size - 1) / 2, (y.size - 1) / 2 + 1) b = 0.5 + 0.5 * numpy.random.rand() ax.plot(x, y, color=(0.0, 0.0, b), linestyle='solid') ax.grid(True) ax.set_xlim([numpy.amin(x), numpy.amax(x)]) ax.set_xlabel("time") ax.set_ylabel("amplitude") if save is None: pylab.show() else: pylab.savefig(save) pylab.close(fig) return
def to_rgb(img): """ Converts the given array into a RGB image. If the number of channels is not 3 the array is tiled such that it has 3 channels. Finally, the values are rescaled to [0,255) :param img: the array to convert [nx, ny, channels] :returns img: the rgb image [nx, ny, 3] """ img = np.atleast_3d(img) channels = img.shape[2] if channels < 3: img = np.tile(img, 3) img[np.isnan(img)] = 0 img -= np.amin(img) img /= np.amax(img) img *= 255 return img
def add(self, x, y = None): self.X = np.memmap( self.path+"/X.npy", self.X.dtype, shape = (self.nrows + x.shape[0] , x.shape[1]) ) self.X[self.nrows:self.nrows + x.shape[0],:] = x if y is not None: if x.shape != y.shape: raise "x and y should have the same shape" self.Y = np.memmap( self.path+"/Y.npy", self.Y.dtype, shape = (self.nrows + y.shape[0] , y.shape[1]) ) self.Y[self.nrows:self.nrows + y.shape[0],:] = y delta = x - self.running_mean n = self.X.shape[0] + np.arange(x.shape[0]) + 1 self.running_dev += np.sum(delta * (x - self.running_mean), 0) self.running_mean += np.sum(delta / n[:, np.newaxis], 0) self.running_max = np.amax(np.vstack((self.running_max, x)), 0) self.running_min = np.amin(np.vstack((self.running_min, x)), 0) self.nrows += x.shape[0]
def _make_grid(dim=(11,4)): """ this function generates the structure for an asymmetrical circle grid domain (0-1) """ x,y = range(dim[0]),range(dim[1]) p = np.array([[[s,i] for s in x] for i in y], dtype=np.float32) p[:,1::2,1] += 0.5 p = np.reshape(p, (-1,2), 'F') # scale height = 1 x_scale = 1./(np.amax(p[:,0])-np.amin(p[:,0])) y_scale = 1./(np.amax(p[:,1])-np.amin(p[:,1])) p *=x_scale,x_scale/.5 return p
def analytic_infinite_wire(obsloc,wireloc,orientation,I=1.): """ Compute the response of an infinite wire with orientation 'orientation' and current I at the obsvervation locations obsloc Output: B: magnetic field [Bx,By,Bz] """ n,d = obsloc.shape t,d = wireloc.shape d = np.sqrt(np.dot(obsloc**2.,np.ones([d,t]))+np.dot(np.ones([n,d]),(wireloc.T)**2.) - 2.*np.dot(obsloc,wireloc.T)) distr = np.amin(d, axis=1, keepdims = True) idxmind = d.argmin(axis=1) r = obsloc - wireloc[idxmind] orient = np.c_[[orientation for i in range(obsloc.shape[0])]] B = (mu_0*I)/(2*np.pi*(distr**2.))*np.cross(orientation,r) return B
def calculate_feature_statistics(feature_id): feature = Feature.objects.get(pk=feature_id) dataframe = _get_dataframe(feature.dataset.id) feature_col = dataframe[feature.name] feature.min = np.amin(feature_col).item() feature.max = np.amax(feature_col).item() feature.mean = np.mean(feature_col).item() feature.variance = np.nanvar(feature_col).item() unique_values = np.unique(feature_col) integer_check = (np.mod(unique_values, 1) == 0).all() feature.is_categorical = integer_check and (unique_values.size < 10) if feature.is_categorical: feature.categories = list(unique_values) feature.save(update_fields=['min', 'max', 'variance', 'mean', 'is_categorical', 'categories']) del unique_values, feature
def find_min_max(scp_file): minimum = float("inf") maximum = -float("inf") uid = 0 offset = 0 ark_dict, uid = read_mats(uid, offset, scp_file) while ark_dict: for key in ark_dict.keys(): mat_max = np.amax(ark_dict[key]) mat_min = np.amin(ark_dict[key]) if mat_max > maximum: maximum = mat_max if mat_min < minimum: minimum = mat_min ark_dict, uid = read_mats(uid, offset, scp_file) print("min:", minimum, "max:", maximum) return minimum, maximum
def _gini(self, array): """Calculate the Gini coefficient of a numpy array.""" # https://github.com/oliviaguest/gini # based on bottom eq: # http://www.statsdirect.com/help/generatedimages/equations/equation154.svg # from: # http://www.statsdirect.com/help/default.htm#nonparametric_methods/gini.htm # All values are treated equally, arrays must be 1d: array = array.flatten() if np.amin(array) < 0: # Values cannot be negative: array -= np.amin(array) # Values cannot be 0: array += 0.0000001 # Values must be sorted: array = np.sort(array) # Index per array element: index = np.arange(1,array.shape[0]+1) # Number of array elements: n = array.shape[0] # Gini coefficient: return ((np.sum((2 * index - n - 1) * array)) / (n * np.sum(array)))
def displayDataset(self, dataset): eps = 0.00001 linewidth = dataset.linewidth if np.var(dataset.values) < eps: linewidth += 2 mean = np.mean(dataset.values) x = np.arange(0, 1, 0.1) x = np.sort(np.append(x, [mean, mean-eps, mean+eps])) density = [1 if v == mean else 0 for v in x] else: self.kde.fit(np.asarray([[x] for x in dataset.values])) ## Computes the x axis x_max = np.amax(dataset.values) x_min = np.amin(dataset.values) delta = x_max - x_min density_delta = 1.1 * delta x = np.arange(x_min, x_max, density_delta / self.num_points) x_density = [[y] for y in x] ## kde.score_samples returns the 'log' of the density log_density = self.kde.score_samples(x_density).tolist() density = map(math.exp, log_density) self.ax.plot(x, density, label = dataset.label, color = dataset.color, linewidth = linewidth, linestyle = dataset.linestyle)
def display(self, output_filename): fig, (ax) = plt.subplots(1, 1) data = [d.values for d in self.datasets] labels = [d.label for d in self.datasets] bp = ax.boxplot(data, labels = labels, notch = 0, sym = '+', vert = '1', whis = 1.5) plt.setp(bp['boxes'], color='black') plt.setp(bp['whiskers'], color='black') plt.setp(bp['fliers'], color='black', marker='+') for i in range(len(self.datasets)): box = bp['boxes'][i] box_x = [] box_y = [] for j in range(5): box_x.append(box.get_xdata()[j]) box_y.append(box.get_ydata()[j]) box_coords = list(zip(box_x, box_y)) box_polygon = Polygon(box_coords, facecolor = self.datasets[i].color) ax.add_patch(box_polygon) if self.title is not None: ax.set_title(self.title) x_min = np.amin([np.amin(d.values) for d in self.datasets]) x_max = np.amax([np.amax(d.values) for d in self.datasets]) ax.set_ylim(x_min - 0.05*(x_max - x_min), x_max + 0.05*(x_max - x_min)) fig.savefig(output_filename) plt.close(fig)
def build_img_pair(img_batch): input_cast = img_batch[:,:,:,0:6].astype(dtype = np.float32) input_min = np.amin(input_cast, axis=(1,2,3)) input_max = np.amax(input_cast, axis=(1,2,3)) for i in range(3): input_min = np.expand_dims(input_min, i+1) input_max = np.expand_dims(input_max, i+1) input_norm = (input_cast - input_min) / (input_max - input_min) gt_cast = img_batch[:,:,:,6].astype(dtype = np.float32) gt_cast = np.expand_dims(gt_cast, 3) gt_min = np.amin(gt_cast, axis=(1,2,3)) gt_max = np.amax(gt_cast, axis=(1,2,3)) for i in range(3): gt_min = np.expand_dims(gt_min, i+1) gt_max = np.expand_dims(gt_max, i+1) gt_norm = (gt_cast - gt_min) / (gt_max - gt_min) return input_norm, gt_norm
def gini(array): """Calculate the Gini coefficient of a numpy array.""" # based on bottom eq: # http://www.statsdirect.com/help/generatedimages/equations/equation154.svg # from: # http://www.statsdirect.com/help/default.htm#nonparametric_methods/gini.htm # All values are treated equally, arrays must be 1d: array = array.flatten() if np.amin(array) < 0: # Values cannot be negative: array -= np.amin(array) # Values cannot be 0: array += 0.0000001 # Values must be sorted: array = np.sort(array) # Index per array element: index = np.arange(1,array.shape[0]+1) # Number of array elements: n = array.shape[0] # Gini coefficient: return ((np.sum((2 * index - n - 1) * array)) / (n * np.sum(array)))
def Get_Batch_Chrominance(): ''''Convert every image in the batch to LAB Colorspace and normalize each value of it between [0,1] Return: AbColores_values array [batch_size,2224,224,2] 0-> A value, 1-> B value color ''' global AbColores_values global ColorImages_Batch AbColores_values = np.empty((Batch_size,224,224,2),"float32") for indx in range(Batch_size): lab = color.rgb2lab(ColorImages_Batch[indx]) Min_valueA = np.amin(lab[:,:,1]) Max_valueA = np.amax(lab[:,:,1]) Min_valueB = np.amin(lab[:,:,2]) Max_valueB = np.amax(lab[:,:,2]) AbColores_values[indx,:,:,0] = Normalize(lab[:,:,1],-128,127) AbColores_values[indx,:,:,1] = Normalize(lab[:,:,2],-128,127)
def match_set_with_pts(db_set_feats, query_set_feats, dist_type, pt_set_dist_mode): print('start matching sets using points...') if query_set_feats is None: query_set_feats = db_set_feats dist_mat = np.empty( (len(query_set_feats), len(db_set_feats)), dtype=np.float) for i in range(len(query_set_feats)): for j in range(len(db_set_feats)): if dist_type == DistType.Hamming: tmp_dist_mat = scipy.spatial.distance.cdist(query_set_feats[i], db_set_feats[j], 'hamming') if dist_type == DistType.L2: tmp_dist_mat = scipy.spatial.distance.cdist( query_set_feats[i], db_set_feats[j], 'euclidean') if pt_set_dist_mode == PtSetDist.Min: dist_mat[i, j] = np.amin(tmp_dist_mat) if pt_set_dist_mode == PtSetDist.Avg: dist_mat[i, j] = np.mean(tmp_dist_mat) if pt_set_dist_mode == PtSetDist.MeanMin: dist_mat[i, j] = np.mean(np.amin(tmp_dist_mat, axis=1)) return dist_mat
def __init__(self, data, leafsize=10): """Construct a kd-tree. Parameters: =========== data : array-like, shape (n,k) The data points to be indexed. This array is not copied, and so modifying this data will result in bogus results. leafsize : positive integer The number of points at which the algorithm switches over to brute-force. """ self.data = np.asarray(data) self.n, self.m = np.shape(self.data) self.leafsize = int(leafsize) if self.leafsize<1: raise ValueError("leafsize must be at least 1") self.maxes = np.amax(self.data,axis=0) self.mins = np.amin(self.data,axis=0) self.tree = self.__build(np.arange(self.n), self.maxes, self.mins)
def get_classification(self, idx): """Docs""" img_rows = self.params.get('img_rows', self.Sxx.shape[0]) img_cols = self.params.get('img_cols', 1) if self.Sxx is None or self.active_song.classification is None: raise TypeError('No active song from which to get data') if np.amax(idx) > self.Sxx.shape[1]: raise IndexError('Data index of sample out of bounds, only {0} ' 'samples in the dataset'.format(self.Sxx.shape[1] - img_cols)) if np.amin(idx) < 0: raise IndexError('Data index of sample out of bounds, ' 'negative index requested') # index out the data classification = self.active_song.classification[idx] return classification
def standard_resize(image, max_side): if image is None: return None, None, None original_h, original_w, _ = image.shape if all(side < max_side for side in [original_h, original_w]): return image, original_h, original_w aspect_ratio = float(np.amax((original_w, original_h)) / float(np.amin((original_h, original_w)))) if original_w >= original_h: new_w = max_side new_h = max_side / aspect_ratio else: new_h = max_side new_w = max_side / aspect_ratio new_h = int(new_h) new_w = int(new_w) resized_image = cv2.resize(image, (new_w, new_h)) return resized_image, new_w, new_h
def update_time_to_recover_map(self): max_distance = 30 self.recover_map = numpy.zeros((max_distance + 1, self.width, self.height)) self.recover_map_smooth = numpy.zeros((max_distance + 1, self.width, self.height)) self.recover_map[0] = numpy.divide(self.strength_map, numpy.maximum(self.production_map, 0.001)) self.recover_map[0] = numpy.multiply(self.recover_map[0], 1 - (self.is_owner_map[self.game_map.my_id] + self.is_enemy_map)) self.recover_map[0] += (self.is_owner_map[self.game_map.my_id] + self.is_enemy_map) * 999 distance = 1 while distance <= max_distance: dir_map = numpy.zeros((4, self.width, self.height)) dir_map[0] = roll_xy(self.recover_map[distance - 1], 0, 1) dir_map[1] = roll_xy(self.recover_map[distance - 1], 0, -1) dir_map[2] = roll_xy(self.recover_map[distance - 1], 1, 0) dir_map[3] = roll_xy(self.recover_map[distance - 1], -1, 0) self.recover_map[distance] = numpy.add(self.recover_map[distance - 1], numpy.amin(dir_map, 0)) distance += 1 for d in range(2, max_distance): self.recover_map[d] = self.recover_map[d] / d self.recover_map_smooth[d] = spread_n(self.recover_map[d], 4)
def update_recover_map(self): max_distance = 50 self.recover_map = numpy.zeros((max_distance + 1, self.width, self.height)) self.recover_map[0] = numpy.divide(self.strength_map, numpy.maximum(self.production_map, 0.01)) self.recover_map[0] = numpy.multiply(self.recover_map[0], self.is_neutral_map) self.recover_map[0] += (self.is_owned_map + self.is_enemy_map) * 999 for distance in range(1, max_distance + 1): dir_map = numpy.zeros((4, self.width, self.height)) dir_map[0] = roll_xy(self.recover_map[distance - 1], 0, 1) dir_map[1] = roll_xy(self.recover_map[distance - 1], 0, -1) dir_map[2] = roll_xy(self.recover_map[distance - 1], 1, 0) dir_map[3] = roll_xy(self.recover_map[distance - 1], -1, 0) self.recover_map[distance] = numpy.add(self.recover_map[distance - 1], numpy.amin(dir_map, 0)) for d in range(2, max_distance + 1): self.recover_map[d] = self.recover_map[d] / d
def diagonal(_, pos): """ Given an object pixels' positions, return the diagonal length of its bound box :param _: pixel values (unused) :param pos: pixel position (1-D) :return: diagonal of bounding box """ xs = np.array([i / SSIZE for i in pos]) ys = np.array([i % SSIZE for i in pos]) minx = np.amin(xs) miny = np.amin(ys) maxx = np.amax(xs) maxy = np.amax(ys) return compute_line(np.array([minx, miny]), np.array([maxx, maxy]))
def binarization (array): ''' Takes a binary-class datafile and turn the max value (positive class) into 1 and the min into 0''' array = np.array(array, dtype=float) # conversion needed to use np.inf after if len(np.unique(array)) > 2: raise ValueError ("The argument must be a binary-class datafile. {} classes detected".format(len(np.unique(array)))) # manipulation which aims at avoid error in data with for example classes '1' and '2'. array[array == np.amax(array)] = np.inf array[array == np.amin(array)] = 0 array[array == np.inf] = 1 return np.array(array, dtype=int)
def bench_on(runner, sym, Ns, trials, dtype=None): global args, kernel, out, mkl_layer prepare = globals().get("prepare_"+sym, prepare_default) kernel = globals().get("kernel_"+sym, None) if not kernel: kernel = getattr(np.linalg, sym) out_lvl = runner.__doc__.split('.')[0].strip() func_s = kernel.__doc__.split('.')[0].strip() log.debug('Preparing input data for %s (%s).. ' % (sym, func_s)) args = [prepare(int(i)) for i in Ns] it = range(len(Ns)) # pprint(Ns) out = np.empty(shape=(len(Ns), trials)) b = body(trials) tic, toc = (0, 0) log.debug('Warming up %s (%s).. ' % (sym, func_s)) runner(range(1000), empty_work) kernel(*args[0]) runner(range(1000), empty_work) log.debug('Benchmarking %s on %s: ' % (func_s, out_lvl)) gc_old = gc.isenabled() # gc.disable() tic = time.time() runner(it, b) toc = time.time() - tic if gc_old: gc.enable() if 'reused_pool' in globals(): del globals()['reused_pool'] #calculate average time and min time and also keep track of outliers (max time in the loop) min_time = np.amin(out) max_time = np.amax(out) mean_time = np.mean(out) stdev_time = np.std(out) #print("Min = %.5f, Max = %.5f, Mean = %.5f, stdev = %.5f " % (min_time, max_time, mean_time, stdev_time)) #final_times = [min_time, max_time, mean_time, stdev_time] print('## %s: Outter:%s, Inner:%s, Wall seconds:%f\n' % (sym, out_lvl, mkl_layer, float(toc))) return out
def view_trigger_snippets(trigger_snippets, chans, save=None): # Create output directory if necessary. if os.path.exists(save): for f in os.listdir(save): p = os.path.join(save, f) os.remove(p) os.removedirs(save) os.makedirs(save) # Plot figures. fig = pylab.figure() for (c, chan) in enumerate(chans): ax = fig.add_subplot(1, 1, 1) for n in xrange(0, trigger_snippets.shape[2]): y = trigger_snippets[:, c, n] x = numpy.arange(- (y.size - 1) / 2, (y.size - 1) / 2 + 1) b = 0.5 + 0.5 * numpy.random.rand() ax.plot(x, y, color=(0.0, 0.0, b), linestyle='solid') y = numpy.mean(trigger_snippets[:, c, :], axis=1) x = numpy.arange(- (y.size - 1) / 2, (y.size - 1) / 2 + 1) ax.plot(x, y, color=(1.0, 0.0, 0.0), linestyle='solid') ax.grid(True) ax.set_xlim([numpy.amin(x), numpy.amax(x)]) ax.set_title("Channel %d" %chan) ax.set_xlabel("time") ax.set_ylabel("amplitude") if save is not None: # Save plot. filename = "channel-%d.png" %chan path = os.path.join(save, filename) pylab.savefig(path) fig.clf() if save is None: pylab.show() else: pylab.close(fig) return
def imgSeg_logo(approx, himg, wimg): w = np.amax(approx[:,:,0])-np.amin(approx[:,:,0]); h = np.amax(approx[:,:,1])-np.amin(approx[:,:,1]) if float(w)/float(h+0.001) > 4.5: h = int(float(w)/3.5) w0 = np.amin(approx[:,:,0]); h0 = np.amin(approx[:,:,1]) h1 = h0-int(3.5*h); h2 = h0; w1 = max(w0+w/2-int(0.5*(h2-h1)), 0); w2 = min(w0+w/2+int(0.5*(h2-h1)), wimg-1) return h1, h2, w1, w2
def imgSeg_rect(approx, himg, wimg): w = np.amax(approx[:,:,0])-np.amin(approx[:,:,0]); h = np.amax(approx[:,:,1])-np.amin(approx[:,:,1]) if float(w)/float(h+0.001) > 4.5: h = int(float(w)/3.5) w0 = np.amin(approx[:,:,0]); h0 = np.amin(approx[:,:,1]) h1 = h0-int(3.6*h); h2 = min(h0+int(3*h), himg-1) w1 = max(w0+w/2-(h2-h1), 0); w2 = min(w0+w/2+(h2-h1), wimg-1) return h1, h2, w1, w2
def collect_point_label(anno_path, out_filename, file_format='txt'): """ Convert original dataset files to data_label file (each line is XYZRGBL). We aggregated all the points from each instance in the room. Args: anno_path: path to annotations. e.g. Area_1/office_2/Annotations/ out_filename: path to save collected points and labels (each line is XYZRGBL) file_format: txt or numpy, determines what file format to save. Returns: None Note: the points are shifted before save, the most negative point is now at origin. """ points_list = [] for f in glob.glob(os.path.join(anno_path, '*.txt')): cls = os.path.basename(f).split('_')[0] if cls not in g_classes: # note: in some room there is 'staris' class.. cls = 'clutter' points = np.loadtxt(f) labels = np.ones((points.shape[0],1)) * g_class2label[cls] points_list.append(np.concatenate([points, labels], 1)) # Nx7 data_label = np.concatenate(points_list, 0) xyz_min = np.amin(data_label, axis=0)[0:3] data_label[:, 0:3] -= xyz_min if file_format=='txt': fout = open(out_filename, 'w') for i in range(data_label.shape[0]): fout.write('%f %f %f %d %d %d %d\n' % \ (data_label[i,0], data_label[i,1], data_label[i,2], data_label[i,3], data_label[i,4], data_label[i,5], data_label[i,6])) fout.close() elif file_format=='numpy': np.save(out_filename, data_label) else: print('ERROR!! Unknown file format: %s, please use txt or numpy.' % \ (file_format)) exit()
def collect_bounding_box(anno_path, out_filename): """ Compute bounding boxes from each instance in original dataset files on one room. **We assume the bbox is aligned with XYZ coordinate.** Args: anno_path: path to annotations. e.g. Area_1/office_2/Annotations/ out_filename: path to save instance bounding boxes for that room. each line is x1 y1 z1 x2 y2 z2 label, where (x1,y1,z1) is the point on the diagonal closer to origin Returns: None Note: room points are shifted, the most negative point is now at origin. """ bbox_label_list = [] for f in glob.glob(os.path.join(anno_path, '*.txt')): cls = os.path.basename(f).split('_')[0] if cls not in g_classes: # note: in some room there is 'staris' class.. cls = 'clutter' points = np.loadtxt(f) label = g_class2label[cls] # Compute tightest axis aligned bounding box xyz_min = np.amin(points[:, 0:3], axis=0) xyz_max = np.amax(points[:, 0:3], axis=0) ins_bbox_label = np.expand_dims( np.concatenate([xyz_min, xyz_max, np.array([label])], 0), 0) bbox_label_list.append(ins_bbox_label) bbox_label = np.concatenate(bbox_label_list, 0) room_xyz_min = np.amin(bbox_label[:, 0:3], axis=0) bbox_label[:, 0:3] -= room_xyz_min bbox_label[:, 3:6] -= room_xyz_min fout = open(out_filename, 'w') for i in range(bbox_label.shape[0]): fout.write('%f %f %f %f %f %f %d\n' % \ (bbox_label[i,0], bbox_label[i,1], bbox_label[i,2], bbox_label[i,3], bbox_label[i,4], bbox_label[i,5], bbox_label[i,6])) fout.close()
def read_testing_inputs(file, roi, im_size, output_path=None): f_h5 = h5py.File(file, 'r') if roi == -1: images = np.asarray(f_h5['resized_images'], dtype=np.float32) read_info = {} read_info['shape'] = np.asarray(f_h5['images'], dtype=np.float32).shape else: images = np.asarray(f_h5['images'], dtype=np.float32) output = h5py.File(os.path.join(output_path, 'All_' + os.path.basename(file)), 'r') predictions = np.asarray(output['predictions'], dtype=np.float32) output.close() # Select the roi roi_labels = (predictions == roi + 1).astype(np.float32) nz = np.nonzero(roi_labels) extract = [] for c in range(3): start = np.amin(nz[c]) end = np.amax(nz[c]) r = end - start extract.append((np.maximum(int(np.rint(start - r * 0.1)), 0), np.minimum(int(np.rint(end + r * 0.1)), images.shape[c]))) extract_images = images[extract[0][0] : extract[0][1], extract[1][0] : extract[1][1], extract[2][0] : extract[2][1]] read_info = {} read_info['shape'] = images.shape read_info['extract_shape'] = extract_images.shape read_info['extract'] = extract images = resize(extract_images, im_size, mode='constant') f_h5.close() return images, read_info
def normalize(im): mini = np.amin(im) maxi = np.amax(im) rng = maxi-mini im -= mini if rng > 0: im /= rng return im # ----- Type transformations --------------------------------------------------
def to_rgb(img): img = img.reshape(img.shape[0], img.shape[1]) img[np.isnan(img)] = 0 img -= np.amin(img) img /= np.amax(img) blue = np.clip(4*(0.75-img), 0, 1) red = np.clip(4*(img-0.25), 0, 1) green= np.clip(44*np.fabs(img-0.5)-1., 0, 1) rgb = np.stack((red, green, blue), axis=2) return rgb
def _process_data(self, data): # normalization data = np.clip(np.fabs(data), self.a_min, self.a_max) data -= np.amin(data) data /= np.amax(data) return data
def plot_prediction(x_test, y_test, prediction, save=False): import matplotlib import matplotlib.pyplot as plt test_size = x_test.shape[0] fig, ax = plt.subplots(test_size, 3, figsize=(12,12), sharey=True, sharex=True) x_test = crop_to_shape(x_test, prediction.shape) y_test = crop_to_shape(y_test, prediction.shape) ax = np.atleast_2d(ax) for i in range(test_size): cax = ax[i, 0].imshow(x_test[i]) plt.colorbar(cax, ax=ax[i,0]) cax = ax[i, 1].imshow(y_test[i, ..., 1]) plt.colorbar(cax, ax=ax[i,1]) pred = prediction[i, ..., 1] pred -= np.amin(pred) pred /= np.amax(pred) cax = ax[i, 2].imshow(pred) plt.colorbar(cax, ax=ax[i,2]) if i==0: ax[i, 0].set_title("x") ax[i, 1].set_title("y") ax[i, 2].set_title("pred") fig.tight_layout() if save: fig.savefig(save) else: fig.show() plt.show()
def computeallcpus(self): """ overall stats for all cores on the nodes """ ratios = numpy.empty((self._ncpumetrics, self._totalcores), numpy.double) coreindex = 0 for host, last in self._last.iteritems(): try: elapsed = last - self._first[host] if numpy.amin(numpy.sum(elapsed, 0)) < 1.0: # typically happens if the job was very short and the datapoints are too close together return {"error": ProcessingError.JOB_TOO_SHORT} coresperhost = len(last[0, :]) ratios[:, coreindex:(coreindex+coresperhost)] = 1.0 * elapsed / numpy.sum(elapsed, 0) coreindex += coresperhost except ValueError: # typically happens if the linux pmda crashes during the job return {"error": ProcessingError.INSUFFICIENT_DATA} results = {} for i, name in enumerate(self._outnames): results[name] = calculate_stats(ratios[i, :]) results['all'] = {"cnt": self._totalcores} return results
def plot_slice_3d_2_patch(ct_scan, mask, pid, img_dir=None, idx=None): # to convert cuda arrays to numpy array ct_scan = np.asarray(ct_scan) mask = np.asarray(mask) fig, ax = plt.subplots(2, 3, figsize=[8, 8]) fig.canvas.set_window_title(pid) if idx == None: #just plot in the middle of the cube in_sh = ct_scan.shape idx = [in_sh[0]/2,in_sh[1]/2,in_sh[2]/2] print np.amin(ct_scan), np.amax(ct_scan) print np.amin(mask), np.amax(mask) ax[0, 0].imshow(ct_scan[idx[0], :, :], cmap=plt.cm.gray) ax[0, 1].imshow(ct_scan[:, idx[1], :], cmap=plt.cm.gray) ax[0, 2].imshow(ct_scan[:, :, idx[2]], cmap=plt.cm.gray) ax[1, 0].imshow(mask[idx[0], :, :], cmap=plt.cm.gray) ax[1, 1].imshow(mask[:, idx[1], :], cmap=plt.cm.gray) ax[1, 2].imshow(mask[:, :, idx[2]], cmap=plt.cm.gray) if img_dir is not None: fig.savefig(img_dir + '/%s.png' % pid, bbox_inches='tight') else: plt.show() fig.clf() plt.close('all')
def calculate_likelihoods(ScoreList, NumInfoSites): num_lines = len(ScoreList) LikeLiHoods = [likeliTest(NumInfoSites[i], int(ScoreList[i])) for i in range(num_lines)] LikeLiHoods = np.array(LikeLiHoods).astype("float") TopHit = np.amin(LikeLiHoods) LikeLiHoodRatios = [LikeLiHoods[i]/TopHit for i in range(num_lines)] LikeLiHoodRatios = np.array(LikeLiHoodRatios).astype("float") return (LikeLiHoods, LikeLiHoodRatios)
def normalize(self): self.X = (self.X - np.amin(self.X, 0)) \ / (np.amax(self.X, 0) - np.amin(self.X, 0))
def normalize_points(self, x): return np.divide(x - np.amin(self.X, 0) , np.amax(self.X, 0) - np.amin(self.X, 0), np.empty_like(x))
def compute_patches_at_scale(self, scale_idx, scale, p_id_base): debug("Processing {} scale_idx:{} scale:{}".format(self.file_name, scale_idx, scale)) shape = np.array(self.shape) size = (np.amin(shape)-1) / scale num_samples = np.ceil( (shape-1) / size) num_samples = [int(n*2) if n > 1 else int(n) for n in num_samples] patches = [] sample_locs = [ self.sample_locs_for_dim( self.shape[0], size, num_samples[0]), self.sample_locs_for_dim( self.shape[1], size, num_samples[1])] p_id = p_id_base for sample_loc_0 in sample_locs[0]: for sample_loc_1 in sample_locs[1]: patch = ImagePatch( p_id, self, (sample_loc_0, sample_loc_1), size, scale) patch.label, patch.matched_roi_idx = \ self.get_label_for_patch(patch) if patch.label != PASCAL_VOC_BACKGROUND_CLASS: self.non_background_patches.append(patch) else: self.background_patches.append(patch) patches.append(patch) p_id += 1 debug("Compute {} patches".format(p_id-p_id_base)) return p_id # Sample the Pascal VOC dataset
def lower_bounds(self): return Vector2f(*numpy.amin(self.particles['position'], axis=0))
def test_all(self): a = np.random.normal(0, 1, (4, 5, 6, 7, 8)) for i in range(a.ndim): amin = a.min(i) aargmin = a.argmin(i) axes = list(range(a.ndim)) axes.remove(i) assert_(np.all(amin == aargmin.choose(*a.transpose(i,*axes))))
def test_scalar(self): assert_raises(ValueError, np.amax, 1, 1) assert_raises(ValueError, np.amin, 1, 1) assert_equal(np.amax(1, axis=0), 1) assert_equal(np.amin(1, axis=0), 1) assert_equal(np.amax(1, axis=None), 1) assert_equal(np.amin(1, axis=None), 1)
