T2_Code.ipynb · Likelihood-Lab/Local Parameterization

加入 Gitee

与超过 1200万开发者一起发现、参与优秀开源项目，私有仓库也完全免费：）

该仓库未声明开源许可证文件（LICENSE），使用请关注具体项目描述及其代码上游依赖。

克隆/下载

T2_Code.ipynb 85.40 KB

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 课题二：结合几何描述的卷积神经网络结构探究"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 似然实验室\n",
    "# 课题二：结合几何描述的卷积神经网络结构探究\n",
    "# 指导：左谭励\n",
    "# 作者: 梁晓航，曹嘉航\n",
    "\n",
    "\n",
    "# Likelihood Lab\n",
    "# Task 2: Research on the structure of convolutional neural network based on geometric description\n",
    "# Instructor: Tanli Zuo\n",
    "# Author: Xiaohang Liang, Jiahang Cao"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LPCNN 2.0\n",
    "# 默认环境：Anaconda\n",
    "\n",
    "from __future__ import print_function, division\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.optim import lr_scheduler\n",
    "import numpy as np\n",
    "import torchvision\n",
    "from torchvision import datasets, models, transforms #导出已有模型\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import os\n",
    "import copy\n",
    "import torch.nn.functional as F\n",
    "from torchvision.utils import save_image\n",
    "\n",
    "\n",
    "device=torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\") #使用cpu或者gpu\n",
    "\n",
    "\n",
    "# MNIST\n",
    "BATCH_SIZE = 64\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    transforms.Normalize((0.1307,), (0.3081,)),\n",
    "    ])\n",
    "\n",
    "# Train_data_set\n",
    "train_set = datasets.MNIST('./data', train=True, transform=transform, download=True)\n",
    "train_loader_mnist = torch.utils.data.DataLoader(train_set, \n",
    "                          batch_size=BATCH_SIZE,\n",
    "                          shuffle=True)\n",
    "\n",
    "# Test_data_set\n",
    "test_set = datasets.MNIST('./data', train=False, transform=transform, download=True)\n",
    "test_loader_mnist = torch.utils.data.DataLoader(test_set,\n",
    "                        batch_size=BATCH_SIZE,\n",
    "                        shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LPCNN 2.0\n",
    "import random\n",
    "import math\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import sklearn.pipeline as pl\n",
    "import sklearn.preprocessing as sp\n",
    "import sklearn.linear_model as lm\n",
    "import sklearn.metrics as sm\n",
    "from skimage import transform,data\n",
    "import math\n",
    "\n",
    "\n",
    "class LPNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(LPNet, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(13, 40, 2, 1, 0)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(40, 50, 3, 1, 0)\n",
    "        self.fc1 = nn.Linear(450, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 450)\n",
    "        stem = self.fc1(x)\n",
    "        return x, stem\n",
    "    \n",
    "    def test(self, x):\n",
    "        x=self.fc2(x)\n",
    "        return x\n",
    "\n",
    "tnet=LPNet()\n",
    "tnet=tnet.to(device)\n",
    "\n",
    "criterion1=torch.nn.CrossEntropyLoss().cuda()\n",
    "EPOCH=200\n",
    "ppp=56\n",
    "optimizer_161t=optim.SGD(tnet.parameters(),lr=0.1)\n",
    "\n",
    "tea_train=[]\n",
    "tea_test=[]\n",
    "score=[]\n",
    "    \n",
    "    \n",
    "for epoch in range(1,EPOCH):\n",
    "    print('\\nEpoch: %d'%(epoch))\n",
    "    sum_loss=0.0\n",
    "    correct=0.0\n",
    "    total=0.0\n",
    "    for i,data in enumerate(train_loader_mnist,0):\n",
    "        if i>1:\n",
    "            break\n",
    "        inputs, labels=data\n",
    "        m,n,p,q=inputs.shape\n",
    "        newinput=torch.ones(m,13,19,19)\n",
    "        for j in range(m):\n",
    "            out=torchvision.utils.make_grid(inputs[j,:,:,:])\n",
    "            pic=out.numpy()\n",
    "            pic=transform.resize(pic, (3,ppp,ppp))\n",
    "            \n",
    "            ith=0\n",
    "            itw=0\n",
    "            step=3\n",
    "            stride=3\n",
    "            a=0\n",
    "            numofline=0\n",
    "            record=[]\n",
    "\n",
    "            # Green Channel\n",
    "            while(ith+step<=pic.shape[1]):\n",
    "                itw=0\n",
    "                while(itw+step<=pic.shape[2]):\n",
    "                    proposal=pic[1,ith:ith+step,itw:itw+step]\n",
    "\n",
    "                    X=np.linspace(-3,3,step)\n",
    "                    wave=[]\n",
    "\n",
    "\n",
    "                    ## Edge Fitting\n",
    "                    # 左下到右上 \n",
    "                    Y=[]\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[step-1-v,v])\n",
    "\n",
    "                    Y1=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y1)))/step) \n",
    "\n",
    "                    Y=[]\n",
    "                    # 行\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[math.floor((step-1)/2),v])\n",
    "\n",
    "                    Y2=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y2)))/step) \n",
    "\n",
    "                    Y=[]\n",
    "                    # 列\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[v,math.floor((step-1)/2)])\n",
    "\n",
    "                    Y3=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y3)))/step) \n",
    "\n",
    "\n",
    "                    Y=[]\n",
    "                    # 左上到右下\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[v,v])\n",
    "\n",
    "                    Y4=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y4)))/step) #\n",
    "                    \n",
    "                    \n",
    "                    Y=[]\n",
    "                    # 左上弧\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[step-1-v,0])\n",
    "                    for v in range(step):\n",
    "                        if v==0:\n",
    "                            continue\n",
    "                        else:\n",
    "                            Y.append(proposal[0,v])\n",
    "                    Y5=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y5)))/(2*step-2))\n",
    "\n",
    "\n",
    "                    Y=[]\n",
    "                    # 右上弧\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[0,v])\n",
    "                    for v in range(step):\n",
    "                        if v==0:\n",
    "                            continue\n",
    "                        else:\n",
    "                            Y.append(proposal[v,step-1])\n",
    "                    Y6=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y6)))/(2*step-2))\n",
    "\n",
    "\n",
    "                    Y=[]\n",
    "                    # 左下弧\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[v,0])\n",
    "                    for v in range(step):\n",
    "                        if v==0:\n",
    "                            continue\n",
    "                        else:\n",
    "                            Y.append(proposal[step-1,v])\n",
    "                    Y7=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y7)))/(2*step-2))\n",
    "\n",
    "\n",
    "                    Y=[]\n",
    "                    # 右下弧\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[v,step-1])\n",
    "                    for v in range(step):\n",
    "                        if v==(step-1):\n",
    "                            continue\n",
    "                        else:\n",
    "                            Y.append(proposal[step-1,step-1-v])\n",
    "                    Y8=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y5)))/(2*step-2))\n",
    "\n",
    "                    Y=[]\n",
    "                    # 左线\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[v,0])\n",
    "\n",
    "                    Y9=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y9)))/(step-1)) \n",
    "\n",
    "                    Y=[]\n",
    "                    # 上线\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[0,v])\n",
    "\n",
    "                    Y10=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y10)))/(step-1)) \n",
    "\n",
    "                    Y=[]\n",
    "                    # 右线\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[v,step-1])\n",
    "\n",
    "                    Y11=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y11)))/(step-1)) \n",
    "\n",
    "                    Y=[]\n",
    "                    # 下线\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[step-1,v])\n",
    "\n",
    "                    Y12=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y12)))/(step-1))\n",
    "                    \n",
    "                    \n",
    "                    \n",
    "                    wave=np.array(wave)\n",
    "                    m=wave.shape[0]\n",
    "                    for i in range(m):\n",
    "                        if wave[i]==np.min(wave):\n",
    "                            break\n",
    "                    \n",
    "\n",
    "                    Y=[]\n",
    "                    record.append(wave)\n",
    "                    fx=0\n",
    "\n",
    "                    if i==1:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([-1,0,1,-1,0,1,-1,0,1])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[jj,ii]\n",
    "                                k+=1\n",
    "\n",
    "                        if target[math.floor((step-1)/2)-1,math.floor((step-1)/2)]-target[math.floor((step-1)/2)+1,math.floor((step-1)/2)]>0:\n",
    "                            fx=0.5\n",
    "                        else:\n",
    "                            fx=-0.5\n",
    "                        X0=np.linspace(-2,2,50)\n",
    "                        Y0=np.zeros(50)\n",
    "\n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "\n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),-1,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "\n",
    "\n",
    "                    elif i==2:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([-1,0,1,-1,0,1,-1,0,1])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "\n",
    "                        if target[math.floor((step-1)/2),math.floor((step-1)/2)-1]-target[math.floor((step-1)/2),math.floor((step-1)/2)+1]>0:\n",
    "                            fx=1\n",
    "                        else:\n",
    "                            fx=0\n",
    "                        X0=np.linspace(-2,2,50)\n",
    "                        Y0=np.zeros(50)\n",
    "\n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "#                         print(lin_reg_2.score(x0,y0))\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "\n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),0,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "\n",
    "                    elif i==0:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([-math.sqrt(2),-math.sqrt(2)/2,0,-math.sqrt(2)/2,0,math.sqrt(2)/2,0,math.sqrt(2)/2,math.sqrt(2)])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "\n",
    "                        if target[0,0]-target[math.floor(step-1),math.floor(step-1)]>0:\n",
    "                            fx=135/180\n",
    "                        else:\n",
    "                            fx=-45/180\n",
    "                        X0=np.linspace(-2,2,50)\n",
    "                        Y0=np.zeros(50)\n",
    "\n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "\n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(45-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                        \n",
    "                    elif i==3:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([0,math.sqrt(2)/2,math.sqrt(2),-math.sqrt(2)/2,0,math.sqrt(2)/2,-math.sqrt(2),-math.sqrt(2)/2,0])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "\n",
    "                        if target[0,math.floor(step-1)]-target[math.floor(step-1),0]>0:\n",
    "                            fx=45/180\n",
    "                        else:\n",
    "                            fx=-135/180\n",
    "                        X0=np.linspace(-2,2,50)\n",
    "                        Y0=np.zeros(50)\n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "\n",
    "                    elif i==4:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([0,0,0,0,1,1,0,1,2])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "                        if target[0,0]-target[math.floor(step-1),math.floor(step-1)]>0:\n",
    "                            fx=135/180\n",
    "                        else:\n",
    "                            fx=-45/180\n",
    "                            \n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                        \n",
    "                    elif i==5:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([0,0,0,1,1,0,2,1,0])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "                        if target[0,math.floor(step-1)]-target[math.floor(step-1),0]>0:\n",
    "                            fx=45/180\n",
    "                        else:\n",
    "                            fx=-135/180\n",
    "                            \n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                \n",
    "                    elif i==6:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([0,1,2,0,1,1,0,0,0])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "                        if target[0,0]-target[math.floor(step-1),math.floor(step-1)]>0:\n",
    "                            fx=135/180\n",
    "                        else:\n",
    "                            fx=-45/180\n",
    "                            \n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                \n",
    "                    elif i==7:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([2,1,0,1,1,0,0,0,0])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "                        if target[0,math.floor(step-1)]-target[math.floor(step-1),0]>0:\n",
    "                            fx=45/180\n",
    "                        else:\n",
    "                            fx=-135/180\n",
    "                            \n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                \n",
    "                    elif i==8:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([0,1,2,0,1,2,0,1,2])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "                        if target[0,0]-target[0,math.floor(step-1)]>0:\n",
    "                            fx=0/180\n",
    "                        else:\n",
    "                            fx=-180/180\n",
    "                            \n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                \n",
    "                    elif i==9:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([0,0,0,1,1,1,2,2,2])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "                        if target[0,0]-target[math.floor(step-1),0]>0:\n",
    "                            fx=-90/180\n",
    "                        else:\n",
    "                            fx=90/180\n",
    "                            \n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                \n",
    "                    elif i==10:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([2,1,0,2,1,0,2,1,0])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "                        if target[0,0]-target[0,math.floor(step-1)]>0:\n",
    "                            fx=0/180\n",
    "                        else:\n",
    "                            fx=-180/180\n",
    "                            \n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                \n",
    "                    elif i==11:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([2,2,2,1,1,1,0,0,0])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "                        if target[0,0]-target[math.floor(step-1),0]>0:\n",
    "                            fx=-90/180\n",
    "                        else:\n",
    "                            fx=-90/180\n",
    "                            \n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                \n",
    "                    itw+=stride\n",
    "                ith+=stride\n",
    "\n",
    "            \n",
    "\n",
    "\n",
    "        newinput, labels=newinput.to(device), labels.to(device)\n",
    "        \n",
    "        optimizer_161t.zero_grad()\n",
    "        stem_t,outputs=tnet(newinput)\n",
    "\n",
    "        loss=criterion1(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer_161t.step()\n",
    "        sum_loss+=loss.item()\n",
    "        \n",
    "        _,predicted=torch.max(outputs,1)\n",
    "        total+=labels.size(0)\n",
    "        correct+=predicted.eq(labels.data).sum()\n",
    "    print('Loss: %.03f | Acc: %.3f%%'%(sum_loss/(i+1),100.*correct/total))\n",
    "    tea_train.append(100.*correct/total)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        correct=0\n",
    "        total=0\n",
    "        kkk=0\n",
    "        for data in test_loader_mnist:\n",
    "            kkk+=1\n",
    "            if kkk>1:\n",
    "                break\n",
    "            tnet.eval()\n",
    "            images, labels=data\n",
    "            m,n,p,q=images.shape\n",
    "            newinput=torch.ones(m,13,19,19)\n",
    "            for j in range(m):\n",
    "                out=torchvision.utils.make_grid(images[j,:,:,:])\n",
    "                pic=out.numpy()\n",
    "                pic=transform.resize(pic, (3,ppp,ppp))\n",
    "\n",
    "                ith=0\n",
    "                itw=0\n",
    "                step=3\n",
    "                stride=3\n",
    "                a=0\n",
    "                numofline=0\n",
    "                record=[]\n",
    "\n",
    "                # Green Channel\n",
    "                while(ith+step<=pic.shape[1]):\n",
    "                    itw=0\n",
    "                    while(itw+step<=pic.shape[2]):\n",
    "                        proposal=pic[1,ith:ith+step,itw:itw+step]\n",
    "\n",
    "                        X=np.linspace(-3,3,step)\n",
    "                        wave=[]\n",
    "\n",
    "\n",
    "                        ## Edge Fitting\n",
    "                        # 左下到右上 \n",
    "                        Y=[]\n",
    "                        # 先判断波动性\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[step-1-v,v])\n",
    "\n",
    "                        Y1=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y1)))/step) \n",
    "\n",
    "                        Y=[]\n",
    "                        # 行\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[math.floor((step-1)/2),v])\n",
    "\n",
    "                        Y2=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y2)))/step) \n",
    "\n",
    "                        Y=[]\n",
    "                        # 列\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[v,math.floor((step-1)/2)])\n",
    "\n",
    "                        Y3=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y3)))/step) \n",
    "\n",
    "\n",
    "                        Y=[]\n",
    "                        # 左上到右下\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[v,v])\n",
    "\n",
    "                        Y4=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y4)))/step) \n",
    "\n",
    "\n",
    "                        Y=[]\n",
    "                        # 左上弧\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[step-1-v,0])\n",
    "                        for v in range(step):\n",
    "                            if v==0:\n",
    "                                continue\n",
    "                            else:\n",
    "                                Y.append(proposal[0,v])\n",
    "                        Y5=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y5)))/(2*step-2))\n",
    "\n",
    "\n",
    "                        Y=[]\n",
    "                        # 右上弧\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[0,v])\n",
    "                        for v in range(step):\n",
    "                            if v==0:\n",
    "                                continue\n",
    "                            else:\n",
    "                                Y.append(proposal[v,step-1])\n",
    "                        Y6=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y6)))/(2*step-2))\n",
    "\n",
    "\n",
    "                        Y=[]\n",
    "                        # 左下弧\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[v,0])\n",
    "                        for v in range(step):\n",
    "                            if v==0:\n",
    "                                continue\n",
    "                            else:\n",
    "                                Y.append(proposal[step-1,v])\n",
    "                        Y7=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y7)))/(2*step-2))\n",
    "\n",
    "\n",
    "                        Y=[]\n",
    "                        # 右下弧\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[v,step-1])\n",
    "                        for v in range(step):\n",
    "                            if v==(step-1):\n",
    "                                continue\n",
    "                            else:\n",
    "                                Y.append(proposal[step-1,step-1-v])\n",
    "                        Y8=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y5)))/(2*step-2))\n",
    "\n",
    "                        Y=[]\n",
    "                        # 左线\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[v,0])\n",
    "\n",
    "                        Y9=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y9)))/(step-1)) \n",
    "\n",
    "                        Y=[]\n",
    "                        # 上线\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[0,v])\n",
    "\n",
    "                        Y10=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y10)))/(step-1)) \n",
    "\n",
    "                        Y=[]\n",
    "                        # 右线\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[v,step-1])\n",
    "\n",
    "                        Y11=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y11)))/(step-1)) \n",
    "\n",
    "                        Y=[]\n",
    "                        # 下线\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[step-1,v])\n",
    "\n",
    "                        Y12=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y12)))/(step-1)) \n",
    "\n",
    "\n",
    "\n",
    "                        wave=np.array(wave)\n",
    "                        m=wave.shape[0]\n",
    "                        for i in range(m):\n",
    "                            if wave[i]==np.min(wave):\n",
    "                                break\n",
    "\n",
    "\n",
    "                        Y=[]\n",
    "                        # \n",
    "                        record.append(wave)\n",
    "                        fx=0\n",
    "\n",
    "                        if i==1:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([-1,0,1,-1,0,1,-1,0,1])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[jj,ii]\n",
    "                                    k+=1\n",
    "\n",
    "                            if target[math.floor((step-1)/2)-1,math.floor((step-1)/2)]-target[math.floor((step-1)/2)+1,math.floor((step-1)/2)]>0:\n",
    "                                fx=0.5\n",
    "                            else:\n",
    "                                fx=-0.5\n",
    "                            X0=np.linspace(-2,2,50)\n",
    "                            Y0=np.zeros(50)\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),-1,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "\n",
    "                        elif i==2:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([-1,0,1,-1,0,1,-1,0,1])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "\n",
    "                            if target[math.floor((step-1)/2),math.floor((step-1)/2)-1]-target[math.floor((step-1)/2),math.floor((step-1)/2)+1]>0:\n",
    "                                fx=1\n",
    "                            else:\n",
    "                                fx=0\n",
    "                            X0=np.linspace(-2,2,50)\n",
    "                            Y0=np.zeros(50)\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),0,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==0:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([-math.sqrt(2),-math.sqrt(2)/2,0,-math.sqrt(2)/2,0,math.sqrt(2)/2,0,math.sqrt(2)/2,math.sqrt(2)])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "\n",
    "                            if target[0,0]-target[math.floor(step-1),math.floor(step-1)]>0:\n",
    "                                fx=135/180\n",
    "                            else:\n",
    "                                fx=-45/180\n",
    "                            X0=np.linspace(-2,2,50)\n",
    "                            Y0=np.zeros(50)\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(45-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==3:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([0,math.sqrt(2)/2,math.sqrt(2),-math.sqrt(2)/2,0,math.sqrt(2)/2,-math.sqrt(2),-math.sqrt(2)/2,0])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "\n",
    "                            if target[0,math.floor(step-1)]-target[math.floor(step-1),0]>0:\n",
    "                                fx=45/180\n",
    "                            else:\n",
    "                                fx=-135/180\n",
    "                            X0=np.linspace(-2,2,50)\n",
    "                            Y0=np.zeros(50)\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==4:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([0,0,0,0,1,1,0,1,2])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,0]-target[math.floor(step-1),math.floor(step-1)]>0:\n",
    "                                fx=135/180\n",
    "                            else:\n",
    "                                fx=-45/180\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==5:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([0,0,0,1,1,0,2,1,0])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,math.floor(step-1)]-target[math.floor(step-1),0]>0:\n",
    "                                fx=45/180\n",
    "                            else:\n",
    "                                fx=-135/180\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==6:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([0,1,2,0,1,1,0,0,0])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,0]-target[math.floor(step-1),math.floor(step-1)]>0:\n",
    "                                fx=135/180\n",
    "                            else:\n",
    "                                fx=-45/180\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==7:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([2,1,0,1,1,0,0,0,0])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,math.floor(step-1)]-target[math.floor(step-1),0]>0:\n",
    "                                fx=45/180\n",
    "                            else:\n",
    "                                fx=-135/180\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==8:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([0,1,2,0,1,2,0,1,2])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,0]-target[0,math.floor(step-1)]>0:\n",
    "                                fx=0/180\n",
    "                            else:\n",
    "                                fx=-180/180\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==9:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([0,0,0,1,1,1,2,2,2])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,0]-target[math.floor(step-1),0]>0:\n",
    "                                fx=-90/180\n",
    "                            else:\n",
    "                                fx=90/180\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==10:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([2,1,0,2,1,0,2,1,0])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,0]-target[0,math.floor(step-1)]>0:\n",
    "                                fx=0/180\n",
    "                            else:\n",
    "                                fx=-180/180\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==11:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([2,2,2,1,1,1,0,0,0])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,0]-target[math.floor(step-1),0]>0:\n",
    "                                fx=-90/180\n",
    "                            else:\n",
    "                                fx=-90/180\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "\n",
    "                        itw+=stride\n",
    "                    ith+=stride\n",
    "\n",
    "            \n",
    "\n",
    "\n",
    "            newinput, labels=newinput.to(device), labels.to(device)\n",
    "            stem_t,outputs=tnet(newinput)\n",
    "            _,predicted=torch.max(outputs,1)\n",
    "            total+=labels.size(0)\n",
    "            correct+=predicted.eq(labels.data).sum()\n",
    "        acc=100 * correct / total\n",
    "    print('Test Acc:%.3f%%'%acc)\n",
    "    tea_test.append(acc)\n",
    "    \n",
    "print('LPCNN Finish!')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# LPCNN 1.0\n",
    "import random\n",
    "import math\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import sklearn.pipeline as pl\n",
    "import sklearn.preprocessing as sp\n",
    "import sklearn.linear_model as lm\n",
    "import sklearn.metrics as sm\n",
    "import math\n",
    "\n",
    "\n",
    "class LPNet1(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(LPNet1, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(13, 40, 1, 1, 0)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(40, 50, 3, 1, 0)\n",
    "        self.fc1 = nn.Linear(50, 10)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 50)\n",
    "        stem = self.fc1(x)\n",
    "        return x, stem\n",
    "    \n",
    "    def test(self, x):\n",
    "        x=self.fc2(x)\n",
    "        return x\n",
    "\n",
    "\n",
    "tnet=LPNet1()\n",
    "tnet=tnet.to(device)\n",
    "\n",
    "criterion1=torch.nn.CrossEntropyLoss().cuda()\n",
    "EPOCH=200\n",
    "optimizer_161t=optim.SGD(tnet.parameters(),lr=0.08)\n",
    "\n",
    "tea_train=[]\n",
    "tea_test=[]\n",
    "score=[]\n",
    "    \n",
    "\n",
    "    \n",
    "for epoch in range(1,EPOCH):\n",
    "    print('\\nEpoch: %d'%(epoch))\n",
    "    sum_loss=0.0\n",
    "    correct=0.0\n",
    "    total=0.0\n",
    "    for i,data in enumerate(train_loader_mnist,0):\n",
    "        if i>6:\n",
    "            break\n",
    "        inputs, labels=data\n",
    "        m,n,p,q=inputs.shape\n",
    "        newinput=torch.ones(m,13,10,10)\n",
    "        for j in range(m):\n",
    "            out=torchvision.utils.make_grid(inputs[j,:,:,:])\n",
    "            pic=out.numpy()\n",
    "            \n",
    "            # 三通道局部向量\n",
    "            \n",
    "            ith=0\n",
    "            itw=0\n",
    "            step=3\n",
    "            stride=3\n",
    "            a=0\n",
    "            numofline=0\n",
    "            record=[]\n",
    "\n",
    "            # 绿区\n",
    "            while(ith+step<=pic.shape[1]):\n",
    "                itw=0\n",
    "                while(itw+step<=pic.shape[2]):\n",
    "                    proposal=pic[1,ith:ith+step,itw:itw+step]\n",
    "\n",
    "                    X=np.linspace(-3,3,step)\n",
    "                    wave=[]\n",
    "\n",
    "\n",
    "                    ## 边缘拟合\n",
    "                    # 左下到右上 \n",
    "                    Y=[]\n",
    "                    # 先判断波动性\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[step-1-v,v])\n",
    "\n",
    "                    Y1=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y1)))/step) \n",
    "\n",
    "                    Y=[]\n",
    "                    # 行\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[math.floor((step-1)/2),v])\n",
    "\n",
    "                    Y2=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y2)))/step) \n",
    "\n",
    "                    Y=[]\n",
    "                    # 列\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[v,math.floor((step-1)/2)])\n",
    "\n",
    "                    Y3=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y3)))/step) \n",
    "\n",
    "\n",
    "                    Y=[]\n",
    "                    # 左上到右下\n",
    "                    for v in range(step):\n",
    "                        Y.append(proposal[v,v])\n",
    "\n",
    "                    Y4=np.array(Y)\n",
    "                    wave.append(np.sum(np.abs(np.diff(Y4)))/step) \n",
    "\n",
    "                    wave=np.array(wave)\n",
    "                    m=wave.shape[0]\n",
    "                    for i in range(m):\n",
    "                        if wave[i]==np.min(wave):\n",
    "                            break\n",
    "\n",
    "\n",
    "                    Y=[]\n",
    "                    # \n",
    "                    record.append(wave)\n",
    "                    fx=0\n",
    "\n",
    "                    if i==1:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([-1,0,1,-1,0,1,-1,0,1])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[jj,ii]\n",
    "                                k+=1\n",
    "\n",
    "                        if target[math.floor((step-1)/2)-1,math.floor((step-1)/2)]-target[math.floor((step-1)/2)+1,math.floor((step-1)/2)]>0:\n",
    "                            fx=0.5\n",
    "                        else:\n",
    "                            fx=-0.5\n",
    "                        X0=np.linspace(-2,2,50)\n",
    "                        Y0=np.zeros(50)\n",
    "\n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "\n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),-1,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "\n",
    "\n",
    "                    elif i==2:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([-1,0,1,-1,0,1,-1,0,1])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "\n",
    "                        if target[math.floor((step-1)/2),math.floor((step-1)/2)-1]-target[math.floor((step-1)/2),math.floor((step-1)/2)+1]>0:\n",
    "                            fx=1\n",
    "                        else:\n",
    "                            fx=0\n",
    "                        X0=np.linspace(-2,2,50)\n",
    "                        Y0=np.zeros(50)\n",
    "\n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "\n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),0,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "\n",
    "                    elif i==0:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([-math.sqrt(2),-math.sqrt(2)/2,0,-math.sqrt(2)/2,0,math.sqrt(2)/2,0,math.sqrt(2)/2,math.sqrt(2)])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "\n",
    "                        if target[0,0]-target[math.floor(step-1),math.floor(step-1)]>0:\n",
    "                            fx=135/180\n",
    "                        else:\n",
    "                            fx=-45/180\n",
    "                        X0=np.linspace(-2,2,50)\n",
    "                        Y0=np.zeros(50)\n",
    "\n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "\n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(45-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "                        \n",
    "                    elif i==3:\n",
    "                        target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                        x0=np.array([0,math.sqrt(2)/2,math.sqrt(2),-math.sqrt(2)/2,0,math.sqrt(2)/2,-math.sqrt(2),-math.sqrt(2)/2,0])\n",
    "                        y0=np.zeros(9)\n",
    "                        k=0\n",
    "                        for ii in range(3):\n",
    "                            for jj in range(3):\n",
    "                                y0[k]=target[ii,jj]\n",
    "                                k+=1\n",
    "\n",
    "                        if target[0,math.floor(step-1)]-target[math.floor(step-1),0]>0:\n",
    "                            fx=45/180\n",
    "                        else:\n",
    "                            fx=-135/180\n",
    "                        X0=np.linspace(-2,2,50)\n",
    "                        Y0=np.zeros(50)\n",
    "                        x0=np.array(x0).reshape([-1,1])\n",
    "                        y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                        poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                        x0=poly_reg.fit_transform(x0)\n",
    "                        lin_reg_2=lm.LinearRegression()\n",
    "                        lin_reg_2.fit(x0,y0)\n",
    "                        score.append(lin_reg_2.score(x0,y0))\n",
    "                        X0=X0.reshape([-1,1])\n",
    "                        \n",
    "                        newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                        numofline+=1\n",
    "\n",
    "                    \n",
    "                    itw+=stride\n",
    "                ith+=stride\n",
    "\n",
    "            \n",
    "\n",
    "\n",
    "        newinput, labels=newinput.to(device), labels.to(device)\n",
    "        \n",
    "        optimizer_161t.zero_grad()\n",
    "        stem_t,outputs=tnet(newinput)\n",
    "\n",
    "        loss=criterion1(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer_161t.step()\n",
    "        sum_loss+=loss.item()\n",
    "        \n",
    "        _,predicted=torch.max(outputs,1)\n",
    "        total+=labels.size(0)\n",
    "        correct+=predicted.eq(labels.data).sum()\n",
    "    print('Loss: %.03f | Acc: %.3f%%'%(sum_loss/(i+1),100.*correct/total))\n",
    "    tea_train.append(100.*correct/total)\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        correct=0\n",
    "        total=0\n",
    "        kkk=0\n",
    "        for data in test_loader_mnist:\n",
    "            kkk+=1\n",
    "            if kkk>3:\n",
    "                break\n",
    "            tnet.eval()\n",
    "            images, labels=data\n",
    "            m,n,p,q=images.shape\n",
    "            newinput=torch.ones(m,13,10,10)\n",
    "            for j in range(m):\n",
    "                out=torchvision.utils.make_grid(images[j,:,:,:])\n",
    "                pic=out.numpy()\n",
    "\n",
    "                # 三通道局部向量\n",
    "\n",
    "                ith=0\n",
    "                itw=0\n",
    "                step=3\n",
    "                stride=3\n",
    "                a=0\n",
    "                numofline=0\n",
    "                record=[]\n",
    "\n",
    "                # 绿区\n",
    "                while(ith+step<=pic.shape[1]):\n",
    "                    itw=0\n",
    "                    while(itw+step<=pic.shape[2]):\n",
    "                        proposal=pic[1,ith:ith+step,itw:itw+step]\n",
    "\n",
    "                        X=np.linspace(-3,3,step)\n",
    "                        wave=[]\n",
    "\n",
    "\n",
    "                        ## 边缘拟合\n",
    "                        # 左下到右上 \n",
    "                        Y=[]\n",
    "                        # 先判断波动性\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[step-1-v,v])\n",
    "\n",
    "                        Y1=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y1)))/step) \n",
    "\n",
    "                        Y=[]\n",
    "                        # 行\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[math.floor((step-1)/2),v])\n",
    "\n",
    "                        Y2=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y2)))/step) \n",
    "\n",
    "                        Y=[]\n",
    "                        # 列\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[v,math.floor((step-1)/2)])\n",
    "\n",
    "                        Y3=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y3)))/step) \n",
    "\n",
    "\n",
    "                        Y=[]\n",
    "                        # 左上到右下\n",
    "                        for v in range(step):\n",
    "                            Y.append(proposal[v,v])\n",
    "\n",
    "                        Y4=np.array(Y)\n",
    "                        wave.append(np.sum(np.abs(np.diff(Y4)))/step) \n",
    "\n",
    "                        wave=np.array(wave)\n",
    "                        m=wave.shape[0]\n",
    "                        for i in range(m):\n",
    "                            if wave[i]==np.min(wave):\n",
    "                                break\n",
    "\n",
    "\n",
    "                        Y=[]\n",
    "                        record.append(wave)\n",
    "\n",
    "                        if i==1:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([-1,0,1,-1,0,1,-1,0,1])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[jj,ii]\n",
    "                                    k+=1\n",
    "\n",
    "                            if target[math.floor((step-1)/2)-1,math.floor((step-1)/2)]-target[math.floor((step-1)/2)+1,math.floor((step-1)/2)]>0:\n",
    "                                fx=0.5\n",
    "                            else:\n",
    "                                fx=-0.5\n",
    "                            X0=np.linspace(-2,2,50)\n",
    "                            Y0=np.zeros(50)\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "#                             print(lin_reg_2.score(x0,y0))\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),-1,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "\n",
    "                        elif i==2:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([-1,0,1,-1,0,1,-1,0,1])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "\n",
    "                            if target[math.floor((step-1)/2),math.floor((step-1)/2)-1]-target[math.floor((step-1)/2),math.floor((step-1)/2)+1]>0:\n",
    "                                fx=1\n",
    "                            else:\n",
    "                                fx=0\n",
    "                            X0=np.linspace(-2,2,50)\n",
    "                            Y0=np.zeros(50)\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),0,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==0:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([-math.sqrt(2),-math.sqrt(2)/2,0,-math.sqrt(2)/2,0,math.sqrt(2)/2,0,math.sqrt(2)/2,math.sqrt(2)])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,0]-target[math.floor(step-1),math.floor(step-1)]>0:\n",
    "                                fx=135/180\n",
    "                            else:\n",
    "                                fx=-45/180\n",
    "                            X0=np.linspace(-2,2,50)\n",
    "                            Y0=np.zeros(50)\n",
    "\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(45-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "                        elif i==3:\n",
    "                            target=pic[1,ith:ith+step,itw:itw+step]\n",
    "                            x0=np.array([0,math.sqrt(2)/2,math.sqrt(2),-math.sqrt(2)/2,0,math.sqrt(2)/2,-math.sqrt(2),-math.sqrt(2)/2,0])\n",
    "                            y0=np.zeros(9)\n",
    "                            k=0\n",
    "                            for ii in range(3):\n",
    "                                for jj in range(3):\n",
    "                                    y0[k]=target[ii,jj]\n",
    "                                    k+=1\n",
    "                            if target[0,math.floor(step-1)]-target[math.floor(step-1),0]>0:\n",
    "                                fx=45/180\n",
    "                            else:\n",
    "                                fx=-135/180\n",
    "                            X0=np.linspace(-2,2,50)\n",
    "                            Y0=np.zeros(50)\n",
    "                            x0=np.array(x0).reshape([-1,1])\n",
    "                            y0=np.array(y0).reshape([-1,1])\n",
    "\n",
    "                            poly_reg =sp.PolynomialFeatures(degree=3)\n",
    "                            x0=poly_reg.fit_transform(x0)\n",
    "                            lin_reg_2=lm.LinearRegression()\n",
    "                            lin_reg_2.fit(x0,y0)\n",
    "                            score.append(lin_reg_2.score(x0,y0))\n",
    "                            X0=X0.reshape([-1,1])\n",
    "\n",
    "                            newinput[j,:,math.floor(ith/3),math.floor(itw/3)]=torch.tensor([target.mean(),lin_reg_2.coef_[0][0],lin_reg_2.coef_[0][1],lin_reg_2.coef_[0][2],lin_reg_2.coef_[0][3],(math.floor(ith+(step+1)/2)-13)/2,(itw+math.floor((step+1)/2)-13)/2,np.min(wave),(135-90)/90,fx,np.max(wave),target.max(),target.min()])\n",
    "                            numofline+=1\n",
    "\n",
    "\n",
    "                        itw+=stride\n",
    "                    ith+=stride\n",
    "\n",
    "            \n",
    "\n",
    "\n",
    "            newinput, labels=newinput.to(device), labels.to(device)\n",
    "            stem_t,outputs=tnet(newinput)\n",
    "            _,predicted=torch.max(outputs,1)\n",
    "            total+=labels.size(0)\n",
    "            correct+=predicted.eq(labels.data).sum()\n",
    "        acc=100 * correct / total\n",
    "    print('Test Acc:%.3f%%'%acc)\n",
    "    tea_test.append(acc)\n",
    "    \n",
    "print('LPCNN Finish!')\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3.7.3 64-bit ('base': conda)",
   "language": "python",
   "name": "python37364bitbaseconda97a7841a91934ca0b41177e871255bf9"
  },
  "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.7.3"
  },
  "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": 2
}

一键复制编辑原始数据按行查看历史

提交于 2020-11-27 20:06 . code

马建仓 AI 助手

尝试更多

代码解读

代码找茬

代码优化

https://gitee.com/likelihoodlab/local-parameterization.git

git@gitee.com:likelihoodlab/local-parameterization.git

likelihoodlab

local-parameterization

Local Parameterization

master

Likelihood-Lab/Local Parameterization

简介

发行版

贡献者

近期动态

Likelihood-Lab/Local Parameterization .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

Likelihood-Lab/Local Parameterization