diff --git a/Introduction/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb b/Introduction/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb
index 96a4a75..79b01cd 100644
--- a/Introduction/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb	
+++ b/Introduction/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb	
@@ -34,7 +34,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -69,7 +69,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -88,9 +88,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "y = [1], it's a 'cat' picture.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Example of a picture\n",
     "index = 25\n",
@@ -113,16 +133,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {
     "scrolled": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Number of training examples: m_train = 209\n",
+      "Number of testing examples: m_test = 50\n",
+      "Height/Width of each image: num_px = 64\n",
+      "Each image is of size: (64, 64, 3)\n",
+      "train_set_x shape: (209, 64, 64, 3)\n",
+      "train_set_y shape: (1, 209)\n",
+      "test_set_x shape: (50, 64, 64, 3)\n",
+      "test_set_y shape: (1, 50)\n"
+     ]
+    }
+   ],
    "source": [
     "### START CODE HERE ### (≈ 3 lines of code)\n",
-    "m_train = None\n",
-    "m_test = None\n",
-    "num_px = None\n",
+    "m_train = train_set_x_orig.shape[0]\n",
+    "m_test = test_set_x_orig.shape[0]\n",
+    "num_px = train_set_x_orig.shape[1]\n",
     "### END CODE HERE ###\n",
     "\n",
     "print (\"Number of training examples: m_train = \" + str(m_train))\n",
@@ -175,15 +210,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train_set_x_flatten shape: (12288, 209)\n",
+      "train_set_y shape: (1, 209)\n",
+      "test_set_x_flatten shape: (12288, 50)\n",
+      "test_set_y shape: (1, 50)\n",
+      "sanity check after reshaping: [17 31 56 22 33]\n"
+     ]
+    }
+   ],
    "source": [
     "# Reshape the training and test examples\n",
     "\n",
     "### START CODE HERE ### (≈ 2 lines of code)\n",
-    "train_set_x_flatten = None\n",
-    "test_set_x_flatten = None\n",
+    "train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T\n",
+    "test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T\n",
     "### END CODE HERE ###\n",
     "\n",
     "print (\"train_set_x_flatten shape: \" + str(train_set_x_flatten.shape))\n",
@@ -238,7 +285,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -312,7 +359,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -330,7 +377,7 @@
     "    \"\"\"\n",
     "\n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    s = None\n",
+    "    s = 1/(1 + np.exp(-z))\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return s"
@@ -338,11 +385,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {
     "scrolled": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sigmoid([0, 2]) = [0.5        0.88079708]\n"
+     ]
+    }
+   ],
    "source": [
     "print (\"sigmoid([0, 2]) = \" + str(sigmoid(np.array([0,2]))))"
    ]
@@ -372,7 +427,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -391,8 +446,8 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    w = None\n",
-    "    b = None\n",
+    "    w = np.zeros((dim, 1))\n",
+    "    b = 0\n",
     "    ### END CODE HERE ###\n",
     "\n",
     "    assert(w.shape == (dim, 1))\n",
