From 32262eb99e79b4fdb4c4056c788155b6736c5646 Mon Sep 17 00:00:00 2001
From: vasylcf <vasylcf.gmail.com>
Date: Thu, 21 Mar 2019 21:44:14 +0200
Subject: [PATCH 1/3] add implementation into python_basics_with_numpy

---
 .../Python Basics With Numpy v3.ipynb         | 364 ++++++++++++------
 1 file changed, 246 insertions(+), 118 deletions(-)

diff --git a/Week_1/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb b/Week_1/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb
index f99e4d1..23416c9 100644
--- a/Week_1/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb	
+++ b/Week_1/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 World\"\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 World\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)"
    ]
@@ -166,9 +177,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "metadata": {},
    "outputs": [],
    "source": [
     "### One reason why we use \"numpy\" instead of \"math\" in Deep Learning ###\n",
@@ -185,11 +194,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[ 2.71828183  7.3890561  20.08553692]\n"
+     ]
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "\n",
@@ -207,11 +222,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 6,
+   "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 +265,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 7,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: sigmoid\n",
@@ -266,7 +285,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 +293,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([0.73105858, 0.88079708, 0.95257413])"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "x = np.array([1, 2, 3])\n",
     "sigmoid(x)"
@@ -313,10 +341,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 9,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: sigmoid_derivative\n",
@@ -334,8 +360,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 +369,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 10,
+   "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 +424,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 13,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: image2vector\n",
@@ -409,7 +439,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 +447,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "image2vector(image) = [[0.67826139]\n",
+      " [0.29380381]\n",
+      " [0.90714982]\n",
+      " [0.52835647]\n",
+      " [0.4215251 ]\n",
+      " [0.45017551]\n",
+      " [0.92814219]\n",
+      " [0.96677647]\n",
+      " [0.85304703]\n",
+      " [0.52351845]\n",
+      " [0.19981397]\n",
+      " [0.27417313]\n",
+      " [0.60659855]\n",
+      " [0.00533165]\n",
+      " [0.10820313]\n",
+      " [0.49978937]\n",
+      " [0.34144279]\n",
+      " [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 +552,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 17,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: normalizeRows\n",
@@ -520,10 +571,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 +582,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(2, 3)\n",
+      "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 +675,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 20,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: softmax\n",
@@ -638,13 +695,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 = x_exp.sum(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 +710,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 21,
+   "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 +792,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dot = 278\n",
+      " ----- Computation time = 0.0ms\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.0ms\n",
+      "elementwise multiplication = [81.  4. 10.  0.  0. 63. 10.  0.  0.  0. 81.  4. 25.  0.  0.]\n",
+      " ----- Computation time = 0.0ms\n",
+      "gdot = [18.11512508 19.85321541 24.67605789]\n",
+      " ----- Computation time = 0.0ms\n"
+     ]
+    }
+   ],
    "source": [
     "import time\n",
     "\n",
@@ -775,11 +868,38 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dot = 278\n",
+      " ----- Computation time = 0.0ms\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.0ms\n",
+      "elementwise multiplication = [81  4 10  0  0 63 10  0  0  0 81  4 25  0  0]\n",
+      " ----- Computation time = 0.0ms\n",
+      "gdot = [18.11512508 19.85321541 24.67605789]\n",
+      " ----- Computation time = 0.0ms\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 +954,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 24,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: L1\n",
@@ -853,7 +971,7 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    loss = None\n",
+    "    loss = np.sum(abs(y-yhat))\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return loss"
@@ -861,11 +979,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 25,
+   "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 +1022,8 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
+   "execution_count": 26,
+   "metadata": {},
    "outputs": [],
    "source": [
     "# GRADED FUNCTION: L2\n",
@@ -917,7 +1039,7 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    loss = None\n",
+    "    loss = np.sum((y-yhat)**2)\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return loss"
@@ -925,11 +1047,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [],
+   "execution_count": 27,
+   "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",
@@ -989,7 +1117,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.5.2"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,

From 64ff33d2445d747325a7b09976f4b81cab5220b4 Mon Sep 17 00:00:00 2001
From: vasylcf <vasylcf.gmail.com>
Date: Sat, 23 Mar 2019 21:03:37 +0200
Subject: [PATCH 2/3] logistic regression

---
 ...ion with a Neural Network mindset v5.ipynb | 353 +++++++++++++++---
 .../images/cat.jpg                            | Bin 0 -> 5131 bytes
 .../Python_basic_with_numpy/temp_numpy.ipynb  | 200 ++++++++++
 3 files changed, 491 insertions(+), 62 deletions(-)
 create mode 100644 Week_1/Logistic_regression_as_a_neural_network/images/cat.jpg
 create mode 100644 Week_1/Python_basic_with_numpy/temp_numpy.ipynb

diff --git a/Week_1/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb b/Week_1/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb
index 96a4a75..a9301ce 100644
--- a/Week_1/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb	
+++ b/Week_1/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb	
@@ -34,9 +34,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Vasyl\\Anaconda2\\envs\\python_3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
+      "  from ._conv import register_converters as _register_converters\n"
+     ]
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
@@ -69,7 +78,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -88,9 +97,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "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": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Example of a picture\n",
     "index = 25\n",
@@ -113,16 +140,51 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(209, 64, 64, 3)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "train_set_x_orig.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
    "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 +237,27 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 18,
    "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 +312,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 25,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -312,7 +386,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 30,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -330,7 +404,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 +412,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 31,
    "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 +454,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 34,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -391,8 +473,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 +485,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 35,
    "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 +552,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -488,15 +580,15 @@
     "    m = X.shape[1]\n",
     "    \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",
+    "    ### START CODE HERE ### (≈ 2 lines of code) \n",
+    "    A = sigmoid(np.dot(w.T,X)+b)                # compute activation A=sigma(w.T*X +b)\n",
+    "    cost = (-1/m)*np.sum(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 = (1/m)*np.dot(X,(A-Y).T)\n",
+    "    db = (1/m)*np.sum(A-Y)\n",
     "    ### END CODE HERE ###\n",
     "\n",
     "    assert(dw.shape == w.shape)\n",
@@ -512,9 +604,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 39,
    "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 +664,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 40,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -598,7 +701,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 +710,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 +733,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 41,
    "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 +801,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 49,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -710,14 +826,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[0,i] = 1 if A[0,i]>0.5 else 0\n",
     "        ### END CODE HERE ###\n",
     "    \n",
     "    assert(Y_prediction.shape == (1, m))\n",
@@ -727,9 +843,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 50,
    "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 +912,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 53,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -814,18 +938,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 = False)\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 +978,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 54,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train accuracy: 99.04306220095694 %\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,14 +1037,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 79,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "y = 1, you predicted that it is a \"cat\" picture.\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Example of a picture that was wrongly classified.\n",
-    "index = 1\n",
+    "index = 4\n",
     "plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))\n",
-    "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[d[\"Y_prediction_test\"][0,index]].decode(\"utf-8\") +  \"\\\" picture.\")"
+    "print (\"y = \" + str(test_set_y[0,index]) + \", you predicted that it is a \\\"\" + classes[int(d[\"Y_prediction_test\"][0,index])].decode(\"utf-8\") +  \"\\\" picture.\")"
    ]
   },
   {
@@ -923,9 +1074,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 87,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "# Plot learning curve (with costs)\n",
     "costs = np.squeeze(d['costs'])\n",
@@ -969,9 +1131,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 88,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "learning rate is: 0.01\n",
+      "train accuracy: 99.52153110047847 %\n",
+      "test accuracy: 68.0 %\n",
+      "\n",
+      "-------------------------------------------------------\n",
+      "\n",
+      "learning rate is: 0.001\n",
+      "train accuracy: 88.99521531100478 %\n",
+      "test accuracy: 64.0 %\n",
+      "\n",
+      "-------------------------------------------------------\n",
+      "\n",
+      "learning rate is: 0.0001\n",
+      "train accuracy: 68.42105263157895 %\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": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "learning_rates = [0.01, 0.001, 0.0001]\n",
     "models = {}\n",
@@ -1022,14 +1219,46 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 90,
    "metadata": {
     "scrolled": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Vasyl\\Anaconda2\\envs\\python_3\\lib\\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",
+      "C:\\Users\\Vasyl\\Anaconda2\\envs\\python_3\\lib\\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.2.0.\n",
+      "Use ``skimage.transform.resize`` instead.\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": {},
+     "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.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",
@@ -1094,7 +1323,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.6.5"
   }
  },
  "nbformat": 4,
