def build(self): """ Builds the tiny yolo v2 network. :param input: input image batch to the network :return: logits output from network """ self.model = Sequential() self.model.add(Convolution2D(16, (3, 3), input_shape=(416, 416, 3), padding='same')) self.model.add(LeakyReLU()) self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')) self.model.add(Convolution2D(32, (3, 3), padding='same')) self.model.add(LeakyReLU()) self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')) self.model.add(Convolution2D(64, (3, 3), padding='same')) self.model.add(LeakyReLU()) self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')) self.model.add(Convolution2D(128, (3, 3), padding='same')) self.model.add(LeakyReLU()) self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')) self.model.add(Convolution2D(256, (3, 3), padding='same')) self.model.add(LeakyReLU()) self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), padding='valid')) self.model.add(Convolution2D(512, (3, 3), padding='same')) self.model.add(LeakyReLU()) self.model.add(BatchNormalization()) self.model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 1), padding='valid')) self.model.add(Convolution2D(1024, (3, 3), padding='same')) self.model.add(LeakyReLU()) self.model.add(BatchNormalization()) self.model.add(Convolution2D(1024, (3, 3), padding='same')) self.model.add(LeakyReLU()) self.model.add(BatchNormalization()) self.model.add(Convolution2D(125, (1, 1), activation=None)) if self.config.optimizer == 'adam': opt = Adam() elif self.config.optimizer == 'sgd': opt = SGD() if self.config.loss == 'categorical_crossentropy': loss = 'categorical_crossentropy' elif self.config.loss == 'yolov2_loss': raise NotImplemented self.model.compile(loss=loss, optimizer=opt, metrics=['accuracy']) self.model.summary() return self.model
def train(): (X_train, y_train), (X_test, y_test) = mnist.load_data() X_train = (X_train.astype(np.float32) - 127.5)/127.5 X_train = X_train[:, :, :, None] X_test = X_test[:, :, :, None] # X_train = X_train.reshape((X_train.shape, 1) + X_train.shape[1:]) d = discriminator_model() g = generator_model() d_on_g = generator_containing_discriminator(g, d) d_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True) g_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True) g.compile(loss='binary_crossentropy', optimizer="SGD") d_on_g.compile(loss='binary_crossentropy', optimizer=g_optim) d.trainable = True d.compile(loss='binary_crossentropy', optimizer=d_optim) for epoch in range(100): print("Epoch is", epoch) print("Number of batches", int(X_train.shape[0]/BATCH_SIZE)) for index in range(int(X_train.shape[0]/BATCH_SIZE)): noise = np.random.uniform(-1, 1, size=(BATCH_SIZE, 100)) image_batch = X_train[index*BATCH_SIZE:(index+1)*BATCH_SIZE] generated_images = g.predict(noise, verbose=0) if index % 20 == 0: image = combine_images(generated_images) image = image*127.5+127.5 Image.fromarray(image.astype(np.uint8)).save( str(epoch)+"_"+str(index)+".png") X = np.concatenate((image_batch, generated_images)) y = [1] * BATCH_SIZE + [0] * BATCH_SIZE d_loss = d.train_on_batch(X, y) print("batch %d d_loss : %f" % (index, d_loss)) noise = np.random.uniform(-1, 1, (BATCH_SIZE, 100)) d.trainable = False g_loss = d_on_g.train_on_batch(noise, [1] * BATCH_SIZE) d.trainable = True print("batch %d g_loss : %f" % (index, g_loss)) if index % 10 == 9: g.save_weights('generator', True) d.save_weights('discriminator', True)
w_1_1_2.append(init_weights[0][1, 0]) w_1_2_1.append(init_weights[0][0, 1]) w_1_2_2.append(init_weights[0][1, 1]) w_1_3_1.append(init_weights[0][0, 2]) w_1_3_2.append(init_weights[0][1, 2]) w_1_4_1.append(init_weights[0][0, 3]) w_1_4_2.append(init_weights[0][1, 3]) w_2_1.append(init_weights[2][0, 0]) w_2_2.append(init_weights[2][1, 0]) w_2_3.append(init_weights[2][2, 0]) w_2_4.append(init_weights[2][3, 0]) losses = [] accuracies = [] # use SGD optimizer with learning rate 0.1 sgd = SGD(lr=0.1) # set loss function to be mse, print out accuracy model.compile(loss='mse', optimizer=sgd, metrics=['accuracy']) # set loss function to be binary_crossentropy, print accuracy model1.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['accuracy']) ####################################################### # batch_size = 1, update weights every sample; # batch_size = 100, update weights every 100 sample; # without validation_split, all dataset are trained # with validation_split=0.25, 25% dataset is saved for validation,rest for training; during training, there will be loss and val_loss, accu, and val_accu # shuffle = True, all samples of training set will be shuffled for each epoch training # epochs = 10, train with the entire dataset for 10 times # hist = fit() will record a loss for each epoch #######################################################
y_train = to_categorical(np.random.randint(10, size=(1000, 1)), num_classes=10) x_test = np.random.random((100, 20)) y_test = to_categorical(np.random.randint(10, size=(100, 1)), num_classes=10) model = Sequential() # Dense(64) is a fully-connected layer with 64 hidden units. # in the first layer, you must specify the expected input data shape: # here, 20-dimensional vectors. model.add(Dense(64, activation='relu', input_dim=20)) model.add(Dropout(0.5)) model.add(Dense(64, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(10, activation='softmax')) # specify optimizer sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # param adjust model.compile( loss='categorical_crossentropy', # multi-class optimizer=sgd, metrics=['accuracy']) hist = model.fit(x_train, y_train, validation_split=0.2, epochs=1, batch_size=128) print(hist.history) score = model.evaluate(x_test, y_test, batch_size=128)
#create train and test lists. X-patterns, Y-intents train_x = list(training[:, 0]) train_y = list(training[:, 1]) #print("Training data created") #create a model Tensorflow model = Sequential() model.add(Dense(128, input_shape=(len(train_x[0]), ), activation='relu')) model.add(Dropout(0.5)) model.add(Dense(64, activation='relu')) model.add(Dropout(0.5)) model.add(Dense(len(train_y[0]), activation='softmax')) #compile model. Stochastic gradient descent with nesterov accelerated gradient gives good result sgd = SGD(lr=0.01, decay=1e-6, momentum=0.5, nesterov=True) model.compile(loss='categorical_crossentropy', optimizer=sgd) #fitting and saving model hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1) model.save('chatbot_model.h5', hist) print("model created")
# create model if os.path.isfile(savefile): model = load_model(savefile) else: model = Sequential() model.add(Dense(128, input_dim=input_dimension, kernel_initializer=hidden_initializer, activation='relu')) #model.add(Dense(128, input_dim=input_dimension, activation='relu')) model.add(Dropout(dropout_rate)) model.add(Dense(64, kernel_initializer=hidden_initializer, activation='relu')) model.add(Dense(2, kernel_initializer=hidden_initializer, activation='softmax')) #model.add(Dense(64, activation='relu')) #model.add(Dense(2, activation='softmax')) sgd = SGD(lr=learning_rate, momentum=momentum) model.compile(loss='binary_crossentropy', optimizer=sgd, metrics=['acc']) model.fit(X_train, y_train, epochs=50, batch_size=128) predictions = model.predict_proba(X_test) ans = pd.DataFrame(predictions,columns=['target','dmy']) print ans outdf = pd.concat([outdf,ans['target']],axis=1) outdf.to_csv('./submit_keras.csv',index=False) #save the model #model_json = model.to_json() #with open("./ans.json", "w") as json_file: # json_file.write(model_json)