def img_pre(path_to_images, save_dir=None, propotion=0.2, scale=400.0, greyscale=False): import menpo.io as mio from menpo.visualize import print_progress if save_dir is not None: mk_dir(save_dir, 0) for image_path in path_to_images: for img in print_progress(mio.import_images(image_path, verbose=True)): if greyscale: # convert to greyscale if img.n_channels == 3: img = img.as_greyscale() # crop to landmarks bounding box with an extra 20% padding re_img = img.crop_to_landmarks_proportion(propotion) # # rescale image if its diagonal is bigger than 400 pixels # d = img.diagonal() # if d > scale: # img = img.rescale(scale / d) # save enhanced image with lable img_suffix = img.path.suffix lb_suffix = '.pts' new_image_name = '%s' % img.path.name.split('.')[0] img_path = os.path.join(save_dir, new_image_name + img_suffix) lb_path = os.path.join(save_dir, new_image_name + lb_suffix) mio.export_image(re_img, img_path, overwrite=True) mio.export_landmark_file(re_img.landmarks['PTS'], lb_path, overwrite=True)
def process_video(file, dest): if is_video(file): create_dir(os.path.dirname(dest)) frames = mio.import_video(file, normalise=False) print('{} contains {} frames'.format(file, len(frames))) print('writing landmarks to {}...'.format(dest)) frames = frames.map(fit_image) with open(dest, 'w') as outputfile: outwriter = csv.writer(outputfile) try: for i, frame in enumerate(print_progress(frames)): if 'final_shape' not in frame.landmarks: warnings.warn('no faces detected in the frame {}, ' 'initializing landmarks to -1s...'.format(i)) # dlib does not fitting from previous initial shape so # leave entire row as -1s # initial_shape = frames[i - 1].landmarks['final_shape'].lms # fitting_result = fit_image.fitter.fit_from_shape(frame, initial_shape) # frame.landmarks['final_shape'] = fitting_result.final_shape landmarks = [-1] * 136 else: lmg = frame.landmarks['final_shape'] landmarks = lmg['all'].points.reshape((136,)).tolist() # reshape to 136 points fill_row(outwriter, i, landmarks) except Exception as e: warnings.warn('Runtime Error at frame {}'.format(i)) print('initializing landmarks to -1s...') fill_row(outwriter, i, [-1] * 136)
def process_video(file, dest): if is_video(file): create_dir(os.path.dirname(dest)) frames = mio.import_video(file, normalise=False) print('{} contains {} frames'.format(file, len(frames))) print('writing landmarks to {}...'.format(dest)) frames = frames.map(fit_image) with open(dest, 'w') as outputfile: outwriter = csv.writer(outputfile) try: for i, frame in enumerate(print_progress(frames)): if 'final_shape' not in frame.landmarks: warnings.warn( 'no faces detected in the frame {}, ' 'initializing landmarks to -1s...'.format(i)) # dlib does not fitting from previous initial shape so # leave entire row as -1s # initial_shape = frames[i - 1].landmarks['final_shape'].lms # fitting_result = fit_image.fitter.fit_from_shape(frame, initial_shape) # frame.landmarks['final_shape'] = fitting_result.final_shape landmarks = [-1] * 136 else: lmg = frame.landmarks['final_shape'] landmarks = lmg['all'].points.reshape( (136, )).tolist() # reshape to 136 points fill_row(outwriter, i, landmarks) except Exception as e: warnings.warn('Runtime Error at frame {}'.format(i)) print('initializing landmarks to -1s...') fill_row(outwriter, i, [-1] * 136)
def _import_glob_lazy_list(pattern, extension_map, max_assets=None, landmark_resolver=same_name, shuffle=False, as_generator=False, landmark_ext_map=None, landmark_attach_func=None, importer_kwargs=None, verbose=False): filepaths = list(glob_with_suffix(pattern, extension_map, sort=(not shuffle))) if shuffle: random.shuffle(filepaths) if max_assets: filepaths = filepaths[:max_assets] n_files = len(filepaths) if n_files == 0: raise ValueError('The glob {} yields no assets'.format(pattern)) lazy_list = LazyList([partial(_import, f, extension_map, landmark_resolver=landmark_resolver, landmark_ext_map=landmark_ext_map, landmark_attach_func=landmark_attach_func, importer_kwargs=importer_kwargs) for f in filepaths]) if verbose and as_generator: # wrap the generator with the progress reporter lazy_list = print_progress(lazy_list, prefix='Importing assets', n_items=n_files) elif verbose: print('Found {} assets, index the returned LazyList to import.'.format( n_files)) if as_generator: return (a for a in lazy_list) else: return lazy_list
def _import_glob_generator(pattern, extension_map, max_assets=None, landmark_resolver=same_name, shuffle=False, landmark_ext_map=None, importer_kwargs=None, verbose=False): filepaths = list( glob_with_suffix(pattern, extension_map, sort=(not shuffle))) if shuffle: random.shuffle(filepaths) if max_assets: filepaths = filepaths[:max_assets] n_files = len(filepaths) if n_files == 0: raise ValueError('The glob {} yields no assets'.format(pattern)) generator = _multi_import_generator(filepaths, extension_map, landmark_resolver=landmark_resolver, landmark_ext_map=landmark_ext_map, importer_kwargs=importer_kwargs) if verbose: # wrap the generator with the progress reporter generator = print_progress(generator, prefix='Importing assets', n_items=n_files) return generator
def generate_texture_model_from_image_3d_fits(images_and_fits, lambda_=0.01, n_components=0.99): """Build an ITW texture model from a list of images with associated dense 3D fits (one per image). Note that the input images should already have an image feature taken on them, and have all been resized to a consistent scale.""" f = open("/content/fk.txt", "w") f.write("shit") f.close() feat_img, fit_2d = images_and_fits[0] n_channels = feat_img.n_channels n_features = n_channels * fit_2d.n_points n_samples = len(images_and_fits) X = np.empty((n_samples, n_features), dtype=feat_img.pixels.dtype) M = np.empty_like(X, dtype=np.bool) proportion_masked = [] for i, (img, fit_2d) in enumerate( print_progress(images_and_fits, prefix='Extracting masks & features')): features, mask = extract_per_vertex_colour_with_occlusion(fit_2d, img) mask_repeated = np.repeat(mask.ravel(), n_channels) X[i] = features.ravel() M[i] = mask_repeated.ravel() proportion_masked.append(mask.sum() / mask.shape[0]) print('Performing R-PCA to complete missing textures') A, E = rpca_missing(X, M, verbose=True, lambda_=lambda_) print('R-PCA completed. Building PCA model of features on completed ' 'samples.') model = PCAVectorModel(A, inplace=True) print('Trimming the components to retain only what was required.') model.trim_components(n_components=n_components) return model, X, M
def generate_texture_model_from_itwmm(images, mm, id_ind, exp_ind, template_camera, p, qs, cs, lambda_=0.01, n_components=0.99): r"""Build a new texture model from an existing model and fitting information to a collection of images.""" n_channels = images[0].n_channels n_features = n_channels * mm.n_vertices n_samples = len(images) X = np.empty((n_samples, n_features), dtype=mm.texture_model.mean().dtype) M = np.empty_like(X, dtype=np.bool) proportion_masked = [] for i, (img, q, c) in enumerate(zip(print_progress(images, 'Extracting ' 'masks and ' 'features'), qs, cs)): i_in_img = instance_for_params(mm, id_ind, exp_ind, template_camera, p, q, c)['instance_in_img'] features, mask = extract_per_vertex_colour_with_occlusion(i_in_img, img) mask_repeated = np.repeat(mask.ravel(), n_channels) X[i] = features.ravel() M[i] = mask_repeated.ravel() proportion_masked.append(mask.sum() / mask.shape[0]) print('Extraction concluded. Self-occlusions on average masked {:.0%} of ' 'vertices.'.format(np.array(proportion_masked).mean())) print('Performing R-PCA to complete missing textures') A, E = rpca_missing(X, M, verbose=True, lambda_=lambda_) print('R-PCA completed. Building PCA model of features on completed ' 'samples.') model = PCAVectorModel(A, inplace=True) print('Trimming the components to retain only what was required.') model.trim_components(n_components=n_components) return model, X, M
def crop_face(): filePathSimple = NAME OF THE DIRECTOERY files = os.listdir(filePathSimple) filePath = THE PATH OF VIDEOs vids = import_videos(filePathSimple) detector = load_ffld2_frontal_face_detector() for utterance in print_progress(vids): # vids is a list with all videos fileName = files.pop(0) whole_path_of_video = filePath + "/" + fileName path_where_you_want_the_uncropped_images_to_be_stored = fileName + "_" + "uncropped" same_as_before_with_cropped_images = fileName + "_" + "cropped" # cropped_image_location = fileName + "_" + "cropped2" cropped_image_location = same_as_before_with_cropped_images print(fileName + " Cropping") fps_check = subprocess.check_output('ffprobe '+whole_path_of_video+' 2>&1 | grep fps',shell=True) fps_check = str(fps_check, 'utf-8') # fps = float(fps_check.split(' fps')[0].split(',')[-1][1:]) ## in our case we know fps=30 so you can just put this fps = 30 if not os.path.exists(path_where_you_want_the_uncropped_images_to_be_stored): os.makedirs(path_where_you_want_the_uncropped_images_to_be_stored) if not os.path.exists(same_as_before_with_cropped_images): os.makedirs(same_as_before_with_cropped_images) subprocess.call('ffmpeg -loglevel panic -i '+whole_path_of_video+' -vf fps='+ str(fps)+' '+path_where_you_want_the_uncropped_images_to_be_stored+'/%05d.jpg',shell=True) vv = mio.import_images(path_where_you_want_the_uncropped_images_to_be_stored+'/*.jpg') for cnt, im in enumerate(vv): name = '{0:05d}'.format(cnt+1) # i select to start the images names from 1 and not 0 lns = detector(im) if im.landmarks.n_groups == 0: # there are no detections continue if im.landmarks.n_groups == 1: im.constrain_landmarks_to_bounds() mio.export_image(im.crop_to_landmarks(), cropped_image_location+'/'+name+'.jpg', extension=None, overwrite=True) elif im.landmarks.n_groups > 1: for i in range(im.landmarks.n_groups): im.constrain_landmarks_to_bounds() mio.export_image(im.crop_to_landmarks(group='ffld2_'+str(i)), cropped_image_location+'/'+name+'_'+str(i)+'.jpg', extension=None, overwrite=True) subprocess.call("mv " + filePathSimple + "/" + fileName + " " + filePathSimple + "/Finished", shell=True) print(fileName + " Finished") print("All Done")
def densereg_face_iterator(istraining, db='helen'): database_path = Path( '/vol/atlas/homes/yz4009/databases/DenseReg/FaceRegDataset') / db landmarks_path = Path('/vol/atlas/databases') / db image_folder = 'Images_Resized' uv_folder = 'Labels_Resized' z_folder = 'Labels_Resized' if istraining == 1: database_path = database_path / 'trainset' landmarks_path = landmarks_path / 'trainset' elif istraining == 0: database_path = database_path / 'testset' landmarks_path = landmarks_path / 'testset' for pimg in print_progress( mio.import_images(database_path / image_folder / image_folder)): image_name = pimg.path.stem # load iuv data labels = sio.loadmat( str(database_path / uv_folder / uv_folder / ('%s.mat' % image_name))) iuv = Image( np.stack([(labels['LabelsH_resized'] >= 0).astype(np.float32), labels['LabelsH_resized'], labels['LabelsV_resized']]).clip(0, 1)) # load lms data try: orig_image = mio.import_image(landmarks_path / ('%s.jpg' % image_name)) except: orig_image = mio.import_image(landmarks_path / ('%s.png' % image_name)) orig_image = orig_image.resize(pimg.shape) pimg.landmarks['JOINT'] = orig_image.landmarks['PTS'] pimg_data = utils.crop_image_bounding_box( pimg, pimg.landmarks['JOINT'].bounding_box(), [384, 384], base=256) pimg = pimg_data[0] iuv_data = utils.crop_image_bounding_box( iuv, pimg.landmarks['JOINT'].bounding_box(), [384, 384], base=256) iuv = iuv_data[0] yield { 'image': pimg, 'iuv': iuv, 'visible_pts': np.array(list(range(68))), 'marked_index': np.array(list(range(68))) }
def save_images_to_dir(images, out_path, output_ext='.jpg'): from menpo.visualize import print_progress import menpo.io as mio if not out_path.exists(): out_path.mkdir() for k, im in enumerate( print_progress(images, prefix='Saving images to disk')): mio.export_image(im, out_path / '{}{}'.format(k, output_ext))
def PDMModel(path, max_components=None): training_shapes = [] for lg in print_progress( mio.import_landmark_files(path / '*.pts', verbose=True)): training_shapes.append(lg['all']) # train source PDM model shape_model = OrthoPDM(training_shapes, max_n_components=max_components) return shape_model, training_shapes
def main(directory): for portion in portion_to_id.keys(): print(portion) for subj_id in print_progress(portion_to_id[portion]): writer = tf.python_io.TFRecordWriter( (directory / 'tf_records' / portion / '{}.tfrecords'.format(subj_id)).as_posix()) serialize_sample(writer, subj_id)
def save_landmarks_to_dir(images, label, out_path, output_ext='.pts'): from menpo.visualize import print_progress import menpo.io as mio if not out_path.exists(): out_path.mkdir() for k, im in enumerate( print_progress(images, prefix='Saving landmarks to disk')): mio.export_landmark_file(im.landmarks[label], out_path / '{}{}'.format(k, output_ext))
def _create_dense_diagonal_precision( X, graph, n_features, n_features_per_vertex, dtype=np.float32, n_components=None, bias=0, return_covariances=False, verbose=False, ): # Initialize precision precision = np.zeros((n_features, n_features), dtype=dtype) if return_covariances: all_covariances = np.zeros( (graph.n_vertices, n_features_per_vertex, n_features_per_vertex), dtype=dtype, ) if verbose: print_dynamic("Allocated precision matrix of size {}".format( bytes_str(precision.nbytes))) # Print information if asked if verbose: vertices = print_progress( range(graph.n_vertices), n_items=graph.n_vertices, prefix="Precision per vertex", end_with_newline=False, ) else: vertices = range(graph.n_vertices) # Compute covariance matrix for each patch for v in vertices: # find indices in target precision matrix i_from = v * n_features_per_vertex i_to = (v + 1) * n_features_per_vertex # compute covariance covmat = np.cov(X[:, i_from:i_to], rowvar=0, bias=bias) if return_covariances: all_covariances[v] = covmat # invert it covmat = _covariance_matrix_inverse(covmat, n_components) # insert to precision matrix precision[i_from:i_to, i_from:i_to] = covmat # return covariances if return_covariances: return precision, all_covariances else: return precision
def _import_glob_lazy_list( pattern, extension_map, max_assets=None, landmark_resolver=same_name, shuffle=False, as_generator=False, landmark_ext_map=None, landmark_attach_func=None, importer_kwargs=None, verbose=False, ): filepaths = list(glob_with_suffix(pattern, extension_map, sort=(not shuffle))) if shuffle: random.shuffle(filepaths) if (max_assets is not None) and max_assets <= 0: raise ValueError( "Max elements should be positive" " ({} provided)".format(max_assets) ) elif max_assets: filepaths = filepaths[:max_assets] n_files = len(filepaths) if n_files == 0: raise ValueError("The glob {} yields no assets".format(pattern)) lazy_list = LazyList( [ partial( _import, f, extension_map, landmark_resolver=landmark_resolver, landmark_ext_map=landmark_ext_map, landmark_attach_func=landmark_attach_func, importer_kwargs=importer_kwargs, ) for f in filepaths ] ) if verbose and as_generator: # wrap the generator with the progress reporter lazy_list = print_progress( lazy_list, prefix="Importing assets", n_items=n_files ) elif verbose: print("Found {} assets, index the returned LazyList to import.".format(n_files)) if as_generator: return (a for a in lazy_list) else: return lazy_list
def get_images_from_image_folder(top_dir, ext='.jpg', restrict_to_landmarked=False): images = [] folders = glob.glob(os.path.join(top_dir, '*')) for label, folder in enumerate(tqdm(folders)): for img in print_progress( mio.import_images(os.path.join(folder, '*' + ext), verbose=False)): images.append(img) if restrict_to_landmarked: images = [image for image in images if 'PTS' in image.landmarks.keys()] return images
def PointDistributionModel(imgFolder): '''LOAD IMAGES''' path_to_lfpw = Path(imgFolder) training_shapes = [] for lg in print_progress( mio.import_landmark_files(path_to_lfpw / '*.pts', verbose=True)): training_shapes.append(lg['all']) '''TRAIN PDM MODEL''' shape_model = OrthoPDM(training_shapes, max_n_components=None) '''MODIFY PARAMETERS''' shape_model.n_active_components = 20 shape_model.n_active_components = 0.95 return shape_model
def pca_and_weights(meshes, retain_eig_cum_val=0.997, verbose=False): model = PCAModel(meshes, verbose=verbose) n_comps_retained = (model.eigenvalues_cumulative_ratio() < retain_eig_cum_val).sum() if verbose: print('\nRetaining {:.2%} of eigenvalues keeps {} components'.format( retain_eig_cum_val, n_comps_retained)) model.trim_components(retain_eig_cum_val) if verbose: meshes = print_progress(meshes, prefix='Calculating weights') weights = (np.vstack([model.project(m) for m in meshes]) / np.sqrt(model.eigenvalues)) return model, weights
def AAMModel(path, max_shape=None, max_appearance=None): training_images = [] for img in print_progress(mio.import_images(path, verbose=True)): labeller(img, 'PTS', face_ibug_68_to_face_ibug_68_trimesh) training_images.append(img) aam_model = HolisticAAM(training_images, group='face_ibug_68_trimesh', scales=(0.5, 1.0), holistic_features=fast_dsift, verbose=True, max_shape_components=max_shape, max_appearance_components=max_appearance) return aam_model, training_images
def pca(path_to_images, max_n_components=None): path_to_lfpw = Path(path_to_images) training_shapes = [] for lg in print_progress( mio.import_landmark_files(path_to_lfpw / '*.pts', verbose=True)): training_shapes.append(lg) # lg['all'] shape_model = OrthoPDM(training_shapes, max_n_components=max_n_components) print(shape_model) # visualize_pointclouds(training_shapes) # instance = shape_model.similarity_model.instance([100., -300., 0., 0.]) # instance.view(render_axes=False) return shape_model
def _increment_dense_diagonal_precision( X, mean_vector, covariances, n, graph, n_features, n_features_per_vertex, dtype=np.float32, n_components=None, bias=0, verbose=False, ): # Initialize precision precision = np.zeros((n_features, n_features), dtype=dtype) # Print information if asked if verbose: print_dynamic("Allocated precision matrix of size {}".format( bytes_str(precision.nbytes))) vertices = print_progress( range(graph.n_vertices), n_items=graph.n_vertices, prefix="Precision per vertex", end_with_newline=False, ) else: vertices = range(graph.n_vertices) # Compute covariance matrix for each patch for v in vertices: # find indices in target precision matrix i_from = v * n_features_per_vertex i_to = (v + 1) * n_features_per_vertex # get data edge_data = X[:, i_from:i_to] m = mean_vector[i_from:i_to] # increment _, covariances[v] = _increment_multivariate_gaussian_cov( edge_data, m, covariances[v], n, bias=bias) # invert it precision[i_from:i_to, i_from:i_to] = _covariance_matrix_inverse( covariances[v], n_components) # return covariances return precision, covariances
def get_shapes_from_image_folder(top_dir): """ simple helper function to extract saved .pts shapes from a torchvision-like image folder """ shapes = [] folders = glob.glob(os.path.join(top_dir, '*')) for label, folder in enumerate(tqdm(folders)): for lg in print_progress( mio.import_landmark_files(os.path.join(folder, '*.pts'), verbose=False)): try: shapes.append(lg['all']) except: shapes.append(lg['PTS']) return shapes
def transform_pts_temp_v2(image_dir_path, db_name, type_name='trainval'): import menpo.io as mio from menpo.visualize import print_progress img_dir, lb_dir = mk_img_lb_dir(db_name, type_name) impaths = filter(lambda x: 'pts' not in x, os.listdir(image_dir_path)) for imgpath in print_progress(impaths): imgpath = os.path.join(image_dir_path, imgpath) newpath = transform_impath(imgpath) img = mio.import_image(newpath) img_suffix = img.path.suffix lb_suffix = '.txt' image_name = img.path.name.split('.')[0] image_type = img.path._str.split('/')[11] image_name = '%s_%s' % (image_type, image_name) dataType = filter(lambda x: x == image_type, support_types)[0] if dataType == 'afw': image_name_list = image_name.split('_') image_name_list.pop(2) # remove index image_name = '_'.join(image_name_list) img_path = os.path.join(img_dir, image_name + img_suffix) lb_path = os.path.join(lb_dir, image_name + lb_suffix) # save image mio.export_image(img, img_path, overwrite=True) # save label lb = ['None'] * 166 kps = [str(kp) for kp in (img.landmarks['PTS'].as_vector() + 1)] xy = img.landmarks['PTS'].bounds()[0][::-1] zk = img.landmarks['PTS'].bounds()[1][::-1] x = str(xy[0]) y = str(xy[1]) w = str(zk[0] - xy[0]) h = str(zk[1] - xy[1]) box_hxyw = [h] + [x] + [y] + [w] kps_t = np.array(kps[0::2]) kps[0::2] = kps[1::2] kps[1::2] = kps_t lb[30:] = kps lb[25:29] = box_hxyw with open(lb_path, 'a') as f: f.write(' '.join(lb) + '\n') fi = FaceImage(img_path) # fi.vis() pass
def loadImages(self, path_to_training_images): training_images = [] for img in print_progress(mio.import_images(path_to_training_images, verbose=True)): # convert to greyscale if img.n_channels == 3: img = img.as_greyscale() # crop to landmarks bounding box with an extra 20% padding img = img.crop_to_landmarks_proportion(0.2) # rescale image if its diagonal is bigger than 400 pixels d = img.diagonal() if d > 400: img = img.rescale(400.0 / d) # define a TriMesh which will be useful for Piecewise Affine Warp of HolisticAAM labeller(img, 'PTS', face_ibug_68_to_face_ibug_68_trimesh) # append to list training_images.append(img) return training_images
def get_image_feature(img_path, img_list_path, model_path, epoch_num, gpu_id): img_list = open(img_list_path) embedding = Embedding(model_path, epoch_num, gpu_id) files = img_list.readlines() img_feats = [] faceness_scores = [] for img_index, each_line in enumerate(print_progress(files)): name_lmk_score = each_line.strip().split(' ') img_name = os.path.join(img_path, name_lmk_score[0]) img = cv2.imread(img_name) lmk = np.array([float(x) for x in name_lmk_score[1:-1]], dtype=np.float32) lmk = lmk.reshape( (5,2) ) img_feats.append(embedding.get(img,lmk)) faceness_scores.append(name_lmk_score[-1]) img_feats = np.array(img_feats).astype(np.float32) faceness_scores = np.array(faceness_scores).astype(np.float32) return img_feats, faceness_scores
def _create_dense_diagonal_precision(X, graph, n_features, n_features_per_vertex, dtype=np.float32, n_components=None, bias=0, return_covariances=False, verbose=False): # Initialize precision precision = np.zeros((n_features, n_features), dtype=dtype) if return_covariances: all_covariances = np.zeros( (graph.n_vertices, n_features_per_vertex, n_features_per_vertex), dtype=dtype) if verbose: print_dynamic('Allocated precision matrix of size {}'.format( bytes_str(precision.nbytes))) # Print information if asked if verbose: vertices = print_progress( range(graph.n_vertices), n_items=graph.n_vertices, prefix='Precision per vertex', end_with_newline=False) else: vertices = range(graph.n_vertices) # Compute covariance matrix for each patch for v in vertices: # find indices in target precision matrix i_from = v * n_features_per_vertex i_to = (v + 1) * n_features_per_vertex # compute covariance covmat = np.cov(X[:, i_from:i_to], rowvar=0, bias=bias) if return_covariances: all_covariances[v] = covmat # invert it covmat = _covariance_matrix_inverse(covmat, n_components) # insert to precision matrix precision[i_from:i_to, i_from:i_to] = covmat # return covariances if return_covariances: return precision, all_covariances else: return precision
def _compute_minimum_spanning_tree(shapes, root_vertex=0, prefix='', verbose=False): # initialize weights matrix n_vertices = shapes[0].n_points weights = np.zeros((n_vertices, n_vertices)) # print progress if requested range1 = range(n_vertices - 1) if verbose: range1 = print_progress( range1, end_with_newline=False, prefix='{}Deformation graph - Computing complete graph`s ' 'weights'.format(prefix)) # compute weights for i in range1: for j in range(i + 1, n_vertices, 1): # create data matrix of edge diffs_x = [s.points[i, 0] - s.points[j, 0] for s in shapes] diffs_y = [s.points[i, 1] - s.points[j, 1] for s in shapes] coords = np.array([diffs_x, diffs_y]) # compute mean and covariance m = np.mean(coords, axis=1) c = np.cov(coords) # get weight for im in range(len(shapes)): weights[i, j] += -np.log( multivariate_normal.pdf(coords[:, im], mean=m, cov=c)) weights[j, i] = weights[i, j] # create undirected graph complete_graph = UndirectedGraph(weights) if verbose: print_dynamic('{}Deformation graph - Minimum spanning graph ' 'computed.\n'.format(prefix)) # compute minimum spanning graph return complete_graph.minimum_spanning_tree(root_vertex)
def transform_pts(image_dir_path, db_name, type_name='trainval', box_c=0): import menpo.io as mio from menpo.visualize import print_progress img_dir, lb_dir = mk_img_lb_dir(db_name, type_name) for img in print_progress(mio.import_images(image_dir_path, verbose=True)): img_suffix = img.path.suffix lb_suffix = '.txt' image_name = img.path.name.split('.')[0] img_path = os.path.join(img_dir, image_name + img_suffix) lb_path = os.path.join(lb_dir, image_name + lb_suffix) # save image mio.export_image(img, img_path, overwrite=True) # save label lb = ['None'] * (30 + img.landmarks['PTS'].n_points * 2) kps = [str(kp) for kp in img.landmarks['PTS'].as_vector() + 1] if box_c: pickle_path = img.path._str.split('.')[0] + '.pkl' with open(pickle_path, 'rb') as f: box = pickle.load(f)['box'] x = str(box[0]) y = str(box[1]) w = str(box[2] - box[0]) h = str(box[3] - box[1]) box_hxyw = [h] + [x] + [y] + [w] else: xy = img.landmarks['PTS'].bounds()[0][::-1] + 1 zk = img.landmarks['PTS'].bounds()[1][::-1] + 1 x = str(xy[0]) y = str(xy[1]) w = str(zk[0] - xy[0]) h = str(zk[1] - xy[1]) box_hxyw = [h] + [x] + [y] + [w] kps_t = np.array(kps[0::2]) kps[0::2] = kps[1::2] kps[1::2] = kps_t lb[30:] = kps lb[25:29] = box_hxyw with open(lb_path, 'w') as f: f.write(' '.join(lb)) fi = FaceImage(img_path) # fi.vis() pass
def densereg_pose_iterator(): database_path = Path( '/vol/atlas/homes/yz4009/databases/DenseReg/IBUG_UP_DATA/') image_path = database_path / 'ProcessImagesStatic' iuv_path = database_path / 'Processed_correspondence_Static' iuv_map = sio.loadmat(str(database_path / 'GMDS.mat')) index_i, index_u, index_v = iuv_map['Index'].squeeze( ), iuv_map['Final_U'].squeeze(), iuv_map['Final_V'].squeeze() index_i = np.concatenate([[0], index_i]) index_u = np.concatenate([[0], index_u]) index_v = np.concatenate([[0], index_v]) for pimg in print_progress(mio.import_images(image_path)[1:]): image_name = pimg.path.stem bbox = PointCloud(pimg.bounds()).bounding_box() # load iuv data iuv_mat = sio.loadmat(str(iuv_path / ('%s.mat' % image_name)))['I_correspondence'] iuv = Image( np.stack([ index_i[iuv_mat], index_u[iuv_mat] * 255, index_v[iuv_mat] * 255 ]).astype(np.uint8)) # load lms data pimg_data = utils.crop_image_bounding_box(pimg, bbox, [384, 384], base=256) pimg = pimg_data[0] iuv_data = utils.crop_image_bounding_box(iuv, bbox, [384, 384], base=256, order=0) iuv = iuv_data[0] yield {'image': pimg, 'iuv': iuv}
def _compute_minimum_spanning_tree(shapes, root_vertex=0, prefix='', verbose=False): # initialize weights matrix n_vertices = shapes[0].n_points weights = np.zeros((n_vertices, n_vertices)) # print progress if requested range1 = range(n_vertices-1) if verbose: range1 = print_progress( range1, end_with_newline=False, prefix='{}Deformation graph - Computing complete graph`s ' 'weights'.format(prefix)) # compute weights for i in range1: for j in range(i+1, n_vertices, 1): # create data matrix of edge diffs_x = [s.points[i, 0] - s.points[j, 0] for s in shapes] diffs_y = [s.points[i, 1] - s.points[j, 1] for s in shapes] coords = np.array([diffs_x, diffs_y]) # compute mean and covariance m = np.mean(coords, axis=1) c = np.cov(coords) # get weight for im in range(len(shapes)): weights[i, j] += -np.log(multivariate_normal.pdf(coords[:, im], mean=m, cov=c)) weights[j, i] = weights[i, j] # create undirected graph complete_graph = UndirectedGraph(weights) if verbose: print_dynamic('{}Deformation graph - Minimum spanning graph ' 'computed.\n'.format(prefix)) # compute minimum spanning graph return complete_graph.minimum_spanning_tree(root_vertex)
def _import_glob_generator(pattern, extension_map, max_assets=None, landmark_resolver=same_name, landmark_ext_map=None, importer_kwargs=None, verbose=False): filepaths = list(glob_with_suffix(pattern, extension_map)) if max_assets: filepaths = filepaths[:max_assets] n_files = len(filepaths) if n_files == 0: raise ValueError('The glob {} yields no assets'.format(pattern)) generator = _multi_import_generator( filepaths, extension_map, landmark_resolver=landmark_resolver, landmark_ext_map=landmark_ext_map, importer_kwargs=importer_kwargs) if verbose: # wrap the generator with the progress reporter generator = print_progress(generator, prefix='Importing assets', n_items=n_files) return generator
def process_video(file, dest): if is_video(file): try: frames = mio.import_video(file, normalise=False) except IOError: warnings.warn('IO error reading video file {}, '.format(file) + 'the file may be corrupted or the video format is unsupported, skipping...') except ValueError as e: warnings.warn('Value Error reading video file {}, '.format(file) + e.message) return # check if directory is non empty if os.path.dirname(dest): create_dir(os.path.dirname(dest)) print('{} contains {} frames'.format(file, len(frames))) print('writing landmarks to {}...'.format(dest)) frames = frames.map(fit_image) with open(dest, 'w') as outputfile: outwriter = csv.writer(outputfile) try: for i, frame in enumerate(print_progress(frames)): if 'final_shape' not in frame.landmarks: warnings.warn('no faces detected in the frame {}, ' 'initializing landmarks to -1s...'.format(i)) # dlib does not fitting from previous initial shape so # leave entire row as -1s # initial_shape = frames[i - 1].landmarks['final_shape'].lms # fitting_result = fit_image.fitter.fit_from_shape(frame, initial_shape) # frame.landmarks['final_shape'] = fitting_result.final_shape landmarks = [-1] * NO_LANDMARKS*2 else: lmg = frame.landmarks['final_shape'] landmarks = lmg['all'].points.reshape((NO_LANDMARKS*2,)).tolist() # reshape to 136 points fill_row(outwriter, i, landmarks) except Exception as e: warnings.warn('Runtime Error at frame {}'.format(i)) print('initializing landmarks to -1s...') fill_row(outwriter, i, [-1] * NO_LANDMARKS*2)
def _increment_dense_diagonal_precision(X, mean_vector, covariances, n, graph, n_features, n_features_per_vertex, dtype=np.float32, n_components=None, bias=0, verbose=False): # Initialize precision precision = np.zeros((n_features, n_features), dtype=dtype) # Print information if asked if verbose: print_dynamic('Allocated precision matrix of size {}'.format( bytes_str(precision.nbytes))) vertices = print_progress( range(graph.n_vertices), n_items=graph.n_vertices, prefix='Precision per vertex', end_with_newline=False) else: vertices = range(graph.n_vertices) # Compute covariance matrix for each patch for v in vertices: # find indices in target precision matrix i_from = v * n_features_per_vertex i_to = (v + 1) * n_features_per_vertex # get data edge_data = X[:, i_from:i_to] m = mean_vector[i_from:i_to] # increment _, covariances[v] = _increment_multivariate_gaussian_cov( edge_data, m, covariances[v], n, bias=bias) # invert it precision[i_from:i_to, i_from:i_to] = _covariance_matrix_inverse( covariances[v], n_components) # return covariances return precision, covariances
def fit_pre(image_paths): import menpo.io as mio from menpowidgets import visualize_images from menpo.visualize import print_progress training_images = [] for image_path in image_paths: for img in print_progress(mio.import_images(image_path, verbose=True)): # convert to greyscale if img.n_channels == 3: img = img.as_greyscale() # crop to landmarks bounding box with an extra 20% padding img = img.crop_to_landmarks_proportion(0.2) # rescale image if its diagonal is bigger than 400 pixels d = img.diagonal() if d > 400: img = img.rescale(400.0 / d) # %matplotlib inline # visualize_images(img) # append to list training_images.append(img) return training_images
def ffmpeg_video_exporter(images, out_path, fps=30, codec='libx264', preset='medium', bitrate=None, verbose=False, **kwargs): r""" Uses subprocess PIPE to export the images using FFMPEG. There are is one important environment variable that can be set to alter the behaviour of this function: ================== ====================================== ENV Variable Definition ================== ====================================== MENPO_FFMPEG_CMD The path to the 'ffmpeg' executable. ================== ====================================== Parameters ---------- images : `list` of :map:`Image` List of Menpo images to export as a video. out_path : `Path` Path to save the video to. fps : `int`, optional The number of frames per second. codec : `str`, optional The video codec to use. Default 'libx264', which represents the widely available mpeg4. Except when saving .wmv files, then the defaults is 'msmpeg4' which is more commonly supported for windows. preset : `str`, optional The preset FFMPEG compression level. Please check out the documentation for more information: https://trac.ffmpeg.org/wiki/Encode/H.264#a2.Chooseapreset bitrate: `str`, optional The output video bitrate. verbose : `bool`, optional If ``True``, print a progress bar. **kwargs : `dict`, optional Extra parameters for advanced video exporting options. They are passed through directly to FFMPEG and they should. be organised in pairs of option/value in a dictionary. For instance: ``{'crf' : '0'} # equivalent to -crf 0 in ffmpeg.`` You can find further details in the documentation: https://ffmpeg.org/ffmpeg.html#Options """ # Some of the below was inspired by moviepy: # https://github.com/Zulko/moviepy/blob/master/moviepy/video/io/ffmpeg_writer.py # and is used under the terms of the MIT license which can be found at # https://github.com/Zulko/moviepy/blob/master/LICENCE.txt first_image = images[0] frame_shape = first_image.shape # If the first image is gray then all the images will be assumed to be # gray colour = 'rgb24' if images[0].n_channels == 3 else 'gray8' cmd = [_FFMPEG_CMD(), '-y', '-s', '{}x{}'.format(frame_shape[1], frame_shape[0]), '-r', str(fps), '-an', '-pix_fmt', colour, '-c:v', 'rawvideo', '-f', 'rawvideo', '-i', '-'] if codec: cmd.extend(['-vcodec', codec]) if preset: cmd.extend(['-preset', preset]) if bitrate: cmd.extend(['-b', str(bitrate)]) # add the optional kwargs for FFMPEG options. for key, value in kwargs.items(): cmd.extend(['-{}'.format(key), value]) cmd.append(str(out_path)) images = (print_progress(images, prefix='Exporting frames') if verbose else images) # Pipe stdout to DEVNULL to ignore it with _call_subprocess(sp.Popen(cmd, stdin=sp.PIPE, stderr=sp.PIPE, stdout=DEVNULL)) as pipe: for k, image in enumerate(images): try: if image.n_channels != 1 and colour == 'gray8': warnings.warn('Frame {} is non-greyscale and the initial ' 'frame was greyscale. This frame will be ' 'corrupted.'.format(k)) if image.shape != frame_shape: # Valid due to tuple/int warnings.warn('Frame {} is not the same shape as the ' 'initial frame and therefore the output ' 'may be corrupted.'.format(k)) i = image.pixels_with_channels_at_back(out_dtype=np.uint8) # Handle the case of a greyscale image amidst colour images if image.n_channels == 1 and colour == 'rgb24': # Repeat the channels axis 3 times i = i.reshape(i.shape + (1,)).repeat(3, axis=2) pipe.stdin.write(i.tostring()) except IOError: error = ('FFMPEG encountered the following error while ' 'writing the video:\n\n{}'.format( pipe.stderr.read().decode())) # Re-raise the error for a useful error message raise IOError(error)
import menpo import menpo.io as mio from menpodetect.ffld2 import load_ffld2_frontal_face_detector from os.path import join import subprocess detector = load_ffld2_frontal_face_detector() pb = ('/vol/bitbucket/ml9915/annotateVideos2/') pcrop = ('/vol/bitbucket/ml9915/ffcropped2/') puncrop = ('/vol/bitbucket/ml9915/ffuncropped2/') files = os.listdir(pb) files = filter(lambda x: not x.startswith("._"), files) for filename in print_progress(files): if (filename == '.DS_Store'): continue if not os.path.exists(pcrop + filename.split('.')[0] + '/'): os.makedirs(pcrop + filename.split('.')[0] + '/') if not os.path.exists(puncrop + filename.split('.')[0] + '/'): os.makedirs(puncrop + filename.split('.')[0] + '/') fps = 30 subprocess.call('ffmpeg -loglevel panic -i ' + pb + filename + ' -vf fps=' + str(fps) + ' ' + puncrop + filename.split('.')[0] + '/%05d.jpg', shell=True) vv = mio.import_images(puncrop + filename.split('.')[0] + '/*.jpg') # import the video
def as_matrix(vectorizables, length=None, return_template=False, verbose=False): r""" Create a matrix from a list/generator of :map:`Vectorizable` objects. All the objects in the list **must** be the same size when vectorized. Consider using a generator if the matrix you are creating is large and passing the length of the generator explicitly. Parameters ---------- vectorizables : `list` or generator if :map:`Vectorizable` objects A list or generator of objects that supports the vectorizable interface length : `int`, optional Length of the vectorizable list. Useful if you are passing a generator with a known length. verbose : `bool`, optional If ``True``, will print the progress of building the matrix. return_template : `bool`, optional If ``True``, will return the first element of the list/generator, which was used as the template. Useful if you need to map back from the matrix to a list of vectorizable objects. Returns ------- M : (length, n_features) `ndarray` Every row is an element of the list. template : :map:`Vectorizable`, optional If ``return_template == True``, will return the template used to build the matrix `M`. """ # get the first element as the template and use it to configure the # data matrix if length is None: # samples is a list length = len(vectorizables) template = vectorizables[0] vectorizables = vectorizables[1:] else: # samples is an iterator template = next(vectorizables) n_features = template.n_parameters template_vector = template.as_vector() data = np.zeros((length, n_features), dtype=template_vector.dtype) if verbose: print('Allocated data matrix of size {} ' '({} samples)'.format(bytes_str(data.nbytes), length)) # now we can fill in the first element from the template data[0] = template_vector del template_vector if verbose: vectorizables = print_progress(vectorizables, n_items=length, offset=1, prefix='Building data matrix') # 1-based as we have the template vector set already for i, sample in enumerate(vectorizables, 1): if i >= length: break data[i] = sample.as_vector() if return_template: return data, template else: return data
def as_matrix(vectorizables, length=None, return_template=False, verbose=False): r""" Create a matrix from a list/generator of :map:`Vectorizable` objects. All the objects in the list **must** be the same size when vectorized. Consider using a generator if the matrix you are creating is large and passing the length of the generator explicitly. Parameters ---------- vectorizables : `list` or generator if :map:`Vectorizable` objects A list or generator of objects that supports the vectorizable interface length : `int`, optional Length of the vectorizable list. Useful if you are passing a generator with a known length. verbose : `bool`, optional If ``True``, will print the progress of building the matrix. return_template : `bool`, optional If ``True``, will return the first element of the list/generator, which was used as the template. Useful if you need to map back from the matrix to a list of vectorizable objects. Returns ------- M : (length, n_features) `ndarray` Every row is an element of the list. template : :map:`Vectorizable`, optional If ``return_template == True``, will return the template used to build the matrix `M`. Raises ------ ValueError ``vectorizables`` terminates in fewer than ``length`` iterations """ # get the first element as the template and use it to configure the # data matrix if length is None: # samples is a list length = len(vectorizables) template = vectorizables[0] vectorizables = vectorizables[1:] else: # samples is an iterator template = next(vectorizables) n_features = template.n_parameters template_vector = template.as_vector() data = np.zeros((length, n_features), dtype=template_vector.dtype) if verbose: print( "Allocated data matrix of size {} " "({} samples)".format(bytes_str(data.nbytes), length) ) # now we can fill in the first element from the template data[0] = template_vector del template_vector # ensure we take at most the remaining length - 1 elements vectorizables = islice(vectorizables, length - 1) if verbose: vectorizables = print_progress( vectorizables, n_items=length, offset=1, prefix="Building data matrix", end_with_newline=False, ) # 1-based as we have the template vector set already i = 0 for i, sample in enumerate(vectorizables, 1): data[i] = sample.as_vector() # we have exhausted the iterable, but did we get enough items? if i != length - 1: # -1 raise ValueError( "Incomplete data matrix due to early iterator " "termination (expected {} items, got {})".format(length, i + 1) ) if return_template: return data, template else: return data
def as_matrix(vectorizables, length=None, return_template=False, verbose=False): r""" Create a matrix from a list/generator of :map:`Vectorizable` objects. All the objects in the list **must** be the same size when vectorized. Consider using a generator if the matrix you are creating is large and passing the length of the generator explicitly. Parameters ---------- vectorizables : `list` or generator if :map:`Vectorizable` objects A list or generator of objects that supports the vectorizable interface length : `int`, optional Length of the vectorizable list. Useful if you are passing a generator with a known length. verbose : `bool`, optional If ``True``, will print the progress of building the matrix. return_template : `bool`, optional If ``True``, will return the first element of the list/generator, which was used as the template. Useful if you need to map back from the matrix to a list of vectorizable objects. Returns ------- M : (length, n_features) `ndarray` Every row is an element of the list. template : :map:`Vectorizable`, optional If ``return_template == True``, will return the template used to build the matrix `M`. Raises ------ ValueError ``vectorizables`` terminates in fewer than ``length`` iterations """ # get the first element as the template and use it to configure the # data matrix if length is None: # samples is a list length = len(vectorizables) template = vectorizables[0] vectorizables = vectorizables[1:] else: # samples is an iterator template = next(vectorizables) n_features = template.n_parameters template_vector = template.as_vector() data = np.zeros((length, n_features), dtype=template_vector.dtype) if verbose: print('Allocated data matrix of size {} ' '({} samples)'.format(bytes_str(data.nbytes), length)) # now we can fill in the first element from the template data[0] = template_vector del template_vector # ensure we take at most the remaining length - 1 elements vectorizables = islice(vectorizables, length - 1) if verbose: vectorizables = print_progress(vectorizables, n_items=length, offset=1, prefix='Building data matrix') # 1-based as we have the template vector set already i = 0 for i, sample in enumerate(vectorizables, 1): data[i] = sample.as_vector() # we have exhausted the iterable, but did we get enough items? if i != length - 1: # -1 raise ValueError('Incomplete data matrix due to early iterator ' 'termination (expected {} items, got {})'.format( length, i + 1)) if return_template: return data, template else: return data
def _increment_sparse_precision(X, mean_vector, covariances, n, graph, n_features, n_features_per_vertex, mode='concatenation', dtype=np.float32, n_components=None, bias=0, verbose=False): # check mode argument if mode not in ['concatenation', 'subtraction']: raise ValueError("mode must be either ''concatenation'' " "or ''subtraction''; {} is given.".format(mode)) # Initialize arrays all_blocks = np.zeros((graph.n_edges * 4, n_features_per_vertex, n_features_per_vertex), dtype=dtype) columns = np.zeros(graph.n_edges * 4) rows = np.zeros(graph.n_edges * 4) # Print information if asked if verbose: edges = print_progress(range(graph.n_edges), n_items=graph.n_edges, prefix='Precision per edge', end_with_newline=False) else: edges = range(graph.n_edges) # Compute covariance matrix for each edge, invert it and store it count = -1 for e in edges: # edge vertices v1 = graph.edges[e, 0] v2 = graph.edges[e, 1] # find indices in data matrix v1_from = v1 * n_features_per_vertex v1_to = (v1 + 1) * n_features_per_vertex v2_from = v2 * n_features_per_vertex v2_to = (v2 + 1) * n_features_per_vertex # data concatenation if mode == 'concatenation': edge_data = X[:, list(range(v1_from, v1_to)) + list(range(v2_from, v2_to))] m = mean_vector[list(range(v1_from, v1_to)) + list(range(v2_from, v2_to))] else: edge_data = X[:, v1_from:v1_to] - X[:, v2_from:v2_to] m = mean_vector[v1_from:v1_to] - mean_vector[v2_from:v2_to] # increment _, covariances[e] = _increment_multivariate_gaussian_cov( edge_data, m, covariances[e], n, bias=bias) # invert it covmat = _covariance_matrix_inverse(covariances[e], n_components) # store it if mode == 'concatenation': # v1, v1 count += 1 all_blocks[count] = \ covmat[:n_features_per_vertex, :n_features_per_vertex] rows[count] = v1 columns[count] = v1 # v2, v2 count += 1 all_blocks[count] = \ covmat[n_features_per_vertex::, n_features_per_vertex::] rows[count] = v2 columns[count] = v2 # v1, v2 count += 1 all_blocks[count] = \ covmat[:n_features_per_vertex, n_features_per_vertex::] rows[count] = v1 columns[count] = v2 # v2, v1 count += 1 all_blocks[count] = \ covmat[n_features_per_vertex::, :n_features_per_vertex] rows[count] = v2 columns[count] = v1 else: # v1, v1 count += 1 all_blocks[count] = covmat rows[count] = v1 columns[count] = v1 # v2, v2 count += 1 all_blocks[count] = covmat rows[count] = v2 columns[count] = v2 # v1, v2 count += 1 all_blocks[count] = -covmat rows[count] = v1 columns[count] = v2 # v2, v1 count += 1 all_blocks[count] = -covmat rows[count] = v2 columns[count] = v1 # sort rows, columns and all_blocks rows_arg_sort = rows.argsort() columns = columns[rows_arg_sort] all_blocks = all_blocks[rows_arg_sort] rows = rows[rows_arg_sort] # create indptr n_rows = graph.n_vertices indptr = np.zeros(n_rows + 1) for i in range(n_rows): inds, = np.where(rows == i) if inds.size == 0: indptr[i + 1] = indptr[i] else: indptr[i] = inds[0] indptr[i + 1] = inds[-1] + 1 # create block sparse matrix return (bsr_matrix((all_blocks, columns, indptr), shape=(n_features, n_features), dtype=dtype), covariances)
def _increment_dense_precision(X, mean_vector, covariances, n, graph, n_features, n_features_per_vertex, mode='concatenation', dtype=np.float32, n_components=None, bias=0, verbose=False): # check mode argument if mode not in ['concatenation', 'subtraction']: raise ValueError("mode must be either ''concatenation'' " "or ''subtraction''; {} is given.".format(mode)) # Initialize precision precision = np.zeros((n_features, n_features), dtype=dtype) # Print information if asked if verbose: print_dynamic('Allocated precision matrix of size {}'.format( bytes_str(precision.nbytes))) edges = print_progress(range(graph.n_edges), n_items=graph.n_edges, prefix='Precision per edge', end_with_newline=False) else: edges = range(graph.n_edges) # Compute covariance matrix for each edge, invert it and store it for e in edges: # edge vertices v1 = graph.edges[e, 0] v2 = graph.edges[e, 1] # find indices in data matrix v1_from = v1 * n_features_per_vertex v1_to = (v1 + 1) * n_features_per_vertex v2_from = v2 * n_features_per_vertex v2_to = (v2 + 1) * n_features_per_vertex # data concatenation if mode == 'concatenation': edge_data = X[:, list(range(v1_from, v1_to)) + list(range(v2_from, v2_to))] m = mean_vector[list(range(v1_from, v1_to)) + list(range(v2_from, v2_to))] else: edge_data = X[:, v1_from:v1_to] - X[:, v2_from:v2_to] m = mean_vector[v1_from:v1_to] - mean_vector[v2_from:v2_to] # increment _, covariances[e] = _increment_multivariate_gaussian_cov( edge_data, m, covariances[e], n, bias=bias) # invert it covmat = _covariance_matrix_inverse(covariances[e], n_components) # store it if mode == 'concatenation': # v1, v1 precision[v1_from:v1_to, v1_from:v1_to] += \ covmat[:n_features_per_vertex, :n_features_per_vertex] # v2, v2 precision[v2_from:v2_to, v2_from:v2_to] += \ covmat[n_features_per_vertex::, n_features_per_vertex::] # v1, v2 precision[v1_from:v1_to, v2_from:v2_to] = \ covmat[:n_features_per_vertex, n_features_per_vertex::] # v2, v1 precision[v2_from:v2_to, v1_from:v1_to] = \ covmat[n_features_per_vertex::, :n_features_per_vertex] elif mode == 'subtraction': # v1, v2 precision[v1_from:v1_to, v2_from:v2_to] = -covmat # v2, v1 precision[v2_from:v2_to, v1_from:v1_to] = -covmat # v1, v1 precision[v1_from:v1_to, v1_from:v1_to] += covmat # v2, v2 precision[v2_from:v2_to, v2_from:v2_to] += covmat # return covariances return precision, covariances
def _increment_sparse_diagonal_precision(X, mean_vector, covariances, n, graph, n_features, n_features_per_vertex, dtype=np.float32, n_components=None, bias=0, verbose=False): # initialize covariances matrix all_blocks = np.zeros((graph.n_vertices, n_features_per_vertex, n_features_per_vertex), dtype=dtype) columns = np.zeros(graph.n_vertices) rows = np.zeros(graph.n_vertices) # Print information if asked if verbose: vertices = print_progress( range(graph.n_vertices), n_items=graph.n_vertices, prefix='Precision per vertex', end_with_newline=False) else: vertices = range(graph.n_vertices) # Compute covariance matrix for each patch for v in vertices: # find indices in target precision matrix i_from = v * n_features_per_vertex i_to = (v + 1) * n_features_per_vertex # get data edge_data = X[:, i_from:i_to] m = mean_vector[i_from:i_to] # increment _, covariances[v] = _increment_multivariate_gaussian_cov( edge_data, m, covariances[v], n, bias=bias) # invert it all_blocks[v] = _covariance_matrix_inverse(covariances[v], n_components) # store the inverse covariance and its locations rows[v] = v columns[v] = v # sort rows, columns and all_blocks rows_arg_sort = rows.argsort() columns = columns[rows_arg_sort] all_blocks = all_blocks[rows_arg_sort] rows = rows[rows_arg_sort] # create indptr n_rows = graph.n_vertices indptr = np.zeros(n_rows + 1) for i in range(n_rows): inds, = np.where(rows == i) if inds.size == 0: indptr[i + 1] = indptr[i] else: indptr[i] = inds[0] indptr[i + 1] = inds[-1] + 1 # create block sparse matrix return (bsr_matrix((all_blocks, columns, indptr), shape=(n_features, n_features), dtype=dtype), covariances)