def train_model_CV(slices_images, slices_labels, slice_number, f):
'''
Training model using cross-validation passing the slices manually
Parameters
----------
slices_images: list of numpy.array
slices_labels: list of numpy.array
Output
----------
Write in a results file the mean of the accuracy in the test set
'''
#images,labels,list_of_images = reorderRandomly(images,labels,list_of_images)
'''
for i in range(len(labels)):
if labels[i] == "AD":
labels[i] = 0
else:
labels[i] = 1
slices_images = [images[i::5] for i in range(5)]
slices_list_of_images = [list_of_images[i::5] for i in range(5)]
slices_labels = [labels[i::5] for i in range(5)]
print(slices_list_of_images)
'''
values_acc = []
for i in range(5):
model = create_model()
X_test = slices_images[i]
Y_test = slices_labels[i]
X_train = [
item for s in slices_images if s is not X_test for item in s
]
Y_train = [
item for s in slices_labels if s is not Y_test for item in s
]
X_train = np.array(X_train)
Y_train = np.array(Y_train)
X_test = np.array(X_test)
Y_test = np.array(Y_test)
from keras.utils.np_utils import to_categorical
Y_train = to_categorical(Y_train)
Y_test = to_categorical(Y_test)
history = model.fit(X_train,
Y_train,
epochs=70,
batch_size=5,
verbose=0)
test_loss = model.evaluate(X_test, Y_test)
print("Loss and accuracy in the test set: Loss %g, Accuracy %g" %
(test_loss[0], test_loss[1]))
values_acc.append(test_loss[1])
mean = calculate_mean(values_acc)
f.write(("The mean of all the test values for the slice %g is: %g \n" %
(slice_number, mean)))
def __init__(self, tab_x, tab_y):
self.tab_x = np.array(tab_x, dtype=np.float64)
self.tab_y = np.array(tab_y, dtype=np.float64)
self.min_x = self.tab_x.min()
self.max_x = self.tab_x.max()
self.min_y = self.tab_y.min()
self.max_y = self.tab_y.max()
self.norm_tab_x = utils.normalize(self.tab_x, self.max_x, self.min_x)
self.norm_tab_y = utils.normalize(self.tab_y, self.max_y, self.min_y)
self.sorted_tab_x, self.sorted_tab_y = zip(*sorted(zip(self.tab_x, self.tab_y)))
self.theta0 = 0
self.norm_theta0 = 0
self.theta1 = 0
self.norm_theta1 = 0
self.mean_x = utils.calculate_mean(self.tab_y, self.tab_x)
self.mean_y = utils.calculate_mean(self.tab_x, self.tab_y)
def train_model_CV_generator(images, labels, model, train_datagen):
'''
Training model using cross-validation
Parameters
----------
'''
train_datagen = ImageDataGenerator(horizontal_flip=True)
images, labels = reorderRandomly(images, labels)
for i in range(len(labels)):
if labels[i] == "AD":
labels[i] = 0
else:
labels[i] = 1
slices_images = [images[i::5] for i in range(5)]
slices_labels = [labels[i::5] for i in range(5)]
models = {}
histories = {}
values_acc = []
for i in range(5):
model = create_model()
X_test = slices_images[i]
Y_test = slices_labels[i]
X_train = [
item for s in slices_images if s is not X_test for item in s
]
Y_train = [
item for s in slices_labels if s is not Y_test for item in s
]
X_train = np.array(X_train)
Y_train = np.array(Y_train)
X_test = np.array(X_test)
Y_test = np.array(Y_test)
from keras.utils.np_utils import to_categorical
Y_train = to_categorical(Y_train)
Y_test = to_categorical(Y_test)
history = model.fit_generator(train_datagen.flow(X_train,
Y_train,
batch_size=5),
epochs=70,
steps_per_epoch=len(X_train) // 5)
models['model' + str(i)] = model
test_loss = model.evaluate(X_test, Y_test)
print("Loss and accuracy in the test set: Loss %g, Accuracy %g" %
(test_loss[0], test_loss[1]))
histories['test_acc' + str(i)] = test_loss
values_acc.append(test_loss[1])
mean = calculate_mean(values_acc)
print("The mean of all the test values is: %g" % mean)
def train_LOO(images, labels):
'''
Training model using LOO validation using all the images
Parameters
----------
images: list of numpy.array
labels: list of numpy.array
Output
----------
Print the mean of the LOO validation
'''
values_acc = []
for i in range(len(labels)):
if labels[i] == "AD":
labels[i] = 0
else:
labels[i] = 1
print("The lenght of images is " + str(len(images)))
for i in range(len(images)):
print("We are in the fold " + str(i))
model = create_model()
X_test = []
Y_test = []
X_test.append(images[i])
Y_test.append(labels[i])
X_train = []
Y_train = []
for j in range(len(images)):
if j != i:
X_train.append(images[j])
Y_train.append(labels[j])
X_train = np.array(X_train)
Y_train = np.array(Y_train)
X_test = np.array(X_test)
Y_test = np.array(Y_test)
from keras.utils.np_utils import to_categorical
Y_train = to_categorical(Y_train, 2)
Y_test = to_categorical(Y_test, 2)
history = model.fit(X_train,
Y_train,
epochs=70,
batch_size=10,
verbose=0)
test_loss = model.evaluate(X_test, Y_test)
print("Loss and accuracy in the test set: Loss %g, Accuracy %g" %
(test_loss[0], test_loss[1]))
values_acc.append(test_loss[1])
mean = calculate_mean(values_acc)
print("The mean of all the test values is: %g" % mean)
def regression_build_tree(self, X, y, node_parent, min_split_size,
min_leaf_size, examples, random_feature,
n_random_feature):
self.id_counter = self.id_counter + 1
mean = utl.calculate_mean(y, examples)
current_node = regt.Node(node_parent,
self.id_counter,
index=0,
value=0,
examples=copy.deepcopy(examples),
prediction=mean)
if (not (len(examples) >= min_split_size)):
self._update_progress(len(examples))
return current_node
features = []
if (random_feature):
features = ens.random_features(
X, n_random_feature if n_random_feature > 0 else None)
feature, value = splitter.feature_split_best(X, y, examples,
min_leaf_size, features)
if (feature == None):
self._update_progress(len(examples))
return current_node
current_node.index = feature
current_node.value = value
left = splitter.feature_split(X, feature, examples, value)
current_node.left = self.regression_build_tree(X, y, current_node,
min_split_size,
min_leaf_size, left,
random_feature,
n_random_feature)
current_node.right = self.regression_build_tree(
X, y, current_node, min_split_size, min_leaf_size, examples,
random_feature, n_random_feature)
return current_node
def train_LOO_pacient(images, labels, names):
'''
Training model using LOO validation by pacient
Parameters
----------
images: list of numpy.array. images of the pacients
labels: list of numpy.array. labels of the different images
names: list of numpy.array. name of the pacients
Output
----------
Print the mean of the LOO validation
'''
print("Training LOO with pacient name")
values_acc = []
already_tested = []
for i in range(len(labels)):
if labels[i] == "AD":
labels[i] = 0
else:
labels[i] = 1
print("The lenght of images is " + str(len(images)))
for i in range(len(images)):
model = create_model()
X_test = []
Y_test = []
# If we haven't tested that pacient already
# we insert it to the test set and also
# all the images with the same name
if (not (names[i] in already_tested)):
already_tested.append(names[i])
X_test.append(images[i])
Y_test.append(labels[i])
for j in range(len(images)):
if j != i and names[j] == names[i]:
X_test.append(images[j])
Y_test.append(labels[j])
X_train = []
Y_train = []
for j in range(len(images)):
if names[j] != names[i]:
X_train.append(images[j])
Y_train.append(labels[j])
X_train = np.array(X_train)
Y_train = np.array(Y_train)
X_test = np.array(X_test)
Y_test = np.array(Y_test)
from keras.utils.np_utils import to_categorical
Y_train = to_categorical(Y_train, 2)
Y_test = to_categorical(Y_test, 2)
print("The len of the training set is: " + str(len(X_train)))
print("The len of the test set is: " + str(len(X_test)))
history = model.fit(X_train, Y_train, epochs=70, batch_size=10)
test_loss = model.evaluate(X_test, Y_test)
print("Loss and accuracy in the test set: Loss %g, Accuracy %g" %
(test_loss[0], test_loss[1]))
values_acc.append(test_loss[1])
mean = calculate_mean(values_acc)
print("The mean of all the test values is: %g" % mean)
def train_model_CV_MV(images1, images2, images3, labels, model):
'''
Training model using cross-validation
Parameters
----------
'''
f = open('results_cross_validation.txt', 'w')
labels_aux = labels
images1, labels = reorderRandomly(images1, labels)
images2, labels_aux = reorderRandomly(images2, labels_aux)
images3, labels_aux = reorderRandomly(images3, labels_aux)
for i in range(len(labels)):
if labels[i] == "AD":
labels[i] = 0
else:
labels[i] = 1
slices_images1 = [images1[i::5] for i in range(5)]
slices_images2 = [images2[i::5] for i in range(5)]
slices_images3 = [images3[i::5] for i in range(5)]
slices_labels = [labels[i::5] for i in range(5)]
models = {}
histories = {}
values_acc = []
for i in range(5):
f.write("Results for the fold: " + str(i))
f.write("\n")
model1 = create_model()
model2 = create_model()
model3 = create_model()
X_test1 = slices_images1[i]
X_test2 = slices_images2[i]
X_test3 = slices_images3[i]
Y_test = slices_labels[i]
X_train1 = [
item for s in slices_images1 if s is not X_test1 for item in s
]
X_train2 = [
item for s in slices_images2 if s is not X_test2 for item in s
]
X_train3 = [
item for s in slices_images3 if s is not X_test3 for item in s
]
Y_train = [
item for s in slices_labels if s is not Y_test for item in s
]
X_train1 = np.array(X_train1)
X_train2 = np.array(X_train2)
X_train3 = np.array(X_train3)
Y_train = np.array(Y_train)
X_test1 = np.array(X_test1)
X_test2 = np.array(X_test2)
X_test3 = np.array(X_test3)
Y_test = np.array(Y_test)
from keras.utils.np_utils import to_categorical
Y_train = to_categorical(Y_train)
Y_test = to_categorical(Y_test)
history1 = model1.fit(X_train1, Y_train, epochs=70, batch_size=5)
history2 = model2.fit(X_train2, Y_train, epochs=70, batch_size=5)
history3 = model3.fit(X_train3, Y_train, epochs=70, batch_size=5)
#models['model'+str(i)] = model
prediction_1 = model1.predict_classes(X_test1)
prediction_2 = model2.predict_classes(X_test2)
prediction_3 = model3.predict_classes(X_test3)
count = 0
for index in range(len(prediction_1)):
vote = int(prediction_1[index] + prediction_2[index] +
prediction_3[index])
if (vote >= 2):
major_vote = 1
else:
major_vote = 0
if (int(Y_test[index][0]) == 1):
true = 0
else:
true = 1
f.write("The value of the prediction is: " + str(major_vote) +
"and the true value is: " + str(true))
f.write("\n")
if (major_vote == true):
count = count + 1
values_acc.append(count / len(Y_test))
mean = calculate_mean(values_acc)
print("The mean of all the test values is: %g" % mean)
f.close()