purposed.application.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a340d205",
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import plotly.express as px\n",
    "from plotly.subplots import make_subplots\n",
    "import plotly.graph_objs as go\n",
    "from sklearn import svm, datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "from mlxtend.feature_selection import SequentialFeatureSelector as sfs\n",
    "from mlxtend.feature_selection import ColumnSelector\n",
    "from pprint import pprint\n",
    "import warnings\n",
    "import os\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.multiclass import OneVsRestClassifier\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, mean_squared_error, roc_auc_score, roc_curve, f1_score\n",
    "from sklearn import preprocessing\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import TimeSeriesSplit\n",
    "import seaborn as sns\n",
    "import matplotlib\n",
    "from multiprocessing import Pool\n",
    "from pymonad.maybe import Maybe, Just, Nothing\n",
    "from functools import partial\n",
    "from joblib import parallel_backend, Parallel, delayed\n",
    "from sklearn.pipeline import Pipeline\n",
    "    \n",
    "import defs\n",
    "\n",
    "from functools import reduce\n",
    "\n",
    "matplotlib.rcParams['figure.figsize'] = [15, 15]\n",
    "\n",
    "\n",
    "# Uyarıları bastırıyoruz:\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3f714cf3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>question_id</th>\n",
       "      <th>bundle_id</th>\n",
       "      <th>explanation_id</th>\n",
       "      <th>correct_answer</th>\n",
       "      <th>part</th>\n",
       "      <th>tags</th>\n",
       "      <th>deployed_at</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>q1</td>\n",
       "      <td>b1</td>\n",
       "      <td>e1</td>\n",
       "      <td>b</td>\n",
       "      <td>1</td>\n",
       "      <td>1;2;179;181</td>\n",
       "      <td>1558093217098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>q2</td>\n",
       "      <td>b2</td>\n",
       "      <td>e2</td>\n",
       "      <td>a</td>\n",
       "      <td>1</td>\n",
       "      <td>15;2;182</td>\n",
       "      <td>1558093219720</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>q3</td>\n",
       "      <td>b3</td>\n",
       "      <td>e3</td>\n",
       "      <td>b</td>\n",
       "      <td>1</td>\n",
       "      <td>14;2;179;183</td>\n",
       "      <td>1558093222784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>q4</td>\n",
       "      <td>b4</td>\n",
       "      <td>e4</td>\n",
       "      <td>b</td>\n",
       "      <td>1</td>\n",
       "      <td>9;2;179;184</td>\n",
       "      <td>1558093225357</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>q5</td>\n",
       "      <td>b5</td>\n",
       "      <td>e5</td>\n",
       "      <td>c</td>\n",
       "      <td>1</td>\n",
       "      <td>8;2;179;181</td>\n",
       "      <td>1558093228439</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13164</th>\n",
       "      <td>q18139</td>\n",
       "      <td>b12202</td>\n",
       "      <td>e12202</td>\n",
       "      <td>b</td>\n",
       "      <td>2</td>\n",
       "      <td>24;26;183;182</td>\n",
       "      <td>1571733814684</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13165</th>\n",
       "      <td>q18140</td>\n",
       "      <td>b12203</td>\n",
       "      <td>e12203</td>\n",
       "      <td>a</td>\n",
       "      <td>2</td>\n",
       "      <td>24;33;183;182</td>\n",
       "      <td>1571733815331</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13166</th>\n",
       "      <td>q18141</td>\n",
       "      <td>b12204</td>\n",
       "      <td>e12204</td>\n",
       "      <td>a</td>\n",
       "      <td>2</td>\n",
       "      <td>24;26;183;182</td>\n",
       "      <td>1571733815951</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13167</th>\n",
       "      <td>q18142</td>\n",
       "      <td>b12205</td>\n",
       "      <td>e12205</td>\n",
       "      <td>a</td>\n",
       "      <td>2</td>\n",
       "      <td>24;26;183;182</td>\n",
       "      <td>1571733816585</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13168</th>\n",
       "      <td>q18143</td>\n",
       "      <td>b12206</td>\n",
       "      <td>e12206</td>\n",
       "      <td>c</td>\n",
       "      <td>2</td>\n",
       "      <td>27;24;26;183;182</td>\n",
       "      <td>1571733817400</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>13169 rows × 7 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      question_id bundle_id explanation_id correct_answer  part  \\\n",
       "0              q1        b1             e1              b     1   \n",
       "1              q2        b2             e2              a     1   \n",
       "2              q3        b3             e3              b     1   \n",
       "3              q4        b4             e4              b     1   \n",
       "4              q5        b5             e5              c     1   \n",
       "...           ...       ...            ...            ...   ...   \n",
       "13164      q18139    b12202         e12202              b     2   \n",
       "13165      q18140    b12203         e12203              a     2   \n",
       "13166      q18141    b12204         e12204              a     2   \n",
       "13167      q18142    b12205         e12205              a     2   \n",
       "13168      q18143    b12206         e12206              c     2   \n",
       "\n",
       "                   tags    deployed_at  \n",
       "0           1;2;179;181  1558093217098  \n",
       "1              15;2;182  1558093219720  \n",
       "2          14;2;179;183  1558093222784  \n",
       "3           9;2;179;184  1558093225357  \n",
       "4           8;2;179;181  1558093228439  \n",
       "...                 ...            ...  \n",
       "13164     24;26;183;182  1571733814684  \n",
       "13165     24;33;183;182  1571733815331  \n",
       "13166     24;26;183;182  1571733815951  \n",
       "13167     24;26;183;182  1571733816585  \n",
       "13168  27;24;26;183;182  1571733817400  \n",
       "\n",
       "[13169 rows x 7 columns]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "questions_data_path = 'https://gist.githubusercontent.com/LeaveNhA/fbb8c6ce2a6422fab97f66ffdb7a7852/raw/d022e4a53f1bbb35435d82f9371c5a4a328aeb13/ednet-kt1.questions.csv' # fill the path for the question.csv\n",
    "questions = pd.read_csv(questions_data_path, encoding = \"ISO-8859-15\")\n",
    "\n",
    "questions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a9d60959",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bazı yardımcı fonksiyonlar tanımlanıyor:\n",
    "def apply_with(d, fn=lambda x: x):\n",
    "    res = d.copy() # \"= dict(d1)\" for lists of tuples\n",
    "    for key, val in res.items():\n",
    "        if type(res[key]) is dict:\n",
    "            res[key] = apply_with(res[key], fn)\n",
    "        else:\n",
    "            res[key] = fn(res[key])\n",
    "    return res\n",
    "\n",
    "def merge_with(d1, d2, fn=lambda x, y: x + y):\n",
    "    # print(\"---------merging---------\")\n",
    "    # print('d1: {}, d2: {}'.format(d1, d2))\n",
    "    res = d1.copy() # \"= dict(d1)\" for lists of tuples\n",
    "    for key, val in d2.items(): # \".. in d2\" for lists of tuples\n",
    "        try:\n",
    "            if type(res[key]) is dict:\n",
    "                #print('dict')\n",
    "                #print(key)\n",
    "                #print(res[key])\n",
    "                res[key] = merge_with(res[key], val, fn)\n",
    "            else:\n",
    "                #print('scaler')\n",
    "                #print(key)\n",
    "                res[key] = fn(res[key], val)\n",
    "                #print(res[key])\n",
    "        except: #KeyError:res[key] = val\n",
    "            pass\n",
    "    #print(\"res: {}\".format(res))\n",
    "    #print(\"--------------------\")\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fd4dd6f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# KT-1 verilerinin yolu:\n",
    "kt1_path = r'/Users/sckn/projects/academic/OMU-DS/paper/kt1/kt1'\n",
    "standart_drop_fields = ['user_answer',\n",
    "                        'explanation_id',\n",
    "                        'correct_answer',\n",
    "                        'part',\n",
    "                        'deployed_at',\n",
    "                        'user_answer_flag']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "83762d99",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Öğrenici gezinimi için bazı ara-evrensel değişkenler.\n",
    "s = pd.Series(os.listdir(kt1_path))\n",
    "all_student_files = s.to_numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fa8c593c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for the sake of functional composition!\n",
    "import functools\n",
    "\n",
    "def c(*fs):\n",
    "    return functools.reduce(compose2, fs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8e13e180",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pymonad.tools import curry\n",
    "\n",
    "@curry(2)\n",
    "def filename_to_fullpath(path, filename):\n",
    "    return Just(path + '/' + filename)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f8b82262",
   "metadata": {},
   "outputs": [],
   "source": [
    "def filename_to_pd(filefullpath):\n",
    "    try:\n",
    "        return Just(pd.read_csv(filefullpath, encoding = \"ISO-8859-15\"))\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c3e0dbdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "@curry(2)\n",
    "def studentfile_to_pd(answer_limit, file_name):\n",
    "    # Öğrenici verisi okunuyor:\n",
    "    data_raw = pd.read_csv(file_name, encoding = \"ISO-8859-15\")\n",
    "    # Bazı kısıtlar var.\n",
    "    # Herhangi bir kayıp verisi varsa, öğrenici pas geçiliyor:\n",
    "    if data_raw.isnull().values.any():\n",
    "        return Nothing\n",
    "    # Öğrenici cevap sayısı, belirlenen limitin altındaysa,\n",
    "    # öğrenci pas geçiliyor.\n",
    "    if data_raw.shape[0] < answer_limit:\n",
    "        return Nothing\n",
    "    \n",
    "    return Just(pd.DataFrame(data_raw))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "47842b3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "@curry(3)\n",
    "def merge_with_another_pd(another_pd_, common_key_, pd_):\n",
    "    try:\n",
    "        return Just(pd.merge(pd_, another_pd_, left_on = common_key_, right_on = common_key_))\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d51f8476",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_user_answer_flag(data):\n",
    "    try:\n",
    "        data['user_answer_flag'] = data['user_answer'] == data['correct_answer']\n",
    "        data['user_answer_flag'] = data['user_answer_flag'].apply(lambda f: int(f))\n",
    "        return Just(data)\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "334ca8c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_input_structered_data(data):\n",
    "    return Just({'data': data})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4745d70f",
   "metadata": {},
   "outputs": [],
   "source": [
    "@curry(2)\n",
    "def generate_X_y_data(drop_fields, sdata):\n",
    "    try:\n",
    "        # Veri Setimiz birleşimden sonra daha da farklı bir şekil alıyor,\n",
    "        # Bağımlı değişkenleri modele girmeden önce bazı sütunları ayıklıyoruz:\n",
    "        X = sdata['data'].drop(drop_fields, axis = 1)\n",
    "        # Hedef değişkenimizi ayırıyoruz:\n",
    "        y = sdata['data']['user_answer_flag']\n",
    "        \n",
    "        sdata['X'] = X\n",
    "        sdata['y'] = y\n",
    "        \n",
    "        return Just(sdata)\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "93c4090f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def mutate_X_data(sdata):\n",
    "    try:\n",
    "        # Çıkarımlar:\n",
    "        X = sdata['X']\n",
    "        # Etiket kodlama yöntemiyle, kategorik değerleri işliyoruz:\n",
    "        tags_to_identity_number = dict(zip(np.unique(X['tags']), range(1, len(np.unique(X['tags'])) + 1)))\n",
    "        X['tags'] = X['tags'].apply(lambda ui: tags_to_identity_number[ui])\n",
    "\n",
    "        question_id_to_identity_number = dict(zip(np.unique(X['question_id']), range(1, len(np.unique(X['question_id'])) + 1)))\n",
    "        X['question_id'] = X['question_id'].apply(lambda ui: question_id_to_identity_number[ui])\n",
    "\n",
    "        bundle_id_to_identity_number = dict(zip(np.unique(X['bundle_id']), range(1, len(np.unique(X['bundle_id'])) + 1)))\n",
    "        X['bundle_id'] = X['bundle_id'].apply(lambda ui: bundle_id_to_identity_number[ui])\n",
    "\n",
    "        # Sürede geçirilen süre milisaniye cinsinden,\n",
    "        # Bunu, saniye cinsine dönüştürerek iyileştirme yapıyoruz:\n",
    "        X['elapsed_time'] = X['elapsed_time'].apply(lambda et: et / 1000)\n",
    "        \n",
    "        sdata['X'] = X\n",
    "        \n",
    "        return Just(sdata)\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "7c76f4b5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def split_user_data(sdata):\n",
    "    try:\n",
    "        # Çıkarımlar:\n",
    "        X = sdata['X']\n",
    "        y = sdata['y']\n",
    "        # Verinin ayrıştırılması için ilkleme yapıyoruz:\n",
    "        tscv = TimeSeriesSplit()\n",
    "\n",
    "        # Verinin ayrıştırılması için ayrıştırıcıdan sağlanan değerlerle,\n",
    "        # veriyi ayırıyoruz:\n",
    "        for train_index, test_index in tscv.split(X):\n",
    "            X_train, X_test = X.iloc[train_index], X.iloc[test_index]\n",
    "            y_train, y_test = y.iloc[train_index], y.iloc[test_index]\n",
    "        \n",
    "        sdata['X_train'] = X_train\n",
    "        sdata['X_test'] = X_test\n",
    "        sdata['y_train'] = y_train\n",
    "        sdata['y_test'] = y_test\n",
    "        \n",
    "        return Just(sdata)\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a9fd063d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_model_data(sdata):\n",
    "    try:\n",
    "        sdata['model'] = Pipeline([('scaler', StandardScaler()),\n",
    "                                      ('logreg', LogisticRegression(\n",
    "                                          fit_intercept=True, \n",
    "                                            penalty = 'l1',\n",
    "                                            solver = 'saga',\n",
    "                                            tol = 0.00001,\n",
    "                                            max_iter = 1000,\n",
    "                                            random_state = 0,\n",
    "                                            n_jobs = -1))])\n",
    "        \n",
    "        return Just(sdata)\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "37fb0a68",
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model_data(sdata):\n",
    "    try:\n",
    "        sdata['model'].fit(sdata['X_train'], sdata['y_train'])\n",
    "        return Just(sdata)\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "983d2f2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_model_data(sdata):\n",
    "    try:\n",
    "        # Tahminde bulunuyoruz:\n",
    "        sdata['y_train_pred'] = sdata['model'].predict(sdata['X_train'])\n",
    "        sdata['y_test_pred'] = sdata['model'].predict(sdata['X_test'])\n",
    "        \n",
    "        return Just(sdata)\n",
    "    except BaseException as e:\n",
    "        print(e)\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a90b37a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_roc_and_auc_data(sdata):\n",
    "    try:\n",
    "        # Tahmin olasılıkları:\n",
    "        y_pred_proba = sdata['model'].predict_proba(sdata['X_test'])[::,1]\n",
    "        # ROC için bazı değerler toplanıyor ve depolanıyor:\n",
    "        [fpr, tpr, _] = roc_curve(sdata['y_test'],  y_pred_proba)\n",
    "\n",
    "        # Eğer tahmin birim, ikilik değilse, AUC hesaplanamaz.\n",
    "        # Bunu önlemek için, hata fırlatılması durumunda,\n",
    "        # Öğreniciyi ve modeli, yine de atlıyoruz:\n",
    "        try:\n",
    "            auc = roc_auc_score(sdata['y_test'], y_pred_proba)\n",
    "        except:\n",
    "            return Nothing\n",
    "        \n",
    "        sdata['roc'] = [fpr, tpr]\n",
    "        \n",
    "        # Ortalama ROC için temel FPR değeri:\n",
    "        base_fpr = np.linspace(0, 1, 101)\n",
    "        # Temel FPR değeri ve ilgili FPR, TPR değeri işlenerek,\n",
    "        # indirgeme yapılıyor:\n",
    "        tpr = np.interp(base_fpr, fpr, tpr)\n",
    "        # Basit bir düzeltme ile,\n",
    "        # başlangıç değeri sıfırlanıyor.\n",
    "        tpr[0] = 0.0\n",
    "\n",
    "        sdata['auc_score'] = auc\n",
    "        sdata['tpr'] = tpr\n",
    "        \n",
    "        return Just(sdata)\n",
    "    except:\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "21783f7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_classification_report_data(sdata):\n",
    "    try:\n",
    "        # Sınıflandırma raporu hesaplanıyor:\n",
    "        clf_report = classification_report(sdata['y_test'], sdata['y_test_pred'],\n",
    "                                           output_dict=True)\n",
    "        \n",
    "        sdata['clf'] = clf_report\n",
    "        \n",
    "        return Just(sdata)\n",
    "    except BaseException as e:\n",
    "        print(e)\n",
    "        return Nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9d89a10e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "with parallel_backend('threading'):\n",
    "    filtered_students = Parallel()(\n",
    "        delayed(filename_to_fullpath(kt1_path))(f) for f in all_student_files\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f39a8780",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    pd_students = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(studentfile_to_pd(1_000)))(sfn) for sfn in filtered_students\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "dd37abdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    students_pd_with_questions = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(merge_with_another_pd(questions, 'question_id')))(sfn) for sfn in pd_students\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "a582ae8a",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    user_answer_generated = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(generate_user_answer_flag))(sfn) for sfn in students_pd_with_questions\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "4741ba49",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    user_inputs = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(prepare_input_structered_data))(sfn) for sfn in user_answer_generated\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "a8927ffb",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    user_X_y_sdata = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(generate_X_y_data(standart_drop_fields)))(sfn) for sfn in user_inputs\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "f1f363b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    mutated_user_data = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(mutate_X_data))(sfn) for sfn in user_X_y_sdata\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a53d7d72",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    splitted_user_data = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(split_user_data))(sfn) for sfn in mutated_user_data\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d9b72a14",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    modelled_user_data = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(generate_model_data))(sfn) for sfn in splitted_user_data\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "621b78f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    trained_user_data = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(train_model_data))(sfn) for sfn in modelled_user_data\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d8a4304c",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    roc_and_auc_generated_user = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(generate_roc_and_auc_data))(sfn) for sfn in trained_user_data\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "995650fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    predicted_data_generated_user = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(test_model_data))(sfn) for sfn in roc_and_auc_generated_user\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5aa4b8af",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    clf_generated_user = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.then(generate_classification_report_data))(sfn) for sfn in predicted_data_generated_user\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "a05f69a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "with parallel_backend('threading', n_jobs=12):    \n",
    "    filtered_users_data = Parallel()(\n",
    "        delayed(lambda sfn_: sfn_.maybe(Nothing, lambda x: x))(sfn) for sfn in clf_generated_user if sfn is not Nothing\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "15f384b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19761"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(filtered_users_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "484bebc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sınıflandırma Raporu özeti için,\n",
    "# listedeki raporlar toplanıyor:\n",
    "summed_clf = reduce(\n",
    "    lambda acc, e: merge_with(acc, e['clf']), filtered_users_data[1:], filtered_users_data[0]['clf']\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "87b966c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'0': {'precision': 5746.981650494418,\n",
       "  'recall': 2004.3128037991346,\n",
       "  'f1-score': 2177.153094992772,\n",
       "  'support': 2475281},\n",
       " '1': {'precision': 13547.317214748677,\n",
       "  'recall': 18140.06600184442,\n",
       "  'f1-score': 15323.03995543767,\n",
       "  'support': 5623494},\n",
       " 'accuracy': 13507.197226535462,\n",
       " 'macro avg': {'precision': 9647.149432621609,\n",
       "  'recall': 10072.189402821763,\n",
       "  'f1-score': 8750.096525215278,\n",
       "  'support': 8098775},\n",
       " 'weighted avg': {'precision': 11590.080158093126,\n",
       "  'recall': 13507.197226535462,\n",
       "  'f1-score': 11653.137163800235,\n",
       "  'support': 8098775}}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summed_clf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "147be365",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Toplanan değerli rapor, birim sayısına bölünerek ortalama alınıyor:\n",
    "averaged_clf = apply_with(summed_clf, lambda x: x / len(filtered_users_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "174b6f43",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Grafiksel çıktı için figür ilklemesi:\n",
    "fig = plt.figure()\n",
    "# Isı haritası, ortalanan Sınıflandırma Raporu üzerinden hazırlanıyor:\n",
    "sns.heatmap(pd.DataFrame(averaged_clf).iloc[:-1, :].T, annot=True)\n",
    "\n",
    "# Isı haritası kaydediliyor:\n",
    "fig.savefig('clf.compiled.png', dpi = 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "6ab1be83",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n"
     ]
    },
    {
     "data": {