def train():
# compile the model with all of the training parameters (should be done *after* setting layers to non-trainable)
model.compile(optimizer=training_config['optimizer'], loss=training_config['loss_function'],
metrics=training_config['metrics'])
# create csv logger to store to CSV
csv_logging = callbacks.CSVLogger(training_filepath, separator=',', append=False)
model_checkpoint = callbacks.ModelCheckpoint(snapshots_dir + 'weights.{epoch:02d}-{val_loss:.2f}.hdf5',
monitor='val_loss', verbose=0,
save_best_only=False, save_weights_only=False,
mode='auto', period=1)
# train the model on the new data for a few epochs
print "training model with full model"
model.fit_generator(
train_generator,
samples_per_epoch=nb_train_samples,
nb_epoch=training_config['nb_epoch'],
validation_data=val_generator,
nb_val_samples=nb_val_samples,
callbacks=[csv_logging, model_checkpoint]
)
from dataloader_test import test
from dataloader_train import train
from model import model
import matplotlib.pyplot as plt
%matplotlib inline
model.summary()
model.compile(loss = 'categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
history = model.fit_generator(train, epochs=25, validation_data = test, verbose = 1)
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
epochs = range(len(acc))
plt.plot(epochs, acc, 'r', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend(loc=0)
plt.figure()
plt.show()
from preprocess.generator import train_generator, valid_generator
# Custom loss function
def huber_loss(y_true, y_pred):
return tf.losses.huber_loss(y_true, y_pred)
# Creating the model
model = model()
model.summary()
# Compile
adam = Adam(lr=1e-5, beta_1=0.9, beta_2=0.999, epsilon=1e-10, decay=0.0)
model.compile(optimizer=adam, loss=huber_loss)
# Train
epochs = 10
train_gen = train_generator(sample_per_batch=2, batch_number=1690)
val_gen = valid_generator(sample_per_batch=50, batch_number=10)
checkpoints = ModelCheckpoint('weights/weights{epoch:03d}.h5', save_weights_only=True, period=1)
history = model.fit_generator(train_gen, steps_per_epoch=1690, epochs=epochs, verbose=1, shuffle=True,
validation_data=val_gen, validation_steps=10,
callbacks=[checkpoints], max_queue_size=100)
with open('history.txt', 'a+') as f:
print(history.history, file=f)
print('All Done!')
train_ = train(r)
p.append(train_[1].tolist())
q.append(train_[2].tolist())
# a_t = []
# for ii in train_[0]:
# for iii in ii:
# a_t.extend(iii)
# a.append(a_t)
a_t = []
for ii in train_[0].tolist():
a_t.extend(ii)
a.append(a_t)
an.append(train_[3].tolist())
p = np.array(p)
q = np.array(q)
a = np.array(a)
an = np.array(an)
print(p.shape, q.shape, a.shape, an.shape)
yield ([p, q, a], [a, an])
model = model()
model.fit_generator(dgen(),
steps_per_epoch=100,
epochs=30,
validation_data=dgen(),
validation_steps=20)
model.save('oporc_1.h5')
preprocess_function=preprocess_input)
reduce_lr_01 = ReduceLROnPlateau(monitor='val_1st_acc',
factor=0.2,
patience=5,
min_lr=0,
mode='max')
reduce_lr_02 = ReduceLROnPlateau(monitor='val_2nd_acc',
factor=0.2,
patience=5,
min_lr=0.,
mode='max')
reduce_lr_03 = ReduceLROnPlateau(monitor='val_3rd_acc',
factor=0.2,
patience=5,
min_lr=0,
mode='max')
reduce_lr_04 = ReduceLROnPlateau(monitor='val_4th_acc',
factor=0.2,
patience=5,
min_lr=0.,
mode='max')
for i in range(30):
f = model.fit_generator(
train_gen,
steps_per_epoch=7210 / 32,
epochs=1,
validation_data=test_gen,
validation_steps=1000 / 32,
callbacks=[reduce_lr_01, reduce_lr_02, reduce_lr_03, reduce_lr_04])
model.save_weights('weights/classifier.h5')
import dataset
from model import model
step_size_train = dataset.train_generator.n // dataset.train_generator.batch_size
epoch = 5
model.fit_generator(generator=dataset.train_generator, steps_per_epoch=step_size_train,epochs=epoch)
model.save('model.h5')
# 调用了super初始化了父类的构造函数
# 当需要继承父类构造函数中的内容，
# 且子类需要在父类的基础上补充时，使用super().__init__()方法
super().__init__()
# 赋一个较大的初始值
self.lowest = 1e10
def on_epoch_end(self, epoch, logs=None):
# 每个epoch训练完后调用 如果当前loss更低 就保存当前模型
# 也可以设置logs['loss'] 小于一个值时候停止训练
loss_value.append(logs['loss'])
print(loss_value)
if logs['loss'] <= self.lowest:
self.lowest = logs['loss']
model.save(BEST_MODEL_PATH)
# 随机生成几首 看看效果
# print()
# for i in range(5):
# print(write.generate_random(tokenizer, model))
# 创建数据集生成器
dataset = PDGenerator(poetry, random=True)
# 生成器与模型并行运行，以提高效率
model.fit_generator(dataset.for_fit(),
steps_per_epoch=dataset.steps,
epochs=TRAIN_EPOCHS,
callbacks=[Evaluate()])
import keras
from keras.callbacks import CSVLogger
import path
from model import model
import batch
import logger
path.run.make()
run = path.run.loadCurrent()
model.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
model.fit_generator(batch.trainIterator,
validation_data=batch.validationIterator,
steps_per_epoch=batch.trainIterator.n / batch.size,
epochs=8,
callbacks=[
keras.callbacks.CSVLogger(run.log,
separator=',',
append=False)
])
model.save(run.model)
logger.addModelDiagram(run)
logger.addModelSummary(run)
logger.addAccuracyPlot(run)
csv_data_path = "../data/driving_log.csv"
output_model_file_path = '../results/models/model.h5'
simulator_data = DataLoadHelper(csv_data_path)
train_generator = simulator_data.load_train_data_from_generator()
validation_generator = simulator_data.load_validation_data_from_generator()
#Clear any previous keras sessions
K.clear_session()
#Create an object to the model, compile, fit and save it to .h5 file
model = model(input_size=(160, 320, 3))
model.compile(loss='mse', optimizer='adam')
history_object = model.fit_generator(train_generator, samples_per_epoch=simulator_data.sample_training_size(), \
validation_data=validation_generator, nb_val_samples=simulator_data.sample_validation_size(),
nb_epoch=3, verbose=1)
model.save(output_model_file_path)
### print the keys contained in the history object
print(history_object.history.keys())
### plot the training and validation loss for each epoch
plt.plot(history_object.history['loss'])
plt.plot(history_object.history['val_loss'])
plt.title('model mean squared error loss')
plt.ylabel('mean squared error loss')
plt.xlabel('epoch')
plt.legend(['training set', 'validation set'], loc='upper right')
plt.show()
log_dir + "\\weights_epoch_{epoch:02d}-loss_{val_loss:.2f}.hdf5",
monitor='val_loss',
verbose=0,
save_best_only=False,
save_weights_only=False,
mode='auto',
period=1)
# lr_sched = keras.callbacks.LearningRateScheduler(lambda epoch: 0.002* 0.75 ** (epoch-1) )
cfm_callback = confusion_matrix_callback(train_generator,
validation_generator)
callbacks = [tensorboard_callback, reduce_lr, modelCP,
csv_logger] # , lr_sched] #, cfm_callback ]
# ------------------------------
# saved_weights = r"C:\Users\User\PycharmProjects\PlantPathology\logs\fit\20200331-120037\weights_epoch_17-loss_1.00.hdf5"
# saved_weights = r"C:\Users\User\PycharmProjects\PlantPathology\logs\fit\saved_weights\weights_epoch_34-loss_1.06.hdf5"
if C.MODEL == 'VGG' and C.PRETRAINED_VGG:
model.load_weights(C.PRETRAINED_VGG)
model.fit_generator(
train_generator,
validation_data=validation_generator,
epochs=500,
callbacks=callbacks,
verbose=True,
# class_weight=get_class_weights()
class_weight=1 / pd.Series(train_generator.classes).value_counts(),
# initial_epoch = 20,
# class_weight= 'auto',
)
import numpy as np
import random
from dataloader import CaptchaSequence
import string
characters = string.digits + string.ascii_uppercase
data = CaptchaSequence(characters, batch_size=2, steps=1000)
from tensorflow.keras.models import *
from tensorflow.keras.layers import *
from tensorflow.keras.callbacks import EarlyStopping, CSVLogger, ModelCheckpoint
from tensorflow.keras.optimizers import *
train_data = CaptchaSequence(characters, batch_size=128, steps=1000)
valid_data = CaptchaSequence(characters, batch_size=128, steps=100)
callbacks = [
EarlyStopping(patience=3),
CSVLogger('cnn.csv'),
ModelCheckpoint('cnn_best.h5', save_best_only=True)
]
from model import model
model.compile(loss='categorical_crossentropy',
optimizer=Adam(1e-3, amsgrad=True),
metrics=['accuracy'])
model.fit_generator(train_data,
epochs=100,
validation_data=valid_data,
workers=4,
use_multiprocessing=True,
callbacks=callbacks)
import tensorflow as tf
from dataset import PoetryDataGenerator, tokenizer, poetry
from model import model
import settings
import utils
class Evaluate(tf.keras.callbacks.Callback):
"""
在每个epoch训练完成后，保留最有权重，并随机生成settings.SHOW_NUM首古诗展示
"""
def __init__(self):
super().__init__()
self.lowest = 1e10
def on_epoch_end(self, epoch, logs=None):
if logs['loss'] <= self.lowest:
self.lowest = logs['loss']
model.save_weights(settings.BEST_MODEL_PATH)
for i in range(settings.SHOW_NUM):
print(utils.generate_random_poetry(tokenizer, model))
# 创建数据生成器
data_generator = PoetryDataGenerator(poetry, batch_size=settings.BATCH_SIZE)
# 开始训练
model.fit_generator(data_generator.forfit(),
steps_per_epoch=data_generator.steps,
epochs=settings.TRAIN_EPOCHS,
callbacks=[Evaluate()])
import pandas as pd
import numpy as np
import cv2 as cv
import h5py
ROOT_DIR = os.path.abspath('')
dataset_dir = os.path.join(ROOT_DIR, 'datasets/Affectnet')
sys.path.append(dataset_dir)
import data_loading as data
model_dir = os.path.join(ROOT_DIR, 'models/DeXpression')
sys.path.append(model_dir)
from model import model
image_size = (128, 128)
batch_size = 300
early_stopping = EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True)
train_datagen = image.ImageDataGenerator(rescale=1./255)
val_datagen = image.ImageDataGenerator(rescale=1./255)
dataset_imgs_dir = data.dataset_dir
train_generator = train_datagen.flow_from_dataframe(data.train_dataframe, directory=f'{dataset_imgs_dir}Manually_Annotated_Images', x_col='subDirectory_filePath', y_col='expression', target_size=image_size, batch_size=batch_size, drop_duplicates=False)
val_generator = val_datagen.flow_from_dataframe(data.val_dataframe, directory=f'{dataset_imgs_dir}Manually_Annotated_Images', x_col='subDirectory_filePath', y_col='expression', target_size=image_size, batch_size=batch_size)
model.fit_generator(train_generator, steps_per_epoch=414798/300, epochs=38, callbacks=[early_stopping], validation_data=val_generator, workers=12)
model.save('model_epoch_38_image_size_128_batch_300_1.h5')
BATCH_SIZE = 64
EPOCHS = 20
train_gen = data_gen(train_dir, BATCH_SIZE)
val_gen = data_gen(test_dir, BATCH_SIZE)
train_gen.build_data()
val_gen.build_data()
now = jdatetime.datetime.today()
model_folder_name = '%s-%s[%s-%s]__Model' % (now.month, now.day, now.hour,
now.minute)
os.mkdir('data\\models\\%s' % model_folder_name)
tensorboard_callback = k.callbacks.TensorBoard(log_dir='data\\models\\%s' %
(model_folder_name),
histogram_freq=1)
adam = k.optimizers.Adam()
model.compile(loss='mean_squared_error', optimizer=adam)
history = model.fit_generator(
generator=train_gen.next_batch(),
steps_per_epoch=int(train_gen.n / train_gen.batch_size),
epochs=EPOCHS,
validation_data=val_gen.next_batch(),
validation_steps=int(val_gen.n / val_gen.batch_size),
verbose=1,
callbacks=[tensorboard_callback])
model.save_weights('data\\models\\%s\\model.h5' % model_folder_name)
from keras.optimizers import SGD
import batch
from model import model
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=1e-3),
metrics=['accuracy'])
model.fit_generator(batch.trainingBatchIterator,
steps_per_epoch=batch.sampleSize / batch.size,
epochs=2)
model.save('fine_tune.h5')
train_indexes = indexes[:int(len(indexes) * 0.8)]
valid_indexes = indexes[int(len(indexes) * 0.8):]
train_datagen = DataGen.create_set(train_dataset_info[train_indexes],
BATCH_SIZE,
SHAPE,
augment=True)
valid_datagen = DataGen.create_set(train_dataset_info[valid_indexes],
BATCH_SIZE,
SHAPE,
augment=False)
history = model.fit_generator(train_datagen,
validation_data=next(valid_datagen),
steps_per_epoch=STEPS_PER_EPOCH,
epochs=EPOCHS,
verbose=1,
callbacks=[checkpointer, tensorboard])
submit = pd.read_csv('./res/sample_submission.csv')
predicted = []
for name in tqdm(submit["Id"]):
path = os.path.join('./res/test/', name)
image = DataGen.load_image(path, SHAPE)
score_predict = model.predict(image[np.newaxis])[0]
label_predict = np.arange(28)[score_predict >= 0.5]
str_predict_label = ' '.join(str(l) for l in label_predict)
predicted.append(str_predict_label)
submit['Predicted'] = predicted
from model import model
from properties import *
from keras.callbacks import BaseLogger, ModelCheckpoint
from data_generator import midi_input_generator, generate_song_array, save_array_to_midi
print "Training model"
#print generate_song_array(model)
#save_array_to_midi([generate_song_array(model)], 'Generated_zero.mid')
cp = ModelCheckpoint(model_check_point_file,
monitor='loss',
verbose=1,
save_best_only=True,
mode='max')
model.fit_generator(midi_input_generator(),
num_seq_in_epoch,
nb_epoch=num_epochs,
callbacks=[BaseLogger(), cp])
model.save_weights('net_dump.nw')
save_array_to_midi([generate_song_array(model)], 'Generated.mid')
md.train_dir,
target_size = (150, 150), #--> 모든 이미지를 150x150 으로 변경
batch_size = 10,
class_mode = 'binary' #--> oprimizer 부분에서 binary crossentropy loss를 사용해서 이진 레이블이 필요하다.
)
validation_generator = train_datagen.flow_from_directory(
md.validation_dir,
target_size=(150, 150),
batch_size=10,
class_mode = 'binary'
)
history = model.fit_generator(
train_generator,
steps_per_epoch=200,
epochs=30,
validation_data=validation_generator,
validation_steps=50)om_directory(
md.train_dir,
train_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
md.train_dir,
target_size = (150, 150), #--> 모든 이미지를 150x150 으로 변경
batch_size = 10,
class_mode = 'binary' #--> oprimizer 부분에서 binary crossentropy loss를 사용해서 이진 레이블이 필요하다.
)
validation_generator = train_datagen.flow_from_directory(
train_labels = to_categorical(train_labels, num_classes=10)
# Разделение обучающей выборки базы данных на обучение и валидацию
X_train, X_val, Y_train, Y_val = train_test_split(train_images,
train_labels,
test_size=0.1,
random_state=RANDOM_SEED)
# аугментация изображений
datagen = ImageDataGenerator(featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=15,
zoom_range=0.2,
width_shift_range=0.15,
height_shift_range=0.15,
horizontal_flip=False,
vertical_flip=False)
datagen.fit(X_train)
# Обучение
history = model.fit_generator(datagen.flow(X_train,
Y_train,
batch_size=BATCH_SIZE),
epochs=EPOCHS,
validation_data=(X_val, Y_val),
verbose=1,
steps_per_epoch=X_train.shape[0] // BATCH_SIZE,
callbacks=checkpoints)
from datetime import datetime
from tensorflow import keras
logdir = "./folder" + datetime.now().strftime("%Y%m%d-%H%M%S")
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=logdir)
from get_image_generator import train_generator, validation_generator, test_generator
from model import model
from meta_parameters import EPOCHS, STEPS_PER_EPOCH, VALIDATION_STEPS, BATCH_SIZE
model.fit_generator(
train_generator,
steps_per_epoch=STEPS_PER_EPOCH,
epochs=EPOCHS,
validation_data=validation_generator,
validation_steps=VALIDATION_STEPS,
use_multiprocessing=True,
callbacks=[tensorboard_callback],
)
model.save_weights('my_model_weights.h5')
print("evaluate", model.metrics_names)
print(model.evaluate_generator(
test_generator,
use_multiprocessing=True,
))
model.count_params()
model.summary()
#TODO numbe of parameters
color_mode = 'grayscale',
target_size = (img_rows, img_cols),
batch_size = batch_size,
class_mode = 'categorical',
shuffle = True
)
validation_generator = validation_datagen.flow_from_directory(
validation_data_dir,
color_mode = 'grayscale',
target_size = (img_rows, img_cols),
batch_size = batch_size,
class_mode = 'categorical',
shuffle = True
)
from model import model
#print(model.summary())
nb_train_samples = 28273
nb_validation_samples = 3534
epochs = 30
history = model.fit_generator(
train_generator,
steps_per_epoch = nb_train_samples // batch_size,
epochs = epochs,
callbacks = callbacks,
validation_data = validation_generator,
validation_steps = nb_validation_samples // batch_size)
