def model_predict(model_filename: str, data_filename: str):
data = read_dev_data(data_filename)
models = read_model(model_filename)
sent_model, auth_model = build_model(models)
print(sent_model.weights["excellent"])
predictions = model_predict_data(sent_model, auth_model, data)
write_output(predictions)
def main(test_pattern, model_dir, alphabet, print_tags, print_score):
alphabet = list(alphabet)
# Open feature and transition params
theta = read_model(model_dir)
# Read test data
data = read_data(test_pattern)
test(theta, data, alphabet, print_tags, print_score)
def main(test_pattern, model_dir, alphabet, print_tags, print_score): alphabet = list(alphabet) # Open feature and transition params theta = read_model(model_dir) # Read test data data = read_data(test_pattern) test(theta, data, alphabet, print_tags, print_score)
def main():
im_rows, im_cols = 64, 64
batch_size = 64
nb_epoch = 10
random_state = 51
colors = 1
validation_size = 2 # 26 total drivers
nb_models = 10
dropout = 0
train_data, train_target, driver_id, _ = util.load_train_data(im_rows,
im_cols, colors)
drivers_list_train = drivers_list[0:nb_drivers-validation_size]
x_train, y_train, train_index = util.copy_selected_drivers(train_data, \
train_target, driver_id, drivers_list_train)
drivers_list_valid = drivers_list[nb_drivers-validation_size:nb_drivers]
x_valid, y_valid, test_index = util.copy_selected_drivers(train_data, \
train_target, driver_id, drivers_list_valid)
print 'Train: {} Valid: {}'.format(len(x_train), len(x_valid))
print 'Train drivers: {} '.format(drivers_list_train)
print 'Test drivers: {}'.format(drivers_list_valid)
models = []
predictions = np.zeros((len(y_valid), 10))
for i in range(nb_models):
if sys.argv[1] == "load":
if len(sys.argv) < 3:
print "Please enter the name of the model to load"
else:
models.append(util.read_model(sys.argv[2]+'_'+str(i)))
elif sys.argv[1] == "basic_v1":
models.append(basic_net.Basic_Net_v1(im_rows, im_cols, colors))
elif sys.argv[1] == "basic_v2":
models.append(basic_net.Basic_Net_v2(im_rows, im_cols, colors))
elif sys.argv[1] == "fancy_v1":
models.append(fancy_net.Fancy_Net_v1(im_rows, im_cols, colors))
elif sys.argv[1] == "fancy_v2":
models.append(fancy_net.Fancy_Net_v2(im_rows, im_cols, colors))
if sys.argv[1] != "load":
# shuffle the training data and remove dropout proportion
x = [x_train[j,:,:,:] for j in range(x_train.shape[0])]
y = [y_train[j,:] for j in range(y_train.shape[0])]
xy = zip(x, y)
random.shuffle(xy)
xy = xy[int(len(xy)*dropout):]
x, y = zip(*xy)
x = np.asarray(x)
y = np.asarray(y)
models[i].fit(x, y, batch_size=batch_size, \
nb_epoch=nb_epoch, verbose=1, validation_data=(x_valid, y_valid))
util.save_model(models[i], sys.argv[1]+'_'+str(im_rows)+'_'+str(i))
softmax = models[i].predict(x_valid, batch_size=128, verbose=1)
for j in range(len(y_valid)):
predictions[j, np.argmax(softmax[j])] += 1
top1 = 0
for i in range(len(y_valid)):
if np.argmax(y_valid[i]) == np.argmax(predictions[i, :]):
top1 += 1
top1 /= float(len(y_valid))
print 'Final top 1 accuracy: {}, rows: {} cols: {} epoch: {}'\
.format(top1, im_rows, im_cols, nb_epoch)
import crf
import util
theta = util.read_model('model') # model directory
data = util.read_data(
'data/test*') # regex pattern of binarized text image files,
# each sequence (word, sentence, etc.) in its own file
alphabet = list('etainoshrd') # list of all possible character labels
predictions = crf.predict(theta, data, alphabet)
for prediction in predictions:
print ''.join(prediction)
#!/usr/bin/env python
import sys
import cobra
import os
import util
import pickle
infname, ext = os.path.splitext(sys.argv[1])
m = util.read_model(sys.argv[1])
medium = pickle.load(open(sys.argv[2], 'rb'))
m.medium = medium
util.write_model(m, f'minimal_medium_{infname}{ext}')
if m.slim_optimize() > m.tolerance:
print(f'overwritten medium for {infname} - still viable')
else:
print(f'overwritten medium for {infname} - no longer viable')
#!/usr/bin/env python
import sys
import cobra
from cobra.flux_analysis.variability import find_blocked_reactions
import os
import util
infname = sys.argv[1]
model_name, ext = os.path.splitext(infname)
m = util.read_model(infname)
fba_orig = m.slim_optimize()
rxns_orig = len(m.reactions)
mets_orig = len(m.metabolites)
tol_orig = m.tolerance
m.remove_reactions(find_blocked_reactions(m))
m, _ = cobra.manipulation.delete.prune_unused_metabolites(m)
fba_cons = m.slim_optimize()
rxns_cons = len(m.reactions)
mets_cons = len(m.metabolites)
if abs(fba_orig - fba_cons) > (fba_orig * tol_orig):
print(f'ERROR: {infname}: difference in FBA objective is too large')
sys.exit(1)
if ext == '.json':
cobra.io.save_json_model(m, f'consistent_{model_name}{ext}')
def main():
im_rows, im_cols = 64, 64
batch_size = 64
nb_epoch = 15
random_state = 51
colors = 1
validation_size = 2 # 26 total drivers
n_neighbors = 5 # Number of neighbors for KNN
train_data, train_target, driver_id, _ = util.load_train_data(
im_rows, im_cols, colors)
drivers_list_train = drivers_list[0:nb_drivers - validation_size]
x_train, y_train, train_index = util.copy_selected_drivers(train_data, \
train_target, driver_id, drivers_list_train)
drivers_list_valid = drivers_list[nb_drivers - validation_size:nb_drivers]
x_valid, y_valid, test_index = util.copy_selected_drivers(train_data, \
train_target, driver_id, drivers_list_valid)
print 'Train: {} Valid: {}'.format(len(x_train), len(x_valid))
print 'Train drivers: {} '.format(drivers_list_train)
print 'Test drivers: {}'.format(drivers_list_valid)
if sys.argv[1] == "load":
if len(sys.argv < 3):
print "Please enter the name of the model to load"
else:
model = util.read_model(sys.argv[2])
elif sys.argv[1] == "basic_v1":
model = basic_net.Basic_Net_v1(im_rows, im_cols, colors)
elif sys.argv[1] == "basic_v2":
model = basic_net.Basic_Net_v2(im_rows, im_cols, colors)
elif sys.argv[1] == "fancy_v1":
model = fancy_net.Fancy_Net_v1(im_rows, im_cols, colors)
elif sys.argv[1] == "fancy_v2":
model = fancy_net.Fancy_Net_v2(im_rows, im_cols, colors)
if sys.argv[1] != "load":
model.fit(x_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, \
verbose=1, validation_data=(x_valid, y_valid))
util.save_model(model, sys.argv[1] + '_' + str(im_rows))
score = model.evaluate(x_valid, y_valid, verbose=0)
predictions_valid = model.predict(x_valid, batch_size=128, verbose=1)
top1 = 0
for i in range(len(y_valid)):
if np.argmax(y_valid[i]) == np.argmax(predictions_valid[i]):
top1 += 1
top1 /= float(len(y_valid))
print 'Final log_loss: {}, top 1 accuracy: {}, rows: {} cols: {} epoch: {}'\
.format(score, top1, im_rows, im_cols, nb_epoch)
# K-Nearest Neighbors
interm_layer_model = util.build_interm_model(model)
interm_train = interm_layer_model.predict(x_train, batch_size=batch_size, \
verbose=1)
knn = KNeighborsClassifier(n_neighbors=n_neighbors)
knn.fit(interm_train, y_train)
interm_valid = interm_layer_model.predict(x_valid,
batch_size=128,
verbose=1)
knn_predictions = knn.predict(interm_valid)
knn_score = 0
for i in range(len(y_valid)):
if np.argmax(y_valid[i]) == np.argmax(knn_predictions[i]):
knn_score += 1
knn_score /= float(len(y_valid))
print 'K Nearest Neighbors accuracy with {} neighbors: {}'\
.format(n_neighbors, knn_score)
import crf
import util
theta = util.read_model('model') # model directory
data = util.read_data('data/test*') # regex pattern of binarized text image files,
# each sequence (word, sentence, etc.) in its own file
alphabet = list('etainoshrd') # list of all possible character labels
predictions = crf.predict(theta, data, alphabet)
for prediction in predictions:
print ''.join(prediction)