def initial_models(self, nb_threads=1): # sort by show to minimize the reading of mfcc by the statServer self.diar.sort(['show']) # Compute statistics by segments self.stat_seg = StatServer(self.diar.id_map()) self.stat_seg.accumulate_stat(self.ubm, self.features_server) self.stat_speaker = self.stat_seg.adapt_mean_MAP_multisession(self.ubm)
def extract_ivectors_single(self, ubm, stat_server, uncertainty=False): """ Estimate i-vectors for a given StatServer using single process on a single node. :param stat_server: sufficient statistics stored in a StatServer :param ubm: Mixture object (the UBM) :param uncertainty: boolean, if True, return an additional matrix with uncertainty matrices (diagonal of the matrices) :return: a StatServer with i-vectors in the stat1 attribute and a matrix of uncertainty matrices (optional) """ assert(isinstance(stat_server, StatServer) and stat_server.validate()), \ "First argument must be a proper StatServer" assert (isinstance(ubm, Mixture) and ubm.validate()), "Second argument must be a proper Mixture" gmm_covariance = "diag" if ubm.invcov.ndim == 2 else "full" # Set useful variables tv_rank = self.F.shape[1] feature_size = ubm.mu.shape[1] nb_distrib = ubm.w.shape[0] # Whiten the statistics for diagonal or full models if gmm_covariance == "diag": stat_server.whiten_stat1(ubm.get_mean_super_vector(), 1. / ubm.get_invcov_super_vector()) elif gmm_covariance == "full": stat_server.whiten_stat1(ubm.get_mean_super_vector(), ubm.invchol) # Extract i-vectors iv_stat_server = StatServer() iv_stat_server.modelset = copy.deepcopy(stat_server.modelset) iv_stat_server.segset = copy.deepcopy(stat_server.segset) iv_stat_server.start = copy.deepcopy(stat_server.start) iv_stat_server.stop = copy.deepcopy(stat_server.stop) iv_stat_server.stat0 = numpy.ones((stat_server.modelset.shape[0], 1)) iv_stat_server.stat1 = numpy.ones( (stat_server.modelset.shape[0], tv_rank)) iv_sigma = numpy.ones((stat_server.modelset.shape[0], tv_rank)) # Replicate self.stat0 index_map = numpy.repeat(numpy.arange(nb_distrib), feature_size) for sess in tqdm(range(stat_server.segset.shape[0]), desc="Processing"): inv_lambda = scipy.linalg.inv( numpy.eye(tv_rank) + (self.F.T * stat_server.stat0[sess, index_map]).dot(self.F)) Aux = self.F.T.dot(stat_server.stat1[sess, :]) iv_stat_server.stat1[sess, :] = Aux.dot(inv_lambda) iv_sigma[sess, :] = numpy.diag(inv_lambda + numpy.outer( iv_stat_server.stat1[sess, :], iv_stat_server.stat1[sess, :])) if uncertainty: return iv_stat_server, iv_sigma else: return iv_stat_server
def _gaussian_backend_train(data, label): """ Take a StatServer of training examples as input output a StatServer mean for each class and a tied co-variance matrix """ train_ss = StatServer() train_ss.segset = label train_ss.modelset = label train_ss.stat1 = data train_ss.stat0 = numpy.ones((data.shape[0], 1)) train_ss.start = numpy.empty(data.shape[0], dtype="object") train_ss.stop = numpy.empty(data.shape[0], dtype="object") return gaussian_backend_train(train_ss)
def extract_ivectors(self, ubm, stat_server_filename, prefix='', batch_size=300, uncertainty=False, num_thread=1): """ Parallel extraction of i-vectors using multiprocessing module :param ubm: Mixture object (the UBM) :param stat_server_filename: name of the file from which the input StatServer is read :param prefix: prefix used to store the StatServer in its file :param batch_size: number of sessions to process in a batch :param uncertainty: a boolean, if True, return the diagonal of the uncertainty matrices :param num_thread: number of process to run in parallel :return: a StatServer with i-vectors in the stat1 attribute and a matrix of uncertainty matrices (optional) """ assert (isinstance(ubm, Mixture) and ubm.validate()), "Second argument must be a proper Mixture" tv_rank = self.F.shape[1] # Set useful variables with h5py.File(stat_server_filename, 'r') as fh: # open the first statserver to get size _, sv_size = fh[prefix + 'stat1'].shape nb_sessions = fh[prefix + "modelset"].shape[0] iv_server = StatServer() iv_server.modelset = fh.get(prefix + 'modelset').value iv_server.segset = fh.get(prefix + 'segset').value tmpstart = fh.get(prefix + "start").value tmpstop = fh.get(prefix + "stop").value iv_server.start = numpy.empty(fh[prefix + "start"].shape, '|O') iv_server.stop = numpy.empty(fh[prefix + "stop"].shape, '|O') iv_server.start[tmpstart != -1] = tmpstart[tmpstart != -1] iv_server.stop[tmpstop != -1] = tmpstop[tmpstop != -1] iv_server.stat0 = numpy.ones((nb_sessions, 1), dtype=STAT_TYPE) with warnings.catch_warnings(): iv_server.stat1 = serialize(numpy.zeros( (nb_sessions, tv_rank))) iv_sigma = serialize(numpy.zeros((nb_sessions, tv_rank))) nb_sessions = iv_server.modelset.shape[0] batch_nb = int(numpy.floor(nb_sessions / float(batch_size) + 0.999)) batch_indices = numpy.array_split(numpy.arange(nb_sessions), batch_nb) manager = multiprocessing.Manager() q = manager.Queue() pool = multiprocessing.Pool(num_thread + 2) # put listener to work first watcher = pool.apply_async(iv_collect, ((iv_server.stat1, iv_sigma), q)) # fire off workers jobs = [] # Load data per batch to reduce the memory footprint for batch_idx in batch_indices: # Create list of argument for a process arg = batch_idx, fh["stat0"][batch_idx, :], fh["stat1"][ batch_idx, :], ubm, self.F job = pool.apply_async(iv_extract_on_batch, (arg, q)) jobs.append(job) # collect results from the workers through the pool result queue for job in jobs: job.get() # now we are done, kill the listener q.put((None, None, None)) pool.close() iv_server.stat1, iv_sigma = watcher.get() if uncertainty: return iv_server, iv_sigma else: return iv_server
def extract_ivector(tv, stat_server_file_name, ubm, output_file_name, uncertainty=False, prefix=''): """ Estimate i-vectors for a given StatServer using multiple process on multiple nodes. :param comm: MPI.comm object defining the group of nodes to use :param stat_server_file_name: file name of the sufficient statistics StatServer HDF5 file :param ubm: Mixture object (the UBM) :param output_file_name: name of the file to save the i-vectors StatServer in HDF5 format :param uncertainty: boolean, if True, saves a matrix with uncertainty matrices (diagonal of the matrices) :param prefix: prefixe of the dataset to read from in HDF5 file """ assert (isinstance(ubm, Mixture) and ubm.validate()), "Second argument must be a proper Mixture" comm = MPI.COMM_WORLD comm.Barrier() gmm_covariance = "diag" if ubm.invcov.ndim == 2 else "full" # Set useful variables tv_rank = tv.F.shape[1] feature_size = ubm.mu.shape[1] nb_distrib = ubm.w.shape[0] # Get the number of sessions to process with h5py.File(stat_server_file_name, 'r') as fh: nb_sessions = fh["segset"].shape[0] # Work on each node with different data indices = numpy.array_split(numpy.arange(nb_sessions), comm.size, axis=0) sendcounts = numpy.array([idx.shape[0] * tv.F.shape[1] for idx in indices]) displacements = numpy.hstack((0, numpy.cumsum(sendcounts)[:-1])) stat_server = StatServer.read_subset(stat_server_file_name, indices[comm.rank]) # Whiten the statistics for diagonal or full models if gmm_covariance == "diag": stat_server.whiten_stat1(ubm.get_mean_super_vector(), 1. / ubm.get_invcov_super_vector()) elif gmm_covariance == "full": stat_server.whiten_stat1(ubm.get_mean_super_vector(), ubm.invchol) # Estimate i-vectors if comm.rank == 0: iv = numpy.zeros((nb_sessions, tv_rank)) iv_sigma = numpy.zeros((nb_sessions, tv_rank)) else: iv = None iv_sigma = None local_iv = numpy.zeros((stat_server.modelset.shape[0], tv_rank)) local_iv_sigma = numpy.ones((stat_server.modelset.shape[0], tv_rank)) # Replicate stat0 index_map = numpy.repeat(numpy.arange(nb_distrib), feature_size) for sess in range(stat_server.segset.shape[0]): inv_lambda = scipy.linalg.inv( numpy.eye(tv_rank) + (tv.F.T * stat_server.stat0[sess, index_map]).dot(tv.F)) Aux = tv.F.T.dot(stat_server.stat1[sess, :]) local_iv[sess, :] = Aux.dot(inv_lambda) local_iv_sigma[sess, :] = numpy.diag( inv_lambda + numpy.outer(local_iv[sess, :], local_iv[sess, :])) comm.Barrier() comm.Gatherv(local_iv, [iv, sendcounts, displacements, MPI.DOUBLE], root=0) comm.Gatherv(local_iv_sigma, [iv_sigma, sendcounts, displacements, MPI.DOUBLE], root=0) if comm.rank == 0: with h5py.File(stat_server_file_name, 'r') as fh: iv_stat_server = StatServer() iv_stat_server.modelset = fh.get(prefix + "modelset").value iv_stat_server.segset = fh.get(prefix + "segset").value # if running python 3, need a conversion to unicode if sys.version_info[0] == 3: iv_stat_server.modelset = iv_stat_server.modelset.astype( 'U', copy=False) iv_stat_server.segset = iv_stat_server.segset.astype( 'U', copy=False) tmpstart = fh.get(prefix + "start").value tmpstop = fh.get(prefix + "stop").value iv_stat_server.start = numpy.empty(fh[prefix + "start"].shape, '|O') iv_stat_server.stop = numpy.empty(fh[prefix + "stop"].shape, '|O') iv_stat_server.start[tmpstart != -1] = tmpstart[tmpstart != -1] iv_stat_server.stop[tmpstop != -1] = tmpstop[tmpstop != -1] iv_stat_server.stat0 = numpy.ones((nb_sessions, 1)) iv_stat_server.stat1 = iv iv_stat_server.write(output_file_name) if uncertainty: path = os.path.splitext(output_file_name) write_matrix_hdf5(iv_sigma, path[0] + "_uncertainty" + path[1])
def extract_parallel(args, fs_params): emb_a_size = 512 emb_b_size = 512 idmap = IdMap(args.idmap) x_server_1 = StatServer(idmap, 1, emb_a_size) x_server_2 = StatServer(idmap, 1, emb_b_size) x_server_3 = StatServer(idmap, 1, emb_b_size) x_server_4 = StatServer(idmap, 1, emb_b_size) x_server_5 = StatServer(idmap, 1, emb_b_size) x_server_6 = StatServer(idmap, 1, emb_b_size) x_server_1.stat0 = numpy.ones(x_server_1.stat0.shape) x_server_2.stat0 = numpy.ones(x_server_2.stat0.shape) x_server_3.stat0 = numpy.ones(x_server_3.stat0.shape) x_server_4.stat0 = numpy.ones(x_server_4.stat0.shape) x_server_5.stat0 = numpy.ones(x_server_5.stat0.shape) x_server_6.stat0 = numpy.ones(x_server_6.stat0.shape) # Split the indices mega_batch_size = idmap.leftids.shape[0] // args.num_processes logging.critical("Number of sessions to process: {}".format(idmap.leftids.shape[0])) segment_idx = [] for ii in range(args.num_processes): segment_idx.append( numpy.arange(ii * mega_batch_size, numpy.min([(ii + 1) * mega_batch_size, idmap.leftids.shape[0]]))) for idx, si in enumerate(segment_idx): logging.critical("Number of session on process {}: {}".format(idx, len(si))) # Extract x-vectors in parallel output_queue = mp.Queue() processes = [] for rank in range(args.num_processes): p = mp.Process(target=extract_idmap, args=(args, rank, segment_idx[rank], fs_params, args.idmap, output_queue) ) # We first train the model across `num_processes` processes p.start() processes.append(p) # Get the x-vectors and fill the StatServer for ii in range(args.num_processes): indices, seg_1, seg_2, seg_3, seg_4, seg_5, seg_6 = output_queue.get() x_server_1.stat1[indices, :] = seg_1 x_server_2.stat1[indices, :] = seg_2 x_server_3.stat1[indices, :] = seg_3 x_server_4.stat1[indices, :] = seg_4 x_server_5.stat1[indices, :] = seg_5 x_server_6.stat1[indices, :] = seg_6 for p in processes: p.join() print("Process parallel fini") return x_server_1, x_server_2, x_server_3, x_server_4, x_server_5, x_server_6