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')
