def main_separatemodels():
X1, X2, y = generate_data2(TRAINING_SIZE)
X1_test, X2_test, y_test = generate_data2(TEST_SIZE)
print('Defining network...', file=sys.stderr)
firstlstm = Sequential()
firstlstm.add(Embedding(VOCABULARY_SIZE, EMBEDDING_DIMENSION))
firstlstm.add(LSTM(EMBEDDING_DIMENSION, HIDDEN_DIMENSION, return_sequences=False))
secondlstm = Sequential()
secondlstm.add(Embedding(VOCABULARY_SIZE, EMBEDDING_DIMENSION))
secondlstm.add(LSTM(EMBEDDING_DIMENSION, HIDDEN_DIMENSION, return_sequences=False))
model = Sequential()
model.add(Merge([firstlstm, secondlstm], mode='concat'))
model.add(Dense(HIDDEN_DIMENSION + HIDDEN_DIMENSION, 1, activation='sigmoid'))
print('Compiling...', file=sys.stderr)
model.compile(loss='binary_crossentropy', optimizer='adam', class_mode="binary")
print('Training...', file=sys.stderr)
model.fit([X1, X2], y, batch_size=BATCH_SIZE, nb_epoch=EPOCHS,
validation_split=0.05, show_accuracy=True)
print("Testing...", file=sys.stderr)
score, acc = model.evaluate([X1_test, X2_test], y_test, batch_size=BATCH_SIZE,
show_accuracy=True)
print("Testing performance = " + str(score) + ", acc = " + str(acc))
def test_TensorBoard_with_ReduceLROnPlateau(tmpdir):
import shutil
np.random.seed(np.random.randint(1, 1e7))
filepath = str(tmpdir / 'logs')
(X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples,
num_test=test_samples,
input_shape=(input_dim,),
classification=True,
num_classes=num_class)
y_test = np_utils.to_categorical(y_test)
y_train = np_utils.to_categorical(y_train)
model = Sequential()
model.add(Dense(num_hidden, input_dim=input_dim, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
model.compile(loss='binary_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
cbks = [
callbacks.ReduceLROnPlateau(
monitor='val_loss',
factor=0.5,
patience=4,
verbose=1),
callbacks.TensorBoard(
log_dir=filepath)]
model.fit(X_train, y_train, batch_size=batch_size,
validation_data=(X_test, y_test), callbacks=cbks, epochs=2)
assert os.path.isdir(filepath)
shutil.rmtree(filepath)
assert not tmpdir.listdir()
def model(X_train, X_test, y_train, y_test, maxlen, max_features):
embedding_size = 300
pool_length = 4
lstm_output_size = 100
batch_size = 200
nb_epoch = 1
model = Sequential()
model.add(Embedding(max_features, embedding_size, input_length=maxlen))
model.add(Dropout({{uniform(0, 1)}}))
# Note that we use unnamed parameters here, which is bad style, but is used here
# to demonstrate that it works. Always prefer named parameters.
model.add(Convolution1D({{choice([64, 128])}},
{{choice([6, 8])}},
border_mode='valid',
activation='relu',
subsample_length=1))
model.add(MaxPooling1D(pool_length=pool_length))
model.add(LSTM(lstm_output_size))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print('Train...')
model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch,
validation_data=(X_test, y_test))
score, acc = model.evaluate(X_test, y_test, batch_size=batch_size)
print('Test score:', score)
print('Test accuracy:', acc)
return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def train_rnn(character_corpus, seq_len, train_test_split_ratio):
model = Sequential()
model.add(Embedding(character_corpus.char_num(), 256))
model.add(LSTM(256, 5120, activation='sigmoid', inner_activation='hard_sigmoid', return_sequences=True))
model.add(Dropout(0.5))
model.add(TimeDistributedDense(5120, character_corpus.char_num()))
model.add(Activation('time_distributed_softmax'))
model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
seq_X, seq_Y = character_corpus.make_sequences(seq_len)
print "Sequences are made"
train_seq_num = train_test_split_ratio*seq_X.shape[0]
X_train = seq_X[:train_seq_num]
Y_train = to_time_distributed_categorical(seq_Y[:train_seq_num], character_corpus.char_num())
X_test = seq_X[train_seq_num:]
Y_test = to_time_distributed_categorical(seq_Y[train_seq_num:], character_corpus.char_num())
print "Begin train model"
checkpointer = ModelCheckpoint(filepath="model.step", verbose=1, save_best_only=True)
model.fit(X_train, Y_train, batch_size=256, nb_epoch=100, verbose=2, validation_data=(X_test, Y_test), callbacks=[checkpointer])
print "Model is trained"
score = model.evaluate(X_test, Y_test, batch_size=512)
print "valid score = ", score
return model
def test_EarlyStopping():
np.random.seed(1337)
(X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples,
num_test=test_samples,
input_shape=(input_dim,),
classification=True,
num_classes=num_class)
y_test = np_utils.to_categorical(y_test)
y_train = np_utils.to_categorical(y_train)
model = Sequential()
model.add(Dense(num_hidden, input_dim=input_dim, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
mode = 'max'
monitor = 'val_acc'
patience = 0
cbks = [callbacks.EarlyStopping(patience=patience, monitor=monitor, mode=mode)]
history = model.fit(X_train, y_train, batch_size=batch_size,
validation_data=(X_test, y_test), callbacks=cbks, epochs=20)
mode = 'auto'
monitor = 'val_acc'
patience = 2
cbks = [callbacks.EarlyStopping(patience=patience, monitor=monitor, mode=mode)]
history = model.fit(X_train, y_train, batch_size=batch_size,
validation_data=(X_test, y_test), callbacks=cbks, epochs=20)
def train():
print('Build model...')
model = Sequential()
model.add(Embedding(max_features, 128, input_length=maxlen, dropout=0.2))
model.add(LSTM(128, dropout_W=0.2, dropout_U=0.2)) # try using a GRU instead, for fun
model.add(Dense(1))
model.add(Activation('sigmoid'))
# try using different optimizers and different optimizer configs
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print('Train...')
print(X_train.shape)
print(y_train.shape)
model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=15,
validation_data=(X_test, y_test))
score, acc = model.evaluate(X_test, y_test,
batch_size=batch_size)
print('Test score:', score)
print('Test accuracy:', acc)
with open("save_weight_lstm.pickle", mode="wb") as f:
pickle.dump(model.get_weights(),f)
def create_model(x_train, y_train, x_test, y_test):
"""
Create your model...
"""
layer_1_size = {{quniform(12, 256, 4)}}
l1_dropout = {{uniform(0.001, 0.7)}}
params = {
'l1_size': layer_1_size,
'l1_dropout': l1_dropout
}
num_classes = 10
model = Sequential()
model.add(Dense(int(layer_1_size), activation='relu'))
model.add(Dropout(l1_dropout))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
model.fit(x_train, y_train, batch_size=128, epochs=10, validation_data=(x_test, y_test))
score, acc = model.evaluate(x_test, y_test, verbose=0)
out = {
'loss': -acc,
'score': score,
'status': STATUS_OK,
'model_params': params,
}
# optionally store a dump of your model here so you can get it from the database later
temp_name = tempfile.gettempdir()+'/'+next(tempfile._get_candidate_names()) + '.h5'
model.save(temp_name)
with open(temp_name, 'rb') as infile:
model_bytes = infile.read()
out['model_serial'] = model_bytes
return out
def imdb_lstm():
max_features = 20000
maxlen = 80 # cut texts after this number of words (among top max_features most common words)
batch_size = 32
(X_train, y_train), (X_test, y_test) = imdb.load_data(nb_words=max_features)
print type(X_train)
exit(0)
print len(X_train), 'train sequences'
print len(X_test), 'test sequences'
print('Pad sequences (samples x time)')
X_train = sequence.pad_sequences(X_train, maxlen=maxlen)
X_test = sequence.pad_sequences(X_test, maxlen=maxlen)
print('X_train shape:', X_train.shape)
print('X_test shape:', X_test.shape)
print('Build model...')
model = Sequential()
model.add(Embedding(max_features, 128, dropout=0.2))
model.add(LSTM(128, dropout_W=0.2, dropout_U=0.2)) # try using a GRU instead, for fun
model.add(Dense(1))
model.add(Activation('sigmoid'))
# try using different optimizers and different optimizer configs
model.compile(loss='binary_crossentropy', optimizer='adam',metrics=['accuracy'])
print('Train...')
model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=15,
validation_data=(X_test, y_test))
score, acc = model.evaluate(X_test, y_test, batch_size=batch_size)
print('Test score:', score)
print('Test accuracy:', acc)
def CNN_3_layer(activation):
Xtrain, ytrain, XCV, yCV, Xtest, ytest = load_data("mnist.pkl.gz")
Xtrain = Xtrain.reshape(Xtrain.shape[0], 1, 28, 28)
Xtest = Xtest.reshape(Xtest.shape[0], 1, 28, 28)
XCV = Xtest.reshape(XCV.shape[0], 1, 28, 28)
# 0~9 ten classes
ytrain = np_utils.to_categorical(ytrain, 10)
ytest = np_utils.to_categorical(ytest, 10)
yCV = np_utils.to_categorical(yCV, 10)
# Build the model
model = Sequential()
model.add(Convolution2D(32,3,3,border_mode='valid',input_shape=(1,28,28)))
model.add(Activation(activation))
model.add(Convolution2D(32,3,3))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Convolution2D(16,3,3))
model.add(Activation(activation))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation(activation))
model.add(Dropout(0.5))
model.add(Dense(10))
model.add(Activation('softmax'))
# fit module
print "fit module"
model.compile(loss='categorical_crossentropy',optimizer='adadelta',metrics=['accuracy'])
model.fit(Xtrain,ytrain,batch_size=100,nb_epoch=20,verbose=1,validation_data=(XCV,yCV))
score = model.evaluate(Xtest,ytest, verbose=0)
print score[0]
print score[1]
class MLP:
'''
[(output_dim, input_dim, init, activation, dropout)]
'''
def __init__(self\
, structure\
, sgd_params_init = sgd_params(0.1,1e-6,0.9,True)\
, loss_name = 'mean_squared_error'):
self.model = Sequential()
for layers in structure:
self.model.add(Dense(output_dim = layers.output_dim\
, input_dim = layers.input_dim\
, init = layers.init\
, activation = layers.activation))
if layers.dropout != None:
self.model.add(Dropout(layers.dropout))
sgd = SGD(lr = sgd_params_init.lr\
, decay = sgd_params_init.decay\
, momentum = sgd_params_init.momentum\
, nesterov = sgd_params_init.nesterov)
self.model.compile(loss = loss_name, optimizer = sgd)
def train(self, X_train, y_train, nb_epoch = 20, batch_size = 16):
self.model.fit(X_train, y_train, nb.epoch, batch_size)
def test(self, X_test, y_test, batch_size = 16):
return self.model.evaluate(X_test, y_test, batch_size)
def train_the_nn(features, label, look_back = 1):
model = Sequential()
model.add(Dense(8, input_dim=look_back, activation='relu'))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer = 'adam')
model.fit(features, label, nb_epoch=200, batch_size=2, verbose=2)
return model
def trainNN():
# POSITIVE training data
posPX, posSX = getAllWindowedMinMaxPositiveTrainingData('./sample/example30', preSize=10, postSize=20)
posPY = np.array([[1]] * len(posPX))
posSY = np.array([[1]] * len(posSX))
# NEGATIVE training data
negX = getSomeWindowedMinMaxNegativeTrainingData('./sample/example30/', size=30, num=200)
negY = np.array([[0]] * 200)
# ALL training data
X = np.concatenate([posPX, posSX, negX])
Y = np.concatenate([posPY, posSY, negY])
# 使用keras创建神经网络
# Sequential是指一层层堆叠的神经网络
# Dense是指全连接层
# 定义model
model = Sequential()
model.add(Dense(50, input_dim=30, activation='sigmoid'))
model.add(Dense(50, activation='sigmoid'))
model.add(Dense(10, activation='sigmoid'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
# model.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])
model.fit(X, Y, epochs=200, batch_size=32)
model.save('model.h5')
return model
def generateModel(self,docSeries):
topics = docSeries.topicSeries.keys()
seriesLength = 50
sequenceTuples = []
for j in range(len(topics)):
topic = topics[j]
topicLength = len(docSeries.topicSeries[topic])
for i in range(0,topicLength):
if i+seriesLength < topicLength:
sequenceTuples.append((docSeries.topicSeries[topic][i:i+seriesLength],j))
random.shuffle(sequenceTuples)
X = []
y = []
for s,l in sequenceTuples:
X.append(s)
y.append(l)
X = np.array(X).astype(np.uint8)
y = np_utils.to_categorical(np.array(y)).astype(np.bool)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.1)
print len(X_train),len(y_train)
print X.shape,y.shape
model = Sequential()
model.add(Embedding(50, 64, input_length = seriesLength, mask_zero = True))
model.add(LSTM(64,init='glorot_uniform',inner_init='orthogonal',activation='tanh',inner_activation='hard_sigmoid',return_sequences=False))
model.add(Dropout(0.5))
model.add(Dense(len(topics)))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', class_mode='categorical')
early_stopping = EarlyStopping(patience=5, verbose=1)
model.fit(X_train, y_train,nb_epoch=20,show_accuracy=True,verbose=1,shuffle=True)
preds = model.predict_classes(X_test, batch_size=64, verbose=0)
print '\n'
print(classification_report(np.argmax(y_test, axis=1), preds, target_names=topics))
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 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 model(X_train, X_test, Y_train, Y_test):
model = Sequential()
model.add(Dense(512, input_shape=(784,)))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense({{choice([400, 512, 600])}}))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense(10))
model.add(Activation('softmax'))
rms = RMSprop()
model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy'])
nb_epoch = 10
batch_size = 128
model.fit(X_train, Y_train,
batch_size=batch_size, nb_epoch=nb_epoch,
verbose=2,
validation_data=(X_test, Y_test))
score, acc = model.evaluate(X_test, Y_test, verbose=0)
return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def runNN(train_X, train_y, test_X, test_y=None):
#sc = preprocessing.StandardScaler()
#train_X = sc.fit_transform(train_X)
#test_X = sc.transform(test_X)
train_y = np_utils.to_categorical(train_y, 2)
model = Sequential()
model.add(Dense(train_X.shape[1], 100, init='he_uniform'))
model.add(Activation('relu'))
model.add(Dropout(0.2))
model.add(Dense(100, 50, init='he_uniform'))
model.add(Activation('relu'))
model.add(Dropout(0.4))
model.add(Dense(50, 25, init='he_uniform'))
model.add(Activation('relu'))
model.add(Dropout(0.4))
model.add(Dense(25, 2, init='he_uniform'))
model.add(Activation('softmax'))
#sgd_opt = SGD(lr=0.01)
model.compile(loss='binary_crossentropy', optimizer='adam')
model.fit(train_X, train_y, batch_size=256, nb_epoch=50, validation_split=0.05, verbose=2)
preds = model.predict(test_X, verbose=0)[:,1]
print preds[:10]
print "Test preds shape : ",preds.shape
print "ROC AUC score : ", metrics.roc_auc_score(test_y, preds)
def model(X_train, X_test, y_train, y_test, max_features, maxlen):
model = Sequential()
model.add(Embedding(max_features, 128, input_length=maxlen))
model.add(LSTM(128))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
early_stopping = EarlyStopping(monitor='val_loss', patience=4)
checkpointer = ModelCheckpoint(filepath='keras_weights.hdf5',
verbose=1,
save_best_only=True)
model.fit(X_train, y_train,
batch_size={{choice([32, 64, 128])}},
nb_epoch=1,
validation_split=0.08,
callbacks=[early_stopping, checkpointer])
score, acc = model.evaluate(X_test, y_test, verbose=0)
print('Test accuracy:', acc)
return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def get_ts_model( trainX, trainY, look_back = 1, nb_epochs = 100 ):
model = Sequential()
# takes input array of shape (*, 1) where (2,1) - (row,col) array example looks like [23]
# [43]
model.add(LSTM(20, input_shape=(None , look_back) ))
#model.add(LSTM(20, batch_input_shape=(None, None, look_back), return_sequences= True ))
#print(model.summary)
model.add( Dense(1) )
model.add(Dense(1))
model.add(Dense(1))
model.add(Dense(1))
model.add(Dense(1))
model.add(Dense(1))
#model.add(LSTM(1, return_sequences= True))
#model.add(LSTM(1))
# outputs array of shape (*,1)
#model.add(Dense(1))
#model.compile(loss='mean_absolute_error', optimizer='SGD') # mape
#model.compile(loss='poisson', optimizer='adam') # mape
model.compile( loss = 'mean_squared_error', optimizer = 'adam' ) # values closer to zero are better.
#model.compile(loss='mean_squared_error', optimizer='adagrad')
# Values of MSE are used for comparative purposes of two or more statistical meythods. Heavily weight outliers, i.e weighs large errors more heavily than the small ones.
# "In cases where this is undesired, mean absolute error is used.
# REF: Available loss functions https://keras.io/objectives.
print('Start : Training model')
# default configuration
model.fit(trainX, trainY, nb_epoch=nb_epochs, batch_size=1, verbose=2)
#model.fit(trainX, trainY, nb_epoch=100, batch_size=1, verbose=2)
print('Ends : Training Model')
return model
def f_nn(params):
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.optimizers import Adadelta, Adam, rmsprop
print ('Params testing: ', params)
model = Sequential()
model.add(Dense(output_dim=params['units1'], input_dim = X.shape[1]))
model.add(Activation(params['activation1']))
model.add(Dropout(params['dropout1']))
model.add(Dense(output_dim=params['units2'], init = "glorot_uniform"))
model.add(Activation(params['activation2']))
model.add(Dropout(params['dropout2']))
if params['choice']['layers']== 'three':
model.add(Dense(output_dim=params['choice']['units3'], init = "glorot_uniform"))
model.add(Activation(params['choice']['activation3']))
model.add(Dropout(params['choice']['dropout3']))
model.add(Dense(2))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy', optimizer=params['optimizer'])
model.fit(X, y, nb_epoch=params['nb_epochs'], batch_size=params['batch_size'], verbose = 1)
pred_auc =model.predict_proba(X_val, batch_size = 128, verbose = 1)
acc = log_loss(y_val, pred_auc)
print("\n")
print('logloss:', acc)
sys.stdout.flush()
return {'loss': acc, 'status': STATUS_OK}
def model(X_train, Y_train, X_test, Y_test):
'''
Model providing function:
Create Keras model with double curly brackets dropped-in as needed.
Return value has to be a valid python dictionary with two customary keys:
- loss: Specify a numeric evaluation metric to be minimized
- status: Just use STATUS_OK and see hyperopt documentation if not feasible
The last one is optional, though recommended, namely:
- model: specify the model just created so that we can later use it again.
'''
model = Sequential()
model.add(Dense(512, input_shape=(784,)))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense({{choice([256, 512, 1024])}}))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense(10))
model.add(Activation('softmax'))
rms = RMSprop()
model.compile(loss='categorical_crossentropy', optimizer=rms, metrics=['accuracy'])
model.fit(X_train, Y_train,
batch_size={{choice([64, 128])}},
nb_epoch=1,
verbose=2,
validation_data=(X_test, Y_test))
score, acc = model.evaluate(X_test, Y_test, verbose=0)
print('Test accuracy:', acc)
return {'loss': -acc, 'status': STATUS_OK, 'model': model}
def evaluate(lr, pos):
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = (X_train.astype("float32")).reshape((60000, 784))
X_test = (X_test.astype("float32")).reshape((10000, 784))
X_train /= 255
X_test /= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)
model = Sequential()
model.add(Dense(output_dim=layer1, input_dim=784))
if pos == 0:
model.add(BatchNormalization())
model.add(Activation("relu"))
model.add(Dense(output_dim=layer2, input_dim=layer1))
if pos == 1:
model.add(BatchNormalization())
model.add(Activation("relu"))
model.add(Dense(output_dim=10, input_dim=layer2))
if pos == 2:
model.add(BatchNormalization())
model.add(Activation("softmax"))
model.compile(
loss="categorical_crossentropy", optimizer=SGD(lr=lr, momentum=0.9, nesterov=True), metrics=["accuracy"]
)
model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_data=(X_test, Y_test))
score = model.evaluate(X_test, Y_test, verbose=0)
return score[1]
def ann(self):
#print self.company.X_train.shape[1]
model = Sequential()
model.add(Dense(input_dim=self.search_inputs.X_train.shape[1], output_dim=10, init="glorot_uniform"))
model.add(Activation('tanh'))
model.add(Dropout(0.1))
model.add(Dense(input_dim=10, output_dim=10, init="uniform"))
model.add(Activation('tanh'))
model.add(Dropout(0.5))
model.add(Dense(input_dim=10, output_dim=1, init="glorot_uniform"))
model.add(Activation("linear"))
sgd = SGD(lr=0.3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='mean_squared_error', optimizer='sgd')
early_stopping = EarlyStopping(monitor='val_loss', patience=25)
#epoch_score = model.evaluate(X_score, y_score, batch_size = 16) # this doesn't work
# first model
print "fitting first model"
model.fit(self.search_inputs.X_train, self.search_inputs.y_train, nb_epoch=100, validation_split=.1, batch_size=100, verbose = 1, show_accuracy = True, shuffle = True, callbacks=[early_stopping])
#score = model.evaluate(self.company.X_cv, self.company.y_cv, show_accuracy=True, batch_size=16)
self.ann_preds = model.predict(self.search_inputs.X_test)
#just in case (like w/ svr)
for i in range(0,len(self.ann_preds) - 1):
if self.ann_preds[i] < 1:
self.ann_preds[i] = 1.00
elif self.ann_preds[i] > 3:
self.ann_preds[i] = 3.00
self.search_inputs.fin_df['relevance'] = np.array(self.ann_preds) # easy swap in / out
final_file_ann = self.search_inputs.fin_df.to_csv(self.fin_file_name+'_ann.csv', float_format='%.5f', index=False)
def OptKeras(h1, h2, h3, d1, d2, d3, d4, ne):
model = Sequential()
model.add(Dense(dims, h1, init='glorot_uniform'))
model.add(PReLU((h1,)))
model.add(BatchNormalization((h1,)))
model.add(Dropout(d1))
model.add(Dense(h1, h2, init='glorot_uniform'))
model.add(PReLU((h2,)))
model.add(BatchNormalization((h2,)))
model.add(Dropout(d2))
model.add(Dense(h2, h3, init='glorot_uniform'))
model.add(PReLU((h3,)))
model.add(BatchNormalization((h3,)))
model.add(Dropout(d3))
model.add(Dense(h3, nb_classes, init='glorot_uniform'))
model.add(Activation('softmax'))
sgd = SGD(lr = 0.1, decay = 1e-6, momentum = 0.9, nesterov = True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)
print("Training model...kkk")
model.fit(X, y, nb_epoch = ne, batch_size=1024, validation_split=0.2)
def test_LambdaCallback():
np.random.seed(1337)
(X_train, y_train), (X_test, y_test) = get_test_data(num_train=train_samples,
num_test=test_samples,
input_shape=(input_dim,),
classification=True,
num_classes=num_class)
y_test = np_utils.to_categorical(y_test)
y_train = np_utils.to_categorical(y_train)
model = Sequential()
model.add(Dense(num_hidden, input_dim=input_dim, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
# Start an arbitrary process that should run during model training and be terminated after training has completed.
def f():
while True:
pass
p = multiprocessing.Process(target=f)
p.start()
cleanup_callback = callbacks.LambdaCallback(on_train_end=lambda logs: p.terminate())
cbks = [cleanup_callback]
model.fit(X_train, y_train, batch_size=batch_size,
validation_data=(X_test, y_test), callbacks=cbks, epochs=5)
p.join()
assert not p.is_alive()
class MotifScoreRNN(Model):
def __init__(self, input_shape, gru_size=10, tdd_size=4):
self.model = Sequential()
self.model.add(GRU(gru_size, return_sequences=True,
input_shape=input_shape))
if tdd_size is not None:
self.model.add(TimeDistributedDense(tdd_size))
self.model.add(Flatten())
self.model.add(Dense(1))
self.model.add(Activation('sigmoid'))
print('Compiling model...')
self.model.compile(optimizer='adam', loss='binary_crossentropy')
def train(self, X, y, validation_data):
print('Training model...')
multitask = y.shape[1] > 1
if not multitask:
num_positives = y.sum()
num_sequences = len(y)
num_negatives = num_sequences - num_positives
self.model.fit(
X, y, batch_size=128, nb_epoch=100,
validation_data=validation_data,
class_weight={True: num_sequences / num_positives,
False: num_sequences / num_negatives}
if not multitask else None,
callbacks=[EarlyStopping(monitor='val_loss', patience=10)],
verbose=True)
def predict(self, X):
return self.model.predict(X, batch_size=128, verbose=False)
def train_model():
# (X_train, Y_train, X_test, Y_test) = prapare_train()
X_ = []
with open('../data/train_matrix.out') as train_file:
X_train = json.load(train_file)
for x in X_train:
a = len(x)
print a/2
x1 = x[:a/2]
x2 = x[a/2:]
x3 = []
x3.append(x1)
x3.append(x2)
X_.append(x3)
# X_test = pickle.load('../data/test_matrix.out')
Y_train = [1,0,0]*3
# Y_test = [1,0,0]*3
# print len(X_train) - len(Y_train)
# print len(X_test) - len(Y_test)
model = Sequential()
model = get_nn_model()
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# model.fit(X_train, Y_train,
# batch_size=batch_size,
# nb_epoch=nb_epoch,
# validation_data=(X_test, Y_test))
#2
model.fit(X_, Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
validation_split = 0.2)
print 'ok'
def model(X_train, Y_train, X_test, Y_test):
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.optimizers import RMSprop
model = Sequential()
model.add(Dense(512, input_shape=(784,)))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense({{choice([256, 512, 1024])}}))
model.add(Activation('relu'))
model.add(Dropout({{uniform(0, 1)}}))
model.add(Dense(10))
model.add(Activation('softmax'))
rms = RMSprop()
model.compile(loss='categorical_crossentropy', optimizer=rms)
model.fit(X_train, Y_train,
batch_size={{choice([64, 128])}},
nb_epoch=1,
show_accuracy=True,
verbose=2,
validation_data=(X_test, Y_test))
score = model.evaluate(X_test, Y_test,
show_accuracy=True, verbose=0)
print('Test accuracy:', score[1])
return {'loss': -score[1], 'status': STATUS_OK}
def lstm(trainData, trainMark, testData, embedding_dim, embedding_matrix, maxlen, output_len):
# 填充数据，将每个序列长度保持一致
trainData = list(sequence.pad_sequences(trainData, maxlen=maxlen,
dtype='float64')) # sequence返回的是一个numpy数组，pad_sequences用于填充指定长度的序列，长则阶段，短则补0，由于下面序号为0时，对应值也为0，因此可以这样
testData = list(sequence.pad_sequences(testData, maxlen=maxlen,
dtype='float64')) # sequence返回的是一个numpy数组，pad_sequences用于填充指定长度的序列，长则阶段，短则补0
# 建立lstm神经网络模型
model = Sequential() # 多个网络层的线性堆叠，可以通过传递一个layer的list来构造该模型，也可以通过.add()方法一个个的加上层
# model.add(Dense(256, input_shape=(train_total_vova_len,))) #使用全连接的输入层
model.add(Embedding(len(embedding_matrix), embedding_dim, weights=[embedding_matrix], mask_zero=False,
input_length=maxlen)) # 指定输入层，将高维的one-hot转成低维的embedding表示，第一个参数大或等于0的整数，输入数据最大下标+1，第二个参数大于0的整数，代表全连接嵌入的维度
# lstm层，也是比较核心的层
model.add(LSTM(256)) # 256对应Embedding输出维度，128是输入维度可以推导出来
model.add(Dropout(0.5)) # 每次在参数更新的时候以一定的几率断开层的链接，用于防止过拟合
model.add(Dense(output_len)) # 全连接，这里用于输出层，1代表输出层维度，128代表LSTM层维度可以自行推导出来
model.add(Activation('softmax')) # 输出用sigmoid激活函数
# 编译该模型，categorical_crossentropy（亦称作对数损失，logloss），adam是一种优化器，class_mode表示分类模式
model.compile(loss='categorical_crossentropy', optimizer='sgd')
# 正式运行该模型,我知道为什么了，因为没有补0！！每个array的长度是不一样的，因此才会报错
X = np.array(list(trainData)) # 输入数据
print("X:", X)
Y = np.array(list(trainMark)) # 标签
print("Y:", Y)
# batch_size：整数，指定进行梯度下降时每个batch包含的样本数
# nb_epoch：整数，训练的轮数，训练数据将会被遍历nb_epoch次
model.fit(X, Y, batch_size=200, nb_epoch=10) # 该函数的X、Y应该是多个输入：numpy list(其中每个元素为numpy.array)，单个输入：numpy.array
# 进行预测
A = np.array(list(testData)) # 输入数据
print("A:", A)
classes = model.predict(A) # 这个是预测的数据
return classes
def dnn_class(X_train,y_train,X_test,y_test):
model=Sequential()
model.add(Dense(1000,input_dim=1583,kernel_initializer="glorot_uniform",activation="relu"))
model.add(BatchNormalization())
model.add(Dense(1000,kernel_initializer="glorot_uniform",activation="relu"))
model.add(BatchNormalization())
# =============================================================================
# model.add(Dropout(0.6))
# =============================================================================
model.add(Dense(1,activation="sigmoid",kernel_initializer="glorot_uniform"))
adam=Adam(lr=0.01) # model.add(Dense(units=1,activation="relu",kernel_initializer="glorot_uniform"))
sgd=SGD(lr=0.01, momentum=0.01, decay=0.0, nesterov=True)
rms=RMSprop(lr=0.005)
model.compile(optimizer=adam,loss="binary_crossentropy",metrics=["accuracy"])
callbacks=[EarlyStopping(monitor='val_loss', patience=2),
ModelCheckpoint(filepath='best_model.h5', monitor='val_loss', save_best_only=True)]
print(model.summary())
model.fit(X_train,y_train,batch_size=4,epochs=50,verbose=1,callbacks=callbacks,validation_data=(X_test,y_test))
pkl_filename = "keras_model.joblib"
with open(pkl_filename, 'wb') as file:
joblib.dump(model, file)
y_pred=model.predict_classes(X_test)
print(y_pred)
evaluation2(y_test,y_pred,model,X_test,X_train,y_train)
