def train_and_report(model_name, kernel, warp, ard): dataset_dir = os.path.join(MODEL_DIR, DATASET) try: os.makedirs(dataset_dir) except OSError: print "skipping output folder" for fold in xrange(10): fold_dir = os.path.join(SPLIT_DIR, DATASET, str(fold)) train_data = np.loadtxt(os.path.join(fold_dir, 'train')) test_data = np.loadtxt(os.path.join(fold_dir, 'test')) params_file = None output_dir = os.path.join(dataset_dir, str(fold)) try: os.makedirs(output_dir) except OSError: print "skipping output folder" if ard: iso_dir = output_dir.replace('True', 'False') params_file = os.path.join(iso_dir, 'params') gp = util.train_gp_model(train_data, kernel, warp, ard, params_file) util.save_parameters(gp, os.path.join(output_dir, 'params')) util.save_gradients(gp, os.path.join(output_dir, 'grads')) metrics = util.get_metrics(gp, test_data) util.save_metrics(metrics, os.path.join(output_dir, 'metrics')) util.save_cautious_curves(gp, test_data, os.path.join(output_dir, 'curves')) util.save_predictions(gp, test_data, os.path.join(output_dir, 'preds')) asym_metrics = util.get_asym_metrics(gp, test_data) util.save_asym_metrics(asym_metrics, os.path.join(output_dir, 'asym_metrics')) gc.collect(2) # buggy GPy has allocation cycles...
def detect(model=None, config=None): torch.backends.cudnn.benchmark = True config = parse_detect_config() if not config else config transform = A.Compose([ A.LongestMaxSize(max_size=config.IMAGE_SIZE), A.PadIfNeeded(min_height=config.IMAGE_SIZE, min_width=config.IMAGE_SIZE, border_mode=cv2.BORDER_CONSTANT, value=0), A.Normalize(), M.MyToTensorV2(), ], additional_targets={ 'right_img': 'image', }) dataset = LoadImages(config.JSON, transform=transform) if not model: model = Model() model = model.to(DEVICE) _, model = load_checkpoint(model, config.CHECKPOINT_FILE, DEVICE) model.eval() for img, predictions, path in generatePredictions(model, dataset): plot_predictions([img], predictions, [path]) save_predictions([img], predictions, [path])
def main(): model = build_model() model.summary() train_images, targets = load_train_data() train_images = train_images.reshape(-1, 28, 28, 1) targets = to_categorical(targets, 10) callbacks = [ EarlyStopping(monitor='val_acc', patience=3), ModelCheckpoint('keras_convnet', save_best_only=True, save_weights_only=True), ] model.fit(train_images, targets, batch_size=64, epochs=100, validation_split=0.1, callbacks=callbacks) model.load_weights('keras_convnet') test_images = load_test_data() test_images = test_images.reshape(-1, 28, 28, 1) predictions = model.predict(test_images) labels = np.argmax(predictions, 1) save_predictions(labels, 'keras_convnet.csv')
def train_and_report(model_name, kernel, warp, ard, likelihood='gaussian'): dataset_dir = os.path.join(MODEL_DIR, DATASET) try: os.makedirs(dataset_dir) except OSError: print "skipping output folder" for fold in xrange(10): fold_dir = os.path.join(SPLIT_DIR, DATASET, str(fold)) train_data = np.loadtxt(os.path.join(fold_dir, 'train')) test_data = np.loadtxt(os.path.join(fold_dir, 'test')) output_dir = os.path.join(dataset_dir, str(fold)) params_file = None if ard: iso_dir = output_dir.replace('True', 'False') params_file = os.path.join(iso_dir, 'params') gp = util.train_gp_model(train_data, kernel, warp, ard, params_file, likelihood=likelihood) metrics = util.get_metrics(gp, test_data) try: os.makedirs(output_dir) except OSError: print "skipping output folder" util.save_parameters(gp, os.path.join(output_dir, 'params')) util.save_metrics(metrics, os.path.join(output_dir, 'metrics')) #util.save_gradients(gp, os.path.join(output_dir, 'grads')) util.save_cautious_curves(gp, test_data, os.path.join(output_dir, 'curves')) util.save_predictions(gp, test_data, os.path.join(output_dir, 'preds'))
def main(): # Debugging models and example use data_filename = os.path.join(config.train_processed_path, config.examples_filename) images_filename = os.path.join(config.train_processed_path, "image_examples.csv") blobs_filename = os.path.join(config.train_processed_path, "blob_examples.csv") labels_filename = os.path.join(config.train_processed_path, config.labels_filename) hot_labels_filename = os.path.join(config.train_processed_path, config.hot_labels_filename) data = pd.read_csv(data_filename, skiprows=0) print data.shape images = pd.read_csv(images_filename, skiprows=0) print images.shape blobs = pd.read_csv(blobs_filename, skiprows=0, usecols=range(1, 4)) print blobs.shape labels = pd.read_csv(labels_filename, skiprows=0) hot_labels = pd.read_csv(hot_labels_filename, skiprows=0) # example = data.loc[13].reshape((1, data.loc[0].shape[0])) # label = labels.loc[13].reshape((1, labels.loc[0].shape[0])) examples = pd.concat([data, images, blobs], axis=1) print examples.shape c = 4 m = 2 maxiter = 300 # Based on sklearn k-means default error = 0.0001 # Based on sklearn k-means default seed = 142 # Seed for randomizer used by clusterer FCM = SoftCluster(c, m, maxiter, error, init=None, seed=seed) FCM.fit(examples, labels) FCM.save_centers(os.path.join(config.cluster_centers_path, config.cluster_centers_filename)) predictions = FCM.predict(examples) # predictions = np.log(predictions) util.save_predictions(predictions, os.path.join(config.cluster_predictions_path, config.cluster_predictions_filename)) naiveBayesClass(data, labels) print predictions # LDA = LinearDiscriminantAnalysis() # LDA.fit(examples, labels) # print LDA.classes_ # predictions = LDA.predict_proba(examples) print predictions.shape print hot_labels.shape NN = Neural(predictions.shape[1], config.num_hidden_neurons, config.output_size) NN.build() shuffled_pred, shuffled_labels = shuffle(predictions, hot_labels.as_matrix(), random_state=142) NN.fit(shuffled_pred, shuffled_labels, config.batch_size, config.epochs)
def main(): model = ConvNet() print(model) images, targets = load_train_data() train_images, val_images, train_targets, val_targets = train_test_split(images, targets, test_size=0.1) train_images = torch.from_numpy(train_images).unsqueeze(1) train_targets = torch.from_numpy(train_targets) train_dataset = TensorDataset(train_images, train_targets) train_loader = DataLoader(train_dataset, batch_size=64) val_images = torch.from_numpy(val_images).unsqueeze(1) val_targets = torch.from_numpy(val_targets) val_dataset = TensorDataset(val_images, val_targets) val_loader = DataLoader(val_dataset, batch_size=64) optimizer = Adam(model.parameters(), lr=1e-3) best_val_acc = -1 patience_count = 0 for epoch in range(1, 1001): loss, acc = train_model(model, optimizer, train_loader) val_loss, val_acc = evaluate_model(model, val_loader) patience_count += 1 if val_acc > best_val_acc: best_val_acc = val_acc patience_count = 0 torch.save(model, 'pytorch_convnet') msg = 'Epoch {:04d} - loss: {:.6g} - acc: {:.6g} - val_loss: {:.6g} - val_acc: {:.6g}' print(msg.format(epoch, loss, acc, val_loss, val_acc)) if patience_count > 3: break model = torch.load('pytorch_convnet') images = load_test_data() images = torch.from_numpy(images).unsqueeze(1) test_dataset = TensorDataset(images, torch.zeros(images.size(0))) test_loader = DataLoader(test_dataset) labels = [] for images, _ in test_loader: images = Variable(images.float(), requires_grad=False) outputs = model.forward(images) labels.extend(torch.max(outputs.data, 1)[1]) save_predictions(np.array(labels), 'pytorch_convnet.csv')
def predict_for_kaggle_test_set(nn,filename): """ this function is responsible for saving test predictions to given filename. Parameters: nn : object filename: str Returns: (no-returns) """ kaggle_test_set = util.load_test_data() preds = [] for i in kaggle_test_set: preds.append(nn.predict(i, show=False)) util.save_predictions(preds, filename)
test_prediction3=restore_model(3) #=====ensemble for two======== #final_pred=np.concatenate((np.matmul(test_prediction1,weight_pred_1),np.matmul(test_prediction2,weight_pred_2)),axis=1) #final_pred=np.matmul(test_prediction1,weight_pred_1)+np.matmul(test_prediction2,weight_pred_2) #======ensemble for three====== #Concatenation approach #final_pred=np.concatenate((np.matmul(test_prediction1,weight_pred_1),np.matmul(test_prediction2,weight_pred_2),np.matmul(test_prediction3,weight_pred_3)),axis=1) #Summation approach final_pred=np.matmul(test_prediction1,weight_pred_1)+np.matmul(test_prediction2,weight_pred_2)+np.matmul(test_prediction3,weight_pred_3) #=======no ensemble============ #final_pred=test_prediction1 #============================== final_pred_index = np.argmax(final_pred,1) save_predictions(base_dir,final_pred_index, file_predictions) # Calculate score golden_stance = pd.read_csv(base_dir+"/"+"test_stances_labeled.csv") prediction_stance=pd.read_csv(base_dir+"/"+"predictions_test.csv") competition_grade,agree_recall,disagree_recall,discuss_recall,unrelated_recall, agree_precision, disagree_precision, discuss_precision, unrelated_precision,all_recall, f1_agree, f1_disagree, f1_discuss, f1_unrelated, F1m=report_score(golden_stance['Stance'],prediction_stance['Prediction']) Grade.append(competition_grade) Agree_recall.append(agree_recall) Disagree_recall.append(disagree_recall) Discuss_recall.append(discuss_recall) Unrelated_recall.append(unrelated_recall)
def main(): # Placeholders images = tf.placeholder(tf.float32, [None, 28, 28]) targets = tf.placeholder(tf.int32, [None, 10]) keep_prob = tf.placeholder(tf.float32) # Weights W_conv1 = weight_variable([3, 3, 1, 16]) b_conv1 = bias_variable([16]) W_conv2 = weight_variable([3, 3, 16, 32]) b_conv2 = bias_variable([32]) hidden_units = (7 * 7 * 32 + 10) // 2 W_hidden = weight_variable([7 * 7 * 32, hidden_units]) b_hidden = bias_variable([hidden_units]) W_output = weight_variable([hidden_units, 10]) b_output = bias_variable([10]) weights = [ W_conv1, b_conv1, W_conv2, b_conv2, W_hidden, b_hidden, W_output, b_output, ] # Forward x = tf.reshape(images, [-1, 28, 28, 1]) x = max_pool(tf.nn.relu(conv2d(x, W_conv1) + b_conv1)) x = max_pool(tf.nn.relu(conv2d(x, W_conv2) + b_conv2)) x = tf.reshape(x, [-1, 7 * 7 * 32]) x = tf.nn.dropout(x, keep_prob) x = tf.nn.relu(tf.matmul(x, W_hidden) + b_hidden) x = tf.nn.dropout(x, keep_prob) outputs = tf.matmul(x, W_output) + b_output # Loss loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=outputs, labels=targets)) optimizer = tf.train.AdamOptimizer(1e-3).minimize(loss) # Accuracy correct = tf.equal(tf.argmax(outputs, 1), tf.argmax(targets, 1)) accuracy = tf.reduce_mean(tf.cast(correct, tf.float32)) with tf.Session() as sess: batch_size = 64 # Training sess.run(tf.global_variables_initializer()) saver = tf.train.Saver(weights, max_to_keep=1) X, y = load_train_data() y = one_hot(y) X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.1) best_val_acc = -1 patience_count = 0 for epoch in range(1, 1001): X_train, y_train = shuffle(X_train, y_train) X_batches = np.array_split(X_train, X_train.shape[0] // batch_size) y_batches = np.array_split(y_train, y_train.shape[0] // batch_size) loss_sum = acc_sum = 0.0 for X_batch, y_batch in zip(X_batches, y_batches): loss_batch, acc_batch, _ = sess.run( [loss, accuracy, optimizer], feed_dict={ images: X_batch, targets: y_batch, keep_prob: 0.5 }) loss_sum += loss_batch * X_batch.shape[0] acc_sum += acc_batch * X_batch.shape[0] acc = acc_sum / X.shape[0] X_batches = np.array_split(X_val, X_val.shape[0] // batch_size) y_batches = np.array_split(y_val, y_val.shape[0] // batch_size) acc_sum = 0.0 for X_batch, y_batch in zip(X_batches, y_batches): acc_batch = sess.run(accuracy, feed_dict={ images: X_batch, targets: y_batch, keep_prob: 1.0 }) acc_sum += acc_batch * X_batch.shape[0] val_acc = acc_sum / X_val.shape[0] patience_count += 1 if val_acc > best_val_acc: best_val_acc = val_acc patience_count = 0 saver.save(sess, 'tensorflow_convnet') msg = 'Epoch {:04d} - loss: {:.6g} - acc: {:.6g} - val_acc: {:.6g}' print(msg.format(epoch, loss_sum / X.shape[0], acc, val_acc)) if patience_count > 3: break # Prediction saver.restore(sess, 'tensorflow_convnet') X = load_test_data() X_batches = np.array_split(X, X.shape[0] // batch_size) labels = [] for X_batch in X_batches: y = sess.run(outputs, feed_dict={images: X_batch, keep_prob: 1.0}) labels.extend(np.argmax(y, 1)) save_predictions(np.array(labels), 'tensorflow_convnet.csv')
# validation_steps=len(valid_dataloader), # ) # train model on dida data to fit better history = model.fit_generator( train_dataloader, steps_per_epoch=len(train_dataloader), epochs=EPOCHS, callbacks=callbacks, validation_data=valid_dataloader, validation_steps=len(valid_dataloader), ) # Create and save result images model.load_weights('best_model.h5') save_predictions(valid_dataset, model) # # Visualization of results on test dataset # n = 5 # ids = np.random.choice(np.arange(len(test_dataset)), size=n) # # for i in ids: # # image, gt_mask = test_dataset[i] # image = np.expand_dims(image, axis=0) # pr_mask = model.predict(image).round() # # visualize( # image=denormalize(image.squeeze()), # gt_mask=gt_mask[..., 0].squeeze(),
eval_loss.append(loss.item()) print('[EVALUATE {}/{}] Eval Loss: {:.4f}'.format( batch_idx+1, len(eval_loader), loss.item() )) print('FINAL EVAL LOSS: {:.4f}'.format(np.mean(eval_loss))) with torch.no_grad(): all_loss = [] for batch_idx, (img, mask, img_fns) in enumerate(all_loader): img = img.cuda() mask = mask.cuda() pred = model(img) loss = criterion(pred, mask) all_loss.append(loss.item()) pred_mask = torch.argmax(F.softmax(pred, dim=1), dim=1) pred_mask = torch.chunk(pred_mask, chunks=args.eval_batch_size, dim=0) save_predictions(pred_mask, img_fns, 'output') print('[PREDICT {}/{}] Loss: {:.4f}'.format( batch_idx+1, len(all_loader), loss.item() )) print('FINAL PREDICT LOSS: {:.4f}'.format(np.mean(all_loss)))
test_loss = [] for batch_idx, (img, mask, img_fns) in enumerate(test_loader): model = load_best_weights(model, 'saved_model') img = img.cuda() mask = mask.cuda() pred = model(img) loss = criterion(pred, mask) test_loss.append(loss.item()) pred_mask = torch.argmax(F.softmax(pred, dim=1), dim=1) pred_mask = torch.chunk(pred_mask, chunks=args.batch_size, dim=0) save_predictions(pred_mask, img_fns, 'test_predictions') print('[Testing {}/{}] Test Loss: {:.4f}'.format( batch_idx + 1, len(test_loader), loss.item())) print('Final Test Loss: {:.4f}'.format(np.mean(test_loss))) fig = plt.figure(figsize=(15, 15)) cmap = mpl.colors.ListedColormap([ 'black', 'blue', 'red', 'green', 'brown', 'cyan', 'yellow', 'royalblue' ]) cmap.set_over('royalblue') cmap.set_under('black') bounds = [0, 1, 2, 3, 4, 5, 6, 7, 8] cmaplist = [cmap(i) for i in range(cmap.N)]
def main(): dirs = setup_dirs(args) num_songs = args.num_songs datasplit_csv = args.datasplit_csv # if no csv_filename provided, split data and generate a csv file if datasplit_csv == None: datasplit_dict = split_data( os.path.join(dirs['data_path'], 'TPD 11kHz'), num_songs) else: df = pd.read_csv(datasplit_csv, usecols=['filename', 'train', 'train_dev', 'test']) datasplit_dict = df.to_dict('list') example_duration = args.example_duration time_window_duration = args.time_window_duration sampling_frequency = args.sampling_frequency loss_domain = args.loss_domain use_equal_loudness = args.equal_loudness_curve num_hidden_units = args.hidden_units num_layers = args.layers unidirectional_flag = args.unidirectional batch_norm_flag = args.batch_norm cell_type = args.cell_type batch_size = args.batch_size dropout = args.dropout learning_rate = args.learning_rate if args.layer_lock_out == None: layer_lock_out = [] else: layer_lock_out = [int(item) for item in args.layer_lock_out.split(',')] layer_lock_out_mask = [(not ((l + 1) in layer_lock_out)) for l in range(num_layers)] num_epochs = args.epochs epoch_save_interval = args.epoch_save_interval gpus = args.gpus # train or evaluate the model # load data X_train, Y_train, filenames = load_data(dirs['data_path'], datasplit_dict, 'train', example_duration, time_window_duration, sampling_frequency, loss_domain, use_equal_loudness) # evaluate model on training and train_dev data X_train_dev, Y_train_dev, filenames = load_data( dirs['data_path'], datasplit_dict, 'train_dev', example_duration, time_window_duration, sampling_frequency, loss_domain, use_equal_loudness) input_shape = (X_train.shape[1], X_train.shape[2]) output_shape = (Y_train.shape[1], Y_train.shape[2]) # create & compile model if not 'model' in vars(): with tf.device('/cpu:0'): elc = np.array([]) if use_equal_loudness: elc = weight_loss(sampling_frequency, output_shape) model = MidiNet(input_shape, output_shape, loss_domain, elc, num_hidden_units, num_layers, unidirectional_flag, cell_type, batch_norm_flag, dropout, layer_lock_out_mask) if gpus >= 2: model = multi_gpu_model(model, gpus=gpus) if (loss_domain == "frequency"): opt = Nadam(clipvalue=1, lr=learning_rate) if (use_equal_loudness): model.compile(loss=weighted_spectrogram_loss, optimizer=opt) else: model.compile(loss=spectrogram_loss, optimizer=opt) else: model.compile(loss='mean_squared_error', optimizer='adam') print(model.summary()) if args.load_last: # load last set of weights # list all the .ckpt files in a tuple (epoch, model_name) tree = os.listdir(dirs["weight_path"]) files = [(int(file.split('.')[0].split('-')[1][1:]), file.split('.h5')[0]) for file in tree] # find the properties of the last checkpoint files.sort(key=lambda t: t[0]) target_file = files[-1] model_epoch = target_file[0] model_name = target_file[1] model_filename = model_name + ".h5" print("[*] Loading " + model_filename + " and continuing from epoch " + str(model_epoch), flush=True) model_path = os.path.join(dirs['weight_path'], model_filename) model.load_weights(model_path) starting_epoch = int(model_epoch) + 1 else: starting_epoch = 0 if args.mode == 'train': # train the model & run a checkpoint callback checkpoint_filename = 'model-e{epoch:03d}-loss{loss:.4f}.hdf5' checkpoint_filepath = os.path.join(dirs['model_path'], checkpoint_filename) checkpoint = ModelCheckpoint(checkpoint_filepath, monitor='loss', verbose=1, period=epoch_save_interval) # save weights cp_wt_filename = 'weights-e{epoch:03d}-loss{loss:.4f}.h5' cp_wt_filepath = os.path.join(dirs['weight_path'], cp_wt_filename) wtcheckpoint = ModelCheckpoint(cp_wt_filepath, monitor='loss', verbose=1, period=epoch_save_interval, save_weights_only=True) csv_filename = 'training_log.csv' csv_filepath = os.path.join(dirs['current_run'], csv_filename) csv_logger = CSVLogger(csv_filepath, append=True) callbacks_list = [checkpoint, csv_logger, wtcheckpoint] history_callback = model.fit(X_train, Y_train, epochs=num_epochs + starting_epoch, initial_epoch=starting_epoch, batch_size=batch_size, callbacks=callbacks_list, validation_data=(X_train_dev, Y_train_dev), verbose=1) # save the loss history loss_history = history_callback.history["loss"] save_dict = {'loss_history': loss_history} filepath = os.path.join(dirs['current_run'], "loss_history.mat") scipy.io.savemat(filepath, save_dict) # save the final model last_epoch = history_callback.epoch[-1] filename = 'model-e' + str(last_epoch) + '.hdf5' filepath = os.path.join(dirs['model_path'], filename) model.save(filepath) Y_train_dev_pred = model.predict(X_train_dev, batch_size=batch_size) Y_train_pred = model.predict(X_train, batch_size=batch_size) # save audio print('save train audio') save_audio(dirs['pred_path'], 'train_dev', Y_train_dev, Y_train_dev_pred, sampling_frequency, loss_domain, use_equal_loudness) save_audio(dirs['pred_path'], 'train', Y_train, Y_train_pred, sampling_frequency, loss_domain, use_equal_loudness) # save predictions save_predictions(dirs['pred_path'], 'train_dev', X_train_dev, Y_train_dev, Y_train_dev_pred) save_predictions(dirs['pred_path'], 'train', X_train, Y_train, Y_train_pred) elif args.mode == 'predict': # if args.predict_data_dir == 'test_dev': # data_path = dirs['test_dev_path'] # elif args.predict_data_dir == 'test': # data_path = dirs['test_path'] X_data, Y_data, filenames = load_data(dirs['data_path'], datasplit_dict, 'test', example_duration, time_window_duration, sampling_frequency, loss_domain, use_equal_loudness) # evaluate model on test data print('[*] Making predictions', flush=True) Y_data_pred = model.predict(X_data, batch_size=batch_size) # save audio save_audio(dirs['pred_path'], args.predict_data_dir, Y_data, Y_data_pred, sampling_frequency, loss_domain, use_equal_loudness) # save predictions save_predictions(dirs['pred_path'], args.predict_data_dir, X_data, Y_data, Y_data_pred) print('save test audio')