diff --git a/Week_1/Logistic_regression_as_a_neural_network/images/cat.jpg b/Week_1/Logistic_regression_as_a_neural_network/images/cat.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..38d910c46f421a5813f4ed0f76e1e36777bd161f
GIT binary patch
literal 5131
zcmbtWWmMGBxBW3gNl7zw_Yeb$bb~W=3rKgTgrbyEGPIN+NJ+;q5+Vpl4KagAH<C&y
zA&v6z|K56Qz0Ysob=Eoeo_+T@>wdWFT+dvu0F+vq2u%PF4-bIfEa3VZV5br4?g9V^
zgb+Xs000Pp;ei06n~3km+~e>8yc;iiWB*{_?r0xq4**~QNF@UBZ%)J|B*Z~)|C?oc
zvj_iAtb7yy!}UC%_OIUm3;#s^UjqLwUv~ji#DFqj3dZ9CKvZ~OD!l7nfE57n@WD6l
z@xQnQ5D}B$6A*$)Z_<L400;!SVE~{T(mxg$A4GshNJLCUO#|GbrQ;%@=VaiPyrDAv
z%l{uG0(?9$A&BTECq{K6g9rW(2>w$E4+N&-1n{W|Xkc6_hJ+ISwDwVScZ{ObicsCx
za{w6_@1{pE6`%y1UjtWJe-sY(*sygAHkP6>c_ee~uP2cS?M&i&ji|<tgbadeYwWY}
z<iR@_kRJ7sgLIZZaoXXit@@Q}oZ!Bz-1MxG#9L^Kr!40$?Ma@6ZJf7~=?FFWT@<6$
z_P5UQZ8n8~p0T}!jKdd~l{(^b(f6aG@dnRN{z_IgdoTr&;nDV*qwMUaJC9QG-5|5y
zJQoX0-Ob{2^!y)^;L$yocY*K)NOuA8f%2<LN1Z2Ga%wWYMe$cZEi~T?*XXYr8B5Tv
zn1^%rz&PYc9K~IrT10=BtS^ToQ%+(7<4*@^C!cW5UW9KqUes5R-%G7No0jwL)6iQY
zd3SI>6dmVy#;jw1M|9O`H#_n+uN-q%21g#pKB$MyDse21FCgOHy>h=%)}=k!ZL?eH
zt6$&9uzIw~(Z~I0vhy5N!l^(Jm~Nce-yPcUrh|M(s$njf7_Wo9SdpQ=*B>$H2yTXa
zcj;~$9o1;_m-R2}J%QQLet%1*R?E`yy|b}lf<k)-PJDuxH8NylcIxH1qeSve%dY|p
zMbAc1NPDIjYSSE;wXcU}^0ViV&OfdKL%cZu<in9T;;nw^UrUgY&Q1UL*Lzz(_$xGa
z6Aa&d(|uQb>oX>s4*l{gpv(E9wLzmrmu}aS#DYy3ya)Q+sv(e<xQ~50pl|SmujDh!
z+fk}XrN6@w^$3$+2rC-6`i!lKy}N;^a-BOZ^a3P}P%coV<uF7b^^Et^g)`0P(=I!(
zfbw8h%}V&dLA`gRMW*r{34m{O^<X_*X_+W-_jkvz^6Z_CDA^b>j!C)qqtvCwJUO*a
z{=Ed^FL0E50{8KL&=P{ORHDlAFTf&96ISkVwH__x6|bG!68rCPD1H*?|4hD;n)#gC
zNhlhw3C7WJXyUZoH!TiqXJyio?*AySkYj^1ZPaP=y3%=Qdmhh=SeFn!%_AFg&cs4c
zn(@4DNGv!7pL@;3EdwtjF#1TaxBr--{E=t5k$;(UcuVu41`cH$s&EZ>qi4i8#v64e
zQ&pZnDIf$suq)(zMUW*Sy3P|zxPif~@_Yx)BsO=M54`p!8O_}WYptr|1a*ALKF40#
zJgJP<!I%ai0ZDZEBe|~?@a|wI^3hCx10wF!JJNeWGj21nOcKm4W!Vi*V(!J<U6QX*
zWYu;uAZRt0BS$Zfn=;WZgyM0pB-#6?nEhR;SIGjRFo!7O9?~f1wR}W27CPdAbUf-E
z76`#fLRH1%o@&C7HbZ*@CS}bt==)|r?rQg-d7EOL#fD9awl;ZI#^(L@h}A}5@>wuJ
zUI<R6xBXTu(JLPhF)70)tyf=k?s`<GQs(k>^hm1bx1*6Ed(_CsIBphg@sW1NjkTEc
z*&bTHR|T64KS@tHc!U>Y>k;?NtJ#BhW}M9oNbBDQc&x%{*GaW7<m!%t<NgOvZ5gl^
z!rB|t*Fe8zrm#)sWB>fHfa4IOhg7=fOur!>49K%&Vf%)`w<>)Uq39@)czCaXcH~NK
zzde(|(>B+$i7(QMsZXL8`nb>}e*<T!%&G}EG6TAOB-aQDE&~Zhl}sAX)EH~opURi#
zMvSDav%;q)lWgmh)+V5TkJq;s<4)PX`(8~ZJ#L=2q<Ftsj*+d(qxgU}ePh995`Z$-
zS-XU4XR6U3;cu#Ba3Liu?h9qhjQ9&sI%L1I7Bb7*9B(b5F`iGxeNB5CW3JpBjYao?
zZ@qBq{(-FeOpS}sy6Zvh%tjwV)n)YSQ`eLD+bXXK(L<NAVddQALs#iB4=*NNutJLw
z1}`5qOJ#^a^Q?2kyLl>##B=B>E!9L_!5T>7?$9SXPh(bCj<wNKlV6qtc2R9Rv~V?U
zDbzr-Z$DF#NbU^G?8D6Ka!9SW4=7r#z|x$Qe}@8M2V&%~SjxKRBcL*jDl&BiB}mbZ
z;d1Yc7(DB;pi6}v+4#XClKd5{1GWr1g#0`DkNfgDI|BYBzG`+;-GWXxRc!k-mkyy%
zAMJ?u53SJ1!*WRJx{V1^>dX?mK4f>D{|*|DqYXTjJ7SkUYEo&zSx=wP1xuUleTIMM
z4QiF~w094+WE?<~^_8JsDVd0OgzLfkB0~FB9+Dy-FYC_IgUbCSu&vZE3McTb3cG?5
zRmiU#=1T`d+*3)GE$V*%dFj2bfnpqJ>|Eq;X{bk5c}mE<kerrv49Tp$h^H5MUZutG
ziD{y=g(r)A0Wm*5WQ)<cCY@lAcOzy2YA}>f<~11*%kzc%t4f!Vxaa!gDLIW&%?*3<
zefy}@9QFVT-9j(-^F`^Fa`LIwBJXP;G4#l1)~l+luE;y0?(3Ynh}9Hn`ef2HzNRTy
zsVKRdO@U`5k!4E)rwK0%91kJ81~wKZ6&u<fd`sd^ZryQR6f~L3cQtzX(3b&9CRZ2W
zuxFf~)mBq$gy!(xS#l33@+y0Qe9Hk(p>loG_GdymF*isz#7-fGplwIGqxQ;Rc-SzS
zr)xm6ic!5bl7?r4;~F^NR7r4_8KPksnjEdGlU``~t5UX=C{*A%S^GPE8}Y!9{P^s-
z^VF`X_rf*Mx|0o+lJ<!TC#w@4xzj6@nog+J{T4np$<m(kPBkht5=<3rvbLTd=D5u8
z=%gEAF{?sC^0ILh1C(%OB|x85Jkh&rO7g}y&i5h#UGc6#Uw@UpIn3R&crx3P3d{79
zC7~}QSoPCfak^s<B-cO8p6=*Y#%~xXj3~m~XnYNO`s3hFV(^8t!`r%PZ}wF9&g72N
zHSipoLpLcdACJi3;y<VyC4EAu(Ffb4;;`x&-wQv$S|x<_J{t7A()Mgv)T*i_kNoM<
z5ZNfrpeNXDC~vXpi8F>dh2j%H@;xYU+8D1O_A+$QA&bDn-hJB@;rzdA9G6M4UR?5P
zvnh-bDvs2taKDwDe2#!nSLqNBN4a6@!|*;x6j4g_NG~bWi-eyY3p(Yq{X*v!X>+D9
zZXds<6&WU$ab8cCb$j*flUU++Yq4yRYk*D9vgV5{%~qSsJbB>B(?1w`(>lvAlahh0
zRU3%GVZbyeSGB!bE{KgW3-WU76zLLwL}sl0ZRBEWV|e<B@w#I6`*4|><&!^K*}=87
z<-u(;=rXs7W?6PtgZjp~#sPckejP*e*jfT7$@T72iM>!i>Q~_(gnLk;k(7Kle_SNB
zocsc+i}d+n_?UB~&~LXa@9&y-{oy76!j-O1nNjN5C+Hfk_HtqrZmRHPhsC1wP;&vR
zmsIC<Y?a_=ZC&XsY%ZoZV_A~BIHJr`qhhBt?4Q&4Ws1~T*J*vURgHPKbJsTNNzj_Z
z@5J$#7_&i4SFN!=o&bgIv8b3<6R*%0=G|naH+hf7h{q~QqXLQZ`hBzT*wja;CQd#z
z-07`2Q}FR^4Kt}Mjd}L1)*Eiok@om=kZec&YJs6%t`Szcrkb>pqZfp4e=dnsa{tZS
z8&=3ZGyU_aUK{xWDY;|lRD;)UYD1%7a#&s>aii^oX}r>O3^R@UNa~<VzH`3Q)4ZVM
zJhCr*-^v&6GsBYa2$@2ou&)}?NTOA5j2*di(0Bx537!tQgzo~-?wT)bd7!9HxbJ&P
z{a;0bJ=cKaB4R(oa-y)A@Jm*^k&|Q#XSRD$ZbD`bE9!(QP=e-foVcwt(obAdp^TV~
zg6bOJq+oaIo{%AIJdDaVwi@?Ykd|uyxa9Bx%|Jg4RW}$J_`#+^yd^Ul$N<BIKNv4)
zv)f=}n3pWI+zDowtS8am$#V!=w`}|w8}LGP*g?^Wm)%B^vi89+mCz=C0a5BJi@dwe
zW6OeX&zMkCN%zg2yB*}_#&s}A=l~(vKs?qSmVO(;=SZ2snB`vx9Ufjg)czWh22J`9
zqh3A8%Bse^ssNu>r^X|A4EB5wEiivf-X25GXjMXBXP5&{@gwG#USR6@S^WUhwBhqg
zwrH&gG-0VQ);wpmkvP$9wYP1$n}VOc>ESmll!{8`PuKE`Y=2rV9~yE-BD?%OyHr$s
zb=dkeS>}F#u~YSkuD(S?$H%b5L_G0e;WPp^iXk*nvsYCGrHP?+0Fz7MJEHt*f3;`W
z_u0*D?{eF{Ck3YGm}-$Ed+W5W0t^rck}6e^L*D*YDx}{*np*vymt98B`J<C@rk7t~
zEkDiVSPMWs6K26)R+AzUpZz}bS;swm#e?cKN0!J$!--cUiKQxqIdA<4t8G8Pyg`_O
zhBmlWA^iZSRa0>+OO(7h-fBvs<Kq20I`wFmRM4$pTBfenE_$ukr`JG9SW=36R5u|T
zjp7+0Y4dja)zr2`JA%M9n^s`X$!iMHcESr<X^@|Fad`1C@{=-!uK>1<EZTd3`?c0p
z7^|ob+=a(SF%72{^$gtWAGLBQ_;J%B*L9h-99P(XIm)ZZ8mv*RcYaksr-H^*2^A>v
z=10Lg>;j;C8yPsN!Ls~B>0UedmZB|Zy-B-v+x|3fZMCmEUrf(jliugH?;jYZ|BCii
ziwnTti|%CeyynLRyvI;1w(}#;RmpZ+9^PMs(7VkCb{9661_&nF$*0OwD*`fOmuGy|
z<$nFEqO0{%bh>}}SEdu$_wO?Q6-!(_n~M5+?oeM|Am6YgEgXV(%OUyG7Hny%)814N
zI)Wjm(G2j+{f3dSQe{-jJW9{9t!yRJ4t?{SqOFsheVW0F<^H%Y+3rHbAamH<`JRmC
zsV@oKBRktk;aOIBiAk8#u?I3zMp$;Dm=`UO#cL+1Xor?Ac>Jr1W5GvO2jy*_{uqg(
zOXhWP>`Q1<Hjh;1XU80shrh}8y=|OyDp3j}UME<0*1(ShcwZv7mbXTeSSx(59@lu@
zn_J3IoeCKWpa&GNp~1P)L&d$%5(1s=uyc=VId|Szl_w@`*b-&AO$I)|KVLqu6|?ja
z<94xof9IK4Z-P+GYKI}0n|-G$qN@5f)jKfzXe=n;4o|euq`C>STM2Qe%OXqGMDxyG
zwp$aaRZ{CUQ0(=UyckVo`esgpj=%7`!lOU>v3({>Zz3rnkRb@lele@?BxDTNu+gvI
zv5Yb|Tz9X0P#Hk?P$!h^osBfgrZPB#mN~L7U(;}xkaUBPV9{;Aq{Qcia&l(-&*5Cs
z&m-S0l+$RdzL?2dn0Im!(FZAX$pubIS^apDJo?fAUzaHsh%N;!XL8(L5HU-%8AOvh
zg?UYhG(iP2X((BF3%c)8XiIN)f&&F=J`|Es_JqEEE~i^|l`JvE_2S58b`$F(?~wJQ
z^uf4j!%iotrlKZVr$<!NtY-BC*$e-}WPl6_%YtzYQ0E*dnMp#s-JWIr7Tp|mY<?K<
zX*a~X8j~x8E%mK4nxY_(>6Jybz~@bm67+9lO!!*4?yhoI16gXZQ_uH|OFWKv91eAJ
zFocD8$$D~2I1AzvXW8J{_$G{ch6!JR(>qscxDn=?ydIbVQ~rHXzhl^Y{IsIo{_ce}
zhLo$~0Rz9Na)ZOJ0)6jW5)Ge}%HJ!I+7nVf-rY)-kr$-qgz@_Vc<O6BO>ex<*>{Yh
zf9=n?o5f8@X{QzI#!!-1mN=EbC>i`vJpAG;s*uKcaZE3cQ%sQNsHerg?+?R%J@ZVx
ziZ8KG$W{YWFq!yS@drjC7v?J6P4qP|H>&}-;5hVKnk18r<az=HU1@&u7t>@(EnnO{
zG^<Xzdv3+@xLy3iIN5&C2ntd4(yyOK3EuxS+OK;fUDcn(`B3R*40K!M-h-iN?_Fvg
z&Y|RCuH<5=joWF~=@OYQDOsT)IS7NaEcWENo1_eFV3w1POUCU9BaUe6dJ~u+EyY|g
z0RDl$Z}d$yorsS!G=?m+u2kZ;sn74QPX+bs$yZ#X9TZN4o`b8Bu3h}b1wUBjtE)@4
zFJjXy5Y`?VKHeh7me{i2Ha#FKkZIVrdYfQ%`3CKex0mkquIg>(BHp7v>%G4QJch8M
zReJCI<wcug>guurB?cWzNv)Bb9<5Hv;vJqJSQZifu3QlFen-k7BP*WxWhZMG4CqTb
znI|ZJ>(kbT*k&%J@);i~ib>7n<tVegRCb;nL1d)jn;*~Qq=6*e<c`tUi(iU|i<(<C
zN^(NmKNY8g+}~@R3QO|2FMWiT#4K3{OG2VHu3QCh3h12|SNG#p>dP)74Cap&Pqw^U
zW0l5nWo1z%HhPZs+d|C<<39bl;-nTno<C|Gv-;yB20l`Uo#A|Iw3y9IbDBQ$6&rKA
Vj00u0n<4yW41304CDnO7`(HOTB7*<`

literal 0
HcmV?d00001

diff --git a/Week_1/Python_basic_with_numpy/temp_numpy.ipynb b/Week_1/Python_basic_with_numpy/temp_numpy.ipynb
new file mode 100644
index 0000000..9b21010
--- /dev/null
+++ b/Week_1/Python_basic_with_numpy/temp_numpy.ipynb
@@ -0,0 +1,200 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Populating the interactive namespace from numpy and matplotlib\n"
+     ]
+    }
+   ],
+   "source": [
+    "%pylab inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=np.linspace(-10,10,100)\n",
+    "y=1/(1+np.exp(-x))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[<matplotlib.lines.Line2D at 0x7f41c6c9e8>]"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(x,y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m=np.array([[0,3,4],[2,6,4]])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[ 7],\n",
+       "       [12]])"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m.sum(axis=1,keepdims=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0.        , 0.6       , 0.8       ],\n",
+       "       [0.26726124, 0.80178373, 0.53452248]])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "norm_m=np.linalg.norm(m,axis=1,keepdims=1)\n",
+    "m/norm_m"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def sigmoid(x):\n",
+    "    \"\"\"\n",
+    "    Compute the sigmoid of x\n",
+    "\n",
+    "    Arguments:\n",
+    "    x -- A scalar or numpy array of any size\n",
+    "\n",
+    "    Return:\n",
+    "    s -- sigmoid(x)\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    ### START CODE HERE ### (≈ 1 line of code)\n",
+    "    s = 1/(1+np.exp(-x))\n",
+    "    ### END CODE HERE ###\n",
+    "    \n",
+    "    return s"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x=np.linspace(-10,10,100)\n",
+    "y=-(np.log(sigmoid(x))+np.log(1-sigmoid(x)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(x,y)\n",
+    "plt.grid=1"
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 98005509e23c29c0600b89faf7f2da085dbea8e3 Mon Sep 17 00:00:00 2001
From: vasylcf <vasylcf.gmail.com>
Date: Mon, 25 Mar 2019 22:57:32 +0200
Subject: [PATCH 3/3] change function model - print_parametr

---
 .../Logistic Regression with a Neural Network mindset v5.ipynb  | 2 +-
 .../Python_basic_with_numpy/Python Basics With Numpy v3.ipynb   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Week_1/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb b/Week_1/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb
index a9301ce..e3d60a9 100644
--- a/Week_1/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb	
+++ b/Week_1/Logistic_regression_as_a_neural_network/Logistic Regression with a Neural Network mindset v5.ipynb	
@@ -941,7 +941,7 @@
     "    w, b = initialize_with_zeros(X_train.shape[0])\n",
     "\n",
     "    # Gradient descent (≈ 1 line of code)\n",
-    "    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost = False)\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",
diff --git a/Week_1/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb b/Week_1/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb
index 23416c9..7be99ce 100644
--- a/Week_1/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb	
+++ b/Week_1/Python_basic_with_numpy/Python Basics With Numpy v3.ipynb	
@@ -971,7 +971,7 @@
     "    \"\"\"\n",
     "    \n",
     "    ### START CODE HERE ### (≈ 1 line of code)\n",
-    "    loss = np.sum(abs(y-yhat))\n",
+    "    loss = np.sum(np.abs(y-yhat))\n",
     "    ### END CODE HERE ###\n",
     "    \n",
     "    return loss"