def gen_train_data(in_path, out_path): matchObj = re.compile(r'(.+):([0-9\.]+)', re.M | re.I) res, qid = [], 0 qw = query_weight() text = [e.strip().split("\t") for e in open(in_path, encoding="utf8").readlines() if e.strip()] for i, ele in enumerate(tqdm(text, total=len(text))): line_ele, sen2terms = [], [] for e in ele: matchRes = matchObj.match(e) term, weight = matchRes.group(1), matchRes.group(2) line_ele.append((term, weight)) sen2terms.append(term) qw.run_step(" ".join(sen2terms)) weight_attn, weight_idf, weight_lm = qw.weight_attn, qw.weight_idf, qw.weight_lm sorted_line_ele = sorted(line_ele, key=lambda d: d[1], reverse=True) for i in range(len(sorted_line_ele)): feature_vector, fmap = get_feature(sorted_line_ele[i][0], sen2terms, weight_attn, weight_idf, weight_lm) res.append(" ".join([str(len(sorted_line_ele) - i - 1), "qid:" + str(qid)] + [str(i+1) + ":" + str(e) for i, e in enumerate(feature_vector)])) qid += 1 print("train data length: %d" % (len(res))) with open(out_path + "train.txt", "w", encoding="utf8") as fin: fin.write("\n".join(res[:int(len(res) * 0.9)])) with open(out_path + "test.txt", "w", encoding="utf8") as fin: fin.write("\n".join(res[int(len(res) * 0.9):])) with open(out_path + "valid.txt", "w", encoding="utf8") as fin: fin.write("\n".join(res[int(len(res) * 0.9):])) with open(out_path + "feature.fmap", "w", encoding="utf8") as fin: fin.write("\n".join(fmap))
def get_motifs(model, data_x, data_y, protein_name): model.trainable = False pos_x = get_pos(data_x, data_y) data_x = pos_x.reshape(pos_x.shape[0], pos_x.shape[1], pos_x.shape[2], 1) features = get_feature(model=model, data=data_x) features = features.reshape(features.shape[0], features.shape[1], features.shape[3]) if os.path.exists('./' + protein_name + '.fa'): os.remove('./' + protein_name + '.fa') fp = open('./' + protein_name + '.fa', 'w') count = 0 for i in range(features.shape[0]): seq = get_seq(data_x[i]) for j in range(features.shape[1]): count_1 = 0 for k in range(features.shape[2]): if features[i][j][k] > 0: count_1 += 1 if count_1 < 33 + int(len(data_y) / 4000): continue else: for k in range(features.shape[2]): if features[i][j][k] > 0.4: fp.write('>' + 'seq_' + str(i) + '_' + 'filter' + str(j) + '_' + str(k) + '\n') fp.write(seq[j:j + 7] + '\n') count += 1 fp.close() print('count:', count) print('{}start get {} logo{}'.format('*' * 10, protein_name, '*' * 10)) get_logo(protein_name) print('{}draw {} logo done{}'.format('*' * 10, protein_name, '*' * 10))
def inference(self, question, source='solr'): if not source: source = 'solr' documents = self.search(question, source) # print(documents) assert len(documents) != 0, 'Can not search any passages.' response = [] for document in documents: result = OrderedDict() passage = document['passage'] source = document['source'] inps = (passage, question) feed_dict = get_feature(self.model, inps, self.vocab, self.config) start_prob, end_prob = self.sess.run( [self.model.start_probs, self.model.end_probs], feed_dict=feed_dict) best_start, best_end, max_prob = find_best_answer( start_prob[0], end_prob[0], self.model.max_a_len) answer = ''.join(list(jieba.cut(passage))[best_start:best_end + 1]) score = max_prob result['answer'] = answer result['score'] = str(score) result['passage'] = passage result['source'] = source response.append(result) response = sorted(response, key=lambda x: float(x['score']), reverse=True) return {'response': response}
def __update(self): patch = get_subwindow(self.img, self.pos, self.window_size) xf = fft2( get_feature(patch, self.feature, self.cell_size, self.cos_window)) alphaf = self.__train(xf) self.model_xf = ( 1 - self.interp_factor) * self.model_xf + self.interp_factor * xf self.model_alphaf = ( 1 - self.interp_factor ) * self.model_alphaf + self.interp_factor * alphaf
def rank_weight(self, sen2terms, weight_attn, weight_idf, weight_lm): tmp, score_sum = [], 1e-8 for term in sen2terms: feature_vector, _ = get_feature(term, sen2terms, weight_attn, weight_idf, weight_lm) feature = np.array(feature_vector) feature_csr = sparse.csr_matrix(feature) input = DMatrix(feature_csr) score = self.xgb_model.predict(input)[0] prob = 1.0 / (1 + math.exp(-1 * score)) tmp.append((term, prob)) score_sum += prob res = [(k, round(v / score_sum, 3)) for k, v in tmp] return res
def main(): eps = eps_start for i_episode in range(1, n_episode + 1): state = env.reset() done = False step = 0 for t in range(1, n_timestep + 1): step += 1 action, _ = choose_action( state, F_network, C_network, n_action, n_state, eps, device ) next_state, reward, done, _ = env.step(action) feature = get_feature(state) action_vector = np.zeros(n_action) action_vector[action] = 1.0 experience = experience_t( np.concatenate([state, action_vector]), reward, feature, next_state, done and t < n_timestep, ) state = next_state memory.append(experience) if step % freq_update_network == 0 and len(memory) > batch_size: train() if t % freq_target_update == 0: soft_update(F_network, F_aux, tau) soft_update(C_network, C_aux, tau) eps = max(eps_end, eps - (eps_start - eps_end) / (eps_decrease_steps - 1)) if done: break if i_episode % freq_evaluation == 0: evaluation() torch.save(F_network.state_dict(), F_net_name) torch.save(C_network.state_dict(), C_net_name)
def evaluation(): total_reward = 0 total_GVF_loss = 0 n_trial = 100 for _ in range(n_trial): state = env.reset() done = False gt_feature = torch.zeros(n_timestep, n_feature) pred_feature = torch.zeros(n_timestep, n_feature) discounted_para = torch.zeros(n_timestep, 1) step = 0 for t in range(1, n_timestep + 1): step += 1 action, pred_feature_vector = choose_action( state, F_network, C_network, n_action, n_state, 0.0, device ) next_state, reward, done, _ = env.step(action) total_reward += reward gt_feature_vector = torch.tensor(get_feature(state)) pred_feature[step - 1] = pred_feature_vector gt_feature[:step] += ( gt_feature_vector * (GVF_discount_factor ** discounted_para) )[:step] discounted_para[:step] += 1 state = next_state if done: break with torch.no_grad(): criterion = nn.MSELoss() total_GVF_loss += criterion(gt_feature[:step], pred_feature[:step]).item() avg_reward = total_reward / n_trial avg_GVF_loss = total_GVF_loss / n_trial
def evaluate(model, dev_data, batch_size, max_sent_length, device): was_training = model.training model.eval() vocab_tag = model.vocab_tag tok2idx, idx2tok = vocab_tag['token_to_index'], vocab_tag['index_to_token'] tag2idx, idx2tag = vocab_tag['tag_to_index'], vocab_tag['index_to_tag'] data_loader = DataLoader(dev_data, batch_size=batch_size) val_loss = 0 cum_cnt = 0 with torch.no_grad(): for iter_idx, data in enumerate(data_loader): chars_batch, tags_batch = get_feature(data) chars_batch, chars_mask = pad_sents(chars_batch, pad_token, max_len=max_sent_length) tags_batch, tags_mask = pad_sents(tags_batch, pad_token, max_len=max_sent_length) input_chars = torch.tensor(token2id(chars_batch, tok2idx, unk_id=tok2idx['<UNK>']), device=device) target_tags = torch.tensor(token2id(tags_batch, tag2idx), device=device) tags_mask = torch.tensor(tags_mask, dtype=torch.uint8, device=device) # output_emission = conv_seg(input_chars.to(device)) # loss = -crf_model(output_emission.transpose(0,1), target_tags.transpose(0,1).to(device), tags_mask.transpose(0,1).to(device)) loss = -model(input_chars, target_tags, tags_mask) val_loss += loss cum_cnt = cum_cnt + input_chars.shape[0] val_loss = val_loss / cum_cnt if was_training: model.train() return val_loss
def dectect(self, img): # 这个其实和下面update是一样的,不知道为什么源代码会分成两部分写 self.original_img = img self.img = img if self.resize: self.img = cv2.resize(self.img, self.img_size[::-1]) if self.feature == 'gray': self.img = cv2.cvtColor( self.img, cv2.COLOR_BGR2GRAY) # translate image from rgb to gray patch = get_subwindow(self.img, self.pos, self.window_size) zf = fft2( get_feature(patch, self.feature, self.cell_size, self.cos_window)) if self.kernel_type == "gaussian": kzf = gaussian_correlation(zf, self.model_xf, self.kernel_sigma) elif self.kernel_type == "polynomial": kzf = polynomial_correlation(zf, self.model_xf, self.kernel_poly_a, self.kernel_poly_b) pass response = np.real(ifft2(self.model_alphaf * kzf)) cv2.imshow("response", response) cv2.waitKey(10) [vert_delta, horiz_delta] = np.unravel_index(response.argmax(), response.shape) # print("[vert_delta, horiz_delta] = " + str([vert_delta, horiz_delta])) if vert_delta > zf.shape[0] / 2: vert_delta = vert_delta - zf.shape[0] if horiz_delta > zf.shape[1] / 2: horiz_delta = horiz_delta - zf.shape[1] # print("after handled [vert_delta, horiz_delta] = " + str([vert_delta, horiz_delta])) self.pos = int(self.pos[0] + self.cell_size * (vert_delta)), int(self.pos[1] + self.cell_size * (horiz_delta)) self.__show_image() self.__update() return self.original_pos, self.original_target_size
def save_person_information(name): saved_model = './ArcFace/model/068.pth' info_path = './users/'+name if not os.path.exists(info_path): os.makedirs(info_path) # threshold = 0.30896 model = mobileFaceNet() model.load_state_dict(t.load(saved_model)['backbone_net_list']) model.eval() use_cuda = t.cuda.is_available() and True device = t.device("cuda" if use_cuda else "cpu") # is_cuda_avilableqq trans = transforms.Compose([ transforms.Resize((112,112)), transforms.ToTensor(), transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5]) ]) model.to(device) cap = cv2.VideoCapture(0) if not cap.isOpened(): print('failed open camara!!!') ret, frame = cap.read() while ret : frame = frame[:,:,::-1] img = Image.fromarray(frame) bboxes, landmark = detect_faces(img) show_img = show_bboxes(img,bboxes,landmark) show_img = np.array(show_img)[:,:,::-1] cv2.imshow('img',show_img) # 480 640 3 if cv2.waitKey(1) & 0xFF == ord('c'): person_img = frame[int(bboxes[0,1]):int(bboxes[0,3]),int(bboxes[0,0]):int(bboxes[0,2])] cv2.imshow('crop',person_img[:,:,::-1]) cv2.imwrite(os.path.join(info_path,'%s.jpg'%(name)),person_img[:,:,::-1]) feature = np.squeeze(get_feature(person_img,model,trans,device)) np.savetxt(os.path.join(info_path,'%s.txt'%(name)),feature) # cv2.waitKey(30) if cv2.waitKey(30) & 0xFF == ord('q'): break ret, frame = cap.read()
def get_pos_states(alist): global cap x, y = alist[0], alist[1] # print("x, y:", x, y) ret,img = cap.read() cv2.imshow("imag",img) img_trans = perTrans(img) cv2.imshow("perTrans_rst",img_trans) if pos_to_id(x, y) == None: return 0 # print("get_pos_states:", x, y) x_t, y_t = pos_to_id(x, y) x_t, y_t = 15+45*x_t, 13+46*y_t roi = img_trans[y_t-10:y_t+10, x_t-10:x_t+10, :] cv2.imwrite(r"C:\Users\SadAngel\Desktop\myworkplace\test1.jpg", roi) img_path = r"C:\Users\SadAngel\Desktop\myworkplace\test1.jpg" f1, f2, f3, f4, f5 = list(get_feature(img_path))[:5] print(f1, f2, f3, f4, f5) # 此处应该转格式 roi = Image.open(r"C:\Users\SadAngel\Desktop\myworkplace\test1.jpg") image = roi.convert('RGB') x, y, z = get_dominant_color(image) if x > 150 : #x , y , z = hsv_caculate(x,y,z) # if x > 170 and (y > 100 or z > 100): print(x, y, z, 'checker') # print(alist[0], alist[1]) result = 'Checker' return 1 else: # print(x, y, z, 'null') result = 'Null' return 2 return 0
def test(model_path, data_path, split, batch_size, max_sent_length, cuda): device = torch.device("cuda:0" if cuda else "cpu") dataset = SIGHAN(split='dev', root_path=data_path) model = CharWordSeg.load(model_path) model = model.to(device) model.eval() vocab_tag = model.vocab_tag tok2idx, idx2tok = vocab_tag['token_to_index'], vocab_tag['index_to_token'] tag2idx, idx2tag = vocab_tag['tag_to_index'], vocab_tag['index_to_tag'] data_loader = DataLoader(dataset, batch_size=batch_size) val_loss = 0 cum_cnt = 0 with torch.no_grad(): for iter_idx, data in enumerate(data_loader): chars_batch, tags_batch = get_feature(data) chars_batch, chars_mask = pad_sents(chars_batch, pad_token, max_len=max_sent_length) tags_batch, tags_mask = pad_sents(tags_batch, pad_token, max_len=max_sent_length) input_chars = torch.tensor(token2id(chars_batch, tok2idx, unk_id=tok2idx['<UNK>']), device=device) target_tags = torch.tensor(token2id(tags_batch, tag2idx), device=device) tags_mask = torch.tensor(tags_mask, dtype=torch.uint8, device=device) loss = -model(input_chars, target_tags, tags_mask) val_loss += loss cum_cnt = cum_cnt + input_chars.shape[0] val_loss = val_loss / cum_cnt return val_loss
def backend(self, sess, model, config, run_event): global query, response while run_event.is_set(): sleep(0.1) if query: local_response = list() for passage in query[0]: inp = (passage, query[1]) passage_tokens, passage_token_ids, question_token_ids, \ p_length, q_length, passage_char_ids, \ question_char_ids = get_feature( inp, model.vocab, config) feed_dict = { model.p: [passage_token_ids], model.q: [question_token_ids], model.p_length: [p_length], model.q_length: [q_length], model.ph: [passage_char_ids], model.qh: [question_char_ids], model.start_label: [0], model.end_label: [0], model.dropout: config.dropout } start_prob, end_prob = sess.run( [model.start_probs, model.end_probs], feed_dict=feed_dict) best_start, best_end, max_prob = find_best_answer( start_prob[0], end_prob[0], model.max_a_len) answer = ''.join(passage_tokens[best_start:best_end + 1]) score = str(max_prob) local_response.append({'answer': answer, 'score': score}) response = local_response local_response = list() query = tuple()
def predict(model_path, data_path, split, output_path, batch_size, max_sent_length, cuda): device = torch.device("cuda:0" if cuda else "cpu") dataset = SIGHAN(split=split, root_path=data_path) output = [] model = CharWordSeg.load(model_path) model = model.to(device) model.eval() vocab_tag = model.vocab_tag tok2idx, idx2tok = vocab_tag['token_to_index'], vocab_tag['index_to_token'] tag2idx, idx2tag = vocab_tag['tag_to_index'], vocab_tag['index_to_tag'] data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=False) with torch.no_grad(): for iter_idx, data in enumerate(data_loader): chars = get_feature(data, stage='predict') chars_batch, chars_mask = pad_sents(chars, pad_token, max_len=max_sent_length) input_chars = torch.tensor(token2id(chars_batch, tok2idx, unk_id=tok2idx['<UNK>']), device=device) chars_mask = torch.tensor(chars_mask, dtype=torch.uint8, device=device) pred_tags = id2token(model.decode(input_chars, chars_mask), idx2tag) output.extend(create_output(chars, pred_tags)) with codecs.open(output_path, 'w', 'utf8') as f: for sent in output: print(sent, file=f)
def train(split, data_path, save_to, batch_size, max_sent_length, char_embed_size, num_hidden_layer, channel_size, kernel_size, learning_rate, max_epoch, log_every, patience, max_num_trial, lr_decay, last_model_path, cuda): if not Path(save_to).exists(): Path(save_to).mkdir() device = torch.device("cuda:0" if cuda else "cpu") dataset = SIGHAN(split=split, root_path=data_path) val_dataset = SIGHAN(split='dev', root_path=data_path) # build vocab train_chars, train_tags = get_feature(dataset.data) vocab = build_vocab(chain.from_iterable(train_chars)) tok2idx, idx2tok = add_id(vocab) tags = build_vocab(["B", "M", "E", "S"], add_unk=False, add_pad=True) tag2idx, idx2tag = add_id(tags) # build model # conv_seg = CharWordSeg(len(tags), len(vocab), char_embed_size, num_hidden_layer, channel_size, kernel_size).to(device) # crf_model = CRF(num_tags=5).to(device) # conv_seg.train() # crf_model.train() # optimizer = torch.optim.Adam(list(conv_seg.parameters())+list(crf_model.parameters()), lr=learning_rate) vocab_tag = { "token_to_index": tok2idx, "index_to_token": idx2tok, "tag_to_index": tag2idx, "index_to_tag": idx2tag } data_loader = DataLoader(dataset, batch_size=batch_size) model = CharWordSeg(vocab_tag, char_embed_size, num_hidden_layer, channel_size, kernel_size).to(device) optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) if last_model_path is not None: # load model logging.info(f'load model from {last_model_path}') params = torch.load(last_model_path, map_location=lambda storage, loc: storage) model.load_state_dict(params['state_dict']) logging.info('restore parameters of the optimizers') optimizer.load_state_dict(torch.load(last_model_path + '.optim')) model.train() epoch = 0 cur_trial = 0 hist_valid_scores = [] train_time = begin_time = time.time() logging.info("begin training!") while True: epoch += 1 train_loss = 0 cum_cnt = 0 for iter_idx, data in enumerate(data_loader): optimizer.zero_grad() chars_batch, tags_batch = get_feature(data) chars_batch, chars_mask = pad_sents(chars_batch, pad_token, max_len=max_sent_length) tags_batch, tags_mask = pad_sents(tags_batch, pad_token, max_len=max_sent_length) input_chars = torch.tensor(token2id(chars_batch, tok2idx, unk_id=tok2idx['<UNK>']), device=device) target_tags = torch.tensor(token2id(tags_batch, tag2idx), device=device) tags_mask = torch.tensor(tags_mask, dtype=torch.uint8, device=device) # output_emission = conv_seg(input_chars.to(device)) # loss = -crf_model(output_emission.transpose(0,1), target_tags.transpose(0,1).to(device), tags_mask.transpose(0,1).to(device)) loss = -model(input_chars, target_tags, tags_mask) train_loss += loss cum_cnt = cum_cnt + input_chars.shape[0] loss.backward() optimizer.step() train_loss = train_loss / cum_cnt val_loss = evaluate(model, val_dataset, batch_size, max_sent_length, device) logging.info( f'epoch {epoch}\t train_loss: {train_loss}\t val_loss:{val_loss}\t speed:{time.time()-train_time:.2f}s/epoch\t time elapsed {time.time()-begin_time:.2f}s' ) train_time = time.time() is_better = len( hist_valid_scores) == 0 or val_loss < min(hist_valid_scores) hist_valid_scores.append(val_loss) if epoch % log_every == 0: model.save(f"{save_to}/model_step_{epoch}") torch.save(optimizer.state_dict(), f"{save_to}/model_step_{epoch}.optim") if is_better: cur_patience = 0 model_save_path = f"{save_to}/model_best" print(f'save currently the best model to [{model_save_path}]') model.save(model_save_path) # also save the optimizers' state torch.save(optimizer.state_dict(), model_save_path + '.optim') elif cur_patience < patience: cur_patience += 1 print('hit patience %d' % cur_patience) if cur_patience == patience: cur_trial += 1 print(f'hit #{cur_trial} trial') if cur_trial == max_num_trial: print('early stop!') exit(0) # decay lr, and restore from previously best checkpoint lr = optimizer.param_groups[0]['lr'] * lr_decay logging.info( f'load previously best model and decay learning rate to {lr}' ) # load model params = torch.load(model_save_path, map_location=lambda storage, loc: storage) model.load_state_dict(params['state_dict']) model = model.to(device) logging.info('restore parameters of the optimizers') optimizer.load_state_dict( torch.load(model_save_path + '.optim')) # set new lr for param_group in optimizer.param_groups: param_group['lr'] = lr # reset patience cur_patience = 0 if epoch == max_epoch: print('reached maximum number of epochs!') exit(0)
import numpy as np from sklearn import datasets from utils import get_feature import cv2 if __name__ == '__main__': img_path = r'.\vision\2-classify\data\1\test1554022732.042874.jpg' X_data = [] X_data.append(get_feature(img_path)) X = np.array(X_data) print(type(X)) print(X.shape) X = X.astype(np.float32) # svm = cv2.ml.SVM_create() # svm.load("svmtest.mat") svm = cv2.ml.SVM_load(r".\vision\2-classify\svmtest.mat") '''开始预测''' print(X) print(svm.predict(X)) _, y_pred = svm.predict(X) print(y_pred)
from utils import get_feature import os rootdir = r'.\vision\2-classify\data\0' alist = os.listdir(rootdir) #列出文件夹下所有的目录与文件 # print(alist[:20]) X_data = [] for i, path in enumerate(alist): img_path = os.path.join(rootdir, alist[i]) print(img_path) if os.path.isfile(img_path): fea = get_feature(img_path) X_data.append(fea) lenth = len(alist) y_data = [0] * lenth rootdir = r'.\vision\2-classify\data\1' alist = os.listdir(rootdir) #列出文件夹下所有的目录与文件 for i, path in enumerate(alist): img_path = os.path.join(rootdir, alist[i]) print(img_path) if os.path.isfile(img_path): fea = get_feature(img_path) X_data.append(fea) lenth = len(alist) y_data = y_data + [1] * lenth
def __init__(self, batch_size, steps, embeddings, embedding_size, rnn_size, num_rnn_layers, max_grad_norm, filter_sizes, num_filters, self_att=True, model_choice=0, mode="qa", rnn_windows=5, l2_reg_lambda=0.0, adjust_weight=False, label_weight=[], is_training=True): self.batch_size = batch_size self.embeddings = embeddings self.embedding_size = embedding_size self.adjust_weight = adjust_weight self.label_weight = label_weight self.rnn_size = rnn_size self.steps = steps self.max_grad_norm = max_grad_norm self.l2_reg_lambda = l2_reg_lambda self.is_training = is_training self.filter_sizes = list(map(int, filter_sizes.split(','))) self.num_filters = num_filters self.mode_choice = model_choice self.rnn_windows = rnn_windows self.att = self_att self.keep_pron = tf.placeholder(tf.float32, name='keep_prob') self.lr = tf.Variable(0.0, trainable=False) self.new_lr = tf.placeholder(tf.float32, shape=[], name='new-learning-rate') self.lr_update = tf.assign(self.lr, self.new_lr) self.ori_input = tf.placeholder(tf.int32, shape=[None, self.steps], name='ori_inputs_quests') self.cand_input = tf.placeholder(tf.int32, shape=[None, self.steps], name='cand_inputs_quests') self.neg_input = tf.placeholder(tf.int32, shape=[None, self.steps], name='neg_inputs_quests') self.test_q = tf.placeholder(tf.int32, shape=[None, self.steps], name='test_q') self.test_a = tf.placeholder(tf.int32, shape=[None, self.steps], name='test_a') self.ori_q_len = tf.count_nonzero(self.ori_input, 1) self.cand_a_len = tf.count_nonzero(self.cand_input, 1) self.neg_a_len = tf.count_nonzero(self.neg_input, 1) self.test_q_len = tf.count_nonzero(self.test_q, 1) self.test_a_len = tf.count_nonzero(self.test_a, 1) #embedding layer with tf.device('/cpu:0'), tf.name_scope('embedding_layer'): W = tf.Variable(tf.to_float(self.embeddings), trainable=Trur, name='W') ori_que = tf.nn.embedding_lookup(W, self.ori_input) cand_que = tf.nn.embedding_lookup(W, self.cand_input) neg_que = tf.nn.embedding_lookup(W, self.neg_input) test_que = tf.nn.embedding_lookup(W, self.test_q) test_ans = tf.nn.embedding_lookup(W, self.test_a) # biLSTM with tf.variable_scope("LSTM_scope1", reuse=None): ori_q = bilstm(ori_que, self.rnn_size) with tf.variable_scope("LSTM_scope1", reuse=True): test_q = bilstm(test_que, self.rnn_size) test_a = bilstm(test_ans, self.rnn_size) if mode == 'qq': cand_a = bilstm(cand_que, self.rnn_size) neg_a = bilstm(neg_que, self.rnn_size) if mode == 'qa': with tf.variable_scope("LSTM_scope2", reuse=None): cand_a = bilstm(cand_que, self.rnn_size) with tf.variable_scope("LSTM_scope2", reuse=True): neg_a = bilstm(neg_que, self.rnn_size) ori_q = mask(ori_q, self.ori_q_len, self.steps) cand_a = mask(cand_a, self.cand_a_len, self.steps) neg_a = mask(neg_a, self.neg_a_len, self.steps) test_q = mask(test_q, self.test_q_len, self.steps) test_a = mask(test_a, self.test_a_len, self.steps) for i, filter_size in enumerate(filter_sizes): with tf.name_scope("conv-maxpool-%s" % filter_size): if self.mode_choice == 3: filter_size = [ filter_size, self.embedding_size, 1, self.num_filters ] else: filter_size = [ filter_size, self.rnn_size * 2, 1, self.num_filters ] W = tf.Variable(tf.truncated_normal(filter_size, stddev=0.1), name='Kernel_W') b = tf.Variable(tf.constant(0.1, shape=[self.num_filters]), name='Kernel_b') self.kernel.append((W, b)) in_dim = ori_que.get_shape()[2] with tf.variable_scope('door'): if self.mode_choice == 5 or self.mode_choice == 6: door_w = { 'd_w': tf.get_variable('d_w', [100, 300]), 'd_b': tf.get_variable('d_b', [1, 300]), } else: door_w = { 'd_w': tf.get_variable('d_w', [in_dim, in_dim]), 'd_b': tf.get_variable('d_b', [in_dim, in_dim]), } with tf.variable_scope('change'): if self.mode_choice == 5 or self.mode_choice == 6: change_w = { 'c_w': tf.get_variable('c_w', [300, 300]), 'c_b': tf.get_variable('c_b', [1, 300]), } else: change_w = { 'c_w': tf.get_variable('c_w', [in_dim, in_dim]), 'c_b': tf.get_variable('c_b', [1, in_dim]), } with tf.variable_scope('self_att'): self_att = { 'att_w': tf.get_variable('att_w', [300, 300]), 'att_b': tf.get_variable('att_b', [1, 300]), 'att_u': tf.get_variable('att_u', [300, 1]) } if self.mode_choice == 0: ##biLSTM + mask + highway+cnn_qa ori_q_highway, cand_a_highway = get_rnn2cnn_out( ori_q, cand_a, door_w, change_w, self.steps) _, neg_a_highway = get_rnn2cnn_out(ori_q, neg_a, door_w, change_w, self.steps) test_q_highway, test_a_highway = get_rnn2cnn_out( test_q, test_a, door_w, change_w, self.steps) print(ori_q_highway.shape) ori_q_fea, cand_a_fea, neg_a_fea = cnn_qa( ori_q=ori_q_highway, can_a=cand_a_highway, neg_a=neg_a_highway, seq_len=self.steps, hidden_size=2 * self.rnn_size, filter_sizes=self.filter_sizes, num_filters=self.num_filters) test_q_fea, test_a_fea, _ = cnn_qa(ori_q=test_q_highway, cand_a=test_a_highway, neg_a=neg_a_highway, seq_len=self.steps, hidden_size=2 * self.rnn_size, filter_sizes=self.filter_sizes, num_filters=self.num_filters) if self.mode_choice == 1: ##biLSTM + mask + max_pooling ori_q_fea, cand_a_fea = get_feature_mask(ori_q, cand_a, self.ori_q_len, self.cand_a_len, self.steps) _, neg_a_fea = get_rnn2cnn_out(ori_q, neg_a, self.ori_q_len, self.neg_a_len, self.steps) test_q_fea, test_a_fea = get_feature_mask(test_q, test_a, self.test_q_len, self.test_a_len, self.steps) if self.mode_choice == 2: ##biLSTM+ mask + highway + max_pooling ori_q_highway, cand_a_highway = get_rnn2cnn_out( ori_q, cand_a, door_w, change_w, self.steps) _, neg_a_highway = get_rnn2cnn_out(ori_q, neg_a, door_w, change_w, self.steps) test_q_highway, test_a_highway = get_rnn2cnn_out( test_q, test_a, door_w, change_w, self.steps) print(ori_q_highway.shape) ori_q_fea, cand_a_fea = get_feature(ori_q_highway, cand_a_highway) ori_nq_fea, neg_a_fea = get_feature(ori_q_highway, neg_a_highway) test_q_fea, test_a_fea, _ = get_feature(test_q_highway, test_a_highway) if self.mode_choice == 3: ##embedding + CNN ori_q_fea, cand_a_fea, neg_a_fea = cnn_qa( ori_q=ori_que, can_a=cand_que, neg_a=neg_que, seq_len=self.steps, hidden_size=self.embedding_size, filter_sizes=self.filter_sizes, num_filters=self.num_filters) test_q_fea, test_a_fea, _ = cnn_qa(ori_q=test_q, cand_a=test_a, neg_a=neg_que, seq_len=self.steps, hidden_size=self.embedding_size, filter_sizes=self.filter_sizes, num_filters=self.num_filters) if self.mode_choice == 4: ## biLSTM + mask + highway + highway + maxpooling ori_q_highway, cand_a_highway = get_rnn2cnn_out( ori_q, cand_a, door_w, change_w, self.steps) _, neg_a_highway = get_rnn2cnn_out(ori_q, neg_a, door_w, change_w, self.steps) test_q_highway, test_a_highway = get_rnn2cnn_out( test_q, test_a, door_w, change_w, self.steps) ori_q_2highway, cand_a_2highway = get_rnn2cnn_out( ori_q_highway, cand_a_highway, door_w, change_w, self.steps) _, neg_a_2highway = get_rnn2cnn_out(ori_q_highway, neg_a_highway, door_w, change_w, self.steps) test_q_2highway, test_a_2highway = get_rnn2cnn_out( test_q_highway, test_a_highway, door_w, change_w, self.steps) ori_q_fea, cand_a_fea = get_feature(ori_q_2highway, cand_a_2highway) ori_nq_fea, neg_a_fea = get_feature(ori_q_2highway, neg_a_2highway) test_q_fea, test_a_fea, _ = get_feature(test_q_2highway, test_a_2highway) if self.mode_choice == 5: ## biLSTM + mask + concat + highway + attention ori_q_concat = tf.concat([ori_q, ori_que], 2) cand_a_concat = tf.concat([cand_a, cand_que], 2) neg_a_concat = tf.concat([neg_a, neg_que], 2) test_q_concat = tf.concat([test_q, test_que], 2) test_a_concat = tf.concat([test_a, test_ans], 2) print(ori_q_concat.shape) ori_q_highway, cand_a_highway = get_rnn2cnn_out_hxh( ori_que, ori_q_concat, cand_que, cand_a_concat, door_w, change_w, self.steps) print(ori_q_highway) _, neg_a_highway = get_rnn2cnn_out_hxh(ori_que, ori_q_concat, neg_que, neg_a_concat, door_w, change_w, self.steps) test_q_highway, test_a_highway = get_rnn2cnn_out( test_que, test_q_concat, test_ans, test_a_concat, door_w, change_w, self.steps) if self.att: ori_q_fea = get_feature_att(ori_q_highway, self_att, self.ori_q_len, self.steps) cand_a_fea = get_feature_att(cand_a_concat, self_att, self.cand_a_len, self.steps) neg_a_fea = get_feature_att(neg_a_concat, self_att, self.neg_a_len, self.steps) test_q_fea = get_feature_att(test_q_highway, self_att, self.test_q_len, self.steps) test_a_fea = get_feature_att(test_a_concat, self_att, self.neg_a_len, self.steps) self.ori_q_fea = tf.reshape(ori_q_fea, [-1, 300], name='ori_q_feature') print('ori_q_shape is :', ori_q_fea.shape) else: ori_q_fea, cand_a_fea = get_feature(ori_q_highway, cand_a_highway) _, neg_a_fea = get_feature(ori_q_highway, neg_a_highway) test_q_fea, test_a_fea = get_feature(test_q_highway, test_a_highway) self.ori_q_fea = tf.reshape(ori_q_fea, [-1, 300], name='ori_q_feature') if self.mode_choice == 6: ##model 5 - attention + window + maxpooling ori_q_concat = tf.concat([ori_q, ori_que], 2) cand_a_concat = tf.concat([cand_a, cand_que], 2) neg_a_concat = tf.concat([neg_a, neg_que], 2) test_q_concat = tf.concat([test_q, test_que], 2) test_a_concat = tf.concat([test_a, test_ans], 2) print(ori_q_concat.shape) ori_q_highway, cand_a_highway = get_rnn2cnn_out_hxh( ori_que, ori_q_concat, cand_que, cand_a_concat, door_w, change_w, self.steps) print(ori_q_highway) _, neg_a_highway = get_rnn2cnn_out_hxh(ori_que, ori_q_concat, neg_que, neg_a_concat, door_w, change_w, self.steps) test_q_highway, test_a_highway = get_rnn2cnn_out( test_que, test_q_concat, test_ans, test_a_concat, door_w, change_w, self.steps) ori_q_list, cand_a_list, neg_a_list, test_q_list, test_a_list = [], [], [], [], [] for i in range(self.steps - self.rnn_windows + 1): ori_q_slice = tf.slice(ori_q_highway, [0, i, 0], [-1, self.rnn_windows, 300]) cand_a_slice = tf.slice(cand_a_highway, [0, i, 0], [-1, self.rnn_windows, 300]) neg_a_slice = tf.slice(neg_a_highway, [0, i, 0], [-1, self.rnn_windows, 300]) test_q_slice = tf.slice(test_q_highway, [0, i, 0], [-1, self.rnn_windows, 300]) test_a_slice = tf.slice(test_a_highway, [0, i, 0], [-1, self.rnn_windows, 300]) if i > 0: tf.get_variable_scope().reuse with tf.variable_scope("LSTM_scope3", reuse=None): ori_q_slice_fea = bilstm(ori_q_slice, self.rnn_size) with tf.variabel_scope("LSTM_scope4", reuse=True): cand_a_slice_fea = bilstm((cand_a_slice, self.rnn_size)) neg_a_slice_fea = bilstm(neg_a_slice, self.rnn_size) test_q_slice_fea = bilstm(test_q_slice, self.rnn_size) test_a_slice_fea = bilstm(test_a_slice, self.rnn_size) print(ori_q_slice_fea.shape) ori_q_f, cand_a_f = get_feature(ori_q_slice_fea, cand_a_slice_fea) _, neg_a_f = get_feature(ori_q_slice_fea, neg_a_slice_fea) test_q_f, test_a_f = get_feature(test_q_slice_fea, test_a_slice_fea) print('model 6 ori_q_fea.shape:', ori_q_f.shape) ori_q_list.append(ori_q_f) cand_a_list.append(cand_a_f) neg_a_list.append(neg_a_f) test_q_list.append(test_q_f) test_a_list.append(test_a_f) ori_q_feat = tf.transpose(ori_q_list, perm=[1, 0, 2]) cand_a_feat = tf.transpose(cand_a_list, perm=[1, 0, 2]) neg_a_feat = tf.transpose(neg_a_list, perm=[1, 0, 2]) test_q_feat = tf.transpose(test_q_list, perm=[1, 0, 2]) test_a_feat = tf.transpose(test_a_list, perm=[1, 0, 2]) ori_q_fea, cand_a_fea = get_feature(ori_q_feat, cand_a_feat) _, neg_a_fea = get_feature(ori_q_feat, neg_a_feat) test_q_fea, test_a_fea = get_feature(test_q_feat, test_a_feat) self.ori_q_fea = ori_q_fea self.ori_cand = feature2cos(ori_q_fea, cand_a_feat) self.ori_neg = feature2cos(ori_q_fea, neg_a_fea) self.loss, self.acc = cal_loss_and_acc(self.ori_cand, self.ori_neg) self.test_q_a = feature2cos(test_q_fea, test_a_fea)
def __init__(self, img, start_pos, target_size, padding=2.5, lamb=0.0001, output_sigma_factor=0.1, interp_factor=0.075, cell_size=1, feature='gray', resize=False, kernel={ 'kernel_type': 'gaussian', 'sigma': 0.2 }, showvideo=True): self.original_img = img self.img = img self.padding = padding self.lamb = lamb self.output_sigma_factor = output_sigma_factor self.interp_factor = interp_factor self.cell_size = cell_size self.feature = feature self.showvideo = showvideo self.original_pos = start_pos self.original_target_size = target_size self.pos = start_pos # the box's CENTER point coordinate,it is format as [y, x] self.target_size = target_size # the box's size , it is format as [h, w] self.base_size = target_size self.kernel_type = kernel['kernel_type'] if self.kernel_type == 'gaussian': self.kernel_sigma = kernel['sigma'] elif self.kernel_type == 'polynomial': self.kernel_poly_a = kernel['poly_a'] self.kernel_poly_b = kernel['poly_b'] self.resize = resize if np.sqrt(np.prod(self.target_size)) >= 150: print("resize image") self.resize = True if self.resize: print("image is resized") self.pos = tuple([int(ele / 2) for ele in self.pos]) self.target_size = tuple( [int(ele / 2) for ele in self.target_size]) self.img_size = (int(img.shape[0] / 2), int(img.shape[1] / 2)) img = cv2.resize(img, self.img_size[::-1]) # in opencv the img's size get from shape # the shape is format as (h,w,c), c is the chanel of image self.img_size = (img.shape[0], img.shape[1]) self.window_size = (int(self.target_size[0] * self.padding), int(self.target_size[1] * self.padding)) if self.feature == 'gray': img = cv2.cvtColor( img, cv2.COLOR_BGR2GRAY) # translate image from rgb to gray # 一些不会变的变量,如余弦窗,期望分布 output_sigma = np.sqrt(np.prod( self.target_size)) * self.output_sigma_factor / self.cell_size self.y = gaussian_shaped_labels( output_sigma, (int(self.window_size[0] / self.cell_size), int(self.window_size[1] / self.cell_size))) self.yf = fft2(self.y) self.cos_window = np.outer(np.hanning(self.yf.shape[0]), np.hanning(self.yf.shape[1])) # 初始化模型 patch = get_subwindow(img, self.pos, self.window_size) xf = fft2( get_feature(patch, self.feature, self.cell_size, self.cos_window)) self.model_xf = xf self.model_alphaf = self.__train(xf) self.__show_image()
from ruamel import yaml from sklearn.model_selection import train_test_split import lightgbm as lgb # Read data df_train = pd.read_csv('./data/train.csv') # setup words = get_words(df_train) counts = Counter(words) weights = {word: get_weight(count) for word, count in counts.items()} df_train['word_shares'] = df_train.apply(lambda x: word_shares(x, weights), axis=1) # get feature x = get_feature(df_train) feature_names = list(x.columns.values) print("Features:", feature_names) y = df_train['label'].values # Load params params = yaml.safe_load(open('./src/Essemble/params_lightgbm.yaml')) MODEL_PATH = './models/lightgbm.bin' ROUNDS = 200 RS = 123457 def train(X, y, params): print('Train for {} rounds, Randomseed: {}'.format(ROUNDS, RS)) x_train, x_val, y_train, y_val = train_test_split(X, y,
def verification(): saved_model = './ArcFace/model/068.pth' name_list = os.listdir('./users') path_list = [os.path.join('./users', i, '%s.txt' % (i)) for i in name_list] total_features = np.empty((128, ), np.float32) people_num = len(path_list) font = ImageFont.truetype('simhei.ttf', 20, encoding='utf-8') if people_num > 1: are = 'are' people = 'people' else: are = 'is' people = 'person' print('start retore users information, there %s %d %s information' % (are, people_num, people)) for i in path_list: temp = np.loadtxt(i) total_features = np.vstack((total_features, temp)) total_features = total_features[1:] # threshold = 0.30896 #阈值并不合适,可能是因为训练集和测试集的差异所致!!! threshold = 0.5 model = mobileFaceNet() model.load_state_dict(t.load(saved_model)['backbone_net_list']) model.eval() use_cuda = t.cuda.is_available() and True device = t.device("cuda" if use_cuda else "cpu") # is_cuda_avilable trans = transforms.Compose([ transforms.Resize((112, 112)), transforms.ToTensor(), transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]) ]) model.to(device) cap = cv2.VideoCapture(0) if not cap.isOpened(): print('failed open camara!!!') ret, frame = cap.read() while ret: frame = frame[:, :, ::-1] img = Image.fromarray(frame) bboxes, landmark = detect_faces(img) # print(bbox) # [[296.89171371 211.27569699 441.8924298 396.48678774 0.99999869]] if len(bboxes) == 0: cv2.imshow('img', frame[:, :, ::-1]) # videoWriter.write(frame[:,:,::-1]) cv2.waitKey(10) ret, frame = cap.read() continue show_img = frame.copy() for bbox in bboxes: loc_x_y = [bbox[2], bbox[1]] person_img = frame[int(bbox[1]):int(bbox[3]), int(bbox[0]):int(bbox[2])].copy() feature = np.squeeze(get_feature(person_img, model, trans, device)) cos_distance = cosin_metric(total_features, feature) index = np.argmax(cos_distance) if not cos_distance[index] > threshold: ret, frame = cap.read() continue person = name_list[index] show_img = draw_ch_zn(show_img, person, font, loc_x_y) cv2.rectangle(show_img, (int(bbox[0]), int(bbox[1])), (int(bbox[2]), int(bbox[3])), (0, 0, 255)) cv2.imshow('img', show_img[:, :, ::-1]) if cv2.waitKey(10) & 0xFF == ord('q'): # videoWriter.release() break ret, frame = cap.read()
def __init__(self, batch_size, num_unroll_steps, embeddings, embedding_size, rnn_size, num_rnn_layers, max_grad_norm,attention_matrix_size,loss_ratio, l2_reg_lambda=0.0, adjust_weight=False,label_weight=[],is_training=True,m=0.1): # define input variable self.batch_size = batch_size self.embeddings = embeddings self.embedding_size = embedding_size self.adjust_weight = adjust_weight self.label_weight = label_weight self.rnn_size = rnn_size self.num_rnn_layers = num_rnn_layers self.num_unroll_steps = num_unroll_steps self.max_grad_norm = max_grad_norm self.l2_reg_lambda = l2_reg_lambda self.is_training = is_training self.keep_prob = tf.placeholder(tf.float32, name="keep_drop") self.lr = tf.Variable(0.0,trainable=False) self.new_lr = tf.placeholder(tf.float32, shape=[],name="new_learning_rate") self._lr_update = tf.assign(self.lr, self.new_lr) self.ori_input_quests = tf.placeholder(tf.int32, shape=[None, self.num_unroll_steps]) self.cand_input_quests = tf.placeholder(tf.int32, shape=[None, self.num_unroll_steps]) self.neg_input_quests = tf.placeholder(tf.int32, shape=[None, self.num_unroll_steps]) self.test_input_q = tf.placeholder(tf.int32, shape=[None, self.num_unroll_steps], name='test_q') self.test_input_a = tf.placeholder(tf.int32, shape=[None, self.num_unroll_steps], name='test_a') self.q_cats = tf.placeholder(tf.int32, [None, CAT_NUMBER], name='q_cats') self.a_cats = tf.placeholder(tf.int32, [None, CAT_NUMBER], name='a_cats') #embedding layer with tf.device("/cpu:0"),tf.name_scope("embedding_layer"): W = tf.Variable(tf.to_float(self.embeddings), trainable=True, name="W") ori_quests =tf.nn.embedding_lookup(W, self.ori_input_quests) cand_quests =tf.nn.embedding_lookup(W, self.cand_input_quests) neg_quests =tf.nn.embedding_lookup(W, self.neg_input_quests) test_q =tf.nn.embedding_lookup(W, self.test_input_q) test_a =tf.nn.embedding_lookup(W, self.test_input_a) # run lstm without attention # with tf.variable_scope("LSTM_scope") as scope: # ori_q = biLSTM(ori_quests, self.rnn_size) # ori_q_feat = tf.nn.tanh(max_pooling(ori_q)) # # scope.reuse_variables() # # cand_a = biLSTM(cand_quests, self.rnn_size) # neg_a = biLSTM(neg_quests, self.rnn_size) # cand_q_feat = tf.nn.tanh(max_pooling(cand_a)) # neg_q_feat = tf.nn.tanh(max_pooling(neg_a)) # # test_q_out = biLSTM(test_q, self.rnn_size) # test_q_out = tf.nn.tanh(max_pooling(test_q_out)) # test_a_out = biLSTM(test_a, self.rnn_size) # test_a_out = tf.nn.tanh(max_pooling(test_a_out)) #build LSTM network with tf.variable_scope("LSTM_scope") as scope: ori_q = biLSTM(ori_quests, self.rnn_size) #ori_q_feat = tf.nn.tanh(max_pooling(ori_q)) scope.reuse_variables() cand_a = biLSTM(cand_quests, self.rnn_size) neg_a = biLSTM(neg_quests, self.rnn_size) #cand_q_feat = tf.nn.tanh(max_pooling(cand_a)) #neg_q_feat = tf.nn.tanh(max_pooling(neg_a)) test_q_out = biLSTM(test_q, self.rnn_size) #test_q_out = tf.nn.tanh(max_pooling(test_q_out)) test_a_out = biLSTM(test_a, self.rnn_size) #test_a_out = tf.nn.tanh(max_pooling(test_a_out)) with tf.name_scope("att_weight"): # attention params att_W = { 'Wam': tf.Variable(tf.truncated_normal([2 * self.rnn_size, attention_matrix_size], stddev=0.1)), 'Wqm': tf.Variable(tf.truncated_normal([2 * self.rnn_size, attention_matrix_size], stddev=0.1)), 'Wms': tf.Variable(tf.truncated_normal([attention_matrix_size, 1], stddev=0.1)) } ori_nq_feat, cand_q_feat = get_feature(ori_q, cand_a, att_W) ori_q_feat, neg_q_feat = get_feature(ori_q, neg_a, att_W) test_q_out, test_a_out = get_feature(test_q_out, test_a_out, att_W) # multitasking with tf.variable_scope("multitasking") as scope: feature_size = int(ori_q_feat.get_shape()[1]) logits_q = fc(ori_q_feat,feature_size) # scope.reuse_variables() logits_a = fc(cand_q_feat, feature_size) logits_ng_a = fc(neg_q_feat, feature_size) #feature_size = int(ori_q_feat.get_shape()[1]) #w = tf.get_variable(name='weights', shape=(feature_size, CAT_NUMBER, initializer=tf.random_normal_initializer()) #b = tf.get_variable(name='bias', shape=(1, CAT_NUMBER), initializer=tf.zeros_initializer()) # positive_qa = tf.concat([out_ori,out_cand],1,name="embedding_for_multitask") #logits = tf.matmul(ori_q_feat, w) + b entropy_q = tf.nn.softmax_cross_entropy_with_logits(logits=logits_q, labels=self.q_cats, name='loss1') entropy_a= tf.nn.softmax_cross_entropy_with_logits(logits=logits_a, labels=self.q_cats, name='loss2') entropy_ng_a = tf.nn.softmax_cross_entropy_with_logits(logits=logits_ng_a, labels=self.a_cats, name='loss3') loss_multitask_q = tf.reduce_mean(entropy_q) loss_multitask_a = tf.reduce_mean(entropy_a) loss_multitask_ng_a = tf.reduce_mean(entropy_ng_a) loss_multitask = loss_multitask_q+loss_multitask_a+loss_multitask_ng_a loss_multitask = loss_multitask_q # acc self.ori_cand_score = feature2cos_sim(ori_q_feat, cand_q_feat) self.ori_neg_score = feature2cos_sim(ori_q_feat, neg_q_feat) loss_origin, self.acc = cal_loss_and_acc(self.ori_cand_score, self.ori_neg_score,m) self.loss = loss_origin * (1 - loss_ratio) + loss_multitask * loss_ratio self.test_q_a = feature2cos_sim(test_q_out, test_a_out) #evaluate multitasking_acc with tf.name_scope("multi_acc"): self.preds_q = tf.nn.softmax(logits_q) self.correct_preds_q = tf.equal(tf.argmax(self.preds_q, 1), tf.argmax(self.q_cats, 1)) self.multi_acc_q = tf.reduce_sum(tf.cast(self.correct_preds_q, tf.float32)) self.preds_a = tf.nn.softmax(logits_a) self.correct_preds_a = tf.equal(tf.argmax(self.preds_a, 1), tf.argmax(self.q_cats, 1)) self.multi_acc_a = tf.reduce_sum(tf.cast(self.correct_preds_a, tf.float32)) self.preds_ng_a = tf.nn.softmax(logits_ng_a) self.correct_preds_ng_a = tf.equal(tf.argmax(self.preds_ng_a, 1), tf.argmax(self.a_cats, 1)) self.multi_acc_ng_a = tf.reduce_sum(tf.cast(self.correct_preds_ng_a, tf.float32)) self.multi_acc = (self.multi_acc_q + self.multi_acc_a + self.multi_acc_ng_a)/3 self.multi_acc = self.multi_acc_q
# for p1, p2 in itertools.chain(cars): # # Draw SVC boxes # cv2.rectangle(svc_img, p1, p2, (255, 255, 0), 3) svc_img = cv2.addWeighted(svc_img, 1.0, heatmap, 0.8, 0.0) return svc_img if __name__ == "__main__": # Import car and not car images cars = get_file_names('./data/vehicles', pattern='*.png') not_cars = get_file_names('./data/non-vehicles', pattern='*.png') # Calculate car features & not-car features car_features = get_feature(cars, workers=4) not_car_features = get_feature(not_cars, workers=4) # Create data set x = np.vstack((car_features, not_car_features)).astype(np.float64) y = np.concatenate( (np.ones(len(car_features)), np.zeros(len(not_car_features)))) # SVC classifier clf = SupportVectorMachineClassifier() clf.train(x, y) # Vehicle Tracker car_tracker = VehicleTracker(looking_back_frames=10) output = 'output.mp4'
if __name__ == "__main__": warnings.filterwarnings("ignore") file_path = "~/Documents/pyTest/HMMELM/ok_data/S01R01.txt" raw_data = utils.read_data_from(file_path=file_path) print("Have read data:", raw_data.shape) # segmentation fs = 64 window_time = 2 overlap_time = 0 frames = utils.sliding_window(raw_data, window=fs * window_time, overlap=fs * overlap_time) # extract features features = [] for frame in frames: feature = utils.get_feature(frame=frame, col_range=[1, 2, 3]) features.append(feature) features = np.array(features) pre_length = 4 split_data = utils.abandon_pre_fog(features[:, -1], pre_length) # train GMM-HMM frame_num = 4 fog_indices = split_data['fog_indices'] pre_fog_indices = split_data['pre_fog_indices'] normal_indices = split_data['normal_indices'] normal_down_indices = utils.down_sampling(normal_indices, 2 * len(fog_indices)) fog_train, fog_test = train_test_split(fog_indices, test_size=0.1, random_state=0)
def __init__(self, batch_size, num_unroll_steps, embeddings, embedding_size, rnn_size, num_rnn_layers, max_grad_norm, attention_matrix_size, l2_reg_lambda=0.0, adjust_weight=False, label_weight=[], is_training=True): """ LSTM-BASED DEEP LEARNING MODELS FOR NON-FACTOID ANSWER SELECTION """ # define input variable self.batch_size = batch_size self.embeddings = embeddings self.embedding_size = embedding_size self.adjust_weight = adjust_weight self.label_weight = label_weight self.rnn_size = rnn_size self.num_rnn_layers = num_rnn_layers self.num_unroll_steps = num_unroll_steps self.max_grad_norm = max_grad_norm self.l2_reg_lambda = l2_reg_lambda self.is_training = is_training self.keep_prob = tf.placeholder(tf.float32, name="keep_drop") self.lr = tf.Variable(0.0, trainable=False) self.new_lr = tf.placeholder(tf.float32, shape=[], name="new_learning_rate") self._lr_update = tf.assign(self.lr, self.new_lr) self.ori_input_quests = tf.placeholder( tf.int32, shape=[None, self.num_unroll_steps]) self.cand_input_quests = tf.placeholder( tf.int32, shape=[None, self.num_unroll_steps]) self.neg_input_quests = tf.placeholder( tf.int32, shape=[None, self.num_unroll_steps]) self.test_input_q = tf.placeholder(tf.int32, shape=[None, self.num_unroll_steps]) self.test_input_a = tf.placeholder(tf.int32, shape=[None, self.num_unroll_steps]) #embedding layer with tf.device("/cpu:0"), tf.name_scope("embedding_layer"): W = tf.Variable(tf.to_float(self.embeddings), trainable=True, name="W") ori_quests = tf.nn.embedding_lookup(W, self.ori_input_quests) cand_quests = tf.nn.embedding_lookup(W, self.cand_input_quests) neg_quests = tf.nn.embedding_lookup(W, self.neg_input_quests) test_q = tf.nn.embedding_lookup(W, self.test_input_q) test_a = tf.nn.embedding_lookup(W, self.test_input_a) #build LSTM network with tf.variable_scope("LSTM_scope", reuse=None): ori_q = biLSTM(ori_quests, self.rnn_size) #ori_q_feat = tf.nn.tanh(max_pooling(ori_q)) with tf.variable_scope("LSTM_scope", reuse=True): cand_a = biLSTM(cand_quests, self.rnn_size) neg_a = biLSTM(neg_quests, self.rnn_size) #cand_q_feat = tf.nn.tanh(max_pooling(cand_a)) #neg_q_feat = tf.nn.tanh(max_pooling(neg_a)) test_q_out = biLSTM(test_q, self.rnn_size) #test_q_out = tf.nn.tanh(max_pooling(test_q_out)) test_a_out = biLSTM(test_a, self.rnn_size) #test_a_out = tf.nn.tanh(max_pooling(test_a_out)) with tf.name_scope("att_weight"): # attention params att_W = { 'Wam': tf.Variable( tf.truncated_normal( [2 * self.rnn_size, attention_matrix_size], stddev=0.1)), 'Wqm': tf.Variable( tf.truncated_normal( [2 * self.rnn_size, attention_matrix_size], stddev=0.1)), 'Wms': tf.Variable( tf.truncated_normal([attention_matrix_size, 1], stddev=0.1)) } ori_q_feat, cand_q_feat = get_feature(ori_q, cand_a, att_W) ori_nq_feat, neg_q_feat = get_feature(ori_q, neg_a, att_W) test_q_out, test_a_out = get_feature(test_q_out, test_a_out, att_W) self.ori_cand = feature2cos_sim(ori_q_feat, cand_q_feat) self.ori_neg = feature2cos_sim(ori_q_feat, neg_q_feat) self.loss, self.acc = cal_loss_and_acc(self.ori_cand, self.ori_neg) self.test_q_a = feature2cos_sim(test_q_out, test_a_out)