猫的十二分类.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data7983\r\n"
     ]
    }
   ],
   "source": [
    "# 查看当前挂载的数据集目录\n",
    "!ls /home/aistudio/data/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pretrained\r\n"
     ]
    }
   ],
   "source": [
    "# 查看个人持久化工作区文件\n",
    "!ls /home/aistudio/work/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!unzip data/data7983/cat_12.zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!wget https://paddle-imagenet-models-name.bj.bcebos.com/ResNet101_vd_pretrained.tar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!tar -xvf ResNet101_vd_pretrained.tar -C work/pretrained"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "import paddle as paddle\n",
    "import paddle.fluid as fluid\n",
    "from paddle.fluid.param_attr import ParamAttr\n",
    "import reader\n",
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##生成test.txt\n",
    "#filepath='cat_12/cat_12_test'\n",
    "#pathlist=os.listdir(filepath)\n",
    "#print(pathlist)\n",
    "#with open('cat_12/test_list.txt','w+') as f:\n",
    "    #for file_name in pathlist:\n",
    "        #f.write(file_name+'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11    180\n",
      "9     180\n",
      "7     180\n",
      "5     180\n",
      "3     180\n",
      "1     180\n",
      "10    180\n",
      "8     180\n",
      "6     180\n",
      "4     180\n",
      "2     180\n",
      "0     180\n",
      "Name: 1, dtype: int64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "a=pd.read_table('cat_12/train_list.txt',header=None)\n",
    "print(a[1].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##处理数据集，将原有训练集按二八比例分割\n",
    "with open('cat_12/train_list.txt','r') as f:\n",
    "    with open('cat_12/train_split_list.txt','w+') as train:\n",
    "        lines=f.readlines()\n",
    "    with open('cat_12/train_split_list.txt','w+') as train:\n",
    "        for i in range(0,2160,180):\n",
    "            for line in lines[i:i+135]:\n",
    "                train.write(line)\n",
    "    with open('cat_12/val_split_list.txt','w+') as val:\n",
    "        for i in range(0,2160,180):\n",
    "            for line in lines[i+135:i+180]:\n",
    "                val.write(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11    135\n",
      "10    135\n",
      "9     135\n",
      "8     135\n",
      "7     135\n",
      "6     135\n",
      "5     135\n",
      "4     135\n",
      "3     135\n",
      "2     135\n",
      "1     135\n",
      "0     135\n",
      "Name: 1, dtype: int64\n",
      "11    45\n",
      "10    45\n",
      "9     45\n",
      "8     45\n",
      "7     45\n",
      "6     45\n",
      "5     45\n",
      "4     45\n",
      "3     45\n",
      "2     45\n",
      "1     45\n",
      "0     45\n",
      "Name: 1, dtype: int64\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:1: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n",
      "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:3: FutureWarning: read_table is deprecated, use read_csv instead, passing sep='\\t'.\n",
      "  This is separate from the ipykernel package so we can avoid doing imports until\n"
     ]
    }
   ],
   "source": [
    "train=pd.read_table('cat_12/train_split_list.txt',header=None)\n",
    "print(train[1].value_counts())\n",
    "val=pd.read_table('cat_12/val_split_list.txt',header=None)\n",
    "print(val[1].value_counts())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##获取猫数据\n",
    "train_reader = paddle.batch(reader.train(), batch_size=16)\n",
    "test_reader = paddle.batch(reader.val(), batch_size=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##定义残差网络\n",
    "def resnet(input):\n",
    "    def conv_bn_layer(input, num_filters, filter_size, stride=1, groups=1, act=None, name=None):\n",
    "        conv = fluid.layers.conv2d(input=input,\n",
    "                                   num_filters=num_filters,\n",
    "                                   filter_size=filter_size,\n",
    "                                   stride=stride,\n",
    "                                   padding=(filter_size - 1) // 2,\n",
    "                                   groups=groups,\n",
    "                                   act=None,\n",
    "                                   param_attr=ParamAttr(name=name + \"_weights\"),\n",
    "                                   bias_attr=False,\n",
    "                                   name=name + '.conv2d.output.1')\n",
    "        if name == \"conv1\":\n",
    "            bn_name = \"bn_\" + name\n",
    "        else:\n",
    "            bn_name = \"bn\" + name[3:]\n",
    "        return fluid.layers.batch_norm(input=conv,\n",
    "                                       act=act,\n",
    "                                       name=bn_name + '.output.1',\n",
    "                                       param_attr=ParamAttr(name=bn_name + '_scale'),\n",
    "                                       bias_attr=ParamAttr(bn_name + '_offset'),\n",
    "                                       moving_mean_name=bn_name + '_mean',\n",
    "                                       moving_variance_name=bn_name + '_variance', )\n",
    "\n",
    "    def shortcut(input, ch_out, stride, name):\n",
    "        ch_in = input.shape[1]\n",
    "        if ch_in != ch_out or stride != 1:\n",
    "            return conv_bn_layer(input, ch_out, 1, stride, name=name)\n",
    "        else:\n",
    "            return input\n",
    "            \n",
    "    def bottleneck_block(input, num_filters, stride, name):\n",
    "        conv0 = conv_bn_layer(input=input,\n",
    "                              num_filters=num_filters,\n",
    "                              filter_size=1,\n",
    "                              act='relu',\n",
    "                              name=name + \"_branch2a\")\n",
    "        conv1 = conv_bn_layer(input=conv0,\n",
    "                              num_filters=num_filters,\n",
    "                              filter_size=3,\n",
    "                              stride=stride,\n",
    "                              act='relu',\n",
    "                              name=name + \"_branch2b\")\n",
    "        conv2 = conv_bn_layer(input=conv1,\n",
    "                              num_filters=num_filters * 4,\n",
    "                              filter_size=1,\n",
    "                              act=None,\n",
    "                              name=name + \"_branch2c\")\n",
    "\n",
    "        short = shortcut(input, num_filters * 4, stride, name=name + \"_branch1\")\n",
    "\n",
    "        return fluid.layers.elementwise_add(x=short, y=conv2, act='relu', name=name + \".add.output.5\")\n",
    "\n",
    "    depth = [3, 4, 23, 3]\n",
    "    num_filters = [64, 128, 256, 512]\n",
    "\n",
    "    conv = conv_bn_layer(input=input, num_filters=64, filter_size=7, stride=2, act='relu', name=\"conv1\")\n",
    "    conv = conv_bn_layer(input=input, num_filters=32, filter_size=3, stride=2, act='relu', name='conv1_1')\n",
    "    conv = conv_bn_layer(input=conv, num_filters=32, filter_size=3, stride=1, act='relu', name='conv1_2')\n",
    "    conv = conv_bn_layer(input=conv, num_filters=64, filter_size=3, stride=1, act='relu', name='conv1_3')\n",
    "    conv = fluid.layers.pool2d(input=conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max')\n",
    "\n",
    "    for block in range(len(depth)):\n",
    "        for i in range(depth[block]):\n",
    "            if block == 2:\n",
    "                if i == 0:\n",
    "                    conv_name=\"res\"+str(block+2)+\"a\"\n",
    "                else:\n",
    "                    conv_name=\"res\"+str(block+2)+\"b\"+str(i)\n",
    "            else:\n",
    "                    conv_name=\"res\"+str(block+2)+chr(97+i)\n",
    "            conv = bottleneck_block(input=conv,\n",
    "                                    num_filters=num_filters[block],\n",
    "                                    stride=2 if i == 0 and block != 0 else 1,\n",
    "                                    name=conv_name)\n",
    "\n",
    "    pool = fluid.layers.pool2d(input=conv, pool_size=7, pool_type='avg', global_pooling=True)\n",
    "    return pool\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##定义输入层\n",
    "image=fluid.layers.data(name='image',shape=[3,224,224],dtype='float32')\n",
    "label=fluid.layers.data(name='label',shape=[1],dtype='int64')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##停止梯度下降\n",
    "pool=resnet(image)\n",
    "pool.stop_gradient=True\n",
    "\n",
    "##创建主程序\n",
    "base_model_program=fluid.default_main_program().clone()\n",
    "model=fluid.layers.fc(input=pool,size=12,act='softmax')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##定义损失函数和准确率函数\n",
    "cost=fluid.layers.cross_entropy(input=model,label=label)\n",
    "avg_cost=fluid.layers.mean(cost)\n",
    "acc=fluid.layers.accuracy(input=model,label=label)\n",
    "\n",
    "##定义优化方法\n",
    "optimizer=fluid.optimizer.AdamOptimizer(learning_rate=5e-4)\n",
    "opts=optimizer.minimize(avg_cost)\n",
    "\n",
    "##定义训练场所\n",
    "use_gpu=True\n",
    "place=fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()\n",
    "exe=fluid.Executor(place)\n",
    "\n",
    "##进行参数初始化\n",
    "exe.run(fluid.default_startup_program())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##预训练模型路径\n",
    "src_pretrain_model_path='work/pretrained/ResNet101_vd_pretrained'\n",
    "\n",
    "##判断模型文件是否存在\n",
    "def if_exit(var):\n",
    "    path=os.path.join(src_pretrain_model_path,var.name)\n",
    "    exist=os.path.exists(path)\n",
    "    return exist\n",
    "\n",
    "##加载模型文件，且只加载存在模型的模型文件\n",
    "fluid.io.load_vars(executor=exe,dirname=src_pretrain_model_path,predicate=if_exit,main_program=base_model_program)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "memory_optimize is deprecated. Use CompiledProgram and Executor\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pass:0, Batch:0, Cost:2.31926, Accuracy:0.18750\n",
      "Pass:0, Batch:50, Cost:2.25434, Accuracy:0.25000\n",
      "Pass:0, Batch:100, Cost:1.93801, Accuracy:0.37500\n",
      "Pass:1, Batch:0, Cost:2.12956, Accuracy:0.25000\n",
      "Pass:1, Batch:50, Cost:1.92962, Accuracy:0.37500\n",
      "Pass:1, Batch:100, Cost:1.88695, Accuracy:0.62500\n",
      "Pass:2, Batch:0, Cost:2.08787, Accuracy:0.18750\n",
      "Pass:2, Batch:50, Cost:1.98429, Accuracy:0.31250\n",
      "Pass:2, Batch:100, Cost:1.63930, Accuracy:0.50000\n",
      "Pass:3, Batch:0, Cost:1.20482, Accuracy:0.68750\n",
      "Pass:3, Batch:50, Cost:1.62702, Accuracy:0.50000\n",
      "Pass:3, Batch:100, Cost:1.22755, Accuracy:0.68750\n",
      "Pass:4, Batch:0, Cost:1.38590, Accuracy:0.56250\n",
      "Pass:4, Batch:50, Cost:1.64612, Accuracy:0.50000\n",
      "Pass:4, Batch:100, Cost:1.59459, Accuracy:0.50000\n",
      "Pass:5, Batch:0, Cost:1.65650, Accuracy:0.50000\n",
      "Pass:5, Batch:50, Cost:0.99064, Accuracy:0.75000\n",
      "Pass:5, Batch:100, Cost:1.29896, Accuracy:0.68750\n",
      "Pass:6, Batch:0, Cost:1.08770, Accuracy:0.75000\n",
      "Pass:6, Batch:50, Cost:1.25853, Accuracy:0.62500\n",
      "Pass:6, Batch:100, Cost:1.11061, Accuracy:0.43750\n",
      "Pass:7, Batch:0, Cost:1.24460, Accuracy:0.62500\n",
      "Pass:7, Batch:50, Cost:1.35066, Accuracy:0.50000\n",
      "Pass:7, Batch:100, Cost:1.05262, Accuracy:0.87500\n",
      "Pass:8, Batch:0, Cost:1.40854, Accuracy:0.50000\n",
      "Pass:8, Batch:50, Cost:1.38918, Accuracy:0.56250\n",
      "Pass:8, Batch:100, Cost:1.17453, Accuracy:0.56250\n",
      "Pass:9, Batch:0, Cost:1.13956, Accuracy:0.62500\n",
      "Pass:9, Batch:50, Cost:0.77729, Accuracy:0.75000\n",
      "Pass:9, Batch:100, Cost:0.91229, Accuracy:0.87500\n",
      "Pass:10, Batch:0, Cost:1.27810, Accuracy:0.62500\n",
      "Pass:10, Batch:50, Cost:1.21936, Accuracy:0.68750\n",
      "Pass:10, Batch:100, Cost:0.98405, Accuracy:0.68750\n",
      "Pass:11, Batch:0, Cost:1.30859, Accuracy:0.50000\n",
      "Pass:11, Batch:50, Cost:1.34335, Accuracy:0.62500\n",
      "Pass:11, Batch:100, Cost:1.42120, Accuracy:0.56250\n",
      "Pass:12, Batch:0, Cost:1.01757, Accuracy:0.75000\n",
      "Pass:12, Batch:50, Cost:1.11660, Accuracy:0.62500\n",
      "Pass:12, Batch:100, Cost:0.99614, Accuracy:0.75000\n",
      "Pass:13, Batch:0, Cost:1.17144, Accuracy:0.68750\n",
      "Pass:13, Batch:50, Cost:0.93247, Accuracy:0.75000\n",
      "Pass:13, Batch:100, Cost:1.11008, Accuracy:0.68750\n",
      "Pass:14, Batch:0, Cost:0.78983, Accuracy:0.56250\n",
      "Pass:14, Batch:50, Cost:1.27914, Accuracy:0.43750\n",
      "Pass:14, Batch:100, Cost:0.63750, Accuracy:0.87500\n"
     ]
    }
   ],
   "source": [
    "##优化内存\n",
    "optimized = fluid.transpiler.memory_optimize(input_program=fluid.default_main_program(), print_log=False)\n",
    "\n",
    "##定义数据维度\n",
    "feeder=fluid.DataFeeder(place=place,feed_list=[image,label])\n",
    "\n",
    "for pass_id in range(15):\n",
    "    for batch_id,data in enumerate(train_reader()):\n",
    "        train_cost,train_acc=exe.run(program = fluid.default_main_program(),feed=feeder.feed(data),fetch_list=[avg_cost,acc])\n",
    "        if batch_id%50==0:\n",
    "            print('Pass:%d, Batch:%d, Cost:%0.5f, Accuracy:%0.5f' %\n",
    "                  (pass_id, batch_id, train_cost[0], train_acc[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "save_pretrain_model_path='models/step-1_model/'\n",
    "\n",
    "##删除旧的模型文件\n",
    "shutil.rmtree(save_pretrain_model_path,ignore_errors=True)\n",
    "##创建保存模型文件记录\n",
    "os.makedirs(save_pretrain_model_path)\n",
    "##保存参数模型\n",
    "fluid.io.save_params(executor=exe,dirname=save_pretrain_model_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step-2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "import paddle as paddle\n",
    "import paddle.dataset.flowers as flowers\n",
    "import paddle.fluid as fluid\n",
    "from paddle.fluid.param_attr import ParamAttr\n",
    "import reader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 获取数据\n",
    "train_reader = paddle.batch(reader.train(), batch_size=16)\n",
    "test_reader = paddle.batch(reader.val(), batch_size=16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##定义resnet，加上fc\n",
    "def resnet(input,class_dim):\n",
    "    def conv_bn_layer(input, num_filters, filter_size, stride=1, groups=1, act=None, name=None):\n",
    "        conv = fluid.layers.conv2d(input=input,\n",
    "                                   num_filters=num_filters,\n",
    "                                   filter_size=filter_size,\n",
    "                                   stride=stride,\n",
    "                                   padding=(filter_size - 1) // 2,\n",
    "                                   groups=groups,\n",
    "                                   act=None,\n",
    "                                   param_attr=ParamAttr(name=name + \"_weights\"),\n",
    "                                   bias_attr=False,\n",
    "                                   name=name + '.conv2d.output.1')\n",
    "        if name == \"conv1\":\n",
    "            bn_name = \"bn_\" + name\n",
    "        else:\n",
    "            bn_name = \"bn\" + name[3:]\n",
    "        return fluid.layers.batch_norm(input=conv,\n",
    "                                       act=act,\n",
    "                                       name=bn_name + '.output.1',\n",
    "                                       param_attr=ParamAttr(name=bn_name + '_scale'),\n",
    "                                       bias_attr=ParamAttr(bn_name + '_offset'),\n",
    "                                       moving_mean_name=bn_name + '_mean',\n",
    "                                       moving_variance_name=bn_name + '_variance', )\n",
    "\n",
    "    def shortcut(input, ch_out, stride, name):\n",
    "        ch_in = input.shape[1]\n",
    "        if ch_in != ch_out or stride != 1:\n",
    "            return conv_bn_layer(input, ch_out, 1, stride, name=name)\n",
    "        else:\n",
    "            return input\n",
    "            \n",
    "    def bottleneck_block(input, num_filters, stride, name):\n",
    "        conv0 = conv_bn_layer(input=input,\n",
    "                              num_filters=num_filters,\n",
    "                              filter_size=1,\n",
    "                              act='relu',\n",
    "                              name=name + \"_branch2a\")\n",
    "        conv1 = conv_bn_layer(input=conv0,\n",
    "                              num_filters=num_filters,\n",
    "                              filter_size=3,\n",
    "                              stride=stride,\n",
    "                              act='relu',\n",
    "                              name=name + \"_branch2b\")\n",
    "        conv2 = conv_bn_layer(input=conv1,\n",
    "                              num_filters=num_filters * 4,\n",
    "                              filter_size=1,\n",
    "                              act=None,\n",
    "                              name=name + \"_branch2c\")\n",
    "\n",
    "        short = shortcut(input, num_filters * 4, stride, name=name + \"_branch1\")\n",
    "\n",
    "        return fluid.layers.elementwise_add(x=short, y=conv2, act='relu', name=name + \".add.output.5\")\n",
    "\n",
    "    depth = [3, 4, 23, 3]\n",
    "    num_filters = [64, 128, 256, 512]\n",
    "\n",
    "    conv = conv_bn_layer(input=input, num_filters=64, filter_size=7, stride=2, act='relu', name=\"conv1\")\n",
    "    conv = conv_bn_layer(input=input, num_filters=32, filter_size=3, stride=2, act='relu', name='conv1_1')\n",
    "    conv = conv_bn_layer(input=conv, num_filters=32, filter_size=3, stride=1, act='relu', name='conv1_2')\n",
    "    conv = conv_bn_layer(input=conv, num_filters=64, filter_size=3, stride=1, act='relu', name='conv1_3')\n",
    "    conv = fluid.layers.pool2d(input=conv, pool_size=3, pool_stride=2, pool_padding=1, pool_type='max')\n",
    "\n",
    "    for block in range(len(depth)):\n",
    "        for i in range(depth[block]):\n",
    "            if block == 2:\n",
    "                if i == 0:\n",
    "                    conv_name=\"res\"+str(block+2)+\"a\"\n",
    "                else:\n",
    "                    conv_name=\"res\"+str(block+2)+\"b\"+str(i)\n",
    "            else:\n",
    "                    conv_name=\"res\"+str(block+2)+chr(97+i)\n",
    "            conv = bottleneck_block(input=conv,\n",
    "                                    num_filters=num_filters[block],\n",
    "                                    stride=2 if i == 0 and block != 0 else 1,\n",
    "                                    name=conv_name)\n",
    "\n",
    "    pool = fluid.layers.pool2d(input=conv, pool_size=7, pool_type='avg', global_pooling=True)\n",
    "    output=fluid.layers.fc(input=pool,size=class_dim,act='softmax')\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##定义输入层\n",
    "image = fluid.layers.data(name='image', shape=[3, 224, 224], dtype='float32')\n",
    "label = fluid.layers.data(name='label', shape=[1], dtype='int64')\n",
    "\n",
    "##获取分类器\n",
    "model = resnet(image,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##获取损失函数和准确率函数\n",
    "cost = fluid.layers.cross_entropy(input=model, label=label)\n",
    "avg_cost = fluid.layers.mean(cost)\n",
    "acc = fluid.layers.accuracy(input=model, label=label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##获取训练和测试程序\n",
    "test_program = fluid.default_main_program().clone(for_test=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##定义优化方法\n",
    "optimizer=fluid.optimizer.AdamOptimizer(learning_rate=5e-4)\n",
    "opts=optimizer.minimize(avg_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##定义一个使用GPU的执行器\n",
    "use_gpu=False\n",
    "place=fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()\n",
    "exe=fluid.Executor(place)\n",
    "\n",
    "##进行参数初始化\n",
    "exe.run(fluid.default_startup_program())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##经过step-1处理后的的预训练模型\n",
    "pretrained_model_path = 'models/step-1_model/'\n",
    "\n",
    "##加载经过处理的模型\n",
    "fluid.io.load_params(executor=exe, dirname=pretrained_model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##定义数据维度\n",
    "feeder=fluid.DataFeeder(place=place,feed_list=[image,label])\n",
    "for pass_id in range(10):\n",
    "    ##训练\n",
    "    for batch_id,data in enumerate(train_reader()):\n",
    "        train_cost,train_acc=exe.run(program=fluid.default_main_program(),feed=feeder.feed(data),fetch_list=[avg_cost,acc])\n",
    "        if batch_id%100==0:\n",
    "            print('Pass:%d, Batch:%d, Cost:%0.5f, Accuracy:%0.5f' %\n",
    "                  (pass_id, batch_id, train_cost[0], train_acc[0]))\n",
    "    ##测试\n",
    "    test_acc=[]\n",
    "    test_costs=[]\n",
    "    for batch_id,data in enumerate(test_reader()):\n",
    "        test_cost,test_acc=exe.run(program=test_program,feed=feeder.feed(data), fetch_list=[avg_cost,acc])\n",
    "        test_acc.append(test_acc[0])\n",
    "        test_costs.append(test_cost[0])\n",
    "    test_cost = (sum(test_costs) / len(test_costs))\n",
    "    test_acc = (sum(test_accs) / len(test_accs))\n",
    "    print('Test:%d, Cost:%0.5f, Accuracy:%0.5f' % (pass_id, test_cost, test_acc))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "##保存预测模型\n",
    "save_path = 'models/step_2_model/'\n",
    "\n",
    "##删除旧的模型文件\n",
    "shutil.rmtree(save_path, ignore_errors=True)\n",
    "##创建保持模型文件目录\n",
    "os.makedirs(save_path)\n",
    "##保存预测模型\n",
    "fluid.io.save_inference_model(save_path, feeded_var_names=[image.name], target_vars=[model], executor=exe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PaddlePaddle 1.4.1 (Python 3.6)",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}