def train(model: Sequential, mode):
if mode == 'gray':
with open('./train_ids_gray.pickle', 'rb') as fp:
training_paths = pickle.load(fp)
with open('./validation_ids_gray.pickle', 'rb') as fp:
validation_paths = pickle.load(fp)
elif mode == 'recoloured':
with open('./train_ids_recolour.pickle', 'rb') as fp:
training_paths = pickle.load(fp)
with open('./validation_ids_recolour.pickle', 'rb') as fp:
validation_paths = pickle.load(fp)
elif mode == 'colour':
with open('./train_ids_tiny.pickle', 'rb') as fp:
training_paths = pickle.load(fp)
with open('./validation_ids_tiny.pickle', 'rb') as fp:
validation_paths = pickle.load(fp)
# params
dim_in = (64, 64, 3)
shuffle = True
batch_size = 64
n_classes = 30
dim_out = (n_classes)
training_generator = data_utils.DataGenerator(training_paths, batch_size,
dim_in, dim_out, shuffle,
mode, 'training')
validation_generator = data_utils.DataGenerator(validation_paths,
batch_size, dim_in,
dim_out, shuffle, mode,
'validation')
callback_list = list()
directory = create_result_dir('./vgg_classification')
print('Directory:', directory)
print("using tensorboard")
tensor_directory = directory + '/' + 'tensorboard'
tb_callback = callbacks.TensorBoard(log_dir=tensor_directory)
callback_list.append(tb_callback)
saving_period = 3
print("saving model every {} epochs".format(saving_period))
model_dir = os.path.join(directory, 'models',
'model.{epoch:02d}-loss_{val_loss:.2f}.hdf5')
p_save_callback = callbacks.ModelCheckpoint(model_dir,
period=saving_period)
callback_list.append(p_save_callback)
print("saving best model")
bestmodels_dir = directory + '/' + 'bestmodels/best_model.hdf5'
best_save_callback = callbacks.ModelCheckpoint(bestmodels_dir,
save_best_only=True,
mode='val_acc')
callback_list.append(best_save_callback)
lr_reduce = callbacks.ReduceLROnPlateau(monitor='val_acc',
factor=0.2,
patience=4)
callback_list.append(lr_reduce)
n_workers = 2
n_epochs = 30
model.fit_generator(generator=training_generator,
validation_data=validation_generator,
use_multiprocessing=True,
workers=n_workers,
verbose=1,
epochs=n_epochs,
callbacks=callback_list)
y_train= to_categorical(y_train1)
y_test= to_categorical(y_test1)
X_train = np.array(trainX)
X_test = np.array(testT)
batch_size = 64
# 1. define the network
model = Sequential()
model.add(Dense(1024,input_dim=41,activation='relu'))
model.add(Dropout(0.01))
model.add(Dense(5))
model.add(Activation('softmax'))
# try using different optimizers and different optimizer configs
model.compile(loss='categorical_crossentropy',optimizer='adam',metrics=['accuracy'])
checkpointer = callbacks.ModelCheckpoint(filepath="kddresults/dnn1layer/checkpoint-{epoch:02d}.hdf5", verbose=1, save_best_only=True, monitor='loss')
csv_logger = CSVLogger('kddresults/dnn1layer/training_set_dnnanalysis.csv',separator=',', append=False)
model.fit(X_train, y_train, validation_data=(X_test, y_test),batch_size=batch_size, nb_epoch=1000, callbacks=[checkpointer,csv_logger])
model.save("kddresults/dnn1layer/dnn1layer_model.hdf5")
y_test = y_test[:-VAL_SIZE]
model_MSDNet = model_MSDNet()
# 创建一个实例history
history = LossHistory()
# monitor：监视数据接口，此处是val_loss,patience是在多少步可以容忍没有提高变化
earlyStopping6 = kcallbacks.EarlyStopping(monitor='val_loss',
patience=patience,
verbose=1,
mode='auto')
# 用户每次epoch最后都会保存模型，如果save_best_only=True,那么最近验证误差最后的数据将会被保存下来
saveBestModel6 = kcallbacks.ModelCheckpoint(best_weights_MSDNet_path,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='auto')
# 训练和验证
tic6 = time.clock()
print(x_train.shape, x_test.shape)
# (2055,7,7,200) (7169,7,7,200)
history_3d_MSDNet = model_MSDNet.fit(
x_train.reshape(x_train.shape[0], x_train.shape[1], x_train.shape[2],
x_train.shape[3], 1),
y_train,
validation_data=(x_val.reshape(x_val.shape[0], x_val.shape[1],
x_val.shape[2], x_val.shape[3],
1), y_val),
batch_size=batch_size,
def keras1(train2, y, test2, v, z):
cname = sys._getframe().f_code.co_name
v[cname], z[cname] = 0, 0
scores = list()
scaler = preprocessing.RobustScaler()
train3 = scaler.fit_transform(train2)
test3 = scaler.transform(test2)
input_dims = train3.shape[1]
def build_model():
input_ = layers.Input(shape=(input_dims, ))
model = layers.Dense(
int(input_dims * 2.8),
kernel_initializer='Orthogonal',
activation=layers.advanced_activations.PReLU())(input_)
model = layers.BatchNormalization()(model)
#model = layers.Dropout(0.7)(model)
model = layers.Dense(
int(input_dims * 1.15),
kernel_initializer='Orthogonal',
activation=layers.advanced_activations.PReLU())(model)
model = layers.BatchNormalization()(model)
#model = layers.Dropout(0.9)(model)
model = layers.Dense(
int(input_dims * 0.31),
kernel_initializer='Orthogonal',
activation=layers.advanced_activations.PReLU())(model)
model = layers.BatchNormalization()(model)
model = layers.Dense(1, activation='sigmoid')(model)
model = models.Model(input_, model)
model.compile(loss='binary_crossentropy',
optimizer=optimizers.Nadam(lr=0.03),
metrics=["accuracy"])
#print(model.summary(line_length=120))
return model
np.random.seed(1234)
est = KerasRegressor(
build_fn=build_model,
nb_epoch=10000,
batch_size=32,
#verbose=2
)
print(build_model().summary(line_length=120))
model_path = '../data/working/' + csv_name_suffix()
model_path = model_path[:-4] + '_keras_model.h5'
kcb = [
callbacks.EarlyStopping(monitor='val_loss', patience=20
#verbose=1
),
callbacks.ModelCheckpoint(model_path,
monitor='val_loss',
save_best_only=True,
save_weights_only=True,
verbose=0),
callbacks.ReduceLROnPlateau(monitor='val_loss',
min_lr=1e-7,
factor=0.2,
verbose=1)
]
num_splits = 4
ss = model_selection.ShuffleSplit(n_splits=num_splits, random_state=11)
for n, (itrain, ival) in enumerate(ss.split(train3, y)):
xtrain, xval = train3[itrain], train3[ival]
ytrain, yval = y[itrain], y[ival]
est.fit(xtrain,
ytrain,
epochs=10000,
validation_data=(xval, yval),
verbose=0,
callbacks=kcb,
shuffle=True)
est.model.load_weights(model_path)
p = est.predict(xval)
v.loc[ival, cname] += pconvert(p)
score = metrics.log_loss(y[ival], p)
print(cname, 'fold %d: ' % (n + 1), score, now())
scores.append(score)
z[cname] += pconvert(est.predict(test3))
os.remove(model_path)
cv = np.array(scores)
print(cv, cv.mean(), cv.std())
z[cname] /= num_splits
def fit(self,
train_dst=Dataset('./test_image/'),
val_dst=Dataset('./test_image/'),
big_batch_size=1000,
batch_size=16,
learning_rate=1e-4,
loss='mse',
shuffle=True,
visual_graph=True,
visual_grads=True,
visual_weight_image=True,
multiprocess=False,
nb_epochs=100,
save_history=True,
log_dir='./logs') -> Model:
assert train_dst._is_saved(
), 'Please save the data and label in train_dst first!'
assert val_dst._is_saved(
), 'Please save the data and label in val_dst first!'
train_count = train_dst.get_num_data()
val_count = val_dst.get_num_data()
if self.model is None:
self.create_model()
# adam = optimizers.Nadam()
adam = optimizers.Adam(lr=learning_rate)
self.model.compile(optimizer=adam, loss=loss, metrics=[PSNR])
callback_list = []
# callback_list.append(HistoryCheckpoint(history_fn))
callback_list.append(
callbacks.ModelCheckpoint(self.weight_path,
monitor='val_PSNR',
save_best_only=True,
mode='max',
save_weights_only=True,
verbose=2))
if save_history:
log_dir = os.path.join(log_dir, self.model_name)
callback_list.append(
TensorBoardBatch(log_dir=log_dir,
batch_size=batch_size,
histogram_freq=1,
write_grads=visual_grads,
write_graph=visual_graph,
write_images=visual_weight_image))
print('Training model : %s' % (self.model_name))
self.model.fit_generator(
train_dst.image_flow(big_batch_size=big_batch_size,
batch_size=batch_size,
shuffle=shuffle),
steps_per_epoch=train_count // batch_size + 1,
epochs=nb_epochs,
callbacks=callback_list,
validation_data=val_dst.image_flow(big_batch_size=10 * batch_size,
batch_size=batch_size,
shuffle=shuffle),
validation_steps=val_count // batch_size + 1,
use_multiprocessing=multiprocess,
workers=4)
return self.model
y_train = np.array(Y)
y_test = np.array(C)
# reshape input to be [samples, time steps, features]
X_train = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1]))
X_test = np.reshape(testT, (testT.shape[0], 1, testT.shape[1]))
batch_size = 256
# 1. define the network
model = Sequential()
model.add(LSTM(32,input_dim=90)) # try using a GRU instead, for fun
model.add(Dropout(0.1))
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'])
checkpointer = callbacks.ModelCheckpoint(filepath="logs/lstm3/checkpoint-{epoch:02d}.hdf5", verbose=1, save_best_only=True, monitor='val_acc', mode='max')
csv_logger = CSVLogger('logs/lstm3/training_set_iranalysis.csv',separator=',', append=False)
model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=1000, validation_data=(X_test, y_test),callbacks=[checkpointer,csv_logger])
model.save("logs/lstm3/lstm1layer_model.hdf5")
# plt.show()
model.summary()
# fidxTrn = '/mnt/data1T2/datasets2/z_all_in_one/Portraits_256x256/idx.txt'
# fidxTrn = '/mnt/data1T2/datasets2/z_all_in_one/mscoco/coco_4x3/idx.txt'
fidxTrn = '/mnt/data1T2/datasets2/z_all_in_one/mscoco/train_data/idx.txt'
fidxVal = '/mnt/data1T2/datasets2/z_all_in_one/BVideo_All_256x256/idx.txt'
#
numTrn = len(open(fidxTrn, 'r').read().splitlines())
batchSize = 128
numEpochs = 100
numIterPerEpoch = numTrn / batchSize
pathLog = '%s-log.csv' % pathModel
#
# trnX, trnY = readDataMasked(fidxTrn)
valX, valY = readDataMasked(fidxVal)
# model.fit(x=trnX, y=trnY, batch_size=128, epochs=100, validation_data=(valX, valY))
model.fit_generator(generator=train_generator(fidxTrn,
batchSize=128,
imsize=256),
steps_per_epoch=numIterPerEpoch,
epochs=numEpochs,
validation_data=(valX, valY),
callbacks=[
kall.ModelCheckpoint(pathModel,
verbose=True,
save_best_only=True),
kall.CSVLogger(pathLog, append=True)
])
# model.save(pathModel)
# print ('-----')
batch_size = 256
epochs = 10
X_tra, X_val, y_tra, y_val = train_test_split(x_train,
y_train,
train_size=0.95,
random_state=233)
RocAuc = RocAucEvaluation(validation_data=(X_val, y_val), interval=1)
es = callbacks.EarlyStopping(
monitor='val_loss',
patience=3,
#mode='max',
verbose=1)
model_path = 'capsule_gru.h5'
mc = callbacks.ModelCheckpoint(
model_path,
monitor='val_loss',
save_best_only=True,
#mode='max',
verbose=1)
hist = model.fit(X_tra,
y_tra,
batch_size=batch_size,
epochs=8,
validation_data=(X_val, y_val),
callbacks=[RocAuc, mc, es],
verbose=1)
#if os.path.isfile(model_path):
# model = load_model(model_path)
y_pred = model.predict(x_test, batch_size=1024, verbose=1)
submission = pd.read_csv('data/sample_submission.csv')
if model_load is False:
'Save accuracy & loss'
csv_logger = callbacks.CSVLogger(os.path.join(params["savefolder"],
str(datetime.date.today()) + '-' +
str(datetime.datetime.now())[11:16] + 'training.csv'))
'Custom callback'
roc_callback = roc_val(callback_generator, params["savefolder"],
str(datetime.date.today()) + '-' +
str(datetime.datetime.now())[11:16] + 'roc_callback.csv',
label=params["label"])
'Save last model'
checkpoint = callbacks.ModelCheckpoint(os.path.join(
params["savefolder"], "last_model.hdf5"))
'Save best model'
checkpoint_best = callbacks.ModelCheckpoint(os.path.join(
params["savefolder"], "best_model.hdf5"), save_best_only=True)
else:
'Append to existing files'
csvfile = glob.glob(os.path.join(params["savefolder"],
"*training.csv"))
csv_logger = callbacks.CSVLogger(csvfile[0], append=True)
roc_valfiles = glob.glob(os.path.join(params["savefolder"],
"*roc_callback.csv"))
roc_valfile0 = roc_valfiles[0]
#learning_rate = 2e-4
#rms=RMSprop(lr=learning_rate)
model.compile(loss='mse', optimizer=sgd, metrics=['mse'])
# Fit the model
#model.compile(loss=custom_objective, optimizer='adadelta')
#model.fit(X_train, y_train,
# batch_size=batch_size,
# epochs=nb_epoch,
# shuffle=True)
from keras import callbacks
m_name = 'DeepMIL_MaxPooling_swish' + str(i) + '.h5'
checkpoint = callbacks.ModelCheckpoint(m_name,
monitor='val_mean_squared_error',
save_best_only=True,
save_weights_only=True,
verbose=1,
mode='min')
early_stopping = callbacks.EarlyStopping(monitor='val_mean_squared_error',
patience=200,
verbose=0,
mode='min')
model.fit(X_train,
y_train,
epochs=1000,
batch_size=1,
verbose=1,
validation_data=(X_test, Y_o),
callbacks=[checkpoint, early_stopping])
def train_test(X, y, arch_num, layer_sizes, maxlen, batch_size, learning_rate,
epochs, X_test, y_test, name, data_width, selection_problem):
model = create_model(arch_num, layer_sizes, maxlen, data_width,
selection_problem)
print("DATA WIDTH:", data_width)
weight_file = "../models/" + name + ".weights"
optimizer = keras.optimizers.Adam(lr=learning_rate)
#tensorboard = callbacks.TensorBoard(log_dir="../logs",
# histogram_freq=1,
# batch_size=batch_size,
# write_graph=True,
# write_grads=True,
# write_images=False,
# embeddings_freq=0,
# embeddings_layer_names=None,
# embeddings_metadata=None)
cbks = [
callbacks.EarlyStopping(monitor='val_loss', patience=10),
callbacks.ModelCheckpoint(filepath=util.TMP_PATH + name +
'.best.weights',
verbose=0,
save_best_only=True)
]
if layer_sizes[-1] == 1:
model.compile(optimizer=optimizer,
loss="binary_crossentropy",
metrics=["binary_accuracy"])
else:
model.compile(optimizer=optimizer,
loss="categorical_crossentropy",
metrics=["categorical_accuracy"])
model.summary()
X_train, X_val, y_train, y_val = train_test_split(X,
y,
shuffle=True,
stratify=y,
test_size=.2,
random_state=13)
history = model.fit(X_train,
y_train,
batch_size=batch_size,
verbose=2,
epochs=epochs,
validation_data=(X_val, y_val),
callbacks=cbks)
model.load_weights(util.TMP_PATH + name + ".best.weights")
return_history = history.history
logging.debug("Testing")
loss, acc, predictions = test(X_test, y_test, batch_size, model)
logging.debug("Returning...")
return model, return_history, loss, acc, predictions
# lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(0.001, decay_steps=100000, decay_rate=0.96, staircase=True)
model.compile(loss='categorical_crossentropy',
optimizer=Adam(learning_rate=0.001),
metrics=['accuracy'])
# # save model for later
model_json = model.to_json()
with open(model_path_json, 'w') as json_file:
json_file.write(model_json)
# print(model.summary())
# checkpoints in case training stops
checkpoint = callbacks.ModelCheckpoint(model_path,
monitor='val_accuracy',
verbose=2,
save_best_only=True,
mode='max',
save_freq='epoch')
# stops early if loss doesn't improve after 500 epocs
# es = callbacks.EarlyStopping(monitor='val_accuracy', mode='min', verbose=1, patience=500)
tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir,
histogram_freq=1)
model.fit(
training_data_batch_generator,
steps_per_epoch=steps_per_epoch,
validation_data=validation_data_batch_generator,
validation_steps=validation_steps_per_epoch,
# initial_epoch=10, # in case we need to resume training
def build_model(self, input_shape, n_classes):
# input layer
input_layer = Input(input_shape)
# Block 1
x = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv1')(input_layer)
x = Conv2D(64, (3, 3),
activation='relu',
padding='same',
name='block1_conv2')(x)
x = MaxPool2D((2, 2), strides=(2, 2), name='block1_pool')(x)
# Block 2
x = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv1')(x)
x = Conv2D(128, (3, 3),
activation='relu',
padding='same',
name='block2_conv2')(x)
x = MaxPool2D((2, 2), strides=(2, 2), name='block2_pool')(x)
# Block 3
x = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv1')(x)
x = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv2')(x)
x = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv3')(x)
x = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv4')(x)
x = MaxPool2D((2, 2), strides=(2, 2), name='block3_pool')(x)
# Block 4
x = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv1')(x)
x = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv2')(x)
x = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv3')(x)
x = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block4_conv4')(x)
x = MaxPool2D((2, 2), strides=(2, 2), name='block4_pool')(x)
# Block 5
x = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv1')(x)
x = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv2')(x)
x = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv3')(x)
x = Conv2D(512, (3, 3),
activation='relu',
padding='same',
name='block5_conv4')(x)
x = MaxPool2D((2, 2), strides=(2, 2), name='block5_pool')(x)
# Classification block
x = Flatten(name='flatten')(x)
x = Dense(4096, activation='relu', name='fc1')(x)
x = Dense(4096, activation='relu', name='fc2')(x)
output_layer = Dense(n_classes,
activation='softmax',
name='predictions')(x)
## define the model with input layer and output layer
model = Model(inputs=input_layer, outputs=output_layer)
model.summary()
plot_model(model,
to_file=self.output_directory + '/model_graph.png',
show_shapes=True,
show_layer_names=True)
model.compile(loss=categorical_crossentropy,
optimizer=Adadelta(lr=0.1),
metrics=['acc'])
# model save
file_path = self.output_directory + '/best_model.hdf5'
model_checkpoint = callbacks.ModelCheckpoint(filepath=file_path,
monitor='loss',
save_best_only=True)
# Tensorboard log
log_dir = self.output_directory + '/tf_logs'
chk_n_mkdir(log_dir)
tb_cb = TrainValTensorBoard(log_dir=log_dir)
self.callbacks = [model_checkpoint, tb_cb]
return model
model.add(Dropout(rate=0.5))
model.add(Dense(units=num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
### model is ready ###
# callbacks
# for debugging: tensorboard
cb_tensorboard = callbacks.TensorBoard(write_images=True)
cb_checkpoint = callbacks.ModelCheckpoint(filepath=file_path,
monitor='val_acc',
save_best_only=True,
save_weights_only=False,
mode='max')
callbacks = [cb_tensorboard, cb_checkpoint]
# training
model.fit(
x_train,
y_train,
validation_data=(x_test, y_test),
batch_size=batch_size,
epochs=epochs,
# callbacks=callbacks,
verbose=verbose_train)
embeddings_layer_names=None,
embeddings_metadata=None)
training_history = train_histories()
num_epochs = 500
patience = 2000 #number of epochs where we see no improvement after which we stop training
last_epoch_val_loss = 1000 #arbitrarily large number
perc_decrease_per_epoch = 10
epochwise_loss_history = []
batchwise_loss_history = []
epochwise_val_loss_history = []
batchwise_val_loss_history = []
epoch_count = 0
checkpoint = callbacks.ModelCheckpoint(
os.environ['BASEDIR'] + "/models/best_model_" + args.model_name + '_' +
args.loss_name + '_' + args.opt_name + '.h5',
save_best_only=True)
for epoch in range(num_epochs):
np.random.shuffle(train_data_list)
np.random.shuffle(val_data_list)
logging.info("Epoch no %s", epoch + 1)
my_generator = batch_generator(4000, train_data_list, image_type)
my_val_generator = batch_generator(1000, val_data_list, image_type)
gen_batch_loss_history = []
gen_batch_val_loss_history = []
logging.info("Training on EB or EE+ images")
for batch in my_generator:
try:
val_batch = my_val_generator.next()
def train_char_rnn_model(model, dataset: List[str], args: argparse.Namespace):
from keras import callbacks, utils
if args.length % 2 != 0:
raise ValueError("--length must be even")
log = logging.getLogger("train")
numpy.random.seed(args.seed)
log.info("Splitting into validation and train...")
valid_doc_indices = set(
numpy.random.choice(numpy.arange(len(dataset)),
int(len(dataset) * args.validation),
replace=False))
train_doc_indices = set(range(len(dataset))) - valid_doc_indices
train_docs = [dataset[i] for i in sorted(train_doc_indices)]
valid_docs = [dataset[i] for i in sorted(valid_doc_indices)]
# we cannot reach first l / 2 (forward) and last l / 2 (backward)
valid_size = sum(len(text) - args.length for text in valid_docs)
train_size = sum(len(text) - args.length for text in train_docs)
log.info("train samples: %d\tvalidation samples: %d\t~%.3f", train_size,
valid_size, valid_size / (valid_size + train_size))
class Feeder(utils.Sequence):
def __init__(self, texts: List[str]):
self.texts = texts
pos = 0
self.index = index = numpy.zeros(len(texts) + 1, dtype=numpy.int32)
for i, text in enumerate(texts):
pos += len(text) - args.length
index[i + 1] = pos
# this takes much memory but is the best we can do.
self.batches = numpy.arange(pos, dtype=numpy.uint32)
log.info("Batches occupied %s",
humanize.naturalsize(self.batches.size))
self.on_epoch_end()
def __len__(self):
return self.index[-1] // args.batch_size
def __getitem__(self, item):
centers = self.batches[item * args.batch_size:(item + 1) *
args.batch_size]
batch = ([
numpy.zeros((args.batch_size, args.length), dtype=numpy.uint8)
for _ in range(2)
], [
numpy.zeros((args.batch_size, len(CHARS) + 1),
dtype=numpy.float32)
])
text_indices = numpy.searchsorted(self.index, centers + 0.5) - 1
for bi, (center,
text_index) in enumerate(zip(centers, text_indices)):
text = self.texts[text_index]
x = center - self.index[text_index]
assert 0 <= x < self.index[text_index +
1] - self.index[text_index]
x += args.length // 2
text_i = x - 1
batch_i = args.length - 1
while text_i >= 0 and batch_i >= 0:
batch[0][0][bi][batch_i] = CHARS.get(
text[text_i], len(CHARS))
text_i -= 1
batch_i -= 1
text_i = x + 1
batch_i = args.length - 1
while text_i < len(text) and batch_i >= 0:
batch[0][1][bi][batch_i] = CHARS.get(
text[text_i], len(CHARS))
text_i += 1
batch_i -= 1
batch[1][0][bi][CHARS.get(text[x], len(CHARS))] = 1
return batch
def on_epoch_end(self):
log.info("Shuffling")
numpy.random.shuffle(self.batches)
log.info("Creating the training feeder")
train_feeder = Feeder(train_docs)
log.info("Creating the validation feeder")
valid_feeder = Feeder(valid_docs)
log.info("model.fit_generator")
tensorboard = callbacks.TensorBoard(log_dir=args.tensorboard)
checkpoint = callbacks.ModelCheckpoint(os.path.join(
args.tensorboard, "checkpoint_{epoch:02d}_{val_loss:.3f}.hdf5"),
save_best_only=True)
if args.enable_weights:
weights = [min(v, 100)
for (c, v) in sorted(WEIGHTS.items())] + [OOV_WEIGHT]
else:
weights = None
class Shuffler(callbacks.Callback):
def on_epoch_end(self, epoch, logs=None):
# Bug: it is not called automatically
train_feeder.on_epoch_end()
class Presenter(callbacks.Callback):
def __init__(self):
super().__init__()
self.i = 0
self.text = "I am working on a collection of classes used for video playback and " \
"recording. I have one main class which acts like the public interface, " \
"with methods like play(), stop(), pause(), record() etc... Then I " \
"have workhorse classes which do the video decoding and video encoding."
self.batches = []
for x in range(args.length // 2,
len(self.text) - args.length // 2 - 1):
before = self.text[x - args.length // 2:x]
after = self.text[x + 1:x + 1 + args.length // 2]
before_arr = numpy.zeros(args.length, dtype=numpy.uint8)
after_arr = numpy.zeros_like(before_arr)
for i, c in enumerate(reversed(before)):
before_arr[args.length - 1 - i] = CHARS.get(c, len(CHARS))
for i, c in enumerate(reversed(after)):
after_arr[args.length - 1 - i] = CHARS.get(c, len(CHARS))
self.batches.append((before_arr, after_arr))
log.info("Testing on %d batches" % len(self.batches))
self.vocab = [None] * (len(CHARS) + 1)
for k, v in CHARS.items():
self.vocab[v] = k
self.vocab[len(CHARS)] = "?"
def on_batch_end(self, batch, logs=None):
if self.i % 10000 == 0:
predicted = model.predict(self.batches,
batch_size=len(self.batches))
print("".join(self.vocab[numpy.argmax(p)] for p in predicted))
class LRPrinter(callbacks.Callback):
def on_epoch_end(self, epoch, logs=None):
from keras import backend
lr = self.model.optimizer.lr
decay = self.model.optimizer.decay
iterations = self.model.optimizer.iterations
lr_with_decay = lr / (
1. + decay * backend.cast(iterations, backend.dtype(decay)))
print("Learning rate:", backend.eval(lr_with_decay))
model.fit_generator(
generator=train_feeder,
validation_data=valid_feeder,
validation_steps=len(valid_feeder),
steps_per_epoch=len(train_feeder),
epochs=args.epochs,
class_weight=weights,
callbacks=[tensorboard, checkpoint,
Shuffler(),
LRPrinter()],
use_multiprocessing=True)
# Training
hist = model.fit(X_train, y_train, batch_size=16, nb_epoch=num_epoch, verbose=1, validation_data=(X_test, y_test))
#hist = model.fit(X_train, y_train, batch_size=32, nb_epoch=20,verbose=1, validation_split=0.2)
# Training with callbacks
from keras import callbacks
filename='model_train_new.csv'
csv_log=callbacks.CSVLogger(filename, separator=',', append=False)
early_stopping=callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=0, verbose=0, mode='min')
filepath="Best-weights-my_model-{epoch:03d}-{loss:.4f}-{acc:.4f}.hdf5"
checkpoint = callbacks.ModelCheckpoint(filepath, monitor='val_loss', verbose=1, save_best_only=True, mode='min')
callbacks_list = [csv_log,early_stopping,checkpoint]
hist = model.fit(X_train, y_train, batch_size=16, nb_epoch=num_epoch, verbose=1, validation_data=(X_test, y_test),callbacks=callbacks_list)
# visualizing losses and accuracy
train_loss=hist.history['loss']
val_loss=hist.history['val_loss']
train_acc=hist.history['acc']
val_acc=hist.history['val_acc']
xc=range(num_epoch)
plt.figure(1,figsize=(7,5))
plt.plot(xc,train_loss)
model.summary()
adam = optimizers.Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, epsilon=1e-08)
model.compile(optimizer=adam, loss='mse', metrics=[snr])
#####################################################################################
# 3. Fit the model
#####################################################################################
# Stop criteria
stop_str = cbs.EarlyStopping(monitor='val_loss', patience=16, verbose=1, mode='min')
# Reduce learning rate
reduce_LR = cbs.ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=2, verbose=1, mode='min', epsilon=0.0001, cooldown=0, min_lr=0)
# Save only best weights
best_weights = "./data/cnn_weights_ceps_g711_example.h5"
best_weights = os.path.normcase(best_weights)
model_save = cbs.ModelCheckpoint(best_weights, monitor='val_loss', save_best_only=True, mode='min', save_weights_only=True, period=1)
start = time.time()
print("> Training model " + "using Batch-size: " + str(batch_size) + ", Learning_rate: " + str(learning_rate) + "...")
hist = model.fit(x_train_noisy, x_train, epochs=nb_epochs, batch_size=batch_size, shuffle=True, initial_epoch=0,
callbacks=[reduce_LR, stop_str, model_save],
validation_data=[x_train_noisy_vali, x_train_vali]
)
print("> Saving Completed, Time : ", time.time() - start)
print('> +++++++++++++++++++++++++++++++++++++++++++++++++++++ ')
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.4))
model.add(Dense(10))
model.add(Activation('softmax'))
#Train the model
t1 = dt.now()
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=SGD(lr=0.01),
metrics=['accuracy'])
model_checkpoints = callbacks.ModelCheckpoint(
'/content/gdrive/My Drive/CNNProject/SampleOut_2018-12-01_07-16-45.694543/12_Layer3_E40_B128_F64_K55_DO2040.py_weights_{epoch:02d}_{val_loss:.2f}_Proj.h5',
monitor='val_loss',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto',
period=1)
model_log = model.fit(x_train,
y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test),
callbacks=[model_checkpoints])
t2 = dt.now()
delta = t2 - t1
trainingTime = str(delta.total_seconds())
#Evaluate the accuracy
score = model.evaluate(x_test, y_test, verbose=0)
def train(model, data, epoch_size_frac=1.0):
"""
Training a CapsuleNet
:param model: the CapsuleNet model
:param data: a tuple containing training and testing data, like `((x_train, y_train), (x_test, y_test))`
:param args: arguments
:return: The trained model
"""
# unpacking the data
(x_train, y_train), (x_test, y_test) = data
# callbacks
log = callbacks.CSVLogger('log.csv')
checkpoint = callbacks.ModelCheckpoint('weights-{epoch:02d}.h5',
save_best_only=True,
save_weights_only=True,
verbose=1)
lr_decay = callbacks.LearningRateScheduler(
schedule=lambda epoch: 0.001 * np.exp(-epoch / 10.))
# compile the model
model.compile(optimizer='adam',
loss=[margin_loss, 'mse'],
loss_weights=[1., 0.0005],
metrics={'out_caps': 'accuracy'})
"""
# Training without data augmentation:
model.fit([x_train, y_train], [y_train, x_train], batch_size=args.batch_size, epochs=args.epochs,
validation_data=[[x_test, y_test], [y_test, x_test]], callbacks=[log, tb, checkpoint])
"""
# -----------------------------------Begin: Training with data augmentation -----------------------------------#
def train_generator(x, y, batch_size, shift_fraction=0.1):
train_datagen = ImageDataGenerator(
width_shift_range=shift_fraction,
height_shift_range=shift_fraction) # shift up to 2 pixel for MNIST
generator = train_datagen.flow(x, y, batch_size=batch_size)
while 1:
x_batch, y_batch = generator.next()
yield ([x_batch, y_batch], [y_batch, x_batch])
# Training with data augmentation. If shift_fraction=0., also no augmentation.
model.fit_generator(generator=train_generator(x_train, y_train, 64, 0.1),
steps_per_epoch=int(epoch_size_frac *
y_train.shape[0] / 64),
epochs=2,
validation_data=[[x_test, y_test], [y_test, x_test]],
callbacks=[log, checkpoint, lr_decay])
# -----------------------------------End: Training with data augmentation -----------------------------------#
### Saving the model
from keras.models import model_from_json
model_jason = model.to_json()
with open("/Users/keyadesai/Desktop/capsNet/models/mnist_capsnet_2.json",
"w") as json_file:
json_file.write(model_jason)
model.save_weights(
"/Users/keyadesai/Desktop/capsNet/models/mnist_capsnet_2.h5")
print("saved model to disk")
'''
from keras_contrib.utils.save_load_utils import save_all_weights, load_all_weights
save_load_utils.save_all_weights(model, "/Users/keyadesai/Desktop/capsNet/models/temp.h5")
'''
return model
# Generators
data_list, index_dict = reader.pickle_data()
# training_generator = DataGenerator(reader, list_IDs, labels, **params)
training_generator = DataGenerator(data_list, index_dict, list_IDs, labels,
**params)
steps_per_epoch = int(
len(relations) / config_model_train["batch_size"]) + 1
del relations
del index
del relation_labeler
print("Model training...")
mc = callbacks.ModelCheckpoint(config_model_train["weights"] +
'_iter_{epoch:04d}.h5',
save_weights_only=True,
period=config_model_train["save_period"])
history = model.fit_generator(generator=training_generator,
epochs=config_model_train["epochs"],
verbose=config_model_train["verbose"],
steps_per_epoch=steps_per_epoch,
callbacks=[mc])
# save trained model
print("Saving model and its weights ...")
model.save_weights(config_model_train["weights"] + ".h5")
print("Plotting history ...")
plot_history(history, config_model_train["train_details"],
config_model_param["model_name"])
def build_model(self, input_shape, n_classes):
## input layer
input_layer = Input(input_shape)
## convolutional layers
conv_layer1_1 = Conv2D(filters=16,
kernel_size=(1, 1),
activation=None,
padding='same')(input_layer)
conv_layer1_2 = Conv2D(filters=16,
kernel_size=(3, 3),
activation=None,
padding='same')(input_layer)
conv_layer1_3 = Conv2D(filters=16,
kernel_size=(5, 5),
activation=None,
padding='same')(input_layer)
concat_layer1 = Concatenate(
[conv_layer1_1, conv_layer1_2, conv_layer1_3])
activation_layer1 = Activation('relu')(concat_layer1)
dropout_layer1 = Dropout(0.2)(activation_layer1)
conv_layer2_1 = Conv2D(filters=16,
kernel_size=(1, 1),
activation=None,
padding='same')(dropout_layer1)
conv_layer2_2 = Conv2D(filters=16,
kernel_size=(3, 3),
activation=None,
padding='same')(dropout_layer1)
concat_layer2 = Concatenate([conv_layer2_1, conv_layer2_2])
activation_layer2 = Activation('relu')(concat_layer2)
dropout_layer2 = Dropout(0.2)(activation_layer2)
conv_layer2 = Conv2D(filters=32, kernel_size=(3, 3),
activation='relu')(pooling_layer1)
conv_layer3 = Conv2D(filters=32, kernel_size=(3, 3),
activation='relu')(conv_layer2)
pooling_layer2 = MaxPool2D(pool_size=(2, 2),
strides=(2, 2))(conv_layer3)
dropout_layer = Dropout(0.5)(pooling_layer2)
dense_layer = Dense(units=2048, activation='relu')(dropout_layer)
output_layer = Dense(units=n_classes,
activation='softmax')(dense_layer)
## define the model with input layer and output layer
model = Model(inputs=input_layer, outputs=output_layer)
model.summary()
plot_model(model,
to_file=self.output_directory + '/model_graph.png',
show_shapes=True,
show_layer_names=True)
model.compile(loss=categorical_crossentropy,
optimizer=Adam(),
metrics=['acc'])
# model save
file_path = self.output_directory + '/best_model.hdf5'
model_checkpoint = callbacks.ModelCheckpoint(filepath=file_path,
monitor='loss',
save_best_only=True)
# Tensorboard log
log_dir = self.output_directory + '/tf_logs'
chk_n_mkdir(log_dir)
tb_cb = TrainValTensorBoard(log_dir=log_dir)
self.callbacks = [model_checkpoint, tb_cb]
return model
###########################
training_callbacks = []
if SAVE_BEST_MODEL:
# Remove . from learning rate.
learning_rate_string = str(LEARNING_RATE).replace('.', '_', 1)
# Save best model to file based on monitored value.
training_callbacks.append(
callbacks.ModelCheckpoint(
filepath = 'models/Epc' + str(EPOCHS) + '_Btc' + str(BATCH_SIZE) + '_Lr' + str(learning_rate_string) + '_Vld' +
str(VALIDATION_EXTRAS) + '_Con' + str(CONVOLUTION_COUNT) + '_Fil' + str(FILTER_COUNT[0]) + '_Siz' +
str(FILTER_SIZE) + '_Pol' + str(POOL_SIZE) + '_Ful' + str(FULLY_CONNECTED_COUNT) + '_FCS' + str(FULLY_CONNECTED_SIZE[0]) + '_Opp' +
str(OPTIMISER.__name__) + '.h5',
# Printout mode. (0, 1)
verbose = 0,
# Value to monitor while training. (loss, val_loss, accuracy, val_accuracy)
monitor = 'val_loss',
# Save only the best epoch weights.
save_best_only = True,
# Minimise or maximise monitored value. (min, max, auto)
mode = 'auto'))
if REDUCE_LEARNING_RATE:
# Reduce training learning rate if monitored value plateaus.
training_callbacks.append(
callbacks.ReduceLROnPlateau(
# Value to monitor while training. (loss, val_loss, accuracy, val_accuracy)
monitor = 'val_loss',
# Maximum number of epochs to wait for improvement.
patience = 3,
def cross_validation():
model_name = 'rnn_stacked_word'
saved_models_fp = 'saved_models/{}.hdf5'.format(model_name)
index_list = load_data('../data/oof_index.pkl')
word_padded_sequences, _, word_embedding_matrix, _, train_y = \
load_data('../data/processed.pkl')
word_x1 = word_padded_sequences[:30000]
word_x2 = word_padded_sequences[30000:]
embedding_matrix = word_embedding_matrix
train_word_x1 = word_x1[:20000]
train_word_x2 = word_x2[:20000]
test_word_x1 = word_x1[20000:]
test_word_x2 = word_x2[20000:]
train_x = [train_word_x1, train_word_x2]
test_x = [test_word_x1, test_word_x2]
config = rnn_config
config['max_length'] = train_word_x1.shape[1]
train_new = np.zeros((len(train_word_x1), 1))
test_new = np.zeros((len(test_word_x1), 1))
scores = []
for fold_id, (train_index, test_index) in enumerate(index_list):
rand_set()
model = rnn(embedding_matrix, config)
skf_x_train = [train_x[0][train_index],
train_x[1][train_index]] # 800,10
skf_y_train = train_y[train_index] # 800,3
skf_x_test = [train_x[0][test_index], train_x[1][test_index]] # 200,10
skf_y_test = train_y[test_index]
lr_decay = callbacks.ReduceLROnPlateau(
monitor='val_f1',
factor=0.5,
patience=config['lr_decay_epoch'],
min_lr=0.01 * config['learning_rate'],
mode='max')
es = callbacks.EarlyStopping(monitor='val_f1',
patience=config['n_stop'],
mode='max')
mc = callbacks.ModelCheckpoint(saved_models_fp,
monitor='val_f1',
save_best_only=True,
save_weights_only=True,
mode='max')
hist = model.fit(skf_x_train,
skf_y_train,
batch_size=config['batch_size'],
epochs=config['epochs'],
validation_data=(skf_x_test, skf_y_test),
callbacks=[lr_decay, es, mc])
# 每次填充200*3，五次填充1000*3
model.load_weights(saved_models_fp)
valid_pred = model.predict(skf_x_test)
train_new[test_index, 0:1] = valid_pred
test_new += model.predict(test_x) # 300*3
best_score = max(hist.history['val_f1'])
scores.append(best_score)
del model
if K.backend() == 'tensorflow':
K.clear_session()
logging.info('\t{}\t{}\t平均得分{}'.format(
model_name, '|'.join([str(i) for i in np.around(scores, decimals=4)]),
str(np.average(scores))))
dump_data('../cv_result/{}.pkl'.format(model_name), [train_new, test_new])
#model.load_weights(join("ckpt/saved/", "***.hdf5"))
batch_size = 4
num_epochs = 50
# setup data generator
data_gen_args = dict(rotation_range=0.2,
width_shift_range=0.05,
height_shift_range=0.05,
shear_range=0.05,
zoom_range=0.05,
horizontal_flip=True,
fill_mode='nearest')
model_checkpoint = callbacks.ModelCheckpoint(model_ckpt_name,
monitor='loss',
verbose=1,
mode='auto',
save_weights_only=True,
save_best_only=True)
# data generator
train_gen = trainDataGenerator(
batch_size, # batch_size
train_dir, # train-data dir
"images", # image_folder
"masks", # mask_folder
data_gen_args, # aug_dict
image_color_mode="rgb",
mask_color_mode="rgb",
target_size=(im_res_[1], im_res_[0]))
## fit model
def test_ModelCheckpoint(tmpdir):
np.random.seed(1337)
filepath = str(tmpdir / 'checkpoint.h5')
(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_classes)
y_test = np_utils.to_categorical(y_test)
y_train = np_utils.to_categorical(y_train)
# case 1
monitor = 'val_loss'
save_best_only = False
mode = 'auto'
model = Sequential()
model.add(Dense(num_hidden, input_dim=input_dim, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
cbks = [
callbacks.ModelCheckpoint(filepath,
monitor=monitor,
save_best_only=save_best_only,
mode=mode)
]
model.fit(X_train,
y_train,
batch_size=batch_size,
validation_data=(X_test, y_test),
callbacks=cbks,
epochs=1)
assert os.path.isfile(filepath)
os.remove(filepath)
# case 2
mode = 'min'
cbks = [
callbacks.ModelCheckpoint(filepath,
monitor=monitor,
save_best_only=save_best_only,
mode=mode)
]
model.fit(X_train,
y_train,
batch_size=batch_size,
validation_data=(X_test, y_test),
callbacks=cbks,
epochs=1)
assert os.path.isfile(filepath)
os.remove(filepath)
# case 3
mode = 'max'
monitor = 'val_acc'
cbks = [
callbacks.ModelCheckpoint(filepath,
monitor=monitor,
save_best_only=save_best_only,
mode=mode)
]
model.fit(X_train,
y_train,
batch_size=batch_size,
validation_data=(X_test, y_test),
callbacks=cbks,
epochs=1)
assert os.path.isfile(filepath)
os.remove(filepath)
# case 4
save_best_only = True
cbks = [
callbacks.ModelCheckpoint(filepath,
monitor=monitor,
save_best_only=save_best_only,
mode=mode)
]
model.fit(X_train,
y_train,
batch_size=batch_size,
validation_data=(X_test, y_test),
callbacks=cbks,
epochs=1)
assert os.path.isfile(filepath)
os.remove(filepath)
# case 5
save_best_only = False
period = 2
mode = 'auto'
filepath = 'checkpoint.{epoch:02d}.h5'
cbks = [
callbacks.ModelCheckpoint(filepath,
monitor=monitor,
save_best_only=save_best_only,
mode=mode,
period=period)
]
model.fit(X_train,
y_train,
batch_size=batch_size,
validation_data=(X_test, y_test),
callbacks=cbks,
epochs=4)
assert os.path.isfile(filepath.format(epoch=2))
assert os.path.isfile(filepath.format(epoch=4))
assert not os.path.exists(filepath.format(epoch=1))
assert not os.path.exists(filepath.format(epoch=3))
os.remove(filepath.format(epoch=2))
os.remove(filepath.format(epoch=4))
assert not tmpdir.listdir()
def trainModel(train, epochs=30, folds=5, cleanData=True, equalAmount=True):
if cleanData:
amountCroppedSplitDomino = int(len(os.listdir('screenshots/croppedDominoCleanOhne10'))) - 1
if equalAmount:
amountCroppedSplitNoDomino = amountCroppedSplitDomino
else:
amountCroppedSplitNoDomino = len(os.listdir('screenshots/croppedNoDominoCleanOhne10')) - 1
else:
amountCroppedSplitDomino = int(len(os.listdir('screenshots/croppedDominoFaultyOhne10'))) - 1
if equalAmount:
amountCroppedSplitNoDomino = amountCroppedSplitDomino
else:
amountCroppedSplitNoDomino = len(os.listdir('screenshots/croppedNoDominoFaultyOhne10')) - 1
testAmountDomino = int(amountCroppedSplitDomino / 5)
trainAmountDomino = int((amountCroppedSplitDomino / 5) * 4)
testAmountNoDomino = int(amountCroppedSplitNoDomino / 5)
trainAmountNoDomino = int((amountCroppedSplitNoDomino / 5) * 4)
testAmount = testAmountDomino + testAmountNoDomino
trainAmount = trainAmountDomino + trainAmountNoDomino
print('domino total:',amountCroppedSplitDomino,'noDomino total:',amountCroppedSplitNoDomino)
print('Training model with', epochs, 'epochs,', folds, ' folds...')
if cleanData:
print('used Data: clean')
else:
print('used Data: dirty')
absoluteStartTime = datetime.datetime.now()
imgWidth, imgHeight = imageWidth, imageHeight
#imgWidth, imgHeight = lowImageWith, lowImageHeight
trainDataDir = 'screenshots/trainSplit'
testDataDir = 'screenshots/testSplit'
trainSamples = trainAmount
testSamples = testAmount
epochs = epochs #should be more like 50
batchSize = 32
if K.image_data_format() == 'channels_first':
input_shape = (3, imgWidth, imgHeight)
else:
input_shape = (imgWidth, imgHeight, 3)
meanAcc =0
meanValAcc = 0
meanValLoss = 0
meanTrainLoss = 0
bestAcc = 0
listValAcc = []
listValLoss = []
listAcc = []
# callbacks
csv_logger = callbacks.CSVLogger('training' + str(datetime.datetime.now()) +'.log')
earlyStopping = callbacks.EarlyStopping(monitor='val_loss', min_delta=0.03, patience=4, verbose=1, mode='auto')
saveBestModel = callbacks.ModelCheckpoint('bestWeightsModel.h5', monitor='val_acc', verbose=1,
save_best_only=True, mode='auto')
history = callbacks.History()
for i in range(folds):
bestValAcc = 0
lowestValLoss = 50
print('training fold', i, '...')
splitPrepare(amountCroppedSplitDomino, amountCroppedSplitNoDomino, clean=cleanData, fractionOfTest=5)
startTime = datetime.datetime.now()
model = getModel(input_shape)
trainDataGen = ImageDataGenerator(rescale=1./255)
testDataGen = ImageDataGenerator(rescale=1./255)
trainingSet = trainDataGen.flow_from_directory(
trainDataDir,
target_size=(imgWidth, imgHeight),
batch_size=batchSize,
class_mode='binary')
testSet = testDataGen.flow_from_directory(
testDataDir,
target_size=(imgWidth, imgHeight),
batch_size=batchSize,
class_mode='binary')
if train:
print('training...')
history = model.fit_generator(
trainingSet,
steps_per_epoch=trainSamples // batchSize,
epochs=epochs,
validation_data=testSet,
validation_steps=testSamples // batchSize,
verbose=2, callbacks=[csv_logger, history, saveBestModel, earlyStopping])
# reload best weights
model.load_weights('bestWeightsModel.h5')
#model.save_weights(str(datetime.datetime.now()) + 'MODEL.h5')
else: # in case you only want to predict, not train
model.load_weights('23:20:23.h5')
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
validateImages(model)
utils.plot(history, epochs, trainSamples, testSamples)
endtime = datetime.datetime.now()
duration = endtime - startTime
print("duration of epoch: ", str(duration))
if max(history.history['val_acc']) > bestValAcc:
bestValAcc = max(history.history['val_acc'])
if min(history.history['val_loss']) < lowestValLoss:
lowestValLoss = min(history.history['val_loss'])
if max(history.history['acc']) > bestAcc:
bestAcc = max(history.history['acc'])
# these values are measured each epoch
val_acc = max(history.history['val_acc']) #ensures that the best epoch (regarding val acc) is used for measurements
index = history.history['val_acc'].index(val_acc)
loss = history.history['loss'][index] # takes the values on index[val_acc]
val_loss = history.history['val_loss'][index]
acc = history.history['acc'][index]
listValAcc.append(val_acc)
listValLoss.append(val_loss)
listAcc.append(acc)
print('best val_acc:', round(bestValAcc, 4))
print('lowest val_loss:', round(lowestValLoss, 4))
print('best acc:', round(bestAcc, 4))
if i == 0:
utils.latexTableTopline()
utils.latexTable(trainAmount, testAmount, epochs, history)
if i == folds-1:
overallValAccStdev = stdev(listValAcc)
overallValLossStdev = stdev(listValLoss)
absoluteDuration = datetime.datetime.now() - absoluteStartTime
utils.latexTableBottomline(absoluteDuration, bestValAcc, overallValAccStdev, overallValLossStdev)
if cleanData:
validateImages(model, 'screenshots/validationFolderClean')
else:
validateImages(model, 'screenshots/validationFolderFaulty')
#validateImages(model, 'screenshots/realLevelsSplit')
meanTrainLoss = meanTrainLoss/folds
meanValAcc = meanValAcc/folds
meanValLoss = meanValLoss/folds
meanAcc = meanAcc/folds
valAccStd = stdev(listValAcc)
valLossStd = stdev(listValLoss)
accStd = stdev(listAcc)
# these values are measured over ALL epochs
print('acc std:', round(accStd,4))
print('val acc std:', round(valAccStd,4))
print('val loss std:', round(valLossStd,4))
print('mean acc:', round(meanAcc,4))
print('meanTrainLoss:',round(meanTrainLoss,4))
print('meanValLoss:',round(meanValLoss,4))
print('meanValAcc:',round(meanValAcc,4))
# Train upper layers first
for layer in model.layers[:-2]:
layer.trainable = False
model.compile(optimizer='adam',
loss="categorical_crossentropy",
metrics=['accuracy'])
model.fit_generator(generator=training_generator,
validation_data=validation_generator,
use_multiprocessing=False,
workers=6,
epochs=1,
callbacks=[
callbacks.ModelCheckpoint("frozen_" + modelName,
save_best_only=True),
LRTensorBoard(log_dir="frozen_" + args.output)
])
# Restore the best weights and train the whole network
model = load_model("frozen_" + modelName)
for layer in model.layers:
layer.trainable = True
sgd = optimizers.SGD(lr=lr, momentum=momentum, decay=decay)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit_generator(generator=training_generator,
validation_data=validation_generator,
X_test = np.reshape(testT, (testT.shape[0], 1, testT.shape[1]))
batch_size = 16
# 1. define the network
model = Sequential()
model.add(LSTM(16, input_dim=61)) # try using a GRU instead, for fun
model.add(Dropout(0.1))
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'])
checkpointer = callbacks.ModelCheckpoint(
filepath="logs/lstm2/checkpoint-{epoch:02d}.hdf5",
verbose=1,
save_best_only=True,
monitor='loss')
csv_logger = CSVLogger('logs/lstm2/training_set_iranalysis.csv',
separator=',',
append=False)
model.fit(X_train,
y_train,
batch_size=batch_size,
nb_epoch=1000,
validation_data=(X_test, y_test),
callbacks=[checkpointer, csv_logger])
model.save("logs/lstm2/lstm1layer_model.hdf5")
def train():
print('-' * 30)
print('Loading and preprocessing train data...')
print('-' * 30)
imgs_train, imgs_gtruth_train = load_train_data()
print('-' * 30)
print('Loading and preprocessing validation data...')
print('-' * 30)
imgs_val, imgs_gtruth_val = load_validatation_data()
print('-' * 30)
print('Creating and compiling model...')
print('-' * 30)
if unet_model_type == 'default':
model = get_unet_default()
elif unet_model_type == 'reduced':
model = get_unet_reduced()
elif unet_model_type == 'extended':
model = get_unet_extended()
model.summary()
print('-' * 30)
print('Fitting model...')
print('-' * 30)
#============================================================================
print('training starting..')
log_filename = 'outputs/' + image_type + '_model_train.csv'
#Callback that streams epoch results to a csv file.
csv_log = callbacks.CSVLogger(log_filename, separator=',', append=True)
early_stopping = callbacks.EarlyStopping(monitor='val_loss',
min_delta=0,
patience=PATIENCE,
verbose=0,
mode='min')
#checkpoint_filepath = 'outputs/' + image_type +"_best_weight_model_{epoch:03d}_{val_loss:.4f}.hdf5"
checkpoint_filepath = 'outputs/' + 'weights.h5'
checkpoint = callbacks.ModelCheckpoint(checkpoint_filepath,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
#callbacks_list = [csv_log, checkpoint]
callbacks_list = [csv_log, early_stopping, checkpoint]
#============================================================================
hist = model.fit(
imgs_train,
imgs_gtruth_train,
batch_size=batch_size,
nb_epoch=nb_epochs,
verbose=1,
validation_data=(imgs_val, imgs_gtruth_val),
shuffle=True,
callbacks=callbacks_list) # validation_split=0.2,
model_name = 'outputs/' + image_type + '_model_last'
model.save(model_name) # creates a HDF5 file 'my_model.h5'
