def train_model(
X_train,
Y_train,
X_test,
Y_test,
mode,
epochs,
batch_size,
model_name=None,
checkpoint_path=None,
model_path=None,
):
clear_session()
# mode = agrs.mode
# model_name = args.model_name
if mode == 'train':
if model_name == 'ConvNet':
print("Choosen model ConvNet")
Convnet = ConvNet()
model = Convnet.train(X_train, Y_train, X_test, Y_test, batch_size,
epochs, checkpoint_path)
Convnet.showloss()
return model
else:
raise ValueError("Select Correct model")
def main():
model_save_folder = args.model_save_folder
if not os.path.exists(model_save_folder):
os.makedirs(model_save_folder)
model_save_path = args.model_save_folder + '/cnn.model'
dict_save_path = args.model_save_folder + '/cnn.dict'
dl = DataLoader(args.train_file, args.dev_file, args.test_file,
args.freq_threshold, args.max_batch_size, args.max_length,
args.min_length)
en_dict, train_data, dev_data, test_data = dl.prepareData()
with open(dict_save_path, 'wb') as handle:
pickle.dump(en_dict, handle, protocol=pickle.HIGHEST_PROTOCOL)
clf = ConvNet(en_dict.index2word,
args.emb_size,
dl.class_inv_freq,
args.num_kernels,
args.kernel_sizes,
args.learning_rate,
model_save_path,
pretrained_path=args.pretrained_path)
clf.fit(train_data, dev_data, args.num_epochs)
y_true, y_pred = clf.predict(test_data)
corrects = (y_true == y_pred).sum()
print('testing accuracy: {:}'.format(corrects * 1.0 /
test_data.num_instances))
class MNISTConvNetTestingTest(unittest.TestCase): def setUp(self): configPath = "MNIST_10_Config-trained-55.ini" self.net = ConvNet(configPath) # get all data (data, labels) = read_mnist.getMNISTTest() labels.flags.writeable = True self.labels = np.zeros(labels.shape) self.data = data for i in xrange(len(labels)): self.labels[i] = int(labels[i]) def testTestAll(self): # no training here # run test maxEpochs = 1000 epochsPerSave = 5 print "data: ", self.data print "labels: ", self.labels #self.net.trainSet(data, labels, maxEpochs, epochsPerSave) self.net.testSet(self.data, self.labels)
def setUp(self): configPath = "MNIST2and3Config.ini" self.net = ConvNet(configPath) # import just images of 2s and 3s for now self.imagesOf2s = extract_mnist.getMNISTTrainingSamplesNum(2) self.imagesOf3s = extract_mnist.getMNISTTrainingSamplesNum(3)
def main(nn_type='ConvNet',
d=64,
s=32,
m=5,
epoch=2000,
lr=0.001,
batch_size=256):
now = datetime.datetime.now()
#print(flags.data_url)
#print(flags.train_url)
log_dir = r's3://obs-fmf-eq/model/%s_d%d_s%d_m%d_ep%d_lr%.3f_bs%d/V0002' % (
nn_type, d, s, m, epoch, lr, batch_size)
chkmkdir(log_dir)
data_path = r's3://obs-fmf-eq/complete_frame'
training_data = get_data_by_frame(data_path, 2, 'train')
test_data = get_data_by_frame(
data_path, 5, 'test'
) #{'test_data': training_data['train_data'], 'test_label': training_data['train_label']}
val_data = get_data_by_frame(
data_path, 3, 'validation'
) #{'val_data': training_data['train_data'], 'val_label': training_data['train_label']}
if nn_type == 'VDSR':
model = VDSR(d, s, m, input_shape=[1, 360, 12]).build_model()
elif nn_type == 'ConvNet':
model = ConvNet(d, s, m, input_shape=[1, 360, 12]).build_model()
train_model(training_data, test_data, val_data, model,
tf.train.AdamOptimizer(0.001), epoch, batch_size, log_dir)
def setUp(self): configPath = "MNIST2and3and7Config_twoConv-trained-100.ini" self.net = ConvNet(configPath) # import just images of 2s and 3s for now self.imagesOf2s = extract_mnist.getMNISTTestSamplesNum(2) self.imagesOf3s = extract_mnist.getMNISTTestSamplesNum(3) self.imagesOf7s = extract_mnist.getMNISTTestSamplesNum(7)
def geneator_handler():
"""Upload an handwrittend digit image in range [0-9], then
preprocess and classify"""
# check if the post request has the file part
if 'file' not in request.files:
return BadRequest("File not present in request")
file = request.files['file']
if file.filename == '':
return BadRequest("File name is not present in request")
if not allowed_file(file.filename):
return BadRequest("Invalid file type")
filename = secure_filename(file.filename)
image_folder = os.path.join(EVAL_PATH, "images")
# Create dir /eval/images
try:
os.makedirs(image_folder)
except OSError:
pass
# Save Image to process
input_filepath = os.path.join(image_folder, filename)
file.save(input_filepath)
# Get ckp
checkpoint = request.form.get(
"ckp") or "/input/mnist_convnet_model_epoch_10.pth" # FIX to
# Preprocess, Build and Evaluate
Model = ConvNet(ckp=checkpoint)
Model.image_preprocessing()
Model.build_model()
pred = Model.classify()
output = "Images: {file}, Classified as {pred}\n".format(
file=file.filename, pred=int(pred))
os.remove(input_filepath)
return output
def setUp(self): configPath = "MNIST_10_Config-trained-55.ini" self.net = ConvNet(configPath) # get all data (data, labels) = read_mnist.getMNISTTest() labels.flags.writeable = True self.labels = np.zeros(labels.shape) self.data = data for i in xrange(len(labels)): self.labels[i] = int(labels[i])
class MNISTConvNetTrainingTest(unittest.TestCase):
def setUp(self):
configPath = "MNIST2and3Config.ini"
self.net = ConvNet(configPath)
# import just images of 2s and 3s for now
self.imagesOf2s = extract_mnist.getMNISTTrainingSamplesNum(2)
self.imagesOf3s = extract_mnist.getMNISTTrainingSamplesNum(3)
def testTrain2sAnd3s(self):
numImages = 10 # number of images of each category
# combine two data sets
twos = self.imagesOf2s[0:numImages]
threes = self.imagesOf3s[0:numImages]
data = np.concatenate((twos, threes))
# set up labels
labels = []
for i in xrange(numImages):
labels.append("two")
for i in xrange(numImages):
labels.append("three")
# epochs
maxEpochs = 50
epochsPerSave = 50
# run test
print "Start"
self.net.trainSet(data, labels, maxEpochs, epochsPerSave)
self.net.testSet(data, labels)
self.net.saveFilters(maxEpochs)
class MNISTConvNetTestingTest(unittest.TestCase):
def setUp(self):
configPath = "MNIST2and3and7Config_twoConv-trained-100.ini"
self.net = ConvNet(configPath)
# import just images of 2s and 3s for now
self.imagesOf2s = extract_mnist.getMNISTTestSamplesNum(2)
self.imagesOf3s = extract_mnist.getMNISTTestSamplesNum(3)
self.imagesOf7s = extract_mnist.getMNISTTestSamplesNum(7)
def testTest2sAnd3sAnd7s(self):
numImages = 1 # number of images of each category
# combine two data sets
#twos = self.imagesOf2s[0:numImages]
threes = self.imagesOf3s[0:numImages]
#sevens = self.imagesOf7s[0:numImages]
#data = np.concatenate((twos, threes, sevens))
# set up labels
labels = []
#for i in xrange(numImages):
# labels.append("two")
for i in xrange(numImages):
labels.append("three")
#for i in xrange(numImages):
# labels.append("seven")
# run test
self.net.testSet(threes, labels)
self.net.saveFilters(100)
self.net.saveActivations(100)
class MNISTMisclassifyTest(unittest.TestCase):
def setUp(self):
configPath = "../ini/MNIST10labels_50img_twoConv-trained-50.ini"
self.net = ConvNet(configPath)
(self.images, self.labels) = read_mnist.getMNISTTest()
def testTest10Labels(self):
str_labels = []
for digit in self.labels:
if digit == 0:
str_labels.append("zero")
elif digit == 1:
str_labels.append("one")
elif digit == 2:
str_labels.append("two")
elif digit == 3:
str_labels.append("three")
elif digit == 4:
str_labels.append("four")
elif digit == 5:
str_labels.append("five")
elif digit == 6:
str_labels.append("six")
elif digit == 7:
str_labels.append("seven")
elif digit == 8:
str_labels.append("eight")
elif digit == 9:
str_labels.append("nine")
numWrong = 10
# run test
for i in xrange(len(self.images)):
# Propagate our sample through the network.
expectedOutputLabel = str_labels[i]
outputVector = self.net.testSample(self.images[i], self.labels[i])
sortedOutputVector = sorted(outputVector[0])
# We have a vector of outputs.
# Get the index of the max score of this output.
largest = outputVector[0].argmax()
outputLabel = self.net.labelSetReversed[largest]
secondLargest = outputVector[0].tolist().index(sortedOutputVector[1])
# Save the number of correct labels.
if outputLabel == expectedOutputLabel:
misc.saveImage(self.images[i], "twoconv_corclass/" + "corclass_"+str(expectedOutputLabel)+"_"+str(largest)+"_"+str(secondLargest)+".png")
def setUp(self): configPath = "MNIST_10_Config.ini" self.net = ConvNet(configPath) # import all images self.imagesOf0s = extract_mnist.getMNISTTestSamplesNum(0) self.imagesOf1s = extract_mnist.getMNISTTestSamplesNum(1) self.imagesOf2s = extract_mnist.getMNISTTestSamplesNum(2) self.imagesOf3s = extract_mnist.getMNISTTestSamplesNum(3) self.imagesOf4s = extract_mnist.getMNISTTestSamplesNum(4) self.imagesOf5s = extract_mnist.getMNISTTestSamplesNum(5) self.imagesOf6s = extract_mnist.getMNISTTestSamplesNum(6) self.imagesOf7s = extract_mnist.getMNISTTestSamplesNum(7) self.imagesOf8s = extract_mnist.getMNISTTestSamplesNum(8) self.imagesOf9s = extract_mnist.getMNISTTestSamplesNum(9)
def setUp(self): configPath = "MultipleConvPoolLayersConfig.ini" imagePathPrefix = "../test_imgs/lines/" imagePaths = ["horiz_line0.png", "horiz_line1.png", "horiz_line2.png", "vert_line0.png", "vert_line1.png", "vert_line2.png"] self.labels = np.array(["horiz", "horiz", "horiz", "vert", "vert", "vert"]) self.imageDim = 32 self.numImages = 6 assert len(self.labels) == self.numImages, "Not enough labels to run!" assert len(imagePaths) == self.numImages, "Not enough images to run!" self.net = ConvNet(configPath) self.images = np.zeros((self.numImages, self.imageDim, self.imageDim)) for i in xrange(self.numImages): self.images[i] = misc.loadImage(imagePathPrefix + imagePaths[i])
def model_validation(nn_type='VDSR',
d=64,
s=32,
m=5,
data_path=None,
chkpt_path=None,
frame_idx=None):
if nn_type == 'VDSR':
model = VDSR(d, s, m, input_shape=[1, 360, 12]).build_model()
elif nn_type == 'ConvNet':
model = ConvNet(d, s, m, input_shape=[1, 360, 12]).build_model()
model.load_weights(chkpt_path)
val_data = get_data_by_frame(data_path, frame_idx,
'validation')['val_data']
y_predict = model.predict(val_data, steps=4)
ber = calc_ber(y_predict)
def get_song_emotions():
api = genius.Genius(
'9mXsJ6OfC-KdM2QF1xl_0hRVZ7KiqrQYtUwobdB4kcpVsClOHUGf_d1a8qQjfIoa')
emotion_dict = np.load('emotion_dict.npy')
emotion_dict = emotion_dict.item()
names = get_dictionary()
PATH = "model/model.pth"
num_classes = 6
model = ConvNet(num_classes)
model.load_state_dict(torch.load(PATH))
model.eval()
print("load models")
songs_emo = {}
for k, v in names.items():
print(k, v)
title = v[0]
artist = v[1]
text_emotions = [0 for i in range(6)]
output = [0 for i in range(6)]
pred = [0 for i in range(6)]
try:
lyrics = PyLyrics.getLyrics(artist, title)
if lyrics == "":
song = api.search_song(artist, title)
lyrics = song.lyrics
emovector = lib.emotion_analyzer(lyrics, emotion_dict)
high = max(emovector)
text_emotions = [0 if i != high else 1 for i in emovector]
text_emotions = np.array(text_emotions)
except:
print("passing")
#try:
mp3file = "data/" + k + ".mp3"
spec = lib.audio_read(mp3file) # extract spectrogram
spec = torch.from_numpy(spec)
pred = model(spec)
high = max(pred)
pred = [0 if i != high else 1 for i in pred]
pred = np.array(pred)
output = np.add(pred, text_emotions)
np.clip(output, 0, 1, out=output)
songs_emo[k] = output
print('finishing ' + k)
return songs_emo
def evaluate(dl, config):
""" Given a trained network, evaluate on the whole test set and receive outcomes for qualitative analysis
"""
word_seq_size = dl.train_data.vocab_size_words + 1
chr_seq_size = dl.train_data.vocab_size_char + 1
max_sentence_length = max(dl.train_data.seq_size_words,
dl.test_data.seq_size_words,
dl.val_data.seq_size_words)
model = ConvNet(word_seq_size, chr_seq_size, max_sentence_length)
t1 = time.time()
if torch.cuda.is_available():
model.cuda()
# Load checkpoint
if config.checkpoint:
checkpoint = load_checkpoint(config.model_path)
model.load_state_dict(checkpoint['model'])
print("Checkpoint loaded")
batch_inputs_words, batch_inputs_chars, batch_targets_label, batch_targets_scores, _ = dl.test_data.next_batch(
)
batch_inputs_words = batch_inputs_words.t().reshape(-1, word_seq_size, 1)
# Forward pass to get output/logits
outputs = model(batch_inputs_words)
# Calculate Loss: softmax --> cross entropy loss
label = batch_targets_label.type('torch.LongTensor').reshape(-1)
acc = calc_accuracy(outputs, label)
save_mistakes(outputs, label, batch_inputs_words, dl)
t2 = time.time()
examples_per_second = config.batch_size / float(t2 - t1)
print('Here the test results.\n[{}] \t Acc {} \t Examples/Sec = {:.2f},'.
format(datetime.now().strftime("%Y-%m-%d %H:%M"), acc,
examples_per_second))
class ToyConvNetTrainingTest(unittest.TestCase): def setUp(self): configPath = "MultipleConvPoolLayersConfig.ini" imagePathPrefix = "../test_imgs/lines/" imagePaths = ["horiz_line0.png", "horiz_line1.png", "horiz_line2.png", "vert_line0.png", "vert_line1.png", "vert_line2.png"] self.labels = np.array(["horiz", "horiz", "horiz", "vert", "vert", "vert"]) self.imageDim = 32 self.numImages = 6 assert len(self.labels) == self.numImages, "Not enough labels to run!" assert len(imagePaths) == self.numImages, "Not enough images to run!" self.net = ConvNet(configPath) self.images = np.zeros((self.numImages, self.imageDim, self.imageDim)) for i in xrange(self.numImages): self.images[i] = misc.loadImage(imagePathPrefix + imagePaths[i]) # def testTrain1Image(self): # data = np.zeros((1, self.imageDim, self.imageDim)) # data[0] = np.array([self.images[0]]) # maxEpochs = 100 # epochsPerSave = 101 # no saving in this test # self.net.trainSet(data, np.array([self.labels[0]]), maxEpochs, epochsPerSave) # self.net.testSet(data, np.array([self.labels[0]])) # def testTrain6Images(self): # data = self.images # maxEpochs = 1000 # epochsPerSave = 10001 # no saving in this test either # self.net.trainSet(data, self.labels, maxEpochs, epochsPerSave) def testTrain6ImagesAndTest(self): data = self.images maxEpochs = 500 epochsPerSave = 500 # save at the end of this test self.net.trainSet(data, self.labels, maxEpochs, epochsPerSave) self.net.testSet(data, self.labels) self.net.saveFilters(maxEpochs) # for visualization
def main():
device = get_best_device()
training_data = load_training_data()
# Initialize Net Object, Optimizer and Loss function
net = ConvNet().to(device)
if not SHOULD_RETRAIN_NET:
net.load_state_dict(torch.load(MODEL_PATH))
optimizer = optim.Adam(net.parameters(), lr=0.001)
loss_function = nn.MSELoss()
train_x, train_y, test_x, test_y = separate_training_and_testing_data(
training_data)
if SHOULD_RETRAIN_NET:
do_training(net, optimizer, loss_function, device, train_x, train_y)
torch.save(net.state_dict(), MODEL_PATH)
do_testing(net, device, test_x, test_y)
def run_main(FLAGS):
'''
Main body of program.
Initializes model, defines loss function and optimizer.
Loads datasets.
Calls train() and test() to train and test model over a specified number of epochs.
Prints training and testing results to TensorBoard.
Prints the best accuracy obtained by the model.
optimizer: optimizer to use for model parameter updates.
criterion: used to compute loss for prediction and target
'''
# Check if cuda is available
use_cuda = torch.cuda.is_available()
# Set proper device based on cuda availability
device = torch.device("cuda" if use_cuda else "cpu")
print("Torch device selected: ", device)
# Initialize the model and send to device
model = ConvNet().to(device)
writer = SummaryWriter()
# Define loss function.
criterion = nn.BCEWithLogitsLoss()
# Define optimizer function.
optimizer = optim.SGD(model.parameters(), FLAGS.learning_rate)
# Load datasets for training and testing
# Inbuilt datasets available in torchvision (check documentation online)
dataset1 = Dataset("segmentation_out/color/train/")
dataset2 = Dataset("segmentation_out/color/train/")
train_loader = DataLoader(dataset1,
batch_size=FLAGS.batch_size,
shuffle=True,
num_workers=0)
test_loader = DataLoader(dataset2,
batch_size=FLAGS.batch_size,
shuffle=False,
num_workers=4)
best_accuracy = 0.0
# Run training for n_epochs specified in config
for epoch in range(1, FLAGS.num_epochs + 1):
train_loss, train_accuracy = train(model, device, train_loader,
optimizer, criterion, epoch,
FLAGS.batch_size)
test_loss, test_accuracy = test(model, device, test_loader, criterion)
writer.add_scalar('Loss/train', train_loss, epoch)
writer.add_scalar('Loss/test', test_loss, epoch)
writer.add_scalar('Accuracy/train', train_accuracy, epoch)
writer.add_scalar('Accuracy/test', test_accuracy, epoch)
if test_accuracy > best_accuracy:
best_accuracy = test_accuracy
print("accuracy is {:2.2f}".format(best_accuracy))
print("Training and evaluation finished")
writer.flush()
torch.save(model.state_dict(), "model.pth")
loss_fn = torch.nn.CrossEntropyLoss()
sm = torch.nn.Softmax(dim=1)
if datasource in ['omniglot', 'miniImageNet']:
from ConvNet import ConvNet
DIM_INPUT = {
'omniglot': (1, 28, 28),
'miniImageNet': (3, 84, 84)
}
net = ConvNet(
dim_input=DIM_INPUT[datasource],
dim_output=num_classes_per_task,
num_filters=(32, 32, 32, 32),
filter_size=(3, 3),
device=device
)
elif datasource in ['miniImageNet_640', 'tieredImageNet_640']:
import pickle
from FC640 import FC640
net = FC640(
dim_output=num_classes_per_task,
num_hidden_units=(128, 32),
device=device
)
else:
sys.exit('Unknown dataset!')
from torch.utils.data import DataLoader
import pandas as pd
from ConvNet import ConvNet
import torch
import torchvision.transforms as transforms
from ISCDataset import ISCDataset,ToTensor
#加载训练数据
sentiment_dataset=ISCDataset(csv_file='data/train.csv',transform=transforms.Compose([ToTensor()]))
trainloader = DataLoader(sentiment_dataset, batch_size=4,
shuffle=True, num_workers=0)
net=ConvNet()
#print(net)
optimizer=torch.optim.SGD(net.parameters(),lr=0.001,momentum=0.1)
loss_fn=torch.nn.CrossEntropyLoss()
for i in range(300):
num_verificationData=0
num_right=0
for i_batch,item in enumerate(trainloader):
if i_batch<=6000:
#print(type(item['image']),item['image'].shape)
prediction=net(item['image'])
##print(prediction)
loss=loss_fn(prediction,item['lable'])
#print(loss)
optimizer.zero_grad()
def __getitem__(self, idx):
X = self.images[idx]
Y = self.labels[idx]
return X, Y
#dataset creation
train_dataset = FaceDataset(transform, f)
test_dataset = FaceDataset(transform, f)
train_loader = DataLoader(dataset=train_dataset, shuffle=False, batch_size=batch_size)
test_loader = DataLoader(dataset=test_dataset, shuffle=False, batch_size=batch_size)
f.close()
#magic
model = ConvNet()
optimizer = torch.optim.Adam(model.parameters(), lr=lr)
criterion = nn.BCELoss()
start_time = time.time()
loss_list = []
acc_list = []
total = 0
correct = 0
for epoch in range(num_epochs):
train_loss = 0
i = 0
if (epoch + 1) % 75 == 0:
lr /= 2
optimizer.param_groups[0]['lr'] = lr
for images, labels in train_loader:
optimizer.zero_grad()
def train_model_4(self):
datasets = Datasets(datasets_folder="../Sample/cifar-10-batches-py/")
model = ConvModel()
# plotter = MyPlotter()
utils = Utils()
x = T.tensor4()
"""
y = true label
"""
y = T.matrix()
w1 = utils.init_kernel((16, 3, 5, 5))
b1 = utils.init_kernel((16, ))
w2 = utils.init_kernel((20, 16, 5, 5))
w3 = utils.init_kernel((20, 20, 5, 5))
w4 = utils.init_kernel((20, 20, 5, 5))
w_output = utils.init_kernel((80, 10))
# plotter.visual_weight()
params = [w1, w2, w3, w_output]
"""
pyx = prediction label of model
"""
layer_0, layer_1, layer_2, layer_3, layer_4, layer_5, layer_6, layer_7, layer_8, layer_9a, pyx = model.model4(
x, w1, w2, w3, w4, w_output)
y_x = T.argmax(pyx, axis=1)
visual_layer = []
visual_layer.append(theano.function(inputs=[x], outputs=layer_0))
visual_layer.append(theano.function(inputs=[x], outputs=layer_1))
visual_layer.append(theano.function(inputs=[x], outputs=layer_2))
visual_layer.append(theano.function(inputs=[x], outputs=layer_3))
visual_layer.append(theano.function(inputs=[x], outputs=layer_4))
visual_layer.append(theano.function(inputs=[x], outputs=layer_5))
visual_layer.append(theano.function(inputs=[x], outputs=layer_6))
visual_layer.append(theano.function(inputs=[x], outputs=pyx))
convnet = ConvNet(params=params, pyx=pyx, x=x, y=y, y_x=y_x)
training_x, training_y, testing_x, testing_y = datasets.load_cifar_datasets(
batch=1)
figure_layer = []
figure_layer.append(self.figure)
figure_layer.append(self.figure_layer1)
figure_layer.append(self.figure_layer2)
figure_layer.append(self.figure_layer3)
figure_layer.append(self.figure_layer4)
figure_layer.append(self.figure_layer5)
figure_layer.append(self.figure_layer6)
figure_layer.append(self.figure_layer7)
canvas = []
canvas.append(self.canvas)
canvas.append(self.canvas_layer1)
canvas.append(self.canvas_layer2)
canvas.append(self.canvas_layer3)
canvas.append(self.canvas_layer4)
canvas.append(self.canvas_layer5)
canvas.append(self.canvas_layer6)
canvas.append(self.canvas_layer7)
convnet.training(training_x[0:100], training_y[0:100],
testing_x[0:100], testing_y[0:100], visual_layer,
figure_layer, canvas, datasets)
dim_output=z_dim,
num_hidden_units=(40, 40),
device=device)
generator_hidden_units = (128, 512)
tanh_scale = 1
label_eps = 0
L2_regularization_discriminator = 0
elif datasource == 'miniImageNet':
from ConvNet import ConvNet
from WGenerator2 import WeightDiscriminator, WeightGenerator
net = ConvNet(dim_input=(3, 84, 84),
dim_output=num_classes_per_task,
num_filters=[32] * 4,
bn_flag=True)
encoder = ConvNet(dim_input=(3, 84, 84),
dim_output=None,
num_filters=[32] * 5,
bn_flag=False,
device=device)
z_dim = 128
generator_hidden_units = (256, 512)
tanh_scale = 20
label_eps = 0.1
L2_regularization_discriminator = 0
return len(self.images)
def __getitem__(self, idx):
X = self.images[idx]
Y = self.labels[idx]
return X, Y
#dataset creation
test_dataset = FaceDataset(transform, f)
test_loader = DataLoader(dataset=test_dataset,
shuffle=False,
batch_size=batch_size)
f.close()
model = ConvNet()
model.load_state_dict(
torch.load(
'D:/soft\PyCharmCommunityEdition2019.2.3\pycharmprojects\project/10_10000.ckpt'
))
model.eval()
with torch.no_grad():
correct = 0
total = 0
for images, labels in test_loader:
outputs = model(images)
row = sheet1.row(total)
row.write(0, test_dataset.names[total])
row.write(
1,
criterion(outputs.detach().numpy(),
plot_iter = 0
loss_str = ['Move', 'Reach', 'Pellet', 'Grasp', 'Retract']
ind_writer = []
for j in range(5):
ind_writer.append(SummaryWriter(LOG_DIR + '/ConvNet_Adam_SL1_' + loss_str[j]))
# create data loader
trajs = trajs_dataset(
trial_times_file='labels.csv',
trajs_dir='./CSV_files_DJT')
trajs_loader = torch.utils.data.DataLoader(trajs, batch_size=768, shuffle=True)
# instance of neural net
# nnet = TwoLayerNet()
# nnet = ConvNet()
nnet = ConvNet(num_times=5, l1_conv_ks=7, l1_max_ks=4, l2_conv_ks=7, l2_max_ks=2)
nnet.to('cpu')
nnet.train()
# set up loss function and optimizer
eta = .01
# criterion = nn.MSELoss()
# optimizer = torch.optim.SGD(nnet.parameters(), lr=eta)
criterion = nn.SmoothL1Loss()
optimizer = torch.optim.Adam(nnet.parameters(), lr=eta)
# train neural net
num_epochs = 2000
for epoch in range(num_epochs):
for i, sample in enumerate(trajs_loader):
traj = sample['traj'].float().to('cpu')
def main():
print("Starting Network...")
print("-------------------------------------------------------")
print("Reading Data sets...")
# MNIST Data sets
#train_img, test_img, train_lbl, test_lbl = load(file_name="mnist")
# CIFAR-10 Data sets
train_img, test_img, train_lbl, test_lbl = load(file_name="cifar")
Y = train_lbl[:].astype(int)
X = train_img[:] / 255.
Y_test = test_lbl[:].astype(int)
X_test = test_img[:] / 255.
#preprocess data
#X = preprocess_data(X)
#X_test = preprocess_data(X_test)
#model
model = Model()
model.add(
ConvNet(filter_size=(5, 5),
filter_no=6,
zero_padding=0,
stride=(1, 1),
activation="relu"))
model.add(Pool(pool_size=(2, 2), stride=(2, 2), pool_type="max"))
model.add(
ConvNet(filter_size=(5, 5),
filter_no=6,
zero_padding=0,
stride=(1, 1),
activation="relu"))
model.add(Pool(pool_size=(2, 2), stride=(2, 2), pool_type="max"))
model.add(Flatten())
model.add(
FCLayer(activation="relu",
n_neurons=32,
l_rate=0.001,
is_drop_out=True,
drop_out=0.7))
model.add(FCLayer(activation="softmax", n_neurons=10, l_rate=0.001))
print("-------------------------------------------------------")
print("CNN Layers:")
print("-------------------------------------------------------")
model.print_layers()
print("-------------------------------------------------------")
print("Begin Training...")
model.train(X, Y, n_epochs=150, print_loss=True, batch_size=32)
print("End Training.")
print("-------------------------------------------------------")
print("Begin Testing...")
train_accuracy = model.test(X, Y)
test_accuracy = model.test(X_test, Y_test)
print("End Testing.")
print("-------------------------------------------------------")
print('Training Accuracy: {0:0.2f} %'.format(train_accuracy))
print('Test Accuracy: {0:0.2f} %'.format(test_accuracy))
model.show_graph()
dat1 = ImageData(train_size=.75, gen_new_images=True)
cn5 = ConvNet(cross_validating=True, model_num=204, conv_layers=(16, 32, 64, 128),
dense_layers=(256, 128), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn5.fit(dat1)
sub5 = cn5.evaluate(dat1)
dat1 = ImageData(train_size=.75, gen_new_images=True)
cn6 = ConvNet(cross_validating=True, model_num=205, conv_layers=(16, 32, 64, 128),
dense_layers=(512, 256), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn6.fit(dat1)
sub6 = cn6.evaluate(dat1)
>>>>>>> 980052548dd8be2efd48a7a7fd93b484b6a3b985
dat1 = ImageData(train_size=.75, gen_new_images=True)
cn8 = ConvNet(cross_validating=True, model_num=206, conv_layers=(32, 64, 128, 256),
dense_layers=(256, 128), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn8.fit(dat1)
sub8 = cn8.evaluate(dat1)
dat1 = ImageData(train_size=.75, gen_new_images=True)
cn9 = ConvNet(cross_validating=True, model_num=207, conv_layers=(32, 64, 128, 256),
dense_layers=(512, 256), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn9.fit(dat1)
sub9 = cn9.evaluate(dat1)
dat1 = ImageData(train_size=.75, gen_new_images=True)
cn10 = ConvNet(cross_validating=True, model_num=208, conv_layers=(32, 64, 128, 128),
dense_layers=(256, 128), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn10.fit(dat1)
sub10 = cn10.evaluate(dat1)
def train(dl, config):
""" Train the model given the parameters in the config object
"""
writer = SummaryWriter(config.summary_path)
total_loss = 0
word_seq_size = dl.train_data.vocab_size_words + 1
chr_seq_size = dl.train_data.vocab_size_char + 1
max_sentence_length = max(dl.train_data.seq_size_words,
dl.test_data.seq_size_words,
dl.val_data.seq_size_words)
model = ConvNet(word_seq_size, chr_seq_size, max_sentence_length)
if torch.cuda.is_available():
model.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(),
lr=config.learning_rate,
momentum=0.9)
# Load checkpoint
if config.checkpoint:
checkpoint = torch.load(config.checkpoint)
model.load_state_dict(checkpoint['model'])
optimizer.load_state_dict(checkpoint['optimizer'])
epoch = checkpoint['epoch']
print("Checkpoint loaded")
best_acc = [0]
for index in range(config.n_iters):
t1 = time.time()
print('Starting on iteration {}'.format(index + 1))
# load new batch
batch_inputs_words, batch_inputs_chars, batch_targets_label, batch_targets_scores, _ = dl.train_data.next_batch(
config.batch_size, padding=True, type='long')
# print(batch_inputs_words.shape)
if torch.cuda.is_available():
batch_inputs_words, batch_inputs_chars, batch_targets_label, batch_targets_scores = batch_inputs_words.cuda(
), batch_inputs_chars.cuda(), batch_targets_label.cuda(
), batch_targets_scores.cuda()
optimizer.zero_grad()
# Forward pass to get output/logits
outputs = model(batch_inputs_words, batch_inputs_chars)
# Calculate Loss: softmax --> cross entropy loss
if torch.cuda.is_available():
label = batch_targets_label.type('torch.cuda.LongTensor').reshape(
-1)
else:
label = batch_targets_label.type('torch.LongTensor').reshape(-1)
loss = criterion(outputs, label)
total_loss += loss.item()
acc = calc_accuracy(outputs, label)
# niter = epoch*len(data_loader)+step
writer.add_scalar('loss', loss.item(), index)
# Getting gradients w.r.t. parameters
loss.backward()
nn.utils.clip_grad_norm_(model.parameters(), 1)
# Updating parameters
optimizer.step()
t2 = time.time()
examples_per_second = config.batch_size / float(t2 - t1)
if index % config.print_every == 0:
print('[{}]\t Step {}\t Loss {} \t Examples/Sec = {:.2f},'.format(
datetime.now().strftime("%Y-%m-%d %H:%M"), index, total_loss,
examples_per_second))
total_loss = 0
if index % config.save_every == 0:
save_checkpoint(model, optimizer, config.checkpoint_path)
if index % config.test_every == 0:
loss, acc = test(dl, index, model, test_size=500)
writer.add_scalar('accuracy', acc, index)
# Saving the best model
if acc > max(best_acc):
torch.save(model, 'best_model.pt')
best_acc.append(acc)
def main():
# base model with angle implemented
dat1 = ImageData(train_size=.75, gen_new_images=False)
cn1 = ConvNet(cross_validating=True, model_num=200, conv_layers=(64, 128, 128, 64),
dense_layers=(512, 256), epochs=500, learning_rate=0.001, dropout=0, patience=10)
cn1.fit(dat1)
sub1 = cn1.evaluate(dat1)
# lower learning rate
dat1 = ImageData(train_size=.75, gen_new_images=False)
cn2 = ConvNet(cross_validating=True, model_num=201, conv_layers=(64, 128, 128, 64),
dense_layers=(512, 256), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn2.fit(dat1)
sub2 = cn2.evaluate(dat1)
# lower lr, gen new images
dat1 =ImageData(train_size=.75, gen_new_images=True)
cn3 = ConvNet(cross_validating=True, model_num=202, conv_layers=(64, 128, 128, 64),
dense_layers=(512, 256), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn3.fit(dat1)
sub3 = cn3.evaluate(dat1)
# lower lr, dropout
dat1 =ImageData(train_size=.75, gen_new_images=False)
cn4 = ConvNet(cross_validating=True, model_num=203, conv_layers=(64, 128, 128, 64),
dense_layers=(512, 256), epochs=500, learning_rate=0.0001, dropout=.3, patience=10)
cn4.fit(dat1)
sub4 = cn4.evaluate(dat1)
# set 1
dat1 = ImageData(train_size=.75, gen_new_images=True)
cn5 = ConvNet(cross_validating=True, model_num=204, conv_layers=(16, 32, 64, 128),
dense_layers=(256, 128), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn5.fit(dat1)
sub5 = cn5.evaluate(dat1)
dat1 = ImageData(train_size=.75, gen_new_images=True)
cn6 = ConvNet(cross_validating=True, model_num=205, conv_layers=(16, 32, 64, 128),
dense_layers=(512, 256), epochs=500, learning_rate=0.0001, dropout=0, patience=10)
cn6.fit(dat1)
sub6 = cn6.evaluate(dat1)
def main() -> None:
dat1 = ImageData(test_size=.75, gen_new_images=True)
cn1 = ConvNet(cross_validating=True, model_num=16, conv_layers=(32, 64, 128, 256),
dense_layers=(256, 128), epochs=500, learning_rate=0.0001, patience=10)
cn1.fit(dat1)
sub1 = cn1.evaluate(dat1)
dat1 = ImageData(test_size=.75, gen_new_images=True)
cn2 = ConvNet(cross_validating=True, model_num=17, conv_layers=(32, 64, 128, 128),
dense_layers=(256, 128), epochs=500, learning_rate=0.0001, patience=10)
cn2.fit(dat1)
sub2 = cn2.evaluate(dat1)
dat1 =ImageData(test_size=.75, gen_new_images=True)
cn3 = ConvNet(cross_validating=True, model_num=18, conv_layers=(32, 64, 128, 256),
dense_layers=(512, 256), epochs=500, learning_rate=0.0001, patience=10)
cn3.fit(dat1)
sub3 = cn3.evaluate(dat1)
dat1 = ImageData(test_size=.75, gen_new_images=True)
cn4 = ConvNet(cross_validating=True, model_num=19, conv_layers=(16, 32, 64, 128),
dense_layers=(256, 128), epochs=500, learning_rate=0.0001, patience=10)
cn4.fit(dat1)
sub4 = cn4.evaluate(dat1)
dat1 = ImageData(test_size=.75, gen_new_images=True)
cn5 = ConvNet(cross_validating=True, model_num=20, conv_layers=(64, 128, 128, 64),
dense_layers=(256, 128), epochs=500, learning_rate=0.0001, patience=10)
cn5.fit(dat1)
sub5 = cn5.evaluate(dat1)
ensemble = pd.DataFrame([sub1.id,
sub1.is_icerberg,
sub2.is_iceberg,
sub3.is_iceberg,
sub4.is_iceberg,
sub5.is_iceberg]).T
l1_max_ks) + '_l2_conv_ks_' + str(
l2_conv_ks) + '_l2_max_ks_' + str(l2_max_ks)
print('\n\n' + 60 * '*' + '\n' + LOG_DIR + '\n' + 60 * '*' +
'\n\n')
writer = SummaryWriter(LOG_DIR + '/ConvNet_Adam_SL1_TotalLoss')
plot_iter = 0
# create data loader
trajs = trajs_dataset(trial_times_file='labels.csv',
trajs_dir='./CSV_files_DJT')
trajs_loader = DataLoader(trajs, batch_size=768, shuffle=True)
# instance of neural net
nnet = ConvNet(num_times=5,
l1_conv_ks=l1_conv_ks,
l1_max_ks=l1_max_ks,
l2_conv_ks=l2_conv_ks,
l2_max_ks=l2_max_ks)
nnet.to('cpu')
nnet.train()
# set up loss function and optimizer
eta = .01
criterion = nn.SmoothL1Loss()
optimizer = torch.optim.Adam(nnet.parameters(), lr=eta)
# train neural net
num_epochs = 200
for epoch in range(num_epochs):
for i, sample in enumerate(trajs_loader):
traj = sample['traj'].float().to('cpu')
from ConvNet import ConvNet
from Inception import Inception
import torch
import numpy as np
EPOCHS = 10
BATCH_SIZE = 8
ITERATION_DOMAINS = 500
VALIDATION_SIZE = 250
CPU_WORKERS = 16
LEARNING_RATE = 1e-3
WEIGHT_DECAY = 0
train_domains = np.loadtxt('../../data/our_input/train_domains.csv', dtype='O')
model = ConvNet().to("cuda")
opt = torch.optim.Adam(model.parameters(),
lr=LEARNING_RATE,
weight_decay=WEIGHT_DECAY)
train(model,
opt,
'../../steps/convnet_results',
train_domains,
EPOCHS=EPOCHS,
BATCH_SIZE=BATCH_SIZE,
ITERATION_DOMAINS=ITERATION_DOMAINS,
CPU_WORKERS=CPU_WORKERS)
del model, opt
torch.cuda.empty_cache()
class MNISTConvNetTestingTest(unittest.TestCase):
def setUp(self):
configPath = "MNIST_10_Config.ini"
self.net = ConvNet(configPath)
# import all images
self.imagesOf0s = extract_mnist.getMNISTTestSamplesNum(0)
self.imagesOf1s = extract_mnist.getMNISTTestSamplesNum(1)
self.imagesOf2s = extract_mnist.getMNISTTestSamplesNum(2)
self.imagesOf3s = extract_mnist.getMNISTTestSamplesNum(3)
self.imagesOf4s = extract_mnist.getMNISTTestSamplesNum(4)
self.imagesOf5s = extract_mnist.getMNISTTestSamplesNum(5)
self.imagesOf6s = extract_mnist.getMNISTTestSamplesNum(6)
self.imagesOf7s = extract_mnist.getMNISTTestSamplesNum(7)
self.imagesOf8s = extract_mnist.getMNISTTestSamplesNum(8)
self.imagesOf9s = extract_mnist.getMNISTTestSamplesNum(9)
def testTestAll(self):
numImages = 100 # number of images of each category
# combine all data sets
zeros = self.imagesOf0s[0:numImages]
ones = self.imagesOf1s[0:numImages]
twos = self.imagesOf2s[0:numImages]
threes = self.imagesOf3s[0:numImages]
fours = self.imagesOf4s[0:numImages]
fives = self.imagesOf5s[0:numImages]
sixs = self.imagesOf6s[0:numImages]
sevens = self.imagesOf7s[0:numImages]
eights = self.imagesOf8s[0:numImages]
nines = self.imagesOf9s[0:numImages]
data = np.concatenate((zeros, ones, twos, threes, fours, fives, sixs, \
sevens, eights, nines))
# set up labels
labels = []
for i in xrange(numImages):
labels.append("zero")
for i in xrange(numImages):
labels.append("one")
for i in xrange(numImages):
labels.append("two")
for i in xrange(numImages):
labels.append("three")
for i in xrange(numImages):
labels.append("four")
for i in xrange(numImages):
labels.append("five")
for i in xrange(numImages):
labels.append("six")
for i in xrange(numImages):
labels.append("seven")
for i in xrange(numImages):
labels.append("eight")
for i in xrange(numImages):
labels.append("nine")
# run test
maxEpochs = 1000
epochsPerSave = 5
self.net.trainSet(data, labels, maxEpochs, epochsPerSave)
self.net.testSet(data, labels)
self.net.saveFilters(1010)
self.net.saveActivations(1010)
# In[2]:
emotion_dict = np.load('emotion_dict.npy')
emotion_dict = emotion_dict.item()
names = np.load('songs.npy')
names = names.item()
# In[3]:
PATH = "model/model.pth"
num_classes = 6
model = ConvNet(num_classes)
model.load_state_dict(torch.load(PATH))
model.eval()
# In[4]:
songs_emo = {}
for k,track in names.items():
punct = ""
for c in track[0]:
if c in ['-', '!', '?', '(']:
punct = c
idx = track[0].find(punct)
val_set = 'val'
test_set = 'test'
val_subset = args.val_subset
# -------------------------------------------------------------------------------------------------
# Setup based model/network
# -------------------------------------------------------------------------------------------------
loss_fn = torch.nn.CrossEntropyLoss()
sm = torch.nn.Softmax(dim=1)
if datasource in ['omniglot', 'miniImageNet']:
from ConvNet import ConvNet
DIM_INPUT = {'omniglot': (1, 28, 28), 'miniImageNet': (3, 84, 84)}
net = ConvNet(dim_input=DIM_INPUT[datasource],
dim_output=None,
num_filters=(32, 32, 32, 32),
filter_size=(3, 3),
device=device)
elif datasource in ['miniImageNet_640', 'tieredImageNet_640']:
import pickle
from FC640 import FC640
net = FC640(num_hidden_units=(128, 32), dim_output=None, device=device)
else:
sys.exit('Unknown dataset!')
weight_shape = net.get_weight_shape()
# -------------------------------------------------------------------------------------------------
# Parse training parameters
# -------------------------------------------------------------------------------------------------
meta_lr = args.meta_lr
print('Meta learning rate = {0}'.format(meta_lr))
def setUp(self):
configPath = "../ini/MNIST10labels_50img_twoConv-trained-50.ini"
self.net = ConvNet(configPath)
(self.images, self.labels) = read_mnist.getMNISTTest()
def run_training():
trainX, trainY, validX, validY = load(one_hot=False, cv=-1)
mean = []
for shape in [trainX.shape, validX.shape]:
mean.append(
np.repeat(
np.mean(trainX.transpose([3, 0, 1, 2]).reshape(3, -1),
axis=1), shape[0] * shape[1] * shape[2]).reshape(
3, -1).transpose().reshape(shape[0], shape[1],
shape[2], shape[3]))
trainX = trainX - mean[0]
validX = validX - mean[1]
#testX = testX - mean[2]
with tf.Graph().as_default():
convNet = ConvNet(dropout=DROPOUT)
global_epoch = tf.Variable(0, trainable=False)
learning_rate = tf.Variable(INITIAL_LEARNING_RATE, trainable=False)
learning_rate_decay = tf.Variable(LEARNING_RATE_DECAY, trainable=False)
train_mode = tf.Variable(True, trainable=False)
X = tf.placeholder("float", [FLAGS.batch_size, 28, 28, 3])
Y = tf.placeholder("float", [FLAGS.batch_size])
phase = tf.placeholder("string")
logits = convNet.inference(X, FLAGS.batch_size, train_mode)
loss, cross_entropy_loss, accuracy = loss_and_accuracy(logits,
Y,
phase=phase)
avg_op = _add_loss_accuracy_summary(loss,
cross_entropy_loss,
accuracy,
phase=phase)
with tf.control_dependencies([avg_op]):
valid_op = tf.no_op(name='validation')
valid_loss_op = cross_entropy_loss
valid_acc_op = accuracy
valid_error_op = (1. - accuracy) * 100.
with tf.control_dependencies([avg_op]):
train_op = train(cross_entropy_loss, learning_rate,
learning_rate_decay, global_epoch)
loss_op = cross_entropy_loss
accuracy_op = accuracy
error_op = (1. - accuracy) * 100.
learning_rate_op = learning_rate
summary_op = tf.merge_all_summaries()
saver = tf.train.Saver(tf.all_variables(),
keep_checkpoint_every_n_hours=12.0)
init = tf.initialize_all_variables()
with tf.Session() as sess:
if FLAGS.checkpoint is not None:
saver.restore(sess=sess, save_path=FLAGS.checkpoint)
else:
sess.run(init)
tf.train.start_queue_runners(sess=sess)
current_epoch = global_epoch.eval(sess)
summary_writer = tf.train.SummaryWriter(FLAGS.save_directory,
graph_def=sess.graph_def)
best_error = 100.0
bad_cnt = 0
print("*** start training ***")
for epoch in xrange(current_epoch, FLAGS.max_epoch):
start_time = time.time()
training_steps = int(FLAGS.training_num / FLAGS.batch_size)
shuffler = np.random.permutation(FLAGS.training_num)
trainX = trainX[shuffler]
trainY = trainY[shuffler]
for step in xrange(training_steps):
start = step * FLAGS.batch_size
end = start + FLAGS.batch_size
thisX = trainX[start:end]
# random flip left right
if (np.random.randint(2) == 0):
thisX = thisX[:, :, ::-1, :]
# random crop to (28, 28)
ind = np.random.randint(4)
thisX = thisX[:, ind:ind + 28, ind:ind + 28, :]
# random gray with 20% prob
if (np.random.randint(5) == 0):
thisX = np.repeat(np.average(thisX, axis=3),
3).reshape(-1, 28, 28, 3)
thisY = trainY[start:end]
if step == training_steps - 1:
_, lr, loss, error, summary_string = sess.run(
[
train_op, learning_rate_op, loss_op, error_op,
summary_op
],
feed_dict={
X: thisX,
Y: thisY,
phase: 'train'
})
else:
_, lr, loss, error = sess.run(
[train_op, learning_rate_op, loss_op, error_op],
feed_dict={
X: thisX,
Y: thisY,
phase: 'train'
})
t = time.time() - start_time
examples_per_sec = FLAGS.batch_size * training_steps / t
print('epoch %d : lr = %.1e, loss = %.4f, error = %.2f'
'(%.1f examples/sec)' %
(epoch, lr, loss, error, examples_per_sec))
summary_writer.add_summary(summary_string, epoch)
# eval validation accuracy
if epoch % FLAGS.val_interval == 0:
val_loss_sum = 0.0
val_error_sum = 0.0
valid_steps = int(FLAGS.valid_num / FLAGS.batch_size)
sess.run(train_mode.assign(False))
start_time = time.time()
for v_step in xrange(valid_steps):
start = v_step * FLAGS.batch_size
end = start + FLAGS.batch_size
thisX = validX[start:end, 2:30, 2:30, :]
thisY = validY[start:end]
if v_step == valid_steps - 1:
_, val_loss, val_error, summary_string = sess.run(
[
valid_op, valid_loss_op, valid_error_op,
summary_op
],
feed_dict={
X: thisX,
Y: thisY,
phase: 'valid'
})
else:
_, val_loss, val_error = sess.run(
[valid_op, valid_loss_op, valid_error_op],
feed_dict={
X: thisX,
Y: thisY,
phase: 'valid'
})
val_loss_sum += val_loss
val_error_sum += val_error
val_loss = val_loss_sum / valid_steps
val_error = val_error_sum / valid_steps
t = time.time() - start_time
examples_per_sec = FLAGS.batch_size * valid_steps / t
print('[Valid] epoch %d : loss = %.4f, error = %.2f'
'(%.1f examples/sec)' %
(epoch, val_loss, val_error, examples_per_sec))
summary_writer.add_summary(summary_string, epoch)
sess.run(train_mode.assign(True))
if best_error > val_error:
best_error = val_error
bad_cnt = 0
else:
bad_cnt += 1
if bad_cnt > 5:
sess.run(learning_rate.assign(learning_rate * 0.1))
if epoch % 10 == 0:
saver.save(sess,
FLAGS.save_directory + '/model.ckpt',
global_step=step)
)
p_sine = 0.5
elif datasource == 'miniImageNet_embedding':
from FC640 import FC640
net = FC640(
dim_output=num_classes_per_task,
num_hidden_units=(128,),
device=device
)
elif datasource == 'miniImageNet':
from ConvNet import ConvNet
net = ConvNet(
dim_input=(3, 84, 84),
dim_output=num_classes_per_task,
num_filters=[32]*4
)
w_target_shape = net.get_weight_shape()
# print(w_target_shape)
num_weights = get_num_weights(my_net=net)
print('Number of weights of base model = \t {0:d}'.format(num_weights))
dst_folder_root = '.'
dst_folder = '{0:s}/Amortised_ML_few_shot_meta/Amortised_ML_{1:s}_{2:d}way_{3:d}shot'.format(
dst_folder_root,
datasource,
num_classes_per_task,
num_training_samples_per_class
k1 = 250
w1 = 30
k2 = 100
w2 = 10
poolw1 = 5
poolw2 = 5
n_packets = 300
pad1 = 1
pad2 = 2
Lin1 = 300
Lin2 = 80
Lin3 = 20
dropout = 0.05
DeepCorr_small = ConvNet(n_packets, k1, w1, k2, w2, poolw1, poolw2, Lin1,
Lin2, Lin3, pad1, pad2, dropout).to(device)
checkpoint = torch.load(
'JADE/final_small_good_fits_lr:0.001wd:0.001batch:90dropout:0.05DeepCorr.tar',
map_location=device)
DeepCorr_small.load_state_dict(checkpoint['model_state_dict'])
Outputs_small, losses_small = predict(DeepCorr_small,
inputs,
batch_size=10)
#Outputs_small2, losses_small2 = predict(DeepCorr_small, inputs, batch_size=10)
k1 = 600
w1 = 30
k2 = 250
w2 = 10
loss_fn = torch.nn.CrossEntropyLoss()
sm_loss = torch.nn.Softmax(dim=2)
# load data onto RAM
if train_flag:
all_class_train, embedding_train = load_dataset(datasource, train_set)
all_class_val, embedding_val = load_dataset(datasource, val_set)
else:
all_class_test, embedding_test = load_dataset(datasource, test_set)
if (datasource == 'omniglot'):
from ConvNet import ConvNet
net = ConvNet(dim_input=(1, 28, 28),
dim_output=num_classes_per_task,
num_filters=(64, 64, 64, 64),
filter_size=(3, 3),
device=device)
elif (datasource == 'miniImageNet') or (datasource == 'tieredImageNet'):
from ConvNet import ConvNet
net = ConvNet(dim_input=(3, 84, 84),
dim_output=num_classes_per_task,
num_filters=(32, 32, 32, 32),
filter_size=(3, 3),
device=device)
elif (datasource
== 'miniImageNet_embedding') or (datasource
== 'tieredImageNet_embedding'):
from FC640 import FC640
def main():
train = pd.read_csv(train_file, delimiter=" ", header=0)
tokenizer = pickle.load(open("../models/T1DGC/ConvNet/tokenizer.p", "rb"))
yEncoders = pickle.load(open("../models/T1DGC/ConvNet/yEncoders.p", "rb"))
# generate n-grams
max_seq_length = 0
for i in range(8):
train.iloc[:, i] = [
generate_n_grams(list(s), n_gram) for s in train.iloc[:, i]
]
max_seq_length = max(max([len(s) for s in train.iloc[:, i]]),
max_seq_length)
# Map words and labels to numbers
n_grams = []
for i in range(8):
n_grams += train.iloc[:, i].tolist()
tokenizer = Tokenizer(num_words=max_nb_words)
tokenizer.fit_on_texts(n_grams)
trainY = train.iloc[:, 8:16]
yEncoders = [LabelEncoder() for i in range(8)]
for i in range(8):
genename = trainY.columns[i]
yEncoders[i].fit(trainY[genename])
# Generate training, dev, and validation datasets
train, validation = train_validation_split(train, p=0.20)
train, dev = train_validation_split(train, p=0.15)
trainX, trainY = generate_feature_label_pair(train, tokenizer, yEncoders,
max_seq_length)
devX, devY = generate_feature_label_pair(dev, tokenizer, yEncoders,
max_seq_length)
validationY = []
validationX = np.zeros((validation.shape[0], 8, max_seq_length))
for i in range(8):
x = tokenizer.texts_to_sequences(validation.iloc[:, i])
validationX[:, i, :] = pad_sequences(x,
maxlen=max_seq_length,
padding='post')
genename = validation.columns[i + 8]
validationY.append(validation[genename])
# setup save file
result_columns = [
"embedding_dim", "batch_size", "n_1", "n_2", "n_3", "stride1",
"stride2", "maxpool", "dropout", "max_nb_words", "max_seq_length",
"validation_accuracy"
]
save_df = pd.DataFrame(index=list(range(n_searches)),
columns=result_columns)
start_time = time.time()
for i in range(n_searches):
if i % 10 == 0:
print("hyperparameter set {0}, {1} minutes".format(
i, round((time.time() - start_time) / 60)))
hyperparameters = {
"embedding_dim": np.random.choice(embedding_dims, 1)[0],
"batch_size": np.random.choice(batch_sizes, 1)[0],
"n_1": np.random.choice(n1_units, 1)[0],
"n_2": np.random.choice(n2_units, 1)[0],
"n_3": np.random.choice(n3_units, 1)[0],
"stride1": np.random.choice(strides1, 1)[0],
"stride2": np.random.choice(strides2, 1)[0],
"maxpool": np.random.choice(maxpools, 1)[0],
"dropout": np.random.choice(dropouts, 1)[0],
"max_nb_words": max_nb_words,
"max_seq_length": max_seq_length,
"stride": 1
}
overfitCallback = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=2,
verbose=0,
mode='auto')
model = ConvNet(yEncoders, hyperparameters)
model.fit(trainX,
trainY,
epochs=100,
batch_size=hyperparameters["batch_size"],
validation_data=(devX, devY),
callbacks=[overfitCallback])
predY = model.predict(validationX)
classPred = []
for j in range(len(validationY)):
numPredY = np.argmax(predY[j], axis=1)
predYname = yEncoders[j].inverse_transform(numPredY)
classPred.append(predYname)
validation_accuracy = round(accuracy_score(validationY, classPred), 4)
# record hyperparameters used
save_df.loc[i, "embedding_dim"] = hyperparameters["embedding_dim"]
save_df.loc[i, "batch_size"] = hyperparameters["batch_size"]
save_df.loc[i, "n_1"] = hyperparameters["n_1"]
save_df.loc[i, "n_2"] = hyperparameters["n_2"]
save_df.loc[i, "n_3"] = hyperparameters["n_3"]
save_df.loc[i, "stride1"] = hyperparameters["stride1"]
save_df.loc[i, "stride2"] = hyperparameters["stride2"]
save_df.loc[i, "maxpool"] = hyperparameters["maxpool"]
save_df.loc[i, "dropout"] = hyperparameters["dropout"]
save_df.loc[i, "max_nb_words"] = hyperparameters["max_nb_words"]
save_df.loc[i, "max_seq_length"] = hyperparameters["max_seq_length"]
save_df.loc[i, "validation_accuracy"] = validation_accuracy
save_df.sort_values(by=["validation_accuracy"],
ascending=False,
inplace=True)
save_df.to_csv(result_file, index=False)