def main():
(train_images, train_labels), (test_images, test_labels) = cnn.init()
train_images, test_images = cnn.preprocess_normalise(
train_images, test_images)
sharpened = cnn.preprocess_contrast(train_images)
img = train_images[2]
plt.imshow(img, cmap="gray")
plt.show()
plt.imshow(sharpened[2], cmap="gray")
plt.show()
train_images += sharpened
model = cnn.create_model(1)
model.summary()
model.compile(
optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
train_images, test_images = cnn.reshape(train_images, test_images)
history = model.fit(train_images,
train_labels,
epochs=3,
validation_data=(test_images, test_labels))
cnn.plot_history(history)
test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print(test_acc)
def _build(self):
config = basic_config.Config()
session_config = tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)
session_config.gpu_options.allow_growth = True
g = tf.Graph()
with g.as_default():
with tf.device(None):
self.sess = tf.Session(config=session_config)
self.input_ids = tf.placeholder(
dtype=tf.int64,
shape=[config.batch_size, config.max_seq_length],
name='input_ids')
self.e1_mas = tf.placeholder(
dtype=tf.int64,
shape=[config.batch_size, config.max_seq_length],
name='e1_mas')
self.e2_mas = tf.placeholder(
dtype=tf.int64,
shape=[config.batch_size, config.max_seq_length],
name='e2_mas')
self.labels, self.probs = cnn.create_model(
input_ids=self.input_ids,
e1_mas=self.e1_mas,
e2_mas=self.e2_mas)
self.sess.run(tf.global_variables_initializer())
def train(code, start, end):
input_data = cnn_data_generater.generate_input_data(code, start, end)
output_data = cnn_data_generater.generate_output_data(code, start, end)
model = cnn.create_model()
cnn.fit(model, input_data, output_data)
cnn.save_model(model, code)
def main():
model = create_model()
model.load_weights(f"models/{MODEL_WEIGHTS}")
# Create argument parser to allow CLI commands
parser = argparse.ArgumentParser(description="A cat-and-dog classifier")
parser.add_argument(
'-i',
'--input',
help="The folder directory in which the image is located on")
parser.add_argument('-s',
'--show',
action="store_true",
help="Display the current image file")
args = parser.parse_args()
# If no argument is provided
if len(sys.argv) <= 1:
parser.print_help()
sys.exit(1)
# Performs the default operation
if args.input:
try:
classify(model, args.input)
# Plot the image
if args.show:
show_image(args.input)
except FileNotFoundError:
print("Error: No such folder. Try again")
sys.exit(1)
def load(event):
global model
model = cnn.create_model()
try:
model.load_weights("models/cnn")
label_message["text"] = "Model loaded successfully"
except Exception:
label_message["text"] = "Model loading failed, no saved models found"
def main(weights_dir, n):
os.makedirs(weights_dir, exist_ok=True)
(x_train, y_train), _ = cifar10.load_data()
model = cnn.create_model(x_train.shape, 10)
for i in range(n):
reset_weights(model)
model.save_weights(os.path.join(weights_dir, '{:03d}'.format(i)))
def train_and_score(network):
model = create_model(network['layers_and_filters'],
network['kernel_size'],
network['activation'], (IMG_SIZE, IMG_SIZE, levels),
network['dropout_rate'],
network['optimizer'],
network['learning_rate'],
output_size=train_Y.shape[1])
fit_one_at_time(model, train_X, train_Y, epochs=network['epochs'])
return score_one_at_time(model, test_X, test_Y)
def train_and_score_in_memory(network):
model = create_model(network['layers_and_filters'],
network['kernel_size'],
network['activation'], (IMG_SIZE, IMG_SIZE, levels),
network['dropout_rate'],
network['optimizer'],
network['learning_rate'],
output_size=train_Y.shape[1])
result = model.fit(x=train_X, y=train_Y, epochs=network['epochs'])
preds = model.predict(test_X)
std_dev = np.std(preds)
preds[preds >= 0.5] = 1
preds[preds < 0.5] = 0
_, _, f1 = scores(preds, test_Y)
return np.mean(f1) + 2 * std_dev
def train(event):
global model
label_message["text"] = "Training in progress..."
label_message.update()
cnn.load_data()
(x_train, y_train), (x_test, y_test) = cnn.get_data()
model = cnn.create_model()
model.fit(x_train,
y_train,
batch_size=100,
validation_data=(x_test, y_test))
label_message["text"] = "Done! Now testing..."
label_message.update()
test_loss, test_acc = model.evaluate(x_test, y_test)
label_message["text"] = "Test accuracy: {}%".format(
round(test_acc * 100, 2))
def __init__(self, args):
config_path = join(THIS_DIR_PATH, args[0])
with open(config_path) as f:
self.config = json.load(f)
self.img_height = self.config['network']['input_height']
self.network = model.create_model(self.config)
if torch.cuda.is_available():
self.network.cuda()
self.dtype = torch.cuda.FloatTensor
self.network.load_state_dict(
torch.load(join(THIS_DIR_PATH,
self.config['model_save_path'])))
else:
self.dtype = torch.FloatTensor
self.network.load_state_dict(
torch.load(join(THIS_DIR_PATH, self.config['model_save_path']),
map_location='cpu'))
self.network.eval()
from configuration import MAX_MEMORY, EPOCHS, MODEL_NAME from cnn import create_model from datetime import datetime ======= from config import MAX_MEMORY, EPOCHS, MP_MN, FB_TIME, LR_TIME from cnn import checkModel >>>>>>> ultrasonic:reinforced.py memory = [] moves = 3 learningRate = 0.9 epsilon = 1.0 epsilon_min = 0.01 epsilon_decay = 0.995 <<<<<<< HEAD:Using-Object-Detection-For-Reward/reinforced.py model = create_model() ======= model = checkModel() >>>>>>> ultrasonic:reinforced.py for i in range(EPOCHS): game_over = False input_img, errors = getImage() errors = False reward = 0 while game_over==False: if np.random.rand() <= epsilon: action = np.random.randint(0, moves, size=1)[0] else: output = model.predict(input_img) action = np.argmax(output[0])
else:
input_shape = (img_width, img_height, 3)
#
training_data_gen = ImageDataGenerator(rescale=1. / 255)
training_data_img = training_data_gen.flow_from_directory(
train_data_dir, batch_size=batch_size, target_size=(img_width, img_height))
validation_data_gen = ImageDataGenerator(rescale=1. / 255)
validation_data_img = validation_data_gen.flow_from_directory(
validation_data_dir,
batch_size=batch_size,
target_size=(img_width, img_height))
#
model = cnn.create_model(input_shape, len(training_data_img.class_indices))
model.compile(optimizer=keras.optimizers.adam(),
loss=keras.losses.categorical_crossentropy,
metrics=['accuracy'])
model.summary()
model.fit_generator(training_data_img,
steps_per_epoch=training_data_img.samples / batch_size,
validation_data=validation_data_img,
validation_steps=validation_data_img.samples / batch_size,
epochs=epochs,
verbose=1)
predictions = model.predict_generator(generator=validation_data_img,
def train(model_type='parallel', label_set='full', drop_unk=False,
word_vecs=None, setup_only=False):
print "Loading data..."
df = sentences_df(SENTENCES_CSV, labels=label_set, drop_unk=drop_unk)
X, y, word2idx, l_enc = load_dataset(df, pad=True)
print "X shape:", X.shape
y_orig = y
y_binary = to_categorical(y)
labels = np.unique(y_orig)
nb_labels = labels.shape[0]
if drop_unk:
label_set_str = label_set + ' (-unk)'
else:
label_set_str = label_set
print "Number of labels: %i [%s]" % (nb_labels, label_set_str)
if nb_labels > 2:
y = y_binary
maxlen = X.shape[1]
vocab_size = len(word2idx) + 1 # 0 masking
if pretrained_embeddings is True:
word_vectors = load_bin_vec(word_vecs, word2idx)
add_unknown_words(word_vectors, word2idx)
embedding_weights = np.zeros((vocab_size+1, emb_dim))
for word, index in word2idx.items():
embedding_weights[index,:] = word_vectors[word]
else:
embedding_weights = None
print "Data loaded."
if setup_only:
cnn = create_model(vocab_size, nb_labels, emb_dim, maxlen,
embedding_weights, filter_hs, nb_filters,
dropout_p, trainable_embeddings,
pretrained_embeddings, model_type=model_type)
return {'X': X,
'y': y,
'word2idx': word2idx,
'l_enc': l_enc,
'y_binary': y_binary,
'labels': labels,
'nb_labels': nb_labels,
'maxlen': maxlen,
'emb_dim': emb_dim,
'vocab_size': vocab_size,
'embedding_weights': embedding_weights,
'cnn': cnn}
params = [('filter_hs',filter_hs), ('nb_filters',nb_filters),
('dropout_p',dropout_p),
('trainable_embeddings',trainable_embeddings),
('pretrained_embeddings',pretrained_embeddings),
('batch_size',batch_size), ('nb_epoch',nb_epoch),
('lr',lr), ('beta_1',beta_1), ('beta_2',beta_2),
('epsilon',epsilon)]
print "\nModel type: %s" % model_type
for (name, value) in params:
print name + ':', value
skf = StratifiedKFold(y_orig, n_folds=10, shuffle=True, random_state=0)
cv_scores = []
for i, (train, test) in enumerate(skf):
start_time = time.time()
cnn = None
cnn = create_model(vocab_size,
nb_labels,
emb_dim,
maxlen,
embedding_weights,
filter_hs,
nb_filters,
dropout_p,
trainable_embeddings,
pretrained_embeddings,
model_type=model_type)
if i == 0:
print_summary(cnn.model.layers)
acc = train_and_test_model(cnn, X[train], y[train], X[test], y[test],
batch_size, nb_epoch,
lr, beta_1, beta_2, epsilon)
cv_scores.append(acc)
train_time = time.time() - start_time
print('\nLabel frequencies in y[test]')
print_label_frequencies((y_orig[test], l_enc))
y_pred = cnn.model.predict(X[test])
y_pred = probas_to_classes(y_pred)
c = Counter(y_pred)
total = float(len(y_pred))
print('\nLabel frequencies in predict(y[test])')
for label, count in c.most_common():
print l_enc.inverse_transform(label), count, count / total
print "fold %i/10 - time: %.2f s - acc: %.4f on %i samples" % \
(i+1, train_time, acc, len(test))
print "Avg cv accuracy: %.4f" % np.mean(cv_scores)
text_train = get_cleaned_text('../data/test_text')
text_test = get_cleaned_text('../data/training_text')
w2v_model = Word2Vec(text_train + text_test,
size=vector_size,
window=5,
min_count=3,
workers=4,
iter=5)
return w2v_model
if __name__ == '__main__':
train_variants = pd.read_csv('../data/training_variants')
test_variants = pd.read_csv('../data/test_variants')
n_text = len(train_variants)
#w2v_model = create_w2v()
#w2v_model = Word2Vec.load('w2v_tt200')
w2v_model = Word2Vec.load('w2v_tt50')
fvec = get_feature_vector2('../data/training_text', train_variants,
n_text + 1)
wvec_size = w2v_model.layer1_size
#nn_model = cnn.test(fvec2)
nn_model = cnn.create_model(fvec[:, :, :], train_variants, epochs=10)
fvec_test = get_feature_vector2('../data/test_text', test_variants)
cnn.predict_cnn(nn_model, fvec_test)
import pickle as pkl
import config
import cnn
data = []
for i, pickle_file in enumerate(
["X_train", "Y_train", "X_validation", "Y_validation", "X_test",
"Y_test"]):
with open("data/" + pickle_file + ".pkl", "rb") as pklf:
data.append(pkl.load(pklf))
X_train, Y_train, X_validation, Y_validation, X_test, Y_test = data
print(X_train.shape)
print("Creating model...")
model = cnn.create_model(config.n_classes, config.image_size,
config.learning_rate)
model.summary()
print("Training the model...")
model.fit(
X_train,
Y_train,
epochs=config.epochs,
batch_size=config.batch_size,
shuffle=True,
validation_data=(X_validation, Y_validation),
)
print("Model trained!")
print("Saving the weights...")
model.save_weights('audio_event_classifier.h5')
print("Weights saved!")
def main():
config_path = sys.argv[1]
with open(config_path) as f:
config = json.load(f)
#Replace next line with initializing the dataset object for both training and validation. Create two HWDataset class objects ...
#Beginning edits of this code.
train_dataset, test_dataset = datasets.get_training_and_validation_datasets(
config['image_root_directory'])
train_dataset = HwDataset(
config['image_root_directory']
) #This doesn't work yet as is--I think it needs to be passed something else
test_dataset = HwDataset(config) #
train_dataloader = DataLoader(train_dataset,
batch_size=8,
shuffle=True,
num_workers=0,
collate_fn=hw_dataset.collate)
test_dataloader = DataLoader(test_dataset,
batch_size=8,
shuffle=False,
num_workers=0,
collate_fn=hw_dataset.collate)
hw = model.create_model(config)
if torch.cuda.is_available():
hw.cuda()
dtype = torch.cuda.FloatTensor
print("Using GPU")
else:
dtype = torch.FloatTensor
print("No GPU detected")
optimizer = torch.optim.Adam(hw.parameters(),
lr=config['network']['learning_rate'])
criterion = torch.nn.CrossEntropyLoss()
lowest_loss = 0.0
for epoch in range(1000):
sum_loss = 0.0
steps = 0.0
hw.train()
for i, x in enumerate(train_dataloader):
line_imgs = Variable(x['line_imgs'].type(dtype),
requires_grad=False)
gts = Variable(torch.from_numpy(np.array(x['gt'])))
preds = hw(line_imgs).cpu()
loss = criterion(preds, gts)
optimizer.zero_grad()
loss.backward()
optimizer.step()
prs = preds.data.numpy()
prs = np.argmax(prs, axis=1)
out = [
1 for num in range(len(prs))
if prs[num] == gts.data.numpy()[num]
]
sum_loss += sum(out)
print("Training accuracy: %.2f" % (sum_loss * 100 /
(len(train_dataloader) * 8)) + "%")
sum_loss = 0.0
steps = 0.0
hw.eval()
for x in test_dataloader:
line_imgs = Variable(x['line_imgs'].type(dtype),
requires_grad=False,
volatile=True)
gts = Variable(torch.from_numpy(np.array(x['gt'])))
preds = hw(line_imgs).cpu()
#output_batch = preds.permute(1,0,2)
out = preds.data.cpu().numpy()
for i, gt_line in enumerate(x['gt']):
logits = out[i, ...]
max = np.argmax(logits)
sum_loss += 1 if max == gt_line else 0
steps += 1
print("Test accuracy: %.2f" % (sum_loss * 100 / steps) + '%')
if lowest_loss < sum_loss / steps:
lowest_loss = sum_loss / steps
print("Saving Best")
dirname = os.path.dirname(config['model_save_path'])
if len(dirname) > 0 and not os.path.exists(dirname):
os.makedirs(dirname)
torch.save(hw.state_dict(),
os.path.join(config['model_save_path']))
def train(model_type='parallel',
label_set='full',
drop_unk=False,
word_vecs=None,
setup_only=False):
print "Loading data..."
df = sentences_df(SENTENCES_CSV, labels=label_set, drop_unk=drop_unk)
X, y, word2idx, l_enc = load_dataset(df, pad=True)
print "X shape:", X.shape
y_orig = y
y_binary = to_categorical(y)
labels = np.unique(y_orig)
nb_labels = labels.shape[0]
if drop_unk:
label_set_str = label_set + ' (-unk)'
else:
label_set_str = label_set
print "Number of labels: %i [%s]" % (nb_labels, label_set_str)
if nb_labels > 2:
y = y_binary
maxlen = X.shape[1]
vocab_size = len(word2idx) + 1 # 0 masking
if pretrained_embeddings is True:
word_vectors = load_bin_vec(word_vecs, word2idx)
add_unknown_words(word_vectors, word2idx)
embedding_weights = np.zeros((vocab_size + 1, emb_dim))
for word, index in word2idx.items():
embedding_weights[index, :] = word_vectors[word]
else:
embedding_weights = None
print "Data loaded."
if setup_only:
cnn = create_model(vocab_size,
nb_labels,
emb_dim,
maxlen,
embedding_weights,
filter_hs,
nb_filters,
dropout_p,
trainable_embeddings,
pretrained_embeddings,
model_type=model_type)
return {
'X': X,
'y': y,
'word2idx': word2idx,
'l_enc': l_enc,
'y_binary': y_binary,
'labels': labels,
'nb_labels': nb_labels,
'maxlen': maxlen,
'emb_dim': emb_dim,
'vocab_size': vocab_size,
'embedding_weights': embedding_weights,
'cnn': cnn
}
params = [('filter_hs', filter_hs), ('nb_filters', nb_filters),
('dropout_p', dropout_p),
('trainable_embeddings', trainable_embeddings),
('pretrained_embeddings', pretrained_embeddings),
('batch_size', batch_size), ('nb_epoch', nb_epoch), ('lr', lr),
('beta_1', beta_1), ('beta_2', beta_2), ('epsilon', epsilon)]
print "\nModel type: %s" % model_type
for (name, value) in params:
print name + ':', value
skf = StratifiedKFold(y_orig, n_folds=10, shuffle=True, random_state=0)
cv_scores = []
for i, (train, test) in enumerate(skf):
start_time = time.time()
cnn = None
cnn = create_model(vocab_size,
nb_labels,
emb_dim,
maxlen,
embedding_weights,
filter_hs,
nb_filters,
dropout_p,
trainable_embeddings,
pretrained_embeddings,
model_type=model_type)
if i == 0:
print_summary(cnn.model.layers)
acc = train_and_test_model(cnn, X[train], y[train], X[test], y[test],
batch_size, nb_epoch, lr, beta_1, beta_2,
epsilon)
cv_scores.append(acc)
train_time = time.time() - start_time
print('\nLabel frequencies in y[test]')
print_label_frequencies((y_orig[test], l_enc))
y_pred = cnn.model.predict(X[test])
y_pred = probas_to_classes(y_pred)
c = Counter(y_pred)
total = float(len(y_pred))
print('\nLabel frequencies in predict(y[test])')
for label, count in c.most_common():
print l_enc.inverse_transform(label), count, count / total
print "fold %i/10 - time: %.2f s - acc: %.4f on %i samples" % \
(i+1, train_time, acc, len(test))
print "Avg cv accuracy: %.4f" % np.mean(cv_scores)
frame_probs.grid(row=0, column=2)
labels_prob = []
for i in range(10):
labels_prob.append(
tk.Label(frame_probs,
text="{}: 0.00%".format(i),
anchor=tk.W,
justify=tk.LEFT))
labels_prob[-1].grid(row=i, sticky="W")
root.mainloop()
exit(0)
cnn.load_data()
(x_train, y_train), (x_test, y_test) = cnn.get_data()
model = cnn.create_model()
model.summary()
model.fit(x_train, y_train, batch_size=100, validation_data=(x_test, y_test))
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)
model.save_weights("models/cnn")
model = cnn.create_model()
model.load_weights("models/cnn")
test_loss, test_acc = model.evaluate(x_test, y_test)
print('Test accuracy:', test_acc)
def main(debug):
n_times = 10
weights_dir = '_weights'
models_dir = '_models'
plots_dir = '_plots'
results_filename = 'results.pkl'
x_train, y_train, x_test, y_test, num_classes = prepare_data(debug)
batches = [32, 128, 512, 20000, len(x_train)]
WEIGHT_UPDATES = int(len(x_train) / 32 * 100)
os.makedirs(models_dir, exist_ok=True)
os.makedirs(plots_dir, exist_ok=True)
model = cnn.create_model(x_train.shape, num_classes)
model.compile(loss='categorical_crossentropy',
optimizer=SGD(),
metrics=['accuracy'])
model.summary()
results = {}
# recover results
if os.path.isfile(results_filename):
results = pickle.load(open(results_filename, 'rb'))
for weights_filename in sorted(glob.glob(weights_dir + '/*')):
w_num = int(weights_filename[-3:])
if w_num not in results:
results[w_num] = {}
for batch_size in batches:
if batch_size not in results[w_num]:
results[w_num][batch_size] = {}
for exp_num in range(n_times):
name = '{}_{}_{}'.format(weights_filename[-3:],
batch_size, exp_num)
if exp_num not in results[w_num][batch_size]:
print('Start {}'.format(name))
else:
print('Skip: {} - already calculated'.format(name))
continue
model.load_weights(weights_filename)
updates_per_epochs = len(x_train) // batch_size
epochs = WEIGHT_UPDATES // updates_per_epochs
history = model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test),
shuffle=True)
y_scores = model.predict_proba(x_test)
results[w_num][batch_size][exp_num] = save_results(
model, name, history, y_test, y_scores,
models_dir, plots_dir,
debug)
pickle.dump(results, open(results_filename, 'wb'))
from cnn import create_model
import tensorflow as tf
import numpy as np
W, D = 19, 500
def create_fake_images(value=0, N=10, w=W):
return tf.constant(value, shape=(N, w, w, w, 1), dtype=tf.dtypes.float32)
def create_fake_labels(r=1, d=D, N=10):
prob = np.zeros([N, d], dtype="float32")
prob[:, 0] = 1
return np.hstack(
[np.full(fill_value=r, shape=(N, 1), dtype="float32"), prob])
if __name__ == "__main__":
model = create_model(W, D)
preds = model.predict(create_fake_images())
# print(preds[0].shape, preds[1].shape)
model.evaluate(create_fake_images(N=5), create_fake_labels(N=5), verbose=1)
# print(len(create_fake_labels()))