@@ -403,9 +458,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "w = [[0.]\n",
+      " [0.]]\n",
+      "b = 0\n"
+     ]
+    }
+   ],
    "source": [
     "dim = 2\n",
     "w, b = initialize_with_zeros(dim)\n",
@@ -460,7 +525,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -489,14 +554,14 @@
     "    \n",
     "    # FORWARD PROPAGATION (FROM X TO COST)\n",
     "    ### START CODE HERE ### (≈ 2 lines of code)\n",
-    "    A = None                                    # compute activation\n",
-    "    cost = None                                 # compute cost\n",
+    "    A = sigmoid(np.dot(w.T, X) + b)                             # compute activation\n",
+    "    cost = - np.mean(Y * np.log(A) + (1 - Y) * np.log(1 - A))   # compute cost\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    # BACKWARD PROPAGATION (TO FIND GRAD)\n",
     "    ### START CODE HERE ### (≈ 2 lines of code)\n",
-    "    dw = None\n",
-    "    db = None\n",
+    "    dw = np.dot(X, (A - Y).T) / m\n",
+    "    db = np.mean(A - Y)\n",
     "    ### END CODE HERE ###\n",
     "\n",
     "    assert(dw.shape == w.shape)\n",
@@ -512,9 +577,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dw = [[0.99845601]\n",
+      " [2.39507239]]\n",
+      "db = 0.001455578136784208\n",
+      "cost = 5.801545319394553\n"
+     ]
+    }
+   ],
    "source": [
     "w, b, X, Y = np.array([[1.],[2.]]), 2., np.array([[1.,2.,-1.],[3.,4.,-3.2]]), np.array([[1,0,1]])\n",
     "grads, cost = propagate(w, b, X, Y)\n",
@@ -561,7 +637,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -598,7 +674,7 @@
     "        \n",
     "        # Cost and gradient calculation (≈ 1-4 lines of code)\n",
     "        ### START CODE HERE ### \n",
-    "        grads, cost = None\n",
+    "        grads, cost = propagate(w, b, X, Y)\n",
     "        ### END CODE HERE ###\n",
     "        \n",
     "        # Retrieve derivatives from grads\n",
@@ -607,8 +683,8 @@
     "        \n",
     "        # update rule (≈ 2 lines of code)\n",
     "        ### START CODE HERE ###\n",
-    "        w = None\n",
-    "        b = None\n",
+    "        w = w - learning_rate * dw\n",
+    "        b = b - learning_rate * db\n",
     "        ### END CODE HERE ###\n",
     "        \n",
     "        # Record the costs\n",
@@ -630,9 +706,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 14,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "w = [[0.19033591]\n",
+      " [0.12259159]]\n",
+      "b = 1.9253598300845747\n",
+      "dw = [[0.67752042]\n",
+      " [1.41625495]]\n",
+      "db = 0.21919450454067657\n"
+     ]
+    }
+   ],
    "source": [
     "params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)\n",
     "\n",
@@ -685,7 +774,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -710,14 +799,14 @@
     "    \n",
     "    # Compute vector \"A\" predicting the probabilities of a cat being present in the picture\n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    A = None\n",
+    "    A = sigmoid(np.dot(w.T, X) + b)\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    for i in range(A.shape[1]):\n",
     "        \n",
     "        # Convert probabilities A[0,i] to actual predictions p[0,i]\n",
     "        ### START CODE HERE ### (≈ 4 lines of code)\n",
-    "        pass\n",
+    "        Y_prediction = np.round(A)\n",
     "        ### END CODE HERE ###\n",
     "    \n",
     "    assert(Y_prediction.shape == (1, m))\n",
@@ -727,9 +816,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 16,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "predictions = [[1. 1. 0.]]\n"
+     ]
+    }
+   ],
    "source": [
     "w = np.array([[0.1124579],[0.23106775]])\n",
     "b = -0.3\n",
@@ -788,7 +885,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -814,18 +911,18 @@
     "    ### START CODE HERE ###\n",
     "    \n",
     "    # initialize parameters with zeros (≈ 1 line of code)\n",
-    "    w, b = None\n",
+    "    w, b = initialize_with_zeros(X_train.shape[0])\n",
     "\n",
     "    # Gradient descent (≈ 1 line of code)\n",
-    "    parameters, grads, costs = None\n",
+    "    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n",
     "    \n",
     "    # Retrieve parameters w and b from dictionary \"parameters\"\n",
     "    w = parameters[\"w\"]\n",
     "    b = parameters[\"b\"]\n",
     "    \n",
     "    # Predict test/train set examples (≈ 2 lines of code)\n",
-    "    Y_prediction_test = None\n",
-    "    Y_prediction_train = None\n",
+    "    Y_prediction_test = predict(w, b, X_test)\n",
+    "    Y_prediction_train = predict(w, b, X_train)\n",
     "\n",
     "    ### END CODE HERE ###\n",
     "\n",
@@ -854,9 +951,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 20,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Cost after iteration 0: 0.693147\n",
+      "Cost after iteration 100: 0.584508\n",
+      "Cost after iteration 200: 0.466949\n",
+      "Cost after iteration 300: 0.376007\n",
+      "Cost after iteration 400: 0.331463\n",
+      "Cost after iteration 500: 0.303273\n",
+      "Cost after iteration 600: 0.279880\n",
+      "Cost after iteration 700: 0.260042\n",
+      "Cost after iteration 800: 0.242941\n",
+      "Cost after iteration 900: 0.228004\n",
+      "Cost after iteration 1000: 0.214820\n",
+      "Cost after iteration 1100: 0.203078\n",
+      "Cost after iteration 1200: 0.192544\n",
+      "Cost after iteration 1300: 0.183033\n",
+      "Cost after iteration 1400: 0.174399\n",
+      "Cost after iteration 1500: 0.166521\n",
+      "Cost after iteration 1600: 0.159305\n",
+      "Cost after iteration 1700: 0.152667\n",
+      "Cost after iteration 1800: 0.146542\n",
+      "Cost after iteration 1900: 0.140872\n",
+      "train accuracy: 99.043062201 %\n",
+      "test accuracy: 70.0 %\n"
+     ]
+    }
+   ],
    "source": [
     "d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
    ]
