def main():
x_train, y_train, x_test, y_test = load_data()
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(11, 11),
strides=4,
padding="same",
activation='relu',
input_shape=(48, 48, 1)))
model.add(MaxPooling2D(pool_size=(3, 3), strides=2, padding="valid"))
model.add(
Conv2D(32,
kernel_size=(5, 5),
strides=1,
padding="same",
activation='relu'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=2, padding="valid"))
model.add(
Conv2D(32,
kernel_size=(3, 3),
strides=1,
padding="same",
activation='relu'))
model.add(
Conv2D(32,
kernel_size=(3, 3),
strides=1,
padding="same",
activation='relu'))
model.add(
Conv2D(32,
kernel_size=(3, 3),
strides=1,
padding="same",
activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(7, activation='softmax'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(x_train,
y_train,
batch_size=128,
epochs=5,
verbose=1,
validation_data=(x_test, y_test))
model.save(expanduser("~/emotion/alex_net.h5"))
accuracy, fbeta = test_model(model, x_test, y_test)
print("Accuracy: %s" % accuracy)
print("F-Beta: %s" % fbeta)
class WindPuller(object):
def __init__(self, input_shape, lr=0.01, n_layers=2, n_hidden=8, rate_dropout=0.2, loss=risk_estimation):
print("initializing..., learing rate %s, n_layers %s, n_hidden %s, dropout rate %s." % (
lr, n_layers, n_hidden, rate_dropout))
self.model = Sequential()
self.model.add(Dropout(rate=rate_dropout, input_shape=(input_shape[0], input_shape[1])))
for i in range(0, n_layers - 1):
self.model.add(LSTM(n_hidden * 4, return_sequences=True, activation='tanh',
recurrent_activation='hard_sigmoid', kernel_initializer='glorot_uniform',
recurrent_initializer='orthogonal', bias_initializer='zeros',
dropout=rate_dropout, recurrent_dropout=rate_dropout))
self.model.add(LSTM(n_hidden, return_sequences=False, activation='tanh',
recurrent_activation='hard_sigmoid', kernel_initializer='glorot_uniform',
recurrent_initializer='orthogonal', bias_initializer='zeros',
dropout=rate_dropout, recurrent_dropout=rate_dropout))
self.model.add(Dense(1, kernel_initializer=initializers.glorot_uniform()))
# self.model.add(BatchNormalization(axis=-1, moving_mean_initializer=Constant(value=0.5),
# moving_variance_initializer=Constant(value=0.25)))
self.model.add(BatchNormalization(axis=-1))
self.model.add(Activation("relu(alpha=0., max_value=1.0)"))
opt = RMSprop(lr=lr)
self.model.compile(loss=loss,
optimizer=opt,
metrics=['accuracy'])
def fit(self, x, y, batch_size=32, nb_epoch=100, verbose=1, callbacks=None,
validation_split=0., validation_data=None, shuffle=True,
class_weight=None, sample_weight=None, initial_epoch=0):
self.model.fit(x, y, batch_size, nb_epoch, verbose, callbacks,
validation_split, validation_data, shuffle, class_weight, sample_weight,
initial_epoch)
def save(self, path):
self.model.save(path)
def load_model(self, path):
self.model = load_model(path)
return self
def evaluate(self, x, y, batch_size=32, verbose=1,
sample_weight=None, **kwargs):
return self.model.evaluate(x, y, batch_size, verbose,
sample_weight)
def predict(self, x, batch_size=32, verbose=0):
return self.model.predict(x, batch_size, verbose)
#### Access middle layer output when First Dropout and then BatchNormalization
model_seq = Sequential()
model_seq.add(Dropout(0.3, input_shape=(10, )))
model_seq.add(BatchNormalization())
model_seq.add(Dense(1))
# check out weights before training
# model_seq.get_weights()
# compile and train
model_seq.compile(optimizer='SGD', loss='mse')
model_seq.fit(input_array_small, target_small, epochs=10)
model_seq.get_weights()
model_seq.save("to_delete.h5")
model_best = load_model("to_delete.h5")
###### compare two weights from two different training
# model_seq.get_weights()
###### check output
batchNorm_test = K.function(
[model_best.input, K.learning_phase()],
[model_best.layers[-2].output])([input_array_small, 0])[0]
batchNorm_train = K.function(
[model_best.input, K.learning_phase()],
[model_best.layers[-2].output])([input_array_small, 1])[0]
# dropout_layer_behaviour
## 下面代码帮助解释，dropout_rate = 0.3的含义，将30%的neuron权重参数设置为0
#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")
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)
model.save(savefile)
input_shape=(20, 20, 1),
activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# Second convolutional layer with max pooling
model.add(Conv2D(50, (5, 5), padding="same", activation="relu"))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# Hidden layer with 500 nodes
model.add(Flatten())
model.add(Dense(500, activation="relu"))
# Output layer with 32 nodes (one for each possible letter/number we predict)
model.add(Dense(32, activation="softmax"))
# Ask Keras to build the TensorFlow model behind the scenes
model.compile(loss="categorical_crossentropy",
optimizer="adam",
metrics=["accuracy"])
# Train the neural network
model.fit(X_train,
Y_train,
validation_data=(X_test, Y_test),
batch_size=32,
epochs=10,
verbose=1)
# Save the trained model to disk
model.save(MODEL_FILENAME)