def vis(self): self.model.eval() gallery_path = data.testset.imgs query_path = data.queryset.imgs # Extract feature print('extract features, this may take a few minutes') #query_feature = extract_feature(model, tqdm([(torch.unsqueeze(data.query_image, 0), 1)])) query_feature = extract_feature(model, tqdm(data.query_loader)) gallery_feature = extract_feature(model, tqdm(data.test_loader)) print(query_feature.size()) for query_Index in range(query_feature.size()[0]): # sort images query_img_path = query_path[query_Index] query_feature_now = query_feature[query_Index].unsqueeze(1) print(query_feature_now.size()) #query_feature = query_feature.view(-1, 1) #print(query_feature.size()) score = torch.mm(gallery_feature, query_feature_now) score = score.squeeze(1).cpu() score = score.numpy() index = np.argsort(score) # from small to large index = index[::-1] # from large to small # # Remove junk images # junk_index = np.argwhere(gallery_label == -1) # mask = np.in1d(index, junk_index, invert=True) # index = index[mask] # Visualize the rank result fig = plt.figure(figsize=(16, 4)) ax = plt.subplot(1, 11, 1) ax.axis('off') plt.imshow(plt.imread(query_img_path)) ax.set_title('query') #print('Top 10 images are as follow:') for i in range(10): img_path = gallery_path[index[i]] #print(img_path) ax = plt.subplot(1, 11, i + 2) ax.axis('off') plt.imshow(plt.imread(img_path)) ax.set_title(img_path.split('/')[-1][:9]) fig.savefig( "/home/wangminjie/Desktop/wmj/projects/Part-reID_2/result/detect/{}.png" .format(query_img_path.split('/')[-1][:9])) print('result saved to show{}.png'.format( query_img_path.split('/')[-1][:9])) print("task end")
def run_HetGNN(model, hg, het_graph, config): # het_graph is used to sample neighbour hg = hg.to('cpu') category = config.category train_mask = hg.nodes[category].data.pop('train_mask') test_mask = hg.nodes[category].data.pop('test_mask') train_idx = th.nonzero(train_mask, as_tuple=False).squeeze() test_idx = th.nonzero(test_mask, as_tuple=False).squeeze() labels = hg.nodes[category].data.pop('label') emd = hg.nodes[category].data['dw_embedding'] train_batch = load_link_pred('./a_a_list_train.txt') test_batch = load_link_pred('./a_a_list_test.txt') # HetGNN Sampler batch_sampler = SkipGramBatchSampler(hg, config.batch_size, config.window_size) neighbor_sampler = NeighborSampler(het_graph, hg.ntypes, batch_sampler.num_nodes, config.device) collator = HetGNNCollator(neighbor_sampler, hg) dataloader = DataLoader(batch_sampler, collate_fn=collator.collate_train, num_workers=config.num_workers) opt = th.optim.Adam(model.parameters()) pred = ScorePredictor() dataloader_it = iter(dataloader) for i in range(config.max_epoch): model.train() for batch_id in tqdm.trange(config.batches_per_epoch): positive_graph, negative_graph, blocks = next(dataloader_it) blocks = [b.to(config.device) for b in blocks] positive_graph = positive_graph.to(config.device) negative_graph = negative_graph.to(config.device) # we need extract multi-feature input_features = extract_feature(blocks[0], hg.ntypes) x = model(blocks[0], input_features) loss = compute_loss(pred(positive_graph, x), pred(negative_graph, x)) opt.zero_grad() loss.backward() opt.step() print('Epoch {:05d} |Train - Loss: {:.4f}'.format(i, loss.item())) input_features = extract_feature(het_graph, hg.ntypes) x = model(het_graph, input_features) author_link_prediction(x['author'].to('cpu').detach(), train_batch, test_batch) micro_f1, macro_f1 = Hetgnn_evaluate( x[config.category].to('cpu').detach(), labels, train_idx, test_idx) print('<Classification> Micro-F1 = %.4f, Macro-F1 = %.4f' % (micro_f1, macro_f1)) pass
def test_feature_extraction(): print("Testing Feature Extraction with test file..") result = extract_feature(list_of_files[0]) if len(result) > 1: print("FEATURE EXTRACTION PASSED") else: print("FEATURE EXTRACTION FAILED") print("Testing Feature Extraction with empty input..") result = extract_feature("") if result == "File Doesn't Exist": print("FEATURE EXTRACTION PASSED") else: print("FEATURE EXTRACTION FAILED")
def evaluate(model): model.eval() with open(test_file, 'r') as file: lines = file.readlines() angles = [] start = time.time() with torch.no_grad(): for line in tqdm(lines): tokens = line.split() file0 = tokens[0] mel0 = extract_feature(input_file=file0, feature='fbank', dim=hp.n_mels, cmvn=True) mel0 = build_LFR_features(mel0, m=hp.LFR_m, n=hp.LFR_n) mel0 = torch.unsqueeze(torch.from_numpy(mel0), dim=0) mel0 = mel0.to(hp.device) with torch.no_grad(): output = model(mel0)[0] feature0 = output.cpu().numpy() file1 = tokens[1] mel1 = extract_feature(input_file=file1, feature='fbank', dim=hp.n_mels, cmvn=True) mel1 = build_LFR_features(mel1, m=hp.LFR_m, n=hp.LFR_n) mel1 = torch.unsqueeze(torch.from_numpy(mel1), dim=0) with torch.no_grad(): mel1 = mel1.to(hp.device) output = model(mel1)[0] feature1 = output.cpu().numpy() x0 = feature0 / np.linalg.norm(feature0) x1 = feature1 / np.linalg.norm(feature1) cosine = np.dot(x0, x1) theta = math.acos(cosine) theta = theta * 180 / math.pi is_same = tokens[2] angles.append('{} {}\n'.format(theta, is_same)) elapsed_time = time.time() - start print('elapsed time(sec) per audio: {}'.format(elapsed_time / (6000 * 2))) with open(angles_file, 'w') as file: file.writelines(angles)
def vis(self): self.model.eval() gallery_path = data.testset.imgs gallery_label = data.testset.ids # Extract feature print('extract features, this may take a few minutes') query_feature = extract_feature( model, tqdm([(torch.unsqueeze(data.query_image, 0), 1)])) gallery_feature = extract_feature(model, tqdm(data.test_loader)) # sort images query_feature = query_feature.view(-1, 1) score = torch.mm(gallery_feature, query_feature) score = score.squeeze(1).cpu() score = score.numpy() index = np.argsort(score) # from small to large index = index[::-1] # from large to small # # Remove junk images # junk_index = np.argwhere(gallery_label == -1) # mask = np.in1d(index, junk_index, invert=True) # index = index[mask] # Visualize the rank result fig = plt.figure(figsize=(16, 4)) ax = plt.subplot(1, 11, 1) ax.axis('off') plt.imshow(plt.imread(opt.query_image)) ax.set_title('query') print('Top 10 images are as follow:') for i in range(10): img_path = gallery_path[index[i]] print(img_path) ax = plt.subplot(1, 11, i + 2) ax.axis('off') plt.imshow(plt.imread(img_path)) ax.set_title(img_path.split('/')[-1][:9]) fig.savefig("show.png") print('result saved to show.png')
def choose_best_vec(): train_sets_names = ["A", "B", "C", "D"] print("Choosing best vectorization method:") clf = LinearDiscriminantAnalysis() best_score = 0 best_vec_method = "" for vec_method in train_sets_names: X_train, y_train, X_test, _ = training_data() X_train, X_test = extract_feature(X_train, X_test, vec_method) # Split Training set to predefined train and cross validation X_t, X_cv, y_t, y_cv, _ = split_data(X_train, y_train) model = clf.fit(X_t, y_t) y_pred = model.predict(X_cv) score = accuracy_score(y_cv, y_pred) print("Method:", vec_method, "cv accuracy:", score) if score > best_score: best_score = score best_vec_method = vec_method print("Best vectorization method:", best_vec_method, "with score of:", best_score) return best_vec_method
def get_feature(img): gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) # 反向二值化,将黑色的数字变为白色,白色背景变成黑色 retval, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY_INV | cv.THRESH_OTSU) # 定位到各个数字的RoI区域 contours, hierarchy = cv.findContours(binary, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE) rects = [] for c in contours: rect = cv.boundingRect(c) # print(rect) rects.append(rect) cv.rectangle(img, rect, (0, 0, 255), 1, 8) # 按左上角x坐标从小到大排列,如图像td1.png,从左到右排列,分别为1-9、0 rects = sorted(rects, key=lambda x: x[0], reverse=False) feature_list = [] for i, r in enumerate(rects): x, y, w, h = r roi = binary[y:y + h, x:x + w] feature = extract_feature(roi) feature_list.append(feature) # print(f"number {(i + 1) % 10} 's features: ", feature) return np.array(feature_list), np.array(rects) # (n, 40), (n, 4)
def predict(self, audio_path): feature = extract_feature(audio_path, **self.audio_config).reshape( (1, 1, self.input_length)) if self.classification: return self.int2emotions[self.model.predict_classes(feature)[0][0]] else: return self.model.predict(feature)[0][0][0]
def pre(self): json_file = 'results/result_' + time.strftime("%Y%m%d%H%M%S") + '.json' json_file_rk = 'results/result_' + time.strftime( "%Y%m%d%H%M%S") + '_rk.json' self.model.eval() t1 = time.time() print('extract features, this may take a few minutes') feats = extract_feature(self.model, tqdm(self.test_loader)) print('feats:', feats.shape) qf = feats[:self.num_query] gf = feats[self.num_query:] print('qf,gf:', qf.shape, gf.shape) m, n = qf.shape[0], gf.shape[0] distmat = torch.pow(qf, 2).sum(dim=1, keepdim=True).expand(m, n) + \ torch.pow(gf, 2).sum(dim=1, keepdim=True).expand(n, m).t() distmat.addmm_(1, -2, qf, gf.t()) distmat = distmat.cpu().numpy() self.writeResult(distmat, json_file) print('re_ranking ...') distmat_rk = reRanking(qf, gf, 7, 3, 0.85) self.writeResult(distmat_rk, json_file_rk) print('Time cost is: {:.2f} s'.format(time.time() - t1)) print('over!')
def gen_feat(opt, model_, data_loader, feat_path): opt.model_name = model_['model_name'] opt.model_path = os.path.expanduser(model_['model_path']) opt.weight = os.path.expanduser(model_['weight']) logger.debug(opt) model = build_model(opt, 2432) if torch.cuda.device_count() > 1: model = torch.nn.DataParallel(model) model = model.to("cuda") model.eval() with torch.no_grad(): feat = extract_feature(model, tqdm(data_loader)) print('feat:', feat.shape) # Save to Matlab for check feature = feat.numpy() result = {'test_f': feature} feat_dir, feat_file = os.path.split(feat_path) if not os.path.exists(feat_dir): os.makedirs(feat_dir, exist_ok=True) scipy.io.savemat(feat_path, result) return feature
def __getitem__(self, i): sample = self.samples[i] wave = sample['wave'] trn = sample['trn'] feature = extract_feature(wave) return feature, trn
def gen_feat(opt, model_, data): opt.model_name = model_['model_name'] opt.model_path = os.path.expanduser(model_['model_path']) opt.weight = model_['weight'] print(opt,'\n') if opt.model_name == 'se_resnext50': model = build_model(opt, 2432) # model.load_state_dict(torch.load(opt.weight)) model.load_param(opt.weight) else: # model = build_model(opt, 4950) model = build_model(opt, data.num_classes) model.load_state_dict(torch.load(opt.weight)['state_dict']) if torch.cuda.device_count() > 1: model = torch.nn.DataParallel(model) model = model.to("cuda") model.eval() with torch.no_grad(): feat = extract_feature(model, tqdm(data.test_loader)) logger.debug('feat: {}'.format(feat.shape)) # Save to Matlab for check feature = feat.numpy() result = {'test_f': feature} mat_dir, mat_file = os.path.split(model_['mat_path']) if not os.path.exists(mat_dir): os.makedirs(mat_dir, exist_ok=True) scipy.io.savemat(model_['mat_path'], result) return feature
def results(): """ This route is used to save the file, convert the audio to 16000hz monochannel, and predict the emotion using the saved binary model """ if not os.path.isdir("./audio"): os.mkdir("audio") if request.method == 'POST': try: f = request.files['file'] filename = secure_filename(f.filename) f.save(os.path.join(app.config["UPLOAD_FOLDER"], filename)) except: return render_template('main.html', value="") wav_file_pre = os.listdir("./audio")[0] wav_file_pre = f"{os.getcwd()}/audio/{wav_file_pre}" wav_file = convert(wav_file_pre) os.remove(wav_file_pre) model = pickle.load(open(f"{os.getcwd()}/model.model", "rb")) x_test =extract_feature(wav_file) y_pred=model.predict(np.array([x_test])) os.remove(wav_file) print(y_pred) return render_template('main.html', value=y_pred[0])
def test(self, use_cuda, use_fed=False): print("="*10) print("Start Testing!") print("="*10) print('We use the scale: %s' % self.multiple_scale) for dataset in self.data.datasets: # if self.use_clustering: if use_fed and not self.use_clustering: print("Using federated model") client_model = self.federated_model.eval() if use_cuda: client_model = self.federated_model.cuda() else: print("Using local model") client_model = self.clients[dataset].get_model().eval() # self.federated_model.eval() if use_cuda: client_model = client_model.cuda() # self.federated_model.cuda() # else: # self.federated_model = self.federated_model.eval() # if use_cuda: # self.federated_model = self.federated_model.cuda() with torch.no_grad(): gallery_feature = extract_feature(client_model, self.data.test_loaders[dataset]['gallery'], self.multiple_scale) query_feature = extract_feature(client_model, self.data.test_loaders[dataset]['query'], self.multiple_scale) result = { 'gallery_f': gallery_feature.numpy(), 'gallery_label': self.data.gallery_meta[dataset]['labels'], 'gallery_cam': self.data.gallery_meta[dataset]['cameras'], 'query_f': query_feature.numpy(), 'query_label': self.data.query_meta[dataset]['labels'], 'query_cam': self.data.query_meta[dataset]['cameras'] } print("====== before loading =======") # for i in result: # print(i, np.array(result[i]).shape, result[i][:3]) # file_path = os.path.join(self.project_dir, # 'model', # self.model_name, # 'pytorch_result_{}_{}.mat'.format(dataset, random.randint(0, 100000000))) # scipy.io.savemat(file_path, result) print(self.model_name) print(dataset) testing_model(result, dataset)
def predict(self, audio_path): """ given an `audio_path`, this method extracts the features and predicts the emotion """ feature = extract_feature(audio_path, **self.audio_config).reshape(1, -1) return self.model.predict(feature)[0]
def __getitem__(self, i): sample = self.samples[i] wave = sample['wave'] trn = sample['trn'] feature = extract_feature(input_file=wave, feature='fbank', dim=80, cmvn=True, delta=True, delta_delta=True) return feature, trn
def predict_proba(self, audio_path): """""" feature = extract_feature(audio_path, **self.audio_config).reshape(1, -1) proba = self.model.predict_proba(feature)[0] result = {} for emotion, prob in zip(self.emotions, proba): result[emotion] = prob return result
def predict_proba(self, audio_path): if self.classification: feature = extract_feature(audio_path, **self.audio_config).reshape((1, 1, self.input_length)) proba = self.model.predict(feature)[0][0] result = {} for prob, emotion in zip(proba, self.emotions): result[emotion] = prob return result else: raise NotImplementedError("Probability prediction doesn't make sense for regression")
def evaluate(self): self.model.eval() print('extract features, this may take a few minutes') qf = extract_feature(self.model, tqdm(self.query_loader)).numpy() gf = extract_feature(self.model, tqdm(self.test_loader)).numpy() # mqf = extract_feature(self.model, tqdm(self.query_loader)).numpy() def rank(dist): r = cmc(dist, self.queryset.ids, self.testset.ids, self.queryset.cameras, self.testset.cameras, separate_camera_set=False, single_gallery_shot=False, first_match_break=True) m_ap = mean_ap(dist, self.queryset.ids, self.testset.ids, self.queryset.cameras, self.testset.cameras) return r, m_ap # # ######################## re rank########################## # q_g_dist = np.dot(qf, np.transpose(gf)) # q_q_dist = np.dot(qf, np.transpose(qf)) # g_g_dist = np.dot(gf, np.transpose(gf)) # dist = re_ranking(q_g_dist, q_q_dist, g_g_dist) # # r, m_ap = rank(dist) # # print('[With Re-Ranking] mAP: {:.4f} rank1: {:.4f} rank3: {:.4f} rank5: {:.4f} rank10: {:.4f}' # .format(m_ap, r[0], r[2], r[4], r[9])) # # # #########################no re rank########################## dist = cdist(qf, gf) r, m_ap = rank(dist) index = np.argsort(dist, axis=1) # from small to large index = index[:, :100] + 1 file = opt.weight file = file.split('/model')[0] np.savetxt(os.path.join('weights',file, 'rank.txt'), index, delimiter=' ', fmt='%d') print('[Without Re-Ranking] mAP: {:.4f} rank1: {:.4f} rank3: {:.4f} rank5: {:.4f} rank10: {:.4f}' .format(m_ap, r[0], r[2], r[4], r[9]))
def evaluate(self): self.model.eval() print('extract features, this may take a few minutes') qf = extract_feature(self.model, tqdm(self.query_loader)).numpy() gf = extract_feature(self.model, tqdm(self.test_loader)).numpy() def rank(dist): r = cmc(dist, self.queryset.ids, self.testset.ids, self.queryset.cameras, self.testset.cameras, separate_camera_set=False, single_gallery_shot=False, first_match_break=True) m_ap = mean_ap(dist, self.queryset.ids, self.testset.ids, self.queryset.cameras, self.testset.cameras) return r, m_ap ######################### re rank########################## q_g_dist = np.dot(qf, np.transpose(gf)) q_q_dist = np.dot(qf, np.transpose(qf)) g_g_dist = np.dot(gf, np.transpose(gf)) dist = re_ranking(q_g_dist, q_q_dist, g_g_dist) r, m_ap = rank(dist) print( '[With Re-Ranking] mAP: {:.4f} rank1: {:.4f} rank3: {:.4f} rank5: {:.4f} rank10: {:.4f}' .format(m_ap, r[0], r[2], r[4], r[9])) #########################no re rank########################## dist = cdist(qf, gf) r, m_ap = rank(dist) print( '[Without Re-Ranking] mAP: {:.4f} rank1: {:.4f} rank3: {:.4f} rank5: {:.4f} rank10: {:.4f}' .format(m_ap, r[0], r[2], r[4], r[9]))
def __getitem__(self, i): sample = self.samples[i] wave = sample['audiopath'] label = sample['label'] feature = extract_feature(input_file=wave, feature='fbank', dim=hp.n_mels, cmvn=True) feature = build_LFR_features(feature, m=hp.LFR_m, n=hp.LFR_n) return feature, label
def test(self, use_cuda): print("=" * 10) print("Start Tesing!") print("=" * 10) print('We use the scale: %s' % self.multiple_scale) for dataset in self.data.datasets: self.federated_model = self.federated_model.eval() if use_cuda: self.federated_model = self.federated_model.cuda() with torch.no_grad(): gallery_feature = extract_feature( self.federated_model, self.data.test_loaders[dataset]['gallery'], self.multiple_scale) query_feature = extract_feature( self.federated_model, self.data.test_loaders[dataset]['query'], self.multiple_scale) result = { 'gallery_f': gallery_feature.numpy(), 'gallery_label': self.data.gallery_meta[dataset]['labels'], 'gallery_cam': self.data.gallery_meta[dataset]['cameras'], 'query_f': query_feature.numpy(), 'query_label': self.data.query_meta[dataset]['labels'], 'query_cam': self.data.query_meta[dataset]['cameras'] } scipy.io.savemat( os.path.join(self.project_dir, 'model', self.model_name, 'pytorch_result.mat'), result) print(self.model_name) print(dataset) os.system('python evaluate.py --result_dir {} --dataset {}'.format( os.path.join(self.project_dir, 'model', self.model_name), dataset))
def pre(self): json_file = 'results/result_' + time.strftime("%Y%m%d%H%M%S") + '.json' json_file_rk = 'results/result_' + time.strftime( "%Y%m%d%H%M%S") + '_rk.json' self.model.eval() t1 = time.time() print('extract features, this may take a few minutes') feats = extract_feature(self.model, tqdm(self.test_loader)) print('feats:', feats.shape) qf = feats[:self.num_query] gf = feats[self.num_query:] print('qf,gf:', qf.shape, gf.shape) m, n = qf.shape[0], gf.shape[0] distmat = torch.pow(qf, 2).sum(dim=1, keepdim=True).expand(m, n) + \ torch.pow(gf, 2).sum(dim=1, keepdim=True).expand(n, m).t() distmat.addmm_(1, -2, qf, gf.t()) distmat = distmat.cpu().numpy() self.writeResult(distmat, json_file) print('re_ranking ...') distmat_rk = reRanking(qf, gf, 7, 3, 0.85) self.writeResult(distmat_rk, json_file_rk) # print('distmat:', distmat.shape) # index = np.argsort(distmat) # from small to large # max_index = index[:, :200] # print(max_index.shape) # # # Visualize the rank result # results = {} # json_file = 'results/result_' + time.strftime("%Y%m%d%H%M%S") + '.json' # json_file_rk = 'results/result_' + time.strftime("%Y%m%d%H%M%S") + '_rk.json' # for i in range(len(self.query_paths)): # query_name = self.query_paths[i].split('/')[-1] # index_mask = max_index[i] # gallery_name = [self.gallery_paths[k].split('/')[-1] for k in index_mask] # #print(index_mask) # # results[query_name] = gallery_name # #print(res) # # with open(json_file, 'w', encoding='utf-8') as fp: # json.dump(results, fp) print('Time cost is: {:.2f} s'.format(time.time() - t1)) print('over!')
def __getitem__(self, i): sample = self.samples[i] wave = sample['wave'] trn = sample['trn'] feature = extract_feature(input_file=wave, feature='fbank', dim=self.args.d_input, cmvn=True) feature = build_LFR_features(feature, m=self.args.LFR_m, n=self.args.LFR_n) return feature, trn
def sub_extract(args): iscount = args.count k, gap, lam, n_jobs = args.kmer, args.gap, args.lam, args.process if args.directory: out = Path(args.output[0]) out.mkdir(exist_ok=True) ul.batch_extract(args.file, out, k, gap, lam, n_jobs=n_jobs, count=iscount) else: if args.raa: raa = list(args.raa) else: raa = list(Path(args.file[0]).stem.split('-')[-1]) xy_ls = [] aa_ls = [''.join(aa) for aa in product(raa, repeat=k)] for idx, file in enumerate(args.file): feature_file = Path(file) xy = ul.extract_feature(feature_file, raa, k, gap, lam, count=iscount) new_aa_ls = aa_ls if args.index: _, (fea_idx, _) = ul.load_data(args.index, normal=False, label_exist=False) fea_idx = fea_idx.astype(int).flatten() xy = xy[:, fea_idx] new_aa_ls = [aa_ls[i] for i in fea_idx] if args.label_f: y = np.array([[idx]] * xy.shape[0]) xy = np.hstack([y, xy]) xy_ls.append(xy) new_aa_ls.insert(0, 'label') if args.label_f else 0 header = ','.join(new_aa_ls) if args.merge: out = args.output[0] seq_mtx = np.vstack(xy_ls) ul.write_array(Path(out), seq_mtx, header=header) exit() for idx, o in enumerate(args.output): ul.write_array(Path(o), xy_ls[idx], header=header)
def predictSpeech(): print("Please talk") filename = "test.wav" # record the file (start talking) record_to_file(filename) # load the saved model (after training) model = pickle.load(open("result/mlp_classifier.model", "rb")) # extract features and reshape it features = extract_feature(file_name="test.wav", mfcc=True, chroma=True, mel=True).reshape(1, -1) # predict result = model.predict(features)[0] # show the result ! print("result:", result) return result
def predict_proba(self, audio_path): """ Predicts the probability of each emotion. """ if self.classification: feature = extract_feature(audio_path, **self.audio_config).reshape(1, -1) proba = self.model.predict_proba(feature)[0] result = {} for emotion, prob in zip(self.model.classes_, proba): result[emotion] = prob return result else: raise NotImplementedError( "Probability prediction doesn't make sense for regression")
def __getitem__(self, i): sample = self.samples[i] wave = sample['wave'] trn = sample['trn'] feature = extract_feature(input_file=wave, feature='fbank', dim=self.args.d_input, cmvn=True) # zero mean and unit variance feature = (feature - feature.mean()) / feature.std() feature = spec_augment(feature) feature = build_LFR_features(feature, m=self.args.LFR_m, n=self.args.LFR_n) return feature, trn
return sample_width, r def record_to_file(path): "Records from the microphone and outputs the resulting data to 'path'" sample_width, data = record() data = pack('<' + ('h' * len(data)), *data) wf = wave.open(path, 'wb') wf.setnchannels(1) wf.setsampwidth(sample_width) wf.setframerate(RATE) wf.writeframes(data) wf.close() if __name__ == "__main__": # load the saved model (after training) model = pickle.load(open("result/mlp_classifier.model", "rb")) print("Please talk") filename = "test.wav" # record the file (start talking) record_to_file(filename) # extract features and reshape it features = extract_feature(filename, mfcc=True, chroma=True, mel=True).reshape(1, -1) # predict result = model.predict(features)[0] # show the result ! print("result:", result)
def compute_true_false_miss(self, conf, log_dir, feat_path, tta): def gen_distmat(qf, q_pids, gf, g_pids): m, n = qf.shape[0], gf.shape[0] logger.debug('query shape {}, gallery shape {}'.format(qf.shape, gf.shape)) # logger.debug('q_pids {}, g_pids {}'.format(q_pids, g_pids)) distmat = torch.pow(qf, 2).sum(dim=1, keepdim=True).expand(m, n) + \ torch.pow(gf, 2).sum(dim=1, keepdim=True).expand(n, m).t() distmat.addmm_(1, -2, qf, gf.t()) distmat = distmat.cpu().numpy() return distmat# embeddings[idx:idx + conf.batch_size] = l2_norm(emb_batch).cpu() def distance(emb1, emb2): diff = np.subtract(emb1, emb2) dist = np.sum(np.square(diff), 1) return dist self.model.eval() if conf.gen_feature: with torch.no_grad(): query_feature, query_label = extract_feature(conf, self.model, self.loader['query']['dl'], tta) gallery_feature, gallery_label = extract_feature(conf, self.model, self.loader['gallery']['dl'], tta) result = {'query_feature': query_feature.numpy(), 'query_label': query_label.numpy(), 'gallery_feature': gallery_feature.numpy(), 'gallery_label': gallery_label.numpy()} scipy.io.savemat(feat_path, result) else: result = scipy.io.loadmat(feat_path) query_feature = torch.from_numpy(result['query_feature']) query_label = torch.from_numpy(result['query_label'])[0] gallery_feature = torch.from_numpy(result['gallery_feature']) gallery_label = torch.from_numpy(result['gallery_label'])[0] distmat = gen_distmat(query_feature, query_label, gallery_feature, gallery_label) # record txt with open(os.path.join(log_dir, 'result.txt'),'at') as f: f.write('%s\t%s\t%s\t%s\n' % ('threshold', 'acc', 'err', 'miss')) # record excel xls_file = xlwt.Workbook() sheet_1 = xls_file.add_sheet('sheet_1', cell_overwrite_ok=True) row = 0 path_excel = os.path.join(log_dir, 'result.xls') sheet_title = ['threshold', 'acc', 'err', 'miss'] for i_sheet in range(len(sheet_title)): sheet_1.write(row, i_sheet, sheet_title[i_sheet]) xls_file.save(path_excel) row += 1 index = np.argsort(distmat) # from small to large max_index = index[:, 0] query_list_file = 'data/probe.txt' gallery_list_file = 'data/gallery.txt' err_rank1 = os.path.join(log_dir, 'err_rank1.txt') data_path = DataPath(query_list_file, gallery_list_file) with open(err_rank1,'at') as f: f.write('%s\t\t\t%s\n' % ('query', 'gallery')) thresholds = np.arange(0.4, 2, 0.01) for threshold in thresholds: acc, err, miss = compute_rank1(distmat, max_index, query_label, gallery_label, threshold, data_path, err_rank1) # record txt with open(os.path.join(log_dir, 'result.txt'),'at') as f: f.write('%.6f\t%.6f\t%.6f\t%.6f\n' % (threshold, acc, err, miss)) # record excel list_data = [threshold, acc, err, miss] for i_1 in range(len(list_data)): sheet_1.write(row, i_1, list_data[i_1]) xls_file.save(path_excel) row += 1