吴恩达-深度学习-logistic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import math\n",
    "import h5py\n",
    "import matplotlib.pyplot as plt\n",
    "from lr_utils import load_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_dataset():\n",
    "    train_dataset = h5py.File('datasets/train_catvnoncat.h5', \"r\")\n",
    "    train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n",
    "    train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n",
    "\n",
    "    test_dataset = h5py.File('datasets/test_catvnoncat.h5', \"r\")\n",
    "    test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n",
    "    test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n",
    "\n",
    "    classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n",
    "    \n",
    "    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n",
    "    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n",
    "    \n",
    "    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = load_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#由数据集获取一些基本参数，如训练样本数m，图片大小：\n",
    "m_train = train_set_x_orig.shape[0]  #训练集大小209\n",
    "m_test = test_set_x_orig.shape[0]    #测试集大小50\n",
    "num_px = train_set_x_orig.shape[1]  #图片宽度64，大小是64×64\n",
    "#将图片数据向量化（扁平化）：\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",
    "#对数据进行标准化：\n",
    "train_set_x = train_set_x_flatten/255.\n",
    "test_set_x = test_set_x_flatten/255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "209"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义激活函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    A=1/(1+np.exp(-z))\n",
    "    return A\n",
    "#好耶只有写出来的这个部分和答案是一样的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigmoid(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 参数初始化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_with_zeros(dim):\n",
    "    w=np.zeros((dim,1))\n",
    "    b=0\n",
    "    return w,b\n",
    "#dim是参数的维度"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 前向传播"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def propagate(w, b, X, Y):\n",
    "    \"\"\"\n",
    "    传参:\n",
    "    w -- 权重, shape： (num_px * num_px * 3, 1)\n",
    "    b -- 偏置项, 一个标量\n",
    "    X -- 数据集，shape： (num_px * num_px * 3, m),m为样本数\n",
    "    Y -- 真实标签，shape： (1,m)\n",
    "\n",
    "    返回值:\n",
    "    cost， dw ，db，后两者放在一个字典grads里\n",
    "    \"\"\"\n",
    "    #获取样本数m：\n",
    "    m = X.shape[1]\n",
    "\n",
    "    # 前向传播 ：\n",
    "    A = sigmoid(np.dot(w.T,X)+b)    #调用前面写的sigmoid函数    \n",
    "    cost = -(np.sum(Y*np.log(A)+(1-Y)*np.log(1-A)))/m                 \n",
    "\n",
    "    # 反向传播：\n",
    "    dZ = A-Y\n",
    "    dw = (np.dot(X,dZ.T))/m\n",
    "    db = (np.sum(dZ))/m\n",
    "\n",
    "    #返回值：\n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "\n",
    "    return grads, cost"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 优化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):\n",
    "    #定义一个costs数组，存放每若干次迭代后的cost，从而可以画图看看cost的变化趋势：\n",
    "    costs = []\n",
    "    #进行迭代：\n",
    "    for i in range(num_iterations):\n",
    "        # 用propagate计算出每次迭代后的cost和梯度：\n",
    "        grads, cost = propagate(w,b,X,Y)\n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "\n",
    "        # 用上面得到的梯度来更新参数：\n",
    "        w = w - learning_rate*dw\n",
    "        b = b - learning_rate*db\n",
    "\n",
    "        # 每100次迭代，保存一个cost看看：\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "\n",
    "        # 这个可以不在意，我们可以每100次把cost打印出来看看，从而随时掌握模型的进展：\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))\n",
    "    #迭代完毕，将最终的各个参数放进字典，并返回：\n",
    "    params = {\"w\": w,\n",
    "              \"b\": b}\n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}\n",
    "    return params, grads, costs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 预测函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(w,b,X):\n",
    "    m = X.shape[1]\n",
    "    Y_prediction = np.zeros((1,m))\n",
    "\n",
    "    A = sigmoid(np.dot(w.T,X)+b)\n",
    "    for  i in range(m):\n",
    "        if A[0,i]>0.5:\n",
    "            Y_prediction[0,i] = 1\n",
    "        else:\n",
    "            Y_prediction[0,i] = 0\n",
    "\n",
    "    return Y_prediction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 结合所有函数搭建模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logistic_model(X_train,Y_train,X_test,Y_test,learning_rate=0.1,num_iterations=2000,print_cost=False):\n",
    "    #获特征维度，初始化参数：\n",
    "    dim = X_train.shape[0]\n",
    "    w,b = initialize_with_zeros(dim)\n",
    "\n",
    "    #梯度下降，迭代求出模型参数：\n",
    "    params,grads,costs = optimize(w,b,X_train,Y_train,num_iterations,learning_rate,print_cost)\n",
    "    w = params['w']\n",
    "    b = params['b']\n",
    "\n",
    "    #用学得的参数进行预测：\n",
    "    prediction_train = predict(w,b,X_train)\n",
    "    prediction_test = predict(w,b,X_test)\n",
    "\n",
    "    #计算准确率，分别在训练集和测试集上：\n",
    "    accuracy_train = 1 - np.mean(np.abs(prediction_train - Y_train))\n",
    "    accuracy_test = 1 - np.mean(np.abs(prediction_test - Y_test))\n",
    "    print(\"Accuracy on train set:\",accuracy_train )\n",
    "    print(\"Accuracy on test set:\",accuracy_test )\n",
    "\n",
    "   #为了便于分析和检查，我们把得到的所有参数、超参数都存进一个字典返回出来：\n",
    "    d = {\"costs\": costs,\n",
    "         \"Y_prediction_test\": prediction_test , \n",
    "         \"Y_prediction_train\" : prediction_train , \n",
    "         \"w\" : w, \n",
    "         \"b\" : b,\n",
    "         \"learning_rate\" : learning_rate,\n",
    "         \"num_iterations\": num_iterations,\n",
    "         \"train_acy\": accuracy_train,\n",
    "         \"test_acy\": accuracy_test\n",
    "        }\n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "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",
      "Accuracy on train set: 0.9904306220095693\n",
      "Accuracy on test set: 0.7\n"
     ]
    }
   ],
   "source": [
    "d = logistic_model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 稍微检查一下维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "dim = train_set_x.shape[0]\n",
    "w,b = initialize_with_zeros(dim)\n",
    "prediction_train = predict(w,b,test_set_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 50)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prediction_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 209)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set_y.shape"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}