@@ -904,9 +1030,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 21,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "IndexError",
+     "evalue": "only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m----------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mIndexError\u001b[0m                           Traceback (most recent call last)",
+      "\u001b[0;32m<ipython-input-21-50a2ff1ec91d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mindex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_set_x\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnum_px\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_px\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"y = \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_set_y\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\", you predicted that it is a \\\"\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mclasses\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"Y_prediction_test\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"utf-8\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m  \u001b[0;34m\"\\\" picture.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;31mIndexError\u001b[0m: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Example of a picture that was wrongly classified.\n",
     "index = 1\n",
@@ -923,9 +1073,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 22,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Plot learning curve (with costs)\n",
     "costs = np.squeeze(d['costs'])\n",
@@ -969,9 +1132,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "learning rate is: 0.01\n",
+      "train accuracy: 99.5215311005 %\n",
+      "test accuracy: 68.0 %\n",
+      "\n",
+      "-------------------------------------------------------\n",
+      "\n",
+      "learning rate is: 0.001\n",
+      "train accuracy: 88.995215311 %\n",
+      "test accuracy: 64.0 %\n",
+      "\n",
+      "-------------------------------------------------------\n",
+      "\n",
+      "learning rate is: 0.0001\n",
+      "train accuracy: 68.4210526316 %\n",
+      "test accuracy: 36.0 %\n",
+      "\n",
+      "-------------------------------------------------------\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "learning_rates = [0.01, 0.001, 0.0001]\n",
     "models = {}\n",
@@ -1022,14 +1222,48 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 24,
    "metadata": {
     "scrolled": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/vladislavovich_d/.local/lib/python2.7/site-packages/ipykernel_launcher.py:7: DeprecationWarning: `imread` is deprecated!\n",
+      "`imread` is deprecated in SciPy 1.0.0.\n",
+      "Use ``matplotlib.pyplot.imread`` instead.\n",
+      "  import sys\n",
+      "/home/vladislavovich_d/.local/lib/python2.7/site-packages/ipykernel_launcher.py:8: DeprecationWarning: `imresize` is deprecated!\n",
+      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.3.0.\n",
+      "Use Pillow instead: ``numpy.array(Image.fromarray(arr).resize())``.\n",
+      "  \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "y = 1.0, your algorithm predicts a \"cat\" picture.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "## START CODE HERE ## (PUT YOUR IMAGE NAME) \n",
-    "my_image = \"my_image.jpg\"   # change this to the name of your image file \n",
+    "my_image = \"Cat_March.jpg\"   # change this to the name of your image file \n",
     "## END CODE HERE ##\n",
     "\n",
     "# We preprocess the image to fit your algorithm.\n",
@@ -1087,14 +1321,14 @@
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
-    "version": 3
+    "version": 2
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "pygments_lexer": "ipython2",
+   "version": "2.7.15rc1"
   }
  },
  "nbformat": 4,
