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()