Classificadores_Trabalho_Final.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Classificadores_Trabalho-Final.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hh4Yt1LuOheQ",
        "outputId": "6ce82959-5006-4764-eb2a-a90bd8f19fc4"
      },
      "source": [
        "#Conecta a sua conta do Drive para pegar os .pickle nos proximos blocos\n",
        "\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zVjJyr17i8yN"
      },
      "source": [
        " from sklearn import svm\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.metrics import classification_report, f1_score, confusion_matrix\n",
        "from sklearn.neural_network import MLPClassifier\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n",
        "from sklearn.pipeline import Pipeline\n",
        "from sklearn.model_selection import GridSearchCV, train_test_split\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.datasets import make_classification\n",
        "from sklearn import tree\n",
        "import sys\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split\n",
        "import pickle\n",
        "\n",
        "def KNNClassifier(X_train, y_train, X_test, y_test, k = 1, distancia = 'euclidean'):\n",
        "        #acertos(treinamento_normalizado, teste_normalizado, k, distancia)\n",
        "        from sklearn.metrics import classification_report\n",
        "        neigh = KNeighborsClassifier(n_neighbors=k, metric=distancia)\n",
        "        neigh.fit(X_train, y_train)\n",
        "        #return (neigh.score(X_test, y_test))\n",
        "        return f1_score(y_test, neigh.predict(X_test), average='weighted')\n",
        "        #return classification_report(y_test, neigh.predict(X_test))\n",
        "        \n",
        "def SVMWithGridSearch(X_train, y_train, X_test, y_test, ker = 'rbf', normalizacao = 'min-max'):\n",
        "    C_range = 2. ** np.arange(-5,15,2)\n",
        "    gamma_range = 2. ** np.arange(3,-15,-2)\n",
        "    #k = [ 'rbf']\n",
        "    # instancia o classificador, gerando probabilidades\n",
        "    srv = svm.SVC(probability=True, kernel=ker)\n",
        "\n",
        "    if normalizacao == 'min-max':\n",
        "      ss = MinMaxScaler() #Cria o Normalizador\n",
        "    else:\n",
        "      ss = StandardScaler()\n",
        "    pipeline = Pipeline([ ('scaler', ss), ('svm', srv) ])\n",
        "#        \n",
        "    param_grid = {\n",
        "        'svm__C' : C_range,\n",
        "        'svm__gamma' : gamma_range\n",
        "    }\n",
        "#        \n",
        "#        # faz a busca\n",
        "    grid = GridSearchCV(pipeline, param_grid, n_jobs=-1, verbose=False)\n",
        "    grid.fit(X_train, y_train)\n",
        "#        \n",
        "#        # recupera o melhor modelo\n",
        "    model = grid.best_estimator_\n",
        "    #return f1_score(X_test, y_test, average='weighted')\n",
        "    return f1_score(y_test, grid.predict(X_test), average='weighted'), grid.best_estimator_\n",
        "    #return (grid.score(X_test, y_test))\n",
        "    #return classification_report(y_test, model.predict(X_test))\n",
        "#        \n",
        "\n",
        "def MLP(X_train, y_train, X_test, y_test, normalizacao = 'min-max', confusion = False):\n",
        "    if normalizacao == 'min-max':\n",
        "      scaler = MinMaxScaler() #Cria o Normalizador\n",
        "    else:\n",
        "      scaler = StandardScaler()\n",
        "\n",
        "    parameter_space = {\n",
        "        'hidden_layer_sizes': [(50,50,50), (50,100,50), (100,)],\n",
        "        'activation': ['tanh', 'relu'],\n",
        "        'solver': ['sgd', 'adam'],\n",
        "        'alpha': [0.0001, 0.05],\n",
        "        'learning_rate': ['constant','adaptive'],\n",
        "    }\n",
        "    #MLPClassifier(activation='tanh', hidden_layer_sizes=(50, 100, 50), random_state=0)\n",
        "\n",
        "    X_train = scaler.fit_transform(X_train)\n",
        "    X_test = scaler.fit_transform(X_test)\n",
        "    \n",
        "    mlp = MLPClassifier(max_iter=100)\n",
        "\n",
        "    #clf = MLPClassifier(solver='adam', alpha=1e-5, hidden_layer_sizes=(500, 500, 500, 500), random_state=1)\n",
        "    #clf.fit(X_train, y_train)\n",
        "\n",
        "    clf = GridSearchCV(mlp, parameter_space, n_jobs=-1, cv=3)\n",
        "    clf.fit(X_train, y_train)\n",
        "    if confusion == True:\n",
        "      import seaborn as sn\n",
        "      import pandas as pd\n",
        "      import matplotlib.pyplot as plt\n",
        "      result = (confusion_matrix(y_test, clf.predict(X_test)))\n",
        "      print(\"result C Matrix\")\n",
        "      print(result)\n",
        "      plt.figure(figsize = (10,7))\n",
        "      sn.heatmap(result, annot=True)\n",
        "\n",
        "    return f1_score(y_test, clf.predict(X_test), average='weighted'), clf.best_estimator_\n",
        "\n",
        "def RandomForestClassifiers(X_train, y_train, X_test, y_test, normalizacao = 'min-max'):\n",
        "\n",
        "    if normalizacao == 'min-max':\n",
        "      scaler = MinMaxScaler() #Cria o Normalizador\n",
        "    else:\n",
        "      scaler = StandardScaler()\n",
        "\n",
        "    X_train = scaler.fit_transform(X_train)\n",
        "    X_test = scaler.fit_transform(X_test)\n",
        "\n",
        "    parametros = {\n",
        "        'bootstrap': [True, False],\n",
        "        'max_depth': [10, 20, 30, None],\n",
        "        'max_features': ['auto', 'sqrt'],\n",
        "        'min_samples_leaf': [1, 2, 4],\n",
        "        'min_samples_split': [2, 5, 10],\n",
        "        'n_estimators': [100, 200],\n",
        "        }\n",
        "    rf = RandomForestClassifier()\n",
        "\n",
        "    clf = GridSearchCV(estimator=rf, param_grid=parametros, cv= 5, n_jobs=-1)\n",
        "    clf.fit(X_train, y_train)\n",
        "    \n",
        "    return f1_score(y_test, clf.predict(X_test), average='weighted'), clf.best_estimator_\n",
        "\n",
        "def decisionTree(X_train, y_train, X_test, y_test):\n",
        "    clf = tree.DecisionTreeClassifier()\n",
        "    clf.fit(X_train, y_train)\n",
        "    predict = clf.predict(X_test)\n",
        "    return classification_report(y_test, predict)\n",
        "    #tree.plot_tree(clf)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qPMMD2sLHapP"
      },
      "source": [
        "best_all_value = [0,'']\n",
        "for deepfeature in ['inception', 'mobilenet', 'resnet', 'vgg16', 'vgg19', 'xception']:\n",
        "  print(\"\\n===========================================\")\n",
        "  print(\"--------DeepFeature: \", deepfeature)\n",
        "  file = open('/content/drive/MyDrive/features/dataset_'+deepfeature+'.pickle', 'rb')\n",
        "  data = pickle.load(file)\n",
        "\n",
        "  X = data[:, 0 : -1]\n",
        "  y = data[:,-1]\n",
        "\n",
        "  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)\n",
        "\n",
        "  #['ACURACIA', 'DISTANCIA', 'K', 'NORMALIZACAO', 'DEEP_FEATURE']\n",
        "  best_value_knn = [0,'',0, '', '']\n",
        "\n",
        "  #acuracia, Normalizacao, kernel, best estimator, deep_feature\n",
        "  best_value_svm = [0,'','', 0, '']\n",
        "\n",
        "  #acuracia, normalizacao, best_estimator, deep_feature\n",
        "  best_value_mlp = [0,'', 0, '']\n",
        "\n",
        "  #acuracia, normalizacao, best_estimator, deep_feature\n",
        "  best_value_rf = [0,'', 0, '']\n",
        "\n",
        "  for normalizacao in ['min-max', 'z-score']:\n",
        "    print(\"Tipo de Normalização: \", normalizacao)\n",
        "\n",
        "    '''Radom Forest- '''\n",
        "    '''     '''\n",
        "    print(\"-----------------------------------------------------RFOREST\")\n",
        "    acc_rf, best = RandomForestClassifiers(X_train, y_train, X_test, y_test, normalizacao)\n",
        "    print(\"ACC: \", acc_rf)\n",
        "\n",
        "    if acc_rf > best_value_rf[0]:\n",
        "      best_value_rf[0] = acc_rf\n",
        "      best_value_rf[1] = normalizacao\n",
        "      best_value_rf[2] = best\n",
        "      best_value_rf[3] = deepfeature\n",
        "\n",
        "    if acc_rf > best_all_value[0]:\n",
        "      best_all_value[0] = acc_rf\n",
        "      best_all_value[1] = best_value_rf\n",
        "      best_all_value[2] = \"RFOREST\"\n",
        "\n",
        "\n",
        "    '''MLP- '''\n",
        "    '''     '''\n",
        "    print(\"-----------------------------------------------------MLP\")\n",
        "    acc_mlp, best = MLP(X_train, y_train, X_test, y_test, normalizacao)\n",
        "    print(\"ACC: \", acc_mlp)\n",
        "\n",
        "    if acc_mlp > best_value_mlp[0]:\n",
        "      best_value_mlp[0] = acc_mlp\n",
        "      best_value_mlp[1] = normalizacao\n",
        "      best_value_mlp[2] = best\n",
        "      best_value_mlp[3] = deepfeature\n",
        "\n",
        "    if acc_mlp > best_all_value[0]:\n",
        "      best_all_value[0] = acc_mlp\n",
        "      best_all_value[1] = best_value_mlp\n",
        "      best_all_value[2] = \"MLP\"\n",
        "\n",
        "    ''' SVM ----- '''\n",
        "    '''           '''\n",
        "    print(\"-----------------------------------------------------SVM\")\n",
        "    for kernel in ['linear', 'poly', 'rbf', 'sigmoid']:\n",
        "      acc_svm, best = SVMWithGridSearch(X_train, y_train, X_test, y_test, kernel, normalizacao)\n",
        "      print(\"Kernel: \", kernel, \"ACC: \", acc_svm)\n",
        "      if acc_svm > best_value_svm[0]:\n",
        "        best_value_svm[0] = acc_svm\n",
        "        best_value_svm[1] = normalizacao\n",
        "        best_value_svm[2] = kernel\n",
        "        best_value_svm[3] = best\n",
        "        best_value_svm[4] = deepfeature\n",
        "\n",
        "      if acc_svm > best_all_value[0]:\n",
        "        best_all_value[0] = acc_svm\n",
        "        best_all_value[1] = best_value_svm\n",
        "        best_all_value[2] = \"SVM\"\n",
        "\n",
        "    ''' KNN ----- '''\n",
        "    '''           '''\n",
        "    print(\"-----------------------------------------------------KNN\")\n",
        "    if normalizacao == 'min-max':\n",
        "      ss = MinMaxScaler() #Cria o Normalizador\n",
        "    else:\n",
        "      ss = StandardScaler()\n",
        "\n",
        "    ss.fit(X_train)                \n",
        "    X_train_normalizado = ss.transform(X_train) #Aplica a normalização\n",
        "    X_test_normalizado = ss.transform(X_test) #Aplica a normalização\n",
        "\n",
        "    for distancia in ['euclidean','manhattan', 'minkowski', 'chebyshev']:\n",
        "      print(\"\\nDistancia:\", distancia)\n",
        "\n",
        "      for k in [1,3,5,7,9,11,13,15,17,19]:\n",
        "        acc = KNNClassifier(X_train_normalizado, y_train, X_test_normalizado, y_test, k, distancia)\n",
        "        print(\"K: \",k,\"Acc:\",acc)\n",
        "        if acc > best_value_knn[0]:\n",
        "          best_value_knn[0] = acc\n",
        "          best_value_knn[1] = distancia\n",
        "          best_value_knn[2] = k\n",
        "          best_value_knn[3] = normalizacao\n",
        "          best_value_knn[4] = deepfeature\n",
        "\n",
        "        if acc > best_all_value[0]:\n",
        "          best_all_value[0] = acc\n",
        "          best_all_value[1] = best_value_knn\n",
        "          best_all_value[2] = \"KNN\"\n",
        "\n",
        "  print(\"\\n=-----BEST VALUES--DO--KNN---------------=\")        \n",
        "  print(\"ACC: \",best_value_knn[0])\n",
        "  print(\"Distancia: \",best_value_knn[1])\n",
        "  print(\"K: \",best_value_knn[2])\n",
        "  print(\"Normalizacao: \",best_value_knn[3])\n",
        "  print(\"=-----------------------------------------=\")\n",
        "\n",
        "\n",
        "  print(\"\\n=-----BEST VALUES--DO--SVM---------------=\")        \n",
        "  print(\"ACC: \", best_value_svm[0])\n",
        "  print(\"Normalizacao: \", best_value_svm[1])\n",
        "  print(\"Kernel: \", best_value_svm[2])\n",
        "  print(\"Best Parametros: \", best_value_svm[3])\n",
        "  print(\"=-----------------------------------------=\")\n",
        "\n",
        "\n",
        "  print(\"\\n=-----BEST VALUES--DO--MLP---------------=\")        \n",
        "  print(\"ACC: \", best_value_mlp[0])\n",
        "  print(\"Normalizacao: \", best_value_mlp[1])\n",
        "  print(\"Best Parametros: \", best_value_mlp[2])\n",
        "  print(\"=-----------------------------------------=\")\n",
        "\n",
        "\n",
        "  print(\"\\n=-----BEST VALUES--DO--RFOREST---------------=\")        \n",
        "  print(\"ACC: \", best_value_rf[0])\n",
        "  print(\"Normalizacao: \", best_value_rf[1])\n",
        "  print(\"Best Parametros: \", best_value_rf[2])\n",
        "  print(\"=-----------------------------------------=\")\n",
        "\n",
        "  print(\"===========================================\\n\\n\")\n",
        "\n",
        "\n",
        "\n",
        "  '''Decision Tree- '''\n",
        "  '''               '''\n",
        "  #Código do Decision Tree\n",
        "\n",
        "print(best_all_value)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "background_save": true,
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "x0hAp22gR3ne",
        "outputId": "3cdd6345-81a8-4a5d-dc86-196739e63c40"
      },
      "source": [
        "'''\n",
        "\n",
        "O melhor de todos\n",
        "\n",
        "+------------------------------------------------------------------------\n",
        "|O melhor de TODOS!!!!!\n",
        "|\n",
        "|ExtractionFeature: RESNET\n",
        "|ACC: 0.9443871115697741\n",
        "|Classificador: MLP\n",
        "|Normalização: z-score\n",
        "|Parametros: MLPClassifier(activation='tanh', hidden_layer_sizes=(50, 100, 50), random_state=0)\n",
        "+------------------------------------------------------------------------\n",
        "\n",
        "'''\n",
        "\n",
        "def MLP(X_train, y_train, X_test, y_test, normalizacao = 'min-max', confusion = False):\n",
        "    if normalizacao == 'min-max':\n",
        "      scaler = MinMaxScaler() #Cria o Normalizador\n",
        "    else:\n",
        "      scaler = StandardScaler()\n",
        "\n",
        "    parameter_space = {\n",
        "        'hidden_layer_sizes': [(50,100,50)],\n",
        "        'activation': ['tanh'],\n",
        "        'solver': ['sgd', 'adam'],\n",
        "        'alpha': [0.0001, 0.05],\n",
        "        'learning_rate': ['constant','adaptive'],\n",
        "    }\n",
        "    #MLPClassifier(activation='tanh', hidden_layer_sizes=(50, 100, 50), random_state=0)\n",
        "\n",
        "    X_train = scaler.fit_transform(X_train)\n",
        "    X_test = scaler.fit_transform(X_test)\n",
        "    \n",
        "    mlp = MLPClassifier(max_iter=100)\n",
        "\n",
        "    #clf = MLPClassifier(solver='adam', alpha=1e-5, hidden_layer_sizes=(500, 500, 500, 500), random_state=1)\n",
        "    #clf.fit(X_train, y_train)\n",
        "\n",
        "    clf = GridSearchCV(mlp, parameter_space, n_jobs=-1, cv=3)\n",
        "    clf.fit(X_train, y_train)\n",
        "    if confusion == True:\n",
        "      import seaborn as sn\n",
        "      import pandas as pd\n",
        "      import matplotlib.pyplot as plt\n",
        "      result = (confusion_matrix(y_test, clf.predict(X_test)))\n",
        "      print(\"result C Matrix\")\n",
        "      print(result)\n",
        "      plt.figure(figsize = (10,7))\n",
        "      sn.heatmap(result, annot=True)\n",
        "\n",
        "    return f1_score(y_test, clf.predict(X_test), average='weighted'), clf.best_estimator_\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "for deepfeature in ['resnet']:\n",
        "  print(\"\\n===========================================\")\n",
        "  print(\"--------DeepFeature: \", deepfeature)\n",
        "  file = open('/content/drive/MyDrive/features/dataset_'+deepfeature+'.pickle', 'rb')\n",
        "  data = pickle.load(file)\n",
        "\n",
        "  X = data[:, 0 : -1]\n",
        "  y = data[:,-1]\n",
        "\n",
        "  X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)\n",
        "\n",
        "  #acuracia, normalizacao, best_estimator, deep_feature\n",
        "  best_value_mlp = [0,'', 0, '']\n",
        "\n",
        "  for normalizacao in ['z-score']:\n",
        "    print(\"Tipo de Normalização: \", normalizacao)\n",
        "\n",
        "    '''MLP- '''\n",
        "    '''     '''\n",
        "    print(\"-----------------------------------------------------MLP\")\n",
        "    acc_mlp, best = MLP(X_train, y_train, X_test, y_test, normalizacao, True)\n",
        "    print(\"ACC: \", acc_mlp)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "===========================================\n",
            "--------DeepFeature:  resnet\n",
            "Tipo de Normalização:  z-score\n",
            "-----------------------------------------------------MLP\n",
            "result C Matrix\n",
            "[[23  5]\n",
            " [ 4 22]]\n",
            "ACC:  0.833390508862207\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}