diff --git a/Introduction/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb b/Introduction/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb
index f99e4d1..c25739b 100644
--- a/Introduction/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb	
+++ b/Introduction/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb	
@@ -38,24 +38,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 1,
+   "metadata": {},
    "outputs": [],
    "source": [
     "### START CODE HERE ### (≈ 1 line of code)\n",
-    "test = None\n",
+    "test = 'Hello Word!'\n",
     "### END CODE HERE ###"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "test: Hello Word!\n"
+     ]
+    }
+   ],
    "source": [
     "print (\"test: \" + test)"
    ]
@@ -103,10 +107,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": true
-   },
+   "execution_count": 3,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: basic_sigmoid\n",
@@ -125,7 +127,7 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    s = None\n",
+    "    s = 1 / (1 + math.exp(-x))\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return s"
@@ -133,11 +135,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9525741268224334"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "basic_sigmoid(3)"
    ]
@@ -165,11 +176,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9525741268224334"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "### One reason why we use \"numpy\" instead of \"math\" in Deep Learning ###\n",
     "x = [1, 2, 3]\n",
@@ -185,11 +205,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ 2.71828183  7.3890561  20.08553692]\n"
+     ]
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "\n",
@@ -207,11 +233,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[4 5 6]\n"
+     ]
+    }
+   ],
    "source": [
     "# example of vector operation\n",
     "x = np.array([1, 2, 3])\n",
@@ -244,10 +276,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 8,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: sigmoid\n",
@@ -266,7 +296,7 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    s = None\n",
+    "    s = 1 / (1 + np.exp(-x))\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return s"
@@ -274,11 +304,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.73105858, 0.88079708, 0.95257413])"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "x = np.array([1, 2, 3])\n",
     "sigmoid(x)"
