def test_CNN_forward(): frame = torch.zeros((3, 108, 60)) layers_params = [(3, 32, 8, 4, 0, 1)] model = CNN(layers_params, None) assert model(frame).shape == (1, 32, 26, 14) layers_params = [(3, 32, 8, 4, 0, 1), (32, 64, 4, 2, 0, 1)] model = CNN(layers_params, None) assert model(frame).shape == (1, 64, 12, 6) return True
def __init__(self, dataset, size, NL_set, NF_set, lr_set, mom_set, indiv_list=[], \ train_loader=None, test_loader=None, train_batch_size=0, test_batch_size=0) : """ \Description: Build a population of random individual \Args : dataset : dataset used size : population's size (must be a multiple of 4) NL_set : set of possible values for the number of hidden layers NF_set : set of possible values for the number of feature maps lr_set : set of possible values for the learning rate mom_set : set of possible values for the momentum indiv_list : list of individuals train_loader : train loader test_loader : test_loader train_batch_size : size of the training batch test_batch_size : size of the testing batch \Outputs : None """ seed(654) # Set the random seed self.dataset = dataset # Dataset self.size = size # Size of the population # Those are sets of values to choose from to create an indivudal self.NL_set = NL_set self.NF_set = NF_set self.lr_set = lr_set self.mom_set = mom_set self.pop = indiv_list[:] # List of the individuals in the population self.train_loader = train_loader # Train loader self.test_loader = test_loader # Test loader self.train_batch_size = train_batch_size # Size of the training batch self.test_batch_size = test_batch_size # Size of the testing batch if indiv_list == []: # Create a random initial populations for i in range(0, self.size): # Append a random individual if torch.cuda.is_available(): self.pop.append( CNN.CNN(dataset=self.dataset, NL=choice(self.NL_set), NF=choice(self.NF_set), lr=choice(self.lr_set), mom=choice(self.mom_set)).cuda()) else: self.pop.append( CNN.CNN(dataset=self.dataset, NL=choice(self.NL_set), NF=choice(self.NF_set), lr=choice(self.lr_set), mom=choice(self.mom_set)))
def Ensemble_CNN(Data, Rs, Ns, M, full_list=False): """ Ensemble Clustering using Common-Nearest-Neighbor algorithm. Parameters ---------- Data : array Data x*y with x being the data points and y the features/dimensions. Rs : list of float Distance cut-offs R to be tested. Ns : list of int Neighbor cut-offs N to be tested. M : int Minimal number of data points within a cluster. full_list : bool, optional if True returns clustering results for every parameter set tested. The default is False. Returns ------- coclustering : array Array containing the x*x coclustering matrix. """ Tree = spatial.cKDTree(Data) coclustering = np.zeros((len(Data),len(Data))) norm = 0 if full_list: Cluster_list_full={} for R in Rs: neighborlist, number_neighbors = get_neighborlist_tree(Tree, R) for N in Ns: nc = np.copy(number_neighbors) Cluster_list = CNN.CNN(Data, R, N, M, Ensemble=True, neighborlist=neighborlist, number_neighbors=nc) for cluster in Cluster_list: x, y = np.meshgrid(cluster,cluster) coclustering[x,y]+=1 if Cluster_list: norm +=1 Cluster_list_full.update({str(R)+"_"+str(N):Cluster_list}) return coclustering/norm, Cluster_list_full else: for R in Rs: neighborlist, number_neighbors = get_neighborlist_tree(Tree, R) for N in Ns: nc = np.copy(number_neighbors) Cluster_list = CNN.CNN(Data, R, N, M, Ensemble=True, neighborlist=neighborlist, number_neighbors=nc) for cluster in Cluster_list: x, y = np.meshgrid(cluster,cluster) coclustering[x,y]+=1 if Cluster_list: norm +=1 return coclustering/norm
def main(args): # Adagrad requires model to be moved to GPU before instantiating the optimizer model = CNN(height=96, width=96, channels=3).to(DEVICE) ### CHECKPOINT - load parameters, args, loss ### if args.resume_checkpoint != None and args.resume_checkpoint.exists(): checkpoint = torch.load(args.resume_checkpoint) print( f"Resuming model {args.resume_checkpoint} that achieved {checkpoint['loss']} loss" ) model.load_state_dict(checkpoint['model']) old_epochs = args.epochs args = checkpoint['args'] args.epochs -= old_epochs train_loader = torch.utils.data.DataLoader( train_data, shuffle=True, batch_size=args.batch_size, pin_memory=True, num_workers=args.worker_count, ) test_loader = torch.utils.data.DataLoader( test_data, shuffle=False, batch_size=args.batch_size, num_workers=args.worker_count, pin_memory=True, ) # criterion = lambda logits, labels : torch.mean(torch.sqrt(torch.sum(nn.MSELoss(reduction="none")(logits, labels), dim=1))).requires_grad_(True) criterion = nn.MSELoss() optimizer = optim.Adagrad(model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay) if args.lr_decay: optimizer = optim.Adagrad(model.parameters(), lr_decay=0.1, lr=args.learning_rate, weight_decay=args.weight_decay) log_dir = get_summary_writer_log_dir(args) print(f"Writing logs to {log_dir}") summary_writer = SummaryWriter(str(log_dir), flush_secs=5) trainer = Trainer(model, train_loader, test_loader, criterion, optimizer, summary_writer, DEVICE) trainer.train(args.epochs, args.val_frequency, print_frequency=args.print_frequency, log_frequency=args.log_frequency, args=args) print("done training") summary_writer.close()
def run_model(model_name): vocab_size, word_embeddings, train_iter, valid_iter, test_iter = load_data.load_dataset( ) learning_rate = config.learning_rate batch_size = config.batch_size output_size = config.output_size hidden_size = config.hidden_size embedding_length = config.embedding_length epochs = config.epochs in_channels = config.in_channels out_channels = config.out_channels kernel_heights = config.kernel_heights stride = config.stride padding = config.padding keep_probab = config.keep_probab if model_name == 'CNN': model = CNN.CNN(batch_size, output_size, in_channels, out_channels, kernel_heights, stride, padding, keep_probab, vocab_size, embedding_length, word_embeddings) elif model_name == 'LSTM': model = LSTM_Attn.AttentionModel(batch_size, output_size, hidden_size, vocab_size, embedding_length, word_embeddings) loss_fn = F.cross_entropy path = "Saved Models/" for epoch in range(epochs): train_loss, train_acc = train_model(model, train_iter, epoch, loss_fn) val_loss, val_acc, y_test, y_pred = eval_model(model, valid_iter, loss_fn) _, f, o = helper.getResult(y_test, y_pred) current_f1 = f['f1-score'] checkpoint_model(model, path, current_f1, epoch + 1, model_name, 'max') print( f'Epoch: {epoch+1:02}, Train Loss: {train_loss:.3f}, Train Acc: {train_acc:.2f}%, Val. Loss: {val_loss:3f}, Val. Acc: {val_acc:.2f}%' ) load_saved_model(model, path + '{}_best.pth'.format(model_name)) test_loss, test_acc, y_test, y_pred = eval_model(model, test_iter, loss_fn) print(f'Test Loss: {test_loss:.3f}, Test Acc: {test_acc:.2f}%') print( " Overall # Fake " ) print( " precision recall f1-score # precision recall f1-score" ) _, f, o = helper.getResult(y_test, y_pred) res = helper.printResult(model_name, o, f) print(res) path = model_name + "_results.txt" helper.saveResults(path, res)
def trainModel(self): traningData, labels = self.loadTrainingData() cnn = CNN.CNN() cnn.build_model() cnn.train(traningData, labels, batch_size=128, nb_epoch=500, data_augmentation=False) cnn.save_model()
def on_evaluate_clicked(self): alert = QMessageBox() alert.setText('Evaluating Expression...please name the drawing!') # print(alert.exec_()) visibleImage = self.drawingArea.image self.drawingArea.resizeImage(visibleImage, self.drawingArea.size()) fileName = "CNN_input.JPG" visibleImage.save(fileName, "") neural_net = CNN.CNN() neural_net.predict(fileName)
def main(args): model = CNN(height=96, width=96, channels=3) ### CHECKPOINT - load parameters, args, loss ### if args.resume_checkpoint != None and args.resume_checkpoint.exists(): checkpoint = torch.load(args.resume_checkpoint) print( f"Resuming model {args.resume_checkpoint} that achieved {checkpoint['loss']} loss" ) model.load_state_dict(checkpoint['model']) old_epochs = args.epochs args = checkpoint['args'] args.epochs -= old_epochs train_loader = torch.utils.data.DataLoader( train_data, shuffle=True, batch_size=args.batch_size, pin_memory=True, num_workers=args.worker_count, ) test_loader = torch.utils.data.DataLoader( test_data, shuffle=False, batch_size=args.batch_size, num_workers=args.worker_count, pin_memory=True, ) criterion = nn.MSELoss() optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=args.nesterov) log_dir = get_summary_writer_log_dir(args) print(f"Writing logs to {log_dir}") summary_writer = SummaryWriter(str(log_dir), flush_secs=5) trainer = Trainer(model, train_loader, test_loader, criterion, optimizer, summary_writer, DEVICE) trainer.train(args.epochs, args.val_frequency, print_frequency=args.print_frequency, log_frequency=args.log_frequency, args=args) print("done training") summary_writer.close()
def network(image, K, W, U, b, h, GRUStacks, M, N, subsetNum): # running the CNN imageConvRunData = CNN(image, K) # running the GRU for k in range(subsetNum): (h, GRUStacks) = GRU_Cell(M, N, h, imageConvRunData[0][5][k], W, U, b, GRUStacks) return (imageConvRunData, GRUStacks)
def sort_cnn(image): a= transforms.Compose([transforms.Resize(32), transforms.CenterCrop(32), transforms.ToTensor(), transforms.Normalize(mean=[0.4, 0.4, 0.4], std=[0.2, 0.2, 0.2])]) pred_data = a(image) pred_data = pred_data.view(-1, 3, 32, 32) # rebuild tensor cnn = CNN.CNN().to(device) cnn.load_state_dict(torch.load("data/model/trained.pkl")) # Load model parameter weights sorted = cnn(pred_data.to(device)) pred = sorted.max(1, keepdim=True)[1] return pred.item()
def trainNetWithAllData(): unsupervisedData, data, labels = createTrainingSet() print "data.shape" print data.shape print "labels.shape" print labels.shape data = common.scale(data) unsupervisedData = None activationFunction = activationfunctions.Rectified() rbmActivationFunctionVisible = activationfunctions.Identity() rbmActivationFunctionHidden = activationfunctions.RectifiedNoisy() unsupervisedLearningRate = 0.0001 supervisedLearningRate = 0.001 momentumMax = 0.99 # net = db.DBN(4, [1200, 1500, 1000, len(args.emotions)], # binary=False, # activationFunction=activationFunction, # rbmActivationFunctionVisible=rbmActivationFunctionVisible, # rbmActivationFunctionHidden=rbmActivationFunctionHidden, # unsupervisedLearningRate=unsupervisedLearningRate, # supervisedLearningRate=supervisedLearningRate, # momentumMax=momentumMax, # nesterovMomentum=True, # rbmNesterovMomentum=True, # rmsprop=True, # miniBatchSize=20, # hiddenDropout=0.5, # visibleDropout=0.8, # momentumFactorForLearningRateRBM=False, # firstRBMheuristic=False, # rbmVisibleDropout=1.0, # rbmHiddenDropout=1.0, # preTrainEpochs=10, # sparsityConstraintRbm=False, # sparsityRegularizationRbm=0.001, # sparsityTragetRbm=0.01) # # net.train(data, labels, maxEpochs=200, # validation=False, # unsupervisedData=unsupervisedData) net = cnn.CNN(width=30, height=40, classes=len(args.emotions)) net.train(data, labels) with open(args.net_file, "wb") as f: pickle.dump(net, f) return net
def test_CNN_transform(): frame = np.zeros((3, 108, 60), dtype=np.uint8) layers_params = [(1, 1, 1, 1, 0, 1)] transform = transforms.Compose([ transforms.ToPILImage(), transforms.Grayscale(), transforms.Resize((54, 30)), transforms.ToTensor(), ]) model = CNN(layers_params, transform) assert model(frame).shape == (1, 1, 54, 30) return True
def __init__(self, input_shape, action_space, game_name, memory=MAX_EXPERIENCES, epsilon=1.0, min_epsilon=MIN_EPSILON, decay_rate=DECAY_RATE, batch_size=BATCH_SIZE, load_weights=True, test=False): self.action_set = action_space # if action_space <= 6 else 6 self.input_shape = input_shape self.memory_size = memory self.epsilon = epsilon self.epsilon_min = min_epsilon self.decay = decay_rate self.batch_size = batch_size self.game = game_name print("Action Set: ", self.action_set) filepath = str("Assets/Weights/" + self.game + "_weights") if load_weights else None self.policy_network = CNN( self.input_shape, self.action_set, batch_size=self.batch_size, weights=filepath if os.path.exists(filepath) else None) if not test: self.target_network = CNN(self.input_shape, self.action_set, batch_size=self.batch_size) self.target_network.model.set_weights( self.policy_network.model.get_weights()) self.experiences = []
def test_CNN_init(): layers_params = [(3, 64, 3, 1, 0, 1)] model = CNN(layers_params, None) assert isinstance(model.layers[0], nn.Conv2d) assert isinstance(model.layers[1], nn.BatchNorm2d) assert isinstance(model.layers[2], nn.ReLU) assert model.layers[0].in_channels == 3 assert model.layers[0].out_channels == 64 assert model.layers[0].kernel_size == (3,3) assert model.layers[0].stride == (1,1) assert model.layers[0].padding == (0, 0) assert model.layers[0].dilation == (1, 1) return True
def _compose_model(self) -> Model: model = CNN( output_dim=self.output_dim, activation_fn=self.activation, stochastic_parameters=True, linear_model=True, dropout=self.dropout_rate > 0, dropout_rate=self.dropout_rate, uniform_init_minval=self.uniform_init_minval, uniform_init_maxval=self.uniform_init_maxval, w_init=self.w_init, b_init=self.b_init, ) return model
def __init__(self,url,mode="TRAIN"): self.port = None self.mode = mode self.url = url if mode == "TRAIN": pygame.init() self.screen = pygame.display.set_mode((1280, 720)) clock = pygame.time.Clock() if mode == "AUTO": self.net = CNN.CNN() self.net.load_model('trained_dataset.h5') self.training_file = None
def training(): train_images, train_labels = input_data.get_files(TRAIN_DIR) batch_images, batch_labels = input_data.get_batches( train_images, train_labels, IMG_W, IMG_H, BATCH_SIZE, CAPACITY) train_logits = CNN.CNN(batch_images, BATCH_SIZE, N_CLASSES) train_loss = Layers.loss(train_logits, batch_labels) train_op = Layers.optimize(train_loss, learning_rate) train_accuracy = Layers.accuracy(train_logits, batch_labels) summary_op = tf.summary.merge_all() sess = tf.Session() train_writer = tf.summary.FileWriter(LOGS_TRAIN_DIR, sess.graph) saver = tf.train.Saver() sess.run(tf.global_variables_initializer()) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess=sess, coord=coord) try: for step in range(MAX_STEP): if coord.should_stop(): break _, tra_loss, tra_acc = sess.run( [train_op, train_loss, train_accuracy]) if step % 50 == 0: print( 'Step %d, the training loss is %.2f, train accuracy is %.2f%%' % (step, tra_loss, tra_acc)) summary_str = sess.run(summary_op) train_writer.add_summary(summary_str, step) if step % 2000 == 0: checkpoint_path = os.path.join(LOGS_TRAIN_DIR, 'model.ckpt') saver.save(sess, checkpoint_path, global_step=step) except tf.errors.OutOfRangeError: print('Training Done.') finally: coord.request_stop() coord.join(threads) sess.close()
def main(_): test_data, test_labels = load_data() test_size = len(test_data) # print(test_size) test_X = tf.placeholder(tf.float32, shape=(EVAL_BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, NUM_CHANNELS)) with tf.name_scope('cnn_model'): cnn = CNN.CNN(NUM_LABELS, EVAL_BATCH_SIZE, EVAL_BATCH_SIZE, IMAGE_SIZE, NUM_CHANNELS, SEED) eval_prediction = tf.nn.softmax(cnn.model(test_X, drop_out=False)) # Get all predictions for a dataset by running it in small batches. def eval_in_batches(data, sess): size = data.shape[0] if size < EVAL_BATCH_SIZE: raise ValueError("batch size for evals larger than dataset: %d" % size) predictions = np.ndarray(shape=(size, NUM_LABELS), dtype=np.float32) for begin in xrange(0, size, EVAL_BATCH_SIZE): end = begin + EVAL_BATCH_SIZE if end <= size: predictions[begin:end, :] = sess.run( eval_prediction, feed_dict={test_X: data[begin:end, ...]}) else: batch_predictions = sess.run( eval_prediction, feed_dict={test_X: data[-EVAL_BATCH_SIZE:, ...]}) predictions[begin:, :] = batch_predictions[begin - size:, :] return predictions # test process saver = tf.train.Saver() with tf.Session() as sess: tf.global_variables_initializer().run() # reload model ckpt = tf.train.latest_checkpoint(MODEL_PATH) saver.restore(sess, ckpt) predictions = eval_in_batches(test_data, sess) test_error = error_rate(predictions, test_labels) acc = 100.0 - test_error print('accuracy: %.1f%%' % acc)
def restore_model(checkpoint_path, vocab_size): image_features_extract_model = CNN() encoder = CNN_Encoder(embedding_dim) decoder = RNN_Decoder(embedding_dim, units, vocab_size) optimizer = tf.keras.optimizers.Adam() ckpt = tf.train.Checkpoint(encoder=encoder, decoder=decoder, optimizer=optimizer) ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5) # if a checkpoint exists, restore the latest checkpoint. if ckpt_manager.latest_checkpoint: ckpt.restore(ckpt_manager.latest_checkpoint) print('Latest checkpoint restored!') return image_features_extract_model, encoder, decoder
def __init__(self, snapshot_index=0): global class_index global predict_index class_index = int(sys.argv[2]) predict_index = int(sys.argv[3]) self.data = Data("../input/" + class_names[predict_index] + "_test.list", log="../log/test.data", Test=True, class_name=class_names[class_index]) self.local_search_log = open("../log/local_search.log", "w") qnetwork = cPickle.load( open("../output/qnetwork/" + str(snapshot_index) + ".pkl", "r")) self.qnetwork = qnetwork self.qnetwork.reset_q() self.cnn = CNN("/mnt/caffenet.model", "/mnt/caffenet.deploy")
def __init__(self, metadata: Optional[MetaData] = None, *args, **kwargs) -> None: super().__init__() # Populate self.hparams with args and kwargs automagically! # We want to skip metadata since it is saved separately by the NNCheckpointIO object. # Be careful when modifying this instruction. If in doubt, don't do it :] self.save_hyperparameters(logger=False, ignore=("metadata",)) self.metadata = metadata # example metric = torchmetrics.Accuracy() self.train_accuracy = metric.clone() self.val_accuracy = metric.clone() self.test_accuracy = metric.clone() self.model = CNN(num_classes=len(metadata.class_vocab))
def init_CNN(): # Initializes NN classifier clf = CNN( layer_sizes = [ {'type':'conv', 'f_H':3, 'f_W':3, 'n_C':10, 'stride':1, 'pad':0}, {'type':'pool', 'f_H':2, 'f_W':2, 'stride':2, 'mode':'max'}, {'type':'fc', 'size':20}, {'type':'fc', 'size':20} ], learning_rate = 0.0005, max_iter = 75, L2 = 0, beta1 = 0.9, beta2 = 0.999, minibatch_size = 540, activation = 'relu', classification = 'multiclass', plot_N = 1, end_on_close = False, end_on_delete = True) return clf
def prediction(ModelName, lines): string = '' wordList = [] for image in lines: #if type(image) is str: # case of "," if image == ',': wordList.append(string) string = '' else: #calling model if ModelName == 'SVM': prediction = SVM.SVM(image) if ModelName == 'CNN': prediction = CNN.CNN(image) # if ModelName == 'KNN': # prediction = SVM.SVM(image) # string += prediction return wordList # word_list=prediction() # print(word_list)
from PIL import Image import numpy as np np.random.seed(10) # Set the seed for reproductibility PATCH_SIZE = 16 #Size of the patch WINDOW_SIZE = 64 #Size of the context ORIGINAL_SIZE = 400 #Size of the training images BATCH_SIZE = 16 #Size of the batch num_epoch = 40 #Number of epochs learning_rate = 1e-4 #Initial learning rate seed = 10 #Seed for reproductibility pad_size = int((WINDOW_SIZE - PATCH_SIZE) / 2) #Padding at each border #Instantiate the CNN New_CNN = CNN(num_epoch, learning_rate, PATCH_SIZE, WINDOW_SIZE, ORIGINAL_SIZE, BATCH_SIZE) print("") save_stuff = "" while not (save_stuff is "1" or save_stuff is "2" or save_stuff is "3" or save_stuff is "4"): print("Choose one : ") print("Predict the Kaggle result [1]") print("Train the Kaggle Model, VGG16 + classifier [2]") print("Train VGG16 from scratch [3]") print("Train the custom CNN from scratch [4]") save_stuff = input("Choose one of [1,2,3,4]") if save_stuff == "1": #Load the model
from MultiLayerPerceptron import * from CNN import * import mnist_loader import matplotlib.pyplot as plt import numpy as np training, validation, test = mnist_loader.load_data() offset = 1000 t = training[0][0:offset], training[1][0:offset] offsetv = 500 v = validation[0][0:offsetv], validation[1][0:offsetv] #reshape x 28:28 #ndimage.convolve dla kazdego filtra i zapisac wynik w jakiejs liscie a = CNN([980, 50, 10], None, 3, 1, 1) a.train(t, v, 20, 0.001, 64, softplus_function, sigmoid_function, 20)
def trainingCNN(): # get the 32*32 pixel normalized picture with Center cut # Unify the pictures that need to be input to the model image_process = transforms.Compose([ transforms.Resize(32), transforms.CenterCrop(32), transforms.ToTensor(), transforms.Normalize(mean=[0.4, 0.4, 0.4], std=[0.2, 0.2, 0.2]) ]) train_data = ImageFolder(root="data/train_set", transform=image_process) test_data = ImageFolder(root="data/test_set", transform=image_process) train_loader = DataLoader(train_data, batch_size=10, shuffle=True, num_workers=1) test_loader = DataLoader(test_data, batch_size=5, shuffle=True, num_workers=1) cnn = CNN.CNN().to(device) optimizer = torch.optim.Adam(cnn.parameters(), lr=0.001) # Use Adam optimizer for epoch in range(3): # edit epoch here for step, (img, label) in enumerate(train_loader): img, label = img.to(device), label.to(device) sort = cnn(img) loss = torch.nn.functional.nll_loss( sort, label) # Use maximum likelihood / log likelihood cost function optimizer.zero_grad( ) # Pytorch will accumulate the gradient, so the gradient needs to be cleared # waste my a lot of time! loss.backward() optimizer.step() # Use Adam for gradient update if (step + 1) % 3 == 0: print( f'Train Epoch: {epoch + 1} [{step * len(img)}/{len(train_loader.dataset)} ({100. * step / len(train_loader):.0f}%)]\tLoss: {loss.item():.4f}' ) cnn.eval() # Check model accuracy test_loss = 0 correct = 0 with torch.no_grad(): for img, label in test_loader: img, label = img.to(device), label.to(device) sort = cnn(img) test_loss += torch.nn.functional.nll_loss(sort, label, reduction='sum').item() pred = sort.max(1, keepdim=True)[1] correct += pred.eq(label.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) print( f'\ntest loss={test_loss:.4f}, accuracy={float(correct) / len(test_loader.dataset):.4f}\n' ) try: os.makedirs("data/model/") except OSError as e: if e.errno == 17: # 17 means this file are already exists pass else: raise torch.save(cnn.state_dict(), "data/model/trained.pkl" ) # Save the model weights to the model directory
import TFE as tfet import mct_config as mctconfig from MCT import * import time import random as rnd import sys import random import CNN as cnn import torch.nn as nn from torch.autograd import Variable from torch.utils.data import DataLoader,TensorDataset import torch # All the lovely neural network stuff goes here. BOARD_WIDTH = 4 NN = cnn.CNN(BOARD_WIDTH * BOARD_WIDTH * 12) criterion = nn.MSELoss() optimizer = torch.optim.Adam(NN.parameters(), lr=0.01) # Function to generate tuples of size two: # ( # UCB to next state taking direction i, # current node value # ) # Input is specified NxN play field. # UCB should be in dictionary form where # keys are shown in DIR_KEY within mct_config def generateValue(grid): NN.train(False) # Convert numpy grid to input for NN.
# * A convolutional layer contains N (count) x 3D convolutional kernels (FH, FW, C) which works on their 3D input activation (H, W, C). # * A fully connected layer contains a 2D (H, W) weight matrix (+ biases - count like output), # where the W represents the flattened input activation map all pixels and H is the output vector elements. layerTypeList = ["Convolution", "Convolution", "FullyConnected"] # Describe the activation function types for each layer in a list. The list element can be "sigmoid", "linear", "relu", "softmax". # NOTE: The "softmax" derivate function is not same with the literature. It is not reliable. Avoid to use it yet. activationTypeList = ["relu", "sigmoid", "softmax"] # Describe convolutional layer patterns [N, H, W, C], [count, height, width, channels] of kernels. # Describe fully connected layer pattern [K, C], [all pixels of previous layer, output count] of kernels. # WARNING: The Ni and Ci must be same between two consecutive convolutional layers. weightSizeList = [[20, 5, 5, 1], [20, 3, 3, 20], [20 * 7 * 7, 10]] # Initialization of a network. cnn = CNN.CNN(initializationType, layerTypeList, activationTypeList, weightSizeList) print("[" + __file__ + "]" + "[INFO]" + " CNN initialized.") # TODO image preprocessing need to be modified and moved into a class/utility script. print("[" + __file__ + "]" + "[INFO]" + " Preprocessing images.") numberOfTrainExample = 200 xx = [None] * numberOfTrainExample yy = [None] * numberOfTrainExample for i in range(numberOfTrainExample): # xx is a list which contains selected images in 28x28 numpy array xx[i] = numpy.reshape(numpy.asarray(trainImages[i], dtype=numpy.float128), (28, 28, 1)) yy[i] = numpy.asarray(trainLabels[i]) print("[" + __file__ + "]" + "[INFO]" + " Start training.") cnn.train(xx, yy, batchSize=1, numberOfEpochs=5, learningRate=0.0001)
def main(args): model = CNN(height=96, width=96, channels=3).to(DEVICE) ### CHECKPOINT - load parameters, args, loss ### if args.resume_checkpoint != None and args.resume_checkpoint.exists(): if torch.cuda.is_available(): checkpoint = torch.load(args.resume_checkpoint) else: # if CPU is used checkpoint = torch.load(args.resume_checkpoint, map_location=torch.device('cpu')) print(f"Testing model {args.resume_checkpoint} that achieved {checkpoint['loss']} loss") model.load_state_dict(checkpoint['model']) # visualise filters learnt by first conv layer weight = model.conv1.weight.data # normalise between 0 and 1 min_val = torch.min(weight) max_val = torch.max(weight) norm_weight = (weight - min_val)/(max_val - min_val) fig, axes = plt.subplots(4,8) fig.suptitle("Filters of First Convolutional Layer") for i in range(4): for j in range(8): filter = norm_weight[8*i+j].cpu() axes[i, j].imshow(filter.permute(1,2,0)) axes[i, j].axis('off') axes[i, j].set_title(8*i+j+1) plt.savefig(args.filter_path, dpi=fig.dpi) print(f"Filters of first conv layer saved to {args.filter_path}") test_loader = torch.utils.data.DataLoader( test_data, shuffle=False, batch_size=args.batch_size, num_workers=args.worker_count, pin_memory=True, ) criterion = nn.MSELoss() preds = np.empty([0, 2304]) total_loss = 0 model.eval() # No need to track gradients for validation, we're not optimizing. with torch.no_grad(): for batch, labels in test_loader: batch = batch.to(DEVICE) labels = labels.to(DEVICE) logits = model(batch) loss = criterion(logits, labels) total_loss += loss.item() preds = np.vstack((preds, logits.cpu().numpy())) average_loss = total_loss / len(test_loader) print(f"validation loss: {average_loss:.5f}") # Save predictions to preds.pkl and view it with visualisation/evaluation with open(args.preds_path, "wb") as f: pickle.dump(preds, f) print(f"Saved predictions to {args.preds_path}")
# train the model # shuffle data randomOrder = np.random.permutation(len(segmentedData[:, 0, 0])) labelRandom = labels[randomOrder] segmentedDataRandom = segmentedData[randomOrder] #f1 score over all validations fScoreOverall = [] # split the dataset in five parts to train with 4 and test with 1 --> cross fold validation samples = len(segmentedData[:, 0, 0]) sections = round(samples / len(listOfPatients)) for idx in range(len(listOfPatients)): # create new CNN cnn = CNN.CNN() cnn.create_model(len(listOfSensors)) teststart = idx*sections testend = teststart + sections testData = segmentedDataRandom[teststart:testend, :, :] testLabel = labelRandom[teststart:testend] # trainData = segmentedDataRandom[0:idx*sections, :, :] + segmentedDataRandom[idx*sections+sections:, :, :] trainData = np.concatenate((segmentedDataRandom[0:idx*sections, :, :], segmentedDataRandom[idx*sections+sections:, :, :])) trainLabel = np.concatenate((labelRandom[0:idx*sections], labelRandom[idx*sections+sections:])) # from label to onehot Vector oneHotGT = DataHandler.getOneHotGTVectotr(trainLabel)