def test(self):
'''
use self.clf to get score/accuracy
prints accuracy
draws plot
'''
img_rows,img_columns = 45,45
test_data = self.test_img.reshape((self.test_img.shape[0], img_rows,img_columns))
test_data = test_data[:, np.newaxis, :, :]
label_map={}
count = 0
for folder in os.listdir("./data"):
label_map[folder]=count
count+=1
for j in range(len(self.test_labels)):
self.test_labels[j]=label_map[self.test_labels[j]]
total_classes = count
test_labels = np_utils.to_categorical(self.test_labels,total_classes)
sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
clf = CNN().build(img_rows,img_columns,1,total_classes,'model.h5')
clf.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy"])
loss, accuracy = clf.evaluate(test_data, test_labels, batch_size=self.b_size, verbose=1)
print('Accuracy of Model: {:.2f}%'.format(accuracy * 100))
return accuracy
def main():
# data generator
data_generator = ImageDataGenerator(
featurewise_center=False,
featurewise_std_normalization=False,
rotation_range=0,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=.1,
horizontal_flip=True)
model = CNN()
opt = optimizers.Adam(lr=0.0001)
# opt = optimizers.SGD(lr=0.001)
model.compile(opt, loss='categorical_crossentropy', metrics=['accuracy'])
model.summary()
# callbacks
f = open(base_path + 'gender_classification_training.log', 'w')
f.close()
log_file_path = base_path + 'gender_classification_training.log'
csv_logger = CSVLogger(log_file_path, append=False)
early_stop = EarlyStopping('val_loss', patience=patience)
reduce_lr = ReduceLROnPlateau('val_loss', factor=0.1, patience=int(patience/4), verbose=1)
trained_models = base_path + 'CNN.{epoch:02d}-{val_loss:.3f}-{val_acc:.2f}.hdf5'
# model_cp = ModelCheckpoint(trained_models, 'val_acc', verbose=1, save_best_only=True)
model_cp = ModelCheckpoint(trained_models, 'val_loss', verbose=1, save_best_only=True)
callbacks = [model_cp, csv_logger, early_stop, reduce_lr]
# load data
faces, labels = load_data(data_path)
print (len(faces))
print (len(labels))
faces = preprocess_input(faces)
order = np.argsort(np.random.random(len(faces)))
faces = faces[order]
labels = labels[order]
train_data, val_data = split_data(faces, labels, validation_split)
train_faces, train_labels = train_data
model.fit_generator(data_generator.flow(train_faces, train_labels, batch_size),
steps_per_epoch=len(train_faces)/batch_size,
epochs=num_epochs,
verbose=1,
callbacks=callbacks,
validation_data=val_data)
def train(self):
#Change data to required format
img_rows,img_columns = 45,45
train_data = self.train_img.reshape((self.train_img.shape[0], img_rows,img_columns))
train_data = train_data[:, np.newaxis, :, :]
test_data = self.test_img.reshape((self.test_img.shape[0], img_rows,img_columns))
test_data = test_data[:, np.newaxis, :, :]
label_map={}
count = 0
for folder in os.listdir("../src/data"):
label_map[folder]=count
count+=1
for i in range(len(self.train_labels)):
self.train_labels[i]=label_map[self.train_labels[i]]
for j in range(len(self.test_labels)):
self.test_labels[j]=label_map[self.test_labels[j]]
# Transform training and testing data to 10 classes in range [0,classes] ; num. of classes = 0 to 9 = 10 classes
total_classes = count
train_labels = np_utils.to_categorical(self.train_labels, total_classes)
test_labels = np_utils.to_categorical(self.test_labels,total_classes)
# Defing and compile the SGD optimizer and CNN model
print('\n Compiling model...')
sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
clf = CNN().build(img_rows,img_columns,1,total_classes)
clf.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy"])
# Initially train and test the model; If weight saved already, load the weights using arguments.
num_epoch = self.num_epoch # Number of epochs
verb = 1 # Verbose
print('\nTraining the Model...')
model_info=clf.fit(train_data, train_labels, batch_size=self.b_size, nb_epoch=num_epoch,verbose=verb)
# Evaluate accuracy and loss function of test data
print('Evaluating Accuracy and Loss Function...')
loss, accuracy = clf.evaluate(test_data, test_labels, batch_size=self.b_size, verbose=1)
print('Accuracy of Model',(accuracy * 100))
clf.save_weights('model.h5', overwrite=True)
print(model_info.history)
self.plot_model_history(model_info)
return accuracy
def run():
(X_train, y_train), (X_test, y_test) = datasets.load_data(img_rows=32,
img_cols=32)
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
model = CNN(input_shape=X_train.shape[1:], nb_classes=nb_classes)
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
X_train = preprocess_input(X_train)
X_test = preprocess_input(X_test)
csv_logger = CSVLogger('../log/cnn.log')
checkpointer = ModelCheckpoint(filepath="/tmp/weights.hdf5",
monitor="val_acc",
verbose=1,
save_best_only=True)
datagen = ImageDataGenerator(
featurewise_center=False, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=
False, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=
0, # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=
0.1, # randomly shift images horizontally (fraction of total width)
height_shift_range=
0.1, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=False) # randomly flip images
datagen.fit(X_train)
model.fit_generator(datagen.flow(X_train, Y_train, batch_size=batch_size),
samples_per_epoch=X_train.shape[0],
nb_epoch=nb_epoch,
validation_data=(X_test, Y_test),
callbacks=[csv_logger, checkpointer])
ds_train = tf.data.Dataset.list_files("data/train/*/*.jpg") \
.map(load_img,num_parallel_calls=tf.data.experimental.AUTOTUNE) \
.shuffle(buffer_size=1000).batch(BATCH_SIZE) \
.prefetch(tf.data.experimental.AUTOTUNE)
ds_test = tf.data.Dataset.list_files("data/test/*/*.jpg") \
.map(load_img,num_parallel_calls=tf.data.experimental.AUTOTUNE) \
.shuffle(buffer_size=1000).batch(BATCH_SIZE) \
.prefetch(tf.data.experimental.AUTOTUNE)
# 获得模型
model = CNN()
# 编译模型
model.compile(
optimizer='adam',
loss='binary_crossentropy',
metrics=["accuracy"]
)
# 训练中每个世代保存一次
cp_callback = ModelCheckpoint(
'logs/ep{epoch:02d}-loss{loss:.2f}.h5',
monitor='acc',save_weights_only=True,
)
# 训练模型
history = model.fit(ds_train,epochs=EPOCH,
validation_data=ds_test,
callbacks=[cp_callback],
)
# 保存最终模型
model.save_weights('logs/last1.h5')
def main():
(X_train, y_train), (X_test,
y_test) = imdb.load_data(num_words=MAX_NUM_WORDS)
X = np.concatenate((X_train, X_test), axis=0)
y = np.concatenate((y_train, y_test), axis=0)
labels = to_categorical(y)
print('Training samples: %i' % len(X))
# docs = negative_docs + positive_docs
# labels = [0 for _ in range(len(negative_docs))] + [1 for _ in range(len(positive_docs))]
# labels = to_categorical(labels)
# print('Training samples: %i' % len(docs))
# tokenizer.fit_on_texts(docs)
# sequences = tokenizer.texts_to_sequences(docs)
# word_index = tokenizer.word_index
result = [len(x) for x in X]
print('Text informations:')
print(
'max length: %i / min length: %i / mean length: %i / limit length: %i'
% (np.max(result), np.min(result), np.mean(result), MAX_SEQ_LENGTH))
# print('vacobulary size: %i / limit: %i' % (len(word_index), MAX_NUM_WORDS))
# Padding all sequences to same length of `MAX_SEQ_LENGTH`
data = pad_sequences(X, maxlen=MAX_SEQ_LENGTH, padding='post')
histories = []
for i in range(RUNS):
print('Running iteration %i/%i' % (i + 1, RUNS))
random_state = np.random.randint(1000)
X_train, X_val, y_train, y_val = train_test_split(
data, labels, test_size=VAL_SIZE, random_state=random_state)
emb_layer = None
# if USE_GLOVE:
# emb_layer = create_glove_embeddings()
model = CNN(embedding_layer=emb_layer,
num_words=MAX_NUM_WORDS,
embedding_dim=EMBEDDING_DIM,
filter_sizes=FILTER_SIZES,
feature_maps=FEATURE_MAPS,
max_seq_length=MAX_SEQ_LENGTH,
dropout_rate=DROPOUT_RATE,
hidden_units=HIDDEN_UNITS,
nb_classes=NB_CLASSES).build_model()
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(),
metrics=['accuracy'])
if i == 0:
print(model.summary())
plot_model(model,
to_file='cnn_model.png',
show_layer_names=False,
show_shapes=True)
history = model.fit(
X_train,
y_train,
epochs=NB_EPOCHS,
batch_size=BATCH_SIZE,
verbose=1,
validation_data=(X_val, y_val),
callbacks=[
# TQDMCallback(),
ModelCheckpoint('model-%i.h5' % (i + 1),
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min'),
# TensorBoard(log_dir='./logs/temp', write_graph=True)
])
print()
histories.append(history.history)
with open('history.pkl', 'wb') as f:
pickle.dump(histories, f)
histories = pickle.load(open('history.pkl', 'rb'))
def get_avg(histories, his_key):
tmp = []
for history in histories:
tmp.append(history[his_key][np.argmin(history['val_loss'])])
return np.mean(tmp)
print('Training: \t%0.4f loss / %0.4f acc' %
(get_avg(histories, 'loss'), get_avg(histories, 'acc')))
print('Validation: \t%0.4f loss / %0.4f acc' %
(get_avg(histories, 'val_loss'), get_avg(histories, 'val_acc')))
plot_acc_loss('training', histories, 'acc', 'loss')
plot_acc_loss('validation', histories, 'val_acc', 'val_loss')
# Divide data into testing and training sets.
train_img, test_img, train_labels, test_labels = cross_validation.train_test_split(mnist_data/255.0, dataset.target.astype("int"), test_size=0.1)
# Now each image rows and columns are of 28x28 matrix type.
img_rows,img_columns = 28,28
# Transform training and testing data to 10 classes in range [0,classes] ; num. of classes = 0 to 9 = 10 classes
total_classes = 10 # 0 to 9 labels
train_labels = np_utils.to_categorical(train_labels, 10)
test_labels = np_utils.to_categorical(test_labels, 10)
# Defing and compile the SGD optimizer and CNN model
print('\n Compiling model...')
sgd = optimisers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
clf = CNN(width=img_rows, height=img_columns, depth=1, total_classes=total_classes, weightsPath=args["weights"])
clf.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy"])
# Initially train and test the model; If weight saved already, load the weights using arguments.
b_size = 128 # Batch size
num_epoch = 20 # Number of epochs
verb = 1 # Verbose
# If weights saved and argument load_model; Load the pre-trained model.
if args["load_model"] < 0:
print('\nTraining the Model...')
clf.fit(trainData, trainLabels, batch_size=b_size, nb_epoch=num_epoch,verbose=verb)
# Evaluate accuracy and loss function of test data
print('Evaluating Accuracy and Loss Function...')
loss, accuracy = clf.evaluate(test_img, test_labels, batch_size=128, verbose=1)
print('Accuracy of Model: {:.2f}%'.format(accuracy * 100))