@@ -313,10 +352,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 10,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: sigmoid_derivative\n",
@@ -334,8 +371,8 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 2 lines of code)\n",
-    "    s = None\n",
-    "    ds = None\n",
+    "    s = sigmoid(x)\n",
+    "    ds = s*(1-s)\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return ds"
@@ -343,11 +380,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sigmoid_derivative(x) = [0.19661193 0.10499359 0.04517666]\n"
+     ]
+    }
+   ],
    "source": [
     "x = np.array([1, 2, 3])\n",
     "print (\"sigmoid_derivative(x) = \" + str(sigmoid_derivative(x)))"
@@ -392,10 +435,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 12,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: image2vector\n",
@@ -409,7 +450,7 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    v = None\n",
+    "    v = image.reshape((image.shape[0]*image.shape[1] * image.shape[2], 1))\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return v"
@@ -417,11 +458,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "image2vector(image) = [[0.67826139 0.29380381]\n",
+      " [0.90714982 0.52835647]\n",
+      " [0.4215251  0.45017551]\n",
+      " [0.92814219 0.96677647]\n",
+      " [0.85304703 0.52351845]\n",
+      " [0.19981397 0.27417313]\n",
+      " [0.60659855 0.00533165]\n",
+      " [0.10820313 0.49978937]\n",
+      " [0.34144279 0.94630077]]\n"
+     ]
+    }
+   ],
    "source": [
     "# This is a 3 by 3 by 2 array, typically images will be (num_px_x, num_px_y,3) where 3 represents the RGB values\n",
     "image = np.array([[[ 0.67826139,  0.29380381],\n",
@@ -499,10 +554,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 14,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: normalizeRows\n",
@@ -520,10 +573,10 @@
     "    \n",
     "    ### START CODE HERE ### (≈ 2 lines of code)\n",
     "    # Compute x_norm as the norm 2 of x. Use np.linalg.norm(..., ord = 2, axis = ..., keepdims = True)\n",
-    "    x_norm = None\n",
+    "    x_norm = np.linalg.norm(x, ord = 2, axis = 1, keepdims = True)\n",
     "    \n",
     "    # Divide x by its norm.\n",
-    "    x = None\n",
+    "    x = x / x_norm\n",
     "    ### END CODE HERE ###\n",
     "\n",
     "    return x"
@@ -531,11 +584,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "normalizeRows(x) = [[0.         0.6        0.8       ]\n",
+      " [0.13736056 0.82416338 0.54944226]]\n"
+     ]
+    }
+   ],
    "source": [
     "x = np.array([\n",
     "    [0, 3, 4],\n",
@@ -616,10 +676,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 16,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: softmax\n",
@@ -638,13 +696,13 @@
     "    \n",
     "    ### START CODE HERE ### (≈ 3 lines of code)\n",
     "    # Apply exp() element-wise to x. Use np.exp(...).\n",
-    "    x_exp = None\n",
+    "    x_exp = np.exp(x)\n",
     "\n",
     "    # Create a vector x_sum that sums each row of x_exp. Use np.sum(..., axis = 1, keepdims = True).\n",
-    "    x_sum = None\n",
+    "    x_sum = np.sum(x_exp, axis = 1, keepdims = True)\n",
     "    \n",
     "    # Compute softmax(x) by dividing x_exp by x_sum. It should automatically use numpy broadcasting.\n",
-    "    s = None\n",
+    "    s = x_exp / x_sum\n",
     "\n",
     "    ### END CODE HERE ###\n",
     "    \n",
@@ -653,11 +711,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "softmax(x) = [[9.80897665e-01 8.94462891e-04 1.79657674e-02 1.21052389e-04\n",
+      "  1.21052389e-04]\n",
+      " [8.78679856e-01 1.18916387e-01 8.01252314e-04 8.01252314e-04\n",
+      "  8.01252314e-04]]\n"
+     ]
+    }
+   ],
    "source": [
     "x = np.array([\n",
     "    [9, 2, 5, 0, 0],\n",
@@ -726,11 +793,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dot = 278\n",
+      " ----- Computation time = 0.0673680000000676ms\n",
+      "outer = [[81. 18. 18. 81.  0. 81. 18. 45.  0.  0. 81. 18. 45.  0.  0.]\n",
+      " [18.  4.  4. 18.  0. 18.  4. 10.  0.  0. 18.  4. 10.  0.  0.]\n",
+      " [45. 10. 10. 45.  0. 45. 10. 25.  0.  0. 45. 10. 25.  0.  0.]\n",
+      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
+      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
+      " [63. 14. 14. 63.  0. 63. 14. 35.  0.  0. 63. 14. 35.  0.  0.]\n",
+      " [45. 10. 10. 45.  0. 45. 10. 25.  0.  0. 45. 10. 25.  0.  0.]\n",
+      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
+      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
+      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
+      " [81. 18. 18. 81.  0. 81. 18. 45.  0.  0. 81. 18. 45.  0.  0.]\n",
+      " [18.  4.  4. 18.  0. 18.  4. 10.  0.  0. 18.  4. 10.  0.  0.]\n",
+      " [45. 10. 10. 45.  0. 45. 10. 25.  0.  0. 45. 10. 25.  0.  0.]\n",
+      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]\n",
+      " [ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]]\n",
+      " ----- Computation time = 0.16967300000003682ms\n",
+      "elementwise multiplication = [81.  4. 10.  0.  0. 63. 10.  0.  0.  0. 81.  4. 25.  0.  0.]\n",
+      " ----- Computation time = 0.08760699999998955ms\n",
+      "gdot = [20.00637658 18.31545745 15.4553908 ]\n",
+      " ----- Computation time = 0.11664000000011221ms\n"
+     ]
+    }
+   ],
    "source": [
     "import time\n",
     "\n",
@@ -775,11 +869,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dot = 278\n",
+      " ----- Computation time = 0.09319599999990658ms\n",
+      "outer = [[81 18 18 81  0 81 18 45  0  0 81 18 45  0  0]\n",
+      " [18  4  4 18  0 18  4 10  0  0 18  4 10  0  0]\n",
+      " [45 10 10 45  0 45 10 25  0  0 45 10 25  0  0]\n",
+      " [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]\n",
+      " [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]\n",
+      " [63 14 14 63  0 63 14 35  0  0 63 14 35  0  0]\n",
+      " [45 10 10 45  0 45 10 25  0  0 45 10 25  0  0]\n",
+      " [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]\n",
+      " [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]\n",
+      " [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]\n",
+      " [81 18 18 81  0 81 18 45  0  0 81 18 45  0  0]\n",
+      " [18  4  4 18  0 18  4 10  0  0 18  4 10  0  0]\n",
+      " [45 10 10 45  0 45 10 25  0  0 45 10 25  0  0]\n",
+      " [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]\n",
+      " [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]]\n",
+      " ----- Computation time = 0.07306399999995605ms\n",
+      "elementwise multiplication = [81  4 10  0  0 63 10  0  0  0 81  4 25  0  0]\n",
+      " ----- Computation time = 0.09439800000010656ms\n",
+      "gdot = [20.00637658 18.31545745 15.4553908 ]\n",
+      " ----- Computation time = 0.05885400000016361ms\n"
+     ]
+    }
+   ],
    "source": [
     "x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]\n",
     "x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]\n",
@@ -834,10 +955,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 20,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: L1\n",
@@ -853,7 +972,7 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    loss = None\n",
+    "    loss = np.sum(np.abs(yhat - y))\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return loss"
@@ -861,11 +980,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "L1 = 1.1\n"
+     ]
+    }
+   ],
    "source": [
     "yhat = np.array([.9, 0.2, 0.1, .4, .9])\n",
     "y = np.array([1, 0, 0, 1, 1])\n",
@@ -898,10 +1023,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 22,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: L2\n",
@@ -917,7 +1040,7 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    loss = None\n",
+    "    loss = np.dot((yhat - y),(yhat - y))\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return loss"
@@ -925,11 +1048,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "L2 = 0.43\n"
+     ]
+    }
+   ],
    "source": [
     "yhat = np.array([.9, 0.2, 0.1, .4, .9])\n",
     "y = np.array([1, 0, 0, 1, 1])\n",
@@ -966,6 +1095,13 @@
     "- You have reviewed the L1 and L2 loss.\n",
     "- You are familiar with many numpy functions such as np.sum, np.dot, np.multiply, np.maximum, etc..."
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -989,7 +1125,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.7"
   }
  },
  "nbformat": 4,
