titanic_tutorial_for_beginners_2020.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.6",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "name": "titanic-tutorial-for-beginners-2020.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/baekkr95/kaggle/blob/master/titanic_tutorial_for_beginners_2020.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "027165e2-b97e-4313-8f26-b2048c22e0ba",
        "_cell_guid": "4b8a486e-1593-4e9e-9413-bc94d5a185b2",
        "trusted": true,
        "id": "xLAE6n4MAvRp",
        "colab_type": "text"
      },
      "source": [
        "# Titanic Challenge"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "86c93516-1ed8-46eb-8a78-8e884cb60eeb",
        "_cell_guid": "84c28543-f1e0-4cc6-bbf0-888235b95e54",
        "trusted": true,
        "id": "-PCij2F9AvRq",
        "colab_type": "text"
      },
      "source": [
        "![](https://i.imgur.com/rRFchA8.png)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "7cddfed8-6ae0-483b-a224-03b3a600096b",
        "_cell_guid": "d0e93258-f188-4bb1-8a97-d0483760def0",
        "trusted": true,
        "id": "4M-cJAX8AvRr",
        "colab_type": "text"
      },
      "source": [
        "이 튜토리얼은 캐글에 처음 도전하는 분들을 위한 것입니다. 커널부문 세계1위인 안드레이 룩야넨코의 노트북에 한글로설명을 추가로 붙인 것입니다. \n",
        "이 노트의 결과는 작성 현재 Top 4% 결과를 보입니다. (랜덤이 되는 부분이 있어서 결과가 약간씩 다르게 나오긴 합니다만 여러번 하시면 4% 선까지 올라갑니다.)\n",
        "Kaggle에 처음으로 로그인하는 것은 쉬운 결정이 아닙니다. 내가 무슨 머신러닝을? 이런 생각을 하실 수 도 있겠습니다. \n",
        "캐글은 대회로서도 의미가 있겠으나 배움의 터입니다. 이런 데이터를 초보자가 어디서 구하며 어떻게 다른 사람들이 일한 것을 통해 이리 쉽게 배우겠습니까? \n",
        "이 튜토리얼이 끝날 때 즈음에는 Kaggle의 온라인 코딩 환경을 사용하는 방법에 대한 이해를 얻게되며 그 와중에 머신러닝 학습 모델을 학습하게됩니다.\n",
        "\n",
        "우측 상단에 Copy & Edit을 눌러서 복사."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "a757358d-5613-4957-945d-45c1d9dcf361",
        "_cell_guid": "cde4aeff-6a03-43d6-a74a-6a70b60c7fed",
        "trusted": true,
        "id": "6NdfnPudAvRr",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"table_of_contents\"></a>\n",
        "## Table of contents\n",
        "\n",
        "[Part 1: 데이터 준비 및 모듈 임포트](#part1)\t\t\t\n",
        "[Part 2: 파일 병합](#part2)\t\t\t\n",
        "[Part 3: 파일 탐색](#part3)\t\t\t\n",
        "[Part 4: 데이터 탐구 (Exploratory Data Analysis)](#part4)\t\t\t\n",
        "[Part 5: Feature Engineering](#part5)\t\n",
        "\n",
        "[Part 6: 마지막 항목 결정](#part6)\t\t\t\n",
        "[Part 7: 머신러닝 모델 만들기](#part7)\t\t\t\n",
        "[Part 8: 중요도에 따라 모델 재 설정 ](#part8)\t\t\t\n",
        "[Part 9: 하이퍼 파라미터 튜닝](#part9)\t\t\t\n",
        "[Part 10: 모델 재 트레이닝](#part10)\t\t\t\n",
        "\n",
        "[Part 11: 마지막 보팅](#part11)\t\n",
        "[Part 12: 마지막 모델 예측](#part12)   \n",
        "[Part 13: 제출](#part13)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "8193447d-3855-4a2c-9781-8b44f861654f",
        "_cell_guid": "d121736f-b8e0-4636-9726-07cb18153778",
        "trusted": true,
        "id": "MUQfaI4RAvRs",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part1\"></a>\n",
        "## Part 1: 데이터 준비 및 모듈 임포트\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "b0e2e703-1a41-443d-9b5b-480d449db1de",
        "_cell_guid": "2b9c6525-9e52-410f-b319-b73e1e16c73b",
        "trusted": true,
        "id": "9D0OU2QqAvRt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 기본 데이터 정리 및 처리\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# 시각화\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "import seaborn as sns\n",
        "plt.style.use('seaborn-whitegrid')\n",
        "import missingno\n",
        "\n",
        "# 전처리 및 머신 러닝 알고리즘\n",
        "from sklearn.preprocessing import LabelEncoder, OneHotEncoder\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.svm import SVC\n",
        "from xgboost import XGBClassifier\n",
        "from sklearn.ensemble import GradientBoostingClassifier\n",
        "from sklearn.ensemble import ExtraTreesClassifier\n",
        "from sklearn.ensemble import AdaBoostClassifier\n",
        "from sklearn.gaussian_process import GaussianProcessClassifier\n",
        "from sklearn.naive_bayes import GaussianNB\n",
        "from sklearn.ensemble import BaggingClassifier\n",
        "from sklearn.ensemble import VotingClassifier\n",
        "\n",
        "# 모델 튜닝 및 평가\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from sklearn.model_selection import GridSearchCV\n",
        "from sklearn.model_selection import cross_val_predict\n",
        "from sklearn import model_selection\n",
        "\n",
        "# 경고 제거 (판다스가 에러 메세지를 자주 만들어 내기 때문에 이를 일단 무시하도록 설정합니다.)\n",
        "import sys\n",
        "import warnings\n",
        "\n",
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "78785734-5a6a-4f0c-b391-0ce120ea993e",
        "_cell_guid": "e46b4023-990d-409a-b9c7-03eb78b85521",
        "trusted": true,
        "id": "ryYhtltUAvRw",
        "colab_type": "text"
      },
      "source": [
        "### 중요 링크\n",
        "\n",
        "[구글 콜랩](https://colab.research.google.com/) \n",
        "\n",
        "[깃헙브](https://github.com)\n",
        "\n",
        "### 초보자이실 경우는 아래 링크 중 본인에게 맞는 것을 미리 공부해 보는 것도 도움이 됩니다.\n",
        "\n",
        "[edx의 파이썬 기초수업](https://learn.edx.org/topic-python/?g_acctid=926-195-8061&g_campaign=gs-nonbrand-topic-python&g_campaignid=1535528542&g_adgroupid=58645176415&g_adid=405031374941&g_keyword=learn%20python%20online%20tutorial&g_keywordid=kwd-357260176984&g_network=g?utm_source=adwords&utm_campaign=1535528542&utm_medium=58645176415&utm_term=learn%20python%20online%20tutorial&gclid=CjwKCAjwwYP2BRBGEiwAkoBpAu6FTNidm90CEM1AJQGDn_mvW_bDMJSkWuWk6DnUJCrCXnG0-vW_aBoC8GwQAvD_BwE)\n",
        "\n",
        "[파이썬 org에 나오는 파이썬 기초수업](https://docs.python.org/3/tutorial/)\n",
        "\n",
        "[w3schools 파이썬 기초수업](https://www.w3schools.com/python/)\n",
        "\n",
        "[Joshua Choi님의 파이썬 기초 문법 연습](https://joshua-mobile-choi-1756.trinket.io/python-3-4#/tasks/task-1-print-statement)\n",
        "\n",
        "[Joshua Choi님의 타이타닉 판다스 101 사용 예](https://www.kaggle.com/joshuajhchoi/101-pandas-tips-for-beginners-titanic-en-kr)\n",
        "\n",
        "[Joshua Choi님의 타이타닉 시각화 101 사용 예](https://www.kaggle.com/joshuajhchoi/101-data-visualization-tips-for-titanic-beginners)\n",
        "\n",
        "[Seaborn연습](https://seaborn.pydata.org/tutorial/aesthetics.html)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "9bdc9600-80b9-4c5c-b1df-d4068985d83c",
        "_cell_guid": "5da405e1-0b35-458b-b21c-8dbca574dc96",
        "trusted": true,
        "id": "JybAZZUJAvRw",
        "colab_type": "text"
      },
      "source": [
        "### CSV to DF\n",
        "\n",
        "* csv를 임포트하여 데이터셋이 판다스 데이터프레임이 되도록 합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "88f18f28-26b8-44cc-96c8-423a914124c4",
        "_cell_guid": "c7a78dc5-9c2d-4331-8dc1-58be9d451d55",
        "trusted": true,
        "id": "7G28jGohAvRx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 이 것이 처음하는 사람에게 예상보다 어려울 수 있는데 복사한 것에서 데이터가 전달이 잘 안 되었다면 \"+Add Data\" 누르시고 'Competition Data'에서 \"Titanic Data\" 불러온 후 파일을 찍어서 경로 주소 확인해야 함 \n",
        "test = pd.read_csv('../input/titanic/test.csv')\n",
        "train = pd.read_csv('../input/titanic/train.csv')\n",
        "\n",
        "# 이제 csv file들 (test & train)은 데이터 프레임이 되었습니다."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "cf987002-ea4e-43d8-b90d-52fcb72b73d2",
        "_cell_guid": "cd24877f-ce3c-4131-9259-15a4870d1f6b",
        "trusted": true,
        "id": "y67RpMMLAvRz",
        "colab_type": "text"
      },
      "source": [
        "구글 콜랩에서 사용하실 때는 컴퓨터에 파일을 다운로드 한 후 아래 코드를 입력하면 불러올 수 있게 됩니다.\n",
        "\n",
        "    from google.colab import files\n",
        "    uploaded = files.upload()\n",
        "\n",
        "그런 다음 아래 코드를 통해서 csv를 데이터프레임으로 바꿀 수 있게 됩니다.\n",
        "\n",
        "    import io\n",
        "    test = pd.read_csv(io.BytesIO(uploaded['test.csv']))\n",
        "    train = pd.read_csv(io.BytesIO(uploaded['train.csv']))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "5b9d444f-4b43-4b08-a052-80fa235f4c8a",
        "_cell_guid": "5472c06a-e6a5-4a27-9049-5af82ecc2cc2",
        "trusted": true,
        "id": "n5jin10NAvRz",
        "colab_type": "text"
      },
      "source": [
        "### 데이터프레임을 보는 다양한 방법"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "e2c7d4d4-ab5a-4275-b85b-b2e641598ed7",
        "_cell_guid": "ac32f23f-1bd4-468e-9441-b1e47419c648",
        "trusted": true,
        "id": "Fwv5T7cHAvRz",
        "colab_type": "text"
      },
      "source": [
        "`head()`첫 5행을 볼 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7dfc196d-9ba7-4745-b2b7-f9f10fc351dc",
        "_cell_guid": "0259dfab-e239-43da-a1c8-dab9089ed96f",
        "trusted": true,
        "id": "Wg_Mv1e_AvR0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.head(n=3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "2899ee0a-1fef-40e0-9a46-cc0c3e518129",
        "_cell_guid": "9e6dfbcc-1a21-4814-8c88-57183d4bfea7",
        "trusted": true,
        "id": "PzQzPxdzAvR2",
        "colab_type": "text"
      },
      "source": [
        "`tail()` 마지막 5행을 볼 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "b6b7c50f-d224-46df-9250-1fb1030208b2",
        "_cell_guid": "65d8d1e2-034a-4997-b0f8-73f9c04abede",
        "trusted": true,
        "id": "aeZjQ55QAvR2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "0cbcaa88-8b06-4338-b330-e1a3c97058dd",
        "_cell_guid": "5a376513-9e48-4747-b9ee-8cb43692fd8c",
        "trusted": true,
        "id": "jMvDFDolAvR4",
        "colab_type": "text"
      },
      "source": [
        "`describe()` 각 열의 통계적인 면을 보여 줍니다. \n",
        "\n",
        "기본은 연속된 값을 가진 열만 보여주나 `include='all'로 세팅하면 모두 볼 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7067dff1-b856-4d2a-aded-28343e75198f",
        "_cell_guid": "9f3aa6b2-f74c-46df-95ec-7fd524a34093",
        "trusted": true,
        "id": "g5w41OHmAvR5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.describe(include='all')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "acd0541f-3c58-4699-a728-733a5370db0d",
        "_cell_guid": "60be6a77-a2d2-446e-8aee-29412a25be5e",
        "trusted": true,
        "id": "e9BpzRPAAvR7",
        "colab_type": "text"
      },
      "source": [
        "`dtypes` 모든 열의 데이터 종류를 보여 줍니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "cd3238fa-22a7-4d2b-9e56-29ea5bbee40c",
        "_cell_guid": "87b12356-eec5-4ff2-86b0-534b984742e2",
        "trusted": true,
        "id": "9lwEzvkYAvR8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.dtypes"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "bac2dbf4-8cb6-4989-9629-fbbc7051197d",
        "_cell_guid": "bd30e0d1-652a-440d-9da5-29dc5f0d8546",
        "trusted": true,
        "id": "OtE626oRAvR-",
        "colab_type": "text"
      },
      "source": [
        "`info()` 는 `dtypes` 의 좀  더 발전된 개념으로 데이터 타입뿐만 아니라 빈칸이 아닌 갯수까지 보여 줍니다.\n",
        "\n",
        "[describe 학습](https://www.w3resource.com/pandas/dataframe/dataframe-describe.php)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "95a9aebd-1100-4541-b35f-997780dc8710",
        "_cell_guid": "08dc36bc-7f67-4463-8999-f1cdfa9783b3",
        "trusted": true,
        "id": "RCjyYBZEAvR-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.info()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "9ccce62b-003b-4646-9c55-1db47bcef89e",
        "_cell_guid": "d82c7ac5-c95c-4539-9b9f-4e86aec8eb43",
        "trusted": true,
        "id": "U95GbiiqAvSA",
        "colab_type": "text"
      },
      "source": [
        "`columns`은 데이터 프레임의 열의 제목들을 보여 줍니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "10a6222d-f9cc-4d02-a4fa-a0956eb482e4",
        "_cell_guid": "a3d4b863-a399-4b88-9405-479de30079c5",
        "trusted": true,
        "id": "Qub6XLDbAvSA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.columns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "41ddde82-b3c0-4d20-8c8e-9474a8070214",
        "_cell_guid": "afc7ae4c-31c2-4e7d-9966-db51a619eeed",
        "trusted": true,
        "id": "piZOwaQfAvSC",
        "colab_type": "text"
      },
      "source": [
        "단순히 연습으로, 한 번 원하는 컬럼만 인덱싱해 보겠습니다.\n",
        "\n",
        "인덱싱에 대해 더 공부하고 싶으시다면 아래 링크를 클릭하여 공부해 보세요.\n",
        "\n",
        "[w3schools 넘파이 어레이 인덱싱](https://www.w3schools.com/python/numpy_array_indexing.asp)\n",
        "\n",
        "[Joshua CHoi님의 파이썬 인덱싱](https://joshua-mobile-choi-1756.trinket.io/python-3-4#/tasks/task-4-string-indexing)\n",
        "\n",
        "[Joshua Choi님의 파이썬 리스트 인덱싱](https://joshua-mobile-choi-1756.trinket.io/python-3-4#/tasks/task-15-list-methods)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "03254b34-2428-45c5-a320-890f9df0fa69",
        "_cell_guid": "38eb31be-01f6-428d-9d98-27b2b5835438",
        "trusted": true,
        "id": "2h4-PP_vAvSD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.columns[3], train.columns[3:5]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "ed9177a5-6875-42a2-a0d9-d1498d19d476",
        "_cell_guid": "9a4e74fe-dd61-4614-83dc-b0e285ba8bec",
        "trusted": true,
        "id": "pD_c_dzKAvSF",
        "colab_type": "text"
      },
      "source": [
        "한 행 뿐만 아니라 여러행을 인덱싱 할 수도 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "535d377f-8a9b-4302-bb1a-2a544e6db934",
        "_cell_guid": "6ae03c5a-3f26-4047-8cf7-87319b4223b3",
        "trusted": true,
        "id": "nbcoJcRzAvSF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train[5:20]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "c330ed40-7947-45da-9e5e-5684437ce20a",
        "_cell_guid": "fc99f4e9-531d-4cb6-a4fc-f7a2734cdacc",
        "trusted": true,
        "id": "xDQbS9vbAvSI",
        "colab_type": "text"
      },
      "source": [
        "`shape` 은 행의 갯수와 열의 갯수를 보여 줍니다"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "e03deb70-2b76-4d4a-be5c-224540ff73f1",
        "_cell_guid": "18014bf9-206c-48b1-90a8-0cfc8150a678",
        "trusted": true,
        "id": "FnsmJ54fAvSI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "a741544b-128c-4fad-a970-b092040c854b",
        "_cell_guid": "569312d1-2ac5-438a-8f8e-e11127718bba",
        "trusted": true,
        "id": "GY_mntuHAvSK",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part2\"></a>\n",
        "## Part 2:  파일 병합\n",
        "[Go to the Table of Contents](#table_of_contents)\n",
        "\n",
        "* ntrain과 ntest의 shape을 확보해놓습니다. (병합 한 것을 나중에 다시 갈라 놓기 위한 준비)\n",
        "* y_train은 알려진 결과 값이니 따로 모셔 놓고\n",
        "* 테스트의 승객 아이디는 나중에 최종 결과에 넣을 것이기 때문에 따로 떼어 놓습니다.\n",
        "* train과 test를 병합하여 data 란 파일을 만듭니다. 문자로 된 것을 숫자로 바꾼다든가. 숫자를 인터발 별로 그룹화 한다든가 할 때 한꺼번에 하기 위해 합해 놓습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "adb8e67a-fe20-4311-af34-98b323faa1df",
        "_cell_guid": "93fcaecf-0d18-43cd-a993-e8a185b3b6ef",
        "trusted": true,
        "id": "J1PrHzQ2AvSK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 병합 준비\n",
        "ntrain = train.shape[0]\n",
        "ntest = test.shape[0]\n",
        "\n",
        "# 아래는 따로 잘 모셔 둡니다.\n",
        "y_train = train['Survived'].values\n",
        "passId = test['PassengerId']\n",
        "\n",
        "# 병함 파일 만들기\n",
        "data = pd.concat((train, test))\n",
        "\n",
        "# 데이터 행과 열의 크기는\n",
        "print(\"data size is: {}\".format(data.shape))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "eabb0dc2-7d4d-43a0-9b43-1531307393dd",
        "_cell_guid": "65d983b0-a665-42de-8a94-b43e863fe7ce",
        "trusted": true,
        "id": "DRRl4h9uAvSN",
        "colab_type": "text"
      },
      "source": [
        "#### 파이썬의 프린트문과 포맷에 대해 보시려면 아래 링크를 클릭하세요.\n",
        "\n",
        "[프린트문](https://joshua-mobile-choi-1756.trinket.io/python-3-4#/tasks/task-1-print-statement)\n",
        "\n",
        "[포맷팅](https://joshua-mobile-choi-1756.trinket.io/python-3-4#/tasks/task-11-string-format)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "a77eb2ae-c0b1-4be0-98e9-0856275d5286",
        "_cell_guid": "83e4ba2f-5ef1-4cf5-a169-0f6ddcc7c080",
        "trusted": true,
        "id": "wOCX0u3vAvSO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train['Survived'].value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "3c1fcdf7-243a-4f43-a521-8e3b5394283b",
        "_cell_guid": "faf4fbe3-72de-4063-a425-e890300a963b",
        "trusted": true,
        "id": "CaUelAn2AvSP",
        "colab_type": "text"
      },
      "source": [
        "트레인 데이터에 있는 인원 중 342명이 살아남고 549명이 사망했다는 것을 볼 수 있습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "340691a1-c359-439d-af82-54ee29f401ea",
        "_cell_guid": "ca29c6d6-bcd2-4fe1-8fb1-c047cbc34340",
        "trusted": true,
        "id": "qg2JRVEqAvSQ",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part3\"></a>\n",
        "## Part 3: 파일 탐색\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "9656358f-d27a-4649-8d3e-8c5eac159c86",
        "_cell_guid": "9cc83a62-a9ff-441d-b74b-73a982f198db",
        "trusted": true,
        "id": "4psZ5gALAvSQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "missingno.matrix(data, figsize = (15,8))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "2443685a-5950-45c0-ae29-49c6a0b0e142",
        "_cell_guid": "4a4a6bcb-3676-46de-8abc-bc94fa6fd727",
        "trusted": true,
        "id": "m52BbJgtAvSS",
        "colab_type": "text"
      },
      "source": [
        "위 도표는 빈 값을 직관적으로 볼 수 있게 합니다.\n",
        "아래 쪽 `Survived`가 비어 있는데 이 것은 테스트에 우리가 답으로 예측해야 하는 부분이라서 그렇 습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ceffd7cf-90a7-4ec5-864b-2c6189ca68ba",
        "_cell_guid": "170f8c84-991e-49f9-aed2-a4b8086e1a00",
        "trusted": true,
        "id": "HVM3SSrDAvSS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data.isnull().sum() #비어 있는 값들을 체크해 본다."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ceec249b-43b0-4a03-a71c-8c221bcc7357",
        "_cell_guid": "09bc4fb4-8998-4a2c-98eb-53bb4ce4410a",
        "trusted": true,
        "id": "ZbEyON3dAvSU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data.Age.isnull().any()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "120b3ab9-6b3a-472f-acff-6add3671dc50",
        "_cell_guid": "25e9b995-7dbc-41ba-ad4f-390fa5c172bc",
        "trusted": true,
        "id": "ODSz5JtKAvSV",
        "colab_type": "text"
      },
      "source": [
        "열 이름을 보겠습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GbURBqyMAvSW",
        "colab_type": "text"
      },
      "source": [
        "[Kaggle 페이지에서 타이타닉 열 이름 보기 (해당 페이지 중간에 Dictionary 보시면 됨)](https://www.kaggle.com/c/titanic/data)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "9c914771-f064-4061-842c-6c6b275ece87",
        "_cell_guid": "295d8275-ae42-4a04-b85d-1374406ac7c2",
        "trusted": true,
        "id": "hSVgt41XAvSW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data.columns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "6e145614-83fe-48ee-8c52-6c3d0f2ef432",
        "_cell_guid": "3bc21f0e-36dc-4a69-a344-b9ea3c15a97e",
        "trusted": true,
        "id": "5eIQBqytAvSY",
        "colab_type": "text"
      },
      "source": [
        "### Features 항목\n",
        "\n",
        "#### 항목의 종류 \n",
        "\n",
        "* 범주형 항목 (Categorical Features)\n",
        "\n",
        "범주형 항목은 법주형 변수로 된 항목으로 범주형 변수는 둘 이상의 결과 요소가 있는 변수이며 해당 기능의 각 값을 범주별로 분류 할 수 있습니다. \n",
        "\n",
        "예를 들어 성별은 두 가지 범주 (남성과 여성)의 범주 형 변수입니다. \n",
        "\n",
        "이산형 변수(discrete variable) = 범주형 변수 (categorical variable) 의 하나로 명목 변수 norminal variable 라고도합니다.\n",
        "\n",
        "데이터 셋에서 명목 항목 : Sex, Embark 이며 우리는 Name, Ticket 등을 이로 변환해야 할 것 같습니다. \n",
        "\n",
        "\n",
        "* Ordinal Variable :\n",
        "\n",
        "순위 변수는 범주 형의 하나지만 그 차이점은 값 사이의 상대 순서(=서열) 또는 정렬이 가능하다는 것입니다.\n",
        "\n",
        "데이터 셋에서 순위 항목 : PClass 이며 우리는 Cabin을 이 범주로 변환해서 사용해야 할 것 같습니다.\n",
        "\n",
        "\n",
        "* 연속형 항목 (Continuous Features):\n",
        "\n",
        "서로 연속된 값을 가진 변수를 가진 항목이며 여기에서 우리는 연령을 대표적인 것으로 볼 수 있습니다.\n",
        "\n",
        "Age, SipSp, Parch, Fare는 interval variable로 만들어 이에 적용해야 할 것 같습니다.\n",
        "\n",
        " \n",
        "\n",
        "* 아래의 항목에서 열의 이름을 볼 수 있습니다.\n",
        "\n",
        "          Variable          정의                Key\n",
        "\n",
        "          survival          생존 여부            0 = No, 1 = Yes\n",
        "\n",
        "          pclass            선실 등급            1 = 1st, 2 = 2nd, 3 = 3rd\n",
        "\n",
        "          sex               성별    \n",
        "\n",
        "          Age               나이  \n",
        "\n",
        "          sibsp             형재 자매의 수/ 배우자 등이 승선한 경우 수    \n",
        "\n",
        "          parch             부모나 자식과 같이 탄 경우 수   \n",
        "\n",
        "          ticket            표 번호    \n",
        "\n",
        "          fare              요금\n",
        "\n",
        "          cabin             선실 번호   \n",
        "\n",
        "          embarked          승선한 항구         C = Cherbourg, Q = Queenstown, S = Southampton"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "f0e353aa-3dd6-4dfa-b4bb-04f9e7d92e79",
        "_cell_guid": "2d30d895-4f7e-40d5-9b96-85ecd585427e",
        "trusted": true,
        "id": "ADvsXKNKAvSY",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part4\"></a>\n",
        "## Part 4: 데이터 탐구 (Exploratory Data Analysis)\n",
        "[Go to the Table of Contents](#table_of_contents)\n",
        "\n",
        "* train파일 순서대로 데이터 파일의 열들을 봅니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "6eee58df-6d1c-435b-8dc5-e972ca5db9d3",
        "_cell_guid": "ca41bc92-ba31-432b-adc3-5527029eee5e",
        "trusted": true,
        "id": "-dnWjibqAvSY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "af2979e7-3337-4d46-b5dd-fd9c4f55c3c6",
        "_cell_guid": "3ce1a484-b75d-46ef-9bc0-39f92679feca",
        "trusted": true,
        "id": "dW0S3L47AvSa",
        "colab_type": "text"
      },
      "source": [
        "* 파일 각 열의 상관 관계를 보겠습니다.\n",
        "\n",
        "Co-relation 매트릭스는 seaborn에서 변수 간 상관 계수를 보여주는 표입니다. 표의 각 셀은 두 변수 간의 상관 관계를 보여줍니다. 상관 매트릭스는 고급 분석에 대한 입력 및 고급 분석에 대한 진단으로 데이터를 요약하는 데 사용됩니다. \n",
        "\n",
        "참고: https://seaborn.pydata.org/examples/many_pairwise_correlations.html\n",
        "\n",
        "아래 마스크 셋업은 0로 행렬을 상관 행렬과 같은 모양으로 만든 후 여기에 불리안 값을 넣고 이를 다시 True만 만듭니다.\n",
        "\n",
        "triu 는 우측 상단 삼각행렬을 의미\n",
        "\n",
        "annot= True는 각 셀에 숫자를 표시하라는 것이고, False는 하지 말라는 것이구요\n",
        "\n",
        "이어서 이를 heatmap으로 런칭합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "17c43d5e-1116-4b7c-9950-c57ebc6cb4f8",
        "_cell_guid": "453f962b-7055-4e85-851e-13471585c730",
        "trusted": true,
        "id": "yF6EHX5MAvSa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Co-relation 매트릭스\n",
        "corr = data.corr()\n",
        "# 마스크 셋업\n",
        "mask = np.zeros_like(corr, dtype=np.bool)\n",
        "mask[np.triu_indices_from(mask)] = True\n",
        "# 그래프 셋업\n",
        "plt.figure(figsize=(14, 8))\n",
        "# 그래프 타이틀\n",
        "plt.title('Overall Correlation of Titanic Features', fontsize=18)\n",
        "#  Co-relation 매트릭스 런칭\n",
        "sns.heatmap(corr, mask=mask, annot=False,cmap='RdYlGn', linewidths=0.2, annot_kws={'size':20})\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BhfH2ndIAvSc",
        "colab_type": "text"
      },
      "source": [
        "* [히트맵](https://seaborn.pydata.org/generated/seaborn.heatmap.html) \n",
        "\n",
        "* [판다스 코릴레이션 매트릭스](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.corr.html)  \n",
        "\n",
        "* [씨본 콜릴레이션 히트맵](https://seaborn.pydata.org/generated/seaborn.heatmap.html)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "ad786681-e22c-47a1-ad44-595a851a9fe7",
        "_cell_guid": "07d228e4-09bf-4fb6-8578-fb074eb85c14",
        "trusted": true,
        "id": "ERcSxfSoAvSd",
        "colab_type": "text"
      },
      "source": [
        "* \"Surived\" 분석\n",
        "\n",
        "한 열씩 검토해 보겠습니다.\n",
        "\n",
        "Survived - Key: (0 - Not Survived, 1- Survived)\n",
        "\n",
        "Survived는 숫자로 값을 주지만 Categorical Variable인 셈입니다.\n",
        "\n",
        "죽던지 살던지 둘 중 하나의 값을 줍니다.\n",
        "\n",
        "countplot을 그려 봅니다.\n",
        "\n",
        "사이즈는 가로 10인치 세로 2인치\n",
        "\n",
        "생존 여부 0과 1의 숫자를 세어 본 후 그림을 그리도록 명령을 하는 것입니다.\n",
        "\n",
        "pyplot(plt)의 figure라는 메소드를 써서 그림판의 크기를 정하고, seaborn의 카운트플롯을 그리라는 것입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7b85358c-8c5e-4f21-8f27-51742e41c3d7",
        "_cell_guid": "5d6acdeb-0f70-4eb4-83e9-6edc2d090ea4",
        "trusted": true,
        "id": "Lofs_MgZAvSd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "fig = plt.figure(figsize=(10,2))\n",
        "sns.countplot(y='Survived', data=train)\n",
        "print(train.Survived.value_counts())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "62c7307e-7eae-4151-9f8f-cfb72099bd4e",
        "_cell_guid": "803f9f29-ef4a-41fc-b5a8-4c9018a48ab3",
        "trusted": true,
        "id": "AFNQLkhPAvSg",
        "colab_type": "text"
      },
      "source": [
        "* 불행히도 사망자가 훨씬 많아 보입니다.\n",
        "* 전체 사망자 비율을 좀 보겠습니다.\n",
        "\n",
        "* 파이그래프랑 카운트 플롯을 서브플롯으로 그립니다.\n",
        "* 행은 하나 열은 2개의 서브 플롯입니다. 사이즈는 가로 15인치 세로 6인치\n",
        "* 'Survived'의 값을 카운트해서 파이플롯을 만듭니다.\n",
        "* explode는 폭발하는 것이니까 1이면 튀어 나가는 것인데 0을 주면 분리만 되고 돌출은 되지 않습니다. 이어서 0, 1인 것은 첫 번째 것은 아니고 두번 째 것은 분리된다는 의미로 생각하시면 됩니다.\n",
        "* autopercent는 1.1이 표현하는 부분은 소수점 한 자리까지 보여 주라는 의미입니다. 뒤에 점 이하가 4면 둘 다 소수점 4자리수 까지 보여 줍니다.\n",
        "* ax[0]은 첫번째 칸입니다.\n",
        "* set_title 메소드는 서브 플롯의 제목을 보여 줍니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "d8dd280a-a4ad-4fbe-8da2-059f1f85da32",
        "_cell_guid": "e43702a5-c0ac-4069-ac81-66cbb1eca357",
        "trusted": true,
        "id": "XWdsNIl_AvSg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f,ax=plt.subplots(1, 2, figsize=(15, 6))\n",
        "train['Survived'].value_counts().plot.pie(explode=[0, 0.1], autopct='%1.1f%%', ax=ax[0], shadow=True)\n",
        "ax[0].set_title('Survived')\n",
        "ax[0].set_ylabel('')\n",
        "sns.countplot('Survived',data=train, ax=ax[1])\n",
        "ax[1].set_title('Survived')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "527cd761-99ad-47f0-a5f1-c762ddf4efd9",
        "_cell_guid": "c3d82061-84e0-48ae-895d-60724c3ec4cf",
        "trusted": true,
        "id": "gKa3RM1pAvSi",
        "colab_type": "text"
      },
      "source": [
        "* 위의 것을 아래와 같이 함수로 만들겠습니다. (물론 자주 쓰이지는 않겠지만 연습이니)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "939748c6-4779-4fca-8967-2854b8aff92a",
        "_cell_guid": "0799d199-78ad-4023-b4ac-de73851d210d",
        "trusted": true,
        "id": "eSE3StuPAvSi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def piecount(col):\n",
        "    f, ax = plt.subplots(1, 2, figsize=(15, 6))\n",
        "    train[col].value_counts().plot.pie(explode=[0.1 for i in range(train[col].nunique())], autopct='%1.1f%%', ax=ax[0], shadow=True)\n",
        "    ax[0].set_title(col)\n",
        "    ax[0].set_ylabel('')\n",
        "    sns.countplot(col, data=train, ax=ax[1])\n",
        "    ax[1].set_title(col)\n",
        "    plt.show()\n",
        "\n",
        "piecount('Survived')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "82403fa4-2a1c-48ce-a4d7-d2e4b8956e88",
        "_cell_guid": "3c7977e4-79c3-4f1f-b7c0-2e2acb1a2539",
        "trusted": true,
        "id": "bCzyVpKoAvSk",
        "colab_type": "text"
      },
      "source": [
        "[함수 만들기 공부](https://trinket.io/joshua-mobile-choi-1756/courses/python-3-4#/tasks/task-20-making-functions)\n",
        "\n",
        "[파라미터와 아규먼트 공부](https://trinket.io/joshua-mobile-choi-1756/courses/python-3-4#/tasks/task-21-parameters-and-arguments)\n",
        "\n",
        "* \"Pclass\" 분석\n",
        "\n",
        "* Pclass는 값이 숫자이나 서열이 정해진 Ordinal Feature이다.\n",
        "* Key:1 = 1st, 2= 2nd, 3 = 3rd\n",
        "* 각 클래스 당 생존자를 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "fefd849e-e520-48ee-9d89-e35815ac5358",
        "_cell_guid": "37fe1541-abe6-4efe-a576-8f68a7f26bfb",
        "trusted": true,
        "id": "HiJABpKXAvSk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train.groupby(['Pclass','Survived'])['Survived'].count()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "238a5bdf-ba10-474a-89d0-6d2fd1e0a080",
        "_cell_guid": "cfbb127a-c3f0-411c-8837-8cb56f44e17a",
        "trusted": true,
        "id": "CLPhO6cZAvSm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pd.crosstab(train.Pclass, train.Survived, margins=True).style.background_gradient(cmap='summer_r')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "9ba4d87c-1850-4a48-b206-e9f7fd00930a",
        "_cell_guid": "197337d9-efcb-4fb9-be10-2b1e7192e2fd",
        "trusted": true,
        "id": "nwAA_B4gAvSn",
        "colab_type": "text"
      },
      "source": [
        "* 1등급 객실의 사람들은 생존자가 더 많고, 2등급은 생존자에 비해 사망자가 조금 더 많으나, 3등급은 사망자가 3배 이상 많다는 것을 알 수 있습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "2cfe69da-2162-48c3-aaa1-d8978fe40671",
        "_cell_guid": "0a93e775-fcdb-443f-918b-38b11656315c",
        "trusted": true,
        "id": "zG27TcWmAvSo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f, ax = plt.subplots(1, 2, figsize=(12, 6))\n",
        "train[['Pclass','Survived']].groupby(['Pclass']).mean().plot.bar(ax=ax[0])\n",
        "ax[0].set_title('Survived per Pcalss')\n",
        "sns.countplot('Pclass', hue='Survived', data=train, ax=ax[1])\n",
        "ax[1].set_title('Pcalss Survived vs Not Survived')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "a1918545-9422-431b-9d23-fff4e50d59bc",
        "_cell_guid": "b915feeb-e3f4-4a31-8f98-618524c8bc48",
        "trusted": true,
        "id": "-q8rTDc4AvSq",
        "colab_type": "text"
      },
      "source": [
        "* 위에 만든 함수를 한 번 써 먹어 볼까요?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "9b727747-bde7-4979-8b62-05422d89824a",
        "_cell_guid": "bb996a29-f0d9-413f-a14b-b19e0094dff2",
        "trusted": true,
        "id": "T6zmrP3rAvSq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "piecount(\"Pclass\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "85454bdf-94f9-4a91-a9f8-c3511a92775d",
        "_cell_guid": "2e50d31f-10f3-49ae-a73e-fef8a35196c0",
        "trusted": true,
        "id": "K8pEpXIkAvSs",
        "colab_type": "text"
      },
      "source": [
        "* %는 3등칸이 반이 넘으나 위의 그래프에서 생존자는 1등석이 가장 많다는 것을 알 수 있습니다.\n",
        "* 각 클래스 당 생존률을 볼까요?"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "89b69e13-c646-4407-8f84-4e9470564871",
        "_cell_guid": "4839234f-a34d-45bf-9ac3-4c7206758db7",
        "trusted": true,
        "id": "o54m4bBmAvSs",
        "colab_type": "text"
      },
      "source": [
        "### \"Name\" 분석\n",
        "* 이름은 거의 모두 다를 가능성이 큽니다. Family Name, First Name, Middle Name and even Dr. Capt, master and so on 모두 감안하면...\n",
        "* 분류를 한 번 해 봅니다.\n",
        "* 리스트를 한 번 주 욱 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8026a512-ed18-444b-acb4-538e6aeaecb0",
        "_cell_guid": "f1e363f7-be14-45d8-9410-a7291062dd3c",
        "trusted": true,
        "id": "JUvDdaAsAvSs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data.Name.value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "f43c393a-10af-4658-bd77-5f59664d7570",
        "_cell_guid": "1b7cec22-26b3-4e18-bec3-841c05b07e38",
        "trusted": true,
        "id": "aN4yWhXzAvSu",
        "colab_type": "text"
      },
      "source": [
        "* 이름은 언뜻 보아서 감이 안 옵니다. 중간에 있는 Mr. 같은 호칭을 볼까요.\n",
        "* ['Initial']이란 열을 새로 만들어서 여기에 Name에서 추출한 Regular Expression을 넣습니다.\n",
        "* 아래에서 str.extract('([A-Za-z]+).')부분은 str에서 대문자 A~Z, 소문자 a~z 중에 . 명령을 통해 .으로 끝나는 부분을 추출해 내는 것입니다.\n",
        "* ('^([A-Za-z]+)')으로 하면 처음에 나오는 문자 덩어리가 될 것이고 +를 빼면 첫 스펠링 한캐릭터만 추출합니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "5c2ebef4-b3dd-4139-8301-8618498ecea0",
        "_cell_guid": "0b5d2d04-ebee-440f-a8ce-a6d1204aefb6",
        "trusted": true,
        "id": "SFWzLddIAvSv",
        "colab_type": "text"
      },
      "source": [
        "[Regex 공부](https://en.wikipedia.org/wiki/Regular_expression)\n",
        "\n",
        "* 안전을 위해 카피를 하나 만들어서 새로운 항목을 만들어 봅니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "30e3faab-3fff-460c-9df8-58f48308814e",
        "_cell_guid": "df5bf168-af51-4deb-b31c-9a673a4ec2f6",
        "trusted": true,
        "id": "Bf4JnfD2AvSv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp = data.copy()\n",
        "temp['Initial'] = 0\n",
        "temp['Initial'] = data.Name.str.extract('([A-Za-z]+)\\.')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "a3b3c87d-6765-4857-b240-d8950c4f36bc",
        "_cell_guid": "931d2869-d126-4b5b-8f69-5ee2765db3de",
        "trusted": true,
        "id": "acNWrOxjAvSx",
        "colab_type": "text"
      },
      "source": [
        "Miss나 Mr등은 많으나 익숙하지 않은 몇 개가 보입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "204c8706-e0f5-485d-a037-9cff51f0a2b7",
        "_cell_guid": "1ac42aae-e788-4281-b6f4-f3710691cfc2",
        "trusted": true,
        "id": "7yc77imTAvSx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Initial'].value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "ce9ad0ae-aee4-4d7f-a385-2c9185b658ae",
        "_cell_guid": "8aaf851a-9e59-4048-882f-bbd475ec1241",
        "trusted": true,
        "id": "vuii-Q7GAvSy",
        "colab_type": "text"
      },
      "source": [
        "이를 성별로 봅니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "9d69ee9c-5f38-4960-9616-2c16bfd8ca36",
        "_cell_guid": "f80086dc-4794-437b-8fe1-f31135d89727",
        "trusted": true,
        "id": "rhW81fbpAvSz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pd.crosstab(temp.Initial, temp.Sex).T.style.background_gradient(cmap='summer_r')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "00e551bc-1214-4b6f-8888-41bc134889d7",
        "_cell_guid": "933fbe79-7cab-46e3-88ab-a528ee70f106",
        "trusted": true,
        "id": "ZCT4cg0eAvS1",
        "colab_type": "text"
      },
      "source": [
        "* 생존률로 봅니다.\n",
        "\n",
        "* 생존율 함수를 만들어 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "d8259a6c-c8ee-4d20-856f-03247e504a79",
        "_cell_guid": "a404adcb-d60b-41a9-8464-b7c882deb422",
        "trusted": true,
        "id": "MBwZMyTkAvS2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def survpct(col):\n",
        "    return temp.groupby(col)['Survived'].mean()\n",
        "\n",
        "survpct('Initial')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "22c75b4a-253b-445e-b62b-41a03ea700d2",
        "_cell_guid": "b84da566-3184-4fb1-beff-57ce991211ae",
        "trusted": true,
        "id": "nRsZHrd4AvS3",
        "colab_type": "text"
      },
      "source": [
        "* 생존 숫자로 봅니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "e8e63164-ed93-452f-9558-bd3836705d1c",
        "_cell_guid": "22cce559-ce03-4366-9fa6-bd382ad2ce76",
        "trusted": true,
        "id": "XTvyM6LEAvS4",
        "colab_type": "text"
      },
      "source": [
        "* test 에 있는 Dona의 나이를 보고 어디에 넣을지 보겠습니다.\n",
        "* Ms. 는 현대처럼 Miss + Mrs를 합친 말이 아니라 당시에는 귀족미망인을 의미하는 것이 었습니다. Mlle나 Mme등도 마드모아젤과 마담의 줄인말일 경우일 것입니다. 귀족 여성들로 보아야겠죠."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "1b2cf729-b09a-4b32-bbd6-2179cbe6f94c",
        "_cell_guid": "452ebd19-a964-4355-8fa8-5022d48f3bba",
        "trusted": true,
        "id": "KJtSuSQtAvS4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['LastName'] = data.Name.str.extract('([A-Za-z]+)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "0b40c788-6402-4e3a-94d6-00b30d8974f7",
        "_cell_guid": "ba820da9-970a-4491-82e3-05c41b5044cf",
        "trusted": true,
        "id": "ZK-F1lVbAvS6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pd.crosstab(temp.LastName, temp.Survived).T.style.background_gradient(cmap='summer_r')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "63ddd4d5-5e59-4e2e-a444-20572bfd40e9",
        "_cell_guid": "40418fb8-2d98-4c23-8e90-2b70ac5d7fae",
        "trusted": true,
        "id": "bUn-yfAbAvS9",
        "colab_type": "text"
      },
      "source": [
        "* 이제 우리는 Initial에서 Mr.등의 호칭을 뽑아내었고, 성을 뽑아내었습니다.\n",
        "\n",
        "* 머신이 알파벳보다는 숫자를 좋아 하므로 숫자로 바꿉니다.\n",
        "\n",
        "* 아, 그러기 전에 Dona를 처리해야지요."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8a7e1f4c-85ff-49bb-b98c-935df3b9bd48",
        "_cell_guid": "31537000-1762-45ab-b28b-db7916c13aef",
        "trusted": true,
        "id": "5JD0kUbAAvS-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[temp['Initial'] == 'Dona']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "e0c193b5-21f0-41d3-a994-92d64b42cac7",
        "_cell_guid": "dea4d6d9-1a83-4830-a329-f1e12e3b15fc",
        "trusted": true,
        "id": "mKyH6kvEAvTB",
        "colab_type": "text"
      },
      "source": [
        "* 나이로 추측해서 Mrs.로 넣습니다.\n",
        "* 결측치를 처리하는 방법은 많으나 이렇게 하나일 경우에는 가장 적절한 추측을 사용하여 넣는 것도 괜찮습니다.\n",
        "\n",
        "locate method 학습 : https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.loc.html\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "35ab1856-8c99-4137-93c9-78cc291a6b95",
        "_cell_guid": "46b3cbee-a71b-487a-a254-0e3ed47be45e",
        "trusted": true,
        "id": "BpYSSosTAvTB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[temp['Initial'] == 'Dona', 'Initial'] = 'Mrs'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "b4728053-76db-4847-8a6c-4cd2d3064907",
        "_cell_guid": "5fae2b2d-9c14-4753-8947-55dbd02c5b67",
        "trusted": true,
        "id": "LwDrO0XFAvTD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pd.crosstab(temp.Initial, temp.Survived).T.style.background_gradient(cmap='summer_r')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "078c2d73-22d0-4aea-bf84-b11e847605df",
        "_cell_guid": "b1f677fb-c134-4f13-b68c-d22beffc030c",
        "trusted": true,
        "id": "QYMIAjAVAvTF",
        "colab_type": "text"
      },
      "source": [
        "* Last name 은 전부 숫자로 바꿉니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "25f9f773-ba17-4822-b11f-c2996a6910f1",
        "_cell_guid": "e4646a3d-103d-4607-a2ae-6696898cfd68",
        "trusted": true,
        "id": "LIJDPj0GAvTG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['NumName'] = temp['LastName'].factorize()[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "d187b4d0-c4b0-42df-b2ad-cfad173cd039",
        "_cell_guid": "ed54c7b7-8ee0-4fad-ab7c-401d41213605",
        "trusted": true,
        "id": "OB4hBqU_AvTI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pd.crosstab(temp.NumName, temp.Survived).T.style.background_gradient(cmap='summer_r')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "4ffe4974-a354-4021-a0d4-98182705155c",
        "_cell_guid": "49395b59-07d8-40d8-bbf4-eb9461636fe3",
        "trusted": true,
        "id": "FN404JpcAvTJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[temp['LastName'] == 'Ali']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "1a50bae0-1fa4-41c5-9b1c-0b1976e71c1a",
        "_cell_guid": "a8c4cbc1-b744-425d-b242-e389703163fd",
        "trusted": true,
        "id": "mPDo8yz_AvTL",
        "colab_type": "text"
      },
      "source": [
        "* 보시다시피 같은 Last name에 같은 번호가 쓰여졌다.\n",
        "\n",
        "* 끝에 [0]은 라벨만 보고 번호를 붙이는 것으로 정말 unique한 것이란 것은 안 본다는 것입니다.\n",
        " \n",
        "* 자 이제 이름을 의미하는 중요한 요소 두 개를 숫자로 바꾸었으니 다음으로 갑니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "9757c406-7798-457d-a848-8c2376fa5678",
        "_cell_guid": "21de76dd-37ec-43d4-8c91-960da6c21d39",
        "trusted": true,
        "id": "hon_ZLAYAvTL",
        "colab_type": "text"
      },
      "source": [
        "### \"Sex\" 분석\n",
        "\n",
        "* 함수를 만들어서 train파일을 보지요"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "21d5faa6-5695-4666-9992-a80d33ef91e4",
        "_cell_guid": "df923a37-cdec-461e-9a24-735fedb3e842",
        "trusted": true,
        "id": "BGxHsoCwAvTL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train[['Sex','Survived']].groupby(['Sex']).mean()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "04d6567a-af7f-4d43-8495-22c7f9e0da02",
        "_cell_guid": "1cf63c13-7e71-4ddb-abcf-627361176a17",
        "trusted": true,
        "id": "MhOC5tM0AvTN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def bag(col, target, title, title1):\n",
        "    f,ax=plt.subplots(1,2,figsize=(12,5))\n",
        "    train.groupby([col])[target].mean().plot(kind='bar', ax=ax[0])\n",
        "    ax[0].set_title(title)\n",
        "    sns.countplot(col, hue=target, data=train, ax=ax[1])\n",
        "    ax[1].set_title(title1)\n",
        "    plt.show()\n",
        "\n",
        "bag('Sex','Survived','Survived per Sex','Sex Survived vs Not Survived')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "9ac79116-51d2-4e06-9b3f-26e23e1e4fd3",
        "_cell_guid": "32ccf057-9ad3-4fe5-ae97-b0143c25d74e",
        "trusted": true,
        "id": "092ZF5JaAvTP",
        "colab_type": "text"
      },
      "source": [
        "* 배에 있던 남자의 수는 여자의 수보다 훨씬 많습니다. 여전히 생존 여성 수는 남성 수의 거의 두 배입니다. 선박 여성의 생존율은 약 75 % 인 반면 남성의 생존율은 약 18-19 %입니다.\n",
        " \n",
        "* 이 것은 남성/여성을 1,2로 나누면 될 것 같은 뻔해 보이는 것이지만 좀 더 새분화하면 좋아 보입니다.\n",
        "* 예를 들어 아기들은 아기이지, 남자인지 여자인지 구명보트 태울 때 안 물어 볼 것이기 때문입니다.\n",
        "* 오히려 (불행하게도) 귀족 아기인지 서민의 아기인지는 행과불행을 가를 수 있습니다 ㅠㅠ\n",
        "* 생존 Pclass별로 성별을 봅니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "296ea041-dbe2-46bb-9c4e-9523b710125b",
        "_cell_guid": "e25e1b75-d30b-4d94-abd6-d02b3600dc34",
        "trusted": true,
        "id": "WnCk7OK7AvTP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pd.crosstab([train.Sex, train.Survived],train.Pclass,margins=True).style.background_gradient(cmap='summer_r')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "a1d635b0-91c1-4cfd-a8f0-4aa04c435d0a",
        "_cell_guid": "bdd361dc-a8a5-41da-91d3-729ca04be1b2",
        "trusted": true,
        "id": "TjAJQPXhAvTQ",
        "colab_type": "text"
      },
      "source": [
        "* 사회는 불공평 했으나 최소한 남자들의 신사도는 있었다고 할 수 있을 것 같습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "423109e5-9fff-4ebf-b7fc-7c3b80698ec3",
        "_cell_guid": "9e8eae27-a146-443b-a89b-c6193eaa4a03",
        "trusted": true,
        "id": "zyYZNgftAvTR",
        "colab_type": "text"
      },
      "source": [
        "### Age 분석\n",
        " \n",
        "* Age는 Continuous한 값입니다.\n",
        "* 빈칸이 많아서 빈칸처리가 결정적인 역할을 할 것 같습니다.\n",
        " \n",
        "* Age의 최대, 최소, 중간을 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "c2da72d5-d54e-4a63-8512-dbfed27c7d22",
        "_cell_guid": "ac9d5424-a182-4b07-b2b8-a57c3a86a58c",
        "trusted": true,
        "id": "_Gspg28qAvTR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('Oldest Passenger was', data['Age'].max(), 'Years')\n",
        "print('Youngest Passenger was', data['Age'].min(), 'Years')\n",
        "print('Average Age on the ship was', int(data['Age'].mean()), 'Years')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "98eef7f6-f0e5-4442-9520-c6ee2c33cfc3",
        "_cell_guid": "aa6a1e82-c35e-40eb-9517-1d6c05ed3cbb",
        "trusted": true,
        "id": "G2ByrkwEAvTU",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sns.swarmplot(x=train['Survived'], y=train['Age'])\n",
        "plt.xlabel(\"Survived\")\n",
        "plt.ylabel(\"Age\")\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ae19ee02-ab6a-4102-be05-9bb7e0cb3d13",
        "_cell_guid": "6dd61e02-c076-4a7c-8c6f-bf78094e48ce",
        "trusted": true,
        "id": "YquEV7PpAvTX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f, ax = plt.subplots(1,2,figsize=(18,8))\n",
        "sns.violinplot(\"Pclass\", \"Age\", hue=\"Survived\", data=train, split=True, ax=ax[0])\n",
        "ax[0].set_title('Pclass and Age vs Survived')\n",
        "ax[0].set_yticks(range(0, 110, 10))\n",
        "sns.violinplot(\"Sex\",\"Age\", hue=\"Survived\", data=train, split=True, ax=ax[1])\n",
        "ax[1].set_title('Sex and Age vs Survived')\n",
        "ax[1].set_yticks(range(0, 110, 10))\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "6aa4c6ba-79b8-4d4c-b7ea-1c0798ca5390",
        "_cell_guid": "dc2a0457-19d7-44ae-96fb-f4dcef047315",
        "trusted": true,
        "id": "dhtnASEvAvTY",
        "colab_type": "text"
      },
      "source": [
        "#### 관찰 :\n",
        "\n",
        "1) Pclass에 따라 어린이 수가 증가하고 10 세 미만의 어린이 (즉, 어린이)의 생존율은 Pclass에 상관없이 양호해 보입니다.\n",
        "\n",
        "2) Pclass1에서 20-50세의 Passeneger의 생존 가능성은 높고 여성에게는 더 좋습니다.\n",
        "\n",
        "3) 남성의 경우 생존 확률은 나이가 증가함에 따라 감소합니다.\n",
        "\n",
        "\n",
        "우선 age의 빈칸 부터 해결 합니다.\n",
        "\n",
        "앞에서 살펴본 것처럼 Age 항목에는 177 null 값이 있습니다. 이러한 NaN 값을 대체하기 위해 데이터 집합의 평균 수명을 지정할 수 있습니다.\n",
        "\n",
        "그러나 문제는 평균 연령이 29 세를 4세 아이에게 할당 할 수 없습니다. 승객이 어떤 연령대에 있는지 알 수있는 방법이 있을까요? 이름에서 힌트를 찾아 봅니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "dcf34518-7919-4296-85cf-6237db62dce7",
        "_cell_guid": "22688323-cf2f-4be5-aac2-d5b353597138",
        "trusted": true,
        "id": "H0nNPm0TAvTY",
        "colab_type": "text"
      },
      "source": [
        "* 그리고 Initial 별 평균 연령을 보고 Age에 적용 시키는 것이 좋을 것 같습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "0988b695-cac3-4fea-aadd-1f2052eb5102",
        "_cell_guid": "1c39f89e-a757-4386-84ab-7c4e62b0c02a",
        "trusted": true,
        "id": "NysIAy9zAvTa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.groupby('Initial').agg({'Age': ['mean', 'count']}) #이니셜 별 평균 연령 체크"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "6a486a66-50bb-424f-81b8-82cdc8fb601d",
        "_cell_guid": "30e3a2ea-e4df-41f1-9966-436fca3a009d",
        "trusted": true,
        "id": "_9s0T_kEAvTb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 이니셜 별 평균 연령을 빈값에 넣어 봅니다.\n",
        "\n",
        "temp = temp.reset_index(drop=True)\n",
        "\n",
        "temp['Age'] = temp.groupby('Initial')['Age'].apply(lambda x: x.fillna(x.mean()))\n",
        "\n",
        "temp[31:50]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "5ce6f75b-68c1-4f54-8e92-fda20e19d8d5",
        "_cell_guid": "3bb1dd02-838b-49ff-aafa-b57672ecae27",
        "trusted": true,
        "id": "cCOennBPAvTd",
        "colab_type": "text"
      },
      "source": [
        "[람다함수 공부](https://trinket.io/joshua-mobile-choi-1756/courses/python-3-4#/tasks/task-34-lambda)\n",
        "\n",
        "[람다함수 메소드](https://trinket.io/joshua-mobile-choi-1756/courses/python-3-4#/tasks/task-35-lambda-and-functions)\n",
        "\n",
        "* 이제 Initial을 좀 정리합니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "2ed5b220-554d-4c22-bcc6-8ab64126f9ae",
        "_cell_guid": "31cb3428-1bb6-464f-9683-65ccbe606bbd",
        "trusted": true,
        "id": "mYo85Mv6AvTd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Initial'].replace(['Capt', 'Col', 'Countess', 'Don', 'Dona' , 'Dr', 'Jonkheer', 'Lady', 'Major', 'Master',  'Miss'  ,'Mlle', 'Mme', 'Mr', 'Mrs', 'Ms', 'Rev', 'Sir'], ['Sacrificed', 'Respected', 'Nobles', 'Mr', 'Mrs', 'Respected', 'Mr', 'Nobles', 'Respected', 'Kids', 'Miss', 'Nobles', 'Nobles', 'Mr', 'Mrs', 'Nobles', 'Sacrificed', 'Nobles'],inplace=True)\n",
        "temp['Initial'].replace(['Kids', 'Miss', 'Mr', 'Mrs', 'Nobles', 'Respected', 'Sacrificed'], [4, 4, 2, 5, 6, 3, 1], inplace=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "b827866e-bfe0-4943-b8a9-aa89daca8922",
        "_cell_guid": "58906b29-e863-4716-9d67-f0c366039011",
        "trusted": true,
        "id": "-WDGaYLsAvTf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Age_Range'] = pd.qcut(temp['Age'], 10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "52ebf6bc-6616-4091-ace9-f25e63870c5c",
        "_cell_guid": "b7d52e31-6ddc-46ec-a649-20b21e56d0b1",
        "trusted": true,
        "id": "NHhhfEoMAvTg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Age_Range')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "5b076db6-72d2-4f35-9d26-ad0a24490716",
        "_cell_guid": "c75bf35e-2e6b-4ae8-b170-2f5c28589553",
        "trusted": true,
        "id": "Em0eLCS7AvTi",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Agroup'] = 0\n",
        "\n",
        "temp.loc[temp['Age'] < 1.0, 'Agroup'] = 1\n",
        "temp.loc[(temp['Age'] >=1.0) & (temp['Age'] <= 3.0), 'Agroup'] = 2\n",
        "temp.loc[(temp['Age'] > 3.0) & (temp['Age'] < 11.0), 'Agroup'] = 7\n",
        "temp.loc[(temp['Age'] >= 11.0) & (temp['Age'] < 15.0), 'Agroup'] = 13\n",
        "temp.loc[(temp['Age'] >= 15.0) & (temp['Age'] < 18.0), 'Agroup'] = 16\n",
        "temp.loc[(temp['Age'] >= 18.0) & (temp['Age'] <=  20.0), 'Agroup'] = 18\n",
        "temp.loc[(temp['Age'] > 20.0) & (temp['Age'] <= 22.0), 'Agroup'] = 21\n",
        "temp.loc[(temp['Age'] > 22.0) & (temp['Age'] <= 26.0), 'Agroup'] = 24\n",
        "temp.loc[(temp['Age'] > 26.0) & (temp['Age'] <= 30.0), 'Agroup'] = 28\n",
        "temp.loc[(temp['Age'] > 30.0) & (temp['Age'] <= 32.0), 'Agroup'] = 31\n",
        "temp.loc[(temp['Age'] > 32.0) & (temp['Age'] <= 34.0), 'Agroup'] = 33\n",
        "temp.loc[(temp['Age'] > 34.0) & (temp['Age'] <= 38.0), 'Agroup'] = 36\n",
        "temp.loc[(temp['Age'] > 38.0) & (temp['Age'] <= 52.0), 'Agroup'] = 45\n",
        "temp.loc[(temp['Age'] > 52.0) & (temp['Age'] <= 75.0), 'Agroup'] = 60\n",
        "temp.loc[temp['Age'] > 75.0, 'Agroup'] = 78"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "438c81fe-ea33-4ee1-bfcb-1bee60dc3e83",
        "_cell_guid": "a03e08b9-0ee4-43ee-872a-e63bc3f8365d",
        "trusted": true,
        "id": "oylN2-tsAvTk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "e74cb51e-36a1-4b6f-8fe2-3e18a6549f2b",
        "_cell_guid": "5f1e6a24-3e1c-411e-a942-069c30f02377",
        "trusted": true,
        "id": "9UYkSVZDAvTl",
        "colab_type": "text"
      },
      "source": [
        "* Age는 그룹화 시키면 좋으나 학습을 위해서 그냥 놓아두고, 그룹화 연습은 Fare로 하겠습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "bc2615b8-1a8b-473d-b678-44764e8ec883",
        "_cell_guid": "2470540a-fd24-4436-9926-a9bf88ccfc6c",
        "trusted": true,
        "id": "K72H9lh4AvTm",
        "colab_type": "text"
      },
      "source": [
        "* 위를 보고 sex를 남,녀, 1세 이하 Baby로 나누겠습니다. 1,2,3번을 주지오"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "c2ce8ccc-5ce2-4df3-8ded-f87a185b5835",
        "_cell_guid": "b64ba88c-7966-4bfe-b18d-c3af0fece14f",
        "trusted": true,
        "id": "IXXK6LvpAvTm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[(temp['Sex'] == 'male'), 'Sex'] = 1\n",
        "temp.loc[(temp['Sex'] == 'female'), 'Sex'] = 2\n",
        "temp.loc[(temp['Age'] < 1), 'Sex'] = 3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "b8e68001-363c-4e8f-94f5-497384114bd5",
        "_cell_guid": "b254444e-4d21-40a0-bcf2-85e7512502ce",
        "trusted": true,
        "id": "qYujV1-HAvTn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Sex')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "fc261012-1216-4db4-a2ab-b6d9c97b7c71",
        "_cell_guid": "2d231138-b2dd-4558-aaaa-edc5a6372693",
        "trusted": true,
        "id": "v0izbrxkAvTp",
        "colab_type": "text"
      },
      "source": [
        "#### Family or Alone?\n",
        "* \"SibSp\" + \"Parch\" 분석\n",
        " \n",
        "* SibSp - 이 항목은 탑승자가 혼자인지 또는 가족과 함께 있는지를 나타냅니다.\n",
        "* *Sibling = 형제, 자매, 의붓 형제, 이복 누이\n",
        " \n",
        "* Spouse = 남편, 아내\n",
        " \n",
        "* Parch는 부모와 함께 탔는지를 봅니다.\n",
        " \n",
        "* 이 그룹 둘을 'Alone\"그룹과 \"Family'그룹으로 나눕니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ff935eef-8613-47f2-b5cb-c6911c10872a",
        "_cell_guid": "bb86b124-b9c2-461d-863c-884d10cb6b3a",
        "trusted": true,
        "id": "3k_f4JfeAvTp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[(temp['SibSp'] == 0) & (temp['Parch'] == 0), 'Alone'] = 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8b3054a9-3a16-4a53-b602-b899c5344310",
        "_cell_guid": "877c4f03-0c25-4a94-a49c-5142594e18e6",
        "trusted": true,
        "id": "xDg265tYAvTq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Family'] = temp['Parch'] + temp['SibSp'] + 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "c1504a08-b9bc-4798-9adf-88161affe77a",
        "_cell_guid": "7d34c69c-cf60-49e9-a705-095e328f97d0",
        "trusted": true,
        "id": "YCQKFE2vAvTs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.head(n=10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8246a524-eaea-43ee-88a9-7c6a166b5c6c",
        "_cell_guid": "833f64b6-7c9f-4ec5-8e3d-408035e6fd8c",
        "trusted": true,
        "id": "ew4_vcUTAvTt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Family')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "46ce8507-337a-4224-b06f-9289651ec9af",
        "_cell_guid": "f8f12057-1bf3-4065-981e-af398fba7186",
        "trusted": true,
        "id": "dhDjkvcQAvTu",
        "colab_type": "text"
      },
      "source": [
        "* 크로스 탭은 다시 식구 많은 쪽은 Pclass3에 있음을 보여줍니다.\n",
        " \n",
        "* 여기에서도 결과는 매우 비슷합니다. 부모와 함께 탑승 한 승객은 생존 가능성이 더 높습니다. 그러나 숫자가 올라 갈수록 줄어 듭니다.\n",
        " \n",
        "* 생존 가능성은 배에 1-3 명의 부모가있는 누군가에게 좋습니다. 혼자 또한 생존 가능성이 낮은 것으로 판명되고 가족이 4 명이상 있으면 생존 가능성이 줄어 듭니다. 이는 소수의 가족들이 있는 귀족층이 생존하고, 혼자가 많은 젊은 이들은 양보를 할 수 밖에 없고, 가족이 많은 사람들(특히 귀족이 아닌 3등칸 사람들)은 전원이 타지 못 하면 어느 누구도 탈 수가 없는 비극적인 당시 상황을 보여 줍니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "d29f0dbe-6bda-4a4f-bf34-775f81afbfd3",
        "_cell_guid": "e930efc7-4af3-459c-877e-3c66b6547e00",
        "trusted": true,
        "id": "eESw0DXCAvTu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "bag('Parch', 'Survived', 'Survived per Parch', 'Parch Survived vs Not Survived')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "13c3b0b4-a911-4ced-a661-e235d2e8a327",
        "_cell_guid": "4b9f1eda-da5f-47f2-858d-12e4c00b5d00",
        "trusted": true,
        "id": "PAI4hZDlAvTv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pd.crosstab([temp.Family, temp.Survived], temp.Pclass, margins=True).style.background_gradient(cmap='summer_r')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "9547b87e-ec3b-4e11-bc2c-02ddc266e718",
        "_cell_guid": "a794a5b6-396e-400e-8d90-065950bbd046",
        "trusted": true,
        "id": "X21amBBvAvTx",
        "colab_type": "text"
      },
      "source": [
        "#### \"Ticket\"분석\n",
        "* Ticket의 형태를 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "5c4ba566-9d9a-4122-b7ff-d99ea2dcd1e1",
        "_cell_guid": "9cd6dc91-0a63-44b4-a51e-ff8591ba24d3",
        "trusted": true,
        "id": "v4IPrrS9AvTy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.Ticket.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "92fe3125-f32e-4ed3-81d9-2a08d9034bfd",
        "_cell_guid": "ab771375-0caa-4ecb-b54b-6e213e7eadd8",
        "trusted": true,
        "id": "plE8w211AvTz",
        "colab_type": "text"
      },
      "source": [
        "* 도무지 감이 안 잡히는 배열입니다.\n",
        "* 빈칸이 없는지 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "bf8f8d56-2c29-4495-a0d4-292efe536324",
        "_cell_guid": "32a97988-1afc-4cc7-b40b-ded636c13062",
        "trusted": true,
        "id": "8eiVF1R6AvTz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.Ticket.isnull().any()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "eca75170-1327-41a3-9041-f493e69ac8c1",
        "_cell_guid": "c189f4d5-6d75-4f88-ab82-6e3de2d195cd",
        "trusted": true,
        "id": "O9U4d3iZAvT0",
        "colab_type": "text"
      },
      "source": [
        "* 티켓에서 영문있는 것과 숫자만 있는 것을 따봅니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "28b7b708-22ba-410b-8f6d-bf00a70904b7",
        "_cell_guid": "987531b3-64ac-4d08-a9df-938f76509eb6",
        "trusted": true,
        "id": "TLHqsCCiAvT0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Initick'] = temp.Ticket.str.extract('^([A-Za-z0-9]+)')\n",
        "\n",
        "temp = temp.reset_index(drop=True)  # 복사한 항목들을 사용하다보면 'ValueError: cannot reindex from a duplicate axis` 요런 에러가 나오는 경우가 많은데 이런 것은 요 코드로 리셋을 한 번 해주면 됩니다.\n",
        "\n",
        "temp.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "0283c6c8-8b8d-4888-8f29-6e5ed5191328",
        "_cell_guid": "705b27bc-a931-4a48-8d14-6c97f11ae486",
        "trusted": true,
        "id": "h7t3wLN3AvT2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Initick'] = temp.Ticket.str.extract('^([A-Za-z]+)')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "c406b61d-de3e-4a2b-ace1-b1154d500bcc",
        "_cell_guid": "26fd138e-3c4a-4a27-b1db-1c2605328073",
        "trusted": true,
        "id": "pADhtYUPAvT3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "f76465d8-85dd-411e-aa46-0a8b2bdcf704",
        "_cell_guid": "e7cbfd9c-b14d-4f56-a9d8-6b0cf75a9fb2",
        "trusted": true,
        "id": "kJvh9S2YAvT4",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['NumTicket'] = temp['Initick'].factorize()[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "aeb93e90-7cfb-4895-a7ce-daa5287578b3",
        "_cell_guid": "9730221b-95e4-4648-8aa1-15906c1626b0",
        "trusted": true,
        "id": "pq0eOBwtAvT5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.head(n=15)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "e51ce8a4-3e80-4095-a4d3-fff0d8acde43",
        "_cell_guid": "4d2ff538-638d-4d82-b266-2558c6c8fd1e",
        "trusted": true,
        "id": "duq7Bfp5AvT6",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.groupby('NumTicket')['Survived'].mean().to_frame().plot(kind='hist')\n",
        "plt.title('Distribution of survival rate for different tickets');"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "ec185cd2-4f49-426e-808b-340fb278ae8e",
        "_cell_guid": "3460fa6c-1cf0-40d1-a052-2413b0b1544a",
        "trusted": true,
        "id": "_OwwRoYoAvT7",
        "colab_type": "text"
      },
      "source": [
        "### \"Fare\" 분석"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "3de56e45-9b97-434d-b6ea-e57c82ec542d",
        "_cell_guid": "90ebbc04-47b2-4ea5-9321-18cdfd13691d",
        "trusted": true,
        "id": "IxzuxhT0AvT8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('Highest Fare was:', temp['Fare'].max())\n",
        "print('Lowest Fare was:', temp['Fare'].min())\n",
        "print('Average Fare was:', temp['Fare'].mean())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "608e0c28-12b8-4f2b-96e6-c644fef3a708",
        "_cell_guid": "672eb7e9-0aa1-4020-95c2-81a2005134f8",
        "trusted": true,
        "id": "xnXT7a5BAvT9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f,ax=plt.subplots(1, 3, figsize=(20, 6))\n",
        "sns.distplot(train[train['Pclass'] == 1].Fare,ax=ax[0])\n",
        "ax[0].set_title('Fares in Pclass 1')\n",
        "sns.distplot(train[train['Pclass'] == 2].Fare,ax=ax[1])\n",
        "ax[1].set_title('Fares in Pclass 2')\n",
        "sns.distplot(train[train['Pclass'] == 3].Fare,ax=ax[2])\n",
        "ax[2].set_title('Fares in Pclass 3')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "9e341c0b-4b21-4fc0-8cbb-e93a5a0c90ca",
        "_cell_guid": "31509983-22a4-4dcc-80e7-52bc4b8acbd5",
        "trusted": true,
        "id": "kgyv-tLHAvT_",
        "colab_type": "text"
      },
      "source": [
        "* Pclass1의 승객 요금에는 큰 분포가있는 것으로 보이며 불연속 값으로 변환 할 수 있습니다.\n",
        "* Fare를 그룹으로 나누어 놓겠습니다.\n",
        "* qcut을 활용하면 원하는 조각으로 데이터를 나누어 줍니다.\n",
        "* cut와 qcut의 차이"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "70e7561c-e567-43e8-a991-3c9ebe02be68",
        "_cell_guid": "2bd363ed-781a-4f78-a787-a3e6f69a0f73",
        "trusted": true,
        "id": "SCDjNk-BAvUA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def groupmean(a,b):\n",
        "    return temp.groupby([a])[b].mean().to_frame().style.background_gradient(cmap='summer_r')\n",
        "\n",
        "temp['Fare_Range'] = pd.qcut(train['Fare'], 10)\n",
        "groupmean('Fare_Range', 'Fare')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "ed52cd71-a5e8-4b66-b876-97891eb0c90c",
        "_cell_guid": "844c0486-90c6-4c05-bd03-c409d0f60b7a",
        "trusted": true,
        "id": "puZzd5qEAvUB",
        "colab_type": "text"
      },
      "source": [
        "* Fare를 그룹화 시킵니다. Fgroup이라고 이름 짓겠습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "0d3aba7e-6ec3-4246-96d1-9b0fdd1c997d",
        "_cell_guid": "1adba71f-faae-48eb-a44e-f538d28ab29c",
        "trusted": true,
        "id": "Q0SVhnDUAvUB",
        "colab_type": "text"
      },
      "source": [
        "0 and below -> 0\n",
        "\n",
        "7.125 and below-> 5.0\n",
        "\n",
        "7.9 and below-> 7.5\n",
        "\n",
        "8.03 or less-> 8.0\n",
        "\n",
        "Less than 10.5-> 9.5\n",
        "\n",
        "Less than 23-> 16.0\n",
        "\n",
        "27.8 and below-> 25.5\n",
        "\n",
        "51 and below-> 38\n",
        "\n",
        "73.5 and below-> 62\n",
        "\n",
        "Over 73.5-> 100"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "38bb04f8-d5d8-4122-932f-8ba3d59aa641",
        "_cell_guid": "2e048fef-9daf-4ee0-b143-86abc260c70d",
        "trusted": true,
        "id": "G_GdnTSaAvUC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Fgroup'] = 0\n",
        "\n",
        "temp.loc[temp['Fare'] <= 0,'Fgroup'] = 0\n",
        "temp.loc[(temp['Fare'] > 0) & (temp['Fare'] <= 7.125), 'Fgroup'] = 1\n",
        "temp.loc[(temp['Fare'] > 7.125) & (temp['Fare'] <= 7.9), 'Fgroup'] = 2\n",
        "temp.loc[(temp['Fare'] > 7.9) & (temp['Fare'] <= 8.03), 'Fgroup'] = 3\n",
        "temp.loc[(temp['Fare'] > 8.03) & (temp['Fare'] < 10.5), 'Fgroup'] = 4\n",
        "temp.loc[(temp['Fare'] >= 10.5) & (temp['Fare'] < 23.0), 'Fgroup'] = 5\n",
        "temp.loc[(temp['Fare'] >= 23.0) & (temp['Fare'] <= 27.8), 'Fgroup'] = 6\n",
        "temp.loc[(temp['Fare'] > 27.8) & (temp['Fare'] <= 51.0), 'Fgroup'] = 7\n",
        "temp.loc[(temp['Fare'] > 51.0) & (temp['Fare'] <= 73.5), 'Fgroup'] = 8\n",
        "temp.loc[temp['Fare'] > 73.5, 'Fgroup'] = 9\n",
        "\n",
        "temp.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "93c0408c-da95-4f60-b3c0-87f11165871b",
        "_cell_guid": "f4cd9f73-f4a1-4ef7-b27f-0dab64b77173",
        "trusted": true,
        "id": "6PxpIJufAvUD",
        "colab_type": "text"
      },
      "source": [
        "### \"Cabin\" 분석\n",
        "* cabin 의 위치에 따라 달라지는 것이 있는지 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "31f59458-29a4-4d28-a3bd-64066db9cef6",
        "_cell_guid": "7876f062-6171-4f99-9b8c-6620729fe9ae",
        "trusted": true,
        "id": "hlma-uMuAvUE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.Cabin.value_counts().head(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "568d22f5-b17d-45f8-9ded-a91e699b6250",
        "_cell_guid": "bd1f9174-dd14-4ff9-b6a7-5b7f9af43cbb",
        "trusted": true,
        "id": "ExXj0BA2AvUF",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.Cabin.isnull().sum()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "ae4d26e2-9eaf-4d1d-93f6-664ed6b88ce8",
        "_cell_guid": "3b7bd0f7-3aa0-482e-8dd1-145c179bf451",
        "trusted": true,
        "id": "5eMkVYc_AvUG",
        "colab_type": "text"
      },
      "source": [
        "* 빈칸이 무척 많습니다.\n",
        "* Cabin에 비어 있는 것이 많아 이를 다른 분류로 일단 잡고 기존 것은 이니셜로 분류합니다.\n",
        "* 빈 것은 X로 구분하려는데 이 또한 1,2,3 Pclass와 연동될 것 같으니 비어있고 1등급은 X, 2등급은 Y, 3등급은 Z로 하겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "65839b79-4882-4e78-8517-04aef7161b50",
        "_cell_guid": "3c060915-887c-453d-b94d-32bd4dc02b2d",
        "trusted": true,
        "id": "c8BP2zAQAvUG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Inicab'] = 0\n",
        "temp['Inicab'] = temp['Cabin'].str.extract('^([A-Za-z]+)')\n",
        "temp.loc[((temp['Cabin'].isnull()) & (temp['Pclass'].values == 1)), 'Inicab'] = 'X'\n",
        "temp.loc[((temp['Cabin'].isnull()) & (temp['Pclass'].values == 2)), 'Inicab'] = 'Y'\n",
        "temp.loc[((temp['Cabin'].isnull()) & (temp['Pclass'].values == 3)), 'Inicab'] = 'Z'\n",
        "    \n",
        "temp.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "c0335f54-adc4-4658-9833-78cb4e3bc09a",
        "_cell_guid": "1fb288ae-a5eb-47e5-85bb-1805dc38c8e5",
        "trusted": true,
        "id": "2ICDt9oSAvUH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Inicab'] = temp['Inicab'].factorize()[0]\n",
        "    \n",
        "temp[11:20]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "fbbdc087-0b29-4d91-a10d-7a1bc62ca77a",
        "_cell_guid": "d6cd23f3-4cdc-49e9-96ff-bd3bf08ce8df",
        "trusted": true,
        "id": "Z-D5ehgcAvUI",
        "colab_type": "text"
      },
      "source": [
        "#### \"Embarked\" 분석"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "3e30c0be-e793-46e4-b39b-444643d4225c",
        "_cell_guid": "bed0ec32-2e38-40f6-abd8-e8a582c856f2",
        "trusted": true,
        "id": "wMD4PEefAvUI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "pd.crosstab([temp.Embarked, temp.Pclass], [temp.Sex, temp.Survived], margins=True).style.background_gradient(cmap='summer_r')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "671bfd96-6f37-4274-88ad-f254384fa710",
        "_cell_guid": "e5f9105a-eb35-45a7-ad31-e95070e0453b",
        "trusted": true,
        "id": "tT9WNzc4AvUJ",
        "colab_type": "text"
      },
      "source": [
        "* 승선 장소 별로 생존 확률"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "617d466c-a9f0-49ae-a481-2f88b7f2de4a",
        "_cell_guid": "c8182f1e-2776-40ed-8126-fce085b4a065",
        "trusted": true,
        "id": "gFtJ3bvIAvUJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sns.factorplot('Embarked', 'Survived', data=temp)\n",
        "fig = plt.gcf()\n",
        "fig.set_size_inches(5, 3)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "91fbe751-ec0e-46a4-b0d8-6e57ded51e26",
        "_cell_guid": "f9bbfcf8-c26d-4103-b0f0-a353ed447728",
        "trusted": true,
        "id": "O5wS3jDGAvUK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "f,ax=plt.subplots(2,2,figsize=(20,15))\n",
        "sns.countplot('Embarked', data=temp, ax=ax[0,0])\n",
        "ax[0,0].set_title('No. Of Passengers Boarded')\n",
        "sns.countplot('Embarked', hue='Sex', data=temp, ax=ax[0,1])\n",
        "ax[0,1].set_title('Male-Female Split for Embarked')\n",
        "sns.countplot('Embarked', hue='Survived', data=temp, ax=ax[1,0])\n",
        "ax[1,0].set_title('Embarked vs Survived')\n",
        "sns.countplot('Embarked', hue='Pclass', data=temp, ax=ax[1,1])\n",
        "ax[1,1].set_title('Embarked vs Pclass')\n",
        "plt.subplots_adjust(wspace=0.2,hspace=0.5)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "402fd5fa-f7e2-40c8-b7e0-be1a8d8badf3",
        "_cell_guid": "79e69f2b-fea4-4469-8b71-39f1a50465e2",
        "trusted": true,
        "id": "fVSGv5m2AvUM",
        "colab_type": "text"
      },
      "source": [
        "1) 포트 C의 생존 가능성은 0.55 정도이며 S는 가장 낮습니다.S에서 탑승 최대. 대다수는 Pclass3\n",
        "\n",
        "2) C의 승객들은 많은 비율이 살아남았습니다. 그 이유는 Pclass1 및 Pclass2 승객이 많아서 일 것입니다\n",
        "\n",
        "3) Embark S는 대부분의 부자들이 탑승한 항구지만 생존 가능성은 낮습니다. Pclass3의 승객도 많았습니다.\n",
        "\n",
        "4) 포트 Q는 승객의 거의 95 %가 Pclass3\n",
        "\n",
        "* 빈칸이 두개 있는데 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "66000cee-bbc2-4ae4-afc4-c458d4acb524",
        "_cell_guid": "54758510-f46f-43d2-9d86-7333898b2b78",
        "trusted": true,
        "id": "IqyyaBHVAvUM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[(temp.Embarked.isnull())]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "882be0d7-db74-41e5-ada5-fe5ac99fc8d2",
        "_cell_guid": "651291f9-c95e-4a02-ac27-423578036a21",
        "trusted": true,
        "id": "MzefzidvAvUN",
        "colab_type": "text"
      },
      "source": [
        "* 두 사람의 티켓 번호가 같습니다.\n",
        "* 혹시 같은 티켓 번호가 있는 다른 사람이 있는지 봅니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "5ecf71db-c7d2-488a-8974-14aa98cdc15e",
        "_cell_guid": "1a232cec-4a47-414a-9330-9a07d3800c5a",
        "trusted": true,
        "id": "fmKteurmAvUN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[(temp.Ticket == '113572')]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "dc44f6c1-3d55-44a7-b737-c7ef0f326a2a",
        "_cell_guid": "6efda1cb-c9e0-4207-bedf-37fcd5f73023",
        "trusted": true,
        "id": "NoAKRIMFAvUO",
        "colab_type": "text"
      },
      "source": [
        "* 가장 비슷한 번호를 찾아 보겠습니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ed4649cc-c687-4e2c-b772-325b26f1000c",
        "_cell_guid": "ce2d7a5a-baef-41ef-89bf-72f97f0d52b7",
        "trusted": true,
        "id": "mkz_QUVJAvUO",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.sort_values(['Ticket'], ascending = True)[55:70]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "d47cf81c-c67a-418f-89ef-96d15ea9c304",
        "_cell_guid": "c9ba7c28-9db5-4468-861d-98d359594106",
        "trusted": true,
        "id": "Nmqy9YnnAvUS",
        "colab_type": "text"
      },
      "source": [
        "* 앞 뒤로 모두 S이고 Pclass도 모두 1인 것으로 봐서 S일 가능성이 큽니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "2984cd7a-05b4-4c0a-a90e-b4a49f981efc",
        "_cell_guid": "c0e735cf-0af8-4c37-badd-5078c1707449",
        "trusted": true,
        "id": "KSRTYNN7AvUS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[(temp.Embarked.isnull()), 'Embarked'] = 'S'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "d23d8117-4b3b-4ca7-bae6-d78d9a02c043",
        "_cell_guid": "08ca976d-f6da-411f-8730-86e945ee390b",
        "trusted": true,
        "id": "H2duzCyzAvUT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.loc[(temp.Embarked.isnull())]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "1ca320e9-f7a3-4f75-a29c-d8f31701bea3",
        "_cell_guid": "6fd9bcd1-4866-4433-a627-b9f6470dbcc7",
        "trusted": true,
        "id": "HeRPI1eaAvUV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Embarked'] = temp['Embarked'].factorize()[0]\n",
        "    \n",
        "temp[11:20]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "cf842aea-68f7-42db-961d-0590c9050ba5",
        "_cell_guid": "23ba0cc2-3129-459b-9a9f-433856437014",
        "trusted": true,
        "id": "-zT6fL9DAvUW",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part5\"></a>\n",
        "## Part 5: Feature Engineering\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "5dbb1593-0410-4e67-974b-606bbac1f623",
        "_cell_guid": "f27eab5c-5837-48ce-a978-9efc940000d3",
        "trusted": true,
        "id": "0n1bOSrKAvUX",
        "colab_type": "text"
      },
      "source": [
        "* 문자를 숫자로 바꾸는 것도 Feature Engineering의 일부이나 위에서 대부분 다 했습니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "96e63e09-b7a4-49bb-9038-28a961571c2b",
        "_cell_guid": "ec72f754-c006-401e-8e7f-9defc790cca8",
        "trusted": true,
        "id": "THtw258IAvUX",
        "colab_type": "text"
      },
      "source": [
        "### 항목 추가하기\n",
        "\n",
        "* 위에 추가 항목을 몇 개 만들어 보았습니다.\n",
        "\n",
        "* 그래도 몇 개 더 만들어 볼까요? \n",
        "\n",
        "* 5개 정도 만들어 봅니다.\n",
        "\n",
        "* Priority - Nobles, Women in Pclass 1 & 2, Babies under 1, Kids under 17 in Pclass 1 & 2, higher fare, Women in Pclass 3 and so on\n",
        "* FH - Female Higher Survival Group\n",
        "* MH - Male Higher Survival Group\n",
        "* FL - Female Lower Surival Group\n",
        "* ML - Male Lower Survival Group"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "fd9948f1-5890-4a47-bf98-2415cdeb615a",
        "_cell_guid": "9406a15b-1123-4862-84b6-ae7f3a0d1954",
        "trusted": true,
        "id": "ZR7-asUaAvUX",
        "colab_type": "text"
      },
      "source": [
        "* Priority - (1) Nobles (2) Women in Pclass 1  (3) Babies under 1 (4) Kids under 17 in Pclass 1 & 2  (5) Women in Pclass 2 (6) Higher Fare"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "60073a7b-b909-4910-a55e-f3496374f2d3",
        "_cell_guid": "f44b5b0d-192e-4c91-b890-d788afa1330e",
        "trusted": true,
        "id": "5RZWj4Z4AvUX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Initial')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "b8ce3fd2-34c6-4659-aed7-538ca103c864",
        "_cell_guid": "75c2f66b-0ff3-4b1f-837f-351d43358eab",
        "trusted": true,
        "id": "Pq7g7vvMAvUZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Pclass')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "02b69ad4-11f1-4053-85bb-aa4d1e2b3aa8",
        "_cell_guid": "0fc661c2-3553-45a2-a6ee-e4b5ea95bce4",
        "trusted": true,
        "id": "a24XMbQ5AvUZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Sex')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "786c3f87-d87c-47b1-9378-2429ca626209",
        "_cell_guid": "4d85436e-1240-4c7d-af05-3db27fe435df",
        "trusted": true,
        "id": "pnMG6W8SAvUa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Age').head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "feb308d1-cd8f-497f-a115-e5dda29f3a2f",
        "_cell_guid": "08b6d35c-e3bf-480e-a5c8-00f563439b04",
        "trusted": true,
        "id": "4kvnAyhQAvUb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Fgroup')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "e3b8462d-5aeb-4a13-8178-768c7304c206",
        "_cell_guid": "fcbf76eb-cf90-4d1f-80d7-4e6b38ba5c71",
        "trusted": true,
        "id": "rlkcrED0AvUc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['Priority'] = 0\n",
        "temp.loc[(temp['Initial'] == 6), 'Priority'] = 1\n",
        "temp.loc[(temp['Pclass'] == 1) & (temp['Sex'] == 2), 'Priority'] = 2\n",
        "temp.loc[(temp['Age'] < 1), 'Priority'] = 3\n",
        "temp.loc[(temp['Pclass'] == 1) & (temp['Age'] <= 17), 'Priority'] = 4\n",
        "temp.loc[(temp['Pclass'] == 2) & (temp['Age'] <= 17), 'Priority'] = 5\n",
        "temp.loc[(temp['Pclass'] == 2) & (temp['Sex'] == 2), 'Priority'] = 6\n",
        "temp.loc[(temp['Fgroup'] == 9), 'Priority'] = 7"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "97a5c7e8-3115-41d3-96ad-d4b9ce076f62",
        "_cell_guid": "25364dce-44b4-46ad-8fd4-400afde84754",
        "trusted": true,
        "id": "O9Egd2iYAvUd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Priority')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "6a458b2b-6557-4395-bad1-0e8e8c731191",
        "_cell_guid": "de659e44-d0f1-47cd-b4da-91e9c8c00733",
        "trusted": true,
        "id": "tcCN7TcxAvUe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.Priority.value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "efc3f5b9-f6eb-4f6f-a927-3f7b6dd9624e",
        "_cell_guid": "478dd0e6-0d34-4894-b812-d15606753a3d",
        "trusted": true,
        "id": "okJllG6yAvUf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Family')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "bf84231c-a6d1-4188-9b0c-8b817d7a8028",
        "_cell_guid": "fc48f127-ffd5-4ab0-972b-ffcec4817149",
        "trusted": true,
        "id": "8aEzZc8dAvUg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('Fgroup')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "5858dc7e-3a34-42f6-a06c-17d51e6d4619",
        "_cell_guid": "1f0f127f-127b-4118-a73b-0e751c96bf73",
        "trusted": true,
        "id": "HBxbClKPAvUh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['FH'] = 0\n",
        "temp.loc[(temp['Sex'] == 1), 'FH'] = 0\n",
        "temp.loc[(temp['Sex'] == 2), 'FH'] = 1\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Family'] == 2), 'FH'] = 2\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Family'] == 3), 'FH'] = 3\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Family'] == 4), 'FH'] = 4\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Family'] == 1) & (temp['Pclass'] == 1), 'FH'] = 5\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Family'] == 1) & (temp['Pclass'] == 2), 'FH'] = 6\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Fgroup'] == 3), 'FH'] = 7\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Fgroup'] >= 5), 'FH'] = 8"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "3457e9e0-5ef5-416f-9bb9-9ee35311d117",
        "_cell_guid": "f653d595-ad7e-4a32-9e11-4f04533beeb4",
        "trusted": true,
        "id": "yGfnHnYfAvUj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('FH')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "9ced7423-5407-4f0f-abd3-8abf148d2e4d",
        "_cell_guid": "9371af95-6218-4240-9af2-2aa22a5d6057",
        "trusted": true,
        "id": "kNSTGutPAvUl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.FH.value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "b17124d0-ff2b-4c1b-b6c5-edc5b8539675",
        "_cell_guid": "d2414d1d-3b28-4372-aa68-5bfbe799983b",
        "trusted": true,
        "id": "wd37iW4GAvUm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['MH'] = 0\n",
        "temp.loc[(temp['Sex'] == 2), 'MH'] = 0\n",
        "temp.loc[(temp['Sex'] == 1), 'MH'] = 1\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Family'] == 2), 'MH'] = 2\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Family'] == 3), 'MH'] = 3\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Family'] == 4), 'MH'] = 4\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Family'] == 1) & (temp['Pclass'] == 1), 'MH'] = 5\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Family'] == 1) & (temp['Pclass'] == 2), 'MH'] = 6\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Fgroup'] == 3), 'MH'] = 7\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Fgroup'] >= 5), 'MH'] = 8"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "1b98fcca-0eff-482f-8371-ee212859f00f",
        "_cell_guid": "ce9a73c3-f712-45f1-a4dd-4de77e076bad",
        "trusted": true,
        "id": "RRjSGq-bAvUn",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('MH')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "35122a72-0421-448b-9683-cd8a24a75f28",
        "_cell_guid": "ee99abf8-8c26-4bfd-9f54-141d22089147",
        "trusted": true,
        "id": "gm9oJiPAAvUo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.MH.value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8957ad7a-1177-4a12-bf01-a2609b80286c",
        "_cell_guid": "f948eef5-2ce1-4f71-9cc1-4dbb42d841d5",
        "trusted": true,
        "id": "AyAYWeddAvUp",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['FL'] = 0\n",
        "temp.loc[(temp['Sex'] == 1), 'FL'] = 0\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Fgroup'] < 5), 'FL'] = 1\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Fgroup'] != 3), 'FL'] = 2\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['FH'] == 1), 'FL'] = 3\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Family'] < 2), 'FL'] = 4\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Family'] > 4), 'FL'] = 5\n",
        "temp.loc[(temp['Sex'] == 2) & (temp['Family'] == 1) & (temp['Pclass'] == 3), 'FL'] = 6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "450d734d-954d-4485-a62a-ea2b2acaa844",
        "_cell_guid": "5008783d-7bf5-4c55-8667-f43142527516",
        "trusted": true,
        "id": "NlkBDdmFAvUq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('FL')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "668a230d-a378-43da-af0f-ae58bbf504d5",
        "_cell_guid": "606d2f08-8d89-467e-a86d-315143e733b0",
        "trusted": true,
        "id": "MDlQ3g-oAvUr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.FL.value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "f4298a55-0bcb-4996-b385-551b76f63d18",
        "_cell_guid": "649c3afd-8628-456d-a54a-b4a5d8afebcd",
        "trusted": true,
        "id": "g2e9AdhzAvUs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['ML'] = 0\n",
        "temp.loc[(temp['Sex'] == 2), 'ML'] = 0\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Fgroup'] < 5), 'ML'] = 1\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Fgroup'] != 3), 'ML'] = 2\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['MH'] <7), 'ML'] = 3\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Family'] < 2), 'ML'] = 4\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Family'] > 4), 'ML'] = 5\n",
        "temp.loc[(temp['Sex'] == 1) & (temp['Family'] == 1) & (temp['Pclass'] == 3), 'ML'] = 6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "0ea99a54-1dd8-4f1e-9e96-ca83587b9aef",
        "_cell_guid": "7163bb08-952a-47dd-a045-b1a9ef7ede4f",
        "trusted": true,
        "id": "SLOENFwdAvUt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "survpct('ML')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7e57e563-ac41-46c0-aca7-f3ebcfd4a556",
        "_cell_guid": "33f12c42-d824-4e06-8f50-b2cee7058fb3",
        "trusted": true,
        "id": "xWrXmTdeAvUt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp.ML.value_counts()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "f1ddfc52-a03d-456c-b80e-29098be88ea1",
        "_cell_guid": "f53969c5-1fed-4f43-8a7a-4d46bd102c54",
        "trusted": true,
        "id": "MTxwjNRFAvUv",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part6\"></a>\n",
        "## Part 6: 마지막 항목 결정\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "04f42339-a9d5-4270-ab87-3d5046c560fd",
        "_cell_guid": "6b4806d6-dbc3-42cd-a973-4968e33cb734",
        "trusted": true,
        "id": "FdbSrORjAvUw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "temp['F1'] = temp['Priority']\n",
        "temp['F2'] = temp['FH']\n",
        "temp['F3'] = temp['MH']\n",
        "temp['F4'] = temp['FL']\n",
        "temp['F5'] = temp['ML']\n",
        "temp['F6'] = temp['Initial']\n",
        "temp['F7'] = temp['Fgroup']\n",
        "temp['F8'] = temp['NumName']\n",
        "temp['F9'] = temp['NumTicket']\n",
        "temp['F10'] = temp['Family']\n",
        "temp['F11'] = temp['Embarked']\n",
        "temp['F12'] = temp['Sex']\n",
        "temp['F13'] = temp['Pclass']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "82a2412b-9456-4538-a4d1-08322351d138",
        "_cell_guid": "2e152000-400d-4641-bf1f-d6988754f40c",
        "trusted": true,
        "id": "dgSjqbS4AvUw",
        "colab_type": "text"
      },
      "source": [
        "* 이제 다음 단계로 갑니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "1afffe24-f9dd-4d40-937a-3db261f1e96e",
        "_cell_guid": "6780a753-bea4-432e-acb0-1acf21fdafc1",
        "trusted": true,
        "id": "mwTI-LM1AvUw",
        "colab_type": "text"
      },
      "source": [
        "* 두개의 새로운 데이터 프레임을 만듭니다. 하나는 레이블 인코딩 다른 하나는 원핫 인코딩 (둘이 꼭 필요한 것이 아니라 연습이나 두 가지 방 법 모두 사용해봄)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "7175e152-24ae-4ba5-91d0-00ce744279c4",
        "_cell_guid": "6587f585-2f99-45f8-b69f-6c0b4807d203",
        "trusted": true,
        "id": "h8SvPzsBAvUx",
        "colab_type": "text"
      },
      "source": [
        "* 대표적인 인코딩에 Label Encoding이 있는데 이는 각 항목의 값을 서열화 시켜 주~욱 줄세운 것이라 생각하시면 됩니다.\n",
        "* 그 외에 자주쓰는 One Hot Encoding 같은 경우 열 내에서의 항목을 나누어서 (열이 주~욱 늘어나며) 이를 0이냐 1이냐로 구분해 놓은 것입니다."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "857409cf-8797-4445-9a9f-bc9e2b0ea524",
        "_cell_guid": "62840184-3ee6-462e-8e53-d5e875e5b47a",
        "trusted": true,
        "id": "wkuzsFs5AvUx",
        "colab_type": "text"
      },
      "source": [
        "* 다시 말씀 드려서 레이블 인코딩은 줄을 세워서 번호를 부여하는 것이고, 원핫인코딩은 긴가 아닌가 두 가지입니다.\n",
        "\n",
        "* 예를들어 나이별로 줄을 세워 너는 5번, 너는 6번이런식이 레이블 인코딩이고\n",
        "\n",
        "* 16살이야? 1, 16살 아냐 0 ..그 다음 17살이야? 1 17살 아냐 0 ..이런 식이라 열의 수가 무지하게 늘어납니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "2f8632b6-ad01-42ed-8305-e4a16c639859",
        "_cell_guid": "f9f8d5ba-446d-47c8-a132-47ed24ed3d4f",
        "trusted": true,
        "id": "mVkx7DIbAvUx",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.preprocessing import OneHotEncoder, LabelEncoder"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "3926847e-0139-4722-8d6f-5ede74634e60",
        "_cell_guid": "5d288c4a-459d-4db6-a035-11f86558fbdd",
        "trusted": true,
        "id": "lk23cRgoAvUy",
        "colab_type": "text"
      },
      "source": [
        "새로운 Data Frame을 만듭니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "b4b726eb-f1e4-465c-a006-04a859c40bf4",
        "_cell_guid": "129fed72-8341-4f69-9cfd-0ebcd7a537c8",
        "trusted": true,
        "id": "ylKEcaGuAvUy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dfl = pd.DataFrame() # for label encoding"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7581a210-d1e8-4c57-bd16-09be6c2e2e9e",
        "_cell_guid": "aaddbce4-53b2-450a-997f-1399f54e9296",
        "trusted": true,
        "id": "XEDCLdmsAvU0",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "good_columns = ['F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10', 'F11', 'F12', 'F13']\n",
        "dfl[good_columns] = temp[good_columns]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7bd54b47-b6cc-41c1-94fd-482191b8600d",
        "_cell_guid": "79e5c5ee-3ff7-4b3e-a289-29e3c02517b3",
        "trusted": true,
        "id": "py9yCyD9AvU1",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dfl.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "8f651980-4f94-4bb4-9255-8a1260ac83d0",
        "_cell_guid": "6cc76751-9af3-406e-8069-43a3b1184a33",
        "trusted": true,
        "id": "1yHggWhrAvU2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dfh = dfl.copy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "0f0020f3-dff2-4955-ab5f-4e4ed1f6d426",
        "_cell_guid": "bf77ce2b-1673-4327-bed7-6adea2b671c8",
        "trusted": true,
        "id": "iKXnsKuMAvU2",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dfl_enc = dfl.apply(LabelEncoder().fit_transform)\n",
        "                          \n",
        "dfl_enc.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "a260b3d3-d112-438e-86d7-2c6af1a46a42",
        "_cell_guid": "8963333c-256d-41e3-9f3c-69ed9a1c2f39",
        "trusted": true,
        "id": "IDEKK-LxAvU3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "one_hot_cols = dfh.columns.tolist()\n",
        "dfh_enc = pd.get_dummies(dfh, columns=one_hot_cols)\n",
        "\n",
        "dfh_enc.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "c3bd630a-32a7-4406-ae97-cbe94c292a4a",
        "_cell_guid": "f7ffb907-2ef6-4dee-970f-855a1b845b5e",
        "trusted": true,
        "id": "VB-7GKqWAvU4",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part7\"></a>\n",
        "## Part 7:  머신러닝 모델 만들기\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "4f08ed58-5c09-4543-8fb3-dbf52a2ab70b",
        "_cell_guid": "ea403bf5-1e24-404a-a9b3-525b1733152e",
        "trusted": true,
        "id": "8-6OG6tGAvU4",
        "colab_type": "text"
      },
      "source": [
        "* 자, 이제 머신 러닝 모델을 만들어 보지요.\n",
        "* 우선 인코딩한 파일을 train과 test로 아까 구분해 놓은 행으로 쪼갭니다"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "db061f49-8d37-43ea-8d97-88721210e4a3",
        "_cell_guid": "e23b694f-3d9f-4a49-a41a-6972c9014d5e",
        "trusted": true,
        "id": "4QAeFFmFAvU5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train = dfh_enc[:ntrain]\n",
        "test = dfh_enc[ntrain:]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "c212268a-022d-49cf-b285-ab1f9d2cdf6a",
        "_cell_guid": "4fec1a72-d3e8-4f64-9a86-c36ebea86f68",
        "trusted": true,
        "id": "-kiu7j83AvU5",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "X_test = test\n",
        "X_train = train"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "cc504a21-67b3-43d8-877a-e63ff3724924",
        "_cell_guid": "cdcf4cb8-e8d4-4ca5-8e2f-803cfe8c5fa4",
        "trusted": true,
        "id": "93XrrdU6AvU8",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "scaler = StandardScaler()\n",
        "X_train = scaler.fit_transform(X_train)\n",
        "X_test = scaler.transform(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "1c5f1dcb-77ac-41d5-818c-fcb7cb0fbf29",
        "_cell_guid": "326f1a0f-1d3a-441f-adf1-9aff0ddd6a44",
        "trusted": true,
        "id": "YzTLV26FAvU9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ran = RandomForestClassifier(random_state=1)\n",
        "knn = KNeighborsClassifier()\n",
        "log = LogisticRegression()\n",
        "xgb = XGBClassifier()\n",
        "gbc = GradientBoostingClassifier()\n",
        "svc = SVC(probability=True)\n",
        "ext = ExtraTreesClassifier()\n",
        "ada = AdaBoostClassifier()\n",
        "gnb = GaussianNB()\n",
        "gpc = GaussianProcessClassifier()\n",
        "bag = BaggingClassifier()\n",
        "\n",
        "# 리스트 준비\n",
        "models = [ran, knn, log, xgb, gbc, svc, ext, ada, gnb, gpc, bag]         \n",
        "model_names = ['Random Forest', 'K Nearest Neighbour', 'Logistic Regression', 'XGBoost', 'Gradient Boosting', 'SVC', 'Extra Trees', 'AdaBoost', 'Gaussian Naive Bayes', 'Gaussian Process', 'Bagging Classifier']\n",
        "scores = {}\n",
        "\n",
        "# 이어서 연속적으로 모델을 학습 시키고 교차 검증합니다.\n",
        "for ind, mod in enumerate(models):\n",
        "    mod.fit(X_train, y_train)\n",
        "    acc = cross_val_score(mod, X_train, y_train, scoring = \"accuracy\", cv = 10)\n",
        "    scores[model_names[ind]] = acc"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2VyT498bAvU-",
        "colab_type": "text"
      },
      "source": [
        "* [리스트 학습](https://trinket.io/joshua-mobile-choi-1756/courses/python-3-4#/tasks/task-14-list)\n",
        "* [딕쇼너리 학습](https://trinket.io/joshua-mobile-choi-1756/courses/python-3-4#/tasks/task-16-dictionary)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "72f20132-7cfd-41c9-b029-ab3ef1761dc4",
        "_cell_guid": "71527848-6fca-4d30-a868-bf0078f7c59d",
        "trusted": true,
        "id": "7tlFQQkgAvU_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 결과 테이블을 만듭니다.\n",
        "results = pd.DataFrame(scores).T\n",
        "results['mean'] = results.mean(1)\n",
        "\n",
        "result_df = results.sort_values(by='mean', ascending=False)#.reset_index()\n",
        "result_df.head(11)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "da782555-e813-442d-9202-21cea8c83ab2",
        "_cell_guid": "c57826be-f317-444c-b13c-f0b36c83c20f",
        "trusted": true,
        "id": "quQofYqaAvVA",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "result_df = result_df.drop(['mean'], axis=1)\n",
        "sns.boxplot(data=result_df.T, orient='h')\n",
        "plt.title('Machine Learning Algorithm Accuracy Score \\n')\n",
        "plt.xlabel('Accuracy Score (%)');"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "f4907e67-256c-48d9-a6a7-31c0b618b35c",
        "_cell_guid": "4397f6cb-46a7-45fa-b12d-1f81d3936d37",
        "trusted": true,
        "id": "VgMiiMlCAvVC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 중요도를 보는 함수를 만듭니다.\n",
        "def importance_plotting(data, xlabel, ylabel, title, n=20):\n",
        "    sns.set(style=\"whitegrid\")\n",
        "    ax = data.tail(n).plot(kind='barh')\n",
        "    \n",
        "    ax.set(title=title, xlabel=xlabel, ylabel=ylabel)\n",
        "    ax.xaxis.grid(False)\n",
        "    ax.yaxis.grid(True)\n",
        "    plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "0b85fb34-1255-421e-adc2-9884c7dbb6f1",
        "_cell_guid": "8234411f-6078-426a-a780-347ad625f139",
        "trusted": true,
        "id": "gQQ5KJniAvVC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 데이터 프레임에 항목 중요도를 넣습니다.\n",
        "fi = {'Features':train.columns.tolist(), 'Importance':xgb.feature_importances_}\n",
        "importance = pd.DataFrame(fi, index=fi['Features']).sort_values('Importance', ascending=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "f86fd957-7c51-4290-87cc-b06ae24a3733",
        "_cell_guid": "c112f734-a08e-4897-bae7-67688b7f0d65",
        "trusted": true,
        "id": "6UZOhbMxAvVD",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 그래프 제목\n",
        "title = 'Top 20 most important features in predicting survival on the Titanic: XGB'\n",
        "\n",
        "# 그래프 그리기\n",
        "importance_plotting(importance, 'Importance', 'Features', title, 20)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "16c8c145-5404-441a-8238-4a6dfb76f3c5",
        "_cell_guid": "25d96047-94d0-4df5-890c-4c47d7ce20e7",
        "trusted": true,
        "id": "Oq_MBdxeAvVE",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 중요도를 데이터프레임에 넣습니다. Logistic regression에서는 중요도보다 coefficients를 사용합니다. \n",
        "# 아래는 Features라는 열에 트레인의 열들의 이름을 리스트로 만들어서 넣고 Importance에는 Logistic regression에는 coefficient를 바꾸어 넣어라는 넘파이 명령입니다.(즉 가로를 세로로)\n",
        "fi = {'Features':train.columns.tolist(), 'Importance':np.transpose(log.coef_[0])}\n",
        "importance = pd.DataFrame(fi, index=fi['Features']).sort_values('Importance', ascending=True)\n",
        "# 그래프 타이틀\n",
        "title = 'Top 20 important features in predicting survival on the Titanic: Logistic Regression'\n",
        "\n",
        "# 그래프 그리기\n",
        "importance_plotting(importance, 'Importance', 'Features', title, 20)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "1c66280a-d412-43f8-8cdf-b7bcebc0b98d",
        "_cell_guid": "853c9d54-1f82-442d-8db5-cce4f139e7cb",
        "trusted": true,
        "id": "mfxxgDtRAvVG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 5가지 모델에 대한 항목 중요도 얻기\n",
        "gbc_imp = pd.DataFrame({'Feature':train.columns, 'gbc importance':gbc.feature_importances_})\n",
        "xgb_imp = pd.DataFrame({'Feature':train.columns, 'xgb importance':xgb.feature_importances_})\n",
        "ran_imp = pd.DataFrame({'Feature':train.columns, 'ran importance':ran.feature_importances_})\n",
        "ext_imp = pd.DataFrame({'Feature':train.columns, 'ext importance':ext.feature_importances_})\n",
        "ada_imp = pd.DataFrame({'Feature':train.columns, 'ada importance':ada.feature_importances_})\n",
        "\n",
        "# 이를 하나의 데이터프레임으로\n",
        "importances = gbc_imp.merge(xgb_imp, on='Feature').merge(ran_imp, on='Feature').merge(ext_imp, on='Feature').merge(ada_imp, on='Feature')\n",
        "\n",
        "# 항목당 평균 중요도\n",
        "importances['Average'] = importances.mean(axis=1)\n",
        "\n",
        "# 랭킹 정하기\n",
        "importances = importances.sort_values(by='Average', ascending=False).reset_index(drop=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "3e6afcd4-0cbe-4903-a465-86f43fcab9b2",
        "_cell_guid": "7ccb6ca2-2916-4d75-9ba0-1bc5e366526a",
        "trusted": true,
        "id": "sLptW1tOAvVH",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part8\"></a>\n",
        "## Part 8: 중요도에 따라 모델 재 설정\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "56842f9c-52e1-4b50-8e10-bc84167f0087",
        "_cell_guid": "c21ec025-aab1-406f-9a2b-26757f584779",
        "trusted": true,
        "id": "xeX3jwA8AvVH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 중요도를 다시 데이터 프레임에 넣기\n",
        "fi = {'Features':importances['Feature'], 'Importance':importances['Average']}\n",
        "importance = pd.DataFrame(fi).set_index('Features').sort_values('Importance', ascending=True)\n",
        "\n",
        "# 그래프 타이틀\n",
        "title = 'Top 20 important features in predicting survival on the Titanic: 5 model average'\n",
        "\n",
        "# 그래프 보기\n",
        "importance_plotting(importance, 'Importance', 'Features', title, 20)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ff0b0377-6933-401d-8b05-3062b06dcf5f",
        "_cell_guid": "653a147a-b78c-4521-839f-a820dac1bb0d",
        "trusted": true,
        "id": "CxOi_0OrAvVI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "importance1 = importance[-381:]\n",
        "\n",
        "importance1[371:381]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ab817cb6-6139-451d-b537-839d12e6933a",
        "_cell_guid": "3a003ded-2405-4133-9be1-0d4637431f01",
        "trusted": true,
        "id": "QVu1MJSCAvVJ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 영양가 있는 380개만 넣기\n",
        "mylist = list(importance1.index)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "35c1533e-c32a-496f-9ca2-e589976ebdce",
        "_cell_guid": "986b726a-baad-4d26-ab0f-b6c80446a9fd",
        "trusted": true,
        "id": "Dvqi7DVHAvVK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train1 = pd.DataFrame()\n",
        "test1 = pd.DataFrame()\n",
        "\n",
        "for i in mylist:\n",
        "    train1[i] = train[i]\n",
        "    test1[i]= test[i]\n",
        "    \n",
        "train1.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7b6f312b-d50b-46e7-85cd-e59673d3bbe4",
        "_cell_guid": "2c33874d-a1c2-4cdf-a2ad-ab22adba7043",
        "trusted": true,
        "id": "UnAt4Vi6AvVL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "train = train1\n",
        "test = test1\n",
        "\n",
        "# 모델의 변수를 다시 정의하고\n",
        "X_train = train\n",
        "X_test = test\n",
        "\n",
        "# 바꿉니다.\n",
        "X_train = scaler.fit_transform(X_train)\n",
        "X_test = scaler.transform(X_test)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "40b7602f-2740-42d2-9e31-3fb013dfc175",
        "_cell_guid": "a4842052-559b-46f9-bddb-23020052624c",
        "trusted": true,
        "id": "pRauUUl6AvVM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "ran = RandomForestClassifier(random_state=1)\n",
        "knn = KNeighborsClassifier()\n",
        "log = LogisticRegression()\n",
        "xgb = XGBClassifier(random_state=1)\n",
        "gbc = GradientBoostingClassifier(random_state=1)\n",
        "svc = SVC(probability=True)\n",
        "ext = ExtraTreesClassifier(random_state=1)\n",
        "ada = AdaBoostClassifier(random_state=1)\n",
        "gnb = GaussianNB()\n",
        "gpc = GaussianProcessClassifier()\n",
        "bag = BaggingClassifier(random_state=1)\n",
        "\n",
        "# 리스트 준비\n",
        "models = [ran, knn, log, xgb, gbc, svc, ext, ada, gnb, gpc, bag]         \n",
        "model_names = ['Random Forest', 'K Nearest Neighbour', 'Logistic Regression', 'XGBoost', 'Gradient Boosting', 'SVC', 'Extra Trees', 'AdaBoost', 'Gaussian Naive Bayes', 'Gaussian Process', 'Bagging Classifier']\n",
        "scores2 = {}\n",
        "\n",
        "# 학습 및 교차 검증\n",
        "for ind, mod in enumerate(models):\n",
        "    mod.fit(X_train, y_train)\n",
        "    acc = cross_val_score(mod, X_train, y_train, scoring = \"accuracy\", cv = 10)\n",
        "    scores2[model_names[ind]] = acc"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "67b5e902-fa01-4986-a271-4bdf05ef773c",
        "_cell_guid": "abbd4bdc-ba21-42b2-9b99-5a0de6608e78",
        "trusted": true,
        "id": "GGzvyx9PAvVN",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 결과 테이블을 만듭니다.\n",
        "results = pd.DataFrame(scores2).T\n",
        "results['mean'] = results.mean(1)\n",
        "\n",
        "result_df = results.sort_values(by='mean', ascending=False)#.reset_index()\n",
        "result_df.head(11)\n",
        "result_df = result_df.drop(['mean'], axis=1)\n",
        "sns.boxplot(data=result_df.T, orient='h')\n",
        "plt.title('Machine Learning Algorithm Accuracy Score \\n')\n",
        "plt.xlabel('Accuracy Score (%)');"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "82130d2e-cc61-42d1-86bc-11170f652ac6",
        "_cell_guid": "ab646e63-c9a6-4a79-b4f8-b3a5a15695c0",
        "trusted": true,
        "id": "rO4E7ZyuAvVO",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part9\"></a>\n",
        "## Part 9: 하이퍼 파라미터 튜닝\n",
        "[Go to the Table of Contents](#table_of_contents)\n",
        "\n",
        "### SVC\n",
        "* Scikit-Learn에서는 3가지 모형 최적화 도구를 지원하는데 validation_curve/ GridSearchCV/ ParameterGrid이다\n",
        "* fit 메소드를 호출하면 grid search가 자동으로 여러개의 내부 모형을 생성하고 이를 모두 실행시켜서 최적 파라미터를 찾는다.\n",
        "\n",
        "* bestscore는 최고 점수이고 best estimator는 최고 점수를 낸 파라미터를 가진 모형\n",
        "* c값과 gamma값은 10의 배수로 일반적으로 한다.\n",
        "* 감마 매개 변수는 단일 학습 예제의 영향이 도달하는 정도를 정의하며 낮은 값은 'far'를, 높은 값은 'close'를 나타냅니다. 감마 매개 변수는 서포트 벡터로 모델에 의해 선택된 샘플의 영향 반경의 역으로 볼 수 있습니다.\n",
        "* C 매개 변수는 의사 결정 표면의 단순성에 대한 훈련 예제의 오 분류를 제거합니다. C가 낮을수록 결정 표면이 매끄럽고 높은 C는 모델이 더 많은 샘플을 서포트 벡터로 자유롭게 선택할 수 있도록하여 모든 학습 예제를 올바르게 분류하는 것을 목표로합니다.\n",
        "* Verbose는 불리안 값으로 True로 넣으면 꼬치 꼬치 다 알려주는데, 대신 시간이 좀 더 오래 걸립니다.\n",
        "* cv =5는 5 fold로 교차 검증한다는 뜻입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "617e2d9f-4d0d-4c67-b05c-c70f4361b0ae",
        "_cell_guid": "ff325452-b52e-4c13-84eb-43bf47498d61",
        "trusted": true,
        "id": "3x9jr01uAvVP",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 파라미터 서치\n",
        "Cs = [0.01, 0.1, 1, 5, 10, 15, 20, 50]\n",
        "gammas = [0.001, 0.01, 0.1]\n",
        "\n",
        "# 파라미터 그리드 셋팅\n",
        "hyperparams = {'C': Cs, 'gamma' : gammas}\n",
        "\n",
        "# 교차검증\n",
        "gd=GridSearchCV(estimator = SVC(probability=True), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "# 모델 fiting 및 결과\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "02c01cd2-ae81-43c9-96a2-6d1b30781172",
        "_cell_guid": "401d778c-dfd2-4c3a-ad52-e75bfce4fdf5",
        "trusted": true,
        "id": "6who6frTAvVP",
        "colab_type": "text"
      },
      "source": [
        "### Gradient Boosting Classifier\n",
        "* learning_rate는 각 트리의 기여를 줄이는 역할을 합니다.\n",
        "* n_estimator는 각 경우의 트리 숫자입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "29c8e65b-51a4-4825-a724-29357077c6f1",
        "_cell_guid": "4d8e8437-f889-4fb5-8707-d92c7e776bb6",
        "trusted": true,
        "id": "kuGt4ROJAvVQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "learning_rate = [0.01, 0.05, 0.1, 0.2, 0.5]\n",
        "n_estimators = [100, 1000, 2000]\n",
        "max_depth = [3, 5, 10, 15]\n",
        "\n",
        "hyperparams = {'learning_rate': learning_rate, 'n_estimators': n_estimators}\n",
        "\n",
        "gd=GridSearchCV(estimator = GradientBoostingClassifier(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "170f14b5-068f-4b17-ba4d-e9b02a63302a",
        "_cell_guid": "37d0426d-b99d-4809-a017-057351b76fbe",
        "trusted": true,
        "id": "6LkVtk-YAvVQ",
        "colab_type": "text"
      },
      "source": [
        "### Logistic Regression\n",
        "* Penalty - L1 을 사용하는 회귀 모델을 Lasso Regression이라고하고 L2를 사용하는 모델을 Ridge Regression이라고합니다. 이 둘의 주요 차이점은 페널티입니다. 릿지 회귀는 손실 함수에 페널티 항으로 계수의 \"제곱 크기\"를 추가합니다. L2-norm이 오차를 제곱하기 때문에 (오류> 1 인 경우 로트가 증가 함) 모델은 L1-norm보다 훨씬 큰 오차 (e vs e ^ 2)를 보게되므로 훨씬 더 민감합니다. 따라서 오류를 최소화하기 위해 모델을 조정해줍니다.\n",
        "* C는 estimator 입니다. logspace 1차원 10개 배열로 0에서 4까지를 estimator로 놓은 것입니다."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7b4230c4-b8d8-4420-be1e-eaee4acadc77",
        "_cell_guid": "870d3e5c-76ab-4298-b15c-a819d008dd3f",
        "trusted": true,
        "id": "c4r61-ZOAvVR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "penalty = ['l1', 'l2']\n",
        "C = np.logspace(0, 4, 10)\n",
        "\n",
        "hyperparams = {'penalty': penalty, 'C': C}\n",
        "\n",
        "gd=GridSearchCV(estimator = LogisticRegression(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "9df6107b-d2e4-4035-8709-9035479cd64f",
        "_cell_guid": "1405bc44-2a02-4696-94b6-5e5ce4baf8cc",
        "trusted": true,
        "id": "yzqBYsvlAvVT",
        "colab_type": "text"
      },
      "source": [
        "### XGBoost Step 1."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "643bc577-bfa2-4e38-8df6-3e9b4b8fa0d2",
        "_cell_guid": "4346cbb7-f969-4b02-be52-a01f7039897e",
        "trusted": true,
        "id": "EHvDxrYEAvVT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "learning_rate = [0.001, 0.005, 0.01, 0.05, 0.1, 0.2]\n",
        "n_estimators = [10, 50, 100, 250, 500, 1000]\n",
        "\n",
        "hyperparams = {'learning_rate': learning_rate, 'n_estimators': n_estimators}\n",
        "\n",
        "gd=GridSearchCV(estimator = XGBClassifier(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "cac087fb-2374-4b66-89bb-7137be4ddf30",
        "_cell_guid": "26699ef6-da41-4d4b-a72c-2294282ccaee",
        "trusted": true,
        "id": "NWpdOh_vAvVW",
        "colab_type": "text"
      },
      "source": [
        "### XGB Step 2."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "99886f47-c11f-4a2b-8445-99f5c3232464",
        "_cell_guid": "66f3e492-3681-40c3-be52-5a4b4fc83ca1",
        "trusted": true,
        "id": "Ec-xt6A5AvVW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "max_depth = [3, 4, 5, 6, 7, 8, 9, 10]\n",
        "min_child_weight = [1, 2, 3, 4, 5, 6]\n",
        "\n",
        "hyperparams = {'max_depth': max_depth, 'min_child_weight': min_child_weight}\n",
        "\n",
        "gd=GridSearchCV(estimator = XGBClassifier(learning_rate=0.2, n_estimators=10), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "93a87021-9d0f-4958-9d29-4d987c9849b0",
        "_cell_guid": "9f44ba44-d5e6-441c-b649-5f209b4acecf",
        "trusted": true,
        "id": "CiCUyQA9AvVX",
        "colab_type": "text"
      },
      "source": [
        "### XGB Step 3."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "101b59c1-6f8e-4b6d-8fa0-91e3011e881b",
        "_cell_guid": "1102de90-ab2b-4f75-ae37-2fc921b5c217",
        "trusted": true,
        "id": "5XpUAdeIAvVX",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "gamma = [i*0.1 for i in range(0,5)]\n",
        "\n",
        "hyperparams = {'gamma': gamma}\n",
        "\n",
        "gd=GridSearchCV(estimator = XGBClassifier(learning_rate=0.2, n_estimators=10, max_depth=6, \n",
        "                                          min_child_weight=1), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "d20e121c-6125-4a76-b1ae-0cef7e4794e5",
        "_cell_guid": "12a7bf69-0a24-46a4-b8f6-c0aa4894ba0c",
        "trusted": true,
        "id": "RJLIV14JAvVY",
        "colab_type": "text"
      },
      "source": [
        "### XGB Step 4"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "c8c1ef68-731b-41da-a239-1c5c10d4045d",
        "_cell_guid": "d6d3975f-b557-4356-9ab1-ae8861560858",
        "trusted": true,
        "id": "27t8x_v-AvVY",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "subsample = [0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1]\n",
        "colsample_bytree = [0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95, 1]\n",
        "    \n",
        "hyperparams = {'subsample': subsample, 'colsample_bytree': colsample_bytree}\n",
        "\n",
        "gd=GridSearchCV(estimator = XGBClassifier(learning_rate=0.2, n_estimators=10, max_depth=6, \n",
        "                                          min_child_weight=1, gamma=0), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "c8471b94-1bce-4066-9d1e-9ab631176b02",
        "_cell_guid": "c89a7b0f-9a62-4d9b-9222-27cd43c97c00",
        "trusted": true,
        "id": "f95X0x7qAvVZ",
        "colab_type": "text"
      },
      "source": [
        "### XGB Step 5"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ea362268-af07-41d9-9959-46917bd9b925",
        "_cell_guid": "2c6cef6b-85a1-46e7-8be3-700cc786eb60",
        "trusted": true,
        "id": "6Yz-BWfCAvVa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "reg_alpha = [1e-5, 1e-2, 0.1, 1, 100]\n",
        "    \n",
        "hyperparams = {'reg_alpha': reg_alpha}\n",
        "\n",
        "gd=GridSearchCV(estimator = XGBClassifier(learning_rate=0.2, n_estimators=10, max_depth=6, \n",
        "                                          min_child_weight=1, gamma=0, subsample=1, colsample_bytree=1),\n",
        "                                         param_grid = hyperparams, verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "a817bcdf-f0e5-46c4-b7de-50b4fa0ebe63",
        "_cell_guid": "11467818-d0f5-4205-8f7c-82000c92809a",
        "trusted": true,
        "id": "3vlYQik9AvVa",
        "colab_type": "text"
      },
      "source": [
        "### Gaussian Process"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "4f3f5b07-a4d9-4cf2-a71a-c5beec68a8c2",
        "_cell_guid": "18f25af0-a8fb-4248-9e47-9bc2fd3ff3fd",
        "trusted": true,
        "id": "sFcg--nlAvVa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_restarts_optimizer = [0, 1, 2, 3]\n",
        "max_iter_predict = [1, 2, 5, 10, 20, 35, 50, 100]\n",
        "warm_start = [True, False]\n",
        "\n",
        "hyperparams = {'n_restarts_optimizer': n_restarts_optimizer, 'max_iter_predict': max_iter_predict, 'warm_start': warm_start}\n",
        "\n",
        "gd=GridSearchCV(estimator = GaussianProcessClassifier(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "56a9ce2e-1af6-4401-9edf-4b398f160fc3",
        "_cell_guid": "e62c52c8-0fcb-46ed-8661-eec341b7d437",
        "trusted": true,
        "id": "lj7XwMy1AvVb",
        "colab_type": "text"
      },
      "source": [
        "### Adaboost."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "cdff9ce0-ad04-4367-9a3b-0550b071a58c",
        "_cell_guid": "91feb7d9-da30-4724-b202-385b93153539",
        "trusted": true,
        "id": "AqS_srrTAvVb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_estimators = [10, 100, 200, 500]\n",
        "learning_rate = [0.001, 0.01, 0.1, 0.5, 1, 1.5, 2]\n",
        "\n",
        "hyperparams = {'n_estimators': n_estimators, 'learning_rate': learning_rate}\n",
        "\n",
        "gd=GridSearchCV(estimator = AdaBoostClassifier(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "0be8bc86-4f1a-4993-969e-988c81a382f3",
        "_cell_guid": "35f01d93-8cc6-4e11-8f30-2c03b09d1ba6",
        "trusted": true,
        "id": "5sNBnBPcAvVc",
        "colab_type": "text"
      },
      "source": [
        "### KNN"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "0b0b248c-c71a-4d9f-adbd-aa6a8832479c",
        "_cell_guid": "15b9e349-5bb1-4b4a-b959-ee7e5c9f2d9d",
        "trusted": true,
        "id": "j1mJaqDuAvVc",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_neighbors = [1, 2, 3, 4, 5]\n",
        "algorithm = ['auto']\n",
        "weights = ['uniform', 'distance']\n",
        "leaf_size = [1, 2, 3, 4, 5, 10]\n",
        "\n",
        "hyperparams = {'algorithm': algorithm, 'weights': weights, 'leaf_size': leaf_size, \n",
        "               'n_neighbors': n_neighbors}\n",
        "\n",
        "gd=GridSearchCV(estimator = KNeighborsClassifier(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "# Fitting model and return results\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "c05e03d6-e9f6-48a8-a490-91edad269a28",
        "_cell_guid": "467615a9-ba76-480b-bb0e-2d1fa6ee87cd",
        "trusted": true,
        "id": "TSx2HIvPAvVd",
        "colab_type": "text"
      },
      "source": [
        "### Random Forest."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "1fa9fb06-e7e0-48ff-ae44-58a9cd112061",
        "_cell_guid": "2b66e74e-f6e6-49a2-8b5c-b0a046046be5",
        "trusted": true,
        "id": "Q9DuP8ZmAvVd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_estimators = [10, 50, 100, 200]\n",
        "max_depth = [3, None]\n",
        "max_features = [0.1, 0.2, 0.5, 0.8]\n",
        "min_samples_split = [2, 6]\n",
        "min_samples_leaf = [2, 6]\n",
        "\n",
        "hyperparams = {'n_estimators': n_estimators, 'max_depth': max_depth, 'max_features': max_features,\n",
        "               'min_samples_split': min_samples_split, 'min_samples_leaf': min_samples_leaf}\n",
        "\n",
        "gd=GridSearchCV(estimator = RandomForestClassifier(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "6066567d-147e-4002-a4c8-15ca6d1b75b9",
        "_cell_guid": "13c66675-db30-46da-b8d5-7f29c42ae4ae",
        "trusted": true,
        "id": "HlshxljyAvVd",
        "colab_type": "text"
      },
      "source": [
        "### Extra Trees"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "a85ee736-9b4c-4f76-a8c8-94b9c209b521",
        "_cell_guid": "48633479-2e33-4797-8d93-8fd1dec32f0b",
        "trusted": true,
        "id": "rUn9dctUAvVd",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_estimators = [10, 25, 50, 75, 100]\n",
        "max_depth = [3, None]\n",
        "max_features = [0.1, 0.2, 0.5, 0.8]\n",
        "min_samples_split = [2, 10]\n",
        "min_samples_leaf = [2, 10]\n",
        "\n",
        "hyperparams = {'n_estimators': n_estimators, 'max_depth': max_depth, 'max_features': max_features,\n",
        "               'min_samples_split': min_samples_split, 'min_samples_leaf': min_samples_leaf}\n",
        "\n",
        "gd=GridSearchCV(estimator = ExtraTreesClassifier(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "aa0149e2-40d2-43f2-bce5-dd7220ee626a",
        "_cell_guid": "e9910ab8-e6f2-4bcf-8b58-26e969cf2f81",
        "trusted": true,
        "id": "-KDVrCQOAvVf",
        "colab_type": "text"
      },
      "source": [
        "### Bagging Classifier"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "3e837e5d-996e-4605-bafd-138e65ac88ae",
        "_cell_guid": "93573330-8819-4702-9e45-f1f989dc4eb7",
        "trusted": true,
        "id": "flEAVHC7AvVf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "n_estimators = [10, 50, 75, 100, 200]\n",
        "max_samples = [0.1, 0.2, 0.5, 0.8, 1.0]\n",
        "max_features = [0.1, 0.2, 0.5, 0.8, 1.0]\n",
        "\n",
        "hyperparams = {'n_estimators': n_estimators, 'max_samples': max_samples, 'max_features': max_features}\n",
        "\n",
        "gd=GridSearchCV(estimator = BaggingClassifier(), param_grid = hyperparams, \n",
        "                verbose=True, cv=5, scoring = \"accuracy\", n_jobs=-1)\n",
        "\n",
        "gd.fit(X_train, y_train)\n",
        "print(gd.best_score_)\n",
        "print(gd.best_params_)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "6dd959c9-e59c-49a1-bfb9-7b8c57200c55",
        "_cell_guid": "b26eb972-d4f0-4a2a-99e6-90290397e118",
        "trusted": true,
        "id": "caTJCVe3AvVg",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part10\"></a>\n",
        "## Part 10: 모델 재 트레이닝\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "918bef1a-e9e9-409e-ba14-4ee530de5297",
        "_cell_guid": "08cec4e2-9249-435e-9160-e1a5c27d23b4",
        "trusted": true,
        "id": "i2V-j0N4AvVg",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# 튜닝 모델 시작\n",
        "# sample을 split하는 것은 전체데이터 80%를 트레인셋에 20%는 테스트셋에 줌  \n",
        "ran = RandomForestClassifier(max_depth=None, max_features=0.1, min_samples_leaf=2, min_samples_split=2, n_estimators=50, random_state=1)\n",
        "\n",
        "knn = KNeighborsClassifier(leaf_size=1, n_neighbors=4, weights='distance')\n",
        "\n",
        "log = LogisticRegression(C=2.7825594022071245, penalty='l2')\n",
        "\n",
        "xgb = XGBClassifier(learning_rate=0.1, n_estimators=10, max_depth=7, \n",
        "                                          min_child_weight=5, gamma=0, subsample=1, colsample_bytree=1, reg_alpha=1e-05)\n",
        "\n",
        "gbc = GradientBoostingClassifier(learning_rate=0.1, max_depth=3, n_estimators=1000)\n",
        "\n",
        "svc = SVC(probability=True, gamma=0.001, C=5)\n",
        "\n",
        "ext = ExtraTreesClassifier(max_depth=None, max_features=0.2, min_samples_leaf=10, min_samples_split=2, n_estimators=100, random_state=1)\n",
        "\n",
        "ada = AdaBoostClassifier(learning_rate=0.5, n_estimators=500, random_state=1)\n",
        "\n",
        "gpc = GaussianProcessClassifier(max_iter_predict=1, n_restarts_optimizer=0, warm_start=True)\n",
        "\n",
        "bag = BaggingClassifier(max_features=1.0, max_samples=1.0, n_estimators=75, random_state=1)\n",
        "\n",
        "# 리스트\n",
        "models = [ran, knn, log, xgb, gbc, svc, ext, ada, gnb, gpc, bag]         \n",
        "model_names = ['Random Forest', 'K Nearest Neighbour', 'Logistic Regression', 'XGBoost', 'Gradient Boosting', 'SVC', 'Extra Trees', 'AdaBoost', 'Gaussian Naive Bayes', 'Gaussian Process', 'Bagging Classifier']\n",
        "scores3 = {}\n",
        "\n",
        "# Sequentially fit and cross validate all models\n",
        "for ind, mod in enumerate(models):\n",
        "    mod.fit(X_train, y_train)\n",
        "    acc = cross_val_score(mod, X_train, y_train, scoring = \"accuracy\", cv = 10)\n",
        "    scores3[model_names[ind]] = acc"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "e7d6b437-b971-4c16-aff6-36f969d7de29",
        "_cell_guid": "b561e5b7-43d9-4d6f-b61f-28f7aef26163",
        "trusted": true,
        "id": "Uxy0L5DWAvVh",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "results = pd.DataFrame(scores).T\n",
        "results['mean'] = results.mean(1)\n",
        "result_df = results.sort_values(by='mean', ascending=False)\n",
        "result_df.head(11)\n",
        "\n",
        "\n",
        "result_df = result_df.drop(['mean'], axis=1)\n",
        "sns.boxplot(data=result_df.T, orient='h')\n",
        "plt.title('Machine Learning Algorithm Accuracy Score \\n')\n",
        "plt.xlabel('Accuracy Score (%)');"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "43383052-33dc-4af5-b145-5c4e7cde6282",
        "_cell_guid": "d5d361fd-39f5-4789-a190-de4fda36c35a",
        "trusted": true,
        "id": "tYnUICR7AvVj",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part11\"></a>\n",
        "## Part 11: 마지막 보팅\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "ef9dc059-1f16-4b49-b758-8260b8a2885e",
        "_cell_guid": "9136b577-f081-49f0-b0bd-09b805554adc",
        "trusted": true,
        "id": "s17Qy34eAvVj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#튜닝한 파라미터로 하드보팅\n",
        "grid_hard = VotingClassifier(estimators = [('Random Forest', ran), \n",
        "                                           ('Logistic Regression', log),\n",
        "                                           ('XGBoost', xgb),\n",
        "                                           ('Gradient Boosting', gbc),\n",
        "                                           ('Extra Trees', ext),\n",
        "                                           ('AdaBoost', ada),\n",
        "                                           ('Gaussian Process', gpc),\n",
        "                                           ('SVC', svc),\n",
        "                                           ('K Nearest Neighbour', knn),\n",
        "                                           ('Bagging Classifier', bag)], voting = 'hard')\n",
        "\n",
        "grid_hard_cv = model_selection.cross_validate(grid_hard, X_train, y_train, cv=10)\n",
        "grid_hard.fit(X_train, y_train)\n",
        "\n",
        "print(\"Hard voting on test set score mean: {:.2f}\". format(grid_hard_cv['test_score'].mean() * 100))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "7c6e3ce2-3bb7-488f-9b68-d831873bf5b4",
        "_cell_guid": "6702324e-6aa2-4828-8b1b-654fa1d7e6c8",
        "trusted": true,
        "id": "heqGPtyAAvVj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "grid_soft = VotingClassifier(estimators = [('Random Forest', ran), \n",
        "                                           ('Logistic Regression', log),\n",
        "                                           ('XGBoost', xgb),\n",
        "                                           ('Gradient Boosting', gbc),\n",
        "                                           ('Extra Trees', ext),\n",
        "                                           ('AdaBoost', ada),\n",
        "                                           ('Gaussian Process', gpc),\n",
        "                                           ('SVC', svc),\n",
        "                                           ('K Nearest Neighbour', knn),\n",
        "                                           ('Bagging Classifier', bag)], voting = 'soft')\n",
        "\n",
        "grid_soft_cv = model_selection.cross_validate(grid_soft, X_train, y_train, cv=10)\n",
        "grid_soft.fit(X_train, y_train)\n",
        "\n",
        "print(\"Soft voting on test set score mean: {:.2f}\". format(grid_soft_cv['test_score'].mean() * 100))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "fb2e5708-e4ff-422f-855a-046b574e6579",
        "_cell_guid": "db3d7ec2-4ae9-4796-8604-e218b3e6f664",
        "trusted": true,
        "id": "n-Cy44ONAvVk",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part12\"></a>\n",
        "## Part 12: 마지막 모델 예측\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "cbb5704e-97cd-49e2-a348-a3c6c6a308fe",
        "_cell_guid": "3c2478d5-abcf-441b-a670-51c452eee2ea",
        "trusted": true,
        "id": "GziG8HH6AvVk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Final predictions2\n",
        "predictions = grid_hard.predict(X_test)\n",
        "\n",
        "submission = pd.concat([pd.DataFrame(passId), pd.DataFrame(predictions)], axis = 'columns')\n",
        "\n",
        "submission.columns = [\"PassengerId\", \"Survived\"]\n",
        "submission.to_csv('titanic_submission1.csv', header = True, index = False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "bda28460-bcc3-43fc-a31a-4288440c6cb8",
        "_cell_guid": "82742be8-2738-4d16-b1f3-c033616c0c6d",
        "trusted": true,
        "id": "3p-EM_MsAvVl",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Final predictions\n",
        "predictions = grid_soft.predict(X_test)\n",
        "\n",
        "submission = pd.concat([pd.DataFrame(passId), pd.DataFrame(predictions)], axis = 'columns')\n",
        "\n",
        "submission.columns = [\"PassengerId\", \"Survived\"]\n",
        "submission.to_csv('titanic_submission2.csv', header = True, index = False)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "_uuid": "28563ff8-e674-4e5e-b5e8-80e17bbb456e",
        "_cell_guid": "a795db9a-3ee0-410a-9f50-b37e12576e1b",
        "trusted": true,
        "id": "rxKleMXRAvVm",
        "colab_type": "text"
      },
      "source": [
        "<a id = \"part13\"></a>\n",
        "## Part 13: 제출\n",
        "[Go to the Table of Contents](#table_of_contents)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "_uuid": "0ba0e5a5-1e03-41b8-a909-edeec1dba946",
        "_cell_guid": "ae6ba528-d916-4f2d-879d-bb440fde4aef",
        "trusted": true,
        "id": "5lEq-ivIAvVm",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# And we finally make a submission 그리고 제출 합니다.\n",
        "# Please make sure you \"commit\" (It take a few minutes) / commit버턴을 누르시는 것을 잊지 마세요 (몇 분 걸립니다)\n",
        "# And then you will see the submission file on the top right hand side at Data>Output>Kaggle/working / 그럼 우측 상단 데이터 아웃풋에서 제출용 결과물이 나올 것입니다."
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}