def cifar10_cnn_model_yingnan(inputShape, nb_classes): #inputShape 3dim model = Sequential() model.add(Convolution2D(64, 3, 3, border_mode='same', input_shape=inputShape)) model.add(Activation('relu')) model.add(Convolution2D(64, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Convolution2D(64, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(Convolution2D(64, 3, 3)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) model.summary() return 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 main(): train_X = np.load('train_X.npy') train_y = np.load('train_y.npy') test_X = np.load('test_X.npy') test_y = np.load('test_y.npy') model = Sequential() model.add(Flatten(input_shape=(15,60,2))) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dense(900)) model.add(Activation('sigmoid')) print model.summary() adam = Adam(0.001) #adagrad = Adagrad(lr=0.01) model.compile(loss='mse', optimizer=adam) model.fit(train_X, train_y, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(test_X, test_y)) model.save_weights('model.h5', overwrite=True)
def mnist_cnn_model(inputShape, nb_classes): #inputShape 3dim model = Sequential() # each input is 1*28*28, output is 32*26*26 because stride is 1 and image size is 28 model.add(Convolution2D(32, 3, 3, border_mode='valid', input_shape=inputShape)) model.add(Activation('relu')) # output is 32*24*24 because stride is 1 and input is 32*26*26 model.add(Convolution2D(32, 3, 3)) model.add(Activation('relu')) # pooling will reduce the output size to 32*12*12 model.add(MaxPooling2D(pool_size=(2, 2))) # dropout not effect the output shape model.add(Dropout(0.25)) # conver the 32*12*12 output to 4608 model.add(Flatten()) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) model.summary() return model
def test_nested_sequential(in_tmpdir): (x_train, y_train), (x_test, y_test) = _get_test_data() inner = Sequential() inner.add(Dense(num_hidden, input_shape=(input_dim,))) inner.add(Activation('relu')) inner.add(Dense(num_class)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(x_test, y_test)) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=2, validation_split=0.1) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=0) model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, shuffle=False) model.train_on_batch(x_train[:32], y_train[:32]) loss = model.evaluate(x_test, y_test, verbose=0) model.predict(x_test, verbose=0) model.predict_classes(x_test, verbose=0) model.predict_proba(x_test, verbose=0) fname = 'test_nested_sequential_temp.h5' model.save_weights(fname, overwrite=True) inner = Sequential() inner.add(Dense(num_hidden, input_shape=(input_dim,))) inner.add(Activation('relu')) inner.add(Dense(num_class)) middle = Sequential() middle.add(inner) model = Sequential() model.add(middle) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.load_weights(fname) os.remove(fname) nloss = model.evaluate(x_test, y_test, verbose=0) assert(loss == nloss) # test serialization config = model.get_config() Sequential.from_config(config) model.summary() json_str = model.to_json() model_from_json(json_str) yaml_str = model.to_yaml() model_from_yaml(yaml_str)
def build_discriminator(self): model = Sequential() model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=self.img_shape, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(64, kernel_size=3, strides=2, padding="same")) model.add(ZeroPadding2D(padding=((0,1),(0,1)))) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(BatchNormalization(momentum=0.8)) model.add(Conv2D(128, kernel_size=3, strides=2, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(BatchNormalization(momentum=0.8)) model.add(Conv2D(256, kernel_size=3, strides=1, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Flatten()) model.summary() img = Input(shape=self.img_shape) features = model(img) valid = Dense(1, activation="sigmoid")(features) label = Dense(self.num_classes+1, activation="softmax")(features) return Model(img, [valid, label])
def build_model(self): model = Sequential() model.add(Dense(24, input_dim=self.state_size, activation='relu')) model.add(Dense(24, activation='relu')) model.add(Dense(self.action_size, activation='softmax')) model.summary() return model
def trainModel(): inputs, correctOutputs = getNNData() print("Collected data") trainingInputs = inputs[:len(inputs)//2] trainingOutputs = correctOutputs[:len(correctOutputs)//2] testInputs = inputs[len(inputs)//2:] testOutputs = correctOutputs[len(correctOutputs)//2:] model = Sequential() model.add(Dense(24, input_shape=(24, ))) model.add(Activation('tanh')) model.add(Dense(24)) model.add(Activation('tanh')) model.add(Dense(5)) model.add(Activation('softmax')) model.summary() model.compile(loss='mean_squared_error', optimizer=SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)) model.fit(trainingInputs, trainingOutputs, validation_data=(testInputs, testOutputs)) score = model.evaluate(testInputs, testOutputs, verbose=0) print(score) json_string = model.to_json() open('my_model_architecture.json', 'w').write(json_string) model.save_weights('my_model_weights.h5', overwrite=True)
def build_critic(self): model = Sequential() model.add(Conv2D(16, kernel_size=3, strides=2, input_shape=self.img_shape, padding="same")) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(32, kernel_size=3, strides=2, padding="same")) model.add(ZeroPadding2D(padding=((0, 1), (0, 1)))) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(64, kernel_size=3, strides=2, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Conv2D(128, kernel_size=3, strides=1, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(1)) model.summary() img = Input(shape=self.img_shape) validity = model(img) return Model(img, validity)
def buildIrrigationDetectorModel(inputShape): nb_filter = 64 filter_length = 4 model = Sequential() model.add(AveragePooling1D(pool_size=4,input_shape=inputShape)) model.add(Conv1D(nb_filter=nb_filter, kernel_size=filter_length, border_mode="valid", activation="relu", )) model.add(MaxPooling1D(pool_size=2)) model.add(BatchNormalization()) model.add(Conv1D(nb_filter=int(nb_filter), kernel_size=int(filter_length), border_mode="valid", activation="relu", )) model.add(Flatten()) model.add((Dense(100, activation='relu'))) model.add((Dense(1, activation='sigmoid'))) optimizer = Adam(lr=0.0001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0) model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'] ) model.summary() return model
def build_generator(self): model = Sequential() model.add(Dense(128 * 7 * 7, activation="relu", input_dim=100)) model.add(Reshape((7, 7, 128))) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling2D()) model.add(Conv2D(128, kernel_size=3, padding="same")) model.add(Activation("relu")) model.add(BatchNormalization(momentum=0.8)) model.add(UpSampling2D()) model.add(Conv2D(64, kernel_size=3, padding="same")) model.add(Activation("relu")) model.add(BatchNormalization(momentum=0.8)) model.add(Conv2D(self.channels, kernel_size=3, padding='same')) model.add(Activation("tanh")) model.summary() noise = Input(shape=(100,)) label = Input(shape=(1,), dtype='int32') label_embedding = Flatten()(Embedding(self.num_classes, 100)(label)) input = multiply([noise, label_embedding]) img = model(input) return Model([noise, label], img)
def test_recursive(): # test layer-like API graph = Graph() graph.add_input(name='input1', input_shape=(32,)) graph.add_node(Dense(16), name='dense1', input='input1') graph.add_node(Dense(4), name='dense2', input='input1') graph.add_node(Dense(4), name='dense3', input='dense1') graph.add_output(name='output1', inputs=['dense2', 'dense3'], merge_mode='sum') seq = Sequential() seq.add(Dense(32, input_shape=(32,))) seq.add(graph) seq.add(Dense(4)) seq.compile('rmsprop', 'mse') seq.fit(X_train_graph, y_train_graph, batch_size=10, nb_epoch=10) loss = seq.evaluate(X_test_graph, y_test_graph) # test serialization config = seq.get_config() new_graph = Sequential.from_config(config) seq.summary() json_str = seq.to_json() new_graph = model_from_json(json_str) yaml_str = seq.to_yaml() new_graph = model_from_yaml(yaml_str)
def run(dataset): batch_size = 16 nb_epoch = 20 train_X, train_y = dataset['train'] dev_X, dev_y = dataset['dev'] test_X, test_y = dataset['test'] print('train_X shape:', train_X.shape) print('Building model...') model = Sequential() model.add(Dense(1024, input_dim=train_X.shape[1], activation='sigmoid')) model.add(Dropout(0.2)) model.add(Dense(1024, activation='sigmoid')) model.add(Dropout(0.2)) model.add(Dense(2, activation='softmax')) model.summary() model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.fit(train_X, train_y, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, validation_data=(dev_X, dev_y)) score = model.evaluate(test_X, test_y, verbose=0) print('Test score:', score[0]) print('Test accuracy:', score[1])
def test_temporal_classification(): ''' Classify temporal sequences of float numbers of length 3 into 2 classes using single layer of GRU units and softmax applied to the last activations of the units ''' np.random.seed(1337) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=200, num_test=20, input_shape=(3, 4), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential() model.add(layers.GRU(8, input_shape=(x_train.shape[1], x_train.shape[2]))) model.add(layers.Dense(y_train.shape[-1], activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=4, batch_size=10, validation_data=(x_test, y_test), verbose=0) assert(history.history['acc'][-1] >= 0.8) config = model.get_config() model = Sequential.from_config(config)
def get_convBNeluMPdrop(num_conv_layers, nums_feat_maps, feat_scale_factor, conv_sizes, pool_sizes, dropout_conv, input_shape): #[Convolutional Layers] model = Sequential() input_shape_specified = False for conv_idx in xrange(num_conv_layers): # add conv layer n_feat_here = int(nums_feat_maps[conv_idx]*feat_scale_factor) if not input_shape_specified: print ' ---->>First conv layer is being added! with %d' % n_feat_here model.add(Convolution2D(n_feat_here, conv_sizes[conv_idx][0], conv_sizes[conv_idx][1], input_shape=input_shape, border_mode='same', init='he_normal')) input_shape_specified = True else: print ' ---->>%d-th conv layer is being added with %d units' % (conv_idx, n_feat_here) model.add(Convolution2D(n_feat_here, conv_sizes[conv_idx][0], conv_sizes[conv_idx][1], border_mode='same', init='he_normal')) # add BN, Activation, pooling, and dropout model.add(BatchNormalization(axis=1, mode=2)) model.add(keras.layers.advanced_activations.ELU(alpha=1.0)) # TODO: select activation model.add(MaxPooling2D(pool_size=pool_sizes[conv_idx])) if not dropout_conv == 0.0: model.add(Dropout(dropout_conv)) print ' ---->>Add dropout of %f for %d-th conv layer' % (dropout_conv, conv_idx) model.summary() return model
def main(): ext = extension_from_parameters() out_dim = 1 loss = 'mse' metrics = None #metrics = ['accuracy'] if CATEGORICAL else None datagen = RegressionDataGenerator() train_gen = datagen.flow(batch_size=BATCH_SIZE) val_gen = datagen.flow(val=True, batch_size=BATCH_SIZE) val_gen2 = datagen.flow(val=True, batch_size=BATCH_SIZE) model = Sequential() for layer in LAYERS: if layer: model.add(Dense(layer, input_dim=datagen.input_dim, activation=ACTIVATION)) if DROP: model.add(Dropout(DROP)) model.add(Dense(out_dim)) model.summary() model.compile(loss=loss, optimizer='rmsprop', metrics=metrics) train_samples = int(datagen.n_train/BATCH_SIZE) * BATCH_SIZE val_samples = int(datagen.n_val/BATCH_SIZE) * BATCH_SIZE history = BestLossHistory(val_gen2, val_samples, ext) checkpointer = ModelCheckpoint(filepath='model'+ext+'.h5', save_best_only=True) model.fit_generator(train_gen, train_samples, nb_epoch = NB_EPOCH, validation_data = val_gen, nb_val_samples = val_samples, callbacks=[history, checkpointer])
def create_model(train_X, test_X, train_y, test_y): model = Sequential() model.add(Dense(500, input_shape=(238,),kernel_initializer= {{choice(['glorot_uniform','random_uniform'])}})) model.add(BatchNormalization(epsilon=1e-06, mode=0, momentum=0.9, weights=None)) model.add(Activation({{choice(['relu','sigmoid','tanh'])}})) model.add(Dropout({{uniform(0, 0.3)}})) model.add(Dense({{choice([128,256])}})) model.add(Activation('relu')) model.add(Dropout({{uniform(0, 0.4)}})) model.add(Dense({{choice([128,256])}})) model.add(Activation({{choice(['relu','tanh'])}})) model.add(Dropout(0.3)) model.add(Dense(41)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer={{choice(['rmsprop', 'adam'])}}) model.summary() early_stops = EarlyStopping(patience=3, monitor='val_acc') ckpt_callback = ModelCheckpoint('keras_model', monitor='val_loss', verbose=1, save_best_only=True, mode='auto') model.fit(train_X, train_y, batch_size={{choice([128,264])}}, nb_epoch={{choice([10,20])}}, validation_data=(test_X, test_y), callbacks=[early_stops,ckpt_callback]) score, acc = model.evaluate(test_X, test_y, verbose=0) print('Test accuracy:', acc) return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def build_generator(self): model = Sequential() model.add(Dense(8 * 128 * 128, activation="relu", input_dim=self.latent_dim)) model.add(Reshape((128, 128, 8))) # model.add(UpSampling2D()) # model.add(Conv2D(128, kernel_size=3, padding="same")) model.add(Conv2DTranspose(128, kernel_size=3, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) # # model.add(UpSampling2D()) # # model.add(Conv2D(128, kernel_size=3, padding="same")) # model.add(Conv2DTranspose(128, kernel_size=3, padding="same")) # model.add(BatchNormalization(momentum=0.8)) # model.add(LeakyReLU(alpha=0.2)) # model.add(UpSampling2D()) # model.add(Conv2D(64, kernel_size=3, padding="same")) model.add(Conv2DTranspose(64, kernel_size=3, padding="same")) model.add(BatchNormalization(momentum=0.8)) model.add(LeakyReLU(alpha=0.2)) # model.add(Conv2D(self.channels, kernel_size=3, padding="same")) model.add(Conv2DTranspose(self.channels, kernel_size=3, padding="same")) model.add(Activation("tanh")) model.summary() noise = Input(shape=(self.latent_dim,)) img = model(noise) return Model(noise, img)
def baseline_model(): #CNN参数 embedding_dims = 50 filters = 250 kernel_size = 3 hidden_dims = 250 model = Sequential() model.add(Embedding(max_features, embedding_dims)) model.add(Conv1D(filters, kernel_size, padding='valid', activation='relu', strides=1)) #池化 model.add(GlobalMaxPooling1D()) model.add(Dense(2, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) #可视化 plot_model(model, to_file='yelp-cnn-model.png',show_shapes=True) model.summary() return model
def create_LeNet(weights_path=None): """ Use keras to create LeNet structure Return: the model object of keras """ model = Sequential() # 1st Convolution layer model.add(Convolution2D(8, 28, 28, border_mode='same', input_shape=(3, 200, 200))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2,2))) # 2nd Convolution layer model.add(Convolution2D(20, 10, 10, border_mode='same')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2,2))) # Dense model.add(Flatten()) model.add(Dense(120, activation='relu')) model.add(Dense(2, activation='softmax')) print model.summary() return model
def create_fullCIFAR10(): """ Use keras to create CIFAR-10 archetecture Return: the model object of keras """ # 1st Convolution layer model = Sequential() model.add(Convolution2D(32, 5, 5, border_mode='valid', input_shape=(3, 200, 200))) model.add(MaxPooling2D(pool_size=(3, 3))) model.add(Activation('relu')) model.add(BatchNormalization()) # 2nd Convolution layer model.add(Convolution2D(32, 5, 5, border_mode='valid')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(3, 3))) model.add(BatchNormalization()) # 3rd Convolution layer model.add(Convolution2D(64, 5, 5, border_mode='valid')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(3, 3))) # Dense model.add(Flatten()) model.add(Dense(250, init='normal')) model.add(Activation('tanh')) # Softmax model.add(Dense(2, init='normal')) model.add(Activation('softmax')) print model.summary() return model
def build_discriminator(self): model = Sequential() model.add(Dense(512, input_dim=np.prod(self.img_shape))) model.add(LeakyReLU(alpha=0.2)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.4)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.2)) model.add(Dropout(0.4)) model.add(Dense(1, activation='sigmoid')) model.summary() img = Input(shape=self.img_shape) label = Input(shape=(1,), dtype='int32') label_embedding = Flatten()(Embedding(self.num_classes, np.prod(self.img_shape))(label)) flat_img = Flatten()(img) model_input = multiply([flat_img, label_embedding]) validity = model(model_input) return Model([img, label], validity)
def test_image_classification(): np.random.seed(1337) input_shape = (16, 16, 3) (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=input_shape, classification=True, num_classes=4) y_train = to_categorical(y_train) y_test = to_categorical(y_test) model = Sequential([ layers.Conv2D(filters=8, kernel_size=3, activation='relu', input_shape=input_shape), layers.MaxPooling2D(pool_size=2), layers.Conv2D(filters=4, kernel_size=(3, 3), activation='relu', padding='same'), layers.GlobalAveragePooling2D(), layers.Dense(y_test.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=10, batch_size=16, validation_data=(x_test, y_test), verbose=0) assert history.history['val_acc'][-1] > 0.75 config = model.get_config() model = Sequential.from_config(config)
def test_vector_classification(): ''' Classify random float vectors into 2 classes with logistic regression using 2 layer neural network with ReLU hidden units. ''' (x_train, y_train), (x_test, y_test) = get_test_data(num_train=500, num_test=200, input_shape=(20,), classification=True, num_classes=2) y_train = to_categorical(y_train) y_test = to_categorical(y_test) # Test with Sequential API model = Sequential([ layers.Dense(16, input_shape=(x_train.shape[-1],), activation='relu'), layers.Dense(8), layers.Activation('relu'), layers.Dense(y_train.shape[-1], activation='softmax') ]) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) model.summary() history = model.fit(x_train, y_train, epochs=15, batch_size=16, validation_data=(x_test, y_test), verbose=0) assert(history.history['val_acc'][-1] > 0.8) config = model.get_config() model = Sequential.from_config(config)
def build_generator(self): noise_shape = (self.noise_dims,) model = Sequential() model.add(Dense(self.noise_dims, input_shape=noise_shape)) #256 model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(int(self.noise_dims*1.5))) # 512 model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(int(self.noise_dims*2))) # 512 model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(150)) # 1000 model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(np.prod(self.img_shape), activation='tanh')) model.add(Reshape(self.img_shape)) model.summary() noise = Input(shape=noise_shape) img = model(noise) return Model(noise, img)
def moustafa_model1(inputShape, nb_classes): model = Sequential() model.add(Convolution2D(62, 3, 3, border_mode='same', input_shape=inputShape)) model.add(Activation('relu')) model.add(Convolution2D(62, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(128, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(Convolution2D(128, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(64, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(Convolution2D(64, 3, 3, border_mode='same')) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(128)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(512)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) model.summary() return model
def build_generators(self): noise_shape = (100,) noise = Input(shape=noise_shape) # Shared weights between generators model = Sequential() model.add(Dense(256, input_shape=noise_shape)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) latent = model(noise) # Generator 1 g1 = Dense(1024)(latent) g1 = LeakyReLU(alpha=0.2)(g1) g1 = BatchNormalization(momentum=0.8)(g1) g1 = Dense(np.prod(self.img_shape), activation='tanh')(g1) img1 = Reshape(self.img_shape)(g1) # Generator 2 g2 = Dense(1024)(latent) g2 = LeakyReLU(alpha=0.2)(g2) g2 = BatchNormalization(momentum=0.8)(g2) g2 = Dense(np.prod(self.img_shape), activation='tanh')(g2) img2 = Reshape(self.img_shape)(g2) model.summary() return Model(noise, img1), Model(noise, img2)
def build_generator(self): model = Sequential() model.add(Dense(256, input_dim=self.latent_dim)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(1024)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(np.prod(self.img_shape), activation='tanh')) model.add(Reshape(self.img_shape)) model.summary() noise = Input(shape=(self.latent_dim,)) label = Input(shape=(1,), dtype='int32') label_embedding = Flatten()(Embedding(self.num_classes, self.latent_dim)(label)) model_input = multiply([noise, label_embedding]) img = model(model_input) return Model([noise, label], img)
def mnist_transferCNN_model(inputShape, nb_classes): # inputShape 3dim # define two groups of layers: feature (convolutions) and classification (dense) feature_layers = [ Convolution2D(32, 3, 3, border_mode='valid', input_shape=inputShape), Activation('relu'), Convolution2D(32, 3, 3), Activation('relu'), MaxPooling2D(pool_size=(2, 2)), Dropout(0.25), Flatten(), ] classification_layers = [ Dense(128), Activation('relu'), Dropout(0.5), Dense(nb_classes), Activation('softmax') ] # create complete model model = Sequential() for l in feature_layers + classification_layers: model.add(l) model.summary() return model
def create_Tensorflow_smallCIFAR10(): """ Use keras to create CIFAR-10 built in tensorflow github example Return: the model object of keras """ # 1st Convolution layer model = Sequential() model.add(Convolution2D(64, 3, 3, border_mode='valid', input_shape=(3, 200, 200), bias=True)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2,2))) model.add(BatchNormalization()) # 2nd Convolution layer model.add(Convolution2D(32, 3, 3, border_mode='valid')) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(3, 3), strides=(2,2))) # 1st Dense model.add(Flatten()) model.add(Dense(384, init=init_tensorflowCIFAR)) model.add(Activation('relu')) # 2nd Dense model.add(Dense(192, init='normal')) model.add(Activation('relu')) # Softmax model.add(Dense(2, init='normal')) model.add(Activation('softmax')) print model.summary() return model
def main(): (txt_train, label) = read_data(train_path, train=True) (txt_test, _) = read_data(test_path, train=False) label = label.reshape(-1, 1) ######### prepocess print('Convert to index sequences.') corpus = txt_train + txt_test tokenizer = Tokenizer() tokenizer.fit_on_texts(corpus) word_index = tokenizer.word_index train_sequences = tokenizer.texts_to_sequences(txt_train) pickle.dump(tokenizer, open('tokenizer.pkl', 'wb')) print('Pad sequences:') X = sequence.pad_sequences(train_sequences) Y = label output_dim = 1 #Y = np.concatenate((1-label,label), axis=1); output_dim=2 print('Split data into training data and validation data') (x_train, y_train), (x_val, y_val) = split_data(X, Y, split_ratio) max_article_length = x_train.shape[1] ######### print('maxlen', max_article_length) print('Get embedding dict from glove.') embedding_dict = get_embedding_dict('./glove.twitter.27B.%dd.txt' % embedding_dim) print('Found %s word vectors.' % len(embedding_dict)) max_features = len(word_index) + 1 # i.e. the number of words print('Create embedding matrix.') embedding_matrix = get_embedding_matrix(word_index, embedding_dict, max_features, embedding_dim) print('Build model...') csv_logger = CSVLogger('training_report.csv', append=True) earlystopping = EarlyStopping(monitor='val_acc', patience=5, verbose=1, mode='max') checkpoint = ModelCheckpoint(filepath='best.h5', verbose=1, save_best_only=True, monitor='val_acc', mode='max') model = Sequential() model.add( Embedding(max_features, embedding_dim, weights=[embedding_matrix], input_length=max_article_length, trainable=False)) model.add( Bidirectional( LSTM(128, dropout=0.4, recurrent_dropout=0.3, activation='tanh'))) model.add(Dense(64, activation='relu')) model.add(Dropout(0.4)) model.add(BatchNormalization()) model.add(Dense(32, activation='relu')) model.add(Dropout(0.4)) model.add(BatchNormalization()) model.add(Dense(output_dim, activation='sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['acc']) model.summary() model.fit(x_train, y_train, epochs=epoch_num, batch_size=batch, validation_data=(x_val, y_val), callbacks=[earlystopping, checkpoint, csv_logger])
def train_lstm_for_visualization(): checkpoints = glob(MODEL_PATH + "*.h5") if len(checkpoints) > 0: checkpoints = natsorted(checkpoints) assert len(checkpoints) != 0, "No checkpoints for visualization found." checkpoint_file = checkpoints[-1] print("Loading [{}]".format(checkpoint_file)) model = load_model(checkpoint_file) model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy", utils.f1_score]) print(model.summary()) # Load the data x_train, y_train, x_test, y_test, vocab_size, tokenizer, max_tweet_length = prepare_data( SHUFFLE) # Get the word to index and the index to word mappings word_index = tokenizer.word_index index_to_word = {index: word for word, index in word_index.items()} # Evaluate the previously trained model on test data test_loss, test_acc, test_fscore = model.evaluate(x_test, y_test, verbose=1, batch_size=256) print("Loss: %.3f\nF-score: %.3f\n" % (test_loss, test_fscore)) return model, index_to_word, x_test else: # Load the data x_train, y_train, x_test, y_test, vocab_size, tokenizer, max_tweet_length = prepare_data( SHUFFLE) # Get the word to index and the index to word mappings word_index = tokenizer.word_index index_to_word = {index: word for word, index in word_index.items()} # Build, evaluate and save the model model = Sequential() model.add( Embedding(input_dim=vocab_size, output_dim=EMBEDDING_DIM, input_length=max_tweet_length, embeddings_initializer="glorot_normal", name="embedding_layer")) model.add( LSTM(output_dim=HIDDEN_UNITS, name="recurrent_layer", activation="tanh", return_sequences=True)) model.add(Flatten()) model.add(Dense(DENSE_UNITS, activation="relu", name="dense_layer")) model.add(Dense(NO_OF_CLASSES, activation="softmax")) model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=["accuracy", utils.f1_score]) model.summary() checkpoint = ModelCheckpoint(monitor="val_acc", filepath=MODEL_PATH + "model_{epoch:02d}_{val_acc:.3f}.h5", save_best_only=True, mode="max") model.fit(x_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHS, validation_data=(x_test, y_test), callbacks=[checkpoint]) score = model.evaluate(x_test, y_test) print("Loss: %.3f\nF-score: %.3f\n" % (score[0], score[1])) return model, index_to_word, x_test
max_words = 200 input_length = 10 model = Sequential() model.add(Embedding(max_words, embedding_dim, input_length=input_length)) model.add(Convolution1D(128, kernel_size=3, activation='relu')) # 10 - 3 + 1 = 8 model.add(Convolution1D(64, kernel_size=3, activation='relu')) # 10 - 3 + 1 = 6 model.add(Convolution1D(32, kernel_size=3, activation='relu')) # 10 - 3 + 1 = 4 model.add(Flatten()) # 128 = 32 * 4 model.add(Dropout(0.2)) model.add(Dense(128, activation='sigmoid')) # W = 128 x 128 model.add(Dropout(0.2)) model.add(Dense(1, activation='sigmoid')) model.summary() model.compile(loss='mse', optimizer='adam') input_array = np.random.randint(n_in, size=(mb, input_length)) output_array = model.predict(input_array) assert output_array.shape == (mb, 1) print( "Saving model with embedding into several Conv1D layers into Flatten and Dense for backend {} and keras major version {}" .format(backend, major_version)) model.save("{}embedding_conv1d_extended_{}_{}.h5".format( base_path, backend, major_version))
def build_model(self): # Build the network of vgg for 10 classes with massive dropout and weight decay as described in the paper. model = Sequential() weight_decay = 0.0005 model.add( Conv2D(64, (3, 3), padding='same', input_shape=(32, 32, 3), kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.3)) model.add( Conv2D(64, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add( Conv2D(128, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.4)) model.add( Conv2D(128, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add( Conv2D(256, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.4)) model.add( Conv2D(256, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.4)) model.add( Conv2D(256, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add( Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.4)) model.add( Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.4)) model.add( Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add( Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.4)) model.add( Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(Dropout(0.4)) model.add( Conv2D(512, (3, 3), padding='same', kernel_regularizer=regularizers.l2(weight_decay))) model.add(Activation('relu')) model.add(BatchNormalization()) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.5)) model.add(Flatten()) model.add(Dense(200)) model.add(Activation('softmax')) model.summary() return model
env.seed(123) nb_actions = env.action_space.n # Next, we build a very simple model regardless of the dueling architecture # if you enable dueling network in DQN , DQN will build a dueling network base on your model automatically # Also, you can build a dueling network by yourself and turn off the dueling network in DQN. model = Sequential() model.add(Flatten(input_shape=(1, ) + env.observation_space.shape)) model.add(Dense(16)) model.add(Activation('relu')) model.add(Dense(16)) model.add(Activation('relu')) model.add(Dense(16)) model.add(Activation('relu')) model.add(Dense(nb_actions, activation='linear')) print(model.summary()) # Finally, we configure and compile our agent. You can use every built-in Keras optimizer and # even the metrics! memory = SequentialMemory(limit=50000, window_length=1) policy = BoltzmannQPolicy() # enable the dueling network # you can specify the dueling_type to one of {'avg','max','naive'} dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=10, enable_dueling_network=True, dueling_type='avg', target_model_update=1e-2, policy=policy)
log_file = open(log_name, 'w') log_file.write('VGG/Tabular Late Fusion \n') base_model1.summary(print_fn=lambda x: log_file.write(x + '\n\n')) # Build tabular model base_model2 = Sequential() base_model2.add(Dense(12, input_dim=len(dummy_tabular_cols), activation='relu')) base_model2.add(Dropout(DROPOUT_PROB)) base_model2.add(Dense(8, activation='relu')) base_model2.add(Dropout(DROPOUT_PROB)) base_model2.add(Dense(NUM_CLASSES, activation='softmax')) base_model2.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) base_model2.summary(print_fn=lambda x: log_file.write(x + '\n\n')) x2 = base_model2.output # Build text model n_words = text.shape[1] base_model3 = Sequential() base_model3.add(Dense(50, input_shape=(n_words,), activation='relu')) base_model3.add(Dense(4, activation='sigmoid')) base_model3.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) base_model3.summary(print_fn=lambda x: log_file.write(x + '\n\n')) x3 = base_model3.output # LATE FUSION x = concatenate([x1, x2, x3]) x = Sequential()(x)
def warp(data_x, y_train): batch_size = 10 nb_epoch = 10 x_train = data_x ###construct the model model = Sequential() model.add(Dense(2, input_shape=(2, ), activation='tanh')) model.add(Dense(2, activation='softmax')) ###compile and summarize model model.summary() model.compile(loss='binary_crossentropy', optimizer=RMSprop(lr=1e-2), metrics=['accuracy']) ###training model.fit(x_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=1, shuffle=True) ##loading warping datasets y_train2 = numpy.copy(y_train) for i in xrange(len(y_train2)): if y_train2[i][1] == 0: y_train2[i] = [0., 1.] ###construction of the warp setup with added bias layer in the beggining warp = Sequential() warp.add(Dense(2, input_shape=(2, ), init='identity')) warp.add( Dense(2, input_shape=(2, ), activation='tanh', weights=[ model.layers[0].W.get_value(), model.layers[0].b.get_value() ])) warp.add( Dense(2, activation='softmax', weights=[ model.layers[1].W.get_value(), model.layers[1].b.get_value() ])) for i in xrange(len(model.layers)): warp.layers[i + 1].trainable = False ### making sure only bias is allowed to change warp.layers[0].non_trainable_weights.append( warp.layers[0].trainable_weights[0]) warp.layers[0].trainable_weights = warp.layers[0].trainable_weights[1:] warp.summary() warp.compile(loss='binary_crossentropy', optimizer=RMSprop(lr=1e-3), metrics=['accuracy']) def stop_training(model, x_train, y_train2, bias): return numpy.argmax(y_train2) == numpy.argmax( model.predict(x_train + bias)) nb_epoch = 300 sgd = RMSprop(lr=1e-3) biases = [] """ make a Callback for monitoring for each point""" for point in xrange(x_train.shape[0]): print "data point #" + str(point) print " " ### setting the biases to zero between each data point warp.layers[0].b.set_value( numpy.zeros(warp.layers[0].b.get_value().shape[0], dtype="float32")) ### warping.... epochs = 0 while epochs < nb_epoch: if numpy.argmax(y_train2[point:point + 1][0]) == numpy.argmax( model.predict(x_train[point:point + 1] + warp.layers[0].b.get_value())): break print "Epoch " + str(epochs) + " - patient " + str(point) print " " print(model.predict(x_train[point:point + 1])) print((warp.predict(x_train[point:point + 1]))) warp.fit(x_train, [y_train2], batch_size=batch_size, nb_epoch=1, verbose=0, shuffle=True) epochs += 1 biases.append(warp.layers[0].b.get_value()) return biases
input_shape=env.observation_space.shape, activation="relu")) q_network.add(Dropout(rate=0.01)) # not bad # q_network.add(BatchNormalization()) # noisy_layer_2 = NoisyDense(units=32, activation="relu") q_network.add(Dense(units=64, activation="relu")) q_network.add(Dropout(rate=0.01)) # not bad # q_network.add(BatchNormalization()) q_network.add(Dense(units=32, activation="relu")) q_network.add(Dropout(rate=0.01)) # not bad # q_network.add(BatchNormalization()) q_network.add(Dense(units=env.action_space.n, activation="linear")) q_network.compile(optimizer="adam", loss="mean_squared_error") print(q_network.summary()) class EpisodeEndCallback(TensorboardAgentCallback): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.episode_begin_times = [] self.episode_end_times = [] def on_episode_begin(self, episode_n): self.episode_begin_times.append(time.time()) def on_episode_end(self, episode_n, **kwargs): self.episode_end_times.append(time.time()) if episode_n > 0 and episode_n % 100 == 0: t = self.episode_end_times[-1] - self.episode_begin_times[-100]
y.append(0) dir = "../Data/Processed1" for filename in os.listdir(dir): img = np.load(os.path.join(dir, filename))[:, :, 0] smooth_img = skimage.filters.gaussian(img, 8) sobel_img = skimage.filters.sobel(img) im_rez = skimage.transform.resize(sobel_img, (256, 256, 1)) X.append(im_rez) y.append(1) X = np.array(X) y = np.array(y) Xtr, Xts, ytr, yts = train_test_split(X, y, test_size=0.25, random_state=42) print(type(Xtr)) classifier.summary() es = EarlyStopping(patience=20, restore_best_weights=True) history = classifier.fit(Xtr, ytr, callbacks=[es], epochs=40, batch_size=8, validation_data=(Xts, yts)) classifier.evaluate(Xts, yts) classifier.save("../Models/Keras/Test2/model.h5") import pickle as pickle pickle.dump(history, open("../Models/Keras/Test2/history.pkl", "wb"))
X_test = sc.transform(X_test) my_first_nn = Sequential() # create model my_first_nn.add(Dense(8, input_dim=30, activation='relu')) # hidden layer my_first_nn.add(Dense(20, input_dim=30, activation='relu')) # hidden layer my_first_nn.add(Dense(50, input_dim=30, activation='relu')) # hidden layer my_first_nn.add(Dense(1, activation='sigmoid')) # output layer my_first_nn.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) my_first_nn_fitted = my_first_nn.fit(X_train, y_train, epochs=100, verbose=0, initial_epoch=0) print(my_first_nn.summary()) print(my_first_nn.evaluate(X_test, y_test, verbose=0)) # print(my_first_nn.summary()) # y_pred = my_first_nn.predict(X_test) # y_pred = (y_pred > 0.5) # # from sklearn.metrics import confusion_matrix # cm = confusion_matrix(y_test, y_pred) # # ax= plt.subplot() # sns.heatmap(cm, annot=True, ax = ax) # # # labels, title and ticks # ax.set_xlabel('Predicted labels') # ax.set_ylabel('True labels')
def model_generator(model_dict): start_time = time.time() # initialize the model print("Initialize model...") model = Sequential() # create convolutional layers print("Add Convolutional Layers...") convLayers = model_dict["conv_layers"] for convLayerNum in convLayers: if convLayerNum == 1: model.add( Conv2D( filters=convLayers[convLayerNum]["filters_number"], kernel_size=convLayers[convLayerNum]["kernel_size"], activation=convLayers[convLayerNum]["activation_function"], input_shape=model_dict["input_shape"])) else: model.add( Conv2D( filters=convLayers[convLayerNum]["filters_number"], kernel_size=convLayers[convLayerNum]["kernel_size"], activation=convLayers[convLayerNum]["activation_function"], )) # add pooling layer just after each conv layer model.add(AveragePooling2D()) # flatten last convolutional layer output to use in connected layers print("Add Flatten Layer...") model.add(Flatten()) # create connected layers print("Add Connected Layers...") connectedLayers = model_dict["connected_layers"] for concLayerNum in connectedLayers: model.add( Dense(units=connectedLayers[concLayerNum]["units"], activation=connectedLayers[concLayerNum] ["activation_function"])) # show model's summary model.summary() model.summary(print_fn=lambda x: log.write(x + '\n')) # set model's hyper methods print("Compiling...") model.compile(loss=model_dict["loss_method"], optimizer=model_dict["optimizer"], metrics=['accuracy']) # train the model print("Training...") H = model.fit_generator(model_dict["data_augmentation_method"].flow( model_dict["train_data"][0], model_dict["train_data"][1], batch_size=model_dict["batch_size"]), validation_data=model_dict["validation_data"], steps_per_epoch=len(model_dict["train_data"][0]) // model_dict["batch_size"], epochs=model_dict["epochs"]) # model evaluating print("Evaluating...") (loss, accuracy) = model.evaluate(model_dict["validation_data"][0], model_dict["validation_data"][1]) print("Accuracy: {:.2f}%".format(accuracy * 100)) log.write("model accuracy: {:.2f}%\n".format(accuracy * 100)) print("total time: {} seconds\n".format(time.time() - start_time)) log.write("total time: {} seconds\n\n\n".format(time.time() - start_time))
print(y_train[0]) print('x_train shape:', x_train.shape) print('x_test shape:', x_test.shape) print('y_train shape:', y_train.shape) print('y_test shape:', y_test.shape) print(x_train.shape[0], 'train samples') print(x_test.shape[0], 'test samples') #Simple fully connected neural network with 2 hidden layers model = Sequential() model.add(Dense(units=200, activation='relu', input_shape=input_shape)) model.add(Flatten()) model.add(Dense(units=200, activation='relu')) model.add(Dense(units=10, activation='softmax')) model.summary() #Learning process and compile sgd = SGD(lr=0.05, decay=1e-6, momentum=0.9, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) #Learning model.fit(x_train, y_train, epochs=epochs, batch_size=batch_size) #Evaluation score = model.evaluate(x_test, y_test, verbose=1) print('Test loss:', score[0]) print('Test accuracy:', score[1])
def train_model(num_of_games): model_name = './models/ncaa_model.h5' model_file = Path(model_name) if model_file.exists(): model = load_model(model_name) else: model = Sequential() # model.add(LSTM(32, input_shape=(3, 1860), activation='sigmoid', return_sequences=True)) # model.add(LSTM(128, activation='sigmoid', return_sequences=True)) # model.add(LSTM(8, activation='softmax', return_sequences=False)) # model.add(Dense(2, activation='softmax')) # model.compile(loss='categorical_crossentropy', optimizer='adagrad', metrics=['accuracy']) # model.add( LSTM(64, input_shape=(num_of_games, 1860), activation='softmax', return_sequences=True)) model.add(LSTM(32, activation='tanh', return_sequences=True)) model.add(LSTM(128, activation='elu', return_sequences=False)) model.add(Dense(2, activation='softmax')) model.compile(loss='categorical_crossentropy', optimizer='adamax', metrics=['accuracy']) print(model.summary()) model.save(model_name) x = [] y = [] index = 0 for season in range(2003, 2020): a = pd.read_csv('./training_data/%i/x_train-%i.csv' % (num_of_games, season)) b = pd.read_csv('./training_data/%i/y_train-%i.csv' % (num_of_games, season)) if len(a) == 0 or len(b) == 0: continue if index == 0: index = 1 x = a y = b else: x = pd.concat([x, a]) y = pd.concat([y, b]) print('%i: %s' % (season, x.shape)) x = x.values.reshape(y.shape[0], num_of_games, 1860) print('X Shape: %s' % str(x.shape)) print('Y Shape: %s' % str(y.shape)) x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3) es = EarlyStopping(monitor='acc', mode='auto', verbose=1, patience=5) mc = ModelCheckpoint(model_name, monitor='acc', verbose=1, save_best_only=True, mode='auto', period=5) model.fit(x_train, y_train, epochs=50, batch_size=20, verbose=1, callbacks=[es, mc]) score = model.evaluate(x_test, y_test) print('=========================') print('Accuracy: %.3f' % score[1]) print('=========================') model.save(model_name) return
# In[21]: opt = 'adam' loss = 'categorical_crossentropy' metrics = ['accuracy'] # Compile the classifier using the configuration we want cnn.compile(optimizer=opt, loss=loss, metrics=metrics) # In[22]: print(cnn.summary()) # In[23]: history = cnn.fit(x_train, y_train, batch_size=32, epochs=10, validation_data=(x_test, y_test)) # In[24]: scores = cnn.evaluate(x_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1]*100))
class ConvNet: def __init__(self): self.model = Sequential() self.trained = None self.train_datagen = ImageDataGenerator(rescale=1. / 255, shear_range=0.3, zoom_range=0.3, horizontal_flip=True) self.test_datagen = ImageDataGenerator(rescale=1. / 255) self.train_generator = self.train_datagen.flow_from_directory( 'data/train', target_size=(150, 150), batch_size=32, class_mode='categorical') self.validation_generator = self.test_datagen.flow_from_directory( 'data/validation', target_size=(150, 150), batch_size=32, class_mode='categorical') self.network() self.model.compile(loss='categorical_crossentropy', optimizer=optimizers.RMSprop(lr=1e-4), metrics=['accuracy']) def __str__(self): return self.model.summary() def network(self): self.model.add( Conv2D(72, (3, 3), padding='same', input_shape=(150, 150, 3), activation='relu')) self.model.add(Conv2D(64, (3, 3), activation='relu')) self.model.add(MaxPool2D(pool_size=(5, 5))) self.model.add(Conv2D(64, (3, 3), padding='same', activation='relu')) self.model.add(Conv2D(48, (3, 3), activation='relu')) self.model.add(Conv2D(32, (3, 3), activation='relu')) self.model.add(Conv2D(24, (3, 3), activation='relu')) self.model.add(MaxPool2D(pool_size=(5, 5))) self.model.add(Flatten()) self.model.add(Dense(128, activation='relu')) self.model.add(Dense(96, activation='relu')) self.model.add(Dense(64, activation='relu')) self.model.add(Dropout(rate=0.5)) self.model.add(Dense(6, activation='softmax')) def train(self): self.trained = self.model.fit_generator( self.train_generator, steps_per_epoch=439, epochs=20, validation_data=self.validation_generator, validation_steps=439) self.learning_curve() def learning_curve(self): plt.plot(self.trained.history['acc']) plt.plot(self.trained.history['val_acc']) plt.title('Model accuracy') plt.ylabel('Accuracy') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.savefig('figures/model_accuracy.png') plt.show() plt.plot(self.trained.history['loss']) plt.plot(self.trained.history['val_loss']) plt.title('Model loss') plt.ylabel('Loss') plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.savefig('figures/model_loss.png') plt.show()
input_img = Input(shape=(1, 28, 28)) y = tf.placeholder(tf.float32, shape=(None, 10)) encoder = Sequential() x1 = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img) x2 = MaxPooling2D((2, 2), padding='same')(x1) x3 = Conv2D(8, (3, 3), activation='relu', padding='same')(x2) x4 = MaxPooling2D((2, 2), padding='same')(x3) x5 = Conv2D(8, (3, 3), activation='relu', padding='same')(x4) encoded = MaxPooling2D((2, 2), padding='same')(x5) ae = Model(input_img, encoded) encoder.add(ae) encoder.add(Flatten()) encoder.add(Dense(10)) encoder.summary() # at this point the representation is (4, 4, 8) i.e. 128-dimensional x6 = Conv2D(8, (3, 3), activation='relu', padding='same')(encoded) x7 = UpSampling2D((2, 2))(x6) x8 = Conv2D(8, (3, 3), activation='relu', padding='same')(x7) x9 = UpSampling2D((2, 2))(x8) x10 = Conv2D(16, (3, 3), activation='relu')(x9) x11 = UpSampling2D((2, 2))(x10) decoded = Conv2D(1, (3, 3), activation='sigmoid', padding='same')(x11) autoencoder = Model(input_img, decoded) autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy') autoencoder.summary()
# # TimeDistributed(Dense(out.shape[2]*20)), ## # TimeDistributed(Dense(32,)), # TimeDistributed(Dense(1), name='test'), Reshape((375,)), ]) # optimizer = optimizers.Adam(clipvalue=0.5) #optimizer = optimizers.Adam(clipnorm=1.) # model = multi_gpu_model(model, gpus=6) model_1.compile(loss=kl.mean_absolute_error, optimizer = 'adam',metrics=['accuracy']) model_1.summary() hist_1 = model_1.fit(input_bus, output_bus, epochs=30, batch_size=20, verbose=1, shuffle=False) with open('caseof.pickles','wb') as p: pickle.dump(model_1,p) pickle.dump(hist_1,p) # In[2] with open('caseof.pickles','rb') as p: model = pickle.load(p) hist = pickle.load(p) valo = sequence.pad_sequences(valo) explainer = shap.DeepExplainer(model, tf.convert_to_tensor(input_bus[:239,:,2:,:,:],dtype = 'float32'))
def buildmodel(): model = Sequential() #卷積層1 model.add( Conv2D(filters=64, kernel_size=(3, 3), input_shape=(48, 48, 1), activation='relu', padding='same')) #卷積層2與池化層2 #model.add(ZeroPadding2D(padding=(1,1), data_format='channels_last')) model.add( Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same')) model.add( Conv2D(filters=64, kernel_size=(3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.1)) model.add( Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same')) #model.add(ZeroPadding2D(padding=(1,1), data_format='channels_last')) model.add( Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same')) model.add( Conv2D(filters=128, kernel_size=(3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.1)) model.add( Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same')) #model.add(ZeroPadding2D(padding=(1,1), data_format='channels_last')) model.add( Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same')) model.add( Conv2D(filters=256, kernel_size=(3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.1)) model.add( Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same')) #model.add(ZeroPadding2D(padding=(1,1), data_format='channels_last')) model.add( Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same')) model.add( Conv2D(filters=512, kernel_size=(3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.1)) #Step3 建立神經網路(平坦層、隱藏層、輸出層) model.add(Flatten()) model.add( Dense(4096, input_shape=(48, 48, 1), kernel_regularizer=regularizers.l2(0.001), activation='relu')) model.add(Dropout(0.5)) model.add( Dense(2048, input_shape=(48, 48, 1), kernel_regularizer=regularizers.l2(0.001), activation='relu')) model.add(Dropout(0.5)) model.add(Dense(1000, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(7, activation='softmax')) # opt = SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True) opt = Adam(lr=1e-4) # opt = Adadelta(lr=0.1, rho=0.95, epsilon=1e-08) model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy']) model.summary() return model
class Model(object): FILE_PATH = "C:\\Face recognition\\face.model.h5" #模型进行存储和读取的地方 IMAGE_SIZE = 128 #模型接受的人脸图片一定得是128*128的 def __init__(self): self.model = None #读取实例化后的DataSet类作为进行训练的数据源 def read_trainData(self, dataset): self.dataset = dataset #建立CNN模型 def build_model(self): self.model = Sequential() self.model.add( Convolution2D(filters=32, kernel_size=(3, 3), padding='same', data_format='channels_last', input_shape=self.dataset.X_train.shape[1:])) self.model.add(Activation('relu')) self.model.add( Convolution2D(filters=32, kernel_size=(3, 3), padding='same', data_format='channels_last', input_shape=self.dataset.X_train.shape[1:])) self.model.add(Activation('relu')) self.model.add( MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')) self.model.add(Dropout(0.25)) self.model.add( Convolution2D(filters=64, kernel_size=(3, 3), padding='same')) self.model.add(Activation('relu')) self.model.add( Convolution2D(filters=64, kernel_size=(3, 3), padding='same')) self.model.add(Activation('relu')) self.model.add( MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')) self.model.add(Dropout(0.25)) self.model.add( Convolution2D(filters=64, kernel_size=(3, 3), padding='same')) self.model.add(Activation('relu')) self.model.add( Convolution2D(filters=64, kernel_size=(3, 3), padding='same')) self.model.add(Activation('relu')) self.model.add( MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')) self.model.add(Dropout(0.25)) self.model.add( Convolution2D(filters=64, kernel_size=(3, 3), padding='same')) self.model.add(Activation('relu')) self.model.add( Convolution2D(filters=64, kernel_size=(3, 3), padding='same')) self.model.add(Activation('relu')) self.model.add( MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='same')) self.model.add(Dropout(0.25)) self.model.add(Flatten()) self.model.add(Dense(512)) self.model.add(Activation('relu')) self.model.add(Dropout(0.5)) self.model.add(Dropout(0.5)) self.model.add(Dropout(0.5)) self.model.add(Dense(self.dataset.num_classes)) self.model.add(Activation('softmax')) self.model.summary() def train_model(self): self.model.compile( optimizer='adam', #有很多可选的optimizer,例如RMSprop,Adagrad loss='categorical_crossentropy', #可以选用squared_hinge作为loss metrics=['accuracy']) #epochs、batch_size为可调的参数,epochs为训练多少轮、batch_size为每次训练多少个样本 self.model.fit(self.dataset.X_train, self.dataset.Y_train, epochs=5, batch_size=16) def evaluate_model(self): print('\nTesting---------------') loss, accuracy = self.model.evaluate(self.dataset.X_test, self.dataset.Y_test) print('test loss:', loss) print('test accuracy:', accuracy) def save(self, file_path=FILE_PATH): print('Model Saved.') self.model.save(file_path) def load(self, file_path=FILE_PATH): print('Model Loaded.') self.model = load_model(file_path) #需要确保输入的img得是灰化之后(channel =1 )且 大小为IMAGE_SIZE的人脸图片 def predict(self, img): img = img.reshape((1, self.IMAGE_SIZE, self.IMAGE_SIZE, 1)) img = img.astype('float32') img = img / 255.0 result = self.model.predict_proba(img) #测算一下该img属于某个label的概率 max_index = np.argmax(result) #找出概率最高的 return max_index, result[0][ max_index] #第一个参数为概率最高的label的index,第二个参数为对应概率
def ejemplo12(): from keras.datasets import cifar10 from keras.layers import Flatten from keras.constraints import maxnorm from keras.optimizers import SGD from keras.layers.convolutional import Convolution2D from keras.layers.convolutional import MaxPooling2D # fix random seed for reproducibility seed = 7 numpy.random.seed(seed) # load data (X_train, y_train), (X_test, y_test) = cifar10.load_data() # normalize inputs from 0-255 to 0.0-1.0 X_train = X_train.astype('float32') X_test = X_test.astype('float32') X_train = X_train / 255.0 X_test = X_test / 255.0 # one hot encode outputs y_train = np_utils.to_categorical(y_train) y_test = np_utils.to_categorical(y_test) num_classes = y_test.shape[1] # Create the model model = Sequential() model.add( Convolution2D(32, (3, 3), input_shape=(32, 32, 3), activation='relu', padding='same')) model.add(Dropout(0.2)) model.add(Convolution2D(32, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(64, (3, 3), activation='relu', padding='same')) model.add(Dropout(0.2)) model.add(Convolution2D(64, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Convolution2D(128, (3, 3), activation='relu', padding='same')) model.add(Dropout(0.2)) model.add(Convolution2D(128, (3, 3), activation='relu', padding='same')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dropout(0.2)) model.add(Dense(1024, activation='relu', kernel_constraint=maxnorm(3))) model.add(Dropout(0.2)) model.add(Dense(512, activation='relu', kernel_constraint=maxnorm(3))) model.add(Dropout(0.2)) model.add(Dense(num_classes, activation='softmax')) # Compile model epochs = 25 lrate = 0.01 decay = lrate / epochs sgd = SGD(lr=lrate, momentum=0.9, decay=decay, nesterov=False) model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy']) print(model.summary()) # Fit the model model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=epochs, batch_size=32) # Final evaluation of the model scores = model.evaluate(X_test, y_test, verbose=0) print("Accuracy: %.2f%%" % (scores[1] * 100))
# create NN_model NN_model = Sequential() NN_model.add( Dense(x_train.shape[1], input_dim=x_train.shape[1], activation='relu')) NN_model.add(Dense(100, activation='relu')) NN_model.add(Dense(50, activation='relu')) NN_model.add(Dense(25, activation='relu')) NN_model.add(Dense(12, activation='relu')) # output Layer NN_model.add(Dense(1, activation='linear')) # Compile the network : NN_model.compile(loss='mean_absolute_error', optimizer='adam', metrics=['mean_absolute_error']) NN_model.summary() checkpoint_name = 'Weights-{epoch:03d}--{val_loss:.5f}.hdf5' checkpoint = ModelCheckpoint(checkpoint_name, monitor='val_loss', verbose=1, save_best_only=True, mode='auto') callbacks_list = [checkpoint] history = NN_model.fit(x_train, y, batch_size=1000, epochs=20, verbose=1, callbacks=callbacks_list,
strides=(2, 2), input_shape=(14, 47, 36), activation='relu')) model.add(Conv2D(64, 3, input_shape=(5, 22, 48), activation='relu')) model.add(Conv2D(64, 3, input_shape=(3, 20, 64), activation='relu')) model.add(Flatten()) model.add(Dense(1164, activation='relu')) model.add(Dropout(0.5)) #Added dropout layer to avoid overfitting model.add(Dense(100, activation='relu')) model.add(Dense(50, activation='relu')) model.add(Dropout(0.5)) #Added dropout layer to avoid overfitting model.add(Dense(10, activation='relu')) model.add(Dense(1)) model.build() model.compile(optimizer=Adam(lr=2e-04), loss="mse") model.summary(print_fn=lambda x: log.write(x + '\n')) print("Model built!") datagen = ImageDataGenerator( brightness_range=(0.7, 0.9)) #Further data augmentation datagen.fit(train_x) history = model.fit_generator(datagen.flow(train_x, train_y, batch_size=64), epochs=64, validation_data=(valid_x, valid_y)) log.write(str(history.history)) plt.plot(history.history['loss'])
model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) filepath = "./models/lstm-{epoch:02d}-{loss:0.3f}-{acc:0.3f}-{val_loss:0.3f}-{val_acc:0.3f}.hdf5" checkpoint = ModelCheckpoint(filepath, monitor="loss", verbose=1, save_best_only=True, mode='min') reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=2, min_lr=0.000001) print model.summary() model.fit(CONTENT, labels, batch_size=128, epochs=5, validation_split=0.1, shuffle=True, callbacks=[checkpoint, reduce_lr]) else: model = load_model(sys.argv[1]) print model.summary() test_CONTENT, _ = process_CONTENT(TEST_PROCESSED_FILE, test_file=True) test_CONTENT = pad_sequences(test_CONTENT, maxlen=max_length, padding='post') predictions = model.predict(test_CONTENT, batch_size=128, verbose=1)
def main(rnn_model): def message_to_array(msg): msg = msg.lower().split(' ') test_seq = np.array([word_index[word] for word in msg]) test_seq = np.pad(test_seq, (500-len(test_seq), 0), 'constant', constant_values=(0)) test_seq = test_seq.reshape(1, 500) return test_seq data = pd.read_csv("./spam_text_message_data.csv") print(data.head()) print(data.tail()) messages = [] labels = [] for index, row in data.iterrows(): messages.append(row['Message']) if row['Category'] == 'ham': labels.append(0) else: labels.append(1) messages = np.asarray(messages) labels = np.asarray(labels) print("Number of messages: ", len(messages)) print("Number of labels: ", len(labels)) max_vocab = 10000 max_len = 500 # Ignore all words except the 10000 most common words tokenizer = Tokenizer(num_words=max_vocab) # Calculate the frequency of words tokenizer.fit_on_texts(messages) # Convert array of messages to list of sequences of integers sequences = tokenizer.texts_to_sequences(messages) # Dict keeping track of words to integer index word_index = tokenizer.word_index # Convert the array of sequences(of integers) to 2D array with padding # maxlen specifies the maximum length of sequence (truncated if longer, padded if shorter) data = pad_sequences(sequences, maxlen=max_len) print("data shape: ", data.shape) # We will use 80% of data for training & validation(80% train, 20% validation) and 20% for testing train_samples = int(len(messages)*0.8) messages_train = data[:train_samples] labels_train = labels[:train_samples] messages_test = data[train_samples:len(messages)-2] labels_test = labels[train_samples:len(messages)-2] embedding_mat_columns=32 # Construct the SimpleRNN model model = Sequential() ## Add embedding layer to convert integer encoding to word embeddings(the model learns the ## embedding matrix during training), embedding matrix has max_vocab as no. of rows and chosen ## no. of columns model.add(Embedding(input_dim=max_vocab, output_dim=embedding_mat_columns, input_length=max_len)) if rnn_model == 'SimpleRNN': model.add(SimpleRNN(units=embedding_mat_columns)) elif rnn_model == 'LSTM': model.add(LSTM(units=embedding_mat_columns)) else: model.add(GRU(units=embedding_mat_columns)) model.add(Dense(1, activation='sigmoid')) model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['acc']) model.summary() #plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True) # Training the model model.fit(messages_train, labels_train, epochs=10, batch_size=60, validation_split=0.2) # Testing the model pred = model.predict_classes(messages_test) acc = model.evaluate(messages_test, labels_test) print("Test loss is {0:.2f} accuracy is {1:.2f} ".format(acc[0],acc[1])) # Constructing a custom message to check model custom_msg = 'Congratulations ur awarded 500 of CD vouchers or 125gift guaranteed Free entry for movies' test_seq = message_to_array(custom_msg) pred = model.predict_classes(test_seq) print(pred)
class GAN_Model(object): def __init__(self, batch_size, timesteps, word_index, summary=None): self.batch_size = batch_size self.timesteps = timesteps self.word_index = word_index self.lstm_vec_dim = 128 self.summary = summary self.D = None # discriminator self.G = None # generator self.AM = None # adversarial model self.DM = None # discriminator model # (W-F+2P)/S+1 def discriminator(self): if self.D: return self.D dropout_value = 0.1 cnn_filters = [20, 10] cnn_kernels = [2, 3] enc_convs = [] embedding_vec = 20 # lunghezza embedding layer # In: (batch_size, timesteps,1), # Out: (batch_size, 128) discr_inputs = Input(shape=(self.timesteps, 38), name="Discriminator_Input") # embedding layer. expected output ( batch_size, timesteps, embedding_vec) manual_embedding = Dense(embedding_vec, activation='linear') discr = TimeDistributed( manual_embedding, name='manual_embedding', trainable=False )( discr_inputs ) # this is actually the first layer of the discriminator in the joined GAN # discr = Embedding(self.word_index, embedding_vec, input_length=self.timesteps)(discr_inputs) for i in range(2): conv = Conv1D(cnn_filters[i], cnn_kernels[i], padding='same', activation='relu', strides=1, name='discr_conv%s' % i)(discr) conv = Dropout(dropout_value, name='discr_dropout%s' % i)(conv) conv = MaxPooling1D()(conv) enc_convs.append(conv) # concatenating CNNs. expected output (batch_size, 7, 30) discr = concatenate(enc_convs) # LSTM. expected out (batch_size, 128) discr = LSTM(self.lstm_vec_dim)(discr) discr = Dense(1, activation='sigmoid')(discr) self.D = Model(inputs=discr_inputs, outputs=discr, name='Discriminator') if self.summary: self.D.summary() plot_model(self.D, to_file="images/discriminator.png", show_shapes=True) return self.D def generator(self): if self.G: return self.G dropout_value = 0.1 cnn_filters = [20, 10] cnn_kernels = [2, 3] dec_convs = [] # In: (batch_size, 128), # Out: (batch_size, timesteps, word_index) dec_inputs = Input(shape=(128, ), name="Generator_Input") # decoded = Dense(self.lstm_vec_dim, activation='sigmoid')(dec_inputs) # Repeating input by "timesteps" times. expected output (batch_size, 128, 15) decoded = RepeatVector(self.timesteps, name="gen_repeate_vec")(dec_inputs) decoded = LSTM(self.lstm_vec_dim, return_sequences=True, name="gen_LSTM")(decoded) for i in range(2): conv = Conv1D(cnn_filters[i], cnn_kernels[i], padding='same', activation='relu', strides=1, name='gen_conv%s' % i)(decoded) conv = Dropout(dropout_value, name="gen_dropout%s" % i)(conv) dec_convs.append(conv) decoded = concatenate(dec_convs) decoded = TimeDistributed( Dense(self.word_index, activation='softmax'), name='decoder_end')( decoded) # output_shape = (samples, maxlen, max_features ) self.G = Model(inputs=dec_inputs, outputs=decoded, name='Generator') if self.summary: self.G.summary() plot_model(self.G, to_file="images/generator.png", show_shapes=True) return self.G def discriminator_model(self, summary=None): if self.DM: return self.DM optimizer = RMSprop(lr=0.0002, decay=6e-8) self.DM = Sequential() self.DM.add(self.discriminator()) self.DM.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) return self.DM def adversarial_model(self): if self.AM: return self.AM optimizer = RMSprop(lr=0.0001, decay=3e-8) self.AM = Sequential() self.AM.add(self.generator()) self.AM.add(self.discriminator()) self.discriminator().trainable = False self.AM.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy']) if self.summary: self.AM.summary() plot_model(self.AM, to_file="images/adversial.png", show_shapes=True) return self.AM
input_dim = 2*N_crop**2 encoding_dim = 32 epochs = 2000 batch = 32 K.clear_session() AE_high = Sequential() AE_high.add(Dense(16 * encoding_dim, input_shape=(input_dim, ), activation='relu')) AE_high.add(Dense(4 * encoding_dim, activation='relu')) AE_high.add(Dense(2 * encoding_dim, activation='relu')) AE_high.add(Dense(encoding_dim, activation='relu')) AE_high.add(Dense(2 * encoding_dim, activation='relu')) AE_high.add(Dense(4 * encoding_dim, activation='relu')) AE_high.add(Dense(input_dim, activation='sigmoid')) AE_high.summary() AE_high.compile(optimizer='adam', loss='mean_squared_error') ### Run the TRAINING AE_high.fit(train_noisy, train_clean, epochs=epochs, batch_size=batch, shuffle=True, verbose=2, validation_data=(test_noisy, test_clean)) decoded = AE_high.predict(test_noisy) # Make sure the training has succeeded by checking the residuals residuals = np.mean(norm(np.abs(decoded - test_clean), axis=-1)) total = np.mean(norm(np.abs(test_clean), axis=-1)) print(residuals / total * 100) # ================================================================================================================ # # USE THE ENCODER TO TRAIN AN MLP NETWORK # # ================================================================================================================ #
def GSCSubtractNN(x_train, x_val, x_test, y_train, y_val, y_test, verbose): print('--------- GSC Subtract Neural Network ---------') # Convert target labels to categorical data format y_train = np_utils.to_categorical(y_train, 2) y_val = np_utils.to_categorical(y_val, 2) y_test = np_utils.to_categorical(y_test, 2) # Neural Network Configuration input_nodes = x_train.shape[1] drop_out = 0.3 layer_1_nodes = 512 layer_2_nodes = 256 layer_3_nodes = 128 layer_4_nodes = 32 output_nodes = 2 # Sequential Model of 4 hidden layers model = Sequential() model.add( Dense(layer_1_nodes, input_dim=input_nodes, kernel_regularizer=regularizers.l2(0), activity_regularizer=regularizers.l1(0), kernel_initializer=initializers.RandomUniform(seed=123))) #model.add(Activation('relu')) model.add(LeakyReLU(alpha=0.3)) model.add(Dropout(drop_out)) model.add( Dense(layer_2_nodes, input_dim=layer_1_nodes, kernel_regularizer=regularizers.l2(0), activity_regularizer=regularizers.l1(0), kernel_initializer=initializers.RandomUniform(seed=123))) #model.add(Activation('relu')) model.add(LeakyReLU(alpha=0.3)) model.add(Dropout(drop_out)) model.add( Dense(layer_3_nodes, input_dim=layer_2_nodes, kernel_regularizer=regularizers.l2(0), activity_regularizer=regularizers.l1(0), kernel_initializer=initializers.RandomUniform(seed=123))) #model.add(Activation('relu')) model.add(LeakyReLU(alpha=0.3)) model.add(Dropout(drop_out)) model.add( Dense(layer_4_nodes, input_dim=layer_3_nodes, kernel_regularizer=regularizers.l2(0), activity_regularizer=regularizers.l1(0), kernel_initializer=initializers.RandomUniform(seed=123))) #model.add(Activation('relu')) model.add(LeakyReLU(alpha=0.3)) model.add(Dropout(drop_out)) model.add( Dense(output_nodes, input_dim=layer_4_nodes, kernel_regularizer=regularizers.l2(0), activity_regularizer=regularizers.l1(0), kernel_initializer=initializers.RandomUniform(seed=551))) model.add(Activation('sigmoid')) model.summary() model.compile(optimizer=optimizers.SGD(lr=0.05, momentum=0.1, decay=0, nesterov=True), loss='categorical_crossentropy', metrics=['accuracy']) num_epochs = 250 model_batch_size = 128 tb_batch_size = 32 early_patience = 50 tensorboard_cb = TensorBoard(log_dir='logs', batch_size=tb_batch_size, write_graph=True) earlystopping_cb = EarlyStopping(monitor='val_loss', verbose=1, patience=early_patience, mode='min') # Train model using Training Data history = model.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=num_epochs, batch_size=model_batch_size, shuffle=True, callbacks=[tensorboard_cb, earlystopping_cb], verbose=verbose) # Convert labels from categorical format to original vector format y_test = np.argmax(y_test, axis=1) # Predicted labels for Test Data pred = model.predict(x_test) pred = np.argmax(pred, axis=1) df = pd.DataFrame(history.history) print(df.tail(1)) # Accuracy and Erms for Test Data accuracy, erms = GetErms(pred, y_test) print("Test Erms: " + str(erms) + " Test Acuracy: " + str(accuracy)) # Precision and Recall for Test Data precision, recall = GetPrecisionRecall(pred, y_test) print("Precision: " + str(precision) + " Recall: " + str(recall)) # PLot graph of Loss and Accuracy over epochs df.plot() plt.savefig('GSC_Subtract_NN.jpg', grid=True, figsize=(7, 8))
def network_f(X_test_data, Y_test_data): layers_array = ["conv1"] with open('max_dict.csv', mode='r') as infile: reader = csv.reader(infile, delimiter=',') data_read = [row for row in reader] conv_scale = [] for i in range(0, 4): conv_scale.append(math.floor(127 / float(data_read[i * 2][1]))) print(conv_scale[i]) accr_list = [] top_5_acc = [] model = Sequential() # Conv1, Scaling1 and ReLU1 model.add( Conv2D(32, kernel_size=(3, 3), input_shape=(channels, img_rows, img_cols), data_format='channels_first', kernel_initializer='he_normal', padding='same', use_bias=False, name='conv1')) model.add( Lambda(lambda x: floor_func(x, conv_scale[0]), name='scaling1') ) ## Dividing by 27 (MAV) and 18.296 (Instead of 128), so need to multiply by factor of 7 in gain stage model.add(Activation(relu_layer, name='act_conv1')) # Conv2, Scaling2 and ReLU2 model.add( Conv2D(32, kernel_size=(3, 3), data_format='channels_first', kernel_initializer='he_normal', padding='same', use_bias=use_bias, name='conv2')) model.add( Lambda(lambda x: floor_func(x, conv_scale[1]), name='scaling2') ) ## Dividing by 288 (MAV) and 1 (Instead of 128), so need to multiply by factor of 128 in gain stage model.add(Activation(relu_layer, name='act_conv2')) # Pool1 model.add( MaxPooling2D(pool_size=(2, 2), name='pool1', data_format='channels_first')) # Conv3, Scaling3 and ReLU3 model.add( Conv2D(64, kernel_size=(3, 3), data_format='channels_first', kernel_initializer='he_normal', padding='same', use_bias=use_bias, name='conv3')) model.add( Lambda(lambda x: floor_func(x, conv_scale[2]), name='scaling3') ) ## Dividing by 288 (MAV) and 2 (Instead of 128), so need to multiply by factor of 64 in gain stage model.add(Activation(relu_layer, name='act_conv3')) # Conv4, Scaling4 and ReLU4 model.add( Conv2D(64, kernel_size=(3, 3), data_format='channels_first', kernel_initializer='he_normal', padding='same', use_bias=use_bias, name='conv4')) model.add( Lambda(lambda x: floor_func(x, conv_scale[3]), name='scaling4') ) ## Dividing by 576 (MAV) and 1 (Instead of 128), so need to multiply by factor of 128 in gain stage model.add(Activation(relu_layer, name='act_conv4')) # Pool2 model.add( MaxPooling2D(pool_size=(2, 2), name='pool2', data_format='channels_first')) model.add(Flatten()) # model.add(Lambda(lambda x: x*6, name='scaling_fc')) # FC1, Batch Normalization and ReLU5 model.add( Dense(512, use_bias=True, name='FC1', kernel_initializer='he_normal')) model.add( BatchNormalization(epsilon=epsilon, momentum=momentum, name='bn1')) model.add(Activation(relu_layer, name='act_fc1')) # FC2, Batch Normalization and ReLU6 model.add( Dense(classes, use_bias=True, name='FC2', kernel_initializer='he_normal')) model.add( BatchNormalization(epsilon=epsilon, momentum=momentum, name='bn2')) model.add(Activation(softmax_layer, name='act_fc2')) # Optimizers opt = RMSprop(lr=0.0001, decay=1e-6) model.compile(loss='squared_hinge', optimizer=opt, metrics=['accuracy', 'top_k_categorical_accuracy']) # model.compile('adam', 'categorical_crossentropy', ['accuracy', 'top_k_categorical_accuracy']) model.build() model.summary() model.load_weights(weight_hdf5, by_name=True) score = model.evaluate(X_test_data, Y_test_data, verbose=0) print('Test score:', score[0]) print('Test accuracy:', score[1]) print('top-k accuracy:', score[2]) accr_list.append(score[1]) top_5_acc.append(score[2]) ## LAYER OUTPUTS TO DUMP if args["print_layers"] > 0: for i in layers_array: intermediate_layer_model = Model(inputs=model.input, outputs=model.get_layer(i).output) intermediate_output = intermediate_layer_model.predict( [X_test_data]) file_name = "output/" + i + ".pkl" print("Dumping layer {} outputs to file {}".format(i, file_name)) intermediate_output.dump(file_name)
class Classifier: def __init__(self, resultDir: str, modelName: str, x_train, y_train_oh, x_dev, y_dev_oh, x_test, y_test_oh, drop1, drop2, drop3): """ Initialize parameters and sequential model for training """ self.resultDir = resultDir self.modelName = modelName self.x_train = x_train self.x_dev = x_dev self.x_test = x_test self.y_train_oh = y_train_oh self.y_dev_oh = y_dev_oh self.y_test_oh = y_test_oh self.drop1 = drop1 self.drop2 = drop2 self.drop3 = drop3 self.model = Sequential() self.model.add(Dense(200, activation='relu', input_shape=(1500, ))) #self.model.add(BatchNormalization()) self.model.add(Dropout(self.drop1)) self.model.add(Dense(500, activation='relu')) #self.model.add(BatchNormalization()) self.model.add(Dropout(self.drop2)) self.model.add(Dense(800, activation='relu')) #self.model.add(BatchNormalization()) self.model.add(Dropout(self.drop2)) self.model.add(Dense(1000, activation='relu')) #self.model.add(BatchNormalization()) self.model.add(Dropout(self.drop3)) self.model.add(Dense(256, activation='softmax')) self.model.compile(loss='categorical_crossentropy', metrics=['categorical_accuracy'], optimizer='adam') print("Model summary\n") print(self.model.summary()) def train(self, batchSize): """ Train the model with the training data batchSize : batch size during trainig """ Epochs = 1000 logFile = self.resultDir + '/' + self.modelName + '_' + str( batchSize) + '.log' csv_logger = CSVLogger(logFile, append=True, separator="\t") earlyStop = EarlyStopping(monitor='categorical_accuracy', patience=10, mode='auto', verbose=1, restore_best_weights=True) ##filePath = self.resultDir + '/' + self.modelName + '_checkPoint_best_model.hdf5' #### This file will include the epoch number when it gets saved. ##repeatingFile = self.resultDir + '/' + self.modelName +'_{epoch:02d}_epoch_acc_{accVar:.2f}.hdf5' #### By default the every_10epochs will save the model at every 10 epochs ##checkPoint = newCallBacks.ModelCheckpoint_every_10epochs(filePath, repeatingFile, self.x_test, self.y_test_oh , monitor='val_categorical_accuracy', verbose=1, save_best_only=True, every_10epochs=True) self.history = self.model.fit(self.x_train, self.y_train_oh, batch_size=batchSize, epochs=Epochs, verbose=1, shuffle=True, validation_data=(self.x_dev, self.y_dev_oh), callbacks=[csv_logger, earlyStop]) def evaluate(self): """ Evaluate the model on itself """ ## We should be evaluating on dev dataset as well, so commenting x_test #self.model_score = self.model.evaluate(self.x_test, self.y_test_oh, batch_size=2048) self.model_score = self.model.evaluate(self.x_dev, self.y_dev_oh, batch_size=2048) print("%s score = %f\n" % (self.modelName, self.model_score[1])) ##Saving atucal vs predicted predictions ##np.argmax returns the index where it see's 1 in the row #y_pred = np.argmax(self.model.predict(self.x_test, batch_size=2048), axis=1) y_pred = np.argmax(self.model.predict(self.x_dev, batch_size=2048), axis=1) ## vstack will stack them in 2 rows, so we use Trasnpose to get them in column stack #output_predict = np.vstack((np.argmax(self.y_test_oh, axis=1), y_pred)).T output_predict = np.vstack((np.argmax(self.y_dev_oh, axis=1), y_pred)).T outputFile = self.resultDir + '/' + self.modelName + '_4HLw_200_500_800_1000_' + str( self.history.epoch[-1] + 1) + 'epochs_' + 'Dropout_' + str( self.drop1).replace('.', 'p') + '_' + str(self.drop2).replace( '.', 'p') + '_' + str(self.drop3).replace( '.', 'p') + '_' + "_outputPredict.csv" np.savetxt(outputFile, output_predict, fmt="%5.0f", delimiter=",") ##Error Analysis of the prediction errorAnalysis(outputFile) return self.model_score def saveModel(self): """ Save the model """ saveStr = self.resultDir + '/' + self.modelName + '_4HLw_200_500_800_1000_' + str( self.history.epoch[-1] + 1) + 'epochs_' + 'Dropout_' + str( self.drop1).replace('.', 'p') + '_' + str(self.drop2).replace( '.', 'p') + '_' + str(self.drop3).replace( '.', 'p') + '_' + '{0:.2f}'.format( self.model_score[1] * 100).replace('.', 'p') + '.h5' print("Saving model to\n%s\n" % (saveStr)) self.model.save(saveStr)
def resnet(): restnet = ResNet50(include_top=False, weights='imagenet', input_shape=(IMG_SIZE, IMG_SIZE, 3)) output = restnet.layers[-1].output output = keras.layers.Flatten()(output) restnet = Model(restnet.input, output=output) for layer in restnet.layers: layer.trainable = False model = Sequential() model.add(restnet) model.add(Dense(512, activation='relu')) #,input_dim=(IMG_SIZE, IMG_SIZE, 3))) model.add(Dropout(0.3)) model.add(Dense(512, activation='relu')) model.add(Dropout(0.3)) model.add(Dense(10, activation='softmax')) #model.load_weights(weight_Path,by_name=True) model.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=2e-5), metrics=['accuracy']) #model.summary() '''history = model.fit(X_train,y_train,epochs=10,verbose=1) predictions=model.predict(X_test) result = model.evaluate(X_test, y_test, verbose=1) print("Done testing") print("Test loss =", result[0]) print("Test accuracy =", result[1] * 100)''' ###############Fine tuning################ restnet.trainable = True set_trainable = False for layer in restnet.layers: if layer.name in ['res5c_branch2b', 'res5c_branch2c', 'activation_97']: set_trainable = True if set_trainable: layer.trainable = True else: layer.trainable = False layers = [(layer, layer.name, layer.trainable) for layer in restnet.layers] model_finetuned = Sequential() model_finetuned.add(restnet) model_finetuned.add(Dense(512, activation='relu')) #, input_dim=input_shape)) #model_finetuned.add(Dropout(0.3)) model_finetuned.add(Dense(512, activation='relu')) #model_finetuned.add(Dropout(0.3)) model_finetuned.add(Dense(10, activation='sigmoid')) model_finetuned.compile(loss='binary_crossentropy', optimizer=optimizers.RMSprop(lr=1e-5), metrics=['accuracy']) model_finetuned.summary() history = model_finetuned.fit(X_train, y_train, epochs=10, verbose=1) predictions = model_finetuned.predict(X_test) result = model_finetuned.evaluate(X_test, y_test, verbose=1) print("Done testing") print("Test loss =", result[0]) print("Test accuracy =", result[1] * 100) model_finetuned.save('resnetModelFineTuned.h5') #files.download('resnetModelFineTuned.h5') predictionstest = model_finetuned.predict(test_data) predictionLabel = np.argmax(predictionstest, axis=1) predictionLabel = predictionLabel + 1 submitFile['Label'] = predictionLabel TestID = [] for img in tqdm(os.listdir(TEST_DIR)): TestID.append(img) submitFile['Id'] = TestID submitFile.to_csv("submitFile.csv", index=False)