def conv2d_work(input_dim): seq = Sequential() assert self.config['num_conv2d_layers'] > 0 for i in range(self.config['num_conv2d_layers']): seq.add(Conv2D(filters=self.config['2d_kernel_counts'][i], kernel_size=self.config['2d_kernel_sizes'][i], padding='same', activation='relu')) seq.add(MaxPooling2D(pool_size=(self.config['2d_mpool_sizes'][i][0], self.config['2d_mpool_sizes'][i][1]))) return seq
def train_model(): # (X_train, Y_train, X_test, Y_test) = prapare_train() X_ = [] with open('../data/train_matrix.out') as train_file: X_train = json.load(train_file) for x in X_train: a = len(x) print a/2 x1 = x[:a/2] x2 = x[a/2:] x3 = [] x3.append(x1) x3.append(x2) X_.append(x3) # X_test = pickle.load('../data/test_matrix.out') Y_train = [1,0,0]*3 # Y_test = [1,0,0]*3 # print len(X_train) - len(Y_train) # print len(X_test) - len(Y_test) model = Sequential() model = get_nn_model() model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) # model.fit(X_train, Y_train, # batch_size=batch_size, # nb_epoch=nb_epoch, # validation_data=(X_test, Y_test)) #2 model.fit(X_, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, validation_split = 0.2) print 'ok'
def create(self): language_model = Sequential() self.textual_embedding(language_model, mask_zero=True) self.language_model = language_model visual_model_factory = \ select_sequential_visual_model[self._config.trainable_perception_name]( self._config.visual_dim) visual_model = visual_model_factory.create() visual_dimensionality = visual_model_factory.get_dimensionality() self.visual_embedding(visual_model, visual_dimensionality) #visual_model = Sequential() #self.visual_embedding(visual_model) # the below should contain all zeros zero_model = Sequential() zero_model.add(RepeatVector(self._config.max_input_time_steps)-1) visual_model.add(Merge[visual_model, zero_model], mode='concat') self.visual_model = visual_model if self._config.multimodal_merge_mode == 'dot': self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)])) else: self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode)) self.add(self._config.recurrent_encoder( self._config.hidden_state_dim, return_sequences=False, go_backwards=self._config.go_backwards)) self.deep_mlp() self.add(Dense(self._config.output_dim)) self.add(Activation('softmax'))
def __init__(self, restore=None, session=None, Dropout=Dropout, num_labels=10): self.num_channels = 1 self.image_size = 28 self.num_labels = num_labels model = Sequential() nb_filters = 64 layers = [Conv2D(nb_filters, (5, 5), strides=(2, 2), padding="same", input_shape=(28, 28, 1)), Activation('relu'), Conv2D(nb_filters, (3, 3), strides=(2, 2), padding="valid"), Activation('relu'), Conv2D(nb_filters, (3, 3), strides=(1, 1), padding="valid"), Activation('relu'), Flatten(), Dense(32), Activation('relu'), Dropout(.5), Dense(num_labels)] for layer in layers: model.add(layer) if restore != None: model.load_weights(restore) self.model = model
class QLearn: def __init__(self, actions, epsilon, alpha, gamma): # instead of a dictionary, we'll be using # a neural network # self.q = {} self.epsilon = epsilon # exploration constant self.alpha = alpha # discount constant self.gamma = gamma # discount factor self.actions = actions # Build the neural network self.network = Sequential() self.network.add(Dense(50, init='lecun_uniform', input_shape=(4,))) # self.network.add(Activation('sigmoid')) #self.network.add(Dropout(0.2)) self.network.add(Dense(20, init='lecun_uniform')) # self.network.add(Activation('sigmoid')) # #self.network.add(Dropout(0.2)) self.network.add(Dense(2, init='lecun_uniform')) # self.network.add(Activation('linear')) #linear output so we can have range of real-valued outputs # rms = SGD(lr=0.0001, decay=1e-6, momentum=0.5) # explodes to non rms = RMSprop() # rms = Adagrad() # rms = Adam() self.network.compile(loss='mse', optimizer=rms) # Get a summary of the network self.network.summary()
def test_dropout(layer_class): for unroll in [True, False]: layer_test(layer_class, kwargs={'units': units, 'dropout': 0.1, 'recurrent_dropout': 0.1, 'unroll': unroll}, input_shape=(num_samples, timesteps, embedding_dim)) # Test that dropout is applied during training x = K.ones((num_samples, timesteps, embedding_dim)) layer = layer_class(units, dropout=0.5, recurrent_dropout=0.5, input_shape=(timesteps, embedding_dim)) y = layer(x) assert y._uses_learning_phase y = layer(x, training=True) assert not getattr(y, '_uses_learning_phase') # Test that dropout is not applied during testing x = np.random.random((num_samples, timesteps, embedding_dim)) layer = layer_class(units, dropout=0.5, recurrent_dropout=0.5, unroll=unroll, input_shape=(timesteps, embedding_dim)) model = Sequential([layer]) assert model.uses_learning_phase y1 = model.predict(x) y2 = model.predict(x) assert_allclose(y1, y2)
def Simple(layers, func, ipt): model = Sequential() #model.add(BatchNormalization(input_shape = [ipt])) model.add(Dense(layers[0], input_dim = ipt, activation = func[0])) for i in range(1, len(layers)): model.add(Dense(layers[i], activation = func[i])) return model
def encoders_m(self, inputs): input_encoder_m = Sequential() input_encoder_m.add(Embedding(input_dim=self.vocab_size, output_dim=64)) input_encoder_m.add(Dropout(0.3)) encode_m = input_encoder_m(inputs) return encode_m
def encoders_c(self, inputs): input_encoder_c = Sequential() input_encoder_c.add(Embedding(input_dim=self.vocab_size, output_dim=self.query_maxlen)) input_encoder_c.add(Dropout(0.3)) encoder_c = input_encoder_c(inputs) return encoder_c
def build_part1_RNN(window_size): model = Sequential() model.add(LSTM(5, input_shape=(window_size,1) )) #model.add(Dropout(0.5)) model.add(Dense(1)) return model
def build_part2_RNN(window_size, num_chars): model = Sequential() model.add(LSTM(200, input_shape=(window_size, num_chars))) #model.add(Dropout(0.5)) model.add(Dense(num_chars, activation='softmax')) return model
def get_item_subgraph(input_shape, latent_dim): # Could take item metadata here, do convolutional layers etc. model = Sequential() model.add(Dense(latent_dim, input_shape=input_shape)) return model
def create_model(kernel_regularizer=None, activity_regularizer=None): model = Sequential() model.add(Dense(num_classes, kernel_regularizer=kernel_regularizer, activity_regularizer=activity_regularizer, input_shape=(data_dim,))) return model
def fork (model, n=2): forks = [] for i in range(n): f = Sequential() f.add (model) forks.append(f) return forks
def build_partial_cnn1(img_rows, img_cols): model = Sequential() #model.add(Convolution2D(nb_filter=100, nb_row=5, nb_col=5, model.add(Convolution2D(nb_filter=10, nb_row=2, nb_col=2, init='glorot_uniform', activation='linear', border_mode='valid', input_shape=(1, img_rows, img_cols))) model.add(Activation('relu')) #model.add(MaxPooling2D(pool_size=(2, 2))) #model.add(Convolution2D(nb_filter=100, nb_row=5, nb_col=5, '''model.add(Convolution2D(nb_filter=512, nb_row=5, nb_col=5, init='glorot_uniform', activation='linear', border_mode='valid')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) #model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(256)) model.add(Activation('relu')) model.add(Dropout(0.5))''' return model
def build(self, layers): model = Sequential() for layer in layers: model.add(layer) self.model = TimeDistributed(model)
class trainCNN(object): def __init__(self): self.X = np.random.randn(200,1) self.Y = 1.2*self.X**2 + 0.5 def defineCNN(self): print("Setting up network...") self.model = Sequential() self.model.add(Dense(40, input_shape=(1,))) self.model.add(Activation('tanh')) self.model.add(Dense(1)) sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) self.model.compile(loss='mse', optimizer='RMSprop') def trainCNN(self, nIterations): print("Training network...") self.metrics = self.model.fit(self.X, self.Y, batch_size=20, nb_epoch=nIterations, validation_split=0.2, shuffle=False) # self.model.fit(self.XTrainSet, self.YTrainSet, batch_size=self.batchSize, nb_epoch=self.nbEpoch, validation_split=0.2) def testCNN(self): train = self.model.predict(self.X) pl.plot(self.X, self.Y, '.') pl.plot(self.X, train, 'x')
def create_model(insert=None): '''Create the basic model''' model = Sequential() layers = [Convolution2D(NB_FILTERS, NB_CONV, NB_CONV, border_mode='valid', input_shape=(1, IMGROWS, IMGCOLS)), Activation('relu'), MaxPooling2D(pool_size=(NB_POOL, NB_POOL)), Dropout(0.25), Flatten(), Dense(128), Activation('relu'), Dropout(0.5), Dense(NB_CLASSES), Activation('softmax')] if insert is not None: for l in insert['layers']: layers.insert(insert['insert_pos'], l) for layer in layers: model.add(layer) return model
def __init__(self): model = Sequential() model.add(Embedding(115227, 50, input_length=75, weights=pre_weights)) model.compile(loss=MCE, optimizer="adadelta") print "Build Network Completed..." self.model = model self.vocab = {"get_index":{}, "get_word":[]}
def build_siamese(input_model_1, input_model_2, input_dim, output_dim): """ :param input_model_1: :type input_model_1: :param input_model_2: :type input_model_2: :param input_dim: last layer input :type input_dim: :param output_dim: last layer output :type output_dim: :return: :rtype: """ inputs = [input_model_1, input_model_2] layer = Dense(input_dim=input_dim, output_dim=output_dim) model = Sequential() # mode: one of {sum, mul, concat, ave, join, cos, dot}. model.add(Siamese(layer, inputs, 'sum')) # model.compile(loss='mse', optimizer='sgd') return model
def make_fc_model(self): ''' creates a fully convolutional model from self.model ''' # get index of first dense layer in model behead_ix = self._get_behead_index(self.model_layer_names) model_layers = self.model.layers[:behead_ix] # shape of image entering FC layers inp_shape = self.model.layers[behead_ix - 1].get_output_shape_at(-1) # replace dense layers with convolutions model = Sequential() model_layers += [Convolution2D(2048, 1, 1)] model_layers += [Activation('relu')] model_layers += [Convolution2D(2048, 1, 1)] model_layers += [Activation('relu')] model_layers += [Convolution2D(self.nb_classes, inp_shape[-1], inp_shape[-1])] # must be same shape as target vector (None, num_classes, 1) model_layers += [Reshape((self.nb_classes-1,1))] model_layers += [Activation('softmax')] print 'Compiling Fully Convolutional Model...' for process in model_layers: model.add(process) sgd = SGD(lr=self.lr_1, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer='sgd') print 'Done.' return model
def create_mlp_network(input_dim): seq = Sequential() seq.add(SparseFullyConnectedLayer(300, input_dim = input_dim, activation = "relu")) # seq.add(Dense(300, input_dim = input_dim, activation = "relu")) seq.add(Dense(300, activation = "relu")) seq.add(Dense(128, activation = "relu")) return seq
def getVggModel(): """Pretrained VGG16 model with fine-tunable last two layers""" input_image = Input(shape = (160,320,3)) model = Sequential() model.add(Lambda(lambda x: x/255.0 -0.5,input_shape=(160,320,3))) model.add(Cropping2D(cropping=((70,25),(0,0)))) base_model = VGG16(input_tensor=input_image, include_top=False) for layer in base_model.layers[:-3]: layer.trainable = False W_regularizer = l2(0.01) x = base_model.get_layer("block5_conv3").output x = AveragePooling2D((2, 2))(x) x = Dropout(0.5)(x) x = BatchNormalization()(x) x = Dropout(0.5)(x) x = Flatten()(x) x = Dense(4096, activation="elu", W_regularizer=l2(0.01))(x) x = Dropout(0.5)(x) x = Dense(2048, activation="elu", W_regularizer=l2(0.01))(x) x = Dense(2048, activation="elu", W_regularizer=l2(0.01))(x) x = Dense(1, activation="linear")(x) return Model(input=input_image, output=x)
def test_replace_with_mask_layer__no_mask(): m = Sequential([ ReplaceWithMaskLayer(input_shape=(None, 10)), ]) actual = m.predict(np.random.uniform(size=(30, 20, 10))) expected = np.ones((30, 20, 1)) np.testing.assert_allclose(actual, expected)
def define_model(lr, momentum): # CONFIG model = Sequential() # Create Layers # CONVNET layers = [] #layers.append(GaussianNoise(0.02)) layers.append(Convolution2D(8, 9, 9, activation = "relu", input_shape=(1,100,100))) layers.append(MaxPooling2D(pool_size=(2,2))) layers.append(Convolution2D(16, 7, 7, activation = "relu")) layers.append(MaxPooling2D(pool_size=(2,2))) layers.append(Convolution2D(32, 5, 5, activation = "relu")) layers.append(MaxPooling2D(pool_size=(2,2))) layers.append(Convolution2D(64, 3, 3, activation = "relu")) layers.append(MaxPooling2D(pool_size=(2,2))) layers.append(Convolution2D(250, 3, 3, activation= "relu")) # MLP layers.append(Flatten()) layers.append(Dense(125, activation="relu")) layers.append(Dense(2, activation="softmax")) # Adding Layers for layer in layers: model.add(layer) # COMPILE (learning rate, momentum, objective...) sgd = SGD(lr=lr, momentum=momentum) model.compile(loss="categorical_crossentropy", optimizer=sgd) return model
def test_recurrent_wrapper__simple_rnn__no_sequences(): """Return only the latest step in the sequence """ def recurrent_layer(): hidden = Input((128,)) input = Input((10,)) x = Dense(128, activation='relu')(input) x = merge([hidden, x], mode='sum') new_hidden = Activation('sigmoid')(x) return RecurrentWrapper( input=[input], output=[new_hidden], bind={hidden: new_hidden}, return_sequences=False, ) m = Sequential([ InputLayer(input_shape=(None, 10)), recurrent_layer(), ]) result = m.predict(np.random.uniform(size=(30, 20, 10))) # map into hidden state assert result.shape == (30, 128)
def create(self): language_model = Sequential() self.textual_embedding(language_model, mask_zero=True) self.temporal_pooling(language_model) language_model.add(DropMask()) #language_model.add(BatchNormalization(mode=1)) self.language_model = language_model visual_model_factory = \ select_sequential_visual_model[self._config.trainable_perception_name]( self._config.visual_dim) visual_model = visual_model_factory.create() visual_dimensionality = visual_model_factory.get_dimensionality() self.visual_embedding(visual_model, visual_dimensionality) #visual_model.add(BatchNormalization(mode=1)) self.visual_model = visual_model if self._config.multimodal_merge_mode == 'dot': self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)])) else: self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode)) self.deep_mlp() self.add(Dense(self._config.output_dim)) self.add(Activation('softmax'))
def test_recurrent_wrapper__simple_rnn__output_model(): """The hidden state is not returned, but mapped by an output model. """ def recurrent_layer(): hidden = Input((128,)) input = Input((10,)) x = Dense(128, activation='relu')(input) x = merge([hidden, x], mode='sum') new_hidden = Activation('sigmoid')(x) output = Dense(64)(x) return RecurrentWrapper( input=[input], output=[output], bind={hidden: new_hidden}, return_sequences=True, ) m = Sequential([ InputLayer(input_shape=(None, 10)), recurrent_layer(), ]) assert m.predict(np.random.uniform(size=(30, 20, 10))).shape == (30, 20, 64)
def create(self): language_model = Sequential() self.textual_embedding(language_model, mask_zero=True) self.stacked_RNN(language_model) language_model.add(self._config.recurrent_encoder( self._config.hidden_state_dim, return_sequences=False, go_backwards=self._config.go_backwards)) self.language_model = language_model visual_model_factory = \ select_sequential_visual_model[self._config.trainable_perception_name]( self._config.visual_dim) visual_model = visual_model_factory.create() visual_dimensionality = visual_model_factory.get_dimensionality() self.visual_embedding(visual_model, visual_dimensionality) #visual_model = Sequential() #self.visual_embedding(visual_model) self.visual_model = visual_model if self._config.multimodal_merge_mode == 'dot': self.add(Merge([language_model, visual_model], mode='dot', dot_axes=[(1,),(1,)])) else: self.add(Merge([language_model, visual_model], mode=self._config.multimodal_merge_mode)) self.add(Dropout(0.5)) self.add(Dense(self._config.output_dim)) self.add(RepeatVector(self._config.max_output_time_steps)) self.add(self._config.recurrent_decoder( self._config.hidden_state_dim, return_sequences=True)) self.add(Dropout(0.5)) self.add(TimeDistributedDense(self._config.output_dim)) self.add(Activation('softmax'))
def question_encoder(self, dropout=0.3): question_encoder = Sequential() question_encoder.add(Embedding(input_dim=vocab_size, output_dim=64, input_length=query_maxlen)) question_encoder.add(Dropout(dropout)) self._question_encoder = question_encoder