05.Tree_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **Decision Tree Classification**\n",
    "1. 의사결정 트리 분류기를 활용한다\n",
    "1. 전체 n개의 feacture를 이분 분할시 **n개의** 경우의 수가 생성\n",
    "1. 전체 n개의 feacture를 m 분할시 **$n^m$** 경우의 수가 가능하다\n",
    "\n",
    "> Decision Tree 알고리즘\n",
    "\n",
    "1. **ID3**(Iterative Dichotomiser 3)  Top Down 기법\n",
    "1. **C4.5** : 생성한 Tree를 순회하는 백트래킹을 도입\n",
    "1. **CART**(Classification and Regression Tree)\n",
    "1. **CHAID**(Chi-square Automatic Interaction Detetor)\n",
    "\n",
    "<img src=\"https://www.saedsayad.com/images/Decision_Tree_1.png\" align=\"left\" width=500>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **1 CART 알고리즘의 구현**\n",
    "1. **Decision Tree** 알고리즘 중 **CART** 를 구현한다\n",
    "1. 범주형 데이터는 **오른쪽 자식 Node**에 우선 할당하고\n",
    "1. 나머지는 **왼쪽 자식 Node**에 구분하여 할당한다"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "\n",
    "### **01 지니계수 : Tree 분할 비교기준**\n",
    "1. 얼마나 잘 나뉘었는지 조합을 측정하기 위해서 **Gini Impurity** 와 **Information Gain**을 사용한다\n",
    "1. **지니계수**(Gini Impurity)는 **해당 크래스의 순도/ 중첩비율을** 측정한다\n",
    "1. 지니계수 **값이 작을수록**, 데이터 Set의 **순도비율이 높음을** 알 수 있다 (중첩이 적다/분류가 잘 된다)\n",
    "1. Tree 모델을 비교시, **서브그룹의 지니계수를 더하기만** 하면 된다\n",
    "\n",
    "$$ 지니계수 = 1 - \\sum_{k=1}^{k} f_k^2 $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "from matplotlib import rc\n",
    "rc('font', family=['NanumGothic','Malgun Gothic'])\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# 0 ~ 1 사이의 값으로 2진분류에 따른 지니계수 변화\n",
    "pos_fraction = np.linspace(0.00, 1.00, 1000)\n",
    "gini         = 1 - pos_fraction ** 2 - (1-pos_fraction) ** 2\n",
    "plt.plot(pos_fraction, gini)\n",
    "plt.xlabel('양성 클래스 비율(Positive fraction)')\n",
    "plt.ylabel('지니계수(Gini Impurity)')\n",
    "plt.ylim(0, 1); plt.grid(); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0000\n",
      "0.4800\n",
      "0.5000\n",
      "0.0000\n"
     ]
    }
   ],
   "source": [
    "# 데이터set에 레이블이 있는경우 지니계수\n",
    "def gini_impurity(labels):\n",
    "    if not labels: # 레이블이 없는경우 0\n",
    "        return 0\n",
    "    counts = np.unique(labels, return_counts=True)[1]\n",
    "    fractions = counts / float(len(labels))\n",
    "    return 1 - np.sum(fractions ** 2)\n",
    "\n",
    "print('{0:.4f}'.format(gini_impurity([])))\n",
    "print('{0:.4f}'.format(gini_impurity([1, 1, 0, 1, 0])))\n",
    "print('{0:.4f}'.format(gini_impurity([1, 1, 0, 1, 0, 0])))\n",
    "print('{0:.4f}'.format(gini_impurity([1, 1, 1, 1])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "\n",
    "### **02 entropy 불확실성에 대한 확률 측정**\n",
    "1. **엔트로피** : 불확실성에 대한 확률 측정값\n",
    "1. 엔트로피 값이 **작을수록** 명확하고 순도가 높은 DataSet에 해당한다\n",
    "1. 정보이득 = **분할 전** 엔트로피 - **분할 후** 엔트로피  = **부모** 엔트로피 - **자식** 엔트로피\n",
    "1. 목표는 **정보이득이 최대가 되는 분할지점을** 찾는 것이다\n",
    "1. 부모는 변하지 않으므로, **생성된 자식들의 엔트로피가 작을수록** 잘 구조화된 모델이 된다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/markbaum/Python/python/lib/python3.6/site-packages/ipykernel_launcher.py:6: RuntimeWarning: divide by zero encountered in log2\n",
      "  \n",
      "/home/markbaum/Python/python/lib/python3.6/site-packages/ipykernel_launcher.py:6: RuntimeWarning: invalid value encountered in multiply\n",
      "  \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# import warnings\n",
    "# warnings.simplefilter(action='ignore', category=FutureWarning)\n",
    "\n",
    "# Plot entropy in binary case\n",
    "pos_fraction = np.linspace(0.00, 1.00, 1000)\n",
    "ent = - (pos_fraction * np.log2(pos_fraction) + (1 - pos_fraction) * np.log2(1 - pos_fraction))\n",
    "plt.plot(pos_fraction, ent)\n",
    "plt.xlabel('양성클래스 비율(Positive fraction)')\n",
    "plt.ylabel('엔트로피(Entropy)')\n",
    "plt.ylim(0, 1); plt.grid(); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 0, 1, 0] 의 엔트로피 : 0.9710\n",
      "[1, 1, 0, 1, 0, 0] 의 엔트로피 : 1.0000\n",
      "[1, 1, 1, 1] 의 엔트로피 : -0.0000\n"
     ]
    }
   ],
   "source": [
    "# DataSet 의 엔트로피 측정함수\n",
    "def entropy(labels):\n",
    "    if not labels:\n",
    "        return 0\n",
    "    counts = np.unique(labels, return_counts=True)[1]\n",
    "    fractions = counts / float(len(labels))\n",
    "    return - np.sum(fractions * np.log2(fractions))\n",
    "\n",
    "for datum in [[1, 1, 0, 1, 0], [1, 1, 0, 1, 0, 0], [1, 1, 1, 1]]:\n",
    "    print('{} 의 엔트로피 : {:.4f}'.format(datum, entropy(datum)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 자식 Node들의 지니계수 측정\n",
    "def information_gain(y, mask, func=entropy):\n",
    "    s1 = np.sum(mask)\n",
    "    s2 = mask.size - s1\n",
    "    if (s1 == 0 | s2 == 0): return 0\n",
    "    return func(y) - s1 / float(s1 + s2) * func(y[mask]) - s2 / float(s1 + s2) * func(y[np.logical_not(mask)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entropy of #1 split: 0.9510\n",
      "Entropy of #2 split: 0.5510\n"
     ]
    }
   ],
   "source": [
    "# 지니계수와 엔트로피 특정\n",
    "criterion_function = {'gini': gini_impurity, \n",
    "                      'entropy': entropy}\n",
    "\n",
    "# Tree 분할 후 자식노드를 대상으로 가중치가 반영된 순도값 측정\n",
    "def weighted_impurity(groups, criterion='gini'):\n",
    "    total = sum(len(group) for group in groups)\n",
    "    weighted_sum = 0.0\n",
    "    for group in groups:\n",
    "        weighted_sum += len(group) / float(total) * criterion_function[criterion](group)\n",
    "    return weighted_sum\n",
    "\n",
    "children_1 = [[1, 0, 1], [0, 1]]\n",
    "children_2 = [[1, 1], [0, 0, 1]]\n",
    "print('Entropy of #1 split: {0:.4f}'.format(weighted_impurity(children_1, 'entropy')))\n",
    "print('Entropy of #2 split: {0:.4f}'.format(weighted_impurity(children_2, 'entropy')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "\n",
    "## **3 의사결정 Tree 함수를 구현**\n",
    "최적의 Tree 모델을 구현하는데 필요한 함수들을 정의한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gini_impurity(labels):\n",
    "    # When the set is empty, it is also pure\n",
    "    if labels.size == 0:\n",
    "        return 0\n",
    "    # Count the occurrences of each label\n",
    "    counts = np.unique(labels, return_counts=True)[1]\n",
    "    fractions = counts / float(len(labels))\n",
    "    return 1 - np.sum(fractions ** 2)\n",
    "\n",
    "def entropy(labels):\n",
    "    # When the set is empty, it is also pure\n",
    "    if labels.size == 0:\n",
    "        return 0\n",
    "    counts = np.unique(labels, return_counts=True)[1]\n",
    "    fractions = counts / float(len(labels))\n",
    "    return - np.sum(fractions * np.log2(fractions))\n",
    "\n",
    "criterion_function = {'gini': gini_impurity, 'entropy': entropy}\n",
    "def weighted_impurity(groups, criterion='gini'):\n",
    "    total = sum(len(group) for group in groups)\n",
    "    weighted_sum = 0.0\n",
    "    for group in groups:\n",
    "        weighted_sum += len(group) / float(total) * criterion_function[criterion](group)\n",
    "    return weighted_sum # float, weighted impurity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# feacture 와 Value를 사용하여 왼쪽/ 오른쪽 자식 Node로 분할하는 함수\n",
    "def split_node(X, y, index, value):\n",
    "    x_index = X[:, index]\n",
    "    # 수치형 데이터인 경우\n",
    "    if X[0, index].dtype.kind in ['i', 'f']:\n",
    "        mask = x_index >= value\n",
    "    # 범주형 데이터인 경우\n",
    "    else:\n",
    "        mask = x_index == value\n",
    "    # 왼쪽 / 오른쪽 자식 Node로 분할한다\n",
    "    left  = [X[~mask, :], y[~mask]]\n",
    "    right = [X[mask, :], y[mask]]\n",
    "    return left, right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tree 분할 후 최적의 모델을 출력한다\n",
    "def get_best_split(X, y, criterion):\n",
    "    # Obtain the best splitting point and resulting children for the data set X, y\n",
    "    best_index, best_value, best_score, children = None, None, 1, None\n",
    "    for index in range(len(X[0])):\n",
    "        for value in np.sort(np.unique(X[:, index])):\n",
    "            groups = split_node(X, y, index, value)\n",
    "            impurity = weighted_impurity([groups[0][1], groups[1][1]], criterion)\n",
    "            if impurity < best_score:\n",
    "                best_index, best_value, best_score, children = index, value, impurity, groups\n",
    "    # dict {index : index of the feature, value: feature value, children: left and right children}\n",
    "    return {'index': best_index, 'value': best_value, 'children': children}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 가장 많이 나타난 label로 leaf Node의 결과를 출력한다\n",
    "def get_leaf(labels):\n",
    "    return np.bincount(labels).argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Node를 생성하거나, Leaf Node에 할당하기 위해 현재의 Node를 자식Node로 분할\n",
    "def split(node, max_depth, min_size, depth, criterion):\n",
    "    \"\"\" Args >>>\n",
    "        node : (dict, 자식 정보가 포함)\n",
    "        max_depth : (int, 생성할 tree의 최대 깊이)\n",
    "        min_size : (int, 자식 노드를 추가/불할시 필요한 최소의 샘플갯수)\n",
    "        depth : (int, 노드의 현재깊이)\n",
    "        criterion : (gini 또는 entropy) \"\"\"\n",
    "    left, right = node['children']\n",
    "    del (node['children'])\n",
    "    if left[1].size == 0:\n",
    "        node['right'] = get_leaf(right[1])\n",
    "        return\n",
    "    if right[1].size == 0:\n",
    "        node['left'] = get_leaf(left[1])\n",
    "        return\n",
    "    # 현재 생성한 깊이가 최대설정값을 초과하는지 여부를 판단\n",
    "    if depth >= max_depth:\n",
    "        node['left'], node['right'] = get_leaf(left[1]), get_leaf(right[1])\n",
    "        return\n",
    "    # 왼쪽 자식 노드에 샘플데이터가 많은지를 검사한다\n",
    "    if left[1].size <= min_size:\n",
    "        node['left'] = get_leaf(left[1])\n",
    "    else:\n",
    "        # 샘플데이터가 많으면 추가분할을 수행한다\n",
    "        result = get_best_split(left[0], left[1], criterion)\n",
    "        result_left, result_right = result['children']\n",
    "        if result_left[1].size == 0:\n",
    "            node['left'] = get_leaf(result_right[1])\n",
    "        elif result_right[1].size == 0:\n",
    "            node['left'] = get_leaf(result_left[1])\n",
    "        else:\n",
    "            node['left'] = result\n",
    "            split(node['left'], max_depth, min_size, depth + 1, criterion)\n",
    "    # 오른쪽 자식 노드에 샘플데이터가 많은지 검사한다\n",
    "    if right[1].size <= min_size:\n",
    "        node['right'] = get_leaf(right[1])\n",
    "    else:\n",
    "        # 샘플 데이터가 많으면, 추가 분할을 수행한다\n",
    "        result = get_best_split(right[0], right[1], criterion)\n",
    "        result_left, result_right = result['children']\n",
    "        if result_left[1].size == 0:\n",
    "            node['right'] = get_leaf(result_right[1])\n",
    "        elif result_right[1].size == 0:\n",
    "            node['right'] = get_leaf(result_left[1])\n",
    "        else:\n",
    "            node['right'] = result\n",
    "            split(node['right'], max_depth, min_size, depth + 1, criterion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tree 생성을 위한 함수를 정의한다\n",
    "def train_tree(X_train, y_train, max_depth, min_size, criterion='gini'):\n",
    "    \"\"\" Args >>>\n",
    "        X_train,  y_train (list, list, 학습 데이터)\n",
    "        max_depth (int, tree의 최대 깊이)\n",
    "        min_size  (int, 자식 노드를 추가 분할하는데 필요한 최소한의 샘플갯수)\n",
    "        criterion (gini 또는 entropy) \"\"\"\n",
    "    X = np.array(X_train)\n",
    "    y = np.array(y_train)\n",
    "    root = get_best_split(X, y, criterion)\n",
    "    split(root, max_depth, min_size, 1, criterion)\n",
    "    return root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 생성한 Tree 구조를 화면에 출력하는 파라미터와 함수\n",
    "CONDITION = {'numerical'  : {'yes': '>=', 'no': '<'},\n",
    "             'categorical': {'yes': 'is', 'no': 'is not'}}\n",
    "\n",
    "def visualize_tree(node, depth=0):\n",
    "    if isinstance(node, dict):\n",
    "        if node['value'].dtype.kind in ['i', 'f']:\n",
    "            condition = CONDITION['numerical']\n",
    "        else:\n",
    "            condition = CONDITION['categorical']\n",
    "        print('{}|- X{} {} {}'.format(depth * '  ', node['index'] + 1, condition['no'], node['value']))\n",
    "        if 'left' in node:\n",
    "            visualize_tree(node['left'], depth + 1)\n",
    "        print('{}|- X{} {} {}'.format(depth * '  ', node['index'] + 1, condition['yes'], node['value']))\n",
    "        if 'right' in node:\n",
    "            visualize_tree(node['right'], depth + 1)\n",
    "    else:\n",
    "        print('{}[{}]'.format(depth * '  ', node))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "\n",
    "## **4 의사결정 Tree 예제 Data로 구현해보기**\n",
    "수치형 예제 데이터로 test를 진행한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|- X1 is not fashion\n",
      "  |- X2 is not professional\n",
      "    [0]\n",
      "  |- X2 is professional\n",
      "    [1]\n",
      "|- X1 is fashion\n",
      "  [0]\n"
     ]
    }
   ],
   "source": [
    "X_train = [['tech', 'professional'],\n",
    "           ['fashion', 'student'],\n",
    "           ['fashion', 'professional'],\n",
    "           ['sports', 'student'],\n",
    "           ['tech', 'student'],\n",
    "           ['tech', 'retired'],\n",
    "           ['sports', 'professional']]\n",
    "\n",
    "y_train = [1,0,0,0,1,0,1]\n",
    "tree = train_tree(X_train, y_train, 2, 2)\n",
    "visualize_tree(tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|- X2 < 4\n",
      "  |- X1 < 7\n",
      "    [1]\n",
      "  |- X1 >= 7\n",
      "    [0]\n",
      "|- X2 >= 4\n",
      "  |- X1 < 2\n",
      "    [1]\n",
      "  |- X1 >= 2\n",
      "    [0]\n"
     ]
    }
   ],
   "source": [
    "X_train_n = [[6, 7],[2, 4],[7, 2],[3, 6],[4, 7],\n",
    "             [5, 2],[1, 6],[2, 0],[6, 3],[4, 1]]\n",
    "\n",
    "y_train_n = [0,0,0,0,0,1,1,1,1,1]\n",
    "\n",
    "tree = train_tree(X_train_n, y_train_n, 2, 2)\n",
    "visualize_tree(tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 16,
     "metadata": {
      "image/png": {
       "width": 500
      }
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# graphviz 로 Tree 구조를 외부파일로 출력하기\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "tree_sk = DecisionTreeClassifier(criterion='gini', max_depth=2, min_samples_split=2)\n",
    "tree_sk.fit(X_train_n, y_train_n)\n",
    "\n",
    "from sklearn.tree import export_graphviz\n",
    "inter = export_graphviz(tree_sk, \n",
    "                out_file      = './data/tree.dot', \n",
    "                feature_names = ['X1', 'X2'], \n",
    "                impurity      = False, \n",
    "                filled        = True, \n",
    "                class_names   = ['0', '1'])\n",
    "\n",
    "import os\n",
    "from IPython.display import Image\n",
    "os.system('dot -Tpng ./data/tree.dot -o ./data/tree.png') # .dot 파일을 .png 로 변환\n",
    "Image(filename='./data/tree.png', width=500) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "\n",
    "# **Click Through Rate**\n",
    "1. **CRT** (Click Through Rate) : **전체 페이지 뷰** 횟수 대비 **특정광고 클릭횟수** 비율\n",
    "1. **CRT** 값이 클수록 **Target Marketing이** 잘 되었음을 의미한다\n",
    "1. **Feacture**들은 **범주형**데이터로 구성되어 있고, 이를 **수치화를** 해도 **구분만 함에** 유의할 것\n",
    "1. **광고 콘텐츠 및 정보**\n",
    "1. **페이지 콘텐츠 및 광고 정보**\n",
    "1. **광고 수신측 정보**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **1 Decision Tree를 이용한 Click Through Rate 예측하기**\n",
    "전체 데이터 중 100,000개만 추출하여 모델을 학습한다\n",
    "\n",
    "> **데이터 살펴보기**\n",
    "\n",
    "1. **Site_ID** : 광고 ID\n",
    "1. **Click (y_train_data)** : 클릭 여부 (0, 1)\n",
    "1. **C1, C14 ~ C19** : 익명처리된 카테고리 변수\n",
    "1. **banner_pos** : 배너의 위치\n",
    "1. **site_id** : 웹사이트 ID\n",
    "1. **app_id** : 모바일앱 ID"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "\n",
    "### **01 데이터 불러오기**\n",
    "**Click Trough Rate Prediction** [압축1GB](https://www.kaggle.com/c/avazu-ctr-prediction/data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'C1': '1005', 'C14': '15706', 'C15': '320', 'C16': '50', 'C17': '1722', 'C18': '0', 'C19': '35', 'C20': '-1', 'C21': '79', 'app_category': '07d7df22', 'app_domain': '7801e8d9', 'app_id': 'ecad2386', 'banner_pos': '0', 'device_conn_type': '2', 'device_model': '44956a24', 'device_type': '1', 'site_category': '28905ebd', 'site_domain': 'f3845767', 'site_id': '1fbe01fe'}\n",
      "{'C1': '1005', 'C14': '15704', 'C15': '320', 'C16': '50', 'C17': '1722', 'C18': '0', 'C19': '35', 'C20': '100084', 'C21': '79', 'app_category': '07d7df22', 'app_domain': '7801e8d9', 'app_id': 'ecad2386', 'banner_pos': '0', 'device_conn_type': '0', 'device_model': '711ee120', 'device_type': '1', 'site_category': '28905ebd', 'site_domain': 'f3845767', 'site_id': '1fbe01fe'}\n"
     ]
    }
   ],
   "source": [
    "# 6GB 데이터를, 필요한 인덱스 까지 순차적 메모리 호출\n",
    "# 대용량 데이터를 메모리로 호출하는 경우 활용하기에 적합\n",
    "def read_ad_click_data(n, offset=0):\n",
    "    import csv\n",
    "    X_dict, y = [], []\n",
    "    with open('./data/train.csv', 'r') as csvfile:\n",
    "        reader = csv.DictReader(csvfile)\n",
    "        for i in range(offset):\n",
    "            next(reader)\n",
    "        i = 0\n",
    "        for row in reader:\n",
    "            i += 1\n",
    "            y.append(int(row['click']))\n",
    "            del row['click'], row['id'], row['hour'], row['device_id'], row['device_ip']\n",
    "            X_dict.append(dict(row))\n",
    "            if i >= n:\n",
    "                break\n",
    "    return X_dict, y\n",
    "\n",
    "n = 10000  # 데이터를 줄여서 10,000개로 학습\n",
    "X_dict_train, y_train = read_ad_click_data(n)\n",
    "print(X_dict_train[0])\n",
    "print(X_dict_train[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train DataSet (0~10,000) : 2,820\n",
      "X_test DataSet (10,000~20,000) : 2,820\n"
     ]
    }
   ],
   "source": [
    "# sklearn 의 Tree 기반의 알고리즘에 적합한 형태로 변환\n",
    "# 19개 컬럼 데이터를, 5725 차원의 이진 데이터(One-Hot)로 변형 (약 500Mb 늘어남)\n",
    "# Train 데이터 생성하기\n",
    "from sklearn.feature_extraction import DictVectorizer\n",
    "dict_one_hot_encoder = DictVectorizer(sparse = False)\n",
    "X_train              = dict_one_hot_encoder.fit_transform(X_dict_train)\n",
    "\n",
    "# Test 데이터 생성하기\n",
    "X_dict_test, y_test = read_ad_click_data(n, n)\n",
    "X_test = dict_one_hot_encoder.transform(X_dict_test)\n",
    "print(\"X_train DataSet (0~10,000) : {:,}\\nX_test DataSet (10,000~20,000) : {:,}\".format(\n",
    "    len(X_train[0]),len(X_test[0])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "\n",
    "### **02 Decision Tree Classifier 모델 학습**\n",
    "1. **DecisionTreeClassifier** 모듈을 사용하여 최적의 파라미터를 예측한다\n",
    "1. max_depth **최대 깊이 설정값만** 입력하면 조건내 **최적의 파라미터를** 출력한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'max_depth': 10}\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "parameters = {'max_depth': [3, 10, None]}\n",
    "decision_tree = DecisionTreeClassifier(criterion='gini', min_samples_split=30)\n",
    "\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "grid_search = GridSearchCV(decision_tree, parameters, n_jobs=-1, cv=3, scoring='roc_auc')\n",
    "\n",
    "grid_search.fit(X_train, y_train)\n",
    "print(grid_search.best_params_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The ROC AUC on testing set is: 0.671\n"
     ]
    }
   ],
   "source": [
    "# 100,000개로 학습히 0.692 정확도를 출력한다\n",
    "# 데이터 크기가 그렇게 크게 좌우되진 않는 듯\n",
    "decision_tree_best = grid_search.best_estimator_\n",
    "pos_prob = decision_tree_best.predict_proba(X_test)[:, 1]\n",
    "\n",
    "from sklearn.metrics import roc_auc_score\n",
    "print('The ROC AUC on testing set is: {0:.3f}'.format(roc_auc_score(y_test, pos_prob)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br/>\n",
    "\n",
    "### **03 Random Foreset classifier 모델 학습**\n",
    "1. **RandomForestClassifier** 모듈을 사용하여 최적의 파라미터를 예측한다\n",
    "1. **max_dapth** 파라미터만 변경하면 된다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/markbaum/Python/python/lib/python3.6/site-packages/sklearn/ensemble/weight_boosting.py:29: DeprecationWarning: numpy.core.umath_tests is an internal NumPy module and should not be imported. It will be removed in a future NumPy release.\n",
      "  from numpy.core.umath_tests import inner1d\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'max_depth': None}\n",
      "0.6956435223102432\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "random_forest = RandomForestClassifier(n_estimators=100, criterion='gini', min_samples_split=30, n_jobs=-1)\n",
    "grid_search   = GridSearchCV(random_forest, parameters, n_jobs=-1, cv=3, scoring='roc_auc')\n",
    "grid_search.fit(X_train, y_train)\n",
    "print(grid_search.best_params_)\n",
    "print(grid_search.best_score_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The ROC AUC on testing set is: 0.713\n"
     ]
    }
   ],
   "source": [
    "# 위의 Decision tree 보다 Random Foreset Classifier 성능이 더 좋다\n",
    "random_forest_best = grid_search.best_estimator_\n",
    "pos_prob = random_forest_best.predict_proba(X_test)[:, 1]\n",
    "print('The ROC AUC on testing set is: {0:.3f}'.format(roc_auc_score(y_test, pos_prob)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}