diff --git a/Introduction/python_highlighter/LICENSE b/Introduction/python_highlighter/LICENSE
new file mode 100644
index 0000000..f76f894
--- /dev/null
+++ b/Introduction/python_highlighter/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Oleksii
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Introduction/python_highlighter/README.md b/Introduction/python_highlighter/README.md
new file mode 100644
index 0000000..23b51a5
--- /dev/null
+++ b/Introduction/python_highlighter/README.md
@@ -0,0 +1,95 @@
+Highlighter
+===
+
+Sample Python application that demonstrate the possibility to find and mark text sequence in web page
+
+## Table of contents
+
+- [Before you go](#before-you-go)
+- [Install](#install)
+- [How to un](#how-to-run)
+- [Tests](#tests)
+- [Code style check](#code-style-check)
+- [TODO](#todo)
+
+## Before you go
+
+Before to go you should set up your local environment.
+
+- Fork repository by clicking the **Fork** button on the upper right-hand side of the repository’s page. See an example [here](https://help.github.com/en/articles/fork-a-repo#fork-an-example-repository) **NOTE!** All actions described below **MUST** be applied to the **!!!FORKED!!!** repository!!!
+- Clone forked repository to your local system ([hint](https://help.github.com/en/articles/fork-a-repo#step-2-create-a-local-clone-of-your-fork)).
+- Go to the project' directory
+
+```buildoutcfg
+cd python_highlighter
+```
+
+
+## Install
+
+To install dependencies run:
+
+```buildoutcfg
+pip install -r requirements.txt
+```
+
+(Optionally) install highlighter:
+
+```buildoutcfg
+pip install -e .
+```
+
+## How to run
+
+To run highlighter app (On Windows use **set** instead of **export**):
+```buildoutcfg
+export FLASK_APP=highlighter
+flask run
+```
+
+then go to [localhost:5000](localhost:5000)
+
+![image](example.png)
+
+## Tests
+The application contains tests. To run tests:
+```buildoutcfg
+pytest -v
+```
+
+## Code style check
+Code **must** satisfy [PEP008](https://www.python.org/dev/peps/pep-0008/) code style requirements
+
+```buildoutcfg
+pylint -r y **/*.py
+```
+## TODO
+
+**NOTE**
+Before to start your work you must should perform all steps described in [Before you go](#before-you-go) section.
+
+<span style="color:red">**CAUTION** All actions described below **MUST** be applied to the **!!!FORKED!!!** repository!!!</span>
+
+Next, perform steps below:
+
+ - Create **dev** branch. You can do it either via Pycharm' menu (see the Pycharm how to for details) or via terminal like this:
+ ```buildoutcfg
+ git checkout master
+ git pull
+ git checkout -b dev
+```
+ - Add an implementation to methods in the **\_\_init__.py** module that covers the demands
+    - markup_text
+    - highlight_text
+ - Add tests to the implemented methods in the **tests/test_highlighter.py** module. You can find examples of tests on [Flask testing howto](http://flask.pocoo.org/docs/1.0/testing/) page.
+ - Run tests
+ - Run code check
+ - Commit and push your local changes to the remote **git** repository. You can do it either via Pycharm view (**Ctrl + K**) or via terminal 
+ ```buildoutcfg
+git commit -a -m 'type your commit message here'
+git push origin dev
+```
+ - Create **MR** (merge request). See how to do it [here](https://docs.gitlab.com/ee/gitlab-basics/add-merge-request.html)
+ - Add @onidzelskyi as a collaborator with write access rights.
+ - Send the link to the **MR** to your reviewer
+ 
diff --git a/Introduction/python_highlighter/example.png b/Introduction/python_highlighter/example.png
new file mode 100644
index 0000000..37ff103
Binary files /dev/null and b/Introduction/python_highlighter/example.png differ
diff --git a/Introduction/python_highlighter/highlighter/__init__.py b/Introduction/python_highlighter/highlighter/__init__.py
new file mode 100644
index 0000000..cef6405
--- /dev/null
+++ b/Introduction/python_highlighter/highlighter/__init__.py
@@ -0,0 +1,56 @@
+"""Flask module
+file: __init__.py
+date: 12.12.2012
+author smith@example.com
+license: MIT"""
+
+from flask import Flask, render_template, request, Markup
+
+
+def create_app():
+
+    app = Flask(__name__)
+
+    template_file_name = 'index.html'
+
+    @app.route('/', methods=['GET'])
+    def index():
+        return render_template(template_file_name)
+
+    @app.route('/', methods=['POST'])
+    def process():
+        search_text = request.form['search']
+        text = request.form['text']
+        highlighted_text = highlight_text(text, search_text)
+        result = {'text': text,
+                  'highlighted_text': Markup(highlighted_text),
+                  }
+        return render_template(template_file_name, **result)
+
+    def markup_text(text):
+        """Markup given text.
+        This is supplementary method that helps you to wrap marked text in tags.
+        @:param text - string text to be marked
+        @:return marked text, e.g., <mark>highlighted text</mark>."""
+        result = text
+
+        # TODO: add an implementation
+        result = "<mark>{}</mark>".format(text)
+        return result
+
+    def highlight_text(text, expr):
+        """Markup searched string in given text.
+        @:param text - string text to be processed (e.g., 'The sun in the sky')
+        @:param expr - string pattern to be searched in the text (e.g., 'th')
+        @:return marked text, e.g., "<mark>Th</mark>e sun in <mark>th</mark>e sky"."""
+        result = text
+
+        # TODO: add an implementation
+        mc = set(re.findall(expr, text, flags=re.IGNORECASE))
+        for i in mc:
+
+           result = re.sub(i, markup_text(i), result)
+
+        return result
+
+    return app
diff --git a/Introduction/python_highlighter/highlighter/__init__.pyc b/Introduction/python_highlighter/highlighter/__init__.pyc
new file mode 100644
index 0000000..aaaa7d7
Binary files /dev/null and b/Introduction/python_highlighter/highlighter/__init__.pyc differ
diff --git a/Introduction/python_highlighter/highlighter/templates/index.html b/Introduction/python_highlighter/highlighter/templates/index.html
new file mode 100644
index 0000000..eefc405
--- /dev/null
+++ b/Introduction/python_highlighter/highlighter/templates/index.html
@@ -0,0 +1,25 @@
+<html>
+<body>
+<form action="http://localhost:5000/" method="POST">
+    <table cellspacing=24>
+        <tr>
+            <td>
+                <p>Search string <input type="text" name="search" onchange="this.form.submit()"/></p>
+            </td>
+            <td>
+            </td>
+        </tr>
+        <tr>
+            <td>
+                <p><textarea rows="40" cols="50" name="text" style="width: 400px; height: 400px;">{{ text }}</textarea></p>
+            </td>
+            <td style="vertical-align: top; text-align: justify">
+                <div style="width: 400px; height: 400px;">
+                    <p>{{ highlighted_text }}</p>
+                </div>
+            </td>
+        </tr>
+    </table>
+</form>
+</body>
+</html>
\ No newline at end of file
diff --git a/Introduction/python_highlighter/requirements.txt b/Introduction/python_highlighter/requirements.txt
new file mode 100644
index 0000000..4c481db
--- /dev/null
+++ b/Introduction/python_highlighter/requirements.txt
@@ -0,0 +1,2 @@
+flask>=1.0
+pytest
\ No newline at end of file
diff --git a/Introduction/python_highlighter/setup.py b/Introduction/python_highlighter/setup.py
new file mode 100644
index 0000000..0d537b6
--- /dev/null
+++ b/Introduction/python_highlighter/setup.py
@@ -0,0 +1,12 @@
+from setuptools import find_packages, setup
+
+setup(
+    name='highlighter',
+    version='1.0.0',
+    packages=find_packages(),
+    include_package_data=True,
+    zip_safe=False,
+    install_requires=[
+        'flask',
+    ],
+)
diff --git a/Introduction/python_highlighter/tests/__pycache__/test_highlighter.cpython-27-PYTEST.pyc b/Introduction/python_highlighter/tests/__pycache__/test_highlighter.cpython-27-PYTEST.pyc
new file mode 100644
index 0000000..2720527
Binary files /dev/null and b/Introduction/python_highlighter/tests/__pycache__/test_highlighter.cpython-27-PYTEST.pyc differ
diff --git a/Introduction/python_highlighter/tests/test_highlighter.py b/Introduction/python_highlighter/tests/test_highlighter.py
new file mode 100644
index 0000000..b74fd36
--- /dev/null
+++ b/Introduction/python_highlighter/tests/test_highlighter.py
@@ -0,0 +1,36 @@
+"""Test module
+file: test_highlighter.py
+date: 12.12.2012
+author smith@example.com
+license: MIT"""
+
+import unittest
+from highlighter import create_app
+
+
+class HighlightTest(unittest.TestCase):
+    """Test class for flask app."""
+
+    def setUp(self):
+        """This method is called each time the test routine run"""
+        self.app = create_app().test_client()
+        # TODO: add the missing test data in this routine
+        self.highlighted_text = b'Sample <mark>text</mark> to be highlighted'
+        self.search_text = b'Text'
+        self.text = b'Sample text to be highlighted'
+
+    def tearDown(self):
+        """This method is called after the test routine is finished
+        to clear out the data created in setUp method."""
+        # TODO: add an implementation
+        del self.app
+        del self.highlighted_text
+        del self.text
+        del self.search_text
+
+
+def test_markup_text(self):
+        """Test markup process"""
+        response = self.app.post('/', data={'search': self.search_text,
+                                            'text': self.text})
+        self.assertIn(self.highlighted_text, response.data)