VGG-19-features-extraction.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.9","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"from collections import Counter\nimport cv2\nimport os\nimport glob\nimport skimage\nimport numpy as np\nimport pandas as pd\nimport seaborn as sn\nimport preprocessing\nfrom tqdm import tqdm\nfrom PIL import Image\nfrom os import listdir\nimport matplotlib.pyplot as plt\nfrom skimage.transform import resize\nfrom collections import Counter\n\nsn.set()\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.svm import SVC # SVC\nfrom sklearn import metrics\nfrom sklearn.utils import shuffle\nfrom xgboost import XGBClassifier # XGBClassifier\nfrom sklearn import metrics\nfrom sklearn.metrics import confusion_matrix, classification_report, accuracy_score,f1_score,recall_score,cohen_kappa_score,precision_score\nfrom sklearn.utils import compute_class_weight\nfrom sklearn.preprocessing import MinMaxScaler,LabelBinarizer\nfrom sklearn.ensemble import AdaBoostClassifier # AdaBoostClassifier\nfrom sklearn.neighbors import KNeighborsClassifier # KNeighborsClassifier\nfrom sklearn.ensemble import RandomForestClassifier # RandomForestClassifier\nfrom sklearn.model_selection import train_test_split\n\nimport tensorflow as tf\nfrom tensorflow.keras.utils import to_categorical\nfrom tensorflow.keras.metrics import AUC\nfrom tensorflow.keras.preprocessing import image\nfrom tensorflow.keras.models import Model, Sequential\nfrom tensorflow.keras.applications.vgg16 import VGG16 # VGG16\nfrom tensorflow.keras.applications.vgg19 import VGG19 # VGG19\nfrom tensorflow.keras.applications.resnet50 import ResNet50 # ResNet50\nfrom tensorflow.keras.applications.xception import Xception # Xception\nfrom tensorflow.keras.applications.mobilenet import MobileNet # MobileNet\nfrom tensorflow.keras.applications.nasnet import NASNetMobile # NASNetMobile\nfrom tensorflow.keras.applications.densenet import DenseNet169 # DenseNet169\nfrom tensorflow.keras.applications.densenet import DenseNet121 # DenseNet121\nfrom tensorflow.keras.applications.mobilenet_v2 import MobileNetV2 # MobileNetV2\nfrom tensorflow.keras.applications.inception_v3 import InceptionV3 # InceptionV3\nfrom tensorflow.keras.layers import Input, Dense, Dropout, BatchNormalization, Flatten, Activation, GlobalAveragePooling2D,Conv2D, MaxPooling2D\nfrom tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"execution_count":1,"outputs":[]},{"cell_type":"code","source":"images=[]\nlabels=[]\nfeature_dictionary = {\n    'label': tf.io.FixedLenFeature([], tf.int64),\n    'label_normal': tf.io.FixedLenFeature([], tf.int64),\n    'image': tf.io.FixedLenFeature([], tf.string)\n    }","metadata":{"trusted":true},"execution_count":2,"outputs":[]},{"cell_type":"code","source":"def _parse_function(example, feature_dictionary=feature_dictionary):\n    parsed_example = tf.io.parse_example(example, feature_dictionary)\n    return parsed_example\n\ndef read_data(filename):\n    full_dataset = tf.data.TFRecordDataset(filename,num_parallel_reads=tf.data.experimental.AUTOTUNE)\n    full_dataset = full_dataset.shuffle(buffer_size=31000)\n    full_dataset = full_dataset.cache()\n    print(\"Size of Training Dataset: \", len(list(full_dataset)))\n    \n    feature_dictionary = {\n    'label': tf.io.FixedLenFeature([], tf.int64),\n    'label_normal': tf.io.FixedLenFeature([], tf.int64),\n    'image': tf.io.FixedLenFeature([], tf.string)\n    }   \n\n    full_dataset = full_dataset.map(_parse_function, num_parallel_calls=tf.data.experimental.AUTOTUNE)\n    print(full_dataset)\n    for image_features in full_dataset:\n        image = image_features['image'].numpy()\n        image = tf.io.decode_raw(image_features['image'], tf.uint8)\n        image = tf.reshape(image, [299, 299])        \n        image=image.numpy()\n        image=cv2.resize(image,(100,100))\n        image=cv2.merge([image,image,image])        \n        #plt.imshow(image)\n        images.append(image)\n        labels.append(image_features['label_normal'].numpy())","metadata":{"trusted":true},"execution_count":3,"outputs":[]},{"cell_type":"code","source":"filenames=['../input/ddsm-mammography/training10_0/training10_0.tfrecords',\n#          '../input/ddsm-mammography/training10_1/training10_1.tfrecords',\n#           '../input/ddsm-mammography/training10_2/training10_2.tfrecords',\n#           '../input/ddsm-mammography/training10_3/training10_3.tfrecords',\n#           '../input/ddsm-mammography/training10_4/training10_4.tfrecords']\n          ]\n\nfor file in filenames:\n    read_data(file)\n    \nprint(len(images))\nprint(len(labels))","metadata":{"trusted":true},"execution_count":4,"outputs":[{"name":"stdout","text":"Size of Training Dataset:  11177\n<ParallelMapDataset shapes: {image: (), label: (), label_normal: ()}, types: {image: tf.string, label: tf.int64, label_normal: tf.int64}>\n11177\n11177\n","output_type":"stream"}]},{"cell_type":"code","source":"X=np.array(images)\ny=np.array(labels)\nx_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=2021,shuffle=True)","metadata":{"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"code","source":"plt.imshow(x_train[0])","metadata":{"trusted":true},"execution_count":6,"outputs":[{"execution_count":6,"output_type":"execute_result","data":{"text/plain":"<matplotlib.image.AxesImage at 0x7f88c4077410>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}}]},{"cell_type":"code","source":"import numpy as np\nfrom keras.models import Sequential\nfrom keras.layers import Dense, Dropout, Activation, Conv2D, MaxPool2D, Flatten\nfrom keras import optimizers\nfrom keras import losses\nfrom sklearn import metrics\n\nprint(x_train[0].shape)","metadata":{"trusted":true},"execution_count":7,"outputs":[{"name":"stdout","text":"(100, 100, 3)\n","output_type":"stream"}]},{"cell_type":"code","source":"rows, cols,color = x_train[0].shape\nprint(x_train[0].shape)\n\nbase_model = VGG19(input_shape=(100,100,3), weights='imagenet', include_top=False)\nx = base_model.output\nx = Dropout(0.2)(x)\npredictions = Flatten()(x)\n\nmodel_feat = Model(inputs=base_model.input,outputs=predictions)\n\ntrain_features = model_feat.predict(x_train)\ntest_features=model_feat.predict(x_test)","metadata":{"trusted":true},"execution_count":8,"outputs":[{"name":"stdout","text":"(100, 100, 3)\nDownloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg19/vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5\n80142336/80134624 [==============================] - 1s 0us/step\n","output_type":"stream"}]},{"cell_type":"code","source":"x_train_acc, x_val_acc, y_train_acc, y_val_acc = train_test_split(train_features,y_train,\n                                                  test_size = 0.2,\n                                                  stratify = y_train,\n                                                  shuffle = True,\n                                                  random_state = 42)\nX_test,y_test=test_features,y_test","metadata":{"trusted":true},"execution_count":9,"outputs":[]},{"cell_type":"code","source":"print('length X_train:', len(x_train_acc))\nprint('length y_train:', len(y_train_acc))\n\nprint('length X_val:',  len(x_val_acc))\nprint('length y_val:', len(y_val_acc))\n\nprint('length X_test:',  len(X_test))\nprint('length y_test:', len(y_test))","metadata":{"trusted":true},"execution_count":10,"outputs":[{"name":"stdout","text":"length X_train: 7152\nlength y_train: 7152\nlength X_val: 1789\nlength y_val: 1789\nlength X_test: 2236\nlength y_test: 2236\n","output_type":"stream"}]},{"cell_type":"code","source":"names = [\n        \"K Nearest Neighbour Classifier\",\n        'SVM',\n        \"Random Forest Classifier\",\n        \"AdaBoost Classifier\", \n        \"XGB Classifier\",\n         ]\nclassifiers = [\n    KNeighborsClassifier(),\n    SVC(),\n    RandomForestClassifier(),\n    AdaBoostClassifier(),\n    XGBClassifier(),\n        ]\n\nzipped_clf = zip(names,classifiers)","metadata":{"trusted":true},"execution_count":11,"outputs":[]},{"cell_type":"code","source":"def classifier_summary(pipeline, X_train, y_train, X_val, y_val,X_test,y_test):\n    sentiment_fit = pipeline.fit(X_train, y_train)\n    \n    y_pred_train= sentiment_fit.predict(X_train)\n    y_pred_val = sentiment_fit.predict(X_val)\n    y_pred_test = sentiment_fit.predict(X_test)\n    \n    train_accuracy = np.round(accuracy_score(y_train, y_pred_train),4)*100\n    train_precision = np.round(precision_score(y_train, y_pred_train, average='weighted'),4)\n    train_recall = np.round(recall_score(y_train, y_pred_train, average='weighted'),4)\n    train_F1 = np.round(f1_score(y_train, y_pred_train, average='weighted'),4)\n    train_kappa =  np.round(cohen_kappa_score(y_train, y_pred_train),4)\n    train_confusion_matrix = confusion_matrix(y_train,y_pred_train)\n    \n    val_accuracy = np.round(accuracy_score(y_val, y_pred_val),4)*100\n    val_precision = np.round(precision_score(y_val, y_pred_val, average='weighted'),4)\n    val_recall = np.round(recall_score(y_val, y_pred_val, average='weighted'),4)\n    val_F1 = np.round(f1_score(y_val, y_pred_val, average='weighted'),4)\n    val_kappa =  np.round(cohen_kappa_score(y_val, y_pred_val),4)\n    val_confusion_matrix = confusion_matrix(y_val,y_pred_val)\n    \n    test_accuracy = np.round(accuracy_score(y_test, y_pred_test),4)*100\n    test_precision = np.round(precision_score(y_test, y_pred_test, average='weighted'),4)\n    test_recall = np.round(recall_score(y_test, y_pred_test, average='weighted'),4)\n    test_F1 = np.round(f1_score(y_test, y_pred_test, average='weighted'),4)\n    test_kappa =  np.round(cohen_kappa_score(y_test, y_pred_test),4) \n    test_confusion_matrix = confusion_matrix(y_test,y_pred_test)\n    \n    \n    print()\n    print('------------------------ Train Set Metrics------------------------')\n    print()\n    print(\"accuracy : {}%\".format(train_accuracy))\n    print(\"F1_score : {}\".format(train_F1))\n    print(\"Cohen Kappa Score : {} \".format(train_kappa))\n    print(\"Recall : {}\".format(train_recall))\n    print(\"Precision : {}\".format(train_precision))\n    print(\"Confusion Matrix :\\n {}\".format(train_confusion_matrix))\n    \n    print()\n    print('------------------------ Validation Set Metrics------------------------')\n    print()\n    print(\"accuracy : {}%\".format(val_accuracy))\n    print(\"F1_score : {}\".format(val_F1))\n    print(\"Cohen Kappa Score : {} \".format(val_kappa))\n    print(\"Recall : {}\".format(val_recall))\n    print(\"Precision : {}\".format(val_precision))\n    print(\"Confusion Matrix :\\n {}\".format(val_confusion_matrix))\n    \n    print()\n    print('------------------------ Test Set Metrics------------------------')\n    print()\n    print(\"accuracy : {}%\".format(test_accuracy))\n    print(\"F1_score : {}\".format(test_F1))\n    print(\"Cohen Kappa Score : {} \".format(test_kappa))\n    print(\"Recall : {}\".format(test_recall))\n    print(\"Precision : {}\".format(test_precision))\n    print(\"Confusion Matrix : {}\".format(test_confusion_matrix))\n\n    print(\"-\"*80)\n    print()","metadata":{"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"code","source":"def classifier_comparator(X_train,y_train,X_val,y_val,X_test,y_test,classifier=zipped_clf): \n    result = []\n    for n,c in classifier:\n        checker_pipeline = Pipeline([('classifier', c)])\n        print(\"Fitting {} on features \".format(n))\n        #print(c)\n        classifier_summary(checker_pipeline,X_train, y_train, X_val, y_val,X_test,y_test)","metadata":{"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"code","source":"classifier_comparator(x_train_acc,y_train_acc,x_val_acc,y_val_acc,X_test,y_test,classifier=zipped_clf)","metadata":{"trusted":true},"execution_count":14,"outputs":[{"name":"stdout","text":"Fitting K Nearest Neighbour Classifier on features \n\n------------------------ Train Set Metrics------------------------\n\naccuracy : 89.01%\nF1_score : 0.856\nCohen Kappa Score : 0.2747 \nRecall : 0.8901\nPrecision : 0.8968\nConfusion Matrix :\n [[6193    9]\n [ 777  173]]\n\n------------------------ Validation Set Metrics------------------------\n\naccuracy : 87.7%\nF1_score : 0.8339\nCohen Kappa Score : 0.1587 \nRecall : 0.877\nPrecision : 0.8658\nConfusion Matrix :\n [[1544    7]\n [ 213   25]]\n\n------------------------ Test Set Metrics------------------------\n\naccuracy : 87.66000000000001%\nF1_score : 0.8313\nCohen Kappa Score : 0.125 \nRecall : 0.8766\nPrecision : 0.8591\nConfusion Matrix : [[1936    9]\n [ 267   24]]\n--------------------------------------------------------------------------------\n\nFitting SVM on features \n\n------------------------ Train Set Metrics------------------------\n\naccuracy : 92.97999999999999%\nF1_score : 0.9191\nCohen Kappa Score : 0.6115 \nRecall : 0.9298\nPrecision : 0.9335\nConfusion Matrix :\n [[6193    9]\n [ 493  457]]\n\n------------------------ Validation Set Metrics------------------------\n\naccuracy : 89.32%\nF1_score : 0.8671\nCohen Kappa Score : 0.3416 \nRecall : 0.8932\nPrecision : 0.8872\nConfusion Matrix :\n [[1539   12]\n [ 179   59]]\n\n------------------------ Test Set Metrics------------------------\n\naccuracy : 89.62%\nF1_score : 0.8708\nCohen Kappa Score : 0.3471 \nRecall : 0.8962\nPrecision : 0.8908\nConfusion Matrix : [[1931   14]\n [ 218   73]]\n--------------------------------------------------------------------------------\n\nFitting Random Forest Classifier on features \n\n------------------------ Train Set Metrics------------------------\n\naccuracy : 100.0%\nF1_score : 1.0\nCohen Kappa Score : 1.0 \nRecall : 1.0\nPrecision : 1.0\nConfusion Matrix :\n [[6202    0]\n [   0  950]]\n\n------------------------ Validation Set Metrics------------------------\n\naccuracy : 88.37%\nF1_score : 0.8478\nCohen Kappa Score : 0.2346 \nRecall : 0.8837\nPrecision : 0.8774\nConfusion Matrix :\n [[1543    8]\n [ 200   38]]\n\n------------------------ Test Set Metrics------------------------\n\naccuracy : 88.33%\nF1_score : 0.8476\nCohen Kappa Score : 0.2183 \nRecall : 0.8833\nPrecision : 0.8699\nConfusion Matrix : [[1931   14]\n [ 247   44]]\n--------------------------------------------------------------------------------\n\nFitting AdaBoost Classifier on features \n\n------------------------ Train Set Metrics------------------------\n\naccuracy : 90.2%\nF1_score : 0.8935\nCohen Kappa Score : 0.5051 \nRecall : 0.902\nPrecision : 0.892\nConfusion Matrix :\n [[6009  193]\n [ 508  442]]\n\n------------------------ Validation Set Metrics------------------------\n\naccuracy : 88.03999999999999%\nF1_score : 0.8688\nCohen Kappa Score : 0.3878 \nRecall : 0.8804\nPrecision : 0.8645\nConfusion Matrix :\n [[1487   64]\n [ 150   88]]\n\n------------------------ Test Set Metrics------------------------\n\naccuracy : 88.86%\nF1_score : 0.8776\nCohen Kappa Score : 0.417 \nRecall : 0.8886\nPrecision : 0.8743\nConfusion Matrix : [[1874   71]\n [ 178  113]]\n--------------------------------------------------------------------------------\n\nFitting XGB Classifier on features \n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/xgboost/sklearn.py:888: UserWarning: The use of label encoder in XGBClassifier is deprecated and will be removed in a future release. To remove this warning, do the following: 1) Pass option use_label_encoder=False when constructing XGBClassifier object; and 2) Encode your labels (y) as integers starting with 0, i.e. 0, 1, 2, ..., [num_class - 1].\n  warnings.warn(label_encoder_deprecation_msg, UserWarning)\n","output_type":"stream"},{"name":"stdout","text":"[07:43:55] WARNING: ../src/learner.cc:1061: Starting in XGBoost 1.3.0, the default evaluation metric used with the objective 'binary:logistic' was changed from 'error' to 'logloss'. Explicitly set eval_metric if you'd like to restore the old behavior.\n\n------------------------ Train Set Metrics------------------------\n\naccuracy : 100.0%\nF1_score : 1.0\nCohen Kappa Score : 1.0 \nRecall : 1.0\nPrecision : 1.0\nConfusion Matrix :\n [[6202    0]\n [   0  950]]\n\n------------------------ Validation Set Metrics------------------------\n\naccuracy : 90.16%\nF1_score : 0.8848\nCohen Kappa Score : 0.4427 \nRecall : 0.9016\nPrecision : 0.8931\nConfusion Matrix :\n [[1529   22]\n [ 154   84]]\n\n------------------------ Test Set Metrics------------------------\n\naccuracy : 89.8%\nF1_score : 0.8831\nCohen Kappa Score : 0.4296 \nRecall : 0.898\nPrecision : 0.8854\nConfusion Matrix : [[1903   42]\n [ 186  105]]\n--------------------------------------------------------------------------------\n\n","output_type":"stream"}]},{"cell_type":"code","source":"ann=Sequential()\nann.add(Dense(16,activation='relu',input_shape=x_train_acc[0].shape))\nann.add(Dense(32,activation='relu'))\nann.add(Dense(64,activation='relu'))\nann.add(Dense(64,activation='relu'))\nann.add(Dense(32,activation='relu'))\nann.add(Dense(16,activation='relu'))\nann.add(Dense(1,activation='sigmoid'))\n\nann.summary()\n\nann.compile(optimizer='adam',loss='binary_crossentropy', metrics=['accuracy'])\n\nhistory = ann.fit(x_train_acc, y_train_acc,validation_data=(x_val_acc,y_val_acc), epochs=20)\n\nloss_value , accuracy = ann.evaluate(x_train_acc, y_train_acc)\nprint('Train_accuracy = ' + str(accuracy))\nloss_value , accuracy = ann.evaluate(x_val_acc, y_val_acc)\nprint('Validation_accuracy = ' + str(accuracy))\nloss_value , accuracy = ann.evaluate(X_test, y_test)\nprint('test_accuracy = ' + str(accuracy))","metadata":{"trusted":true},"execution_count":15,"outputs":[{"name":"stdout","text":"Model: \"sequential\"\n_________________________________________________________________\nLayer (type)                 Output Shape              Param #   \n=================================================================\ndense (Dense)                (None, 16)                73744     \n_________________________________________________________________\ndense_1 (Dense)              (None, 32)                544       \n_________________________________________________________________\ndense_2 (Dense)              (None, 64)                2112      \n_________________________________________________________________\ndense_3 (Dense)              (None, 64)                4160      \n_________________________________________________________________\ndense_4 (Dense)              (None, 32)                2080      \n_________________________________________________________________\ndense_5 (Dense)              (None, 16)                528       \n_________________________________________________________________\ndense_6 (Dense)              (None, 1)                 17        \n=================================================================\nTotal params: 83,185\nTrainable params: 83,185\nNon-trainable params: 0\n_________________________________________________________________\nEpoch 1/20\n224/224 [==============================] - 2s 6ms/step - loss: 0.4039 - accuracy: 0.8686 - val_loss: 0.3158 - val_accuracy: 0.8849\nEpoch 2/20\n224/224 [==============================] - 1s 4ms/step - loss: 0.2761 - accuracy: 0.8836 - val_loss: 0.3286 - val_accuracy: 0.8821\nEpoch 3/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.2164 - accuracy: 0.9099 - val_loss: 0.2702 - val_accuracy: 0.8983\nEpoch 4/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.1982 - accuracy: 0.9200 - val_loss: 0.2786 - val_accuracy: 0.8865\nEpoch 5/20\n224/224 [==============================] - 1s 4ms/step - loss: 0.1647 - accuracy: 0.9362 - val_loss: 0.3120 - val_accuracy: 0.8927\nEpoch 6/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.1455 - accuracy: 0.9434 - val_loss: 0.3765 - val_accuracy: 0.8927\nEpoch 7/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.1392 - accuracy: 0.9447 - val_loss: 0.3802 - val_accuracy: 0.8955\nEpoch 8/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.1204 - accuracy: 0.9532 - val_loss: 0.3990 - val_accuracy: 0.8888\nEpoch 9/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.1055 - accuracy: 0.9605 - val_loss: 0.4027 - val_accuracy: 0.8932\nEpoch 10/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.0828 - accuracy: 0.9695 - val_loss: 0.4595 - val_accuracy: 0.8871\nEpoch 11/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.0871 - accuracy: 0.9679 - val_loss: 0.4659 - val_accuracy: 0.8826\nEpoch 12/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.0776 - accuracy: 0.9707 - val_loss: 0.4411 - val_accuracy: 0.8932\nEpoch 13/20\n224/224 [==============================] - 1s 4ms/step - loss: 0.0589 - accuracy: 0.9779 - val_loss: 0.4815 - val_accuracy: 0.8843\nEpoch 14/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.0651 - accuracy: 0.9773 - val_loss: 0.5228 - val_accuracy: 0.8932\nEpoch 15/20\n224/224 [==============================] - 1s 4ms/step - loss: 0.0637 - accuracy: 0.9783 - val_loss: 0.5728 - val_accuracy: 0.8837\nEpoch 16/20\n224/224 [==============================] - 1s 4ms/step - loss: 0.0584 - accuracy: 0.9783 - val_loss: 0.6310 - val_accuracy: 0.8932\nEpoch 17/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.0455 - accuracy: 0.9832 - val_loss: 0.6444 - val_accuracy: 0.8809\nEpoch 18/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.0409 - accuracy: 0.9871 - val_loss: 0.6410 - val_accuracy: 0.8871\nEpoch 19/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.0474 - accuracy: 0.9819 - val_loss: 0.6723 - val_accuracy: 0.8787\nEpoch 20/20\n224/224 [==============================] - 1s 3ms/step - loss: 0.0510 - accuracy: 0.9823 - val_loss: 0.8680 - val_accuracy: 0.8804\n224/224 [==============================] - 0s 2ms/step - loss: 0.0257 - accuracy: 0.9912\nTrain_accuracy = 0.9911912679672241\n56/56 [==============================] - 0s 2ms/step - loss: 0.8680 - accuracy: 0.8804\nValidation_accuracy = 0.8803800940513611\n70/70 [==============================] - 0s 2ms/step - loss: 0.6989 - accuracy: 0.8860\ntest_accuracy = 0.8859570622444153\n","output_type":"stream"}]},{"cell_type":"code","source":"y_pred=ann.predict_classes(X_test)\ntarget=[\"B\",\"M\"]\nprint('Accuracy:', np.round(metrics.accuracy_score(y_test, y_pred),4))\nprint('Precision:', np.round(metrics.precision_score(y_test, y_pred, average='weighted'),4))\nprint('Recall:', np.round(metrics.recall_score(y_test,y_pred, average='weighted'),4))\nprint('F1 Score:', np.round(metrics.f1_score(y_test, y_pred, average='weighted'),4))\nprint('Cohen Kappa Score:', np.round(metrics.cohen_kappa_score(y_test, y_pred),4))\nprint('\\t\\tClassification Report:\\n', metrics.classification_report(y_test, y_pred,target_names=target))","metadata":{"trusted":true},"execution_count":16,"outputs":[{"name":"stdout","text":"Accuracy: 0.886\n","output_type":"stream"},{"name":"stderr","text":"/opt/conda/lib/python3.7/site-packages/tensorflow/python/keras/engine/sequential.py:450: UserWarning: `model.predict_classes()` is deprecated and will be removed after 2021-01-01. Please use instead:* `np.argmax(model.predict(x), axis=-1)`,   if your model does multi-class classification   (e.g. if it uses a `softmax` last-layer activation).* `(model.predict(x) > 0.5).astype(\"int32\")`,   if your model does binary classification   (e.g. if it uses a `sigmoid` last-layer activation).\n  warnings.warn('`model.predict_classes()` is deprecated and '\n","output_type":"stream"},{"name":"stdout","text":"Precision: 0.8807\nRecall: 0.886\nF1 Score: 0.883\nCohen Kappa Score: 0.4708\n\t\tClassification Report:\n               precision    recall  f1-score   support\n\n           B       0.93      0.94      0.93      1945\n           M       0.57      0.51      0.54       291\n\n    accuracy                           0.89      2236\n   macro avg       0.75      0.72      0.74      2236\nweighted avg       0.88      0.89      0.88      2236\n\n","output_type":"stream"}]},{"cell_type":"code","source":"","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}