def train():
fact_dict = load_pickle()
sentences, ratings = split(fact_dict)
plotter, fig, ax = create_plot(["loss", "accuracy"])
model = fm.Model(dim_input=50, dim_recurrent=100, dim_output=1)
optimizer = Adam(model.parameters)
plot_every = 500
for k in range(100000):
output = model(sentences)
loss = softmax_crossentropy(output, ratings)
acc = float(output.data.squeeze() == ratings.item())
plotter.set_train_batch({
"loss": loss.item(),
"accuracy": acc
},
batch_size=1,
plot=False)
if k % plot_every == 0 and k > 0:
plotter.set_train_epoch()
loss.backward()
optimizer.step()
loss.null_gradients()
from mynn.optimizers.adam import Adam
from Model import Model
model = Model()
optim = Adam(model.parameters, learning_rate=1e-04, weight_decay=5e-04)
#notebook with noggin
#plotter, fig, ax = create_plot(('loss', 'reg_loss', 'cls_loss', 'Precision', 'Recall'),
# 1, figsize=(8, 12))
path = r"C:\Users\khoui\Nutrient_Detection\Food_Data"
train_dir = r"C:\Users\khoui\Nutrient_Detection\Food_Data\food-11\training"
test_dir = r"C:\Users\khoui\Nutrient_Detection\Food_Data\food-11\validation"
x_train, y_train, x_test, y_test = load_draw_data(path)
generate_plate_set(x_train, y_train)
#load plate data
generate
for _ in range(5):
train_epoch(train_data, train_boxes, train_labels, anchor_boxes, model, optim,
val_data, val_boxes, val_labels)
#plotter.plot()
return weights
def weights2(self):
weights=self.dense2.weight.data
return weights
def weights3(self):
weights=self.dense3.weight.data
return weights
def weights4(self):
weights=self.dense4.weight.data
return weights
@property
def parameters(self):
''' A convenience function for getting all the parameters of our model. '''
return self.dense1.parameters + self.dense2.parameters + self.dense3.parameters + self.dense4.parameters
model = Model()
optim = Adam(model.parameters)
# Create the shape-(1000,1) training data
train_data = mg.linspace(0,19,100).reshape(100,1)
# Create your parameters using your function `create_parameters`;
# start off with N=10 for the number of model parameters
# to use for defining F(x)
# Set `batch_size = 25`: the number of predictions that we will make in each training step
# Define the function `true_f`, which should just accept `x` and return `np.cos(x)`
def true_f(x):
return np.interp(x,np.linspace(0,19,20),unknown_data[BodyPartIndex][CoordIndex])
batch_size = 10
for epoch_cnt in range(200000):
def train(x_tr, y_tr, x_te, y_te):
x_tr = np.array(x_tr)
y_tr = np.array(y_tr)
x_train_vec = vectorize(x_tr, 92)
x_te = np.array(x_te)
y_te = np.array(y_te)
x_test_vec = vectorize(x_te, 58)
model = Model()
optim = Adam(model.parameters, learning_rate=1e-4)
plotter, fig, ax = create_plot(metrics=["loss", "accuracy"])
batch_size = 50
for epoch_cnt in range(7):
idxs = np.arange(len(x_tr))
np.random.shuffle(idxs)
for batch_cnt in range(len(x_tr) // batch_size):
# make slice object so indices can be referenced later
batch_indices = idxs[slice(batch_cnt * batch_size,
(batch_cnt + 1) * batch_size)]
#batch = x_train[batch_indices] # random batch of our training data
# retrieve glove embeddings for batch
# initialize every value as small number which will be the placeholder for not found embeddings
arr = x_train_vec[batch_indices]
"""
arr = np.ones((len(batch), 200, max(train_max, test_max))) / 1000000
for i, sent in enumerate(batch):
for j , word in enumerate(sent):
# retrieve glove embedding for every word in sentence
try:
arr[i,:,j] = glove_model.get_vector(word.lower())
# continue if glove embedding not found
except Exception as e:
continue
"""
# pass model through batch and perform gradient descent
pred = model(arr)
truth = y_tr[batch_indices]
loss = binary_cross_entropy(pred[:, 0], truth)
loss.backward()
optim.step()
loss.null_gradients()
acc = accuracy(pred[:, 0], truth)
# pass loss and accuracy to noggin for plotting
plotter.set_train_batch({
"loss": loss.item(),
"accuracy": acc
},
batch_size=batch_size)
"""
return model
def test(x_te, y_te, model):
# compute test statistics
#idxs = np.arange(len(x_test))
x_te = np.array(x_te)
y_te = np.array(y_te)
x_test_vec = vectorize(x_te, 58)
logger = LiveLogger()
idxs = np.arange(len(x_te))
logger.set_train_batch(dict(metric_a=50., metric_b=5.), batch_size=50)
batch_size = 50
for epoch_cnt in range(2):
idxs = np.arange(len(x_te))
np.random.shuffle(idxs)
"""
idxs = np.arange(len(x_te))
for batch_cnt in range(0, len(x_te) // batch_size):
batch_indices = idxs[slice(batch_cnt * batch_size,
(batch_cnt + 1) * batch_size)]
#batch = x_test[batch_indices]
# again, find embeddings for batch
arr = x_test_vec[batch_indices]
"""
arr = np.ones((len(batch), 200, max(train_max, test_max))) / 1000000
for i, sent in enumerate(batch):
for j , word in enumerate(sent):
try:
arr[i,:,j] = glove_model.get_vector(word.lower())
except Exception as e:
continue
"""
# perform forward pass and find accuracy but DO NOT backprop
pred = model(arr)
truth = y_te[batch_indices]
acc = accuracy(pred[:, 0], truth)
# log the test-accuracy in noggin
plotter.set_test_batch({"accuracy": acc}, batch_size=batch_size)
# plot the epoch-level train/test statistics
plotter.set_train_epoch()
plotter.set_test_epoch()
return model
def main():
path = r"glove.6B.50d.txt.w2v"
glove = KeyedVectors.load_word2vec_format(path, binary=False)
# loads the json file
path_to_json = "captions_train2014.json"
with open(path_to_json, "rb") as f:
json_data = json.load(f)
resnet = unpickle.unpickle()
with open("idfs1.pkl", mode="rb") as idf:
idfs = pickle.load(idf)
with open("img_to_caption1.pkl", mode="rb") as cap:
img_to_caption = pickle.load(cap)
#with open("img_to_coco1.pkl", mode="rb") as coco:
#img_to_coco=pickle.load(coco)
model = Model()
model.dense1.weight = mg.Tensor(np.load('weight.npy'))
model.dense1.bias = mg.Tensor(np.load('bias.npy'))
optim = Adam(model.parameters)
batch_size = 100
for epoch_cnt in range(100):
idxs = list(resnet.keys())
np.random.shuffle(idxs)
for batch_cnt in range(0, len(idxs) // batch_size - 1):
batch_indices = idxs[(batch_cnt * batch_size):((batch_cnt + 1) *
batch_size)]
batch_indices2 = idxs[((batch_cnt + 1) *
batch_size):((batch_cnt + 2) * batch_size)]
# id1 = np.random.choice(list(resnet.keys()))
# print(id1)
id1 = batch_indices
# while id1 == id2:
id2 = batch_indices2
# print(type(resnet[id1]),type(img_to_caption[id1][0]),type(resnet[id2]))
good_image = resnet[id1[0]]
bad_image = resnet[id2[0]]
text = embed_text.se_text(img_to_caption[id1[0]][0], glove, idfs)
for i in id1[1:]:
good_image = np.vstack((good_image, resnet[i]))
text = np.vstack(
(text, embed_text.se_text(img_to_caption[i][0], glove,
idfs)))
for i in id2[1:]:
bad_image = np.vstack((bad_image, resnet[i]))
sim_to_good = cos_sim.cos_sim(model(good_image), text)
sim_to_bad = cos_sim.cos_sim(model(bad_image), text)
# compute the loss associated with our predictions(use softmax_cross_entropy)
loss = margin_ranking_loss(sim_to_good, sim_to_bad, 1, 0.1)
# back-propagate through your computational graph through your loss
loss.backward()
# compute the accuracy between the prediction and the truth
acc = accuracy(sim_to_good.data, sim_to_bad.data)
# execute gradient descent by calling step() of optim
optim.step()
# null your gradients
loss.null_gradients()
np.save('weight', model.dense1.parameters[0].data)
np.save('bias', model.dense1.parameters[1].data)
from mygrad.nnet.layers import max_pool
from mynn.optimizers.adam import Adam
from mygrad.nnet.losses import softmax_crossentropy
#needs import/download of data set
#our train = xtrain
#our truth = ytrain
model = Model()
lr = 1e-2
wd = 1e-04
optimization = Adam(model.parameters, learning_rate=lr, weight_decay=wd)
batch_size = #give number here
for batch_cnt in range(0, len(xtrain) // batch_size):
batch_indices = idxs[batch_cnt * batch_size: (batch_cnt + 1) * batch_size]
batch = xtrain[batch_indices] # random batch of our training data
# compute the predictions for this batch by calling on model
predictions = model(batch)
pass
truth = ytrain[batch_indices]
pass
# compute the loss
x_train = list(x_train)
for i in range(len(x_train)):
x_train[i] = np.array(to_glove(x_train[i]))
x_train = np.array(x_train)
print(x_train[0].shape, x_train[1].shape)
print("SHAPEEE: ", x_train.shape)
dim_input = 50
dim_recurrent = 16
dim_output = 2
rnn = RNN(dim_input, dim_recurrent, dim_output)
optimizer = Adam(rnn.parameters)
plotter, fig, ax = create_plot(metrics=["loss"])
batch_size = 20
# Trains the model over 10 epochs.
for epoch_cnt in range(50):
idxs = np.arange(len(x_train))
np.random.shuffle(idxs)
print("training epoch number ", epoch_cnt)
for batch_cnt in range(0, len(x_train) // batch_size):
batch_indices = idxs[batch_cnt * batch_size: (batch_cnt + 1) * batch_size]
old = x_train[batch_indices]
from img_model import Model
import mygrad as mg
import mynn
import numpy as np
from mynn.layers.dense import dense
from mygrad.nnet import margin_ranking_loss
from mynn.optimizers.adam import Adam
import trainingdata as td
import split_n_stitch as ss
import training_functions as tf
#Call the model to convert the image features to image embeddings.
se_img = Model()
optim = Adam(model.parameters, learning_rate=0.1)
#Unpickle the captions database
with open("captions.pickle", mode="rb") as captiondata:
captions = dict(pickle.load(captiondata))
#Unpickle the image database
with open("resnet18_features.pkl", mode="rb") as imgdata:
img = dict(pickle.load(imgdata))
#The captions and image embeddings are used to generate 16000 triples.
#Each triple is in the format of (caption, good image embedding, bad image embedding)
captions, good_images, bad_images = td.generate_training(captions, img, 64000)
#testingtriples = td.generate_training(captions, image_embeds, 16000)
#The number of epochs and the batch size are defined
num_epochs = 500