def test():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
df_train_x, df_train_y = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.2)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
#call model
RFClassifier = RFClassifierModel(
) #RFClassifierModel() RandomForestClassifier(max_depth=2, random_state=0)
#fit data into RFClassifier
RFClassifier.fit(Xtrain, Ytrain)
#evaluate
predicted = RFClassifier.predict(Xtest)
print('accuracy : {}%'.format(str(accuracy_score(Ytest, predicted) * 100)))
print('train score : {} %'.format(RFClassifier.score(Xtest, Ytest) * 100))
print(classification_report(Ytest, predicted))
print(confusion_matrix(Ytest, predicted))
def test():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
Xtest3, Ytest3, Xtrain3, Ytrain3 = load_data_from_mongoDb()
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
#call model
GMixtureClassifier = GaussianMixtureClassifierModel()
#fit data into GMixtureClassifier
GMixtureClassifierTrain = GMixtureClassifier.fit(Xtrain, Ytrain)
#evaluate
predicted = GMixtureClassifier.predict(Xtest)
print('accuracy : {}%'.format(str(accuracy_score(Ytest, predicted) * 100)))
print(classification_report(Ytest, predicted))
print(confusion_matrix(Ytest, predicted))
with open("model/GMixtureClassifier_pca_raw_csv_train.pkl",
"wb") as fichier:
dump(GMixtureClassifierTrain, fichier)
def train():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
df_train_x, df_train_y = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.2)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
#call model
DTClassifier = DTClassifierModel()
DTClassifierTrain = DTClassifier.fit(Xtrain, Ytrain)
score = DTClassifier.score(Xtest, Ytest)
print('score train : ', score)
def test():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
df_train_x, df_train_y = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.2)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
#call model
KNNClassifier = KNNClassifierModel()
#fit data into KNNClassifier
KNNClassifier.fit(Xtrain, Ytrain)
#evaluate
predicted = KNNClassifier.predict(Xtest)
#Ytest11 = list()
#for elt in Ytest1:
# elt = int(elt)
# Ytest11.append(elt)
print('accuracy : {}%'.format(str(accuracy_score(Ytest, predicted) * 100)))
print(classification_report(Ytest, predicted))
print(confusion_matrix(Ytest, predicted))
print('predicted shape : ', predicted.shape)
print('Ytest1 shape : ', Ytest.shape)
def evaluate():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
Xtest3, Ytest3, Xtrain3, Ytrain3 = load_data_from_mongoDb()
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1, Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# data preprocessing
# reshape
Xtrain = Xtrain.reshape(-1, 28, 28, 1)
Xtest = Xtest.reshape(-1, 28, 28, 1)
print('Xtrain shape : {}'.format(Xtrain.shape))
print('Xtest shape : {}'.format(Xtest.shape))
print('Ytrain shape : {}'.format(Xtrain.shape))
print('Ytest shape : {}'.format(Xtest.shape))
# rescale image
#Xtrain = Xtrain.astype('float32')
#Xtest = Xtest.astype('float32')
Xtrain = Xtrain / 255
Xtest = Xtest / 255
#call CNN trained model
classifierCNN = load_model('model/classifier_cnn_pca_raw_csv_hetero_epoch10.h5py')
evaluation = classifierCNN.evaluate(Xtest, Ytest, verbose=1)
print('\n loss : {} %'.format(evaluation[0]*100))
print('accuracy : {} %'.format(evaluation[1]*100))
def train():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
df_train_x, df_train_y = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.2)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
#call model
KNNClassifier = KNNClassifierModel()
LRClassifierTrain = KNNClassifier.fit(Xtrain, Ytrain)
with open("model/KNNClassifier_fashion_train.pkl", "wb") as fichier:
dump(LRClassifierTrain, fichier)
print('train score : {} %'.format(KNNClassifier.score(Xtest, Ytest) * 100))
def train():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
df_test_x, df_test_y, df_train_x, df_train_y = load_data_from_csv()
Xtrain2, Xtest2a, Ytrain2, Ytest2a = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.9)
Xtrain2b, Xtest2, Ytrain2b, Ytest2 = train_test_split(df_test_x,
df_test_y,
random_state=0,
test_size=0.9)
df_train_xM, df_train_yM = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_xM,
df_train_yM,
random_state=0,
test_size=0.9)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
#call model
SVmClassifier = SvmClassifierModel()
#fit data into RFClassifier
SVmClassifierTrain = SVmClassifier.fit(Xtrain, Ytrain)
print('train score : {} %'.format(
SVmClassifier.score(Xtrain, Ytrain) * 100))
def train():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
Xtest3, Ytest3, Xtrain3, Ytrain3 = load_data_from_mongoDb()
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# data preprocessing
# reshape
Xtrain = Xtrain.reshape(-1, 28, 28, 1)
Xtest = Xtest.reshape(-1, 28, 28, 1)
print('Xtrain shape : {}'.format(Xtrain.shape))
print('Xtest shape : {}'.format(Xtest.shape))
# rescale image
#Xtrain = Xtrain.astype('float32')
#Xtest = Xtest.astype('float32')
Xtrain = Xtrain / 255
Xtest = Xtest / 255
#define CNN architecture
classifierCNN = CnnClassifierModel()
#fit data into model
classifierCNN_train = classifierCNN.fit(Xtrain,
Ytrain,
epochs=10,
batch_size=64,
validation_data=(Xtest, Ytest))
classifierCNN.save('model/classifier_cnn_pca_raw_csv_hetero_epoch10.h5py')
accuracy = classifierCNN_train.history['acc']
accuracy_eval = classifierCNN_train.history['val_acc']
loss = classifierCNN_train.history['loss']
loss_eval = classifierCNN_train.history['val_loss']
epochs = range(len(accuracy))
plt.figure(figsize=[5, 5])
plt.subplot(121)
plt.plot(epochs, accuracy, 'bo', label="Training accuracy")
plt.plot(epochs, accuracy_eval, 'b', label="Validation Accuracy")
plt.title("Training and validation accuracy")
plt.legend()
plt.subplot(122)
plt.plot(loss, 'bo', label="Training loss")
plt.plot(epochs, loss_eval, 'b', label="Validation loss")
plt.title("Training and validation loss")
plt.legend()
plt.show()
print('the training of the CNN_classifier_model has been finished!!!...')
def classifyOne():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
df_train_x, df_train_y = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.2)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
# call model
KNNClassifier = KNNClassifierModel()
# fit data into KNNClassifier
KNNClassifier.fit(Xtrain, Ytrain)
# evaluate
predicted = KNNClassifier.predict(Xtest)
#Ytest11 = list()
#for elt in Ytest1:
# elt = int(elt)
# Ytest11.append(elt)
print('accuracy : {}%'.format(str(accuracy_score(Ytest, predicted) * 100)))
print(classification_report(Ytest, predicted))
print(confusion_matrix(Ytest, predicted))
# rescale and reshape image
input_image = 'image_to_recognize'
image = image__features_extractor(input_image)
image = np.resize(image, (1, 784))
image = np.array(image).reshape((1, -1))
pca = PCA()
image = pca.transform(image)
print('image shape : ', image.shape)
# prediction
predicted = KNNClassifier.predict(image)
image2 = image__features_extractor(input_image)
image2 = np.resize(image2, (1, 784))
image2 = np.array(image2).reshape((1, -1))
plt.figure(figsize=[5, 5])
plt.subplot(121)
plt.title("Predicted : {}".format(predicted))
print('predicted : ', predicted)
plt.imshow(np.reshape(image2, (28, 28)), cmap='gray_r')
plt.tight_layout()
plt.show()
def train():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
Xtest3, Ytest3,Xtrain3, Ytrain3 = load_data_from_mongoDb()
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1, Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
#call model
GMixtureClassifier = GaussianMixtureClassifierModel()
#fit data into GMixtureClassifier
GMixtureClassifierTrain = GMixtureClassifier.fit(Xtrain, Ytrain)
print('train score : {} %'.format(GMixtureClassifier.score(Xtrain, Ytrain) * 100))
def test():
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
df_test_x, df_test_y, df_train_x, df_train_y = load_data_from_csv()
Xtrain2, Xtest2a, Ytrain2, Ytest2a = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.9)
Xtrain2b, Xtest2, Ytrain2b, Ytest2 = train_test_split(df_test_x,
df_test_y,
random_state=0,
test_size=0.9)
df_train_xM, df_train_yM = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_xM,
df_train_yM,
random_state=0,
test_size=0.9)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
#call model
SVmClassifier = SvmClassifierModel()
#fit data into RFClassifier
SVmClassifierTrain = SVmClassifier.fit(Xtrain, Ytrain)
#evaluate
predicted = SVmClassifier.predict(Xtest)
print('predicted : ', predicted)
print('accuracy : {}%'.format(str(accuracy_score(Ytest, predicted) * 100)))
print('train score : {} %'.format(SVmClassifier.score(Xtest, Ytest) * 100))
with open("model/SVmClassifier_pca_raw_csv_heterogenous_mnist_train.pkl",
"wb") as fichier:
dump(SVmClassifierTrain, fichier)
print(classification_report(Ytest, predicted))
print(confusion_matrix(Ytest, predicted))
def classifyOne():
# define categorical label
label_dict = {
0: 'T-Shirt/top',
1: 'Trouser/pants',
2: 'Pullover shirt',
3: 'Dress',
4: 'Coat',
5: 'Sandal',
6: 'Shirt',
7: 'Sneaker',
8: 'Bag',
9: 'Ankle boot',
}
#load heterogenous data
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
df_train_x, df_train_y = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.2)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# reduce dimension of agregated data with LDA
#Xtrain, Xtest = reduction_of_dimension_with_LDA(Xtrain, Xtest, Ytrain)
# call model
DTClassifier = DTClassifierModel()
# fit data into LRclassifier
DTClassifier.fit(Xtrain, Ytrain)
# evaluate
predicted = DTClassifier.predict(Xtest)
print('accuracy : {}%'.format(str(accuracy_score(Ytest, predicted) * 100)))
print(classification_report(Ytest, predicted))
print(confusion_matrix(Ytest, predicted))
# rescale and reshape image
input_image = 'image_to_recognize'
image = image__features_extractor(input_image)
image = np.resize(image, (1, 784))
image = np.array(image).reshape((1, -1))
sc = StandardScaler()
pca = PCA()
image = sc.transform(image)
image = pca.transform(image)
print('image shape : ', image.shape)
# prediction
predicted = DTClassifier.predict(image)
image2 = image__features_extractor(input_image)
image2 = np.resize(image2, (1, 784))
image2 = np.array(image2).reshape((1, -1))
plt.figure(figsize=[5, 5])
plt.subplot(121)
plt.title("Predicted : {}".format(label_dict[int(predicted)]))
print('predicted : ', predicted)
plt.imshow(np.reshape(image2, (28, 28)), cmap='gray_r')
plt.tight_layout()
plt.show()
def classifyOne():
# define categorical label
label_dict = {
0: 'Zero',
1: 'Un',
2: 'Deux',
3: 'Trois',
4: 'Quatre',
5: 'Cinque',
6: 'Six',
7: 'Sept',
8: 'Huit',
9: 'Neuf',
}
#load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
Xtest3, Ytest3, Xtrain3, Ytrain3 = load_data_from_mongoDb()
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# data preprocessing
# reshape
Xtrain = Xtrain.reshape(-1, 28, 28, 1)
Xtest = Xtest.reshape(-1, 28, 28, 1)
print('Xtrain shape : {}'.format(Xtrain.shape))
print('Xtest shape : {}'.format(Xtest.shape))
# rescale image
#Xtrain = Xtrain.astype('float32')
#Xtest = Xtest.astype('float32')
Xtrain = Xtrain / 255
Xtest = Xtest / 255
# rescale and reshape image
input_image = 'image_to_recognize'
image = image__features_extractor(input_image)
image = np.resize(image, (1, 28, 28, 1))
image = np.array(image) / 255
print('image rescaled : {}'.format(image))
print('input image shape : {}'.format(image.shape))
#call model
classifierCNN = load_model(
'model/classifier_cnn_pca_raw_csv_hetero_epoch10.h5py')
#print(classifierCNN.summary())
# predict label category rely for the input image
predict = classifierCNN.predict(image)
print("predicted : ", predict)
predict = np.argmax(np.round(predict), axis=1)
print("predicted : ", predict)
predict = to_categorical(predict, num_classes=10)
print("predicted : ", predict)
print('predict class shape : {}'.format(predict.shape))
print('right class shape : {}'.format(Ytest.shape))
image = np.resize(image, (1, 784))
image = np.array(image) / 255
# show result
plt.figure(figsize=[5, 5])
plt.subplot(121)
plt.imshow(image.reshape(28, 28), cmap='gray_r')
plt.suptitle('predict info : {}'.format(getIndex(predict[0])), fontsize=16)
plt.show()
def classifyOne():
# define categorical label
label_dict = {
0: 'T-Shirt/top',
1: 'Trouser/pants',
2: 'Pullover shirt',
3: 'Dress',
4: 'Coat',
5: 'Sandal',
6: 'Shirt',
7: 'Sneaker',
8: 'Bag',
9: 'Ankle boot',
}
#load data
# load heterogenous data
Xtrain1, Xtest1 = imageLoader()
Ytrain1, Ytest1 = sentenceLoader()
Xtest2, Ytest2, Xtrain2, Ytrain2 = load_data_from_csv()
df_train_x, df_train_y = load_data_from_mongoDb()
Xtrain3, Xtest3, Ytrain3, Ytest3 = train_test_split(df_train_x,
df_train_y,
random_state=0,
test_size=0.2)
#agregate data with numpy
Xtrain, Ytrain, Xtest, Ytest = agregation_of_heterogenous_datas(
Xtrain1, Ytrain1, Xtrain2, Ytrain2, Xtrain3, Ytrain3, Xtest1, Ytest1,
Xtest2, Ytest2, Xtest3, Ytest3)
#reduce dimension of agregated data with PCA
Xtrain, Xtest = reduction_of_dimension_with_PCA(Xtrain, Xtest)
# data preprocessing
# reshape
Xtrain = Xtrain.reshape(-1, 28, 28, 1)
Xtest = Xtest.reshape(-1, 28, 28, 1)
print('Xtrain shape : {}'.format(Xtrain.shape))
print('Xtest shape : {}'.format(Xtest.shape))
# rescale image
# Xtrain = Xtrain.astype('float32')
# Xtest = Xtest.astype('float32')
Xtrain = Xtrain / 255
Xtest = Xtest / 255
# rescale and reshape image
input_image = 'image_to_recognize'
image = image__features_extractor(input_image)
image = np.resize(image, (1, 28, 28, 1))
image = np.array(image) / 255
#print('image rescaled : {}'.format(image))
print('input image shape : {}'.format(image.shape))
#call model
classifierCNN = load_model(
'model/classifier_cnn_lda_raw_csv_hetero_fashion_epoch100.h5py')
#print(classifierCNN.summary())
# predict label category rely for the input image
predict = classifierCNN.predict(image)
print("predicted : ", predict)
predict = np.argmax(np.round(predict), axis=1)
print("predicted : ", predict)
predict = to_categorical(predict, num_classes=10)
print("predicted : ", predict)
print('predict class shape : {}'.format(predict.shape))
print('right class shape : {}'.format(Ytest.shape))
image = np.resize(image, (1, 784))
image = np.array(image) / 255
# show result
plt.figure(figsize=[5, 5])
plt.subplot(121)
plt.imshow(image.reshape(28, 28), cmap='gray_r')
plt.suptitle('predict info : {}'.format(label_dict[getIndex(predict[0])]),
fontsize=16)
plt.show()
