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)