def fit_model_on_fold(self, compiled_model: Model, curr_fold_indices,
train_sequences, test_sequences):
"""
trains compiled (but previously unfitted) model against given indices
:param compiled_model:
:param curr_fold_indices:
:param train_sequences:
:param test_sequences:
:return:
"""
train_indices, val_indices = curr_fold_indices
x_train = train_sequences[train_indices]
y_train = self.raw_train_df[
self.target_cols].iloc[train_indices].values
train_generator = ELMoTFHubGenerator(
x_train,
y_train,
batch_size=self.batch_size,
shuffle=True,
num_processes=self.num_processes).batch_generator()
x_val = train_sequences[val_indices]
y_val = self.raw_train_df[self.target_cols].iloc[val_indices].values
val_generator = ELMoTFHubGenerator(
x_val,
y_val,
batch_size=self.batch_size,
shuffle=False,
num_processes=self.num_processes).batch_generator()
test_generator = ELMoTFHubGenerator(
test_sequences,
None,
batch_size=self.batch_size,
shuffle=False,
num_processes=self.num_processes).batch_generator()
compiled_model.fit(
train_generator,
steps_per_epoch=len(train_indices) // self.batch_size,
epochs=self.epochs,
validation_data=val_generator,
validation_steps=len(val_indices) // self.batch_size)
val_pred = compiled_model.predict_generator(val_generator,
steps=len(val_indices) //
self.batch_size,
verbose=0)
val_roc_auc_score = roc_auc_score(y_val, val_pred)
print('ROC-AUC val score: {0:.4f}'.format(val_roc_auc_score))
test_pred = compiled_model.predict_generator(
test_generator,
steps=len(test_sequences) // self.batch_size,
verbose=0)
return val_roc_auc_score, test_pred
def default_categorical():
img_in = Input(
shape=(120, 160, 3), name='img_in'
) # First layer, input layer, Shape comes from camera.py resolution, RGB
x = img_in
x = Convolution2D(24, (5, 5), strides=(2, 2), activation='relu')(
x
) # 24 features, 5 pixel x 5 pixel kernel (convolution, feauture) window, 2wx2h stride, relu activation
x = Convolution2D(32, (5, 5), strides=(2, 2), activation='relu')(
x) # 32 features, 5px5p kernel window, 2wx2h stride, relu activatiion
x = Convolution2D(64, (5, 5), strides=(2, 2), activation='relu')(
x) # 64 features, 5px5p kernal window, 2wx2h stride, relu
x = Convolution2D(64, (3, 3), strides=(2, 2), activation='relu')(
x) # 64 features, 3px3p kernal window, 2wx2h stride, relu
x = Convolution2D(64, (3, 3), strides=(1, 1), activation='relu')(
x) # 64 features, 3px3p kernal window, 1wx1h stride, relu
# Possibly add MaxPooling (will make it less sensitive to position in image). Camera angle fixed, so may not to be needed
x = Flatten(name='flattened')(x) # Flatten to 1D (Fully connected)
x = Dense(100, activation='relu')(
x) # Classify the data into 100 features, make all negatives 0
x = Dropout(.1)(
x
) # Randomly drop out (turn off) 10% of the neurons (Prevent overfitting)
x = Dense(50, activation='relu')(
x) # Classify the data into 50 features, make all negatives 0
x = Dropout(.1)(
x) # Randomly drop out 10% of the neurons (Prevent overfitting)
# categorical output of the angle
angle_out = Dense(15, activation='softmax', name='angle_out')(
x
) # Connect every input with every output and output 15 hidden units. Use Softmax to give percentage. 15 categories and find best one based off percentage 0.0-1.0
# continous output of throttle
throttle_out = Dense(1, activation='relu', name='throttle_out')(
x) # Reduce to 1 number, Positive number only
model = Model(inputs=[img_in], outputs=[angle_out, throttle_out])
model.compile(optimizer='adam',
loss={
'angle_out': 'categorical_crossentropy',
'throttle_out': 'mean_absolute_error'
},
loss_weights={
'angle_out': 0.9,
'throttle_out': .01
})
model.predict_generator()
return model
class ConvMnist:
def __init__(self, filename=None):
'''
学習済みモデルファイルをロードする (optional)
'''
self.model = None
if filename is not None:
print('load model: ', filename)
self.model = load_model(filename)
self.model.summary()
def preprocess_input(x, **kwargs):
'''
画像前処理(ここでは何もしない)
'''
# x = 255 - x
return x.astype(np.float32)
def train(self):
'''
学習する
'''
# Convolutionモデルの作成
input = Input(shape=(MODEL_WIDTH, MODEL_HEIGHT, 1))
conv1 = Conv2D(filters=8,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(input)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(filters=4,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
activation='relu')(pool1)
dropout1 = Dropout(0.2)(conv2)
flatten1 = Flatten()(dropout1)
output = Dense(units=10, activation='softmax')(flatten1)
self.model = Model(inputs=[input], outputs=[output])
self.model.summary()
self.model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
## fit_generatorを使用する場合。windowsだと遅い(画像読み込みをうまく並列化できない)
# データセットをディレクトリ内画像から読み込む用意
idg_train = ImageDataGenerator(
validation_split=0.2,
rescale=1 / 255.,
# preprocessing_function=preprocess_input
)
# training用データのgenerator(全学習画像の内80%)
img_itr_train = idg_train.flow_from_directory(
'mnist_images/train',
subset="training",
color_mode="grayscale",
target_size=(MODEL_WIDTH, MODEL_HEIGHT),
batch_size=BATCH_SIZE,
class_mode='categorical',
)
# validation用データのgenerator(全学習画像の内20%)
img_itr_validation = idg_train.flow_from_directory(
'mnist_images/train',
subset="validation",
color_mode="grayscale",
target_size=(MODEL_WIDTH, MODEL_HEIGHT),
batch_size=BATCH_SIZE,
class_mode='categorical',
)
# Convolutionモデルの学習
self.model.fit_generator(
img_itr_train,
steps_per_epoch=math.ceil(img_itr_train.samples / BATCH_SIZE),
epochs=EPOCH_NUM,
validation_data=img_itr_validation,
validation_steps=math.ceil(img_itr_validation.samples /
BATCH_SIZE),
)
# テスト用データで評価する
idg_test = ImageDataGenerator(
rescale=1 / 255.,
# preprocessing_function=preprocess_input
)
img_itr_test = idg_test.flow_from_directory('mnist_images/test',
color_mode="grayscale",
target_size=(MODEL_WIDTH,
MODEL_HEIGHT),
batch_size=BATCH_SIZE,
class_mode=None,
shuffle=False)
# 識別処理実施
probs = self.model.predict_generator(
img_itr_test, steps=math.ceil(img_itr_test.samples / BATCH_SIZE))
# 識別精度を計算
predictions = np.argmax(probs, axis=1)
print("score: " +
str(1.0 * np.sum(predictions == img_itr_test.classes) /
img_itr_test.n))
def save_trained_model(self, filename):
'''
学習済みモデルをファイル(h5)に保存する
'''
self.model.save(filename)
def predict(self, input_image):
'''
1つのグレースケール入力画像(28x28のndarray)に対して、数字(0～9)を判定する
ret: result, score
'''
if input_image.shape != (MODEL_WIDTH, MODEL_HEIGHT):
return -1, -1
input_image = input_image.reshape(1, input_image.shape[0],
input_image.shape[1], 1)
input_image = input_image / 255.
probs = self.model.predict(input_image)
result = np.argmax(probs[0])
return result, probs[0][result]
# ---------------------------------------------
# TRAIN TOP LAYERS ON NEW DATA FOR A FEW EPOCHS|
# ---------------------------------------------
post_training_model = model.fit_generator(training_generator,
steps_per_epoch=((hprm['TRAIN_SIZE'] // hprm['BATCH_SIZE'])+1),
epochs=10, # number of epochs, training cycles
validation_data=validation_generator, # performance eval on test set
validation_steps=((hprm['TEST_SIZE'] // hprm['BATCH_SIZE'])+1),
verbose=1,
callbacks=[history,
npt_monitor])
# validation_output_callback])
y_pred = model.predict_generator(validation_generator,
steps=(hprm['TEST_SIZE'] // hprm['BATCH_SIZE'])+1,
callbacks=[],
verbose=1)
# ---------------------------------------------------------------------------------------------------------------------
# --------------------------------------
# EXPORT MODEL ARCHITECTURE AND WEIGHTS |
# --------------------------------------
# export model structure to json file:
model_struct_json = model.to_json()
filename = filepattern('model_allfreeze_', '.json')
with open(filename, 'w') as f:
f.write(model_struct_json)
# export weights to an hdf5 file:
w_filename = filepattern('weights_allfreeze_', '.h5')
model.save_weights(w_filename)
opt = optimizers.SGD(lr=1e-3, momentum=0.9)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
for layer in basemodel.layers:
layer.trainable = False
train_generator = DataGenerator(indexes=train, **generator_parameters)
val_generator = DataGenerator(indexes=test, **generator_parameters)
model.fit_generator(generator=train_generator,
validation_data=val_generator,
epochs=8)
model.save("%s/VGG16_%s.h5" % (dump_folder, fold_id))
generator_parameters["shuffle"] = False
val_generator = DataGenerator(indexes=test, **generator_parameters)
y_pred_raw = model.predict_generator(val_generator)
y_pred = np.argmax(y_pred_raw, axis=-1)
y_true = np.argmax(y[test], axis=-1)
model_predictions = ({
"path":
np.array(metadata_df.path.values.tolist())[test],
"y_true":
y_true,
"y_pred":
y_pred,
"y_pred_raw":
y_pred_raw.tolist()
})
# export new data
model_predictions_df = pd.DataFrame(model_predictions)
model_predictions_df.to_csv(
metrics=['accuracy'])
"""
8. 重新训练组合的新模型，仍然保持 VGG16 的 15 个最低层处于冻结状态。在这个特定的例子中，也使用 Image Augumentator 来增强训练集：
"""
train_datagen = ImageDataGenerator(rescale=1. / 255, horizontal_flip=True)
test_datagen = ImageDataGenerator(rescale=1. / 255)
train_generator = train_datagen.flow_from_directory(train_data_dir,
target_size=(img_height,
img_width),
batch_size=batch_size,
class_mode='binary')
validation_generator = test_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='binary',
shuffle=False)
model.fit_generator(train_generator,
steps_per_epoch=nb_train_samples // batch_size,
epochs=epochs,
validation_data=nb_validation_samples // batch_size,
verbose=2,
workers=12)
"""
9. 在组合网络上评估结果
"""
score = model.evaluate_generator(validation_generator,
nb_validation_samples / batch_size)
scores = model.predict_generator(validation_generator,
nb_validation_samples / batch_size)
# print(score, scores)
target_size = (image_size, image_size),
batch_size = BATCH_SIZE_TESTING,
class_mode = None,
shuffle = False,
seed = 123
)
#Need to compile layer[0] for extracting the 256- dim features.
#model.layers[1].compile(optimizer = sgd, loss = OBJECTIVE_FUNCTION, metrics = LOSS_METRICS)
test_generator.reset()
#pred = model.layers[1].predict_generator(test_generator, steps = len(test_generator), verbose = 1)
f = Model(inputs=model.input,outputs=model.get_layer('dense').output)
f.compile(optimizer = sgd, loss = OBJECTIVE_FUNCTION, metrics = LOSS_METRICS)
for idx,layer in enumerate(f.layers):
if(layer.name == 'dense'):
print(idx,layer.name)
#print(layer.get_weights())
print("________________")
pred = f.predict_generator(test_generator, steps = len(test_generator), verbose = 1)
#Predicted labels
#pred2 = model.predict_generator(test_generator, steps = len(test_generator), verbose = 1)
#predicted_class_indices = np.argmax(pred2, axis = 1)
fname = test_generator.filenames
sio.savemat('sketchmatnew.mat',mdict={'feature':pred,'label':fname})
print(pred.shape)
# buraya batch halinde alınan resimleri veriyoruz
# steps per epoch her epochta kaç adımda verilerin tümünü alıcak toplam veri sayısı bölü batch boyutu
model.fit_generator(train_batches,
steps_per_epoch=4,
validation_data=valid_batches,
validation_steps=4,
epochs=10)
test_images, test_labels = next(test_batches)
print(test_batches.class_indices) # cat 0. indis dog 1. indis
# test_labels = test_labels[:, 0]
# print(test_labels)
Categories = ['Cat', 'Dog']
predictions = model.predict_generator(test_batches, steps=1)
for i in predictions:
print(i)
#saving model
model.save('dog_or_cat_mobilnet.h5')
def prepare_image(file):
img = image.load_img(file, target_size=(224, 224))
img_array = image.img_to_array(img)
img_array_expanded_dims = np.expand_dims(img_array, axis=0)
return mobilenet.preprocess_input(
img_array_expanded_dims) #imagei 0 ile 1 arasında normalize eder
model.load_weights('./weights/starter.hdf5')
test_paths = glob(os.path.join(data_dir, 'test/audio/*wav'))
def test_generator(test_batch_size):
while True:
for start in range(0, len(test_paths), test_batch_size):
x_batch = []
end = min(start + test_batch_size, len(test_paths))
this_paths = test_paths[start:end]
for x in this_paths:
x_batch.append(process_wav_file(x))
x_batch = np.array(x_batch)
yield x_batch
predictions = model.predict_generator(test_generator(64), int(np.ceil(len(test_paths)*1.0/64)))
classes = np.argmax(predictions, axis=1)
# last batch will contain padding, so remove duplicates
submission = dict()
for i in range(len(test_paths)):
fname, label = os.path.basename(test_paths[i]), id2name[classes[i]]
submission[fname] = label
with open('starter_submission.csv', 'w') as fout:
fout.write('fname,label\n')
for fname, label in submission.items():
fout.write('{},{}\n'.format(fname, label))
from fashion.data.data_generatorAGR import DataGeneratorAgro
from fashion.settings import settings
# set gpu
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
os.environ["KERAS_BACKEND"] = "tensorflow"
# gpu growth
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
K.set_session(sess)
model = ResNet50(weights='imagenet')
# input = (224,224,3)
LAYER = "avg_pool"
model = Model(inputs=model.input, outputs=model.get_layer(LAYER).output)
pic_paths = glob.glob(settings["agro_path"] + "**/*", recursive=True)
# WARNING WE SLICE SOME VALUES
pic_df = pd.DataFrame({"path":
pic_paths}) #[:len(pic_paths) - (len(pic_paths) % 16)]
data_generatorAgro = DataGeneratorAgro(pic_df, batch_size=128)
predict = model.predict_generator(data_generatorAgro, verbose=1)
np.save("AGRO.npy", predict)
def predict_densenet121():
# DesneNet generators
test_batches = ImageDataGenerator(
preprocessing_function= \
applications.densenet.preprocess_input).flow_from_directory(
test2_path,
target_size=(image_size, image_size),
batch_size=test_batch_size,
shuffle=False)
input_tensor = Input(shape=(224, 224, 3))
#Loading the model
model = DenseNet121(input_tensor=input_tensor,
weights='imagenet',
include_top=False)
# add a global spatial average pooling layer
x = model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(7, activation='softmax')(x)
# this is the model we will train
model = Model(inputs=model.input, outputs=predictions)
model.load_weights('modelDenseNet121.h5')
test_batches.reset()
test_labels = test_batches.classes
# Make predictions
predictions = model.predict_generator(test_batches,
steps=test_steps,
verbose=1)
# Declare a function for plotting the confusion matrix
def plot_confusion_matrix(cm,
classes,
normalize=False,
title='Confusion matrix',
cmap=plt.cm.Blues):
"""
This function prints and plots the confusion matrix.
Normalization can be applied by setting `normalize=True`.
"""
if normalize:
cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
print("Normalized confusion matrix")
else:
print('Confusion matrix, without normalization')
print(cm)
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=45)
plt.yticks(tick_marks, classes)
fmt = '.2f' if normalize else 'd'
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j,
i,
format(cm[i, j], fmt),
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.ylabel('True label')
plt.xlabel('Predicted label')
plt.tight_layout()
plt.savefig('confusion_matrix_DenseNet121.png')
cm = confusion_matrix(test_labels, predictions.argmax(axis=1))
cm_plot_labels = ['akiec', 'bcc', 'bkl', 'df', 'mel', 'nv', 'vasc']
plot_confusion_matrix(cm, cm_plot_labels)
recall = np.diag(cm) / np.sum(cm, axis=1)
precision = np.diag(cm) / np.sum(cm, axis=0)
print("Mean recall " + str(np.mean(recall).item()))
print("Mean precision " + str(np.mean(precision).item()))
print("Mean recall " + str(
recall_score(
test_labels, predictions.argmax(axis=1), average='weighted')))
print("Balanced Accuracy " +
str(balanced_accuracy_score(test_labels, predictions.argmax(
axis=1))))
print("Mean Precision " + str(
precision_score(
test_labels, predictions.argmax(axis=1), average='weighted')))
print("Mean f1 score " + str(
f1_score(test_labels, predictions.argmax(axis=1), average='weighted')))
file = open("DenseNet121_results_last", "w+")
file.write("Mean recall " + str(np.mean(recall).item()) + "\n")
file.write("Mean precision " + str(np.mean(precision).item()) + "\n")
file.write("Mean recall " + str(
recall_score(
test_labels, predictions.argmax(axis=1), average='weighted')) +
"\n")
file.write(
"Balanced Accuracy " +
str(balanced_accuracy_score(test_labels, predictions.argmax(axis=1))) +
"\n")
file.write("Mean Precision " + str(
precision_score(
test_labels, predictions.argmax(axis=1), average='weighted')) +
"\n")
file.write("Mean f1 score " + str(
f1_score(test_labels, predictions.argmax(
axis=1), average='weighted')) + "\n")
file.close()
predicted_class_indices = np.argmax(predictions, axis=1)
labels = train_batches.class_indices
labels = dict((v, k) for k, v in labels.items())
predictions = [labels[k] for k in predicted_class_indices]
filenames = test_batches.filenames
results = pd.DataFrame({
"Filename": filenames,
"DenseNet121_Predictions": predictions
})
results.to_csv("test_prediction_densenet121.csv", index=False)
test_paths = glob(os.path.join('./test/', 'test/*wav'))
def test_generator(test_batch_size):
while True:
for start in range(0, len(test_paths), test_batch_size):
x_batch = []
end = min(start + test_batch_size, len(test_paths))
this_paths = test_paths[start:end]
for x in this_paths:
x_batch.append(process_wav_file(x))
x_batch = np.array(x_batch)
yield x_batch
predictions = model.predict_generator(test_generator(50),
int(np.ceil(len(test_paths) / 50)))
classes = np.argmax(predictions, axis=1)
# last batch will contain padding, so remove duplicates
submission = dict()
for i in range(0, 10500):
fname, label = os.path.basename(test_paths[i]), id2name[classes[i]]
submission[fname] = label
with open('H5.csv', 'w') as fout:
fout.write('fname,label\n')
for fname, label in submission.items():
fout.write('{},{}\n'.format(fname, label))
def test_generator(test_batch_size):
while True:
for start in range(0, len(test_paths), test_batch_size):
x_batch = []
x_batch_1d = []
end = min(start + test_batch_size, len(test_paths))
this_paths = test_paths[start:end]
for x in this_paths:
x_2d, x_1d = process_wav_file(x, phase='TEST')
x_batch.append(x_2d)
x_batch_1d.append(x_1d)
x_batch = np.array(x_batch)
x_batch_1d = np.array(x_batch_1d)
yield [x_batch, x_batch_1d]
predictions = model.predict_generator(
test_generator(batch_size), int(np.ceil(len(test_paths) / batch_size)))
classes = np.argmax(predictions, axis=1)
# last batch will contain padding, so remove duplicates
submission = dict()
for i in range(len(test_paths)):
fname, label = os.path.basename(test_paths[i]), id2name[classes[i]]
submission[fname] = label
with open(root_dir + weight_name + '.csv', 'w') as fout:
fout.write('fname,label\n')
for fname, label in submission.items():
fout.write('{},{}\n'.format(fname, label))
def get_apoz(model, layer, x_val, node_indexes=None):
"""Identify neurons with high Average Percentage of Zeros (APoZ).
The APoZ a.k.a. (A)verage (P)ercentage (o)f activations equal to (Z)ero,
is a metric for the usefulness of a channel defined in this paper:
"Network Trimming: A Data-Driven Neuron Pruning Approach towards Efficient
Deep Architectures" - [Hu et al. (2016)][]
`high_apoz()` enables the pruning methodology described in this paper to be
replicated.
If node_indexes are not specified and the layer is shared within the model
the APoZ will be calculated over all instances of the shared layer.
Args:
model: A Keras model.
layer: The layer whose channels will be evaluated for pruning.
x_val: The input of the validation set. This will be used to calculate
the activations of the layer of interest.
node_indexes(list[int]): (optional) A list of node indices.
Returns:
List of the APoZ values for each channel in the layer.
"""
if isinstance(layer, str):
layer = model.get_layer(name=layer)
# Check that layer is in the model
if layer not in model.layers:
raise ValueError('layer is not a valid Layer in model.')
layer_node_indices = utils.find_nodes_in_model(model, layer)
# If no nodes are specified, all of the layer's inbound nodes which are
# in model are selected.
if not node_indexes:
node_indexes = layer_node_indices
# Check for duplicate node indices
elif len(node_indexes) != len(set(node_indexes)):
raise ValueError('`node_indexes` contains duplicate values.')
# Check that all of the selected nodes are in the layer
elif not set(node_indexes).issubset(layer_node_indices):
raise ValueError('One or more nodes specified by `layer` and '
'`node_indexes` are not in `model`.')
data_format = getattr(layer, 'data_format', 'channels_last')
# Perform the forward pass and get the activations of the layer.
mean_calculator = utils.MeanCalculator(sum_axis=0)
for node_index in node_indexes:
act_layer, act_index = utils.find_activation_layer(layer, node_index)
# Get activations
if hasattr(x_val, "__iter__") and not isinstance(x_val, np.ndarray):
temp_model = Model(model.inputs,
act_layer.get_output_at(act_index))
a = temp_model.predict_generator(
x_val, x_val.n // x_val.batch_size)
else:
get_activations = k.function(model.input, act_layer.output)
a = get_activations([x_val, 0])
# Ensure that the channels axis is last
if data_format == 'channels_first':
a = np.swapaxes(a, 1, -1)
# Flatten all except channels axis
activations = np.reshape(a, [-1, a.shape[-1]])
zeros = (activations == 0).astype(int)
mean_calculator.add(zeros)
return mean_calculator.calculate()
