def weights(shape, name=None): return tf.Variable(tf.random_normal(shape), name=name) def biases(shape, name=None): return tf.Variable(tf.random_normal(shape), name=name) TRAIN_FOLDER_PATH = "G:/DL/Iceberg Classifier Challenge/train/data/processed/train.json" TEST_FOLDER_PATH = "G:/DL/Iceberg Classifier Challenge/test/data/processed/test.json" dataset_train_features, dataset_train_labels = get_dataset_in_np( TRAIN_FOLDER_PATH, labels_available=True) # dataset_test_features = get_dataset_in_np(TEST_FOLDER_PATH, labels_available=False) dataset_train_features, dataset_test_features = normalize( dataset_train_features, dataset_train_features) # TODO: change to dataset_test_features print('dataset_train_features.shape:', dataset_train_features.shape, 'dataset_train_labels.shape:', dataset_train_labels.shape) DIMENSION = dataset_train_features.shape[1] NUM_CHANNELS = dataset_train_features.shape[3] NUM_CLASSES = dataset_train_labels.shape[1] NUM_EXAMPLES = dataset_train_features.shape[0] BATCH_SIZE = 16 NUM_EPOCHS = 100 x = tf.placeholder(tf.float32, shape=[None, DIMENSION, DIMENSION, NUM_CHANNELS]) y = tf.placeholder(tf.float32, shape=[None, dataset_train_labels.shape[1]])
training_params.path_to_chinese_dataset) np.save(npy_name, chinese_dataset) if training_params.get_features: chinese_dataset = np.load(npy_name) data_extraction.extract_features( chinese_dataset, training_params.path_to_chinese_samples) X, Y = data_extraction.get_sample(training_params.path_to_chinese_samples) '''5-fold cross_validation(K-折交叉验证)''' kfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=100) for train, test in kfold.split(X, Y): train_x = X[train] train_y = Y[train] test_x = X[test] test_y = Y[test] train_x = data_preprocessing.normalize(train_x) test_x = data_preprocessing.normalize(test_x) timestep = 24 train_x = data_preprocessing.pad_sequence(train_x, timestep) test_x = data_preprocessing.pad_sequence(test_x, timestep) train_y_cat = data_preprocessing.to_categorical(train_y) test_y_cat = data_preprocessing.to_categorical(test_y) model = training_models.train_lstm(train_x, train_y_cat, test_x, test_y_cat) scores = model.predict(test_x) prediction = np.array([ training_params.available_emotions[np.argmax(t)] for t in scores ]) # np.argmax(t) 返回最值所在的索引 print(prediction[prediction == test_y].shape[0] /
def normalizing(df): return data_preprocessing.normalize(df)
import greenhouse_clock import data_sourcing import data_splitting import data_preprocessing import feature_engineering from modeling import model import performance_monitoring start_time = greenhouse_clock.get_time() if __name__ == "__main__": # Run prefect flow df = data_sourcing.get() df = data_preprocessing.clean(df) df = data_preprocessing.normalize(df) train, valid, test = data_splitting.split(df) ( train["x"], valid["x"], test["x"], ) = feature_engineering.numerical_missing_imputation( train=train, valid=valid, test=test, cols=["x"], imputation_method="median") m = model().fit(train=train, y_col="y", x_col="x")
def train_model(learn_model, num_epochs, batch_size, learning_rate): """takes a some parameters, trains a specified model, calculates accuracy during training and prints it out. Prints out final accuracy on a test set as well""" #load data num_classes = 6 tr_data = normalize(load_data('X_train.txt')) tr_labels = one_hot_encode_labels(load_data('y_train.txt'),num_classes) te_data = normalize(load_data('X_test.txt')) te_labels = one_hot_encode_labels(load_data('y_test.txt'),num_classes) #determine which learn method to run if learn_model =='logistic' or learn_model == '2-layer': if learn_model=='logistic': x,y_,model,train_op,accuracy = logistic_classifier(learning_rate) else: x,y_,model,train_op,accuracy = two_layer_net(learning_rate) with tf.Session() as sess: sess.run(model) count = 0 #get sample length sample_length = tr_data.shape[0] #get number of batches num_batches = int(sample_length/batch_size) #make the containers to hold test and train accuracy train_accuracy = np.zeros([num_epochs*num_batches,1]) test_accuracy = np.zeros([num_epochs,1]) for epoch in range(num_epochs): #get shuffled index shuffled_indexes = np.arange(sample_length) np.random.shuffle(shuffled_indexes) #shuffle data shuffled_train_data = tr_data[shuffled_indexes] shuffled_train_labels = tr_labels[shuffled_indexes] for i in range(num_batches): #gather batches start = i*batch_size end = (i+1)*batch_size #make sure dont access part of an array that doesn't exist(small overlap of data from previous batch will occur - artifact of uneven data set and even batch size) if end > sample_length: end = sample_length if start > sample_length-batch_size: start = sample_length-batch_size batch_x,batch_y = shuffled_train_data[start:end][:],shuffled_train_labels[start:end][:] _,train_accuracy[count] = sess.run([train_op, accuracy], feed_dict={x:batch_x,y_:batch_y}) #prints out the accuracy every 7 batches (So that an even amount gets printed out based on num_batches) print_out = int(num_batches/7) if i%print_out==0: print("epoch%d, train_step %d, training accuracy %g"%(epoch, i, train_accuracy[count])) count +=1 test_accuracy[epoch] = sess.run(accuracy, feed_dict={x: te_data, y_: te_labels}) print("epoch: %d, test accuracy: %g"%(epoch, test_accuracy[epoch])) print("--------------------------------------------------------------") #calculates average accuracy at five points #plots train accuracy train_line, = plt.plot(train_accuracy,'r.', label = 'train accuracy') test_line, = plt.plot([e*num_batches for e in range(num_epochs)], test_accuracy,'b-', label = 'test accuracy') plt.legend(loc = 'lower right') plt.xlabel('Batch Number') plt.ylabel('Accuracy') plt.title('Prediction Accuracy vs Batch Number') #plt.legend(handles=[]) plt.show() if learn_model =='knn': #get input from user raw_k_val = input("Please enter odd k value (recommend 7) or enter 0 to run a list of k values: ") if int(raw_k_val)==0: #ran multiple k's to decide which was best for this data set (Keep odd so that there are no ties) num_neighbours = [1,3,5,7,9,11,13,15] #num_neighbours = [1,3] else: num_neighbours = [int(raw_k_val)] #will contain the accuracy for each value of k train_accuracy = np.zeros((len(num_neighbours))) for index, k in enumerate(num_neighbours): #retrieve object for graph_constructor x,y_,xtest, ytest,accuracy, model,train_op = knn(k) with tf.Session() as sess: sess.run(model) # loop over test data for i in range(len(te_data)): # Get nearest neighbor to each row of test data which represents one multi dimensional data point train_accuracy[index] += sess.run(accuracy, feed_dict={x: tr_data, y_: tr_labels, xtest: te_data[i, :], ytest: te_labels[i]}) if i%200==0: print(str(i) + ' out of ' + str(len(te_data)) + ' have been tested') print("k = {}, Accuracy: {} ".format(k, train_accuracy[index]/len(te_data))) #only plot if there is more than one k value if int(raw_k_val) == 0: plt.plot(num_neighbours, train_accuracy/len(te_data), 'ro') plt.xlabel('K - value') plt.ylabel('Accuracy') plt.title('Prediction Accuracy vs Batch Number') plt.show()
X_test = X_test.transpose((3, 0, 1, 2)) # EXPECTED IMAGE SIZE img_height = 32 img_width = 32 # PROCESSING THE DATA AND HAVING A LOOK AT AN EXAMPLE rand_int = np.random.randint(X_train.shape[0]) rand_img = X_train[rand_int, :, :, :] plt.imshow(rand_img) plt.show() method = 'grey_scale' X_train = dp.prepocess(X_train, method=method) X_test = dp.prepocess(X_test, method=method) X_train, X_test = dp.normalize(X_train, X_test) if X_train.shape[3] == 3: rand_img = X_train[rand_int, :, :, :] - np.amin(X_train[rand_int, :, :, :]) rand_img = rand_img / np.amax(rand_img) else: rand_img = X_train[rand_int, :, :, 0] plt.imshow(rand_img) plt.show() ############################################################################### # BUILDING TENSORFLOW MODEL tf.reset_default_graph() model = gc.CNN(img_height=img_height, img_width=img_width,
def train_model(num_epochs, batch_size): """Trains model, outputs train and validation accuracy during training, has a early stopping if validation error increases, outputs test accuracy on unseen dataset. params: :num_epochs: This is the number of cycles the model should be trained on :batch_size: Batch training is being used to perform optimization. Therefore the size of the batch must be specified. It cannot be too large else there will be an out of memory error. Generally 20-50 is a good size for the current setup return: nothing. """ #load data num_classes = 10 images_train, labels_train = load_data('train_32x32.mat') tr_data = normalize(images_train) tr_labels = one_hot_encode_labels(labels_train, num_classes) images_test, labels_test = load_data('test_32x32.mat') te_data = normalize(images_test) te_labels = one_hot_encode_labels(labels_test, num_classes) #split test set into validation set and test set 50/50 num_feat_val_set = 500 val_data, val_labels = te_data[: num_feat_val_set], te_labels[: num_feat_val_set] testing_data_and_labels = generate_data(te_data[num_feat_val_set:], te_labels[num_feat_val_set:]) x, y_, model, train_op, accuracy, keep_prob = classifier() #save model functionailty saver = tf.train.Saver() #variable used to determine if to exit training phase due to overfitting exit = False #start interactive matplotlib session plt.ion() with tf.Session() as sess: sess.run(model) count = 0 #training #get sample length sample_length = tr_data.shape[0] #get number of batches num_batches = int(sample_length / batch_size) #make the containers to hold test and train accuracy train_accuracy = np.zeros([num_epochs * num_batches, 1]) val_accuracy = np.zeros([num_epochs * num_batches, 1]) test_accuracy = 0 for epoch in range(num_epochs): #get shuffled index shuffled_indexes = np.arange(sample_length) np.random.shuffle(shuffled_indexes) #shuffle data shuffled_train_data = tr_data[shuffled_indexes] shuffled_train_labels = tr_labels[shuffled_indexes] for i in range(num_batches): #gather batches start = i * batch_size end = (i + 1) * batch_size #make sure dont access part of an array that doesn't exist(small overlap of data from previous batch will occur - artifact of uneven data set and even batch size) if end > sample_length: end = sample_length if start > sample_length - batch_size: start = sample_length - batch_size batch_x, batch_y = shuffled_train_data[ start:end][:], shuffled_train_labels[start:end][:] _, train_accuracy[count] = sess.run([train_op, accuracy], feed_dict={ x: batch_x, y_: batch_y, keep_prob: 0.5 }) val_accuracy[count] = sess.run(accuracy, feed_dict={ x: val_data, y_: val_labels, keep_prob: 1.0 }) #prints out the accuracy every 7 batches (So that an even amount gets printed out based on num_batches) print_out = int(num_batches / 7) if i % print_out == 0: print("epoch: %d, train_step %d, training accuracy %g" % (epoch, i, train_accuracy[count])) print("epoch: %d, test accuracy: %g" % (epoch, val_accuracy[count])) #plotting train_line, = plt.plot(count, train_accuracy[count], 'bo', label='train_accuracy') val_line, = plt.plot(count, val_accuracy[count], 'ro', label='validation_accuracy') plt.xlabel('Batch Number') plt.ylabel('Accuracy') plt.title('Validation & train accuracy vs Batch Number') plt.pause(0.05) #exit training if there is increased validation error (decrease in test accuracy) if val_accuracy[count] < (val_accuracy[count - 1] - 0.1): exit = True break count += 1 #exit training if there is increased validation error (decrease in test accuracy) if exit: print("Overfitting occuring: exiting training phase") break print( "--------------------------------------------------------------" ) #saves model saver_path = saver.save(sess, './trained_model.ckpt') print("Saved model: ", saver_path) #calculate test accuracy on unseen test set for _ in range(te_data.shape[0] - num_feat_val_set): batch = next(testing_data_and_labels) test_accuracy += sess.run(accuracy, feed_dict={ x: np.reshape(batch[0], (1, 32, 32, 3)), y_: np.reshape(batch[1], (1, 10)), keep_prob: 1.0 }) print("Testing Accuracy: %g" % (float(test_accuracy) / float(te_data.shape[0] - num_feat_val_set)))
def train_model(num_epochs, batch_size, learning_rate): """Trains a neural network for image classification from the SVHN dataset, and creates a plot giving training/testing accuracy as a function of batch number. Parameters: num_epochs -- Number of training epochs batch_size -- Number of examples in each training batch learning_rate -- Initial learning rate """ # Get data: train_X_orig, train_y_orig, _, _ = data_preprocessing.load_data() train_X_norm = data_preprocessing.normalize(train_X_orig) train_X, valid_X, train_y, valid_y = data_preprocessing.split( train_X_norm, train_y_orig) # One-hot encode so they can be used for input/validation: train_y_cat = keras.utils.to_categorical(train_y, num_classes=10) valid_y_cat = keras.utils.to_categorical(valid_y, num_classes=10) # Build & compile model: model = graph_construction.get_keras_model() sgd = SGD(lr=learning_rate, decay=1e-5, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) # Train: history = BatchHistory(valid_X, valid_y_cat) model.fit(train_X, train_y_cat, epochs=num_epochs, batch_size=batch_size, callbacks=[history], validation_data=(valid_X, valid_y_cat)) # The callback slows things down a bit, but I'm not sure of a good # way around it. If I were testing only on specific batches of # validation data, it might be less of an issue. fname_base = "model_{0}_{1}_{2}_rgb".format(learning_rate, num_epochs, batch_size) model.save_weights("{0}.h5".format(fname_base)) # Plot training & validation accuracy, and loss (not called for, # but useful): b = [i["batch"] for i in history.history] plt.plot(b, [i["acc"] for i in history.history]) plt.plot(b, [i["val_acc"] for i in history.history]) plt.ylabel('Accuracy') plt.xlabel('Batch') plt.legend(['Training', 'Validation'], loc='lower right') plt.savefig("{0}_accuracy.png".format(fname_base)) plt.show() plt.close() plt.plot(b, [i["loss"] for i in history.history]) plt.plot(b, [i["val_loss"] for i in history.history]) plt.ylabel('Loss (categorical cross-entropy)') plt.xlabel('Batch') plt.legend(['Training', 'Validation'], loc='lower right') plt.savefig("{0}_loss.png".format(fname_base)) plt.close()