def main(): init_logger(_user_logs_file) logging.info('======================start==========================') train_df, test_df = load_data() # split train and valid train_df, val_df, train_X, val_X, test_X = split_train_val( train_df, test_df) train_y = train_df['target'].values val_y = val_df['target'].values # tokenizing and padding train_X, val_X, test_X = token_sentence(train_X, val_X, test_X) logging.info(train_df['target'].count()) train_df.groupby('target').count() train_df['target'].plot.hist( bins=2, title='Distribution of label in trainning set') # build the model build_model() model = build_model() # train the model and plot train_model(model, train_X, train_y, val_X, val_y) # validate the model val_model(model, val_X, val_y) # predict test pred__test_y = model.predict([test_X], batch_size=1024, verbose=1) logging.info('=========done===========')
def main(): init_logger(_user_logs_file) logging.info('======================start==========================') train_x, train_y, val_x, val_y, test_x, test_id = load_data() train_x, val_x, test_x = preprocess(train_x, val_x, test_x) train(train_x, train_y, val_x, val_y) eval(val_x, val_y) logging.info('Done!')
def preprocess(): logger.setLevel(logging.INFO) init_logger(logging.INFO) config = Config('.', 'temp') logger.info('building dict...') build_dict(config)
def preprocess(): logger.setLevel(logging.INFO) init_logger(logging.INFO, 'temp.log.txt', 'w') config = Config('.', 'temp') logger.info('building dict...') build_dict('data/train.txt', config) logger.info('generating data...') generate_data('data/train.txt', config.train_data) generate_data('data/dev.txt', config.valid_data) generate_data('data/test_1.txt', config.test_data, is_test=True)
def main(): parser = argparse.ArgumentParser() parser.add_argument('-config', type=str, default='config/aishell.yaml') parser.add_argument('-log', type=str, default='eval.log') parser.add_argument('-mode', type=str, default='retrain') opt = parser.parse_args() configfile = open(opt.config) config = AttrDict(yaml.load(configfile, Loader=yaml.FullLoader)) exp_name = os.path.join('egs', config.data.name, 'exp', config.model.type, config.training.save_model) if not os.path.isdir(exp_name): os.makedirs(exp_name) logger = init_logger(os.path.join(exp_name, opt.log)) os.environ["CUDA_VISIBLE_DEVICES"] = config.evaling.gpus config.evaling.num_gpu = num_gpus(config.evaling.gpus) logger.info('Number of gpu:' + str(config.evaling.num_gpu)) num_workers = 6 * (config.evaling.num_gpu if config.evaling.num_gpu > 0 else 1) batch_size = config.data.batch_size * config.evaling.num_gpu if config.evaling.num_gpu > 0 else config.data.batch_size dev_dataset = AudioDataset(config.data, 'test') dev_sampler = Batch_RandomSampler(len(dev_dataset), batch_size=batch_size, shuffle=config.data.shuffle) validate_data = AudioDataLoader(dataset=dev_dataset, num_workers=num_workers, batch_sampler=dev_sampler) logger.info('Load Test Set!') if config.evaling.num_gpu > 0: torch.cuda.manual_seed(config.evaling.seed) torch.backends.cudnn.deterministic = True else: torch.manual_seed(config.evaling.seed) logger.info('Set random seed: %d' % config.evaling.seed) if config.evaling.num_gpu == 0: checkpoint = torch.load(config.evaling.load_model, map_location='cpu') else: checkpoint = torch.load(config.evaling.load_model) logger.info(str(checkpoint.keys())) with torch.no_grad(): model = new_model(config, checkpoint).eval() beam_rnnt_decoder = build_beam_rnnt_decoder(config, model) beamctc_decoder = build_ctc_beam_decoder(config, model) if config.evaling.num_gpu > 0: model = model.cuda() _ = eval(config, model, validate_data, logger, beamctc_decoder=beamctc_decoder, beam_rnnt_decoder=beam_rnnt_decoder)
from src.utils import init_logger LOGGER = init_logger()
def train(): """ Train AdaBoost on given classifier. """ with open(r"config.yaml") as f: config = yaml.load(f, Loader=yaml.FullLoader) train_path = full_path(config["dataset"]["train"]) test_path = full_path(config["dataset"]["test"]) ft_name = config["featurizers"]["featurizer"] ft_config = config["featurizers"][ft_name] clf_config = config["classification"] train_len = config["dataset"]["train_examples"] kfold = config["classification"]["k-fold"] utils.ask_for_load(config["always_load"]) utils.init_logger(config) # Read images from dataset X_train, y_train, X_test, y_test = dataset.load_asl_alphabet( train_path, test_path, train_len=train_len) N, H, W = X_train.shape logging.info("Loaded {} training images of size ({}, {})".format( N, H, W)) N, H, W = X_test.shape logging.info("Loaded {} test images of size ({}, {})".format(N, H, W)) # Extract features based on config featurizer = Featurizer() if ft_name == "fft": features = featurizer.fft(X_train, ft_config) test_features = featurizer.fft(X_test, ft_config) elif ft_name == "rgb": features = featurizer.fft(X_train, ft_config) test_features = featurizer.fft(X_test, ft_config) elif ft_name == "dwt": features = featurizer.dwt(X_train, ft_config) test_features = featurizer.dwt(X_test, ft_config) elif ft_name == "sift": features = featurizer.sift(X_train, ft_config) test_features = featurizer.sift(X_test, ft_config) elif ft_name == "surf": features = featurizer.surf(X_train, ft_config) test_features = featurizer.surf(X_test, ft_config) elif ft_name == "orb": features = featurizer.orb(X_train, ft_config) test_features = featurizer.orb(X_test, ft_config) N, M = features.shape logging.info("Extracted {} training features of length {}".format( N, M)) N, M = test_features.shape logging.info("Extracted {} test features of length {}".format(N, M)) # Cross validations clf = ASLClassifier(clf_config) xval_res = clf.cross_val_score(features, y_train, kfold, 11) logging.critical(xval_res) logging.critical(np.mean(xval_res)) # Predictions on test images start = time.time() clf.fit(features, y_train) end = time.time() logging.info("Fit model in {} seconds".format(end - start)) start = time.time() pred = clf.predict(test_features) end = time.time() logging.info("Predicted test dataset in {} seconds".format(end - start)) # Plot each prediction and ground truth for test images for y_true, y_pred, img in zip(y_test, pred, X_test): plt.imshow(img, cmap="gray") plt.title("True: {} Predicted: {}".format( utils.number_to_label(y_true), utils.number_to_label(y_pred))) plt.show() logging.critical(pred) logging.critical(y_test) logging.critical(np.sum(pred == y_test) / len(pred))
get_Into_User_Page from src.file_processing import Merge from src.map import Draw_Map if __name__ == '__main__': data_dir = 'data' log_dir = 'log' picture_dir = 'picture' Exist_or_Make_Dir(data_dir) Exist_or_Make_Dir(log_dir) Exist_or_Make_Dir(picture_dir) # 创建logger cur_time = time.strftime("%Y%m%d%H%M%S", time.localtime()) log_file_path = os.path.join(log_dir, 'spider_log' + cur_time + '.txt') logger = init_logger(log_file=log_file_path) # 获取chorme chrome_options = get_Chorme_Option() # 获取课程类有关信息 # 参数配置 main_url = 'https://www.icourse163.org' class_cate_col_name = '类名' class_cate_url_col_name = '链接' school_page_url = main_url + '/university/view/all.htm' categroys = [ '计算机', '外语', '理学', '工学', '经济管理', '心理学', '文史哲', '艺术设计', '医药卫生', '教育教学', '法学', '农林园艺', '音乐与舞蹈' ]
import wave import deepspeech import numpy as np import os from src.utils import init_logger logger = init_logger("SpeechtoText") from application_properties import ApplicationProperties as props class SpeechtoText: def __init__(self, model_file_path, lm_file_path=None, trie_file_path=None, lm_alpha=0.75, lm_beta=1.85, beam_width=500): self.model = deepspeech.Model(model_file_path, beam_width) if lm_file_path and trie_file_path and lm_alpha and lm_beta: self.model.enableDecoderWithLM(lm_file_path, trie_file_path, lm_alpha, lm_beta) logger.info("Model sample rate : {}".format(self.model.sampleRate())) def get_text_from_speech(self, audio_file_path): w = wave.open(audio_file_path, 'r') audio_file_rate = w.getframerate() audio_file_frames = w.getnframes() audio_file_buffer = w.readframes(audio_file_frames) if audio_file_rate != self.model.sampleRate():
def main(): parser = argparse.ArgumentParser() parser.add_argument('-config', type=str, default='config/aishell.yaml') parser.add_argument('-log', type=str, default='train.log') parser.add_argument('-mode', type=str, default='retrain') opt = parser.parse_args() configfile = open(opt.config) config = AttrDict(yaml.load(configfile, Loader=yaml.FullLoader)) exp_name = os.path.join('egs', config.data.name, 'exp', config.model.type, config.training.save_model) if not os.path.isdir(exp_name): os.makedirs(exp_name) logger = init_logger(os.path.join(exp_name, opt.log)) shutil.copyfile(opt.config, os.path.join(exp_name, 'config.yaml')) logger.info('Save config info.') os.environ["CUDA_VISIBLE_DEVICES"] = config.training.gpus config.training.num_gpu = num_gpus(config.training.gpus) num_workers = 6 * (config.training.num_gpu if config.training.num_gpu > 0 else 1) batch_size = config.data.batch_size * config.training.num_gpu if config.training.num_gpu > 0 else config.data.batch_size train_dataset = LmDataset(config.data, 'train') train_sampler = Batch_RandomSampler(len(train_dataset), batch_size=batch_size, shuffle=config.data.shuffle) training_data = AudioDataLoader(dataset=train_dataset, num_workers=num_workers, batch_sampler=train_sampler) logger.info('Load Train Set!') dev_dataset = LmDataset(config.data, 'dev') dev_sampler = Batch_RandomSampler(len(dev_dataset), batch_size=batch_size, shuffle=config.data.shuffle) validate_data = AudioDataLoader(dataset=dev_dataset, num_workers=num_workers, batch_sampler=dev_sampler) logger.info('Load Dev Set!') if config.training.num_gpu > 0: torch.cuda.manual_seed(config.training.seed) torch.backends.cudnn.deterministic = True else: torch.manual_seed(config.training.seed) logger.info('Set random seed: %d' % config.training.seed) if config.model.type == "transducer": model = Transducer(config.model) elif config.model.type == "ctc": model = CTC(config.model) elif config.model.type == "lm": model = LM(config.model) else: raise NotImplementedError if config.training.load_model: if config.training.num_gpu == 0: checkpoint = torch.load(config.training.load_model, map_location='cpu') else: checkpoint = torch.load(config.training.load_model) logger.info(str(checkpoint.keys())) load_model(model, checkpoint) logger.info('Loaded model from %s' % config.training.new_model) if config.training.load_encoder or config.training.load_decoder: if config.training.load_encoder: checkpoint = torch.load(config.training.load_encoder) model.encoder.load_state_dict(checkpoint['encoder']) logger.info('Loaded encoder from %s' % config.training.load_encoder) if config.training.load_decoder: checkpoint = torch.load(config.training.load_decoder) model.decoder.load_state_dict(checkpoint['decoder']) logger.info('Loaded decoder from %s' % config.training.load_decoder) if config.training.num_gpu > 0: model = model.cuda() if config.training.num_gpu > 1: device_ids = list(range(config.training.num_gpu)) model = torch.nn.DataParallel(model, device_ids=device_ids) logger.info('Loaded the model to %d GPUs' % config.training.num_gpu) # n_params, enc, dec = count_parameters(model) # logger.info('# the number of parameters in the whole model: %d' % n_params) # logger.info('# the number of parameters in the Encoder: %d' % enc) # logger.info('# the number of parameters in the Decoder: %d' % dec) # logger.info('# the number of parameters in the JointNet: %d' % # (n_params - dec - enc)) optimizer = Optimizer(model.parameters(), config.optim) logger.info('Created a %s optimizer.' % config.optim.type) if opt.mode == 'continue': if not config.training.load_model: raise Exception( "if mode is 'continue', need 'config.training.load_model'") optimizer.load_state_dict(checkpoint['optimizer']) start_epoch = checkpoint['epoch'] logger.info('Load Optimizer State!') else: start_epoch = 0 # create a visualizer if config.training.visualization: visualizer = SummaryWriter(os.path.join(exp_name, 'log')) logger.info('Created a visualizer.') else: visualizer = None logger.info(model) for epoch in range(start_epoch, config.training.epochs): train(epoch, config, model, training_data, optimizer, logger, visualizer) save_name = os.path.join( exp_name, '%s.epoch%d.chkpt' % (config.training.save_model, epoch)) save_model(model, optimizer, config, save_name) logger.info('Epoch %d model has been saved.' % epoch) if config.training.eval_or_not: _ = eval(epoch, config, model, validate_data, logger, visualizer) if epoch >= config.optim.begin_to_adjust_lr: optimizer.decay_lr() # early stop if optimizer.lr < 1e-6: logger.info('The learning rate is too low to train.') break logger.info('Epoch %d update learning rate: %.6f' % (epoch, optimizer.lr)) logger.info('The training process is OVER!')
def main(): os.makedirs(config.temp_dir, exist_ok=True) os.makedirs(config.result_dir, exist_ok=True) os.makedirs(config.train_log_dir, exist_ok=True) logger.setLevel(logging.INFO) init_logger(logging.INFO, 'temp.log.txt', 'w') logger.info('preparing data...') config.word_2_id, config.id_2_word = read_json_dict(config.vocab_dict) config.vocab_size = min(config.vocab_size, len(config.word_2_id)) config.oov_vocab_size = min(config.oov_vocab_size, len(config.word_2_id) - config.vocab_size) embedding_matrix = None if args.do_train: if os.path.exists(config.glove_file): logger.info('loading embedding matrix from file: {}'.format( config.glove_file)) embedding_matrix, config.word_em_size = load_glove_embedding( config.glove_file, list(config.word_2_id.keys())) logger.info('shape of embedding matrix: {}'.format( embedding_matrix.shape)) else: if os.path.exists(config.glove_file): with open(config.glove_file, 'r', encoding='utf-8') as fin: line = fin.readline() config.word_em_size = len(line.strip().split()) - 1 data_reader = DataReader(config) evaluator = Evaluator('tgt') logger.info('building model...') model = get_model(config, embedding_matrix) saver = tf.train.Saver(max_to_keep=10) if args.do_train: logger.info('loading data...') train_data = data_reader.read_train_data() valid_data = data_reader.read_valid_data() logger.info(log_title('Trainable Variables')) for v in tf.trainable_variables(): logger.info(v) logger.info(log_title('Gradients')) for g in model.gradients: logger.info(g) with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) else: logger.info('initializing from scratch...') tf.global_variables_initializer().run() train_writer = tf.summary.FileWriter(config.train_log_dir, sess.graph) valid_log_history = run_train(sess, model, train_data, valid_data, saver, evaluator, train_writer) save_json( valid_log_history, os.path.join(config.result_dir, config.current_model, 'valid_log_history.json')) if args.do_eval: logger.info('loading data...') valid_data = data_reader.read_valid_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids, valid_loss, valid_accu = run_evaluate( sess, model, valid_data) logger.info( 'average valid loss: {:>.4f}, average valid accuracy: {:>.4f}' .format(valid_loss, valid_accu)) logger.info(log_title('Saving Result')) save_outputs(predicted_ids, config.id_2_word, config.valid_data, config.valid_outputs) results = evaluator.evaluate(config.valid_data, config.valid_outputs, config.to_lower) save_json(results, config.valid_results) else: logger.info('model not found!') if args.do_test: logger.info('loading data...') test_data = data_reader.read_test_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids = run_test(sess, model, test_data) logger.info(log_title('Saving Result')) save_outputs(predicted_ids, config.id_2_word, config.test_data, config.test_outputs) results = evaluator.evaluate(config.test_data, config.test_outputs, config.to_lower) save_json(results, config.test_results) else: logger.info('model not found!')
def train(config, model_cls=DRHGCN): time_stamp = time.asctime() datasets = DRDataset(dataset_name=config.dataset_name, drug_neighbor_num=config.drug_neighbor_num, disease_neighbor_num=config.disease_neighbor_num) log_dir = os.path.join(f"{config.comment}", f"{config.split_mode}-{config.n_splits}-fold", f"{config.dataset_name}", f"{config.seed}",f"{model_cls.__name__}", f"{time_stamp}") config.log_dir = log_dir config.n_drug = datasets.drug_num config.n_disease = datasets.disease_num config.size_u = datasets.drug_num config.size_v = datasets.disease_num config.gpus = 1 if torch.cuda.is_available() else 0 config.pos_weight = datasets.pos_weight config.time_stamp = time_stamp logger = init_logger(log_dir) logger.info(pformat(vars(config))) config.dataset_type = config.dataset_dype if config.dataset_type is not None else model_cls.DATASET_TYPE cv_spliter = CVDataset(datasets, split_mode=config.split_mode, n_splits=config.n_splits, drug_idx=config.drug_idx, disease_idx=config.disease_idx, train_fill_unknown=config.train_fill_unknown, global_test_all_zero=config.global_test_all_zero, seed=config.seed, dataset_type=config.dataset_type) pl.seed_everything(config.seed) scores, labels, edges, split_idxs = [], [], [], [] metrics = {} start_time_stamp = time.time() for split_id, datamodule in enumerate(cv_spliter): # if split_id not in [4, 5]: # continue config.split_id = split_id split_start_time_stamp = time.time() datamodule.prepare_data() train_loader = datamodule.train_dataloader() val_loader = datamodule.val_dataloader() config.pos_weight = train_loader.dataset.pos_weight model = model_cls(**vars(config)) model = model.cuda() if config.gpus else model if split_id==0: logger.info(model) logger.info(f"begin train fold {split_id}/{len(cv_spliter)}") train_fn(config, model, train_loader=train_loader, val_loader=val_loader) logger.info(f"end train fold {split_id}/{len(cv_spliter)}") save_file_format = os.path.join(config.log_dir, f"{config.dataset_name}-{config.split_id} fold-{{auroc}}-{{aupr}}.mat") score, label, edge, metric = test_fn(model, val_loader, save_file_format) # score, label, edge, metric = train_test_fn(model, train_loader, val_loader, save_file_format) metrics[f"{split_id}"] = metric scores.append(score) labels.append(label) edges.append(edge) split_idxs.append(np.ones(len(score), dtype=int)*split_id) logger.info(f"{split_id}/{len(cv_spliter)} folds: {metric}") logger.info(f"{split_id}/{len(cv_spliter)} folds time cost: {time.time()-split_start_time_stamp}") if config.debug: break end_time_stamp = time.time() logger.info(f"total time cost:{end_time_stamp-start_time_stamp}") scores = np.concatenate(scores, axis=0) labels = np.concatenate(labels, axis=0) edges = np.concatenate(edges, axis=1) split_idxs = np.concatenate(split_idxs, axis=0) final_metric = metric_fn.evaluate(predict=scores, label=labels, is_final=True) metrics["final"] = final_metric metrics = pd.DataFrame(metrics).T metrics.index.name = "split_id" metrics["seed"] = config.seed logger.info(f"final {config.dataset_name}-{config.split_mode}-{config.n_splits}-fold-auroc:{final_metric['auroc']}-aupr:{final_metric['aupr']}") output_file_name = f"final-{config.dataset_name}-{config.split_mode}-{config.n_splits}-auroc:{final_metric['auroc']}-aupr:{final_metric['aupr']}-fold" scio.savemat(os.path.join(log_dir, f"{output_file_name}.mat"), {"row": edges[0], "col": edges[1], "score": scores, "label": labels, "split_idx":split_idxs} ) with pd.ExcelWriter(os.path.join(log_dir, f"{output_file_name}.xlsx")) as f: metrics.to_excel(f, sheet_name="metrics") params = pd.DataFrame({key:str(value) for key, value in vars(config).items()}, index=[str(time.time())]) for key, value in final_metric.items(): params[key] = value params["file"] = output_file_name params.to_excel(f, sheet_name="params") logger.info(f"save final results to r'{os.path.join(log_dir, output_file_name)}.mat'") logger.info(f"final results: {final_metric}")
def main(): os.makedirs(config.temp_dir, exist_ok=True) os.makedirs(config.result_dir, exist_ok=True) os.makedirs(config.train_log_dir, exist_ok=True) logger.setLevel(logging.INFO) init_logger(logging.INFO) logger.info('loading dict...') config.src_2_id, config.id_2_src = read_json_dict(config.src_vocab_dict) config.src_vocab_size = min(config.src_vocab_size, len(config.src_2_id)) config.tgt_2_id, config.id_2_tgt = read_json_dict(config.tgt_vocab_dict) config.tgt_vocab_size = min(config.tgt_vocab_size, len(config.tgt_2_id)) data_reader = DataReader(config) evaluator = Evaluator('tgt') logger.info('building model...') model = get_model(config) saver = tf.train.Saver(max_to_keep=10) if args.do_train: logger.info('loading data...') train_data = data_reader.load_train_data() valid_data = data_reader.load_valid_data() logger.info(log_title('Trainable Variables')) for v in tf.trainable_variables(): logger.info(v) logger.info(log_title('Gradients')) for g in model.gradients: logger.info(g) with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) else: logger.info('initializing from scratch...') tf.global_variables_initializer().run() train_writer = tf.summary.FileWriter(config.train_log_dir, sess.graph) valid_log_history = run_train(sess, model, train_data, valid_data, saver, evaluator, train_writer) save_json( valid_log_history, os.path.join(config.result_dir, config.current_model, 'valid_log_history.json')) if args.do_eval: logger.info('loading data...') valid_data = data_reader.load_valid_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids, valid_loss, valid_accu = run_evaluate( sess, model, valid_data) logger.info( 'average valid loss: {:>.4f}, average valid accuracy: {:>.4f}' .format(valid_loss, valid_accu)) logger.info(log_title('Saving Result')) save_outputs(predicted_ids, config.id_2_tgt, config.valid_data, config.valid_outputs) results = evaluator.evaluate(config.valid_data, config.valid_outputs, config.to_lower) save_json(results, config.valid_results) else: logger.info('model not found!') if args.do_test: logger.info('loading data...') test_data = data_reader.load_test_data() with tf.Session(config=sess_config) as sess: model_file = args.model_file if model_file is None: model_file = tf.train.latest_checkpoint( os.path.join(config.result_dir, config.current_model)) if model_file is not None: logger.info('loading model from {}...'.format(model_file)) saver.restore(sess, model_file) predicted_ids = run_test(sess, model, test_data) logger.info(log_title('Saving Result')) save_outputs(predicted_ids, config.id_2_tgt, config.test_data, config.test_outputs) results = evaluator.evaluate(config.test_data, config.test_outputs, config.to_lower) save_json(results, config.test_results) else: logger.info('model not found!')
# model parameters parser.add_argument("--dim_embedding", type=int, default=300, help="") parser.add_argument("--dim_output", type=int, default=2, help="") parser.add_argument("--conv1_size", type=str, default="5_5_8", help="") parser.add_argument("--pool1_size", type=str, default="10_10", help="") parser.add_argument("--conv2_size", type=str, default="3_3_16", help="") parser.add_argument("--pool2_size", type=str, default="5_5", help="") parser.add_argument("--mp_hidden", type=int, default="128", help="") parser.add_argument("--dim_out", type=int, default="2", help="") # parse arguments params = parser.parse_args() # check parameters logger = init_logger(params) params.word2idx, params.glove_weight = load_w2v(params.embedding_path, params.dim_embedding) train_data = MSRPDataset(params.data_path, data_type="train") test_data = MSRPDataset(params.data_path, data_type="test") params.train_data = train_data params.test_data = test_data mp_model = MatchPyramidClassifier(params) mp_model.run()
def run(): yaml_path = full_path(r"config.yaml") with open(yaml_path) as yaml_file: config = yaml.load(yaml_file, Loader=yaml.FullLoader) if config is None: logging.warning("Could not load config file.") return ft_name = config["featurizers"]["featurizer"] ft_config = config["featurizers"][ft_name] clf_config = config["classification"] dt = 1000.0 / config["app"]["fps"] save_path = full_path(config["app"]["save_path"]) utils.init_logger(config) utils.ask_for_load(config["always_load"]) img_num = get_img_num(save_path) featurizer = Featurizer() featurize = choose_featurizer(featurizer, ft_name) classifier = ASLClassifier(clf_config) cap = cv2.VideoCapture(0) font = cv2.FONT_HERSHEY_SIMPLEX font_scale = 2.5 font_color = (0, 0, 255) font_thickness = 2 font_line_type = cv2.LINE_AA if not cap.isOpened(): logging.warning("Cannot open camera") return width = cap.get(cv2.CAP_PROP_FRAME_WIDTH) height = cap.get(cv2.CAP_PROP_FRAME_HEIGHT) xmin = int((height / 2) - 100) xmax = xmin + 200 ymin = int((width / 2) - 100) ymax = ymin + 200 font_y = ymin font_x = int(0.1 * height) buf = Buffer(5) while True: ret, frame = cap.read() if not ret: continue img = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) img = img[xmin:xmax, ymin:ymax] feature = featurize(img[np.newaxis, ...], ft_config) pred = utils.number_to_label(buf.push(classifier.predict(feature)[0])) frame = cv2.putText(frame, pred, (font_y, font_x), font, font_scale, font_color, font_thickness, font_line_type) frame = cv2.rectangle(frame, (ymin, xmin), (ymax, xmax), font_color, font_thickness) cv2.imshow("ASL Classifier", frame) key = cv2.waitKey(int(dt)) & 0xff if key == ord('y'): cv2.imwrite(save_file(save_path, img_num), frame) img_num += 1 elif key == ord('q'): cv2.destroyAllWindows() return