def train_model(train_test_path):
"""
Creates a model and performs training.
"""
# Load train/test data
train_test_data = np.load(train_test_path)
x_train = train_test_data['X_train']
y_train = train_test_data['y_train']
print("x_train:", x_train.shape)
print("y_train:", y_train.shape)
del train_test_data
x_train = np.expand_dims(x_train, axis=3)
# Create network
model = Sequential()
model.add(Conv1D(128, 5, input_shape=x_train.shape[1:], padding='same', activation='relu'))
model.add(MaxPooling1D(5))
model.add(Conv1D(128, 5, padding='same', activation='relu'))
model.add(MaxPooling1D(5))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(1024, kernel_initializer='glorot_uniform', activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(512, kernel_initializer='glorot_uniform', activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(256, kernel_initializer='glorot_uniform', activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(128, kernel_initializer='glorot_uniform', activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(len(language_codes), kernel_initializer='glorot_uniform', activation='softmax'))
model_optimizer = keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0.0)
model.compile(loss='categorical_crossentropy', optimizer=model_optimizer, metrics=['accuracy'])
# Train
model.fit(x_train, y_train,
epochs=10,
validation_split=0.10,
batch_size=64,
verbose=2,
shuffle=True)
model.save(model_path)
print(Training_img)
model = Sequential()
model.add(Conv2D(
input_shape=(100,100,3),
filters=32,
kernel_size=(5,5),
padding="same"
))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2),strides=(2,2)))
model.add(Conv2D(filters=64,kernel_size=(2,2),padding="same"))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2,2),strides=(2,2)))#output_shape=(25,25,64)
model.add(Flatten())
model.add(Dense(1024))
model.add(Activation("relu"))
model.add(Dense(512))
model.add(Activation("relu"))
model.add(Dense(256))
model.add(Activation("relu"))
model.add(Dense(4))
model.add(Activation("softmax"))
adam=Adam(lr=0.0001)
model.compile(optimizer=adam,loss='categorical_crossentropy',metrics=['accuracy'])
model.fit(x=Training_img,y=Training_label,epochs=number_batch,batch_size=batch_size,verbose=1)
model.save("./fruitfinder.h5")
]
dia_norm = diabetes.copy()
dia_norm[cols_to_norm] = diabetes[cols_to_norm].apply(lambda x: (x - x.min()) /
(x.max() - x.min()))
x = dia_norm.drop(columns='Outcome')
y = dia_norm['Outcome']
X_train, X_test, y_train, y_test = train_test_split(x,
y,
test_size=0.33,
random_state=42)
model = Sequential()
model.add(Dense(12, input_dim=8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.fit(X_train, y_train, epochs=500, batch_size=100)
_, accuracy = model.evaluate(X_train, y_train)
predictions = model.predict(X_test)
rounded = [round(x[0]) for x in predictions]
pred = np.array(rounded)
count = 0
for i, j in zip(pred, y_test):
if i == j:
count += 1
print(count / y_test.size)
model.save('diabetes-model.h5')
if os.path.exists('LeNet_origin_lr=%f.h5' % lr):
model = load_model('LeNet_origin_lr=%f.h5' % lr)
sgd = SGD(lr=lr, decay=1e-5, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(
train_x,
train_y,
batch_size=128,
epochs=EPOCH,
verbose=1,
validation_split=0.05,
callbacks=[TensorBoard(log_dir='./log/LeNet_origin_lr=%f.h5' % lr)])
model.save('LeNet_origin_lr=%f.h5' % lr)
del (model)
gc.collect
for bs in BS:
model = Sequential()
model.add(
Conv2D(filters=6,
kernel_size=(5, 5),
activation='relu',
padding='valid',
name='C1',
input_shape=LENET_INPUT_SHAPE))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='P1'))
model.add(
Conv2D(filters=16,
def create_model(X, y, it=1, no_of_filters=32, kern_size=3,
max_p_size=3, drop_perc_conv=0.3, drop_perc_dense=0.2,
dens_size=128, val_split_perc=0.1, no_of_epochs=30,
optimizer="adam", random_search=False, batch_size=64):
"""Creates an architecture, train and saves CNN model.
Returns:
Dictionary with training report history.
"""
y_train_cat = to_categorical(y)
model = Sequential()
model.add(Conv2D(no_of_filters,
kernel_size=(kern_size, kern_size),
activation='relu',
input_shape=(56, 56, 1),
padding='same'))
model.add(Conv2D(no_of_filters,
kernel_size=(kern_size, kern_size),
activation='relu',
padding='same'))
model.add(MaxPooling2D((max_p_size, max_p_size)))
model.add(Dropout(drop_perc_conv))
model.add(Conv2D(no_of_filters,
kernel_size=(kern_size, kern_size),
activation='relu',
padding='same'))
model.add(Conv2D(no_of_filters,
kernel_size=(kern_size, kern_size),
activation='relu',
padding='same'))
model.add(MaxPooling2D((max_p_size, max_p_size)))
model.add(Dropout(drop_perc_conv))
model.add(Flatten())
model.add(Dense(dens_size, activation='relu'))
model.add(Dropout(drop_perc_dense))
model.add(Dense(36, activation='softmax'))
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
early_stopping_monitor = EarlyStopping(patience=5)
rlrop = ReduceLROnPlateau(monitor='val_acc', factor=0.5,
patience=3, verbose=1, min_lr=0.00001)
history = model.fit(X,
y_train_cat,
validation_split=val_split_perc,
epochs=no_of_epochs,
callbacks=[early_stopping_monitor, rlrop],
batch_size=batch_size)
history_dict = history.history
if random_search:
np.save(r"./models/random_search/hist/history_dict_{}.npy".format(it),
history_dict)
model.save(r"./models/random_search/models/CNN_{}.h5".format(it))
else:
np.save(r"./logs/history_dict_{}.npy".format(it), history_dict)
model.save(r"./models/CNN_FF_{}.h5".format(it))
return history_dict
model.add(Convolution2D(64, 2, 2, border_mode="same"))
model.add(Activation("relu"))
model.add(MaxPooling2D(pool_size=(2, 2), dim_ordering='th'))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation("relu"))
model.add(Dropout(0.5))
model.add(Dense(5, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.RMSprop(lr=0.0004),
metrics=['accuracy'])
train_datagen = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(base_dir,
target_size=(img_height,
img_width),
batch_size=batch_size,
class_mode='categorical')
model.fit_generator(train_generator, samples_per_epoch=1000, epochs=50)
model.save('50_model.h5')
model.save_weights('50_weights.h5')
def create_model(structure_id, model_name, classes, max_epochs, train_tweets,
train_labels, validate_tweets, validate_labels):
model = Sequential()
if structure_id == 0:
binary = True
model.add(GaussianNoise(0.1, input_shape=(140, input_len)))
model.add(Conv1D(8, 3, activation="relu"))
model.add(Dropout(0.3))
model.add(Conv1D(8, 3, activation="relu"))
model.add(Dropout(0.3))
model.add(Conv1D(8, 3, activation="relu"))
model.add(Dropout(0.3))
model.add(Bidirectional(GRU(6, recurrent_dropout=0.5)))
model.add(Dropout(0.3))
if binary:
model.add(Dense(1, activation="sigmoid"))
model.compile(loss="binary_crossentropy",
optimizer="adam",
metrics=["accuracy"])
else:
model.add(Dense(len(classes), activation="softmax"))
model.compile(loss="categorical_crossentropy",
optimizer="adam",
metrics=["accuracy"])
losses = []
if binary:
train_outputs = train_labels
validate_outputs = validate_labels
else:
train_outputs = to_categorical(train_labels)
validate_outputs = to_categorical(validate_labels)
bestLoss = inf
step = 0
i = 0
if balanced:
train_weights = class_weight.compute_class_weight(
"balanced", np.unique(train_labels), train_labels)
validate_weights = class_weight.compute_class_weight(
"balanced", np.unique(validate_labels), validate_labels)
sample_weights = []
print(train_weights)
print(validate_weights)
for lable in validate_labels:
sample_weights.append(validate_weights[lable])
sample_weights = np.array(sample_weights)
else:
train_weights = None
got_worse = 0
best_train_weights = train_weights.copy()
while step < max_epochs and i < 130 and got_worse < tollerance:
i += 1
step += 0
train_sample_weights = []
print(train_weights)
print(validate_weights)
for lable in train_labels:
train_sample_weights.append(best_train_weights[lable])
train_sample_weights = np.array(train_sample_weights)
print(best_train_weights)
model.fit(np.array(train_tweets),
np.array(train_outputs),
epochs=1,
batch_size=16,
sample_weight=train_sample_weights)
loss = model.evaluate(np.array(validate_tweets),
np.array(validate_outputs),
sample_weight=sample_weights)[0]
losses += [loss]
if loss > bestLoss:
got_worse += 1
else:
if loss < bestLoss:
model.save("../models/" + model_name)
bestLoss = loss
got_worse = 0
print(step, loss, bestLoss)
predictions = model.predict(np.array(validate_tweets))
get_weight_multipliers(predictions, validate_labels)
def neuralnet(filename):
df = pd.read_csv(filename, header=None)
with open("tokeniser.pickle", "rb") as input1:
tokenizer = pickle.load(input1)
###### WARNING ######
# ast.literal_eval() is a DANGEROUS function since it can result in arbitary
# code execution. I may try to remove code later down the track, but since
# we are dealing with data that doesn't contain code it is safe.
# TODO: Change from csv to pickle
X = [ast.literal_eval(x) for x in tqdm(df[df.columns[1]].values)]
Y = [ast.literal_eval(x) for x in tqdm(df[df.columns[0]].values)]
training_size = 0.8
max_words = 16
X_train = sequence.pad_sequences(X[:int(training_size * len(X))],
maxlen=max_words)
X_test = sequence.pad_sequences(X[-int((1 - training_size) * len(X)):],
maxlen=max_words)
Y_train = sequence.pad_sequences(Y[:int(training_size * len(Y))], maxlen=1)
Y_test = sequence.pad_sequences(Y[-int((1 - training_size) * len(Y)):],
maxlen=1)
embedding_size = 32
model = Sequential()
model.add(
Embedding(len(tokenizer.word_index.items()) + 1,
embedding_size,
input_length=max_words))
model.add(LSTM(100))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
batch_size = 300
num_epochs = 20
X_valid, y_valid = X_train[:batch_size], Y_train[:batch_size]
X_train2, y_train2 = X_train[batch_size:], Y_train[batch_size:]
filepath = "sentiment-ai-{epoch:02d}-{val_acc:.2f}.hdf5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_acc',
verbose=1,
save_best_only=False,
mode='max')
callbacks_list = [checkpoint]
model.fit(X_train2,
y_train2,
validation_data=(X_valid, y_valid),
batch_size=batch_size,
epochs=num_epochs,
callbacks=callbacks_list)
model.save("my-model.hdf5")
return 0
epochs = 5 #训练5次
model1.summary() #模型输出
model1.compile(
loss='sparse_categorical_crossentropy', #模型编译
optimizer='adam',
metrics=['accuracy'])
#从训练集中抽取0.2进行验证
history = model1.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_split=0.2)
#-----------------------------------------------保存模型，可视化--------------------------
#保存模型
model1.save('model_CNN_text.h5')
#模型可视化
plot_model(model1, to_file='model_CNN_text.png', show_shape=True)
#加载模型
model = load_model('model_CNN_text.h5')
y_new = model.predict(x_train[0].reshape(1, 50))
#训练结果可视化
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('Model accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend(['Train', 'Valid'], loc='upper left')
plt.savefig('Valid_acc.png')
plt.show()
def create_class_weight(labels_dict, mu=0.1):
total = np.sum([i for i in labels_dict.values()])
keys = labels_dict.keys()
class_weight = dict()
for key in keys:
score = math.log((mu * total) / float(labels_dict[key]))
math.log(mu)
class_weight[key] = score if score > 1.0 else 1.0
return class_weight
labels_dict = {0: 37000, 1: 18871, 2: 11132, 3: 6062, 4: 4089, 5: 3496, 6: 677, 7: 583
, 8: 378, 9: 44}
labels_dict_train ={0: 56000, 1: 40000, 2: 33393, 3: 18184, 4: 12264, 5: 10491, 6: 2000, 7: 1746
,8:1133,9:130}
class_weight_dict = create_class_weight(labels_dict_train)
history = model.fit(train_70_x, train_70_y,validation_data=(train_30_x,train_30_y),batch_size=4096, epochs=50)
model.save('my_model4.h5')
loss, accuracy = model.evaluate(x_test, y_test2)
pre_y = model.predict_classes(x_test)
y_test = np.array(y_test)
metrics = classification_report(y_test, pre_y)
print(metrics)
confusion_m = confusion_matrix(y_test, pre_y)
y_pred_pro = model.predict_proba(x_test)[:, 1]
fpr, tpr, thresholds = roc_curve(y_test, y_pred_pro, pos_label=1)
roc_auc = auc(fpr, tpr)
mat_plt(history)
plot_confusion_matrix(confusion_m)
roc(fpr, tpr, roc_auc)
model.save('my_modelm.h5')
def fpr_tpr(confusion_m):
sum = 0
model.add(Activation('relu'))
model.add(Conv2D(16, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(32, 3, 3, border_mode='same'))
model.add(Activation('relu'))
model.add(Conv2D(32, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(256))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(2))
model.add(Activation('softmax'))
model.summary()
model.build(input_shape=(500, 500, 1))
model.compile(optimizer='adam',
loss="categorical_crossentropy",
metrics=['accuracy'])
model.fit(x, y, steps_per_epoch=2, epochs=30)
model.save("first.h5")
# recognizer.train(x_train,np.array(y_labels))
# recognizer.save("trainner.yml")
def train_cifar10(batch_size: int,
learning_rate: float,
epochs: int,
experiment: Experiment,
model: Sequential = get_model(),
initial_epoch: int = 0,
training_datagen: ImageDataGenerator = ImageDataGenerator(),
scheduler: Callable[[int], float] = None,
early_stopping_th: Optional[int] = 250,
data_portion: float = 1.0,
find_lr: bool = False) -> None:
preprocessing_fnc = training_datagen.preprocessing_function
name = experiment.get_key()
log_path, model_path = get_output_paths(name)
data = get_cifar10_data(data_portion=data_portion)
training_datagen.fit(data.x_train)
log_images(data.x_train, training_datagen, experiment)
log_input_images(data.x_train, data.y_train, training_datagen, experiment)
opt = Adam(lr=learning_rate)
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
log_model_plot(experiment, model)
csv_cb = CSVLogger(log_path)
keep_best_cb = KeepBest('val_acc')
callbacks = [csv_cb,
keep_best_cb] # [csv_cb, early_stopping_cb, keep_best_cb]
if early_stopping_th is not None:
early_stopping_cb = EarlyStopping('val_acc',
patience=early_stopping_th,
restore_best_weights=True,
verbose=2)
callbacks.append(early_stopping_cb)
if scheduler is not None:
scheduler.experiment_log(experiment=experiment,
epochs=list(range(epochs)))
callbacks.append(LearningRateScheduler(scheduler))
if find_lr:
lrf = LearningRateFinder(model=model)
lrf.lrMult = (10e-1 / learning_rate)**(
1.0 / (epochs * len(data.x_train) / batch_size))
callbacks = [
LambdaCallback(
on_batch_end=lambda batch, logs: lrf.on_batch_end(batch, logs))
]
model.fit_generator(training_datagen.flow(data.x_train,
data.y_train,
batch_size=batch_size),
steps_per_epoch=len(data.x_train) / batch_size,
epochs=epochs,
validation_data=(preprocessing_fnc(data.x_dev),
data.y_dev),
shuffle=True,
callbacks=callbacks,
verbose=2,
initial_epoch=initial_epoch)
model.save(model_path)
experiment.log_asset(model_path)
experiment.log_asset(log_path)
if find_lr:
experiment.log_figure('lr vs acc', lrf.plot_loss())
log_final_metrics(experiment, model, data, preprocessing_fnc)
model.add(LSTM(64, return_sequences=True))
model.add(LSTM(64, return_sequences=False))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
print(model.summary())
# Split train and validation set (e.g: 10000 dataset -> 8000 train, 1000 validation, 1000 test)
train_valtest = 0.8
val_test = 0.5
train_x, train_y = train_X[:int(train_valtest*len(train_X))], train_Y[:int(train_valtest*len(train_Y))]
valtest_x, valtest_y = train_X[int(train_valtest*len(train_X)):], train_Y[int(train_valtest*len(train_Y)):]
val_x, val_y = valtest_x[:int(val_test*len(valtest_x))], valtest_y[:int(val_test*len(valtest_y))]
test_x, test_y = valtest_x[int(val_test*len(valtest_x)):], valtest_y[int(val_test*len(valtest_y)):]
model.fit(train_x, train_y, validation_data = (val_x, val_y), epochs=10, verbose=1)
scores = model.evaluate(test_x, test_y, verbose=0)
print('Test on %d samples' %len(test_x))
print('Test accuracy: %.2f%%' % (scores[1]*100))
model.save(getcwd()+'/GloVe-LSTM_model.h5')
print('Model saved to '+getcwd()+'/GloVe-LSTM_model.h5')
print("Total training time: %s seconds" % (time.time() - start_time))
from keras import Sequential
from keras.layers import LSTM, Dense, Activation, Dropout
from data_transformD import scaler, train_X, train_Y, test_X, test_Y
import matplotlib.pyplot as plt
from numpy import concatenate
from math import sqrt
from sklearn.metrics import mean_squared_error
model = Sequential()
model.add(LSTM(50, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(Dense(1))
model.compile(loss='mae', optimizer='adam')
History = model.fit(train_X,
train_Y,
epochs=100,
batch_size=64,
validation_data=(test_X, test_Y))
model.save("model/expModelD.h5")
plt.plot(History.history['loss'], label='train')
plt.plot(History.history['val_loss'], label='test')
plt.legend()
plt.show()
# model.add(Activation('relu'))
# model.add(MaxPooling2D(pool_size=(2, 2)))
# model.add(Dropout(0.25))
#
# model.add(Conv2D(64, (3, 3), padding='same'))
# model.add(Activation('relu'))
# model.add(Conv2D(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(4, activation="softmax"))
opt = keras.optimizers.RMSprop(lr=0.0001, decay=1e-6)
model.compile(optimizer=opt,
loss="categorical_crossentropy",
metrics=["accuracy"])
# model.compile(optimizer=opt,loss="sparse_categorical_crossentropy" ,metrics=["accuracy"])
model.fit(train_data_img, train_data_label, epochs=30, batch_size=20)
model.save("E:/sperm_image/HuSHem/model.h5")
for i in test_data_img:
i = np.expand_dims(i, 0)
result = model.predict(i)
print(result)
print(test_data_label)
def alex_net(x_train, y_train, x_test, y_test):
y_train = keras.utils.to_categorical(y_train, num_classes=flower_types)
y_test = keras.utils.to_categorical(y_test, num_classes=flower_types)
model = Sequential()
model.add(
Conv2D(96, (11, 11),
strides=(4, 4),
input_shape=(image_size, image_size, 3),
padding='valid',
activation='relu',
kernel_initializer='uniform'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Dropout(0.25))
model.add(
Conv2D(256, (5, 5),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Dropout(0.25))
model.add(
Conv2D(384, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
model.add(
Conv2D(384, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
model.add(
Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(flower_types, activation='softmax'))
sgd = SGD(lr=1e-2, decay=1e-9)
model.compile(loss='categorical_crossentropy',
optimizer=sgd,
metrics=['accuracy'])
history = model.fit(x_train,
y_train,
validation_split=0.1,
batch_size=100,
epochs=epochs)
loss, acc = model.evaluate(x_test, y_test, batch_size=50)
print('loss is {:.4f}'.format(loss) +
', acc is {:.2f}%\n'.format(acc * 100))
model_name = 'result/alex_model_epoch' + str(epochs) + '_' + str(
round(acc * 100, 2)) + '.h5'
model.save(model_name)
save_history(history, 'result', str(round(acc * 100, 2)))
# 清除session
keras.backend.clear_session()
return model_name
# model.add(Dropout(0.5))
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(100, activation='relu'))
model.add(Dropout(0.25))
# Output Layer
model.add(Dense(units=len(class_names), activation='softmax'))
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
history = LossHistory()
model.fit(x=x_train,
y=y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
callbacks=[history])
model.save('my_model_0.h5')
score = model.evaluate(x_test, y_test, verbose=1)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
history.loss_plot('epoch')
def __len__(self):
return self.X.shape[0]
def __getitem__(self, idx):
return {"X": self.X[idx], "Y": self.Y[idx]}
chess_dataset = ChessValueDataset()
num_classes = 128
model = Sequential()
input_shape = 5, 8, 8
model.add(Conv2D(16, kernel_size=(3, 3), activation="relu", input_shape=input_shape, padding="same"))
model.add(Conv2D(32, kernel_size=(3, 3), activation="relu", padding="same"))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dropout(0.3))
model.add(Dense(num_classes, activation="softmax"))
model.compile()
model.summary()
model.fit(x=X, y=y)
model.save("nets/value.pth")
print(labels[193:])
model = Sequential()
model.add(Conv2D(128, (3,3), activation="relu", input_shape=(128,128,3)))
model.add(MaxPooling2D(2,2))
model.add(Conv2D(256, (3,3), activation="relu"))
model.add(MaxPooling2D(2,2))
model.add(Conv2D(256, (3,3), activation="relu"))
model.add(MaxPooling2D(2,2))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dense(n, activation="softmax"))
model.compile(optimizer="adam", loss = keras.losses.SparseCategoricalCrossentropy(from_logits=True) , metrics=["acc"])
model.fit(train, labels, epochs=epochs, validation_data = (X_test, y_test))
model.save("model.h5")
score = model.evaluate(X_test, y_test)
print("Total Accuracy : ", score[1])
print("Successfully...")
print("Please Run python Real_Time.py")
X_test = X_test.reshape(-1,96,96)
print("X_test", X_test.shape)
model = Sequential()
# x = (7049,96,96)
# y = (7049,30)
model.add(Flatten(input_shape= (96,96)))
model.add(Dense(128,activation = "relu"))
model.add(Dropout(0.1))
model.add(Dense(64,activation = "relu"))
model.add(Dense(30))
model.compile(optimizer = 'adam',
loss = 'mse',
metrics = ['mae','accuracy'])
model.fit(X_train,y_train,epochs = 50, batch_size = 128,validation_split = 0.2)
model.save('model.h5')
json_string = model.to_json()
model = model_from_json(json_string)
model.load_weights('model.h5',by_name = True)
model.load_model('model.h5')
def loaded_model():
model = load_model('model.h5')
return model
def show_results(images_index):
pred = model.predict(X_test[images_index:(images_index+1)])
show_images(X_test[images_index], pred[0])
show_images(3)
metrics=['accuracy'])
history = model.fit(train_data,
train_labels_one_hot,
batch_size=256,
epochs=20,
verbose=1,
validation_data=(test_data, test_labels_one_hot))
[test_loss, test_acc] = model.evaluate(test_data, test_labels_one_hot)
print("Evaluation result on Test Data : Loss = {}, accuracy = {}".format(
test_loss, test_acc))
#model.load_weights("mnist-model.h5")
#model.fit(train_x,train_y,batch_size=32,epochs=10,verbose=1)
model.save("mnistmodel.h5")
model.load_weights("mnistmodel.h5")
#model.predict(test_data[23],)
img = test_data[112]
test_img = img.reshape((1, 784))
img_class = model.predict_classes(test_img)
prediction = img_class[0]
classname = img_class[0]
print("Class: ", classname)
img = img.reshape((28, 28))
plt.imshow(img)
plt.title(classname)
plt.show()
print(history)
# Plot training & validation accuracy values
model.add(Dense(500, activation='relu'))
model.add(BatchNormalization())
#model.add(Dropout(0.7))
model.add(Dense(100, activation='relu'))
model.add(BatchNormalization())
model.add(Dense(20, activation='relu'))
model.add(BatchNormalization())
#model.add(Dropout(0.7))
model.add(Dense(2))
# model.compile(loss=keras.losses.MSE,
# optimizer=keras.optimizers.SGD(lr=1e-3, decay=1e-4, momentum=0.9, nesterov=True),
# metrics=['mse'])
model.compile(loss=keras.losses.MSE,
optimizer=keras.optimizers.Adam(lr=0.5 * 1e-3),
metrics=['mse'])
model.save('my_model.h5')
tensorboard = TensorBoard(log_dir=log_dir)
#%%读取模型
if train_from_pretrained:
model = load_model(pretrained_model)
#%% 提取batch
def prewhiten(x):
if x.ndim == 4:
axis = (1, 2, 3)
size = x[0].size
elif x.ndim == 3:
axis = (0, 1, 2)
size = x.size
model.add(Conv1D(8, kernel_size=4, activation='relu', name='conv5'))
model.add(Flatten())
model.add(Dense(16, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='linear'))
# model setting
model.compile(optimizer='adam', loss='mse', metrics=['mae'])
model.summary()
# test data:80%, valid data:20%
x_valid = x_train[int(0.2 * len(x_train)):, :, :]
y_valid = y_train[int(0.2 * len(y_train)):, :]
x_train = x_train[0:int(0.8 * len(x_train)), :, :]
y_train = y_train[0:int(0.8 * len(y_train)), :]
# random the dataset
index = [i for i in range(len(x_train))]
random.shuffle(index)
x_train = x_train[index]
y_train = y_train[index]
# model saving
hist = model.fit(x_train,
y_train,
batch_size=32,
epochs=30,
validation_data=(x_valid, y_valid))
model.save('CNN_model_dishwasher.h5')
pt.plot_history(hist)
text = text.replace("\n", "")
text = text.replace("\r", "")
seg = jieba.cut(text, cut_all=False, HMM=True)
seg = [word for word in seg if word not in stopwords]
text = " ".join(seg)
textarray = [text]
textarray = np.array(pad_sequences(input_tokenizer.texts_to_sequences(textarray), maxlen=maxLength))
return textarray
def predict_result(text):
features = find_features(text)
predicted = model.predict(features, verbose=1)[0] # we have only one sentence to predict, so take index 0
prob = predicted.max()
prediction = sentiment_tag[predicted.argmax()]
return prediction, prob
# predict the review data
test_data = pd.read_excel(path_testing, encoding='utf-8')
test_data = test_data.astype({'评价内容': str, '情感': str})
test_data['预测情感'] = test_data['评价内容'].apply(lambda x: predict_result(x)[0])
test_data['预测情感'] = np.where(test_data['预测情感'] == 'pos', '正面', '负面')
accuracy = accuracy_score(test_data['情感'], test_data['预测情感'])
labels = ['正面', '负面']
cm = confusion_matrix(test_data['情感'], test_data['预测情感'])
sns.heatmap(cm, annot=True, fmt='d')
# Save the Model
model.save(model_path)
model.add(BatchNormalization())
model.add(Dropout(0.17))
model.add(Flatten())
model.add(Dense(64, activation="relu"))
model.add(BatchNormalization())
model.add(Dropout(0.17))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer='adam', metrics=['acc'], loss='binary_crossentropy')
model.summary()
plot_model(model, to_file='model3.png', show_layer_names=True, show_shapes=True)
import time
start1 = time.clock()
history = model.fit(train_70_x, train_70_y,validation_data=(train_30_x,train_30_y),batch_size=4096, epochs=50)
end1 = time.clock()
t1 = end1 -start1
model.save('my_model5.h5')
start2 = time.clock()
loss, accuracy = model.evaluate(x_test, y_test,batch_size=4096)
end2 = time.clock()
t2 = end2 - start2
pre_y = model.predict_classes(x_test)
y_test = np.array(y_test)
metrics = classification_report(y_test, pre_y)
print(metrics)
confusion_m = confusion_matrix(y_test, pre_y)
y_pred_pro = model.predict_proba(x_test)[:, 0]
fpr, tpr, thresholds = roc_curve(y_test, y_pred_pro, pos_label=1)
roc_auc = auc(fpr, tpr)
mat_plt(history)
plot_confusion_matrix(confusion_m)
roc(fpr, tpr, roc_auc)
# Separate into input (X) and output (Y)
print("Splitting into X and Y...")
sequences = np.array(sequences)
X, Y = sequences[:,0:-1], sequences[:,-1]
# Y = to_categorical(Y, num_classes=vocab_size)
seq_length = X.shape[1]
print('Done.')
# Create Model
model = Sequential()
model.add(Embedding(input_dim=vocab_size, output_dim=100, input_length=seq_length)) # Consider input_length = None
model.add(LSTM(100, return_sequences=True))
model.add(LSTM(100))
model.add(Dense(100, activation='relu'))
model.add(Dense(vocab_size, activation='softmax'))
model.summary()
# Compile model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Fit model
epochs = 1
for e in range(epochs):
model.fit(X, Y, batch_size=512, epochs=1)
# if e % 10 == 0:
model.save('./models/philosopher-king-epoch' + str(e) +'.h5')
# save the tokenizer
pickle.dump(tokenizer, open('./models/tokenizer.pkl', 'wb'))
#building the model
from keras import Sequential
from keras.layers import Embedding, LSTM, Dense, Dropout
embedding_size = 32
model = Sequential()
model.add(Embedding(vocabulary_size, embedding_size, input_length=max_words))
model.add(LSTM(100))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
#traning the model
batch_size = 64
num_epochs = 3
X_valid, y_valid = X_train[:batch_size], y_train[:batch_size]
X_train2, y_train2 = X_train[batch_size:], y_train[batch_size:]
model.fit(X_train,
y_train,
validation_data=(X_test, y_test),
batch_size=batch_size,
epochs=num_epochs)
model.save('Sentiment_analysis.h5')
scores = model.evaluate(X_test, y_test, verbose=0)
print('Test accuracy:', scores[1])
kernel_size=(3, 3),
strides=(2, 2),
activation='relu',
padding='same'))
model.add(AveragePooling2D())
model.add(Flatten())
model.add(Dropout(0.3))
model.add(
Dense(neuron_best, activation='tanh', kernel_regularizer=l2(0.005)))
model.add(Dropout(0.3))
model.add(Dense(3, activation="softmax", kernel_regularizer=l2(0.005)))
model.compile(optimizer=RMSprop(learning_rate=rate_best),
loss='categorical_crossentropy',
metrics=['accuracy'])
es = EarlyStopping(monitor='val_accuracy',
verbose=0,
patience=10,
restore_best_weights=True,
mode='max')
model.fit(x_train,
y_train,
validation_data=(x_valid, y_valid),
batch_size=128,
callbacks=[es],
verbose=0,
epochs=500)
"""
Finally, save the model to an h5 file in the deliverable directory
"""
model.save('../deliverable/nn_task2.h5')
train_image_data_flow = train_image_data_generator.flow_from_directory(
"./Images/Training",
target_size=(dimensions[0], dimensions[1]),
batch_size=batch_size,
class_mode="categorical")
validation_image_data_generator = ImageDataGenerator(rescale=1. / 255)
validation_image_data_flow = validation_image_data_generator.flow_from_directory(
"./Images/Validation",
target_size=(dimensions[0], dimensions[1]),
batch_size=batch_size,
class_mode="categorical")
sample_amount = 1.361 + 1322 + 116 + 600
validation_sample_amount = 1021
epochs = 50
epoch_steps = sample_amount // batch_size
validation_steps = validation_sample_amount // batch_size
history = model.fit_generator(train_image_data_flow,
steps_per_epoch=epoch_steps,
epochs=epochs,
validation_data=validation_image_data_flow,
validation_steps=validation_steps)
print(history.history)
model.save("cnn_model_v5_50epoch.h5")
save_best_only=True)
]
# training
history = model.fit(
x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
shuffle=False, # already shuffled during augmentation
validation_data=(x_val, y_val),
callbacks=cbks,
verbose=1)
# save and plot result
model.save('./model/room_model_{}.h5'.format(cur_time))
train_error = [(1 - acc) * 100 for acc in history.history['acc']]
val_error = [(1 - acc) * 100 for acc in history.history['val_acc']]
fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))
plt.tight_layout(pad=3, w_pad=2)
fig.suptitle('Messy Room Classifier', fontsize=16, fontweight='bold')
ax1.set_xlabel('Epochs', fontsize=14)
ax1.set_ylabel('Error(%)', fontsize=14)
ax1.plot(train_error, label='Training Error')
ax1.plot(val_error, label='Validation Error')
ax1.legend()
ax2.set_xlabel('Epochs', fontsize=14)
ax2.set_ylabel('Loss', fontsize=14)
import numpy as np
from keras import Sequential
from keras.layers import Dense
data = np.random.random((1000, 32))
label = np.random.random((1000, 10))
model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(32, )))
model.add(Dense(64, activation='relu'))
model.add(Dense(10, activation='softmax'))
model.compile('adam', 'categorical_crossentropy')
model.fit(data, label, epochs=100)
model.save('my_model.h5')
validation_generator = test_datagen.flow_from_directory(
VALIDATE_DIR,
target_size=(IMG_WIDTH, IMG_HEIGHT),
batch_size=BATCH_SIZE,
class_mode='binary')
callbacks = [TensorBoard(log_dir="logs/{}".format(NAME))]
model.fit_generator(train_generator,
callbacks=callbacks,
steps_per_epoch=TRAIN_STEP,
epochs=EPOCHS,
validation_data=validation_generator,
validation_steps=VALIDATION_STEP)
score = model.evaluate_generator(validation_generator,
VALIDATION_STEP / BATCH_SIZE,
workers=12)
scores = model.predict_generator(validation_generator,
VALIDATION_STEP / BATCH_SIZE,
workers=12)
model.save(FILE_NAME)
with open("logs/mylog.txt", "a") as f:
f.write("\n\n--------" + NAME + "----------\n")
f.write(str(score) + "\n")
except Exception as e:
with open("logs/mylog.txt", "a") as f:
f.write("\n\n--------" + NAME + "----------\n")
f.write("Failed")
