猫的十二分类_resnet101_7X7卷积_5e-5lr_step1的batch_size32_4比1切分比例.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data7983\r\n"
     ]
    }
   ],
   "source": [
    "# 查看当前挂载的数据集目录\n",
    "!ls /home/aistudio/data/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "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": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cat_12/train_split_list.txt\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<function paddle.reader.decorator.xmap_readers.<locals>.xreader()>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import reader\n",
    "reader.train()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--2019-06-17 11:42:16--  http://paddle-imagenet-models-name.bj.bcebos.com/ResNet101_pretrained.tar\n",
      "Resolving paddle-imagenet-models-name.bj.bcebos.com (paddle-imagenet-models-name.bj.bcebos.com)... 220.181.33.48, 220.181.33.43, 220.181.33.44, ...\n",
      "Connecting to paddle-imagenet-models-name.bj.bcebos.com (paddle-imagenet-models-name.bj.bcebos.com)|220.181.33.48|:80... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 179148800 (171M) [application/x-tar]\n",
      "Saving to: ‘ResNet101_pretrained.tar’\n",
      "\n",
      "ResNet101_pretraine 100%[===================>] 170.85M  20.4MB/s    in 6.0s    \n",
      "\n",
      "2019-06-17 11:42:23 (28.7 MB/s) - ‘ResNet101_pretrained.tar’ saved [179148800/179148800]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!wget http://paddle-imagenet-models-name.bj.bcebos.com/ResNet50_vd_pretrained.tar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!tar -xvf ResNet50_vd_pretrained.tar -C work/pretrained"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "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": 2,
   "metadata": {},
   "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": {},
   "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": 3,
   "metadata": {},
   "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+144]:\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+144:i+180]:\n",
    "                val.write(line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11    144\n",
      "10    144\n",
      "9     144\n",
      "8     144\n",
      "7     144\n",
      "6     144\n",
      "5     144\n",
      "4     144\n",
      "3     144\n",
      "2     144\n",
      "1     144\n",
      "0     144\n",
      "Name: 1, dtype: int64\n",
      "11    36\n",
      "10    36\n",
      "9     36\n",
      "8     36\n",
      "7     36\n",
      "6     36\n",
      "5     36\n",
      "4     36\n",
      "3     36\n",
      "2     36\n",
      "1     36\n",
      "0     36\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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "##获取猫数据\n",
    "train_reader = paddle.batch(reader.train(), batch_size=32)\n",
    "test_reader = paddle.batch(reader.val(), batch_size=32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "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 = 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": 7,
   "metadata": {},
   "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": 8,
   "metadata": {},
   "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": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 9,
     "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=1e-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": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "##预训练模型路径\n",
    "src_pretrain_model_path='work/pretrained/ResNet101_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": 11,
   "metadata": {},
   "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:3.04066, Accuracy:0.00000\n",
      "Pass:0, Batch:50, Cost:2.38735, Accuracy:0.09375\n",
      "Pass:1, Batch:0, Cost:2.41796, Accuracy:0.18750\n",
      "Pass:1, Batch:50, Cost:1.94467, Accuracy:0.43750\n",
      "Pass:2, Batch:0, Cost:1.94120, Accuracy:0.34375\n",
      "Pass:2, Batch:50, Cost:1.89815, Accuracy:0.40625\n",
      "Pass:3, Batch:0, Cost:1.65165, Accuracy:0.65625\n",
      "Pass:3, Batch:50, Cost:1.50891, Accuracy:0.56250\n",
      "Pass:4, Batch:0, Cost:1.55873, Accuracy:0.62500\n",
      "Pass:4, Batch:50, Cost:1.63168, Accuracy:0.53125\n",
      "Pass:5, Batch:0, Cost:1.37793, Accuracy:0.78125\n",
      "Pass:5, Batch:50, Cost:1.22718, Accuracy:0.81250\n",
      "Pass:6, Batch:0, Cost:1.46926, Accuracy:0.65625\n",
      "Pass:6, Batch:50, Cost:1.24888, Accuracy:0.65625\n",
      "Pass:7, Batch:0, Cost:1.08487, Accuracy:0.75000\n",
      "Pass:7, Batch:50, Cost:0.94655, Accuracy:0.87500\n",
      "Pass:8, Batch:0, Cost:1.24757, Accuracy:0.62500\n",
      "Pass:8, Batch:50, Cost:1.09599, Accuracy:0.75000\n",
      "Pass:9, Batch:0, Cost:0.92092, Accuracy:0.71875\n",
      "Pass:9, Batch:50, Cost:0.98443, Accuracy:0.75000\n",
      "Pass:10, Batch:0, Cost:0.87092, Accuracy:0.84375\n",
      "Pass:10, Batch:50, Cost:1.00151, Accuracy:0.78125\n",
      "Pass:11, Batch:0, Cost:0.70071, Accuracy:0.90625\n",
      "Pass:11, Batch:50, Cost:0.91838, Accuracy:0.78125\n",
      "Pass:12, Batch:0, Cost:0.78774, Accuracy:0.84375\n",
      "Pass:12, Batch:50, Cost:0.89908, Accuracy:0.68750\n",
      "Pass:13, Batch:0, Cost:0.84145, Accuracy:0.78125\n",
      "Pass:13, Batch:50, Cost:0.82588, Accuracy:0.81250\n",
      "Pass:14, Batch:0, Cost:0.98420, Accuracy:0.65625\n",
      "Pass:14, Batch:50, Cost:0.98105, Accuracy:0.75000\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": 12,
   "metadata": {},
   "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": {},
   "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": {},
   "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": {},
   "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 = 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": {},
   "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": {},
   "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": {},
   "outputs": [],
   "source": [
    "##获取训练和测试程序\n",
    "test_program = fluid.default_main_program().clone(for_test=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "##定义优化方法\n",
    "optimizer=fluid.optimizer.AdamOptimizer(learning_rate=1e-5)\n",
    "opts=optimizer.minimize(avg_cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##定义一个使用GPU的执行器\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": {},
   "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": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pass:0, Batch:0, Cost:0.79026, Accuracy:0.81250\n",
      "Pass:0, Batch:10, Cost:0.73419, Accuracy:0.93750\n",
      "Pass:0, Batch:20, Cost:0.74877, Accuracy:0.81250\n",
      "Pass:0, Batch:30, Cost:0.75872, Accuracy:0.87500\n",
      "Pass:0, Batch:40, Cost:0.39540, Accuracy:1.00000\n",
      "Pass:0, Batch:50, Cost:0.99851, Accuracy:0.68750\n",
      "Pass:0, Batch:60, Cost:0.35503, Accuracy:0.93750\n",
      "Pass:0, Batch:70, Cost:0.75523, Accuracy:0.81250\n",
      "Pass:0, Batch:80, Cost:0.72592, Accuracy:0.75000\n",
      "Pass:0, Batch:90, Cost:1.17983, Accuracy:0.68750\n",
      "Pass:0, Batch:100, Cost:0.85763, Accuracy:0.68750\n",
      "Test:0, Cost:0.28739, Accuracy:0.92824\n",
      "Pass:1, Batch:0, Cost:0.43119, Accuracy:0.87500\n",
      "Pass:1, Batch:10, Cost:0.44555, Accuracy:0.81250\n",
      "Pass:1, Batch:20, Cost:0.58018, Accuracy:0.93750\n",
      "Pass:1, Batch:30, Cost:0.34542, Accuracy:1.00000\n",
      "Pass:1, Batch:40, Cost:0.54835, Accuracy:0.81250\n",
      "Pass:1, Batch:50, Cost:0.49807, Accuracy:0.87500\n",
      "Pass:1, Batch:60, Cost:0.83121, Accuracy:0.75000\n",
      "Pass:1, Batch:70, Cost:0.57357, Accuracy:0.75000\n",
      "Pass:1, Batch:80, Cost:0.47848, Accuracy:0.87500\n",
      "Pass:1, Batch:90, Cost:0.78502, Accuracy:0.68750\n",
      "Pass:1, Batch:100, Cost:0.53347, Accuracy:0.81250\n",
      "Test:1, Cost:0.21079, Accuracy:0.94213\n",
      "Pass:2, Batch:0, Cost:0.25796, Accuracy:0.87500\n",
      "Pass:2, Batch:10, Cost:0.64723, Accuracy:0.75000\n",
      "Pass:2, Batch:20, Cost:0.31967, Accuracy:0.93750\n",
      "Pass:2, Batch:30, Cost:0.57886, Accuracy:0.87500\n",
      "Pass:2, Batch:40, Cost:0.51151, Accuracy:0.68750\n",
      "Pass:2, Batch:50, Cost:0.45023, Accuracy:0.81250\n",
      "Pass:2, Batch:60, Cost:0.64283, Accuracy:0.81250\n",
      "Pass:2, Batch:70, Cost:0.42490, Accuracy:0.81250\n",
      "Pass:2, Batch:80, Cost:0.32839, Accuracy:0.81250\n",
      "Pass:2, Batch:90, Cost:0.09794, Accuracy:1.00000\n",
      "Pass:2, Batch:100, Cost:0.29423, Accuracy:0.87500\n",
      "Test:2, Cost:0.18936, Accuracy:0.94907\n",
      "Pass:3, Batch:0, Cost:0.38081, Accuracy:0.87500\n",
      "Pass:3, Batch:10, Cost:0.36144, Accuracy:0.87500\n",
      "Pass:3, Batch:20, Cost:0.56815, Accuracy:0.75000\n",
      "Pass:3, Batch:30, Cost:0.29168, Accuracy:0.93750\n",
      "Pass:3, Batch:40, Cost:0.26649, Accuracy:0.93750\n",
      "Pass:3, Batch:50, Cost:0.25020, Accuracy:0.93750\n",
      "Pass:3, Batch:60, Cost:0.39576, Accuracy:0.81250\n",
      "Pass:3, Batch:70, Cost:0.28711, Accuracy:0.87500\n",
      "Pass:3, Batch:80, Cost:0.28949, Accuracy:0.93750\n",
      "Pass:3, Batch:90, Cost:0.43110, Accuracy:0.87500\n",
      "Pass:3, Batch:100, Cost:0.18278, Accuracy:0.93750\n",
      "Test:3, Cost:0.17860, Accuracy:0.93750\n",
      "Pass:4, Batch:0, Cost:0.61258, Accuracy:0.75000\n",
      "Pass:4, Batch:10, Cost:0.27701, Accuracy:0.87500\n",
      "Pass:4, Batch:20, Cost:0.27692, Accuracy:0.93750\n",
      "Pass:4, Batch:30, Cost:0.20275, Accuracy:0.93750\n",
      "Pass:4, Batch:40, Cost:0.51757, Accuracy:0.75000\n",
      "Pass:4, Batch:50, Cost:0.21154, Accuracy:0.93750\n",
      "Pass:4, Batch:60, Cost:0.14151, Accuracy:1.00000\n",
      "Pass:4, Batch:70, Cost:0.22536, Accuracy:0.87500\n",
      "Pass:4, Batch:80, Cost:0.21390, Accuracy:1.00000\n",
      "Pass:4, Batch:90, Cost:0.44535, Accuracy:0.93750\n",
      "Pass:4, Batch:100, Cost:0.18845, Accuracy:0.93750\n",
      "Test:4, Cost:0.18904, Accuracy:0.93287\n",
      "Pass:5, Batch:0, Cost:0.36249, Accuracy:0.87500\n",
      "Pass:5, Batch:10, Cost:0.24461, Accuracy:0.93750\n",
      "Pass:5, Batch:20, Cost:0.23692, Accuracy:0.93750\n",
      "Pass:5, Batch:30, Cost:0.13044, Accuracy:1.00000\n",
      "Pass:5, Batch:40, Cost:0.56600, Accuracy:0.81250\n",
      "Pass:5, Batch:50, Cost:0.26548, Accuracy:0.93750\n",
      "Pass:5, Batch:60, Cost:0.29666, Accuracy:0.93750\n",
      "Pass:5, Batch:70, Cost:0.22336, Accuracy:0.93750\n",
      "Pass:5, Batch:80, Cost:0.28039, Accuracy:0.93750\n",
      "Pass:5, Batch:90, Cost:0.96164, Accuracy:0.68750\n",
      "Pass:5, Batch:100, Cost:0.33877, Accuracy:0.87500\n",
      "Test:5, Cost:0.17889, Accuracy:0.94444\n",
      "Pass:6, Batch:0, Cost:0.18953, Accuracy:0.93750\n",
      "Pass:6, Batch:10, Cost:0.35123, Accuracy:0.93750\n",
      "Pass:6, Batch:20, Cost:0.26835, Accuracy:0.93750\n",
      "Pass:6, Batch:30, Cost:0.32088, Accuracy:0.93750\n",
      "Pass:6, Batch:40, Cost:0.08607, Accuracy:1.00000\n",
      "Pass:6, Batch:50, Cost:0.25191, Accuracy:0.93750\n",
      "Pass:6, Batch:60, Cost:0.14681, Accuracy:1.00000\n",
      "Pass:6, Batch:70, Cost:0.17474, Accuracy:0.93750\n",
      "Pass:6, Batch:80, Cost:0.18045, Accuracy:0.93750\n",
      "Pass:6, Batch:90, Cost:0.29968, Accuracy:0.81250\n",
      "Pass:6, Batch:100, Cost:0.10241, Accuracy:1.00000\n",
      "Test:6, Cost:0.17556, Accuracy:0.95370\n",
      "Pass:7, Batch:0, Cost:0.13106, Accuracy:0.93750\n",
      "Pass:7, Batch:10, Cost:0.24821, Accuracy:0.93750\n",
      "Pass:7, Batch:20, Cost:0.10417, Accuracy:0.93750\n",
      "Pass:7, Batch:30, Cost:0.47386, Accuracy:0.81250\n",
      "Pass:7, Batch:40, Cost:0.06228, Accuracy:1.00000\n",
      "Pass:7, Batch:50, Cost:0.21204, Accuracy:0.93750\n",
      "Pass:7, Batch:60, Cost:0.17899, Accuracy:1.00000\n",
      "Pass:7, Batch:70, Cost:0.32472, Accuracy:0.87500\n",
      "Pass:7, Batch:80, Cost:0.22903, Accuracy:0.93750\n",
      "Pass:7, Batch:90, Cost:0.48786, Accuracy:0.87500\n",
      "Pass:7, Batch:100, Cost:0.13489, Accuracy:0.93750\n",
      "Test:7, Cost:0.18482, Accuracy:0.95370\n",
      "Pass:8, Batch:0, Cost:0.33529, Accuracy:0.87500\n",
      "Pass:8, Batch:10, Cost:0.19163, Accuracy:0.93750\n",
      "Pass:8, Batch:20, Cost:0.15105, Accuracy:1.00000\n",
      "Pass:8, Batch:30, Cost:0.48293, Accuracy:0.81250\n",
      "Pass:8, Batch:40, Cost:0.49471, Accuracy:0.75000\n",
      "Pass:8, Batch:50, Cost:0.51129, Accuracy:0.81250\n",
      "Pass:8, Batch:60, Cost:0.61770, Accuracy:0.81250\n",
      "Pass:8, Batch:70, Cost:0.35176, Accuracy:0.93750\n",
      "Pass:8, Batch:80, Cost:0.28451, Accuracy:0.87500\n",
      "Pass:8, Batch:90, Cost:0.21629, Accuracy:0.93750\n",
      "Pass:8, Batch:100, Cost:0.09973, Accuracy:1.00000\n",
      "Test:8, Cost:0.15254, Accuracy:0.95370\n",
      "Pass:9, Batch:0, Cost:0.19291, Accuracy:0.87500\n",
      "Pass:9, Batch:10, Cost:0.26555, Accuracy:0.93750\n",
      "Pass:9, Batch:20, Cost:0.19748, Accuracy:0.93750\n",
      "Pass:9, Batch:30, Cost:0.15813, Accuracy:0.93750\n",
      "Pass:9, Batch:40, Cost:0.24776, Accuracy:0.93750\n",
      "Pass:9, Batch:50, Cost:0.38536, Accuracy:0.87500\n",
      "Pass:9, Batch:60, Cost:0.17372, Accuracy:0.93750\n",
      "Pass:9, Batch:70, Cost:0.11424, Accuracy:0.93750\n",
      "Pass:9, Batch:80, Cost:0.13586, Accuracy:1.00000\n",
      "Pass:9, Batch:90, Cost:0.07914, Accuracy:1.00000\n",
      "Pass:9, Batch:100, Cost:0.67969, Accuracy:0.75000\n",
      "Test:9, Cost:0.18667, Accuracy:0.94444\n"
     ]
    }
   ],
   "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%10==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_accs=[]\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_accs.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": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['save_infer_model/scale_0']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "SAVE_DIRNAME = './models/step_2_model'  # 保存好的 inference model 的路径\n",
    "\n",
    "#########################################################################\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "运行generate_CSV_file_with_infer.py\n",
    "脚本文件generate_CSV_file_with_infer.py实现生成CSV文件的功能\n",
    "脚本文件将读取训练好的模型（model）和测试集数据（test）\n",
    "并将模型对测试集数据的预测结果保存为CSV文件\n",
    "\"\"\"\n",
    "\n",
    "# coding:utf-8\n",
    "from __future__ import print_function\n",
    "import os\n",
    "import json\n",
    "\n",
    "import paddle\n",
    "import paddle.fluid as fluid\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import sys\n",
    "\n",
    "\n",
    "# 根据竞赛规则更改 TopK 的值。本次竞赛只看 top 1 的值\n",
    "TOP_K = 1\n",
    "\n",
    "SAVE_DIRNAME = './models/step_2_model'  # 保存好的 inference model 的路径\n",
    "\n",
    "DATA_DIM = 224\n",
    "\n",
    "use_cuda = True\n",
    "place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()\n",
    "exe = fluid.Executor(place)\n",
    "\n",
    "# 下面行代码根据自己保存时的写法匹配\n",
    "[inference_program, feed_target_names, fetch_targets] = fluid.io.load_inference_model( SAVE_DIRNAME, exe,\n",
    "                # model_filename='model',\n",
    "                # params_filename='params'\n",
    "                # model_filename = 'fc_0.w_0',\n",
    "                # params_filename = 'params'\n",
    "                )\n",
    "\n",
    "\n",
    "def real_infer_one_img(im):\n",
    "    infer_result = exe.run(\n",
    "        inference_program,\n",
    "        feed={feed_target_names[0]: im},\n",
    "        fetch_list=fetch_targets)\n",
    "\n",
    "    # print(infer_result)\n",
    "    # 打印预测结果\n",
    "    mini_batch_result = np.argsort(infer_result)  # 找出可能性最大的列标，升序排列\n",
    "    # print(mini_batch_result.shape)\n",
    "    mini_batch_result = mini_batch_result[0][:, -TOP_K:]  # 把这些列标拿出来\n",
    "    # print('预测结果：%s' % mini_batch_result)\n",
    "    # 打印真实结果\n",
    "    # label = np.array(test_y)  # 转化为 label\n",
    "    # print('真实结果：%s' % label)\n",
    "    mini_batch_result = mini_batch_result.flatten() #拉平了，只吐出一个 array\n",
    "    mini_batch_result = mini_batch_result[::-1] #逆序\n",
    "    return mini_batch_result\n",
    "\n",
    "\n",
    "def resize_short(img, target_size):\n",
    "    percent = float(target_size) / min(img.size[0], img.size[1])\n",
    "    resized_width = int(round(img.size[0] * percent))\n",
    "    resized_height = int(round(img.size[1] * percent))\n",
    "    img = img.resize((resized_width, resized_height), Image.LANCZOS)\n",
    "    return img\n",
    "\n",
    "\n",
    "def crop_image(img, target_size, center):\n",
    "    width, height = img.size\n",
    "    size = target_size\n",
    "    if center == True:\n",
    "        w_start = (width - size) / 2\n",
    "        h_start = (height - size) / 2\n",
    "    else:\n",
    "        w_start = np.random.randint(0, width - size + 1)\n",
    "        h_start = np.random.randint(0, height - size + 1)\n",
    "    w_end = w_start + size\n",
    "    h_end = h_start + size\n",
    "    img = img.crop((w_start, h_start, w_end, h_end))\n",
    "    return img\n",
    "\n",
    "img_mean = np.array([0.485, 0.456, 0.406]).reshape((3, 1, 1))\n",
    "img_std = np.array([0.229, 0.224, 0.225]).reshape((3, 1, 1))\n",
    "\n",
    "def process_image(img_path):\n",
    "    img = Image.open(img_path)\n",
    "    img = resize_short(img, target_size=256)\n",
    "    img = crop_image(img, target_size=DATA_DIM, center=True)\n",
    "\n",
    "    if img.mode != 'RGB':\n",
    "        img = img.convert('RGB')\n",
    "\n",
    "    img = np.array(img).astype(np.float32).transpose((2, 0, 1)) / 255\n",
    "    img -= img_mean\n",
    "    img /= img_std\n",
    "\n",
    "    img = np.expand_dims(img, axis=0)\n",
    "    return img\n",
    "\n",
    "\n",
    "def convert_list(my_list):\n",
    "    my_list = list(my_list)\n",
    "    my_list = map(lambda x:str(x), my_list)\n",
    "    # print('_'.join(my_list))\n",
    "    return '_'.join(my_list)\n",
    "\n",
    "\n",
    "def infer(file_path):\n",
    "    im = process_image(file_path)\n",
    "    result = real_infer_one_img(im)\n",
    "    result = convert_list(result)\n",
    "    return result\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "def createCSVFile(cat_12_test_path):\n",
    "    lines = []\n",
    "\n",
    "    # 获取所有的文件名\n",
    "    img_paths = os.listdir(cat_12_test_path)\n",
    "    for file_name in img_paths:\n",
    "        file_name = file_name\n",
    "        file_abs_path = os.path.join(cat_12_test_path, file_name)\n",
    "        result_classes = infer(file_abs_path)\n",
    "\n",
    "        file_predict_classes = result_classes\n",
    "\n",
    "        line = '%s,%s\\n'%(file_name, file_predict_classes)\n",
    "        lines.append(line)\n",
    "\n",
    "    with open('csv_file_path.csv', 'w') as f:\n",
    "        f.writelines(lines)\n",
    "\n",
    "\n",
    "abs_path = r'./cat_12/cat_12_test' # cat_12_test 文件夹的真实路径\n",
    "createCSVFile(abs_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow35",
   "language": "python",
   "name": "tensorflow35"
  },
  "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.5.4"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}