def compare_to_ann(): """ Regression problem on two functions (sin, square) with added noise using batch learning with a 2 layer neural network """ epochs = 5000 hidden_neurons = 63 # same number as RBF nodes output_neurons = 1 sin, square = generate_data.sin_square(verbose=verbose) sin = add_noise_to_data(sin) square = add_noise_to_data(square) data = square # use which dataset to train and test batch_size = data.train_X.shape[ 0] # set batch size equal to number of data points ann = ANN(epochs, batch_size, hidden_neurons, output_neurons) y_pred = ann.solve(data.train_X, data.train_Y, data.test_X, data.test_Y) error = 0. for i in range(data.test_Y.shape[0]): error += np.abs(data.test_Y[i] - y_pred[i]) test_error = error / data.test_Y.shape[0] print('Test error: ', test_error) plotter.plot_2d_function(data.test_X, data.test_Y, y_pred=y_pred)
def evaluate(ind): ann = ANN(ind) error = 0.0; for i in range(0,inputs.shape[0]): out=ann.evaluate(inputs[i]) error = error + ((out[0]-outputs[i][0])**2) + ((out[1]-outputs[i][1])**2) return error,
def train(text, continue__ = 0): global data_size, data_len, char_size data = sample_data(text, sample_num = data_size, data_len = data_len) print data[0].shape print data[1].shape l = int(data_size * 0.7) datasets = [(shared(data[0][:l]), shared(data[1][:l])), (shared(data[0][l:]), shared(data[1][l:]))] #ann theano.config.exception_verbosity='high' theano.config.on_unused_input='ignore' if not continue__: cl = ANN(data_len * char_size, char_size, hiddens = [100, 100], lmbd = 0) cl.fit(datasets, lr = theano.tensor.cast(2, theano.config.floatX), n_epochs = 200, batch_size = 200) dump(cl, open('save.dat', 'wb')) else: try: os.rename('save.dat', 'origin.dat') except: pass cl = load(open('origin.dat','rb')) print cl cl.fit(datasets, lr = theano.tensor.cast(1, theano.config.floatX), n_epochs = 100, batch_size = 200) dump(cl, open('save.dat', 'wb'))
def __init__(self, D_hidden_dim, G_hidden_dim, z_dim, hyperparams={}, dataset='mnist', image_dim=None): self.dataset = dataset if dataset.lower() == 'mnist': image_dim = 28 * 28 self.digit = hyperparams.get("digit", 2) elif dataset.lower() == 'celeba_bw': print("This basic GAN version probably will not converge. \ See TTitcombe/GANmodels for more powerful versions \ (in development)") image_dim = 178 * 218 elif dataset is None and image_dim is None: raise RuntimeError("You must either define a recognised dataset \ or define an input image dimension") else: raise NotImplementedError("The dataset you have selected \ is not recognised") self.epochs = hyperparams.get("epochs", 100) self.batchSize = hyperparams.get("batchSize", 64) self.lr = hyperparams.get("lr", 0.001) self.decay = hyperparams.get("decay", 1.) self.epsilon = hyperparams.get("epsilon", 1e-7) #avoid overflow self.D = ANN(image_dim, D_hidden_dim, 1, self.lr, False) self.G = ANN(z_dim, G_hidden_dim, image_dim, self.lr, True)
def train_sgd(): data = load(FNAME) global MIN, MAX MIN = data.min(axis=0)[:-3] MAX = data.max(axis=0)[:-3] MIN[MIN==MAX] = 0. div = (MAX - MIN) div[div==0.] = 0.00000001 data[:,:-3] /= div global TRAIN_POS, TRAIN_NEG TRAIN_POS = (data[:,-3] == 1).sum() TRAIN_NEG = (data[:,-3] == 0).sum() loss = "log" #loss = "modified_huber" # c_t0 = SGDClassifier(loss, n_iter=5) # c_t1 = SGDClassifier(loss, n_iter=5) # c_t2 = SGDClassifier(loss, n_iter=5) c_t0 = ANN([data.shape[1] - 3, 2000, 1]) # c_t1 = ANN([data.shape[1] - 3, 100, 2]) # c_t2 = ANN([data.shape[1] - 3, 100, 2]) N = data.shape[0] indices = np.array(range(N)) pos = data[:,-3] == 1 neg = ~pos pos_ii = indices[pos] neg_ii = indices[neg] for e in range(EPOCHES): np.random.shuffle(pos_ii) np.random.shuffle(neg_ii) for_train = np.concatenate((pos_ii[:MINI_BATCH_SIZE], neg_ii[:MINI_BATCH_SIZE+1])) # y0 = np.array([1. - data[for_train,-3], data[for_train,-3]], dtype=np.float64) # y1 = np.array([1. - data[for_train,-2], data[for_train,-2]], dtype=np.float64) # y2 = np.array([1. - data[for_train,-1], data[for_train,-1]], dtype=np.float64) y0 = data[for_train,-3] # y1 = data[for_train,-2] # y2 = data[for_train,-1] c_t0.partial_fit(data[for_train,:-3], y0, [0, 1]) # c_t1.partial_fit(data[for_train,:-3], y1, [0, 1]) # c_t2.partial_fit(data[for_train,:-3], y2, [0, 1]) print "Epoch %d out of %d done" % (e, EPOCHES) data = None return c_t0, None, None #, c_t1, c_t2
def analyzeSymbol(symbol): startTime = time.time() flag = 0 trainingData = getTrainingData(symbol) network = ANN(inNode=3, hiddenNode=3, outNode=1) network.training(trainingData) # get rolling data for most recent day #network.training(trainingData) for i in range(0, 5): # get rolling data for most recent day predictionData = getPredictionData(symbol, flag) returnPrice = network.test(predictionData) # de-normalize and return predicted stock price predictedStockPrice = denormalizePrice(returnPrice, predictionData[1], predictionData[2]) print predictedStockPrice flag += 1 global new_value new_value = predictedStockPrice return predictedStockPrice
def __init__(self, input_size, num_hidden_layers, hidden_layer_sizes, output_size, epochs=50, batch_size=1, fit_verbose=2, variables=None, weight_file=''): super().__init__() self.weight_file = weight_file self.model = ANN(input_size, num_hidden_layers, hidden_layer_sizes, output_size, epochs=epochs, batch_size=batch_size, fit_verbose=fit_verbose, variables=variables)
def test(ann, images, img_size, S, F, neurons_num): ww, bb = ann.get_weights() ss = ann.ss[: len(ann.ss)/2 + 1] flt = ANN(ss, .0) ww_size = 0 bb_size = 0 for l in range(1, len(ss)): ww_size += ss[l-1] * ss[l] bb_size += ss[l] flt.set_weights(ww[:ww_size], bb[:bb_size]) N = images.shape[0] ii = range(N) np.random.shuffle(ii) ii = ii[:10] to_show = None for i in ii: tmp = images[i].copy() tmp = tmp.reshape((img_size,img_size)) flt_img = np.zeros((neurons_num,neurons_num)) r = 0 c = 0 for patch in patches(tmp, img_size, S, F): p = flt.predict_proba(patch.flatten()) flt_img[r,c] = p[0,1] c = (c + 1) % neurons_num if c == 0: r = (r + 1) % neurons_num tmp = tmp.reshape((img_size,img_size)) tmp *= 255 flt_img *= 255 flt_img = np.concatenate((flt_img, [[0]*(img_size-neurons_num)]* neurons_num), axis=1) flt_img = np.concatenate((flt_img, [[0]* img_size ]*(img_size-neurons_num)), axis=0) if to_show == None: to_show = np.concatenate((tmp, flt_img), axis=1) else: to_show = np.concatenate(( to_show, np.concatenate((tmp, flt_img), axis=1) ), axis=0) to_show = to_show.astype(np.uint8) plot.clf() plot.imshow(to_show) plot.show()
def test(ann, images, img_size, S, F, neurons_num): ww, bb = ann.get_weights() ss = ann.ss[:len(ann.ss) / 2 + 1] flt = ANN(ss, .0) ww_size = 0 bb_size = 0 for l in range(1, len(ss)): ww_size += ss[l - 1] * ss[l] bb_size += ss[l] flt.set_weights(ww[:ww_size], bb[:bb_size]) N = images.shape[0] ii = range(N) np.random.shuffle(ii) ii = ii[:10] to_show = None for i in ii: tmp = images[i].copy() tmp = tmp.reshape((img_size, img_size)) flt_img = np.zeros((neurons_num, neurons_num)) r = 0 c = 0 for patch in patches(tmp, img_size, S, F): p = flt.predict_proba(patch.flatten()) flt_img[r, c] = p[0, 1] c = (c + 1) % neurons_num if c == 0: r = (r + 1) % neurons_num tmp = tmp.reshape((img_size, img_size)) tmp *= 255 flt_img *= 255 flt_img = np.concatenate( (flt_img, [[0] * (img_size - neurons_num)] * neurons_num), axis=1) flt_img = np.concatenate( (flt_img, [[0] * img_size] * (img_size - neurons_num)), axis=0) if to_show == None: to_show = np.concatenate((tmp, flt_img), axis=1) else: to_show = np.concatenate( (to_show, np.concatenate((tmp, flt_img), axis=1)), axis=0) to_show = to_show.astype(np.uint8) plot.clf() plot.imshow(to_show) plot.show()
def __init__(self, x, y, W, H, food): super(Animal, self).__init__(x, y, W, H) self.brain = ANN([1, 2]) """ the orientation of the animal in the environment (range: 0 to 2pi) """ self.orientation = 0 """ initialise speed """ self.speed = ANIMAL_MOVE_SPEED """ number of food eaten in this generation by this animal """ self.num_food = 0 self.food = food
def online_eval(): # evaluation code for online test handler = DataHandler() data = handler.generate_data(TRAIN_FILENAME) testing_data = handler.generate_data(TEST_FILENAME, "test") ann = ANN(9, 10, 1) for i in range(80): print(i + 1) ann.train(data, 5000) result = ann.test_without_true_label(testing_data, 0.23) handler.write_to_result(TEST_FILENAME, result)
def train(self, hidden_layers, epochs, learning_rate): labels = self.dp_train.labels() for label in labels: data = self.dp_train.binarizeU(label, upsampled=True) X = data[:, 0:-1] y_train_logistic = data[:, -1] logistic_classifier = ANN(hidden_layers, epochs, learning_rate, verbose=False) logistic_classifier.train(X, y_train_logistic) self.logistic_classifiers.append(logistic_classifier)
def test_mnist_28by28(self): import time import os import numpy as np import matplotlib.pyplot as plt from sklearn.cross_validation import train_test_split from sklearn.datasets import load_digits from sklearn.metrics import confusion_matrix, classification_report from sklearn.preprocessing import LabelBinarizer from ann import ANN # load lecun mnist dataset X = [] y = [] with open('data/mnist_test_data.txt', 'r') as fd, open('data/mnist_test_label.txt', 'r') as fl: for line in fd: img = line.split() pixels = [int(pixel) for pixel in img] X.append(pixels) for line in fl: pixel = int(line) y.append(pixel) X = np.array(X, np.float) y = np.array(y, np.float) # normalize input into [0, 1] X -= X.min() X /= X.max() # quick test #X = X[:1000] #y = y[:1000] # for my network X_test = X y_test = y #LabelBinarizer().fit_transform(y) nn = ANN([1,1]) nn = nn.deserialize('28_200000.pickle') # '28_100000.pickle' predictions = [] for i in range(X_test.shape[0]): o = nn.predict(X_test[i]) predictions.append(np.argmax(o)) # compute a confusion matrix print("confusion matrix") print(confusion_matrix(y_test, predictions)) # show a classification report print("classification report") print(classification_report(y_test, predictions))
def getAnns(): builderNoConv = BuilderCNN_MNIST(removeConvLayers=True) cnn1 = ANN(BuilderCNN_MNIST(18)) dnn_huConv = ANN(builderNoConv, PreprocessorHuConv4Dnn(cnn1)) dnn_conv = ANN(builderNoConv, PreprocessorHuConv4Dnn(cnn1, removeHuPreprocess=True)) cnn2 = ANN(BuilderCNN_MNIST(18 + 7)) dnn_conv2 = ANN(builderNoConv, PreprocessorHuConv4Dnn(cnn2, removeHuPreprocess=True)) return [cnn1, dnn_huConv, dnn_conv, cnn2, dnn_conv2]
def train(self, hidden_layers, epochs, learning_rate): labels = self.dp_train.labels() self.labels_combination = list(itertools.combinations(labels, 2)) for labels in self.labels_combination: data = self.dp_train.binarize(labels) X = data[:, 0:-1] y = data[:, -1] logistic_classifier = ANN(hidden_layers, epochs, learning_rate, verbose=False) logistic_classifier.train(X, y) self.logistic_classifiers.append(logistic_classifier)
def test_ann(self): ## The ANN annotation CSV file. ann = ANN("testdata/ANN/000000_00_00_00.csv") # The tests. # The headers. self.assertEqual(ann.get_number_of_headers(), 2) self.assertEqual(ann.get_header(0), "annotation_id") self.assertEqual(ann.get_header(1), "annotation") # The annotations. # Test the number of annotations found. self.assertEqual(ann.get_number_of_annotations(), 88)
def main(): if len(sys.argv) != 4: print( f"USAGE: {sys.argv[0]} <saved_model_path> <test_set_path> <predictions_output_path>" ) return saved_model_path = sys.argv[1] test_set_path = sys.argv[2] predictions_output_path = sys.argv[3] ann = ANN.load(saved_model_path) test_data, _ = load_dataset(test_set_path) print(f"{test_data[0].shape}") predictions_vectors = [ ann.predict(test_data[i]) for i in range(len(test_data)) ] # We need to add one to the prediction, because the provided datasets' tags are 1-based predictions = [ from_categorical(predictions_vectors[i]) + 1 for i in range(len(predictions_vectors)) ] print(predictions) with open(predictions_output_path, "w") as file_: file_.write("\n".join([str(x) for x in predictions]))
def __init__(self): #change 3rd param """ Usually you should start with a high learning rate and a low momentum. Then you decrease the learning rate over time and increase the momentum. The idea is to allow more exploration at the beginning of the learning and force convergence at the end of the learning. Usually you should look at the training error to set up your learning schedule: if it got stuck, i.e. the error does not change, it is time to decrease your learning rate. """ self.neural = ANN(48*48,7,2,1200,10,0.5)
def run(self, lambd=0, keep_prob=1): train_X, train_Y, test_X, test_Y = data_service.load_2D_dataset() ann = ANN() learning_rate = 0.3 parameters, costs = ann.fit(train_X, train_Y, learning_rate=learning_rate, lambd=lambd, keep_prob=keep_prob) plotting_service.plot_loss_per_iteration_for_learning_rate( costs, learning_rate) plotting_service.plot_decision_boundary( lambda x: ann_service.predict_dec(parameters, x.T), train_X, train_Y)
def test_xor_trainig(self): print("test_xor_trainig...") nn = ANN([2, 2, 1]) inputs = [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]] targets = [[0.0], [1.0], [1.0], [0.0]] predicts = [] # train nn.train(40000, inputs, targets) for i in range(len(targets)): predicts.append(nn.predict(inputs[i])) # the prediction for 0,0 and 1,1 should be less than prediction for 0,1 and 1,0 self.assertTrue(predicts[0] < predicts[1], 'xor relation1 not learned') self.assertTrue(predicts[0] < predicts[2], 'xor relation2 not learned') self.assertTrue(predicts[3] < predicts[1], 'xor relation3 not learned') self.assertTrue(predicts[3] < predicts[2], 'xor relation4 not learned')
def ann_boost(training_set, validation_set, num_hidden_units, weight_decay_coeff, num_ann_training_iters, num_boosting_training_iters): # Add a column to the front of the example matrix containing the initial weight for each example example_weights = np.full((training_set.shape[0], 1), 1.0 / len(training_set)) anns = [] alphas = [] for i in xrange(0, num_boosting_training_iters): print('\nBoosting Iteration ' + str(i + 1)) weighted_training_set = np.column_stack( (example_weights, training_set)) ann = ANN(weighted_training_set, validation_set, num_hidden_units, weight_decay_coeff, weighted_examples=True) ann.train(num_ann_training_iters, convergence_err=0.5, min_iters=1) actual_labels = ann.training_labels assigned_labels = ann.output_labels error = weighted_training_error(example_weights, actual_labels, assigned_labels) alpha = classifier_weight(error) print('\n\talpha: ' + str(alpha)) if alpha == float('inf'): alphas = [float('inf')] anns = [ann] break anns.append(ann) alphas.append(alpha) if alpha != 0.0: example_weights = update_example_weights(example_weights, alpha, actual_labels, assigned_labels) else: break alphas = np.array(alphas) vote_labels = weighted_vote_labels(anns, alphas) assert ann is not None actual_labels = ann.validation_labels label_pairs = zip(actual_labels, vote_labels) accuracy, precision, recall, fpr = evaluate_ann_performance( None, label_pairs) return accuracy, precision, recall, fpr
def main(argv): argc = len(argv) if argc < 2: print(get_help()) exit(0) if argv[1] == 't': net = ANN(Functions.SIGMOID, Functions.MSE) nb = NaiveBayes() bn = Bernoulli() selected_tweets = reader.read(argv[2]) rejected_tweets = reader.read(argv[3]) t1 = threading.Thread(target=train_net,\ args=(net, selected_tweets, rejected_tweets)) t2 = threading.Thread(target=train_nb,\ args=(nb, selected_tweets, rejected_tweets)) t3 = threading.Thread(target=train_bn,\ args=(bn, selected_tweets, rejected_tweets)) t1.start() t2.start() t3.start() t1.join() t2.join() t3.join() elif argv[1] == 'c': f_net = open(argv[2], 'rb') net = pickle.load(f_net) f_net.close() f_nb = open(argv[3], 'rb') nb = pickle.load(f_nb) f_nb.close() f_bn = open(argv[4], 'rb') bn = pickle.load(f_bn) f_bn.close() tweets = reader.read(argv[5]) t1 = threading.Thread(target=classify_using_net,\ args=(net, tweets)) t2 = threading.Thread(target=classify_using_nb,\ args=(nb, tweets)) t3 = threading.Thread(target=classify_using_bn,\ args=(bn, tweets)) t1.start() t2.start() t3.start() t1.join() t2.join() t3.join() else: print(get_help()) exit(0)
def __init__(self): # load the layers of sketch-a-net with pretrained weights self.layers = load_layers('./data/model_without_order_info_224.mat') # load the corpuses of mark matches at layers 2 and 4 # layer 2 matches low level marks like lines and # layer 4 matches higher levels marks like closed forms. with open('./data/corpus' + file_extension + '4.txt', 'rb') as fp: imgs, acts = pickle.load(fp) self.imgs4 = imgs with open('./data/corpus' + file_extension + '2.txt', 'rb') as fp: imgs, acts = pickle.load(fp) self.imgs2 = imgs # init the approximate nearest neighbors class for mark matching # the results from this can be fetched from self.imgs* self.ANN = ANN() # the layers for this repeater from sketch-a-net self.layer_names = ['conv1', 'conv2', 'conv3', 'conv4']
def main(): if len(sys.argv) != 4: print("Invalid number of arguments.") print( f"Expected usage: python {sys.argv[0]} train_images train_labels validation_images" ) return test_label_path = None history_images = None history_labels = None history_accuracy = None if devel: test_label_path = "validation-labels.txt" (train_images, train_labels, test_images, test_labels) = load_data(sys.argv[1], sys.argv[2], sys.argv[3], test_label_path) train_labels_ohv = labels_to_1_hot(train_labels) if devel: test_labels_ohv = labels_to_1_hot(test_labels) history_images = test_images history_labels = test_labels_ohv history_accuracy = calculate_accuracy network = ANN(784, 'mean_square_error', regularization='L2', lambd=0.01) network.add_layer(10, 'leaky_relu') network.add_layer(10, 'leaky_relu') network.add_layer(10, 'tanh') (train_loss, test_loss, train_acc, test_acc) = network.train(train_images, train_labels_ohv, 40, 10, 0.1, 0.1 / 40, devel, history_images, history_labels, history_accuracy) test_out = network.eval(test_images) if not devel: labels = test_out.argmax(1) for i in labels: print(f"{i}") else: xaxis = [x for x in range(train_loss.size)] plt.figure(1) plt.plot(xaxis, train_loss, xaxis, test_loss) plt.legend(("Training loss", "Test loss")) plt.figure(2) line = plt.plot(xaxis, train_acc, xaxis, test_acc) plt.legend(("Training accuracy", "Test accuracy")) plt.show()
def annFromFVs(self): # [for px in A, get featureVector] fvs = featureVector.getAllFeatureVectors(self.A,self.A1) # get dim print(len(fvs),len(fvs[0])) dim = len(fvs[0]) self.ann = ANN(dim) # add these feature vectors to ann self.ann.addVectors(fvs) if self.debug: print("populated the ANN") self.ann.save()
def main(): if len(sys.argv) != 3: print(f"USAGE {sys.argv[0]} <model_path> <dataset_path>") return model_path = sys.argv[1] dataset_path = sys.argv[2] ann = ANN.load(model_path) data, tags = load_dataset(dataset_path) print(ann.evaluate(data, tags))
def ann_bag(training_set, validation_set, num_hidden_units, weight_decay_coeff, num_ann_training_iters, num_bagging_training_iters): iter_labels = None example_weights = np.full((training_set.shape[0], 1), 1.0 / len(training_set)) for i in xrange(0, num_bagging_training_iters): print('\nBagging Iteration ' + str(i + 1)) replicate_set = bootstrap_replicate(training_set, seed_value=i) weighted_replicate_set = np.column_stack( (example_weights, replicate_set)) ann = ANN(weighted_replicate_set, validation_set, num_hidden_units, weight_decay_coeff, weighted_examples=True) ann.train(num_ann_training_iters, convergence_err=0.5) if iter_labels is not None: iter_labels = np.column_stack((iter_labels, ann.evaluate()[1])) else: iter_labels = ann.evaluate()[1] voting_labels = np.apply_along_axis(most_common_label, 1, iter_labels) assert ann is not None actual_labels = ann.validation_labels label_pairs = zip(actual_labels, voting_labels) accuracy, precision, recall, fpr = evaluate_ann_performance( None, label_pairs) return accuracy, precision, recall, fpr
def __init__(self, input_size, hidden_layers, output_size): # network input self.X = tf.placeholder(tf.float32, [None, input_size], name='X') # encoders and decoder are just fully connected networks self.encoder = ANN(input_size, hidden_layers, output_size) M = output_size // 2 self.decoder = ANN(M, hidden_layers[::-1], input_size) # Construct the sampling distribution form the output of the encoder self.encoder_out = self.encoder.forward(self.X) self.means = self.encoder_out[:, :M] self.stddev = tf.nn.softplus(self.encoder_out[:, M:]) + 1e-6 with st.value_type(st.SampleValue()): self.Z = st.StochasticTensor( Normal(loc=self.means, scale=self.stddev)) # network output self.logits = self.decoder.forward(self.Z) self.pX = Bernoulli(logits=self.logits) # Prior predictive sample standard_normal = Normal(loc=np.zeros(M, dtype=np.float32), scale=np.ones(M, dtype=np.float32)) # initialize cost and training kl = tf.reduce_sum( tf.contrib.distributions.kl_divergence(self.Z.distribution, standard_normal), 1) expected_log_likelihood = tf.reduce_sum(self.pX.log_prob(self.X), 1) self.elbo = tf.reduce_sum(expected_log_likelihood - kl) self.train_op = tf.train.RMSPropOptimizer( learning_rate=0.001).minimize(-self.elbo) self.X_hat = self.pX.sample()
def analyzeSymbol(stockSymbol): startTime = time.time() trainingData = getTrainingData(stockSymbol) network = ANN(inNode=3, hiddenNode=3, outNode=1) network.training(trainingData) # get rolling data for most recent day predictionData = getPredictionData(stockSymbol) # get prediction returnPrice = network.test(predictionData) # de-normalize and return predicted stock price predictedStockPrice = denormalizePrice(returnPrice, predictionData[1], predictionData[2]) # create return object, including the amount of time used to predict return predictedStockPrice
def main(): import input logging.basicConfig(level=logging.INFO, stream=sys.stdout) np.set_printoptions(precision=3, edgeitems=3, threshold=20) random.seed(5108) # used by the GA randSample = random.Random(input.SAMPLE_SEED) # used for data set sampling inp = input.Input("train3-std.tsv", randSample) print "Train set:", inp.trainSet.show() print "Test set:", inp.testSet.show() n = inp.trainSet.size * 20/100 a = ANN() a.prepare(inp.trainSet, POPSIZE) tester = SampleTester() tester.prepare(inp.testSet, randSample) tester.showSampleSets() params = [] generatePop(params) mutateValue = 6.0 for genIndex in range(5000): print "Generation", genIndex, "starting." logFP("Population", params) outputValues = a.evaluate(params, returnOutputs=True) logFP("Outputs", outputValues) thresholds = a.nlargest(n) logFP("Thresholds", thresholds) lifts = a.lift(n) logFP("Lifts", lifts) taggedParams = sorted(zip(lifts, params, range(len(params))), key=lambda (l, p, i): l, reverse=True) sortedParams = [p for l, p, i in taggedParams] logFP("Sorted pop", sortedParams) testLift, _ = tester.test(sortedParams[0]) genplot.addGeneration(lifts, testLift, genIndex) params = generateGeneration(sortedParams, mutateValue) if genIndex%500 == 499: mutateValue -= 0.5 args = sys.argv[1:] if len(args) == 1: open(args[0], "w").write(repr(sortedParams[0])) genplot.plot()
def compare_learning_rate(X, Y): """ This function studies the convergence while varying the learning rate :param X: Training inputs :param Y: Training targets :return: plot of the evolution of the error along the iterations for different values of the learning rate For this function the update rule and the method (batch/sequential) has to be changed manually in params "learn_method" and in the training function respectively """ fig, ax = plt.subplots() eta = np.linspace(0.0005, 0.0015, 5) for e in eta: params = { "learning_rate": e, "batch_size": N, "theta": 0, "epsilon": -0.1, # slack for error during training "epochs": 10, "act_fun": 'step', "m_weights": 0.9, "sigma_weights": 0.9, "nodes": 1, "learn_method": 'delta_rule' #'delta_rule' } training_method = 'sequential' # 'batch' , 'sequential' ann = ANN(X, Y, **params) ann.train(training_method, verbose=verbose) ax.plot(range(len(ann.error_history)), ann.error_history, label='$\eta = {}$'.format(e)) #ax.set_xlim(0, 40) ax.legend() plt.show()
def __init__(self, population): ''' Create game AI. :param population: Number of AI to evolve. ''' print("Creating game AI.") self.genomes = list() self.anns = list() self.generation = 1 self.last_avg_fit = 0.0 index = 0 while population > 0: print("AI's left: " + str(population)) ann = ANN() self.anns.append(ann) # Names will get strange if lots of brains are created self.genomes.append(FloatGenome(ann.get_internal_data(), 0.0, chr(ord('a') + index))) population -= 1 index += 1
class Soldier(object): """ Class to hold the data for a soldier object. Each soldier has a "brain", which is a Sigmoid neural network with 120 inputs. The inputs represent squares in an 11x11 grid around the soldier's current position. Each square in the grid has an integer value representing the current status of that square. For example, if the value for "soldier" was 1, and there was another soldier at (4, 5) relative to this soldier, that input would have value 1. Other values may represent grass, water etc. """ def __init__(self, pos): self.brain = ANN(constants.soldier_brain, Neuron.Sigmoid) self.pos = pos def think(self, squares): output = self.brain.run(squares) """ tolerance must be less than the minimum difference between defining values below """ tolerance = 0.1 """ values of the output defining behaviour """ move_none = 0 move_left = 0.25 move_up = 0.5 move_right = 0.75 move_down = 1 """ decide where to move the soldier """ if abs(output - move_none) < tolerance: pass elif abs(output - move_left) < tolerance: self.move(-1, 0) elif abs(output - move_up) < tolerance: self.move(0, -1) elif abs(output - move_right) < tolerance: self.move(1, 0) elif abs(output - move_down) < tolerance: self.move(0, 1) def move(self, dx, dy): """ Move this solder on the map The actual updating of the map grid is done in gamemap.py """ self.x += dx self.y += dy
def anncv(Xtrain, Ytrain, Xtest, Ytest): inputsize = Xtrain.shape[1] hiddensize = 12 outputsize = len(classes) ann = ANN(inputsize,hiddensize,outputsize) mtrain = len(Ytrain) # for this example, im only training with the first 12 examples for n in xrange(400): for i in xrange(mtrain): x,y = Xtrain[i],Ytrain[i] target = np.zeros(len(classes)) target[classes.index(y)] = 1 ann.train(x,target,alpha=0.1,momentum=0.2) mtest = len(Ytest) Ypredict = np.zeros(mtest) for i in xrange(mtest): x,y = Xtest[i],Ytest[i] results = ann.predict(x) prediction = results.argmax() Ypredict[i] = prediction return Ypredict
def anncv(Xtrain, Ytrain, Xtest, Ytest): inputsize = Xtrain.shape[1] hiddensize = 12 outputsize = len(classes) ann = ANN(inputsize, hiddensize, outputsize) mtrain = len(Ytrain) # for this example, im only training with the first 12 examples for n in xrange(400): for i in xrange(mtrain): x, y = Xtrain[i], Ytrain[i] target = np.zeros(len(classes)) target[classes.index(y)] = 1 ann.train(x, target, alpha=0.1, momentum=0.2) mtest = len(Ytest) Ypredict = np.zeros(mtest) for i in xrange(mtest): x, y = Xtest[i], Ytest[i] results = ann.predict(x) prediction = results.argmax() Ypredict[i] = prediction return Ypredict
def __init__(self, population): ''' Create game AI. :param population: Number of AI to evolve. ''' print("Creating game AI.") self.genomes = list() self.anns = list() self.generation = 1 self.last_avg_fit = 0.0 index = 0 while population > 0: print("AI's left: " + str(population)) ann = ANN() self.anns.append(ann) # Names will get strange if lots of brains are created self.genomes.append( FloatGenome(ann.get_internal_data(), 0.0, chr(ord('a') + index))) population -= 1 index += 1
def train(mode='new', train_times=100, lr=0.1, **kwargs): global data_len if mode in ['new', 'continue']: text = load_data() data = sample_data(text) print data[0].shape print data[1].shape l = int(data_size * 0.7) datasets = [(shared(data[0][:l]), shared(data[1][:l])), (shared(data[0][l:]), shared(data[1][l:]))] #ann theano.config.exception_verbosity='high' theano.config.on_unused_input='ignore' if mode=='new': cl = ANN(data_len * alphanum, alphanum, hiddens = [300, 300, 200], lmbd = 0) cl.fit(datasets, lr = theano.tensor.cast(lr, theano.config.floatX), n_epochs = train_times, batch_size = 200) dump(cl, open('save.dat', 'wb')) elif mode=='continue': try: os.rename('save.dat', 'origin.dat') except: pass cl = load(open('origin.dat','rb')) print cl cl.fit(datasets, lr = theano.tensor.cast(lr, theano.config.floatX), n_epochs = train_times, batch_size = 200) dump(cl, open('save.dat', 'wb')) elif mode=='create': cl = load(open('origin.dat','rb')) create(**kwargs) return cl
def __init__(self, input_size, convolution_layer_info, fully_connected_layer_sizes, output_size): self.conpool_layers = [] self.Xin = tf.placeholder(tf.float32, [None, *input_size], name="X") self.labels = tf.placeholder(tf.float32, [None, output_size], name="labels") C1 = input_size[-1] output_reduction_factor = np.array([0, 0]) # Construct the conpool layers for i, layer_info in enumerate(convolution_layer_info): C2 = layer_info["window_depth"] self.conpool_layers.append(ConPoolLayer(C1, C2, layer_info)) C1 = C2 output_reduction_factor += layer_info["pooling_strides"][1:-2] # Calculate the input size of the fully connected layer so that it # couples to the convolutional layer # - this will depend on stride of the pooling layer self.Cout = int(C2 * np.prod(input_size[:-2] / output_reduction_factor)) self.fully_connected_network = ANN(self.Cout, fully_connected_layer_sizes, output_size) self.logits = self.forward(self.Xin) self.cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=self.logits, labels=self.labels)) self.train_op = tf.train.AdamOptimizer().minimize(self.cost) self.predictions = self.predict(self.Xin)
def train_ANN_PSO(inputs, res_ex, max_iter, n_particle, n_neighbor, nb_h_layers, nb_neurons_layer, min_bound, max_bound, cognitive_trust, social_trust, inertia_start, inertia_end, velocity_max, activations, draw_graph=False): nb_neurons = set_nb_neurons(len(inputs[0]), nb_neurons_layer, nb_h_layers) # print(nb_neurons, n_neighbor, activations) ann = ANN(nb_neurons=nb_neurons, nb_layers=len(nb_neurons), activations=activations) dim = sum(nb_neurons[i] * nb_neurons[i + 1] for i in range(len(nb_neurons) - 1)) + len(nb_neurons) - 1 pso = PSO(dim, lambda params: fitness_for_ann(params, ann, inputs, res_ex), max_iter=max_iter, n_particle=n_particle, n_neighbor=n_neighbor, comparator=minimise, min_bound=min_bound, max_bound=max_bound, cognitive_trust=cognitive_trust, social_trust=social_trust, inertia_start=inertia_start, inertia_end=inertia_end, velocity_max=velocity_max, endl='', version=2007) if draw_graph: pso.set_graph_config(inputs=inputs, res_ex=res_ex) pso.run() return pso, ann
def run_model(which='all'): if which in ['ann', 'all', 'main', 'standard']: model = ANN(emb_size, vocab_size, hid_dim, hid_num, class_num, sent_len).cuda() ann_loss = train(model, x, target, ann=True) plt.plot(ann_loss, label='ann') if which in ['wann', 'all', 'standard']: model = WANN(emb_size, vocab_size, hid_dim, hid_num, class_num, sent_len).cuda() wann_loss = train(model, x, target, ann=True) plt.plot(wann_loss, label='wann') if which in ['rnn', 'all', 'main']: model = RNN(emb_size, vocab_size, hid_dim, hid_num, class_num).cuda() rnn_loss = train(model, x, target) plt.plot(rnn_loss, label='rnn') if which in ['exrnn', 'all']: model = EXRNN(emb_size, vocab_size, hid_dim, hid_num, class_num, 2000, 2000).cuda() exrnn_loss = train(model, x, target) plt.plot(exrnn_loss, label='exrnn') if which in ['exmem', 'all']: model = EXRNN(emb_size, vocab_size, hid_dim, hid_num, class_num, 2000, forget_dim=None).cuda() exmem_loss = train(model, x, target) plt.plot(exmem_loss, label='exmem') if which in ['lstm', 'all', 'main']: model = LSTM(emb_size, vocab_size, hid_dim, hid_num, class_num).cuda() lstm_loss = train(model, x, target) plt.plot(lstm_loss, label='lstm') if which in ['gru', 'all', 'main']: model = GRU(emb_size, vocab_size, hid_dim, hid_num, class_num).cuda() gru_loss = train(model, x, target) plt.plot(gru_loss, label='gru') # plt.ylim([0, 2]) plt.legend() plt.grid(True) plt.show()
def perform_ova_single_nn(): ann = ANN((100, ), 5000, 0.01, verbose=False) parameter_space = { 'hidden_layer_sizes': [(50, ), (100, ), (150, ), (200, ), (50, 50), (50, 100), (100, 50), (200, 50)], 'learning_rate_init': [0.005, 0.01, 0.015, 0.02, 0.025], 'max_iter': [2000, 3000, 4000, 5000] } grid = GridSearchCV(ann.mlp, parameter_space, n_jobs=-1, cv=3) grid.fit(x_train, y_train) print('Best parameters found:\n', grid.best_params_) print('Results on the test set:\n', classification_report(y_test, grid.predict(x_test))) # print('Results on the test set:\n', confusion_matrix(y_test, grid.predict(x_test))) means = grid.cv_results_['mean_test_score'] stds = grid.cv_results_['std_test_score'] params = grid.cv_results_['params'] for mean, stdev, param in zip(means, stds, params): print("%f (%f) with: %r" % (mean, stdev, param))
def main(): nn = ANN([5, 5, 1], Utils.linear, Utils.linear_derivative) u, t = Utils.readData() for i in range(100): for j in range(len(u)): nn.backPropag(nn.computeLoss(u[j], t[j]), 0.01) # compute the errors diff = [] for i in range(len(u)): predicted = nn.feedForward(u[i]) diff.append(abs(predicted[0] - t[i][0])) print("Actual: {}, Predicted:{}".format(t[i][0], predicted[0])) print("Mean of errors: {}".format(mean(diff)))
def train(mode='new', train_times=100, lr=0.1, **kwargs): global data_len if mode in ['new', 'continue']: text = load_data() data = sample_data(text) print data[0].shape print data[1].shape l = int(data_size * 0.7) datasets = [(shared(data[0][:l]), shared(data[1][:l])), (shared(data[0][l:]), shared(data[1][l:]))] #ann theano.config.exception_verbosity = 'high' theano.config.on_unused_input = 'ignore' if mode == 'new': cl = ANN(data_len * alphanum, alphanum, hiddens=[300, 300, 200], lmbd=0) cl.fit(datasets, lr=theano.tensor.cast(lr, theano.config.floatX), n_epochs=train_times, batch_size=200) dump(cl, open('save.dat', 'wb')) elif mode == 'continue': try: os.rename('save.dat', 'origin.dat') except: pass cl = load(open('origin.dat', 'rb')) print cl cl.fit(datasets, lr=theano.tensor.cast(lr, theano.config.floatX), n_epochs=train_times, batch_size=200) dump(cl, open('save.dat', 'wb')) elif mode == 'create': cl = load(open('origin.dat', 'rb')) create(**kwargs) return cl
else: failed += 1 accuracy = float(passed)/float(passed+failed) print 'Passed: %d' % passed print 'Failed: %d' % failed print 'Accuracy: %f' % accuracy # Load the pickled dataset f = gzip.open('mnist.pkl.gz', 'rb') train_set, valid_set, test_set = cPickle.load(f) f.close() # Convert training and testing sets train_set = build_set(train_set[0], train_set[1]) test_set = build_set(test_set[0], test_set[1]) digits_ann = ANN(784,30,10,alpha=0.1) print '+---------------+' print '|Before Training|' print '+---------------+' test_network(digits_ann, test_set) digits_ann.train_set(train_set) print '+--------------+' print '|After Training|' print '+--------------+' test_network(digits_ann, test_set)
(x, y) = (event.x, event.y) if (x >= 0 and x < width and y >= 0 and y < height): draw.ellipse((x - 10, y - 10, x + 10, y + 10), fill = (0xFF, 0xFF, 0xFF)) refresh_draw() def classify_draw(event): print("classifying drawing") ann.classify(ann.parse(normalize(image))) def clear_draw(event): global draw draw.ellipse((-width, -height, width * 2, height * 2), fill = (0xFF, 0xFF, 0xFF)) refresh_draw() def outweights(l, j): return [ann.weights[l][i][j] for i in range(len(ann.weights[l]))] def reconstruct(data): img = Image.new("LA", (16, 16)) pxs = img.load() for x in range(16): for y in range(16): pxs[x, y] = (int(data[y * 16 + x] * 128 + 128), 255) return img if __name__ == "__main__": ann = ANN() ann.load("256_iteration_30") gui()
def setup_network(self): self.move_classifier = ANN(ann_type="rlu2") self.errors = []
# convert from numpy to normal python list for our simple implementation X_train_l = X_train.tolist() labels_train_l = labels_train.tolist() # free memory X = None y = None def step_cb(nn, step): print("ping") nn.serialize(nn, str(step) + ".pickle") # load or create an ANN nn = ANN([1,1]) serialized_name = '28_1000000.pickle' if os.path.exists(serialized_name): # load a saved ANN nn = nn.deserialize(serialized_name) else: # create the ANN with: # 1 input layer of size 64 (the images are 8x8 gray pixels) # 1 hidden layer of size 100 # 1 output layer of size 10 (the labels of digits are 0 to 9) nn = ANN([784, 300, 10]) # see how long training takes startTime = time.time()
class Gui(tk.Tk): def __init__(self, delay, *args, **kwargs): tk.Tk.__init__(self, *args, **kwargs) self.title("2048-solver") self.cell_width = self.cell_height = 50 self.dim = (4, 4) self.delay=delay screen_width = self.dim[0]*self.cell_width+1 screen_height = self.dim[1]*self.cell_height+1 self.canvas = tk.Canvas(self, width=screen_width, height=screen_height, borderwidth=0, highlightthickness=0) self.canvas.pack(side="top", fill="both", expand="true") self.color_dict = self.fill_color_dict() self.results_from_nn_playing = [] self.results_from_random_playing = [] self.results = [] self.start_time = time() self.setup_network() self.user_control() self.start_game() def start_game(self): if len(self.results) < self.results_length: print("run nr", len(self.results)) self.game_board = Game2048(board=[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]) self.board = self.game_board.board self.game_board.generate_new_node() self.depth = 3 self.move_count = 0 self.draw_board() self.time = time() self.run_algorithm() else: if self.action[0] == "p": self.results_from_nn_playing = copy.copy(self.results) print("p, largest tile", max(self.results_from_nn_playing)) print("p, average tile", sum(self.results_from_nn_playing)/float(len(self.results_from_nn_playing))) elif self.action[0] == "r": self.results_from_random_playing = copy.copy(self.results) print("r, largest tile", max(self.results_from_random_playing)) print("r, average tile", sum(self.results_from_random_playing)/float(len(self.results_from_random_playing))) elif self.action[0] == "c": self.results_from_nn_playing = copy.copy(self.results) self.results_from_random_playing = [112]*50 self.print_comparison() self.results = [] self.user_control() self.start_game() def setup_network(self): self.move_classifier = ANN(ann_type="rlu2") self.errors = [] def user_control(self): while True: self.action = input("Press r to play random, t to train, p to play with nn, c to compare results: ") if self.action[0] == "t": if len(self.action) == 1: output_activations = self.move_classifier.do_training() elif self.action[1] == "l": output_activations = self.move_classifier.do_testing() elif self.action[1] == "a": points = ai2048demo.welch(self.results_from_random_playing, self.results_from_nn_playing) print("points", points) elif self.action[0] == "p" or self.action[0] == "r": self.results_length = 50 return elif self.action[0] == "c": if len(self.results_from_nn_playing)+len(self.results_from_random_playing) < 100: self.results_length = 50 return else: self.print_comparison() else: self.errors = self.move_classifier.do_training(epochs=int(self.action), errors=self.errors) output_activations = self.move_classifier.do_testing(boards=self.move_classifier.test_boards) print("Statistics (test set):\t\t ", self.move_classifier.check_result(output_activations, labels=self.move_classifier.test_labels), "%") output_activations = self.move_classifier.do_testing(boards=self.move_classifier.boards) print("Statistics (training set):\t ", self.move_classifier.check_result(output_activations, labels=self.move_classifier.labels), "%") print("Total time elapsed: " + str(round((time() - self.start_time)/60, 1)) + " min") def run_algorithm(self): continuing = True if self.game_board.is_game_over(): largest_tile = self.game_board.get_largest_tile() print("largest tile", largest_tile) self.results.append(largest_tile) print("average tile", sum(self.results)/float(len(self.results))) continuing = False return self.start_game() current_node = State(self.game_board, self.depth) self.move_count += 1 flat_board = current_node.board.board[3] + current_node.board.board[2] + current_node.board.board[1] + current_node.board.board[0] if self.action[0] == "r": chosen_move = self.choose_legal_random_move() else: case = self.move_classifier.preprosessing(flat_board) result = self.move_classifier.predictor(case) chosen_move = self.choose_legal_move_from_nn(result) if chosen_move == 0: self.game_board.move_left() elif chosen_move == 1: self.game_board.move_right() elif chosen_move == 2: self.game_board.move_up() elif chosen_move == 3: self.game_board.move_down() else: print("Illegal move") self.game_board.generate_new_node() self.draw_board() if continuing: self.after(self.delay, lambda: self.run_algorithm()) def choose_legal_random_move(self): while True: r = random.randint(0,3) if self.game_board.is_move_legal(r): return r def choose_legal_move_from_nn(self, result): chosen_move = None while chosen_move == None or not self.game_board.is_move_legal(chosen_move): if chosen_move != None: result[0][chosen_move] = -1 chosen_move = np.argmax(result[0]) return chosen_move def print_comparison(self): print("NN results:\t", self.results_from_nn_playing) print("Random results:\t", self.results_from_random_playing) print("largest tiles", max(self.results_from_nn_playing), max(self.results_from_random_playing)) print("average tiles", sum(self.results_from_nn_playing)/float(len(self.results_from_nn_playing)), sum(self.results_from_random_playing)/float(len(self.results_from_random_playing))) points = ai2048demo.welch(self.results_from_random_playing, self.results_from_nn_playing) print("points", points) def bind_keys(self): self.bind('<Up>', lambda event: self.move(self, self.game_board.move_up())) self.bind('<Down>', lambda event: self.move(self, self.game_board.move_down())) self.bind('<Right>', lambda event: self.move(self, self.game_board.move_right())) self.bind('<Left>', lambda event: self.move(self, self.game_board.move_left())) def move(self, event, is_moved): if is_moved: self.game_board.generate_new_node() self.draw_board() def draw_board(self): self.canvas.delete("all") for y in range(self.dim[1]): for x in range(self.dim[0]): x1 = x * self.cell_width y1 = self.dim[1]*self.cell_height - y * self.cell_height x2 = x1 + self.cell_width y2 = y1 - self.cell_height cell_type = self.board[y][x] text = str(self.board[y][x]) color = self.color_dict[str(self.board[y][x])] self.canvas.create_rectangle(x1, y1, x2, y2, fill=color, tags="rect") if cell_type != 0: self.canvas.create_text(x1+self.cell_width/2, y1-self.cell_height/2, text=text) def fill_color_dict(self): color_dict = { '0': "white", '2': "PaleVioletRed1", '4': "PaleVioletRed2", '8': "hot pink", '16': "maroon1", '32': "maroon2", '64': "DeepPink2", '128': "DeepPink3", '256': "medium violet red", '512': "purple", '1024': "dark violet", '2048': "dark violet", '4096': "purple3", '8192': "purple3", } return color_dict
train_ii = range(N) np.random.shuffle(train_ii) N_train = int(N * .8) N_test = N - N_train test_ii = train_ii[N_train:] train_ii = train_ii[:N_train] M = 128 ann = ANN([S, M, S], .0) total_cnt = 0 total_avr_cost = 0. avr_cost = 0. cnt = 0. EPOCHES = 1000 for e in range(EPOCHES): np.random.shuffle(train_ii) for i in train_ii: tmp = images[i]
ylb.fit(y) # split the dataset X_train, X_test, y_train, y_test = train_test_split(xsc.transform(X), y, random_state=0) # load nn if exists else train nn_fname = 'models/nn_iris_3000epochs.pickle' if os.path.exists(nn_fname): # load print('loading the nn') nn = deserialize(nn_fname) else: # train print('training the nn') nn = ANN([4, 10, 3]) nn.train(X_train, ylb.transform(y_train), 3000) serialize(nn, nn_fname) # predict preds = np.array([nn.predict(example) for example in X_test]) y_pred = ylb.inverse_transform(preds) # evaluate print(confusion_matrix(y_test, y_pred)) print(classification_report(y_test, y_pred))
class FER(): def __init__(self): #change 3rd param """ Usually you should start with a high learning rate and a low momentum. Then you decrease the learning rate over time and increase the momentum. The idea is to allow more exploration at the beginning of the learning and force convergence at the end of the learning. Usually you should look at the training error to set up your learning schedule: if it got stuck, i.e. the error does not change, it is time to decrease your learning rate. """ self.neural = ANN(48*48,7,2,1200,10,0.5) def train(self,dataset): print "FER Train" start = time.clock() weights = self.neural.train(dataset,epoch=3) result = True timex = 0 weight_f = open("weights.txt","w") #print "len(weights)",len(weights) #print "len(weights[0])",len(weights[0]) #print "weights[0][1]",weights[0][1] for layer in range(len(weights)): weight_f.write("Layer "+str(layer)+"\n") for e in range(len(weights[layer])): weight_f.write("Node "+str(e)+"\n") for f in range(len(weights[layer][e])): weight_f.write(str(weights[layer][e][f]) + " ") weight_f.write("\n") weight_f.close() end = time.clock() timex = end - start #train; writes the weight on the file; returns true if sucesss, false otherwise; returns time consumed return result,timex def test(self,dataset,weights): start = time.clock() correct = 0 accuracy = 0.0 result = True timex = 0 count = 1 for row in dataset:#temporary set to 10 start = time.clock() print 'test_data',count prediction = self.predict(row[1],weights,flag=count) if prediction == row[0]: correct+=1 count += 1 end = time.clock() timex = end - start print 'test time',timex accuracy = correct/len(dataset) end = time.clock() timex = end - start #returns the accuracy of the algorithm in floating point format; returns true if sucess, false otherwise; returns time consumed return accuracy,result,timex def predict(self,image,weights,flag=-1): #classify a single image, returns the index of result (see main for the legend index:[0,7]) if flag == 1: self.neural.set_weight(weights) elif flag == -1: self.neural.set_weight(weights) output = list(self.neural.classify(image)) predicted_output = output.index(max(output)) print "output:",output return predicted_output
class ANN_Trainer: def __init__(self, userid): self.userid = userid self.inputSamples = [] self.desiredOutputs = [] for s in models.Ann_samples.objects.filter(userid=userid): self.inputSamples.append(eval(s.input)) self.desiredOutputs.append(eval(s.output)) self.learningRate = 0.1 self.init() def __del__(self): del self.inputSamples del self.desiredOutputs def init(self): self.ann = ANN(self.userid) if self.ann.loadData(): return self.ann.init([25, 30, 20, 26]) def addData(self, inputSamples, desiredOutputs): self.sum_errors_prev = [1000, 1000] self.sum_errors_last = [1000, 1000] self.inputSamples += inputSamples self.desiredOutputs += desiredOutputs def updateLearningRate(self, sum_errors, sum_errors_prev): err = sum_errors[0] err_prev = sum_errors_prev[0] if err_prev == 0.0: return if err / err_prev > 1.04: self.learningRate *= 0.7 if err < err_prev: self.learningRate *= 1.05 if self.learningRate > 3.0: self.learningRate = 0.1 def saveData(self, se, episode): data = [se, self.sum_errors_last, self.learningRate, episode] if not models.Ann_trainer_data.objects.filter(userid=self.userid): models.Ann_trainer_data.objects.create(userid=self.userid, data=str(data)) else: models.Ann_trainer_data.objects.filter(userid=self.userid).update(data=str(data)) del data def loadData(self): if not models.Ann_trainer_data.objects.filter(userid=self.userid): return 0 data = eval(models.Ann_trainer_data.objects.get(userid=self.userid).data) # del self.sum_errors_prev # del self.sum_errors_last # self.sum_errors_prev = data[0] # self.sum_errors_last = data[1] self.learningRate = data[2] res = data[3] del data return res def train(self, max_error): self.sum_errors_prev = [1000, 1000] self.sum_errors_last = [1000, 1000] episode = self.loadData() while True: sum_errors = [0, 0] for i in range(len(self.inputSamples)): self.ann.activate(self.inputSamples[i]) err = self.ann.updateErrorGradients(self.desiredOutputs[i]) sum_errors[0] += err[0] sum_errors[1] += err[1] del err if i < len(self.inputSamples) - 1: self.ann.updateWeights(self.learningRate) self.updateLearningRate(sum_errors, self.sum_errors_prev) if not episode % 10: if sum_errors[0] < self.sum_errors_last[0]: self.ann.saveData() # print "net data saved to file ..." self.saveData(sum_errors, episode) # print "trainer data saved to file ..." self.sum_errors_last[0] = sum_errors[0] self.sum_errors_last[1] = sum_errors[1] # print sum_errors, self.learningRate # print "episode =", episode # print "---------------------------" # if sum_errors[0] < 1.5: if sum_errors[0] < max_error: break self.ann.updateWeights(self.learningRate) del self.sum_errors_prev self.sum_errors_prev = sum_errors episode += 1
def test_mnist_8by8_training(self): print("test_mnist_8by8_training") import time import numpy as np import matplotlib.pyplot as plt from sklearn.cross_validation import train_test_split from sklearn.datasets import load_digits from sklearn.metrics import confusion_matrix, classification_report from sklearn.preprocessing import LabelBinarizer from sklearn.metrics import precision_score, recall_score # import the simplified mnist dataset from scikit learn digits = load_digits() # get the input vectors (X is a vector of vectors of type int) X = digits.data # get the output vector ( y is a vector of type int) y = digits.target # normalize input into [0, 1] X -= X.min() X /= X.max() # split data into training and testing 75% of examples are used for training and 25% are used for testing X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=123) # binarize the labels from a number into a vector with a 1 at that index labels_train = LabelBinarizer().fit_transform(y_train) labels_test = LabelBinarizer().fit_transform(y_test) # convert from numpy to normal python list for our simple implementation X_train_l = X_train.tolist() labels_train_l = labels_train.tolist() # create the artificial neuron network with: # 1 input layer of size 64 (the images are 8x8 gray pixels) # 1 hidden layer of size 100 # 1 output layer of size 10 (the labels of digits are 0 to 9) nn = ANN([64, 100, 10]) # see how long training takes startTime = time.time() # train it nn.train(10, X_train_l, labels_train_l) elapsedTime = time.time() - startTime print("time took " + str(elapsedTime)) self.assertTrue(elapsedTime < 300, 'Training took more than 300 seconds') # compute the predictions predictions = [] for i in range(X_test.shape[0]): o = nn.predict(X_test[i]) predictions.append(np.argmax(o)) # compute a confusion matrix # print(confusion_matrix(y_test, predictions)) # print(classification_report(y_test, predictions)) precision = precision_score(y_test, predictions, average='macro') print("precision", precision) recall = recall_score(y_test, predictions, average='macro') print("recall", recall) self.assertTrue(precision > 0.93, 'Precision must be bigger than 93%') self.assertTrue(recall > 0.93, 'Recall must be bigger than 93%')
training_set = [] filepaths = glob.glob(directory + '/*.bmp') for fp in filepaths: # Open image, convert to grayscale, get data pixels = Image.open(fp).convert('L').getdata() values = normalize_pixel(np.array(pixels)) training_set.append((values, output)) return training_set # Creating a master training set which cycles through images of each class def build_training_sets(): # Build training sets for each class violin_set = load_training_set('image_search/images/resized/violin', [1,0,0,0]) trumpet_set = load_training_set('image_search/images/resized/trumpet', [0,1,0,0]) tuba_set = load_training_set('image_search/images/resized/tuba', [0,0,1,0]) clarinet_set = load_training_set('image_search/images/resized/clarinet', [0,0,0,1]) # Create a list of tuples containing one of each time of instrument zipset = zip(violin_set, trumpet_set, tuba_set, clarinet_set) return [inp for subset in zipset for inp in subset] # flatten zipset # ann = ANN(40*40, 300, 4) ann = ANN.from_file('instrument_ann.npz') ann.alpha=0.1 instrument_training_set = build_training_sets() for _ in xrange(5): print "Error: %s" % np.mean(ann.train_set(instrument_training_set)) ann.write_to_file('instrument_ann.npz') print "Total iterations: %d" % ann.total_iterations
[ [0.25, 0.25], [0.25, 0.25], [0.25, 0.25] ], [ [0.25], [0.25], [0.25] ] ] print datetime.datetime.now() tprime = lambda x: 1 - x**2 faux_data = [((1,1),1)] test_ann = ANN(math.tanh, tprime, t_weights, False) test_ann.populate(faux_data) print "Numerical Gradient, tanh", test_ann.num_grad() print "Actual Gradient, tanh", test_ann.calc_err_grad()[0] test_ann.set_ident(True) print "Numerical Gradient, ident", test_ann.num_grad() print "Actual Gradient, ident", test_ann.calc_err_grad()[0] #Problem 11.2 NN print datetime.datetime.now() weights = [np.random.rand(3,10) / 100, np.random.rand(11,1) / 100] #A test: ann = ANN(math.tanh, tprime, weights, True) ann.populate(sampled_data) #Part a max_itr = 1000
#! /usr/bin/python from ann import ANN ann = ANN() ann.loadData() inputSample = [0.0, 0.0, 0.2407407407407407, 0.79894179894179895, 0.0 , 0.0, 0.10317460317460314, 0.88095238095238093, 0.95767195767195767, 0.11528822055137844 , 0.010582010582010581, 0.74338624338624337, 0.64550264550264558, 0.8306878306878307, 0.35839598997493738 , 0.49470899470899465, 0.8306878306878307, 0.53968253968253976, 0.67460317460317465, 0.62155388471177941 , 0.75396825396825395, 0.19047619047619047, 0.0, 0.082010582010581978, 0.77694235588972438] ann.activate(inputSample) print ann.outputs
class ANN_Trainer: def __init__(self, userid): self.userid = userid self.inputSamples = [] self.desiredOutputs = [] for s in models.Ann_samples.objects.filter(userid=userid): self.inputSamples.append(eval(s.input)) self.desiredOutputs.append(eval(s.output)) self.init() def __del__(self): del self.inputSamples del self.desiredOutputs def init(self): self.ann = ANN(self.userid) if self.ann.loadData(): return self.ann.init([25, 30, 20, 26]) def addData(self, inputSamples, desiredOutputs): self.sum_errors_last = [1000, 1000] self.inputSamples += inputSamples self.desiredOutputs += desiredOutputs def saveData(self, se, episode): data = [se, episode] if not models.Ann_trainer_rp_data.objects.filter(userid=self.userid): models.Ann_trainer_rp_data.objects.create(userid=self.userid, data=str(data)) else: models.Ann_trainer_rp_data.objects.filter(userid=self.userid).update(data=str(data)) del data def loadData(self): return 0 if not models.Ann_trainer_rp_data.objects.filter(userid=self.userid): return 0 data = eval(models.Ann_trainer_rp_data.objects.get(userid=self.userid).data) #del self.sum_errors_last #self.sum_errors_last = data[0] res = data[1] del data return res def train(self, max_error): self.sum_errors_last = [1000, 1000] episode = self.loadData() while True: sum_errors = [0, 0] for i in range(len(self.inputSamples)): self.ann.activate(self.inputSamples[i]) err = self.ann.updateErrorGradients(self.desiredOutputs[i]) sum_errors[0] += err[0] sum_errors[1] += err[1] del err self.ann.updateWeights_slope() #print sum_errors[0] if not episode % 10: if sum_errors[0] < self.sum_errors_last[0]: self.ann.saveData() #print "net data saved to file ..." self.saveData(sum_errors, episode) #print "trainer data saved to file ..." self.sum_errors_last[0] = sum_errors[0] self.sum_errors_last[1] = sum_errors[1] #print sum_errors #print "episode =", episode #print "---------------------------" if sum_errors[0] < max_error: break self.ann.updateWeights() del sum_errors episode += 1
from beer.BeerAgent import BeerAgent def test_ann(shadows, step): global ann for i in xrange(5): n = ann.neurons["s" + str(i)] n.output = shadows[i] n.step_counter = step right = ann.neurons["o0"].update(step) left = ann.neurons["o1"].update(step) return left, right test = {'s0': {'tau': 1.592686147215389, 'bias': -2.615998446020173, 'g': 4.064259823298805}, 's3': {'tau': 2.0, 'bias': -9.596911713770295, 'g': 2.699219833009929}, 's2': {'tau': 2.0, 'bias': -7.9381838205981925, 'g': 1.196180415897641}, 's1': {'tau': 1.7131650362733641, 'bias': -9.800554266312117, 'g': 5}, 'h1': {'tau': 1.4759850492782784, 'g': 4.169964788304448, 's3': 10, 's2': -7.597575378784047, 's1': -7.30851842034613, 's0': -5.515947610513402, 's4': 10, 'bias': 0, 'h0': -9.161215598682354}, 's4': {'tau': 1.719469269868766, 'bias': -10, 'g': 1.5148042062097178}, 'h0': {'tau': 1.9805457921140477, 's0': 3.8498836747822374, 'g': 1.1918849794755142, 's3': 0.19606976014775368, 's2': 1.2234104157931345, 's1': -3.9816290689941063, 'h1': -1.752762947517268, 's4': 7.843733074806298, 'bias': -6.082985820301836}, 'o1': {'tau': 1.1177444179110503, 'g': 4.156539205282791, 'h0': 0.5183605142731278, 'h1': 9.884145727513904, 'bias': -3.094239221093069, 'o0': -10}, 'o0': {'tau': 1.5704922925516338, 'g': 4.8005459803723385, 'h0': 10.0, 'h1': -5.936363488987634, 'bias': -2.338789992756717, 'o1': -5.317834057912171}} ann = ANN(BeerAgent.source) for neuron in BeerAgent.source_appends: for key, weight in neuron["weights"].items(): ann.add_input(neuron["name"], key, weight, True) for key, node in test.items(): for t,n in node.items(): neu = ann.neurons[key] if t == 'tau': neu.tau = n elif t == 'bias': neu.bias = n elif t == 'g': neu.g = n else:
import sys sys.path.append('../') from ann import ANN def plot_error(data): plt.plot(data) plt.show() # Training set for the logical operator XOR training_set = [ ([0,0],[0]), ([1,0],[1]), ([0,1],[1]), ([1,1],[0]) ] # Construct a neural net with 2 input nodes, 3 hidden nodes, and 1 output node ann = ANN(2,3,1,alpha=1) # Run the network through 1000 iterations of the training set error_data = [ann.train_set(training_set) for _ in range(2000)] # Plot the mean error for each iteration none, left, right, both = zip(*error_data) none_line, = plt.plot(none) left_line, = plt.plot(left) right_line, = plt.plot(right) both_line, = plt.plot(both) plt.legend([none_line, left_line, right_line, both_line], ['[0,0]', '[1,0]', '[0,1]', '[1,1]']) plt.xlabel('Iterations')
def init(self): self.ann = ANN(self.userid) if self.ann.loadData(): return self.ann.init([25, 30, 20, 26])