def findOptimalParams(model0, regularizerModule, paramsModule, subtrain, valid, n, p): X_subtrain, Y_subtrain = subtrain[0], subtrain[1] X_valid, Y_valid = valid[0], valid[1] model = model0.copy() model.X, model.Y_ = X_subtrain, Y_subtrain model.N = X_subtrain.shape[0] i = 0 j = 0 v = np.inf model_star = model0.copy() i_star = i paramsModule.niter = n lossClass = lossModule.Loss(model, paramsModule, regularizerModule, Y_subtrain) optimizationClass = optimizator.Optimizator(model, paramsModule, args.optimizer) while j < p: train(model, paramsModule, lossClass, optimizationClass, X_subtrain) i = i + n Y = classify(X_valid, model) accuracy, pr, M = data.eval_perf_multi(Y, Y_valid) v_prime = 1. - accuracy if v_prime < v: j = 0 model_star = model.copy() i_star = i v = v_prime else: j = j + 1 return model_star, i_star, v
def train(self, X, Yoh_, param_niter, param_print_step=-1): if param_print_step < 0: param_print_step = param_niter / 10 # parameter intiailization self.session.run(tf.global_variables_initializer()) # optimization loop for i in range(param_niter): self.session.run([self.loss, self.train_step], feed_dict={ self.X: X, self.Yoh_: Yoh_ }) if i % param_print_step == 0: accuracy = data.eval_perf_multi(self.eval(X), Yoh_) print("Iteration = ", i, ", Loss = ", self.loss, ", Accuracy = ", accuracy)
# instanciraj podatke X i labele Yoh_ X, Y_ = data.sample_gauss_2d(3, 100) X, Y_ = torch.tensor(X, dtype=torch.float), torch.tensor(Y_, dtype=torch.long) Yoh_ = torch.nn.functional.one_hot(Y_) # definiraj model: ptlr = PTLogreg(X.shape[1], Yoh_.shape[1]) # nauči parametre (X i Yoh_ moraju biti tipa torch.Tensor): train(ptlr, X, Yoh_, 50000, 1e-2, 1e-6) X, Y_ = X.numpy(), Y_.numpy() # dohvati vjerojatnosti na skupu za učenje probs = eval(ptlr, X) Y = np.argmax(probs, axis=1) # ispiši performansu (preciznost i odziv po razredima) accuracy, recall, precision = data.eval_perf_multi(Y, Y_) print(accuracy, recall, precision) # iscrtaj rezultate, decizijsku plohu decfun = lambda X: eval(ptlr, X) bbox = (np.min(X, axis=0), np.max(X, axis=0)) data.graph_surface_multi(decfun, bbox, offset=0.5) data.graph_data(X, Y_, Y, special=[]) plt.show()
config = [2, 10, 10, 2] # instanciraj podatke X i labele Yoh_ X, Y_ = data.sample_gmm_2d(6, 2, 10) Yoh_ = F.one_hot(torch.from_numpy(Y_), config[-1]) # definiraj model: ptdeep = PTDeep(config, torch.relu) # nauči parametre (X i Yoh_ moraju biti tipa torch.Tensor): train(ptdeep, torch.from_numpy(X), Yoh_, 10_000, 0.1) # dohvati vjerojatnosti na skupu za učenje probs = eval(ptdeep, X) Y = np.argmax(probs, axis=1) # ispiši performansu (preciznost i odziv po razredima) accuracy, pr, _ = data.eval_perf_multi(Y, Y_) print(f'accuracy: {accuracy}, precision: {pr[0]}, recall: {pr[1]}') # Ispiši imena i broj parametara ptdeep.count_params() # iscrtaj rezultate, decizijsku plohu decfun = pt_deep_decfun(ptdeep) bbox = (np.min(X, axis=0), np.max(X, axis=0)) data.graph_surface(decfun, bbox, offset=0.5) data.graph_data(X, Y_, Y, special=[]) # Prikaži plt.show()
scores1 = np.dot(X, w1.transpose()) + b1 # NxH #ReLU h1 = np.maximum(0, scores1) # NxH scores2 = np.dot(h1, w2.transpose()) + b2 # NxC #softmax expscores = np.exp(scores2) # NxC sumexp = expscores.sum(axis=1) # Nx1 return (expscores.transpose() / sumexp).transpose() if __name__ == '__main__': np.random.seed(32) X, Y = sample_gmm_2d(6, 2, 10) ##X=np.array([[1,3],[1,1],[3,2], [3,3]]);Y=np.array([1,0,2,2]) w1, b1, w2, b2 = fcann2_train(X, Y) Y_ = np.empty((0, 0), dtype=np.int64) # get class by doing argmax on vector (highest value = predicted class) ##for v in fcann2_classify(X, w1, b1, w2, b2): ## Y_ = np.append((Y_), np.argmax(v)) Y_ = np.argmax(fcann2_classify(X, w1, b1, w2, b2), axis=1) # axis=1 - horizontally accuracy, conf_mat, prec_recall = data.eval_perf_multi(Y, Y_) print('accuracy:', accuracy) plt.scatter(X[:, 0], X[:, 1], c=Y) plt.show()
tf.set_random_seed(100) np.random.seed(100) mnist = input_data.read_data_sets(tf.app.flags.FLAGS.data_dir, one_hot=True) N = mnist.train.images.shape[0] D = mnist.train.images.shape[1] C = mnist.train.labels.shape[1] network = TFDeep([D, C], param_delta=0.5) print(":::::::::::::::::::::::") print(":::::::::::::::::::::::") print(":::::::::::::::::::::::") network.train_batch(mnist.train.images, mnist.train.labels, 500, param_print_step=25, param_batch_size=1000) print(":::::::::::::::::::::::") print(":::::::::::::::::::::::") print(":::::::::::::::::::::::") # predict probabilities of the data points probs = network.eval(mnist.test.images) Y = probs.argmax(axis=1) Y_ = mnist.test.labels.argmax(axis=1) # print performance (per-class precision and recall) accuracy, _, _ = data.eval_perf_multi(Y_, Y) print("Accuracy = ", accuracy)
# initialize the random number generator np.random.seed(100) tf.set_random_seed(100) # instantiate the data X and the labels Yoh_ X, Y_ = data.sample_gmm_2d(5, 3, 40) Yoh_ = data.class_to_one_hot(Y_) # build the graph: tfdeep = TFDeep([2, 10, 3], param_delta=0.01) tfdeep.count_params() # perform the training with given hyper-parameters: tfdeep.train(X, Yoh_, 100000) # predict probabilities of the data points probs = tfdeep.eval(X) Y = probs.argmax(axis=1) # print performance (per-class precision and recall) accuracy = data.eval_perf_multi(Y, Y_) print("Accuracy = ", accuracy) # draw results, decision surface decfun = lambda x: tfdeep.eval(x).max(axis=1) bbox = (np.min(X, axis=0), np.max(X, axis=0)) data.graph_surface(decfun, bbox, offset=0.5) data.graph_data(X, Y_, Y, special=[]) plt.show()
pt_deep.train(model, x_train, y_train_oh, args.param_niter, args.param_delta, trace=loss_trace, param_lambda=args.param_lambda, X_val=x_val, Y_val_oh_=y_val_oh) x_test = x_test.reshape(-1, 784).to(device) probs = model(x_test) Y = probs.cpu().detach().numpy().argmax(axis=1) print('Test scores:') test_accuracy, recall, precision = data.eval_perf_multi(Y, y_test) print(test_accuracy, recall, '\n', precision) probs = model(x_train) Y = probs.cpu().detach().numpy().argmax(axis=1) print('Train scores:') train_accuracy, recall, precision = data.eval_perf_multi(Y, y_train) print(train_accuracy, recall, '\n', precision) run_time = time.time() - t0 print('Train and eval run in %.3f s' % run_time) if args.model_idx == 0 and args.show_weights: show_model_weights(model)
# instanciraj podatke X i labele Yoh_ X, Y_ = data.sample_gauss(3, 100) Yoh_ = data.class_to_onehot(Y_) # izgradi graf: tflr = TFLogreg(X.shape[1], Yoh_.shape[1], 0.004) # nauči parametre: tflr.train(X, Yoh_, 20000) # dohvati vjerojatnosti na skupu za učenje probs = tflr.eval(X) Y = [np.argmax(ps) for ps in probs] # ispiši performansu (preciznost i odziv po razredima) accuracy, recall, precision = data.eval_perf_multi(Y_, np.array(Y)) print('acc:', accuracy, '\n rec', recall) plt.show() # iscrtaj rezultate, decizijsku plohu bbox = (np.min(X, axis=0), np.max(X, axis=0)) data.graph_surface(logreg_classify_function(tflr), bbox, offset=0.5, width=256, height=256) # graph the data points data.graph_data(X, Y_, Y) # show the plot plt.show()
def classify(X): return logreg_classify(X, w, b) return classify if __name__ == "__main__": np.random.seed(100) # get the training dataset X, Y_ = data.sample_gmm(5, 2, 100) # train the model W, b = logreg_train(X, Y_) # evaluate the model on the training dataset probs, logprobs = logreg_classify(X, W, b) Y = np.argmax(probs, axis=1) # report performance accuracy, confusion_matrix, recall = data.eval_perf_multi(Y, Y_) print(accuracy, confusion_matrix, recall) data.graph_data(X, Y_, Y, special=[]) decfun = logreg_decfun(W, b) bbox = (np.min(X, axis=0), np.max(X, axis=0)) #data.graph_surface(decfun, bbox, offset=0.5) plt.show()
download=True) x_train, y_train = mnist_train.data, mnist_train.targets x_test, y_test = mnist_test.data, mnist_test.targets x_train, x_test = x_train.float().div_(255.0), x_test.float().div_(255.0) y_oh_train = F.one_hot(y_train, config[-1]) y_oh_test = F.one_hot(y_test, config[-1]) N = x_train.shape[0] D = x_train.shape[1] * x_train.shape[2] C = y_train.max().add_(1).item() model = PTDeep(config, torch.relu) train(model, x_train.view(-1, D), y_oh_train, 100, 0.1) # train_mb(model, x_train.view(-1, D), y_oh_train, 100, 100, 1e-4) # Prikazi slike koje najvise doprinose funkciji gubitka # show_high_loss_pics(model, x_train, y_oh_train) # dohvati vjerojatnosti na skupu za učenje probs = eval(model, x_test.view(-1, D)) Y_pred = np.argmax(probs, axis=1) # ispiši performansu (preciznost i odziv po razredima) accuracy, pr, _ = data.eval_perf_multi(Y_pred, y_test) print(f'accuracy: {accuracy}, precision: {pr[0]}, recall: {pr[1]}') # Ispiši imena i broj parametara model.count_params() # show_weight_matrix(model)