diff --git a/.cache/v/cache/lastfailed b/.cache/v/cache/lastfailed
new file mode 100644
index 0000000..9e26dfe
--- /dev/null
+++ b/.cache/v/cache/lastfailed
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..58461f2
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.ipynb_checkpoints
\ No newline at end of file
diff --git a/data/alice.txt b/data/alice.txt
new file mode 100644
index 0000000..84bf3cc
--- /dev/null
+++ b/data/alice.txt
@@ -0,0 +1,17 @@
+Alice was beginning to get very tired of sitting by her sister on the bank, and of having nothing to do: once or twice she had peeped into the book her sister was reading, but it had no pictures or conversations in it, 'and what is the use of a book,' thought Alice 'without pictures or conversations?'
+So she was considering in her own mind (as well as she could, for the hot day made her feel very sleepy and stupid), whether the pleasure of making a daisy-chain would be worth the trouble of getting up and picking the daisies, when suddenly a White Rabbit with pink eyes ran close by her.
+There was nothing so VERY remarkable in that; nor did Alice think it so VERY much out of the way to hear the Rabbit say to itself, 'Oh dear! Oh dear! I shall be late!' (when she thought it over afterwards, it occurred to her that she ought to have wondered at this, but at the time it all seemed quite natural); but when the Rabbit actually TOOK A WATCH OUT OF ITS WAISTCOAT-POCKET, and looked at it, and then hurried on, Alice started to her feet, for it flashed across her mind that she had never before seen a rabbit with either a waistcoat-pocket, or a watch to take out of it, and burning with curiosity, she ran across the field after it, and fortunately was just in time to see it pop down a large rabbit-hole under the hedge.
+In another moment down went Alice after it, never once considering how in the world she was to get out again.
+The rabbit-hole went straight on like a tunnel for some way, and then dipped suddenly down, so suddenly that Alice had not a moment to think about stopping herself before she found herself falling down a very deep well.
+Either the well was very deep, or she fell very slowly, for she had plenty of time as she went down to look about her and to wonder what was going to happen next. First, she tried to look down and make out what she was coming to, but it was too dark to see anything; then she looked at the sides of the well, and noticed that they were filled with cupboards and book-shelves; here and there she saw maps and pictures hung upon pegs. She took down a jar from one of the shelves as she passed; it was labelled 'ORANGE MARMALADE', but to her great disappointment it was empty: she did not like to drop the jar for fear of killing somebody, so managed to put it into one of the cupboards as she fell past it.
+'Well!' thought Alice to herself, 'after such a fall as this, I shall think nothing of tumbling down stairs! How brave they'll all think me at home! Why, I wouldn't say anything about it, even if I fell off the top of the house!' (Which was very likely true.)
+Down, down, down. Would the fall NEVER come to an end! 'I wonder how many miles I've fallen by this time?' she said aloud. 'I must be getting somewhere near the centre of the earth. Let me see: that would be four thousand miles down, I think—' (for, you see, Alice had learnt several things of this sort in her lessons in the schoolroom, and though this was not a VERY good opportunity for showing off her knowledge, as there was no one to listen to her, still it was good practice to say it over) '—yes, that's about the right distance—but then I wonder what Latitude or Longitude I've got to?' (Alice had no idea what Latitude was, or Longitude either, but thought they were nice grand words to say.)
+Presently she began again. 'I wonder if I shall fall right THROUGH the earth! How funny it'll seem to come out among the people that walk with their heads downward! The Antipathies, I think—' (she was rather glad there WAS no one listening, this time, as it didn't sound at all the right word) '—but I shall have to ask them what the name of the country is, you know. Please, Ma'am, is this New Zealand or Australia?' (and she tried to curtsey as she spoke—fancy CURTSEYING as you're falling through the air! Do you think you could manage it?) 'And what an ignorant little girl she'll think me for asking! No, it'll never do to ask: perhaps I shall see it written up somewhere.'
+Down, down, down. There was nothing else to do, so Alice soon began talking again. 'Dinah'll miss me very much to-night, I should think!' (Dinah was the cat.) 'I hope they'll remember her saucer of milk at tea-time. Dinah my dear! I wish you were down here with me! There are no mice in the air, I'm afraid, but you might catch a bat, and that's very like a mouse, you know. But do cats eat bats, I wonder?' And here Alice began to get rather sleepy, and went on saying to herself, in a dreamy sort of way, 'Do cats eat bats? Do cats eat bats?' and sometimes, 'Do bats eat cats?' for, you see, as she couldn't answer either question, it didn't much matter which way she put it. She felt that she was dozing off, and had just begun to dream that she was walking hand in hand with Dinah, and saying to her very earnestly, 'Now, Dinah, tell me the truth: did you ever eat a bat?' when suddenly, thump! thump! down she came upon a heap of sticks and dry leaves, and the fall was over.
+Alice was not a bit hurt, and she jumped up on to her feet in a moment: she looked up, but it was all dark overhead; before her was another long passage, and the White Rabbit was still in sight, hurrying down it. There was not a moment to be lost: away went Alice like the wind, and was just in time to hear it say, as it turned a corner, 'Oh my ears and whiskers, how late it's getting!' She was close behind it when she turned the corner, but the Rabbit was no longer to be seen: she found herself in a long, low hall, which was lit up by a row of lamps hanging from the roof.
+There were doors all round the hall, but they were all locked; and when Alice had been all the way down one side and up the other, trying every door, she walked sadly down the middle, wondering how she was ever to get out again.
+Suddenly she came upon a little three-legged table, all made of solid glass; there was nothing on it except a tiny golden key, and Alice's first thought was that it might belong to one of the doors of the hall; but, alas! either the locks were too large, or the key was too small, but at any rate it would not open any of them. However, on the second time round, she came upon a low curtain she had not noticed before, and behind it was a little door about fifteen inches high: she tried the little golden key in the lock, and to her great delight it fitted!
+Alice opened the door and found that it led into a small passage, not much larger than a rat-hole: she knelt down and looked along the passage into the loveliest garden you ever saw. How she longed to get out of that dark hall, and wander about among those beds of bright flowers and those cool fountains, but she could not even get her head through the doorway; 'and even if my head would go through,' thought poor Alice, 'it would be of very little use without my shoulders. Oh, how I wish I could shut up like a telescope! I think I could, if I only knew how to begin.' For, you see, so many out-of-the-way things had happened lately, that Alice had begun to think that very few things indeed were really impossible.
+There seemed to be no use in waiting by the little door, so she went back to the table, half hoping she might find another key on it, or at any rate a book of rules for shutting people up like telescopes: this time she found a little bottle on it, ('which certainly was not here before,' said Alice,) and round the neck of the bottle was a paper label, with the words 'DRINK ME' beautifully printed on it in large letters.
+It was all very well to say 'Drink me,' but the wise little Alice was not going to do THAT in a hurry. 'No, I'll look first,' she said, 'and see whether it's marked "poison" or not'; for she had read several nice little histories about children who had got burnt, and eaten up by wild beasts and other unpleasant things, all because they WOULD not remember the simple rules their friends had taught them: such as, that a red-hot poker will burn you if you hold it too long; and that if you cut your finger VERY deeply with a knife, it usually bleeds; and she had never forgotten that, if you drink much from a bottle marked 'poison,' it is almost certain to disagree with you, sooner or later.
+However, this bottle was NOT marked 'poison,' so Alice ventured to taste it, and finding it very nice, (it had, in fact, a sort of mixed flavour of cherry-tart, custard, pine-apple, roast turkey, toffee, and hot buttered toast,) she very soon finished it off.
diff --git a/src/__init__.py b/src/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/src/__pycache__/__init__.cpython-36.pyc b/src/__pycache__/__init__.cpython-36.pyc
new file mode 100644
index 0000000..8908b07
Binary files /dev/null and b/src/__pycache__/__init__.cpython-36.pyc differ
diff --git a/src/__pycache__/assessment.cpython-36.pyc b/src/__pycache__/assessment.cpython-36.pyc
new file mode 100644
index 0000000..9119b8c
Binary files /dev/null and b/src/__pycache__/assessment.cpython-36.pyc differ
diff --git a/src/assessment.py b/src/assessment.py
new file mode 100644
index 0000000..4378469
--- /dev/null
+++ b/src/assessment.py
@@ -0,0 +1,190 @@
+import numpy as np
+import pandas as pd
+
+
+# PYTHON SECTION
+
+def count_characters(string):
+    '''
+    INPUT: STRING
+    OUTPUT: DICT (with counts of each character in input string)
+
+    Return a dictionary which contains
+    a count of the number of times each character appears in the string.
+    Characters which with a count of 0 should not be included in the
+    output dictionary.
+    '''
+    '''
+    d = {}
+    for char in string[::]:
+        if char not in d:
+            d[char] = 1
+        else:
+            d[char] += 1
+    return d
+    '''
+    return {char: string.count(char) for char in string}
+
+def invert_dictionary(d):
+    '''
+    INPUT: DICT
+    OUTPUT: DICT (of sets of input keys indexing the same input values
+                  indexed by the input values)
+
+    Given a dictionary d, return a new dictionary with d's values
+    as keys and the value for a given key being
+    the set of d's keys which shared the same value.
+    e.g. {'a': 2, 'b': 4, 'c': 2} => {2: {'a', 'c'}, 4: {'b'}}
+    '''
+    
+    d_out = {}
+    for char in d:
+        if d[char] not in d_out:
+            d_out[d[char]] = {char}
+        else:
+            d_out[d[char]].add(char)
+    return d_out
+
+
+
+def word_count(filename):
+    '''
+    INPUT: STRING
+    OUTPUT: INT, INT, INT (a tuple with line, word,
+                           and character count of named INPUT file)
+
+    The INPUT filename is the name of a text file.
+    The OUTPUT is a tuple containting (in order)
+    the following stats for the text file:
+      1. number of lines
+      2. number of words (broken by whitespace)
+      3. number of characters
+    '''
+    nlin = 0
+    nword = 0
+    nchar = 0
+    f = open(filename)
+    lines = f.readlines()
+    for line in lines:
+        nlin += 1
+        nword += len(line.split(' '))
+        nchar += len(line)
+
+    return (nlin,nword,nchar)
+
+
+def matrix_multiplication(A, B):
+    '''
+    INPUT: LIST (of length n) OF LIST (of length n) OF INTEGERS,
+            LIST (of length n) OF LIST (of length n) OF INTEGERS
+    OUTPUT: LIST OF LIST OF INTEGERS
+            (storing the product of a matrix multiplication operation)
+
+    Return the matrix which is the product of matrix A and matrix B
+    where A and B will be (a) integer valued (b) square matrices
+    (c) of size n-by-n (d) encoded as lists of lists.
+
+    For example:
+    A = [[2, 3, 4], [6, 4, 2], [-1, 2, 0]] corresponds to the matrix
+
+        | 2  3  4 |
+        | 6  4  2 |
+        |-1  2  0 |
+
+    Please do not use numpy. Write your solution in straight python.
+    '''
+    '''
+    result = [[0] * len(A[0])] * len(B)
+    # iterate through rows of A
+    for i in range(len(A)):
+        # iterate through columns of B
+        for j in range(len(B[0])):
+            # iterate through rows of B
+            for k in range(len(A[0])):
+                result[i][j] += A[i][k] * B[k][j]
+    return result
+    '''
+    '''
+    M_dot = []
+    for i in range(len(A)):
+        new_row=[]
+        for j in range(len(B[0])):
+            sum = 0
+            for k in range(len(A[0])):
+                sum += A[i][k]*B[k][j]
+            new_row.append(sum)
+        M_dot.append(new_row)
+    return M_dot
+    '''
+    return [[sum(a*b for a,b in zip(A_row,B_col)) for B_col in zip(*B)] for A_row in A]
+
+# NumPy SECTION
+
+def array_work(rows, cols, scalar, matrixA):
+    '''
+    INPUT: INT, INT, INT, NUMPY ARRAY
+    OUTPUT: NUMPY ARRAY
+    (of matrix product of r-by-c matrix of "scalar"'s time matrixA)
+
+    Create matrix of size (rows, cols) with elements initialized to the scalar
+    value. Right multiply that matrix with the passed matrixA (i.e. AB, not
+    BA).  Return the result of the multiplication.  You needn't check for
+    matrix compatibililty, but you accomplish this in a single line.
+
+    E.g., array_work(2, 3, 5, [[3, 4], [5, 6], [7, 8]])
+           [[3, 4],      [[5, 5, 5],
+            [5, 6],   *   [5, 5, 5]]
+            [7, 8]]
+    '''
+    return np.dot(matrixA, np.full((rows, cols), scalar))
+
+
+def boolean_indexing(arr, minimum):
+    '''
+    INPUT: NUMPY ARRAY, INT
+    OUTPUT: NUMPY ARRAY
+    (of just elements in "arr" greater or equal to "minimum")
+
+    Return an array of only the elements of "arr" that are greater than or
+    equal to "minimum"
+
+    Ex:
+    In [1]: boolean_indexing([[3, 4, 5], [6, 7, 8]], 7)
+    Out[1]: array([7, 8])
+    '''
+    return arr[arr >= minimum]
+
+
+# Pandas SECTION
+
+def make_series(start, length, index):
+    '''
+    INPUTS: INT, INT, LIST (of length "length")
+    OUTPUT: PANDAS SERIES (of "length" sequential integers
+             beginning with "start" and with index "index")
+
+    Create a pandas Series of length "length" with index "index"
+    and with elements that are sequential integers starting from "start".
+    You may assume the length of index will be "length".
+
+    E.g.,
+    In [1]: make_series(5, 3, ['a', 'b', 'c'])
+    Out[1]:
+    a    5
+    b    6
+    c    7
+    dtype: int64
+    '''
+    return pd.Series(range(start,start + length), index)
+
+
+def data_frame_work(df, colA, colB, colC):
+    '''
+    INPUT: DATAFRAME, STR, STR, STR
+    OUTPUT: None
+
+    Insert a column (colC) into the dataframe that is the sum of colA and colB.
+    Assume that df contains columns colA and colB and that these are numeric.
+    '''
+    df[colC] = df[colA] + df[colB]
+    return df
diff --git a/test/__init__.py b/test/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/test/__pycache__/__init__.cpython-36.pyc b/test/__pycache__/__init__.cpython-36.pyc
new file mode 100644
index 0000000..89a6499
Binary files /dev/null and b/test/__pycache__/__init__.cpython-36.pyc differ
diff --git a/test/__pycache__/test_assessment.cpython-36-PYTEST.pyc b/test/__pycache__/test_assessment.cpython-36-PYTEST.pyc
new file mode 100644
index 0000000..230228a
Binary files /dev/null and b/test/__pycache__/test_assessment.cpython-36-PYTEST.pyc differ
diff --git a/test/test_assessment.py b/test/test_assessment.py
new file mode 100644
index 0000000..c4e64fb
--- /dev/null
+++ b/test/test_assessment.py
@@ -0,0 +1,84 @@
+#
+# 
+import src.assessment as a
+import numpy as np
+import pandas as pd
+
+def test_count_characters():
+    string = "abafdcggfaabe"
+    answer = {"a": 4, "b": 2, "c": 1, "d": 1, "e": 1, "f": 2, "g": 2}
+    result = a.count_characters(string)
+    assert (result == answer)
+
+
+def test_invert_dictionary():
+    d = {"a": 4, "b": 2, "c": 1, "d": 1, "e": 1, "f": 2, "g": 2}
+    result = {4: {'a'}, 2: {'b', 'f', 'g'}, 1: {'c', 'd', 'e'}}
+    assert (a.invert_dictionary(d) == result)
+    print(a.invert_dictionary(d))
+
+
+def test_word_count():
+   # assert (a.word_count('data/alice.txt') == (17, 1615, 8449))
+    assert (a.word_count('data/alice.txt') == (17, 1615, 8461))
+
+
+def test_matrix_multiplication():
+    A = [[2, 3, 4], [6, 4, 2], [-1, 2, 0]]
+    B = [[8, -3, 1], [-7, 3, 2], [0, 3, 3]]
+    answer = [[-5, 15, 20], [20, 0, 20], [-22, 9, 3]]
+    assert(a.matrix_multiplication(A, B) == answer)
+
+def test_array_work():
+    matrixA = np.array([[-4, -2],
+                        [0, -3],
+                        [-4, -1],
+                        [-1, 1],
+                        [-3, 0]])
+    answer1 = np.array([[-24, -24, -24],
+                        [-12, -12, -12],
+                        [-20, -20, -20],
+                        [0, 0, 0],
+                        [-12, -12, -12]])
+    result1 = a.array_work(2, 3, 4, matrixA)
+    assert (np.all(answer1 == result1))
+
+    answer2 = np.array([[-36, -36],
+                        [-18, -18],
+                        [-30, -30],
+                        [0, 0],
+                        [-18, -18]])
+    result2 = a.array_work(2, 2, 6, matrixA)
+    assert (np.all(answer2 == result2))
+
+
+def test_make_series():
+    result = a.make_series(7, 4, ['a', 'b', 'c', 'd'])
+    assert (isinstance(result, pd.Series))
+    assert (result['a'] == 7)
+    assert (result['d'] == 10)
+
+    result = a.make_series(22, 5, ['a', 'b', 'c', 'd', 'hi'])
+    assert (result['a'] == 22)
+    assert (result['d'] == 25)
+    assert (result['hi'] == 26)
+
+
+def test_data_frame_work():
+    df = pd.DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
+    colA, colB, colC = ('a', 'b', 'c')
+    result = a.data_frame_work(df, colA, colB, colC)
+    assert (colC in result.columns.tolist())
+    assert (result[colC].tolist() == [5, 7, 9])
+
+
+def test_boolean_indexing():
+    arr = np.array([[-4, -4, -3],
+                    [-1, 16, -4],
+                    [-3, 6, 4]])
+    result1 = a.boolean_indexing(arr, 0)
+    answer1 = np.array([16, 6, 4])
+    assert (np.all(result1 == answer1))
+    result2 = a.boolean_indexing(arr, 10)
+    answer2 = np.array([16])
+    assert (np.all(result2 == answer2))
diff --git a/titanic.ipynb b/titanic.ipynb
new file mode 100644
index 0000000..344bc37
--- /dev/null
+++ b/titanic.ipynb
@@ -0,0 +1,1097 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 117,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import statsmodels.api as sm\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.metrics import r2_score\n",
+    "from pandas.plotting import scatter_matrix\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 118,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>PassengerId</th>\n",
+       "      <th>Survived</th>\n",
+       "      <th>Pclass</th>\n",
+       "      <th>Name</th>\n",
+       "      <th>Sex</th>\n",
+       "      <th>Age</th>\n",
+       "      <th>SibSp</th>\n",
+       "      <th>Parch</th>\n",
+       "      <th>Ticket</th>\n",
+       "      <th>Fare</th>\n",
+       "      <th>Cabin</th>\n",
+       "      <th>Embarked</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>Braund, Mr. Owen Harris</td>\n",
+       "      <td>male</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>A/5 21171</td>\n",
+       "      <td>7.2500</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>S</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>Cumings, Mrs. John Bradley (Florence Briggs Th...</td>\n",
+       "      <td>female</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>PC 17599</td>\n",
+       "      <td>71.2833</td>\n",
+       "      <td>C85</td>\n",
+       "      <td>C</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>1</td>\n",
+       "      <td>3</td>\n",
+       "      <td>Heikkinen, Miss. Laina</td>\n",
+       "      <td>female</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>STON/O2. 3101282</td>\n",
+       "      <td>7.9250</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>S</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>Futrelle, Mrs. Jacques Heath (Lily May Peel)</td>\n",
+       "      <td>female</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>113803</td>\n",
+       "      <td>53.1000</td>\n",
+       "      <td>C123</td>\n",
+       "      <td>S</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>Allen, Mr. William Henry</td>\n",
+       "      <td>male</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>373450</td>\n",
+       "      <td>8.0500</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>S</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   PassengerId  Survived  Pclass  \\\n",
+       "0            1         0       3   \n",
+       "1            2         1       1   \n",
+       "2            3         1       3   \n",
+       "3            4         1       1   \n",
+       "4            5         0       3   \n",
+       "\n",
+       "                                                Name     Sex   Age  SibSp  \\\n",
+       "0                            Braund, Mr. Owen Harris    male  22.0      1   \n",
+       "1  Cumings, Mrs. John Bradley (Florence Briggs Th...  female  38.0      1   \n",
+       "2                             Heikkinen, Miss. Laina  female  26.0      0   \n",
+       "3       Futrelle, Mrs. Jacques Heath (Lily May Peel)  female  35.0      1   \n",
+       "4                           Allen, Mr. William Henry    male  35.0      0   \n",
+       "\n",
+       "   Parch            Ticket     Fare Cabin Embarked  \n",
+       "0      0         A/5 21171   7.2500   NaN        S  \n",
+       "1      0          PC 17599  71.2833   C85        C  \n",
+       "2      0  STON/O2. 3101282   7.9250   NaN        S  \n",
+       "3      0            113803  53.1000  C123        S  \n",
+       "4      0            373450   8.0500   NaN        S  "
+      ]
+     },
+     "execution_count": 118,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_csv('train.csv')\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 119,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(891, 12)"
+      ]
+     },
+     "execution_count": 119,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 120,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 891 entries, 0 to 890\n",
+      "Data columns (total 12 columns):\n",
+      "PassengerId    891 non-null int64\n",
+      "Survived       891 non-null int64\n",
+      "Pclass         891 non-null int64\n",
+      "Name           891 non-null object\n",
+      "Sex            891 non-null object\n",
+      "Age            714 non-null float64\n",
+      "SibSp          891 non-null int64\n",
+      "Parch          891 non-null int64\n",
+      "Ticket         891 non-null object\n",
+      "Fare           891 non-null float64\n",
+      "Cabin          204 non-null object\n",
+      "Embarked       889 non-null object\n",
+      "dtypes: float64(2), int64(5), object(5)\n",
+      "memory usage: 83.6+ KB\n"
+     ]
+    }
+   ],
+   "source": [
+    "df.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 121,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = df.drop(columns=['PassengerId', 'Name', 'Ticket', 'Cabin'])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 122,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>count</th>\n",
+       "      <th>mean</th>\n",
+       "      <th>std</th>\n",
+       "      <th>min</th>\n",
+       "      <th>25%</th>\n",
+       "      <th>50%</th>\n",
+       "      <th>75%</th>\n",
+       "      <th>max</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Survived</th>\n",
+       "      <td>891.0</td>\n",
+       "      <td>0.383838</td>\n",
+       "      <td>0.486592</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1.0000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Pclass</th>\n",
+       "      <td>891.0</td>\n",
+       "      <td>2.308642</td>\n",
+       "      <td>0.836071</td>\n",
+       "      <td>1.00</td>\n",
+       "      <td>2.0000</td>\n",
+       "      <td>3.0000</td>\n",
+       "      <td>3.0</td>\n",
+       "      <td>3.0000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Age</th>\n",
+       "      <td>714.0</td>\n",
+       "      <td>29.699118</td>\n",
+       "      <td>14.526497</td>\n",
+       "      <td>0.42</td>\n",
+       "      <td>20.1250</td>\n",
+       "      <td>28.0000</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>80.0000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>SibSp</th>\n",
+       "      <td>891.0</td>\n",
+       "      <td>0.523008</td>\n",
+       "      <td>1.102743</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>8.0000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Parch</th>\n",
+       "      <td>891.0</td>\n",
+       "      <td>0.381594</td>\n",
+       "      <td>0.806057</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>6.0000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Fare</th>\n",
+       "      <td>891.0</td>\n",
+       "      <td>32.204208</td>\n",
+       "      <td>49.693429</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>7.9104</td>\n",
+       "      <td>14.4542</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>512.3292</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "          count       mean        std   min      25%      50%   75%       max\n",
+       "Survived  891.0   0.383838   0.486592  0.00   0.0000   0.0000   1.0    1.0000\n",
+       "Pclass    891.0   2.308642   0.836071  1.00   2.0000   3.0000   3.0    3.0000\n",
+       "Age       714.0  29.699118  14.526497  0.42  20.1250  28.0000  38.0   80.0000\n",
+       "SibSp     891.0   0.523008   1.102743  0.00   0.0000   0.0000   1.0    8.0000\n",
+       "Parch     891.0   0.381594   0.806057  0.00   0.0000   0.0000   0.0    6.0000\n",
+       "Fare      891.0  32.204208  49.693429  0.00   7.9104  14.4542  31.0  512.3292"
+      ]
+     },
+     "execution_count": 122,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.describe().T"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 123,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0xe4d42e8>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df.hist();"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 124,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0xe6cb358>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "scatter_matrix(df);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 125,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 891 entries, 0 to 890\n",
+      "Data columns (total 8 columns):\n",
+      "Survived    891 non-null int64\n",
+      "Pclass      891 non-null int64\n",
+      "Sex         891 non-null object\n",
+      "Age         891 non-null float64\n",
+      "SibSp       891 non-null int64\n",
+      "Parch       891 non-null int64\n",
+      "Fare        891 non-null float64\n",
+      "Embarked    889 non-null object\n",
+      "dtypes: float64(2), int64(4), object(2)\n",
+      "memory usage: 55.8+ KB\n"
+     ]
+    }
+   ],
+   "source": [
+    "Age_median = df.Age.median()\n",
+    "df.Age.fillna(Age_median, inplace=True)\n",
+    "df.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 126,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "S    644\n",
+       "C    168\n",
+       "Q     77\n",
+       "Name: Embarked, dtype: int64"
+      ]
+     },
+     "execution_count": 126,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.Embarked.value_counts()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 127,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x000000000E08D9E8>,\n",
+       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000000000C384198>],\n",
+       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x000000000C928400>,\n",
+       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000000000CB85CF8>],\n",
+       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x000000000DFCED68>,\n",
+       "        <matplotlib.axes._subplots.AxesSubplot object at 0x000000000DFCEDA0>]],\n",
+       "      dtype=object)"
+      ]
+     },
+     "execution_count": 127,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<matplotlib.figure.Figure at 0xe04e978>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df.hist()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 128,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "y = df.Survived\n",
+    "X = df.drop(columns = 'Survived')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 129,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0    0\n",
+       "1    1\n",
+       "2    1\n",
+       "3    1\n",
+       "4    0\n",
+       "Name: Survived, dtype: int64"
+      ]
+     },
+     "execution_count": 129,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "y.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 130,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Pclass</th>\n",
+       "      <th>Sex</th>\n",
+       "      <th>Age</th>\n",
+       "      <th>SibSp</th>\n",
+       "      <th>Parch</th>\n",
+       "      <th>Fare</th>\n",
+       "      <th>Embarked</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>3</td>\n",
+       "      <td>male</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7.2500</td>\n",
+       "      <td>S</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1</td>\n",
+       "      <td>female</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>71.2833</td>\n",
+       "      <td>C</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>female</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7.9250</td>\n",
+       "      <td>S</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1</td>\n",
+       "      <td>female</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>53.1000</td>\n",
+       "      <td>S</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>3</td>\n",
+       "      <td>male</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>8.0500</td>\n",
+       "      <td>S</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   Pclass     Sex   Age  SibSp  Parch     Fare Embarked\n",
+       "0       3    male  22.0      1      0   7.2500        S\n",
+       "1       1  female  38.0      1      0  71.2833        C\n",
+       "2       3  female  26.0      0      0   7.9250        S\n",
+       "3       1  female  35.0      1      0  53.1000        S\n",
+       "4       3    male  35.0      0      0   8.0500        S"
+      ]
+     },
+     "execution_count": 130,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 131,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>const</th>\n",
+       "      <th>Pclass</th>\n",
+       "      <th>Age</th>\n",
+       "      <th>SibSp</th>\n",
+       "      <th>Parch</th>\n",
+       "      <th>Fare</th>\n",
+       "      <th>Sex_female</th>\n",
+       "      <th>Embarked_C</th>\n",
+       "      <th>Embarked_Q</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>22.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7.2500</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>38.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>71.2833</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7.9250</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>53.1000</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>35.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>8.0500</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   const  Pclass   Age  SibSp  Parch     Fare  Sex_female  Embarked_C  \\\n",
+       "0    1.0       3  22.0      1      0   7.2500           0           0   \n",
+       "1    1.0       1  38.0      1      0  71.2833           1           1   \n",
+       "2    1.0       3  26.0      0      0   7.9250           1           0   \n",
+       "3    1.0       1  35.0      1      0  53.1000           1           0   \n",
+       "4    1.0       3  35.0      0      0   8.0500           0           0   \n",
+       "\n",
+       "   Embarked_Q  \n",
+       "0           0  \n",
+       "1           0  \n",
+       "2           0  \n",
+       "3           0  \n",
+       "4           0  "
+      ]
+     },
+     "execution_count": 131,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X = pd.get_dummies(X)\n",
+    "X = X.drop(columns=['Sex_male', 'Embarked_S'])\n",
+    "X = sm.add_constant(X)\n",
+    "X.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 132,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.33, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 133,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "((596, 9), (295, 9))"
+      ]
+     },
+     "execution_count": 133,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_train.shape, X_test.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 134,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
+       "          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
+       "          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n",
+       "          verbose=0, warm_start=False)"
+      ]
+     },
+     "execution_count": 134,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model = LogisticRegression()\n",
+    "model.fit(X_train,y_train)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 135,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0, 0, 0, 1, 1, 1, 1, 0, 1, 1], dtype=int64)"
+      ]
+     },
+     "execution_count": 135,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.predict(X_test)[:10]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 137,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>const</th>\n",
+       "      <th>Pclass</th>\n",
+       "      <th>Age</th>\n",
+       "      <th>SibSp</th>\n",
+       "      <th>Parch</th>\n",
+       "      <th>Fare</th>\n",
+       "      <th>Sex_female</th>\n",
+       "      <th>Embarked_C</th>\n",
+       "      <th>Embarked_Q</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>709</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>15.2458</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>439</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>31.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>10.5000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>840</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>20.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7.9250</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>720</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>6.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>33.0000</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>39</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>14.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>11.2417</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>290</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>26.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>78.8500</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>300</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>28.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7.7500</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>333</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>0</td>\n",
+       "      <td>18.0000</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>208</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>16.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7.7500</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>136</th>\n",
+       "      <td>1.0</td>\n",
+       "      <td>1</td>\n",
+       "      <td>19.0</td>\n",
+       "      <td>0</td>\n",
+       "      <td>2</td>\n",
+       "      <td>26.2833</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     const  Pclass   Age  SibSp  Parch     Fare  Sex_female  Embarked_C  \\\n",
+       "709    1.0       3  28.0      1      1  15.2458           0           1   \n",
+       "439    1.0       2  31.0      0      0  10.5000           0           0   \n",
+       "840    1.0       3  20.0      0      0   7.9250           0           0   \n",
+       "720    1.0       2   6.0      0      1  33.0000           1           0   \n",
+       "39     1.0       3  14.0      1      0  11.2417           1           1   \n",
+       "290    1.0       1  26.0      0      0  78.8500           1           0   \n",
+       "300    1.0       3  28.0      0      0   7.7500           1           0   \n",
+       "333    1.0       3  16.0      2      0  18.0000           0           0   \n",
+       "208    1.0       3  16.0      0      0   7.7500           1           0   \n",
+       "136    1.0       1  19.0      0      2  26.2833           1           0   \n",
+       "\n",
+       "     Embarked_Q  \n",
+       "709           0  \n",
+       "439           0  \n",
+       "840           0  \n",
+       "720           0  \n",
+       "39            0  \n",
+       "290           0  \n",
+       "300           1  \n",
+       "333           0  \n",
+       "208           1  \n",
+       "136           0  "
+      ]
+     },
+     "execution_count": 137,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "X_test[:10]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 138,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.8135593220338984"
+      ]
+     },
+     "execution_count": 138,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.score(X_test, y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}