def video(): model = get_model() cap = cv2.VideoCapture(0) cv2.namedWindow('OCR') last_seen = "Number: NaN" while(True): ret, frame = cap.read() gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) thresh = binarize(gray) key = cv2.waitKey(1) contours = find_digits(thresh) draw_contours(frame, contours) if key == ord('p'): digits = insert_into_center(resize_digits(contours)) if digits: X = preprocess(digits) prediction = np.argmax(model.predict(X), axis=1) last_seen = "Number: " + "".join(map(str, prediction)) # print last_seen # plt.imshow(np.hstack(tuple(digits)), cmap=plt.cm.binary) # plt.show() cv2.putText(frame, last_seen, (10, 100), cv2.FONT_HERSHEY_SIMPLEX, 2, 0) cv2.imshow('OCR', frame) if key == ord('q'): break cap.release() cv2.destroyAllWindows()
def get_update(Ws_s, bs_s): x, fx = train.get_model(Ws_s, bs_s) # Ground truth (who won) y = T.vector('y') # Compute loss (just log likelihood of a sigmoid fit) y_pred = sigmoid(fx) loss = -( y * T.log(y_pred) + (1 - y) * T.log(1 - y_pred)).mean() # Metrics on the number of correctly predicted ones frac_correct = ((fx > 0) * y + (fx < 0) * (1 - y)).mean() # Updates learning_rate_s = T.scalar(dtype=theano.config.floatX) momentum_s = T.scalar(dtype=theano.config.floatX) updates = train.nesterov_updates(loss, Ws_s + bs_s, learning_rate_s, momentum_s) f_update = theano.function( inputs=[x, y, learning_rate_s, momentum_s], outputs=[loss, frac_correct], updates=updates, ) return f_update
def get_predict(Ws_s, bs_s): x, p = train.get_model(Ws_s, bs_s) predict = theano.function( inputs=[x], outputs=p) return predict
def static_image(): model = get_model() frame = get_sample_image() contours = find_digits(binarize(frame.copy())) draw_contours(frame, contours) digits = insert_into_center(resize_digits(contours)) X = preprocess(digits) print np.argmax(model.predict(X), axis=1) plt.imshow(np.hstack(tuple(digits)), cmap=plt.cm.binary) plt.show()
def get_model_from_pickle(fn): f = open(fn) Ws, bs = pickle.load(f) Ws_s, bs_s = train.get_parameters(Ws=Ws, bs=bs) x, p = train.get_model(Ws_s, bs_s) predict = theano.function( inputs=[x], outputs=p) return predict
# evaluate import torch from data.shapeNet import ShapeDiffDataset from modules.configUtils import get_args from modules.cuboid import get_cuboid_corner from train import get_model from utils.visualization import plot_pc_mayavi params = get_args() dev = torch.device("cuda") if torch.cuda.is_available() else torch.device( "cpu") model_path = "C:\\Users\\sharon\\Documents\\Research\\models\\model_1011_1134.pt" model, _ = get_model() model.load_state_dict(torch.load(model_path, map_location=dev)) model.eval() train_dataset = ShapeDiffDataset(params.train_path, params.bins, dev=dev, seed=0) train_loader = torch.utils.data.DataLoader(train_dataset, params.batch_size, shuffle=False) if __name__ == '__main__': total_acc = 0. for i, (x, d, h) in enumerate(train_loader): if i == 1: break
thickness=10): # Adds a bounding box to an image. draw = ImageDraw.Draw(image) im_width, im_height = image.size (left, right, top, bottom) = (xmin, xmax, ymin, ymax) draw.line( [(left, top), (left, bottom), (right, bottom), (right, top), (left, top)], width=thickness, ) if __name__ == "__main__": # initialize model and optimizer num_classes = 2 # 1 class (wheat head) + background model = train.get_model(num_classes) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") # load existing checkpoint (comment if none existing) atepoch = 10 PATH = f"/mnt/disks/extra/model_v1/model_weights_v1_{atepoch}.tar" checkpoint = torch.load(PATH, map_location=device) model.load_state_dict(checkpoint['model_state_dict']) root = "/home/ali/kaggle-wheat-detection/test" df = output(model, root=root) df.to_csv("/mnt/disks/extra/model_v1/submission_{atepoch}.csv", index=False) # display a case: img_filename = "51b3e36ab.jpg" img_path = os.path.join(root, img_filename)
from prepare_data import load_and_preprocess_image def get_class_id(image_root): id_cls = {} for i, item in enumerate(os.listdir(image_root)): if os.path.isdir(os.path.join(image_root, item)): id_cls[i] = item return id_cls if __name__ == '__main__': # GPU settings gpus = tf.config.list_physical_devices('GPU') if gpus: for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) model = get_model() model.load_weights(filepath=save_model_dir) image_raw = tf.io.read_file(filename=test_image_dir) image_tensor = load_and_preprocess_image(image_raw) image_tensor = tf.expand_dims(image_tensor, axis=0) pred = model(image_tensor, training=False) idx = tf.math.argmax(pred, axis=-1).numpy()[0] id_cls = get_class_id("./original_dataset") print("The predicted category of this picture is: {}".format(id_cls[idx]))
def grid_search(word_embs=None, ent_embs=None, logger=None, datasets=None, model_dir=None, train_dataset=None, args=None, file_stores=None): param_grid = {'dp': [0.1, 0.2, 0.3, 0.5, 0.8], 'hidden_size': [1000, 2000, 3000], 'lr': [1e-2, 5e-2, 1e-3, 5e-2], 'wd': [1e-4, 1e-5], 'num_candidates': [128, 256], 'prop_gen_candidates': [0.5, 0.75, 1], 'other_optim': ['rmsprop', 'adam'] } grid_results_dict = {} pd_results = list() data_types = args.data_types.split(',') for param_dict in list(ParameterSampler(param_grid, 50)): for k, v in param_dict.items(): assert k in args.__dict__ args.__dict__[k] = v for dataset in list(datasets.values()) + [train_dataset]: dataset.num_cand_gen = int(param_dict['num_candidates'] * param_dict['prop_gen_candidates']) dataset.num_candidates = param_dict['num_candidates'] model = get_model(args, word_embs, ent_embs, logger) train_loader = train_dataset.get_loader(batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, drop_last=False) logger.info("Train loader created.There will be {} batches.".format(len(train_loader))) logger.info("GRID SEARCH PARAMS : {}".format(param_dict)) result_key = tuple(param_dict.items()) grid_results_dict[result_key] = {data_type: [] for data_type in data_types} logger.info("Starting validation for untrained model.....") validators = {} for data_type in data_types: loader = datasets[data_type].get_loader(batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, drop_last=False) logger.info(f'Len loader {data_type} : {len(loader)}') validators[data_type] = Validator(loader=loader, args=args, file_stores=file_stores) trainer = Trainer(loader=train_loader, args=args, validator=validators, model=model, model_type='yamada', grid_results_dict=grid_results_dict, result_key=result_key) logger.info("Starting Training.....") print() best_model, best_results = trainer.train() logger.info("Finished Training") pd_results.append({**param_dict, **best_results}) print('PD RESULTS: {}'.format(pd_results)) df = pd.DataFrame(pd_results) df.to_csv(join(model_dir, 'hyper_df.csv')) for k, v in grid_results_dict.items(): print(k) print(v) with open(join(model_dir, 'grid_search_results.pickle'), 'wb') as f: pickle.dump(grid_results_dict, f) del model, trainer, train_loader, loader, validators, best_model, best_results torch.cuda.empty_cache() gc.collect() time.sleep(3) return grid_results_dict, pd_results
def main(FLAGS): print("[%s: INFO] Start Evaluation: %s" % (datetime.now(), str(FLAGS))) with tf.Graph().as_default(): valid_set = Dataset( FLAGS.valid_file, num_data=NUM_CLASSES * NUM_TEST_PER_CLASS, # batch_size=FLAGS.batch_size, batch_size=10, for_training=False) # valid_set = Dataset(TRAIN_TFRECORD, # num_data=NUM_CLASSES*NUM_TRAIN_PER_CLASS, # batch_size=FLAGS.batch_size, # for_training=False) model = get_model(FLAGS) with tf.Session() as sess: saver = tf.train.Saver() # validity of checkpoint if not tf.train.checkpoint_exists(FLAGS.checkpoint): print("[%s: ERROR] Checkpoint does not exist! : %s" % (datetime.now(), FLAGS.checkpoint)) return saver.restore(sess, FLAGS.checkpoint) ### test! for thres in [0.2, 0.3, 0.4, 0.5]: print("localization_thres: %.2f" % thres) top_1_loc, gt_known_loc, top_1_class = inference( model, sess, valid_set, localization_thres=thres, vis_thres=0.9, multi_crop=FLAGS.do_multi_crop, do_vis=FLAGS.do_vis) print("Top-1 Loc: %.4f, GT-known Loc: %.4f, Top-l Clas: %.4f" % (top_1_loc, gt_known_loc, top_1_class)) print("---------------------") # inference(model, sess, valid_set, # localization_thres=0.3, # vis_thres=0.9, # multi_crop=False, # do_vis=False) # print("---------------------") # inference(model, sess, valid_set, localization_thres=0.3, vis_thres=0.9) # print("---------------------") # inference(model, sess, valid_set, localization_thres=0.4, vis_thres=0.9) # print("---------------------") # inference(model, sess, valid_set, localization_thres=0.5, vis_thres=0.9) # loss, accuracy = validation(model, sess, valid_set) # print("[%s: INFO] valuation Result of testset: loss: %.3f, accuracy: %.3f" % # (datetime.now(), loss, accuracy)) print("[%s: INFO] Done" % (datetime.now()))
def get_predict(Ws_s, bs_s): x, p = train.get_model(Ws_s, bs_s) predict = theano.function(inputs=[x], outputs=p) return predict
pbar.update(1) if generate_txt: answer_file.close() return np.mean(aucs), np.mean(mrrs), np.mean(ndcg5s), np.mean(ndcg10s) if __name__ == '__main__': # avoid circular import from train import parse_arguments, get_model, restore_checkpoint parser = argparse.ArgumentParser(description='Eval params') config = parse_arguments(parser) model = get_model(config) model, is_sucessfull = restore_checkpoint(config, model, is_train=False) if not is_sucessfull: print('No checkpoint file found!') exit() prediction_folder = f'{config.val_dir}/{config.model_name}' Path(prediction_folder).mkdir(parents=True, exist_ok=True) if config.model_name.startswith('DM'): auc, mrr, ndcg5, ndcg10 = evaluate_dm(config, model, config.dev_dir, config.train_dir, generate_txt=True, txt_path=prediction_folder +
def train_epochs(epochs, batch_size, token_size, hidden_size, embedding_size): # Read data x_train_full = open("../input/wili-2018/x_train.txt").read().splitlines() y_train_full = open("../input/wili-2018/y_train.txt").read().splitlines() x_test_full = open("../input/wili-2018/x_test.txt").read().splitlines() y_test_full = open("../input/wili-2018/y_test.txt").read().splitlines() # Get encoders char_vocab = Dictionary().char_dict(x_train_full) lang_vocab = Dictionary().lang_dict(y_train_full) # Convert data x_train_idx, y_train_idx = Encoder().encode_labeled_data( x_train_full, y_train_full, char_vocab, lang_vocab) x_test_idx, y_test_idx = Encoder().encode_labeled_data( x_test_full, y_test_full, char_vocab, lang_vocab) x_train, x_val, y_train, y_val = train_test_split(x_train_idx, y_train_idx, test_size=0.15) train_data = [(x, y) for x, y in zip(x_train, y_train)] val_data = [(x, y) for x, y in zip(x_val, y_val)] test_data = [(x, y) for x, y in zip(x_test_idx, y_test_idx)] device = torch.device("cuda" if torch.cuda.is_available() else "cpu") if not torch.cuda.is_available(): logging.warning("WARNING: CUDA is not available.") criterion = torch.nn.CrossEntropyLoss(reduction='sum') bidirectional = False ntokens = len(char_vocab) nlabels = len(lang_vocab) pad_index = char_vocab.pad_index model, optimizer = get_model( ntokens, embedding_size, hidden_size, nlabels, bidirectional, pad_index, device) with mlflow.start_run(): mlflow.log_metrics( { "train samples": len(train_data), "val samples": len(val_data), "test samples": len(test_data) } ) mlflow.log_dict(lang_vocab.token2idx, "lang_vocab.json") mlflow.log_dict(char_vocab.token2idx, "char_vocab.json") params = {'epochs': epochs, 'batch_size': batch_size, 'token_size': token_size, 'hidden_size': hidden_size, 'embedding_size': embedding_size} mlflow.log_dict(params, "params.json") logging.info(f'Training cross-validation model for {epochs} epochs') for epoch in range(epochs): train_acc = train(model, optimizer, train_data, batch_size, token_size, criterion, device) logging.info(f'| epoch {epoch:02d} | train accuracy={train_acc:.1f}%') validate(model, val_data, batch_size, token_size, device, lang_vocab, tag='val', epoch=epoch) validate(model, test_data, batch_size, token_size, device, lang_vocab, tag='test', epoch=epoch) mlflow.pytorch.log_model(model, f'{epoch:02d}.model') mlflow.pytorch.log_model(model, 'model')
def main(*kargs, **kwargs): # ============ Parse global parameters ============ get_kwargs(kwargs) train_fname = kwargs['train'] test_fname = kwargs['test'] result_fname = kwargs['output'] embeds_fname = kwargs['embeds'] logger_fname = kwargs['logger'] warm_start = kwargs['warm_start'] model_warm_start = [model.lower() for model in kwargs['model_warm_start']] config = kwargs['config'] train_clean = kwargs['train_clean'] train_labels = kwargs['train_labels'] test_clean = kwargs['test_clean'] embeds_clean = kwargs['embeds_clean'] result_path = './catboost/' if not os.path.exists(result_path): os.mkdir(result_path) # cnn_model_file = 'data/cnn.h5' # lstm_model_file = 'data/lstm_model.h5' # gru_model_file = 'data/gru_model.h5' # concat_model_file = 'data/concat.h5' # cnn_model_file = 'data/cnn.h5' # lr_model_file = 'data/{}_logreg.bin' # meta_catboost_model_file = 'data/{}_meta_catboost.bin' # ==== Create logger ==== logger = Logger(logging.getLogger(), logger_fname) # ==== Load data ==== logger.info('Loading data...') test_df = load_data(test_fname) train_x = np.load(train_clean) test_x = np.load(test_clean) embedding_matrix = np.load(embeds_clean) train_y = np.load(train_labels) target_labels = [ 'toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate' ] num_classes = len(target_labels) # ============= Load params of models ============= params = Params(config) models = params.get('models') val_predictions_list = [] test_predictions_list = [] # ============ Train models ============= for model_name in models: model_func = get_model(model_name, embedding_matrix, params) # =========== Training on folds ============ batch_size = params.get(model_name).get('batch_size') logger.debug('Starting {0} training on folds...'.format(model_name)) models, val_predictions = train_folds_catboost( train_x, train_y, params.get(model_name).get('num_folds'), batch_size, model_func, params.get(model_name).get('optimizer'), logger=logger) val_predictions = np.concatenate(val_predictions, axis=0) val_predictions_list.append(val_predictions) logger.debug('Predicting results...') test_predictions = [] for fold_id, model in enumerate(models): test_predictions.append( model.predict(test_x, batch_size=batch_size)) final_test_predictions = np.ones(test_predictions[0].shape) for fold_predict in test_predictions: final_test_predictions *= fold_predict final_test_predictions **= (1. / len(test_predictions)) test_predictions_list.append(final_test_predictions) x_test = np.concatenate(test_predictions_list, axis=1) test_predicts_path = os.path.join(result_path, "catboost_x_test.npy") np.save(test_predicts_path, x_test) x_meta = np.concatenate(val_predictions_list, axis=1) val_predicts_path = os.path.join(result_path, "catboost_x_train.npy") np.save(val_predicts_path, x_meta) x_train_meta, x_val_meta, y_train_meta, y_val_meta = train_test_split( x_meta, train_y[:x_meta.shape[0]], test_size=0.20, random_state=42) meta_model = CatBoost(target_labels, loss_function='Logloss', iterations=1000, depth=6, learning_rate=0.03, rsm=1) meta_model.fit(x_train_meta, y_train_meta, eval_set=(x_val_meta, y_val_meta), use_best_model=True) #y_hat_meta = meta_model.predict_proba(x_val_meta) #metrics_meta = get_metrics(y_val_meta, y_hat_meta, target_labels) logger.info('Applying models...') final_predictions = np.array(meta_model.predict_proba(x_test)).T # ====Save results==== logger.info('Saving results...') test_ids = test_df["id"].values test_ids = test_ids.reshape((len(test_ids), 1)) test_predicts = pd.DataFrame(data=final_predictions, columns=target_labels) test_predicts["id"] = test_ids test_predicts = test_predicts[["id"] + target_labels] submit_path = os.path.join(result_path, "{0}.csv".format('catboost_folds')) test_predicts.to_csv(submit_path, index=False)
def main(): # dataset hyperparams sequence_length = 50 augment_dataset = False # uncomment the below for dataset collection max_note = 127 instruments = ['t'] sample_rate = 12 encoding_size = len(instruments) * (max_note + 1) * 2 + (sample_rate * 2) num_notes = len(instruments) * (max_note + 1) encoder, decoder = utils.build_convert_dict(max_note, instruments, sample_rate) # X, y = datacollector.collect_solo_songs(encoder, max_note, len(instruments), sample_rate, sequence_length, # augment_dataset) X = pickle.load(open("x.pickle", "rb")) y = pickle.load(open('y.pickle', 'rb')) # pickle.dump(X, pickle_x) # pickle_x.close() # pickle.dump(y, pickle_y) # pickle_y.close() X_t, X_test, y_t, y_test = train_test_split(X, y, test_size=0.02, random_state=49) X_train, X_val, y_train, y_val = train_test_split(X_t, y_t, test_size=0.02, random_state=7) print(X.shape, X_t.shape, X_test.shape, X_train.shape, X_val.shape) # # uncomment the below for training # train.train(X_train, y_train, encoding_size) # # uncomment the below for evaluation weights_name = 'weights.49-0.8625.hdf5' # evaluate.evaluate(X_train, y_train, X_val, y_val, X_test, y_test, encoding_size, weights_name) model = train.get_model(X_test, encoding_size) model.load_weights(weights_name) print('weights loaded') y_pred = model.predict(X_test) # y_pred = y_test # print(y_test) # print(y_pred) print('y_test') print(y_test.shape) print(y_test.argmax(axis=1).shape) # print(type(y_test)) print("y_pred") print(y_pred.shape) print(y_pred.argmax(axis=1).shape) # print(type(y_pred)) a = y_pred.argmax(axis = 1) # print(a) y_pred_hardmax = np.zeros(y_pred.shape) y_pred_hardmax[np.arange(a.shape[0]),a] = 1 # print(y_pred_hardmax) # print(list(y_test.argmax(axis=0))) # print(list(y_pred_hardmax.argmax(axis=0))) print('AAAA') evaluate.plot_confusion_matrix('confusion_matrix.png', y_test.argmax(axis=1), y_pred.argmax(axis=1))
from config import * from data_utils import * from train import get_model max_len = 25 word2id, embedding_matrix, vocab = load_embeddings("glove.6B.100d.txt", 100) model = get_model(len(word2id.keys()), embedding_dims, embedding_matrix, max_len, emb_dropout, rnn_units, rnn_dropout, recurrent_dropout) model.load_weights("weights.h5") while True: text = input("Enter sentence:") X = preprocess(text, word2id) print(X) print(model.predict(pad_sequence(X, max_len)))
from train import get_model if __name__ == '__main__': # GPU settings gpus = tf.config.experimental.list_physical_devices('GPU') if gpus: for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) # get the original_dataset train_dataset, valid_dataset, test_dataset, train_count, valid_count, test_count = generate_datasets( ) # print(train_dataset) # load the model model = get_model(flag=0) model.load_weights(filepath=config.save_model_dir) # Get the accuracy on the test set loss_object = tf.keras.metrics.SparseCategoricalCrossentropy() test_loss = tf.keras.metrics.Mean() test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy() @tf.function def test_step(images, labels): predictions = model(images) t_loss = loss_object(labels, predictions) test_loss(t_loss) test_accuracy(labels, predictions)