复现代码测试.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 10>\r\n",
    "\r\n",
    "# pimm依赖"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***data系列***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.data.Dataset 与 pimm.data.create_loader"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.data import Dataset, create_loader"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 测试主要方法与函数运行"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "dataset_eval = Dataset(\"Cream/data/imagenet/val\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "loader_eval = create_loader(\r\n",
    "        dataset_eval,\r\n",
    "        input_size = (3, 224, 224),\r\n",
    "        batch_size = 4 * 32,\r\n",
    "        is_training = True,\r\n",
    "        num_workers = 4,\r\n",
    "        distributed = False,\r\n",
    "        interpolation = 'bicubic',\r\n",
    "        crop_pct = 0.875,\r\n",
    "        mean = (0.485, 0.456, 0.406),\r\n",
    "        std = (0.229, 0.224, 0.225))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 输出值测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for _, (input, _) in enumerate(loader_eval):\r\n",
    "    break\r\n",
    "print(input)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***loss系列***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = \"3\">\r\n",
    "\r\n",
    "### pimm.loss.LabelSmoothingCrossEntropy"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.loss import LabelSmoothingCrossEntropy"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 测试方法创建"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "pd_fun = LabelSmoothingCrossEntropy()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 前向对齐测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import numpy as np"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "output = np.random.rand(100,20)\r\n",
    "target = np.random.randint(low = 0, high = 20, size = (100))\r\n",
    "for i in range(100):\r\n",
    "    output[i][target[i]] += 10\r\n",
    "    output[i] /= output[i].sum()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "pd_loss = pd_fun(\r\n",
    "    paddle.to_tensor(output, dtype = \"float32\"), \r\n",
    "    paddle.to_tensor(target))\r\n",
    "print(pd_loss)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import torch\r\n",
    "import torch.nn as nn\r\n",
    "import torch.nn.functional as F\r\n",
    "class LabelSmoothingCrossEntropy(nn.Module):\r\n",
    "    def __init__(self, smoothing=0.1):\r\n",
    "        super(LabelSmoothingCrossEntropy, self).__init__()\r\n",
    "        assert smoothing < 1.0\r\n",
    "        self.smoothing = smoothing\r\n",
    "        self.confidence = 1. - smoothing\r\n",
    "\r\n",
    "    def forward(self, x, target):\r\n",
    "        logprobs = F.log_softmax(x, dim=-1)\r\n",
    "        nll_loss = -logprobs.gather(dim=-1, index=target.unsqueeze(1))\r\n",
    "        nll_loss = nll_loss.squeeze(1)\r\n",
    "        smooth_loss = -logprobs.mean(dim=-1)\r\n",
    "        loss = self.confidence * nll_loss + self.smoothing * smooth_loss\r\n",
    "        return loss.mean()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "index = torch.from_numpy(target).type_as(torch.zeros((2,2), dtype = torch.int64))\r\n",
    "tc_loss = LabelSmoothingCrossEntropy()(\r\n",
    "    torch.from_numpy(output), \r\n",
    "    index)\r\n",
    "print(tc_loss)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***models.effcientnet_blocks系列***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models.efficientnet_blocks import ConvBnAct, DepthwiseSeparableConv, drop_path, InvertedResidual,SqueezeExcite"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.effcientnet_blocks.ConvBnAct"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络创建"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "conv_bn_act = ConvBnAct(in_chs = 3, out_chs = 8, kernel_size = 3)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络组网与运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "conv_bn_act_model = paddle.Model(conv_bn_act)\r\n",
    "conv_bn_act_model.summary(input_size = (10, 3, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class ConvBnAct_Model(paddle.nn.Layer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super(ConvBnAct_Model, self).__init__()\r\n",
    "        self.core = ConvBnAct(in_chs = 3, out_chs = 8, kernel_size = 3)\r\n",
    "    \r\n",
    "    @paddle.jit.to_static\r\n",
    "    def forward(self, x):\r\n",
    "        return self.core(x)\r\n",
    "\r\n",
    "conv_bn_act_model = ConvBnAct_Model()\r\n",
    "conv_bn_act_model.eval()\r\n",
    "\r\n",
    "conv_bn_act_model(paddle.randn((10, 3, 224, 224)))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.effcientnet_blocks.DepthwiseSeparableConv"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络创建"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "dsc = DepthwiseSeparableConv(in_chs = 8, out_chs = 3)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络组网与运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "dsc_model = paddle.Model(dsc)\r\n",
    "dsc_model.summary(input_size = (1, 8, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "class DSC_Model(paddle.nn.Layer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super(DSC_Model, self).__init__()\r\n",
    "        self.core = DepthwiseSeparableConv(in_chs = 8, out_chs = 3)\r\n",
    "    \r\n",
    "    @paddle.jit.to_static\r\n",
    "    def forward(self, x):\r\n",
    "        return self.core(x)\r\n",
    "\r\n",
    "dsc_model = DSC_Model()\r\n",
    "dsc_model.eval()\r\n",
    "\r\n",
    "dsc_model(paddle.randn((10, 8, 224, 224)))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.effcientnet_blocks.drop_path"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "test_Tensor = paddle.randn((16, 3, 224, 224))\r\n",
    "drop_path(test_Tensor)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.effcientnet_blocks.InvertedResidual"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络创建"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ir = InvertedResidual(in_chs = 8, out_chs = 3)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络组网与运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "ir_model = paddle.Model(ir)\r\n",
    "ir_model.summary(input_size = (16, 8, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "class IR_Model(paddle.nn.Layer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super(IR_Model, self).__init__()\r\n",
    "        self.core = InvertedResidual(in_chs = 8, out_chs = 3)\r\n",
    "    \r\n",
    "    @paddle.jit.to_static\r\n",
    "    def forward(self, x):\r\n",
    "        return self.core(x)\r\n",
    "\r\n",
    "ir_model = IR_Model()\r\n",
    "ir_model.eval()\r\n",
    "\r\n",
    "ir_model(paddle.randn((16, 8, 224, 224)))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.effcientnet_blocks.SqueezeExcite"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络创建"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "se = SqueezeExcite(in_chs = 8)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络组网与运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "se_model = paddle.Model(se)\r\n",
    "se_model.summary(input_size = (16, 8, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "class SE_Model(paddle.nn.Layer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super(SE_Model, self).__init__()\r\n",
    "        self.core = SqueezeExcite(in_chs = 8)\r\n",
    "    \r\n",
    "    @paddle.jit.to_static\r\n",
    "    def forward(self, x):\r\n",
    "        return self.core(x)\r\n",
    "\r\n",
    "se_model = SE_Model()\r\n",
    "se_model.eval()\r\n",
    "\r\n",
    "se_model(paddle.randn((16, 8, 224, 224)))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***models.activations系列***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models.activations import hard_sigmoid, Swish"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.activations.hard_sigmoid"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "import numpy as np\r\n",
    "hard_sigmoid(paddle.to_tensor(np.linspace(0., 10.)))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.activations.Swish"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "import numpy as np\r\n",
    "swish = Swish()\r\n",
    "swish(paddle.to_tensor(np.linspace(0., 10.)))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***models系列（其他函数与类）***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.create_conv2d"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models import create_conv2d"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "Conv_2D = []\r\n",
    "Conv_2D.append(create_conv2d(in_chs = 8, out_chs = 3, kernel_size = [3, 5, 7]))\r\n",
    "Conv_2D.append(create_conv2d(in_chs = 8, out_chs = 3, kernel_size = 5, num_experts = 3))\r\n",
    "Conv_2D.append(create_conv2d(in_chs = 8, out_chs = 3, kernel_size = 5))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络结构检查"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "for module in (Conv_2D[0], Conv_2D[2]):\r\n",
    "    model_test = paddle.Model(module)\r\n",
    "    model_test.summary(input_size = (16, 8, 224, 224))\r\n",
    "    del model_test"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.SelectAdaptivePool2D"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models import SelectAdaptivePool2D"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络创建"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "pools = [\r\n",
    "    SelectAdaptivePool2D(output_size = 10, pool_type = \"avgmax\"), \r\n",
    "    SelectAdaptivePool2D(output_size = 10, pool_type = \"catavgmax\"), \r\n",
    "    SelectAdaptivePool2D(output_size = 10, pool_type = \"avg\"), \r\n",
    "    SelectAdaptivePool2D(output_size = 10, pool_type = \"max\")]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络结构检查"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "for layer in pools:\r\n",
    "    model = paddle.Model(layer)\r\n",
    "    model.summary(input_size = (16, 3, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络组网与运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "test_x = paddle.randint(0, 2, (1, 2, 3, 3))\r\n",
    "test_x = paddle.to_tensor(test_x, dtype = \"float32\")\r\n",
    "print(test_x)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class Pool_Model_1(paddle.nn.Layer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super(Pool_Model_1, self).__init__()\r\n",
    "        self.core = SelectAdaptivePool2D(output_size = 10, pool_type = \"avgmax\")\r\n",
    "    \r\n",
    "    @paddle.jit.to_static\r\n",
    "    def forward(self, x):\r\n",
    "        return self.core(x)\r\n",
    "\r\n",
    "class Pool_Model_2(paddle.nn.Layer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super(Pool_Model_2, self).__init__()\r\n",
    "        self.core = SelectAdaptivePool2D(output_size = 10, pool_type = \"catavgmax\")\r\n",
    "    \r\n",
    "    @paddle.jit.to_static\r\n",
    "    def forward(self, x):\r\n",
    "        return self.core(x)\r\n",
    "\r\n",
    "class Pool_Model_3(paddle.nn.Layer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super(Pool_Model_3, self).__init__()\r\n",
    "        self.core = SelectAdaptivePool2D(output_size = 10, pool_type = \"avg\")\r\n",
    "    \r\n",
    "    @paddle.jit.to_static\r\n",
    "    def forward(self, x):\r\n",
    "        return self.core(x)\r\n",
    "\r\n",
    "class Pool_Model_4(paddle.nn.Layer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super(Pool_Model_4, self).__init__()\r\n",
    "        self.core = SelectAdaptivePool2D(output_size = 10, pool_type = \"max\")\r\n",
    "    \r\n",
    "    @paddle.jit.to_static\r\n",
    "    def forward(self, x):\r\n",
    "        return self.core(x)\r\n",
    "\r\n",
    "Pool_Models = [Pool_Model_1, Pool_Model_2, Pool_Model_3, Pool_Model_4]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for test_Model in Pool_Models:\r\n",
    "    model = test_Model()\r\n",
    "    model.eval()\r\n",
    "    print(model(test_x))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.models.resume_checkpoint"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "测试此部分前，请先测试`pimm.utils.CheckpointSaver`以生成本部分测试所需要的存档"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models import resume_checkpoint"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 存档载入测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models import create_conv2d\r\n",
    "test_Model = create_conv2d(in_chs = 8, out_chs = 3, kernel_size = [3, 5, 7])\r\n",
    "\r\n",
    "resume_checkpoint(test_Model, \"test/last.pdparams\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "测试完成后请运行`utils.CheckpointSaver`中的“删除生成文件部分以”删除用于测试的存档"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***utils系列***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.utils import reduce_tensor, CheckpointSaver, ModelEma"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.utils.reduce_tensor"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "test_Tensor = paddle.randn((3, 3, 3))\r\n",
    "print(test_Tensor)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "reduced_test_Tensor = reduce_tensor(test_Tensor, 3.)\r\n",
    "print(reduced_test_Tensor)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.utils.CheckpointSaver"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "saver = CheckpointSaver(checkpoint_dir = \"test/\", recovery_dir = \"test/\", max_history = 5)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 存储测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models import create_conv2d\r\n",
    "import paddle\r\n",
    "\r\n",
    "test_Model = create_conv2d(in_chs = 8, out_chs = 3, kernel_size = [3, 5, 7])\r\n",
    "test_Optimizer = paddle.optimizer.Adam(parameters = test_Model.parameters())\r\n",
    "\r\n",
    "class test_Args:\r\n",
    "    def __init__(self):\r\n",
    "        self.model = \"\"\r\n",
    "\r\n",
    "test_args = test_Args()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import random\r\n",
    "for i in range(20):\r\n",
    "    saver.save_checkpoint(\r\n",
    "    model = test_Model, optimizer = test_Optimizer, \r\n",
    "    args = test_args, epoch = i + 1, \r\n",
    "    metric = random.random())"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for checkpoint in saver.checkpoint_files:\r\n",
    "    print(checkpoint)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 删除生成文件（若要测试resume_checkpoint则不运行）"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import os\r\n",
    "f_dir = os.getcwd()\r\n",
    "l_dir = os.path.join(f_dir, \"test\")\r\n",
    "if os.path.exists(l_dir):\r\n",
    "    lis_dir = os.listdir(l_dir)\r\n",
    "    for tar_dir in lis_dir:\r\n",
    "        os.remove(os.path.join(l_dir, tar_dir))\r\n",
    "    os.removedirs(l_dir)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.utils.ModelEma"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models import create_conv2d\r\n",
    "ema = ModelEma(\r\n",
    "    create_conv2d(in_chs = 8, out_chs = 3, kernel_size = [3, 5, 7]))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 更新测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "ema.update(\r\n",
    "    create_conv2d(in_chs = 8, out_chs = 3, kernel_size = [3, 5, 7]))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***optim与scheduler系列***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.optim.create_optimizer"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "没有有效的测试方法"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pimm.scheduler.create_scheduler"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.scheduler import create_scheduler"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class test_Args:\r\n",
    "    def __init__(self):\r\n",
    "        self.sched = \"step\"\r\n",
    "        self.lr = .01\r\n",
    "        self.epochs = 200\r\n",
    "        self.decay_epochs = 4\r\n",
    "        self.decay_rate = .1\r\n",
    "        self.warmup_lr = 1e-4\r\n",
    "        self.warmup_epochs = 3\r\n",
    "        self.noise_range = None\r\n",
    "        self.lr_noise_pct = .67\r\n",
    "        self.lr_noise_std = 1.\r\n",
    "        self.seed = 42"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "sched, num_epochs = create_scheduler(test_Args())"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for i in range(20):\r\n",
    "    sched.step(i)\r\n",
    "    print(sched.get_lr())"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# phop依赖"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### phop.profile"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.phop import profile"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "from Paddle_Cream.lib.utils.pimm.models import create_conv2d\r\n",
    "test_layer = create_conv2d(in_chs = 8, out_chs = 3, kernel_size = [3, 5, 7])\r\n",
    "test_model = paddle.Model(test_layer)\r\n",
    "test_model.summary(input_size = (16, 8, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "test_input = paddle.randn((16, 8, 224, 224))\r\n",
    "print(\r\n",
    "    profile(\r\n",
    "        test_layer, \r\n",
    "        inputs = test_input))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "test_layer.buffers()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# pdflops依赖"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### pdflops.get_model_complexity_info"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pdflops import get_model_complexity_info"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "from Paddle_Cream.lib.utils.pimm.models import create_conv2d\r\n",
    "test_layer2 = create_conv2d(in_chs = 8, out_chs = 3, kernel_size = [3, 5, 7])\r\n",
    "test_layer1 = paddle.nn.Linear(in_features = 20, out_features = 8)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "re1 = get_model_complexity_info(\r\n",
    "    test_layer1, \r\n",
    "    (1, 20), \r\n",
    "    as_strings = False, \r\n",
    "    print_per_layer_stat = False)\r\n",
    "re2 = get_model_complexity_info(\r\n",
    "    test_layer2, \r\n",
    "    (8, 224, 224), \r\n",
    "    as_strings = False, \r\n",
    "    print_per_layer_stat = False)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(re1)\r\n",
    "print(re2)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 结果核对"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import torch\r\n",
    "from timm.models.layers import create_conv2d\r\n",
    "test_layer1_t = torch.nn.Linear(in_features = 20, out_features = 8)\r\n",
    "test_layer2_t = create_conv2d(in_chs = 8, out_chs = 3, kernel_size = [3, 5, 7])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Cream.lib.utils.flops_counter import get_model_complexity_info\r\n",
    "re1 = get_model_complexity_info(\r\n",
    "    test_layer1_t, \r\n",
    "    (1, 20), \r\n",
    "    as_strings = False, \r\n",
    "    print_per_layer_stat = False)\r\n",
    "re2 = get_model_complexity_info(\r\n",
    "    test_layer2_t, \r\n",
    "    (8, 224, 224), \r\n",
    "    as_strings = False, \r\n",
    "    print_per_layer_stat = False)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(re1)\r\n",
    "print(re2)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# [lib/models](Paddle_Cream\\lib\\models)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***[blocks](Paddle_Cream\\lib\\models\\blocks)***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.models.blocks import InvertedResidual, get_BasicBlock, get_Bottleneck"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 4>\r\n",
    "\r\n",
    "### InvertedResidual"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "invert_resi_block = InvertedResidual(\r\n",
    "    in_chs = 3, out_chs = 16, \r\n",
    "    dw_kernel_size = 3, stride = 1, dilation = 1,\r\n",
    "    exp_kernel_size = 1, pw_kernel_size=1, se_ratio=0., \r\n",
    "    drop_path_rate=0.)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 结构检查"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "invert_resi_model = paddle.Model(invert_resi_block)\r\n",
    "invert_resi_model.summary(input_size = (16, 3, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络组网与运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "invert_resi_block.eval()\r\n",
    "test_input = paddle.randn((16, 3, 224, 224))\r\n",
    "invert_resi_block(test_input)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 4>\r\n",
    "\r\n",
    "### get_BasicBlock()"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "basic_block = get_BasicBlock(3, 3, 1)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络结构检查"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "basic_block_model = paddle.Model(basic_block)\r\n",
    "basic_block_model.summary((16, 3, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "basic_block.eval()\r\n",
    "test_input = paddle.randn((16, 3, 224, 224))\r\n",
    "basic_block(test_input)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 4>\r\n",
    "\r\n",
    "### get_Bottleneck"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "bottleneck_block = get_Bottleneck(3, 8, 2)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络结构检查"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "bottleneck_model = paddle.Model(bottleneck_block)\r\n",
    "bottleneck_model.summary((16, 3, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "bottleneck_block.eval()\r\n",
    "test_input = paddle.randn((16, 3, 224, 224))\r\n",
    "bottleneck_block(test_input)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***[builders](Paddle_Cream\\lib\\models\\builders)***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.models.builders.build_childnet import ChildNetBuilder\r\n",
    "from Paddle_Cream.lib.models.builders.build_supernet import SuperNetBuilder"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### ChildNetBuilder"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "childnet_block = ChildNetBuilder()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "test_args = [[{\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"ds\",  \r\n",
    "        \"dw_kernel_size\": 3, \r\n",
    "        \"out_chs\": 16, \r\n",
    "        \"stride\": 2\r\n",
    "    }, {\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"ir\", \r\n",
    "        \"dw_kernel_size\": 5, \r\n",
    "        \"exp_ratio\": 6, \r\n",
    "        \"out_chs\": 24, \r\n",
    "        \"stride\": 2\r\n",
    "    }, {\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"ir\", \r\n",
    "        \"dw_kernel_size\": 5, \r\n",
    "        \"out_chs\": 40, \r\n",
    "        \"stride\": 1\r\n",
    "    }, {\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"ir\", \r\n",
    "        \"dw_kernel_size\": 5, \r\n",
    "        \"exp_ratio\": 6, \r\n",
    "        \"out_chs\": 40, \r\n",
    "        \"stride\": 1\r\n",
    "    }, {\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"ir\", \r\n",
    "        \"dw_kernel_size\": 5, \r\n",
    "        \"exp_ratio\": 6, \r\n",
    "        \"out_chs\": 80, \r\n",
    "        \"stride\": 1\r\n",
    "    }, {\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"ir\", \r\n",
    "        \"dw_kernel_size\": 5, \r\n",
    "        \"exp_ratio\": 6, \r\n",
    "        \"out_chs\": 80, \r\n",
    "        \"stride\": 1\r\n",
    "    }, {\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"ir\", \r\n",
    "        \"dw_kernel_size\": 3, \r\n",
    "        \"exp_ratio\": 6, \r\n",
    "        \"out_chs\": 96, \r\n",
    "        \"stride\": 1\r\n",
    "    }, {\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"ir\", \r\n",
    "        \"dw_kernel_size\": 5, \r\n",
    "        \"exp_ratio\": 6, \r\n",
    "        \"out_chs\": 192, \r\n",
    "        \"stride\": 1\r\n",
    "    }, {\r\n",
    "        \"act_layer\": paddle.nn.ReLU, \r\n",
    "        \"block_type\": \"cn\", \r\n",
    "        \"kernel_size\": 1, \r\n",
    "        \"out_chs\": 40, \r\n",
    "        \"stride\": 1\r\n",
    "    }\r\n",
    "]]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "test_stages = childnet_block(16, test_args)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 组网测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "test_models = []\r\n",
    "for stage in test_stages:\r\n",
    "    test_models.append(paddle.Model(stage))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "test_models[0].summary((16, 16, 32, 32))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### SuperNetBuilder"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "supernet_block = SuperNetBuilder({'kernel_size': [3, 5, 7], 'exp_ratio': [4, 6]})"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "test_stages = supernet_block(16, test_args)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "test_stages"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***[structures](Paddle_Cream\\lib\\models\\structures)***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.models.structures.supernet import gen_supernet\r\n",
    "from Paddle_Cream.lib.models.structures.childnet import gen_childnet"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### gen_supernet"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "model, sta_num, resolution = gen_supernet(\r\n",
    "    flops_minimum = 0, \r\n",
    "    flops_maximum = 300, \r\n",
    "    num_classes = 1000, \r\n",
    "    drop_rate = 0., \r\n",
    "    global_pool = \"avg\", \r\n",
    "    resunit = False, \r\n",
    "    dil_conv = False, \r\n",
    "    slice = 4, \r\n",
    "    verbose = False, \r\n",
    "    logger = None)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(sta_num)\r\n",
    "print(resolution)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络结构检查"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for name, layer in model.named_sublayers():\r\n",
    "    print(name, layer)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### gen_childnet"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "test_childnet = gen_childnet(\r\n",
    "    arch_list = [\r\n",
    "        [0], \r\n",
    "        [3], \r\n",
    "        [3, 3], \r\n",
    "        [3, 3], \r\n",
    "        [3, 3, 3], \r\n",
    "        [3, 3], \r\n",
    "        [0]], \r\n",
    "    # arch_list = [\r\n",
    "    #     [0], \r\n",
    "    #     [3], \r\n",
    "    #     [3, 3], \r\n",
    "    #     [3, 3], \r\n",
    "    #     [3], \r\n",
    "    #     [3], \r\n",
    "    #     [0]], \r\n",
    "    arch_def = [\r\n",
    "        [\"ds_r1_k3_s1_e1_c16_se0.25\"], \r\n",
    "        [\"ir_r1_k3_s2_e4_c24_se0.25\"], \r\n",
    "        [\"ir_r1_k5_s2_e4_c40_se0.25\"] * 2, \r\n",
    "        [\"ir_r1_k3_s2_e6_c80_se0.25\"] * 2, \r\n",
    "        [\"ir_r1_k3_s1_e6_c96_se0.25\"] * 3, \r\n",
    "        [\"ir_r1_k5_s2_e6_c192_se0.25\"] * 2, \r\n",
    "        [\"cn_r1_k1_s1_c320_se0.25\"]], \r\n",
    "    num_classes = 1000, \r\n",
    "    drop_rate = .2, \r\n",
    "    global_pool = \"avg\", )"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络结构检查"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "test_childnet_model = paddle.Model(test_childnet)\r\n",
    "test_childnet_model.summary((16, 3, 224, 224))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 网络运行测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "test_childnet.eval()\r\n",
    "re = test_childnet(paddle.randn((16, 3, 224, 224)))\r\n",
    "print([vec.index(max(vec)) for vec in re.tolist()])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***其他***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### MetaMatchingNetwork"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.models.MetaMatchingNetwork import MetaMatchingNetwork\r\n"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class no:\r\n",
    "    def __init__(self, include = False) -> None:\r\n",
    "        if include:\r\n",
    "            self.SUPERNET = no()\r\n",
    "            # self.SUPERNET.PICK_METHOD = \"meta\"\r\n",
    "            self.SUPERNET.PICK_METHOD = \"no\"\r\n",
    "            self.SUPERNET.SLICE = 4\r\n",
    "cfg = no(True)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "MetaMN = MetaMatchingNetwork(cfg)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "进行以下测试前请先在[lib/models/structures](Paddle_Cream\\lib\\models\\structures)的测试中生成超网络"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - forward_training调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "class TestMeta(paddle.autograd.PyLayer):\r\n",
    "    def __init__(self) -> None:\r\n",
    "        super().__init__()\r\n",
    "    \r\n",
    "    @staticmethod\r\n",
    "    def forward(ctx, x):\r\n",
    "        ctx.save_for_backward(x)\r\n",
    "        return paddle.to_tensor([.5])\r\n",
    "    \r\n",
    "    @staticmethod\r\n",
    "    def backward(ctx, dy):\r\n",
    "        x, = ctx.saved_tensor()\r\n",
    "        return paddle.ones(x.shape, dtype = paddle.float32)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "import paddle\r\n",
    "x = paddle.randn((16, 3, 224, 224))\r\n",
    "stu_cand = [[0], [3], [3, 3], [3, 3], [3, 3, 3], [3, 3], [0]]\r\n",
    "tch_cand = [[0], [2], [4, 2], [3, 0], [0, 3, 1], [3, 5], [0]]\r\n",
    "super_model = model\r\n",
    "target_tensor = [param for param in model.rand_parameters(tch_cand, True)][0]\r\n",
    "meta = TestMeta.apply(target_tensor)\r\n",
    "print(meta)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "loss = MetaMN.forward_training(\r\n",
    "    x = x, \r\n",
    "    model = super_model, \r\n",
    "    random_cand = stu_cand, \r\n",
    "    teacher_cand = tch_cand, \r\n",
    "    meta_value = meta)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(loss)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - calculate_1st_gradient调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from paddle.optimizer import SGD\r\n",
    "optim = SGD(learning_rate = 1000., parameters = super_model.parameters())"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "grad = MetaMN.calculate_1st_gradient(\r\n",
    "    kd_loss = loss, \r\n",
    "    model = super_model, \r\n",
    "    random_cand = stu_cand, \r\n",
    "    optimizer = optim)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for g in grad:\r\n",
    "    if type(g) == type(None):\r\n",
    "        print(g)\r\n",
    "    else:\r\n",
    "        print(g.norm())"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - simulate_sgd_update调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "students_weight = [\r\n",
    "    MetaMN.simulate_sgd_update(\r\n",
    "        p, grad_item, optim) for p, grad_item in zip(\r\n",
    "        model.rand_parameters(stu_cand), grad)]"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for weight_del in students_weight:\r\n",
    "    print(weight_del)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - update_student_weights_only调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "grad_v = MetaMN.calculate_2nd_gradient(\r\n",
    "    validation_loss = loss_v, \r\n",
    "    model = super_model, \r\n",
    "    optimizer = optim, \r\n",
    "    teacher_cand = tch_cand, \r\n",
    "    students_weight = students_weight)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for g in grad_v:\r\n",
    "    if type(g) == type(None):\r\n",
    "        print(g)\r\n",
    "    else:\r\n",
    "        print(g.norm())\r\n",
    "print(len(grad_v))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### PrioritizedBoard"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.models.PrioritizedBoard import PrioritizedBoard"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "class no:\r\n",
    "    def __init__(self, include = False) -> None:\r\n",
    "        if include:\r\n",
    "            self.SUPERNET = no()\r\n",
    "            self.SUPERNET.PICK_METHOD = \"meta\"\r\n",
    "            self.SUPERNET.SLICE = 4\r\n",
    "            self.SUPERNET.HOW_TO_PROB = \"teacher\"\r\n",
    "            self.SUPERNET.POOL_SIZE = 10\r\n",
    "cfg = no(True)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "board = PrioritizedBoard(cfg)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 杂类方法测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "prob = board.get_prob()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(prob)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "random_cand = board.get_cand_with_prob(prob)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(random_cand)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# [lib/utils](Paddle_Cream\\lib\\utils)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***[builder_util.py](Paddle_Cream\\lib\\utils\\builder_util.py)***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.builder_util import decode_block_str, init_weight_goog, efficientnet_init_weights"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "###  decode_block_str"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "str_eg = \"ir_r1_k3_s1_e4_c80_se0.25\"\r\n",
    "block_args, num_repeat = decode_block_str(str_eg)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "for item in block_args.items():\r\n",
    "    print(item)\r\n",
    "print(num_repeat)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### init_weight_goog"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试：CondConv2D"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.pimm.models import CondConv2D\r\n",
    "test_cond = CondConv2D(3, 8, 5)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(test_cond.weight[0][:10])\r\n",
    "print(test_cond.bias[0])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "init_weight_goog(test_cond)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(test_cond.weight[0][:10])\r\n",
    "print(test_cond.bias[0])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试：Conv2D"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from paddle.nn import Conv2D\r\n",
    "test_conv = Conv2D(16, 24, 3, 2, 1)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(test_conv.weight[0][:10])\r\n",
    "print(test_conv.bias)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "init_weight_goog(test_conv)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(test_conv.weight[0][:10])\r\n",
    "print(test_conv.bias)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试：BatchNorm2D"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from paddle.nn import BatchNorm2D\r\n",
    "from paddle.framework import create_parameter, ParamAttr\r\n",
    "from paddle.nn.initializer import Normal\r\n",
    "test_batch = BatchNorm2D(32)\r\n",
    "test_batch.weight = create_parameter(\r\n",
    "    test_batch.weight.shape, \r\n",
    "    test_batch.weight.dtype, \r\n",
    "    test_batch.weight.name, \r\n",
    "    ParamAttr(initializer = Normal()))\r\n",
    "test_batch.bias = create_parameter(\r\n",
    "    test_batch.bias.shape, \r\n",
    "    test_batch.bias.dtype, \r\n",
    "    test_batch.bias.name, \r\n",
    "    ParamAttr(initializer = Normal()))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(test_batch.weight)\r\n",
    "print(test_batch.bias)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "init_weight_goog(test_batch, last_bn = [])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(test_batch.weight)\r\n",
    "print(test_batch.bias)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试：Linear"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from paddle.nn import Linear\r\n",
    "test_linear = Linear(8, 8)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(test_linear.weight[0])\r\n",
    "print(test_linear.bias)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "init_weight_goog(test_linear)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "print(test_linear.weight[0])\r\n",
    "print(test_linear.bias)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "<font size = 3>\r\n",
    "\r\n",
    "### efficientnet_init_weights"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "efficientnet_init_weights(test_stages[0])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## ***[flops_table.py](Paddle_Cream\\lib\\utils\\flops_table.py)***"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - import测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "from Paddle_Cream.lib.utils.flops_table import FlopsEst"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 实例化测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "测试前请先在[lib/models/structures](Paddle_Cream\\lib\\models\\structures)的测试中生成超网络"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "model_est = FlopsEst(model, input_shape = (2, 3, 160, 160))"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "model_est.flops_dict"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "model_est.params_dict"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "#### - 调用测试"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "model_est.get_flops([\r\n",
    "        [0], \r\n",
    "        [3], \r\n",
    "        [3, 3], \r\n",
    "        [3, 3], \r\n",
    "        [3, 3, 3], \r\n",
    "        [3, 3], \r\n",
    "        [0]])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "source": [
    "model_est.get_params([\r\n",
    "        [0], \r\n",
    "        [3], \r\n",
    "        [3, 3], \r\n",
    "        [3, 3], \r\n",
    "        [3, 3, 3], \r\n",
    "        [3, 3], \r\n",
    "        [0]])"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# "
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "orig_nbformat": 4,
  "language_info": {
   "name": "python",
   "version": "3.8.1",
   "mimetype": "text/x-python",
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "pygments_lexer": "ipython3",
   "nbconvert_exporter": "python",
   "file_extension": ".py"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.8.1 64-bit"
  },
  "interpreter": {
   "hash": "9c4178638202bf36d847b6f9758ad492f78e3205c6ec371305eb925a87dfd87d"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}