def generate_svg(self, model, hidden_layer_prefix='dense', output_layer_name='output'): self.input_length = model.inputs[0].shape.dims[1].value self.hidden_layer_count = self.set_hidden_layer_count() self.known_layer_names = list(map(lambda u: hidden_layer_prefix + str(u), range(self.hidden_layer_count))) + \ [output_layer_name] self.set_min_and_max_values(model) image = svgwrite.Drawing() self.draw_input_connections(image) for layer_index in range(0, len(self.known_layer_names)): x = self.x_offset + ((layer_index + 1) * self.x_spacing) layer_vars = tflearn.get_layer_variables_by_name( self.known_layer_names[layer_index]) weights = model.get_weights(layer_vars[0]) self.draw_layer_connections(image, weights, x) for layer_index in range(0, len(self.known_layer_names)): layer_vars = tflearn.get_layer_variables_by_name( self.known_layer_names[layer_index]) self.draw_layer_nodes(image, layer_index, layer_vars, model) self.draw_input_nodes(image) return '<?xml version="1.0" encoding="UTF-8" standalone="no"?>' + image.tostring( )
def train(args, glove, data, param_file_path): if glove is None: embedding_size = (utils.NUM_UNIQUE_TOKENS, int(args['--embedding-dims'])) else: embedding_size = glove[0].shape print("Loading model definition for %s..." % args['--model']) net = models.get_model(args['--model'], embedding_size=embedding_size, train_embedding=args['--train-embedding'], hidden_dims=int(args['--hidden-dims']), learning_rate=float(args['--learning-rate'])) model = tflearn.DNN(net, clip_gradients=5., tensorboard_verbose=0) if args['--evaluate-only'] or args['--continue-training']: print("Loading saved parameters from %s" % param_file_path) model.load(param_file_path) elif glove is not None: print("Initializing word embedding...") # Retrieve embedding layer weights (only a single weight matrix, so index is 0) embedding_weights = tflearn.get_layer_variables_by_name('EmbeddingLayer')[0] # Initialize with glove embedding model.set_weights(embedding_weights, glove[0]) if not args['--evaluate-only']: print("Training...") model.fit(data.trainX, data.trainY, n_epoch=int(args['--epochs']), validation_set=(data.valX, data.valY), show_metric=True, batch_size=128, run_id=os.path.splitext(param_file_path)[0]) print("Saving parameters to %s" % param_file_path) model.save(param_file_path) return model
def generate_model(train_x, train_y, input_embeddings): model = tflearn.DNN(rnn_net(), tensorboard_verbose=0) model.fit(train_x, train_y, batch_size=32) embedding_weights = tflearn.get_layer_variables_by_name( 'EmbeddingLayer')[0] model.set_weights(embedding_weights, input_embeddings) return model
def lstm(trainX, trainY, valX, valY, testX, input_weights): ''' Standard lstm Network. ''' # Network building LSTM net = tflearn.input_data([None, MAX_LENGHT]) net = tflearn.embedding(net, input_dim=input_weights.shape[0], output_dim=input_weights.shape[1], trainable=True, name="EmbeddingLayer") net = tflearn.lstm(net, 128, dropout=0.5) net = tflearn.fully_connected(net, 12, activation='softmax') net = tflearn.regression(net, optimizer='adam', learning_rate=0.01, loss='categorical_crossentropy') # Training model = tflearn.DNN(net, tensorboard_verbose=0) # Add embedding weights into the embedding layer embeddingWeights = tflearn.get_layer_variables_by_name("EmbeddingLayer")[0] model.set_weights(embeddingWeights, input_weights) model.fit(trainX, trainY, n_epoch=NB_EPOCHS, validation_set=(valX, valY), show_metric=True, batch_size=32) y_result = model.predict(testX) return y_result
def train(self, trainX, trainY, model_path, ibatch_size=128): # Training gf = smart_open.smart_open(Config.GLOVE_EMBEDDINGS_PATH, 'rb') glove_embeddings = pickle.load(gf) shortened_embeddings = np.zeros((51887, 200)) index = 0 for item in glove_embeddings: shortened_embeddings[index, :] = item[:200] index += 1 # Retrieve embedding layer weights (only a single weight matrix, so index is 0) embeddingWeights = tflearn.get_layer_variables_by_name( 'EmbeddingLayer')[0] print('default embeddings: ', embeddingWeights[0]) self.model.set_weights(embeddingWeights, shortened_embeddings) self.model.fit(trainX, trainY, validation_set=0.1, n_epoch=10, show_metric=True, batch_size=ibatch_size) self.model.save(model_path) print('Model saved at the following location: ', model_path) return self.model
def create_lstm(max_sequence_length, dict_size, word_vectors): net = tflearn.input_data([None, max_sequence_length]) #vocab_dim = 50 #n_symbols = dict_size #embedding_weights = np.zeros((n_symbols, vocab_dim)) #for word, index in index_dict.items(): # embedding_weights[index, :] = word_vectors[word] # define inputs here #embedding_layer = Embedding(output_dim=vocab_dim, input_dim=n_symbols, trainable=True) #embedding_layer.build((None,)) # if you don't do this, the next step won't work #embedding_layer.set_weights([embedding_weights]) emb = tflearn.embedding(net, input_dim=dict_size, output_dim=50, trainable=True, name='EmbeddingLayer') net = tflearn.lstm(emb, 64, dropout=0.75) net = tflearn.fully_connected(net, 2, activation='softmax') net = tflearn.regression(net, optimizer='adam', learning_rate=0.001, loss='categorical_crossentropy') model = tflearn.DNN(net, tensorboard_verbose=0, tensorboard_dir='../tensorboard/tensorboard_lstm') embeddingWeights = tflearn.get_layer_variables_by_name('EmbeddingLayer')[0] model.set_weights(embeddingWeights, word_vectors) print(model.get_weights(emb.W)) return model
def build_network(self): # Smaller 'AlexNet' # https://github.com/tflearn/tflearn/blob/master/examples/images/alexnet.py print('[+] Building CNN') self.network = input_data(shape=[None, SIZE_FACE, SIZE_FACE, 1]) print(input_data) self.network = conv_2d(self.network, 64, 5, activation='relu') #self.network = local_response_normalization(self.network) self.network = max_pool_2d(self.network, 3, strides=2) self.network = conv_2d(self.network, 64, 5, activation='relu') layer1 = tflearn.get_layer_variables_by_name('Conv2D_1') #print(layer1) self.network = max_pool_2d(self.network, 3, strides=2) self.network = conv_2d(self.network, 128, 4, activation='relu') self.network = dropout(self.network, 0.3) self.network = fully_connected(self.network, 3072, activation='relu') self.network = fully_connected(self.network, len(EMOTIONS), activation='softmax') self.network = regression(self.network, optimizer='momentum', loss='categorical_crossentropy') self.model = tflearn.DNN(self.network, checkpoint_path=SAVE_DIRECTORY + '/emotion_recognition', max_checkpoints=1, tensorboard_verbose=2) self.load_model()
def cnn_3_filters(trainX, trainY, valX, valY, testX, input_weights): ''' A CNN with three convolutional layers as in Kim Yoon (Convolutional Neural Networks for Sentence Classification) ''' # Building convolutional network network = input_data(shape=[None, MAX_LENGHT], name='input') network = tflearn.embedding(network, input_dim=input_weights.shape[0], output_dim=input_weights.shape[1], trainable=True, name="EmbeddingLayer") branch1 = conv_1d(network, 128, 3, padding='valid', activation='relu', regularizer="L2") branch2 = conv_1d(network, 128, 4, padding='valid', activation='relu', regularizer="L2") branch3 = conv_1d(network, 128, 5, padding='valid', activation='relu', regularizer="L2") network = merge([branch1, branch2, branch3], mode='concat', axis=1) network = tf.expand_dims(network, 2) network = global_max_pool(network) network = dropout(network, 0.5) network = fully_connected(network, 12, activation='softmax') network = regression(network, optimizer='adam', learning_rate=0.001, loss='categorical_crossentropy', name='target') # Training model = tflearn.DNN(network, tensorboard_verbose=1) # Add embedding weights into the embedding layer embeddingWeights = tflearn.get_layer_variables_by_name("EmbeddingLayer")[0] model.set_weights(embeddingWeights, input_weights) print("Start trianing CNN...") model.fit(trainX, trainY, n_epoch=NB_EPOCHS, validation_set=(valX, valY), shuffle=True, show_metric=True, batch_size=32) y_result = model.predict(testX) return y_result
def filter_displayer(model, layer, padding=1): """ The function displays the filters of layer :param model: tflearn obj, DNN model of tflearn :param layer: string or tflearn obj., the layer whose weights we want to display :param padding: The number of pixels between each two filters :return: imshow the purput image """ if isinstance(layer, str): vars = tflearn.get_layer_variables_by_name(layer) variable = vars[0] else: variable = layer.W filters = model.get_weights(variable) print(filters.shape[0], filters.shape[1], filters.shape[2], filters.shape[3]) # n is the number of convolutions per filter n = filters.shape[2] * filters.shape[3] / 2 # Ensure the output image is rectangle with width twice as # big as height # and compute number of tiles per row (nc) and per column (nr) nr = int(np.ceil(np.sqrt(n))) nc = 2 * nr # Assuming that the filters are square filter_size = filters.shape[0] # Size of the output image with padding img_w = nc * (filter_size + padding) - padding img_h = nr * (filter_size + padding) - padding # Initialize the output image filter_img = np.zeros((img_h, img_w)) # Normalize image to 0-1 fmin = filters.min() fmax = filters.max() filters = (filters - fmin) / (fmax - fmin) # Starting the tiles filter_x = 0 filter_y = 0 for r in range(filters.shape[3]): for c in range(filters.shape[2]): if filter_x == nc: filter_y += 1 filter_x = 0 for i in range(filter_size): for j in range(filter_size): filter_img[filter_y * (filter_size + padding) + i, filter_x * (filter_size + padding) + j] = \ filters[i, j, c, r] filter_x += 1 # Plot figure plt.figure(figsize=(10, 5)) plt.axis('off') plt.imshow(filter_img, cmap='gray', interpolation='nearest') plt.show()
def display_convolutions(model, layer, padding=4, filename=''): if isinstance(layer, six.string_types): vars = tflearn.get_layer_variables_by_name(layer) vars = tflearn.get_layer_variables_by_name(layer) variable = vars[0] else: variable = layer.W data = model.get_weights(variable) filter_size = data.shape[0] filter_depth = data.shape[2] number_of_filters = data.shape[3] N = filter_depth * number_of_filters # N is the total number of convolutions # Ensure the resulting image is square filters_per_row = int(np.ceil(np.sqrt(number_of_filters))) result_size = filters_per_row * (filter_size + padding) - padding result = np.zeros((result_size, result_size, 4)) filter_x = 0 filter_y = 0 for filter_number in range(number_of_filters): if filter_x == filters_per_row: filter_y += 1 filter_x = 0 for i in range(filter_size): for j in range(filter_size): plot_i = filter_y * (filter_size + padding) + i plot_j = filter_x * (filter_size + padding) + j result[plot_i, plot_j, 0] = data[i, j, 0, filter_number] result[plot_i, plot_j, 1] = data[i, j, 1, filter_number] result[plot_i, plot_j, 2] = data[i, j, 2, filter_number] result[plot_i, plot_j, 3] = data[i, j, 3, filter_number] filter_x += 1 # Normalize image to 0-1 min, max = result.min(), result.max() result = (result - min) / (max - min) plot_figure(result, filename)
def display_convolutions(model, layer, padding=4, filename=''): if isinstance(layer, six.string_types): vars = tflearn.get_layer_variables_by_name(layer) variable = vars[0] else: variable = layer.W data = model.get_weights(variable) # N is the total number of convolutions N = data.shape[2] * data.shape[3] # Ensure the resulting image is square filters_per_row = int(np.ceil(np.sqrt(N))) # Assume the filters are square filter_size = data.shape[0] # Size of the result image including padding result_size = filters_per_row * (filter_size + padding) - padding # Initialize result image to all zeros result = np.zeros((result_size, result_size)) # Tile the filters into the result image filter_x = 0 filter_y = 0 for n in range(data.shape[3]): for c in range(data.shape[2]): if filter_x == filters_per_row: filter_y += 1 filter_x = 0 for i in range(filter_size): for j in range(filter_size): result[filter_y * (filter_size + padding) + i, filter_x * (filter_size + padding) + j] = \ data[i, j, c, n] filter_x += 1 # Normalize image to 0-1 min = result.min() max = result.max() result = (result - min) / (max - min) # Plot figure plt.figure(figsize=(10, 10)) plt.axis('off') plt.imshow(result, cmap='gray', interpolation='nearest') # Save plot if filename is set if filename != '': plt.savefig(filename, bbox_inches='tight', pad_inches=0) plt.show()
def display_convolutions(model, layer, padding=3, axis=None, cmap='gray'): if isinstance(layer, str): variable = tflearn.get_layer_variables_by_name(layer) variable = variable[0] else: variable = layer.W data = model.get_weights(variable) # N is the total number of convolutions N = data.shape[2] * data.shape[3] # Ensure the resulting image is square filters_per_row = int(np.ceil(np.sqrt(N))) # Assume the filters are square filter_size = data.shape[0] # Size of the result image including padding result_size = filters_per_row * (filter_size + padding) - padding # Initialize result image to all zeros result = np.zeros((result_size, result_size)) # Tile the filters into the result image filter_x = 0 filter_y = 0 for n in range(data.shape[3]): for c in range(data.shape[2]): if filter_x == filters_per_row: filter_y += 1 filter_x = 0 for i in range(filter_size): for j in range(filter_size): result[filter_y * (filter_size + padding) + i, filter_x * (filter_size + padding) + j] = \ data[i, j, c, n] filter_x += 1 # Normalize image to 0-1 min = result.min() max = result.max() result = (result - min) / (max - min) if not axis: # Plot figure plt.figure(figsize=(10, 10)) axis = plt.gca() axis.imshow(result, cmap=cmap, interpolation='nearest') return axis
def build_model(self): trainable, net = self.build_embedding_layer() net = self.transform_embedded_sequences(net) net = regression( net, optimizer=self.optimizer, loss='categorical_crossentropy', name='target') model = tflearn.DNN(net, tensorboard_verbose=0) if not trainable: embedding_matrix = get_embedding_matrix(self.vocab, self.embeddings_path) embeddingWeights = tflearn.get_layer_variables_by_name('EmbeddingLayer')[0] model.set_weights(embeddingWeights, embedding_matrix) return model
def train(data_dict, model_type, vector_type,flag, embed_size, dump_embeddings=False): print("trainnn") data, trainX, trainY, testX, testY, vocab_processor = return_data(data_dict) vocab_size = len(vocab_processor.vocabulary_) NUM_CLASSES = 3 print(NUM_CLASSES) print(trainX.shape[1]) print("Vocabulary Size: {:d}".format(vocab_size)) vocab = vocab_processor.vocabulary_._mapping print(model_type) print(vector_type) print("Running Model: " + model_type + " with word vector initiliazed with " + vector_type + " word vectors.") model = get_model(model_type, trainX.shape[1], vocab_size, embed_size, NUM_CLASSES, LEARN_RATE) initial_weights = model.get_weights() shuffle_weights(model, initial_weights) if(vector_type!="random"): print("Word vectors used: " + vector_type) model.layers[0].set_weights([map_embedding_weights(get_embeddings_dict(vector_type, embed_size), vocab, embed_size)]) model.fit(trainX, trainY, epochs=EPOCHS, shuffle=True, batch_size=BATCH_SIZE, verbose=1) else: model.fit(trainX, trainY, epochs=EPOCHS, shuffle=True, batch_size=BATCH_SIZE, verbose=1) if (dump_embeddings==True): if(model_type == 'cnn'): embeddingWeights = tflearn.get_layer_variables_by_name('EmbeddingLayer')[0] else: embed = model.layers[0].get_weights()[0] embed_filename = output_folder_name + data + "_" + model_type + "_" + vector_type + "_" + str(embed_size) + ".pkl" embed.dump(embed_filename) vocab_filename = output_folder_name + data + "_" + model_type + "_" + vector_type + "_" + str(embed_size) + "_dict.json" reverse_vocab_filename = output_folder_name + data + "_" + model_type + "_" + vector_type + "_" + str(embed_size) + "_reversedict.json" with open(vocab_filename, 'w') as fp: json.dump(vocab_processor.vocabulary_._mapping, fp) with open(reverse_vocab_filename, 'w') as fp: json.dump(vocab_processor.vocabulary_._reverse_mapping, fp) return evaluate_model(model, testX, testY,flag)
def set_min_and_max_values(self, model): for layer_name in self.known_layer_names: layer_vars = tflearn.get_layer_variables_by_name(layer_name) weights = model.get_weights(layer_vars[0]) tmp_max = float(max(map(max, weights))) self.max_weight_percentage = float( max(tmp_max, self.max_weight_percentage)) tmp_min = float(min(map(max, weights))) self.min_weight_percentage = float( max(tmp_min, self.min_weight_percentage)) self.max_node_count = max(max(map(len, weights)), self.input_length) with model.session.as_default(): if len(layer_vars) > 1: bias_values = tflearn.variables.get_value(layer_vars[1]) self.min_bias_percentage = float( min((self.min_bias_percentage, float(min(bias_values))))) self.max_bias_percentage = float( max((self.max_bias_percentage, float(max(bias_values)))))
import cv2 from constants import * from Training import EmotionRecognition import numpy as np from PIL import Image, ImageDraw, ImageFont import tflearn import tensorflow as tf # Load Model network = EmotionRecognition() network.build_network() # Convolution_1 conv_1_var = tflearn.get_layer_variables_by_name("Conv2d_1") print("Convolution_1 layer weights:") print(network.model.get_weights(conv_1_var[0])) print("Convolution_1 layer Bias:") print(network.model.get_weights(conv_1_var[1])) # Convolution_2a conv_2a_var = tflearn.get_layer_variables_by_name("Conv_2a_FX1") print("Convolution_2a layer weights:") print(network.model.get_weights(conv_2a_var[0])) print("Convolution_2a layer Bias:") print(network.model.get_weights(conv_2a_var[1])) # Convolution_2b conv_2b_var = tflearn.get_layer_variables_by_name("Conv_2b_FX1") print("Convolution_2b layer weights:") print(network.model.get_weights(conv_2b_var[0])) print("Convolution_2b layer Bias:")
def my_objective(y_pred, y_true): return y_pred net = tflearn.regression(net, placeholder=None, loss=my_objective, learning_rate=1.0e-5) model = tflearn.DNN(net, tensorboard_verbose=3) model.fit(X_inputs={'main_statement_input': np.transpose(training_data_main[:main_statement_time_steps], (1, 0, 2)), 'main_hyps_input': np.transpose(training_data_main[main_statement_time_steps:], (1, 0, 2)), 'prop_statement_input_1': np.transpose(training_data_props[0][:prop_statement_time_steps], (1, 0, 2)), 'prop_hyps_input_1': np.transpose(training_data_props[0][prop_statement_time_steps:], (1, 0, 2)), 'prop_statement_input_2': np.transpose(training_data_props[1][:prop_statement_time_steps], (1, 0, 2)), 'prop_hyps_input_2': np.transpose(training_data_props[1][prop_statement_time_steps:], (1, 0, 2)), 'prop_statement_input_3': np.transpose(training_data_props[2][:prop_statement_time_steps], (1, 0, 2)), 'prop_hyps_input_3': np.transpose(training_data_props[2][prop_statement_time_steps:], (1, 0, 2)), 'prop_statement_input_4': np.transpose(training_data_props[3][:prop_statement_time_steps], (1, 0, 2)), 'prop_hyps_input_4': np.transpose(training_data_props[3][prop_statement_time_steps:], (1, 0, 2)), 'prop_statement_input_5': np.transpose(training_data_props[4][:prop_statement_time_steps], (1, 0, 2)), 'prop_hyps_input_5': np.transpose(training_data_props[4][prop_statement_time_steps:], (1, 0, 2))}, Y_targets=None, n_epoch=30, batch_size=100) model.save('pred_model.tflearn') np.save('Pred_W', model.get_weights(tflearn.get_layer_variables_by_name('Weight')[0]))
# Sequence padding # random.seed(1234) # trainX = pad_sequences(X, maxlen=5, value=0.) # trainY = [[random.uniform(-1, 1)] for i in range(len(X))] #PROOF OF CONCEPT # print X # print len(X) splitIdx = len(X) / 5 trainX, valX, testX = splitData(X, 0.7, 0.1) trainY, valY, testY = splitData(Y, 0.7, 0.1) # Training # net = fat_one_layer_LSTM() net = feedforward(embedding, maxClasses) model = tflearn.DNN(net) #, tensorboard_verbose=3) #insert our doc2vec embeddings here embeddingWeights = tflearn.get_layer_variables_by_name('Embedding')[0] model.set_weights(embeddingWeights, embedding) model.fit(trainX, trainY, validation_set=(valX, valY), show_metric=True, batch_size=32, n_epoch=100) print(trainY) print(model.predict(testX)) # model.save("rnn")
def train(data_dict, model_type, vector_type, embed_size, dump_embeddings=False): data, trainX, trainY, testX, testY, vocab_processor = return_data( data_dict) vocab_size = len(vocab_processor.vocabulary_) print("Vocabulary Size: {:d}".format(vocab_size)) vocab = vocab_processor.vocabulary_._mapping print("Running Model: " + model_type + " with word vector initiliazed with " + vector_type + " word vectors.") if (model_type != "cnn"): model = get_model(model_type, trainX.shape[1], vocab_size, embed_size, 4, LEARN_RATE) initial_weights = model.get_weights() shuffle_weights(model, initial_weights) else: model, network = get_model(model_type, trainX.shape[1], vocab_size, embed_size, 4, LEARN_RATE) initial_weights = model.get_weights(network.W) weights = [ np.random.permutation(w.flat).reshape(w.shape) for w in initial_weights ] weights = np.asarray(weights).reshape(initial_weights.shape) model.set_weights(network.W, weights) if (model_type == 'cnn'): if (vector_type != "random"): print("Word vectors used: " + vector_type) embeddingWeights = tflearn.get_layer_variables_by_name( 'EmbeddingLayer')[0] model.set_weights( embeddingWeights, map_embedding_weights( get_embeddings_dict(vector_type, embed_size), vocab, embed_size)) model.fit(trainX, trainY, n_epoch=EPOCHS, shuffle=True, show_metric=True, batch_size=BATCH_SIZE) else: model.fit(trainX, trainY, n_epoch=EPOCHS, shuffle=True, show_metric=True, batch_size=BATCH_SIZE) else: if (vector_type != "random"): print("Word vectors used: " + vector_type) model.layers[0].set_weights([ map_embedding_weights( get_embeddings_dict(vector_type, embed_size), vocab, embed_size) ]) model.fit(trainX, trainY, epochs=EPOCHS, shuffle=True, batch_size=BATCH_SIZE, verbose=1) else: model.fit(trainX, trainY, epochs=EPOCHS, shuffle=True, batch_size=BATCH_SIZE, verbose=1) return evaluate_model(model, testX, testY)
# spatially dropped and top element (winners) return net * drop, tf.reshape(th, tf.stack([b, c])) # b, c if __name__ == '__main__': """ let us test it on MNIST database""" import tflearn.datasets.mnist as mnist X, _, valX, _ = mnist.load_data(one_hot=True) X = X[:500].reshape([-1, 28, 28, 1]) valX = valX[:100].reshape([-1, 28, 28, 1]) with tf.Session() as sess: ae = sparseAE(sess) ae.build_model([None, 28, 28, 1]) # train the Autoencoder ae.train(X, valX, n_epochs=1) # valX for validation # compute the output for a certain input out = ae.model.predict(X[0].reshape([-1, 28, 28, 1])) print(out) # get the weights of a certain layer vars = tflearn.get_layer_variables_by_name('conv3') # in this case, it is the learned features W = ae.model.get_weights(vars[0]) print(W.shape) # get output of encoder for certain input m2 = tflearn.DNN(ae.sparse_rep, session=sess) print(m2.predict(X[0].reshape([-1, 28, 28, 1]))) # save and load the model ae.save('./sparseAE.tflearn') ae.load('./sparseAE.tflearn')
x = tflearn.fully_connected(x, 256, activation='relu') x = tflearn.fully_connected(x, 1, activation='sigmoid') return x gen_input = tflearn.input_data(shape=[None, z_dim], name='input_noise') disc_input = tflearn.input_data(shape=[None, 784], name='disc_input') gen_sample = generate(gen_input) disc_real = discrimination(disc_input) disc_fake = discrimination(gen_sample) disc_loss = -tf.reduce_mean(tf.log(disc_real)) + tf.log(1. - disc_fake) gen_loss = -tf.reduce_mean(tf.log(disc_fake)) gen_vars = tflearn.get_layer_variables_by_name('Generate') gen_model = tflearn.regression(gen_sample, placeholder=None, optimizer='adam', loss=gen_loss, trainable_vars=gen_vars, batch_size=64, name='target_gen', op_name='GEN') disc_vars = tflearn.get_layer_variables_by_scope('Discriminator') disc_model = tflearn.regression(disc_real, placeholder=None, optimizer='adam', loss=disc_loss, trainable_vars=disc_vars, batch_size=64,
network, _ = architectures.build_network(arch, network, CLASSES, None) # model definition model = tflearn.DNN(network, checkpoint_path='models', max_checkpoints=1, tensorboard_verbose=0) # tensorboard_dir='logs' print("[INFO] Loading trained model...") model.load(modelpath) print("[INFO] Model: ", modelpath) print("[INFO] Trained model loaded!\n") # get layer by its name if isinstance(layer, six.string_types): vars = tflearn.get_layer_variables_by_name(layer) variable = vars[0] else: variable = layer.W # load weights (learnt filters) and plots them weights = model.get_weights(variable) print("[INFO] Weights shape: ", weights.shape) plot_conv_weights(weights, input_channel=ichannel) # tries to load a image load = True try: if (ichannel == 3): img = scipy.ndimage.imread(sys.argv[5], mode='RGB', flatten=False) else:
def set_hidden_layer_count(self): x = 0 while tflearn.get_layer_variables_by_name('dense' + str(x)): x += 1 return x
def train_model(train, test, vocab_size, n_epoch=5, n_units=128): '''Method to load the dataset and train the RNN model.''' train_x = train['sub_seqs'] train_y = train['sub_label'] test_x = test['sub_seqs'] test_y = test['sub_label'] sequence_chunk_size = 15 learning_rate = 0.0001 dropout = 0.6 # Sequence padding train_x = pad_sequences(train_x, maxlen=sequence_chunk_size, value=0., padding='post') test_x = pad_sequences(test_x, maxlen=sequence_chunk_size, value=0., padding='post') # Converting labels to binary vectors train_y = to_categorical(train_y, nb_classes=vocab_size) test_y = to_categorical(test_y, nb_classes=vocab_size) print("Building network topology...") # Network building net = tflearn.input_data([None, 15]) net = tflearn.embedding(net, input_dim=vocab_size, output_dim=128, trainable=True) net = tflearn.gru(net, n_units=n_units, dropout=dropout, weights_init=tflearn.initializations.xavier(), return_seq=False) net = tflearn.fully_connected( net, vocab_size, activation='softmax', weights_init=tflearn.initializations.xavier()) net = tflearn.regression(net, optimizer='adam', learning_rate=learning_rate, loss='categorical_crossentropy') # Training model = tflearn.DNN(net, tensorboard_verbose=2) print("Training model...") model.fit(train_x, train_y, validation_set=(test_x, test_y), show_metric=False, batch_size=256, n_epoch=n_epoch) # For visualizations embedding = tflearn.get_layer_variables_by_name("Embedding")[0] return [model, embedding]
] net = merge(net, mode='concat') print("After RNN : ", net.get_shape().as_list()) print("After Dropout : ", net.get_shape().as_list()) net = regression(net, optimizer='adam', loss='binary_crossentropy', learning_rate=0.005) print("After regression : ", net.get_shape().as_list()) testX = trainX[int(0.3 * len(trainY)):] testY = trainY[int(0.3 * len(trainY)):] # Training model = DNN(net, clip_gradients=0., tensorboard_verbose=2) embeddingWeights = get_layer_variables_by_name('EmbeddingLayer')[0] # Assign your own weights (for example, a numpy array [input_dim, output_dim]) model.set_weights(embeddingWeights, embeddings) model.fit(trainX, trainY, n_epoch=3, validation_set=0.1, show_metric=True, batch_size=32, shuffle=True) #print( model.evaluate(testX, testY) ) predictions = model.predict(testX) predictions = prob2Onehot(predictions) #print("Predictions : ", list(predictions[10])) ##Calculate F1 Score
model = tflearn.DNN(net, tensorboard_verbose=2) model.fit(trainX, trainY, validation_set=(testX, testY), show_metric=False, batch_size=512,n_epoch=n_epoch) return model split_perc=0.8 train_len, test_len = np.floor(len(train_df)*split_perc), np.floor(len(train_df)*(1-split_perc)) train, test = train_df.ix[:train_len-1], train_df.ix[train_len:train_len + test_len] model = train_model(train,test,len(vocab)) from sklearn.manifold import TSNE #retrieve the embedding layer fro mthe model by default name 'Embedding' embedding = tflearn.get_layer_variables_by_name("Embedding")[0] finalWs = model.get_weights(embedding) tsne = TSNE(perplexity=30, n_components=2, init='pca', n_iter=5000) lowDWeights = tsne.fit_transform(finalWs) # bokeh 시각화 패키지 from bokeh.plotting import figure, show, output_notebook,output_file from bokeh.models import ColumnDataSource, LabelSet #control the number of labelled subreddits to display sparse_labels = [lbl if random.random() <=0.01 else '' for lbl in vocab] source = ColumnDataSource({'x':lowDWeights[:,0],'y':lowDWeights[:,1],'labels':sparse_labels}) TOOLS="hover,crosshair,pan,wheel_zoom,zoom_in,zoom_out,box_zoom,undo,redo,reset,tap,save,box_select,poly_select,lasso_select,"