import torch
y = torch.tensor([1,2,3],dtype = torch.float)
y_hat = torch.tensor([5,10,4],dtype = torch.float)
loss = torch.nn.MSELoss(reduction='mean')
print('MSELoss = ',loss(y_hat,y).item())

MSELoss = 0
for i in range(y.shape[0]):
    MSELoss += (y[i] - y_hat[i])**2 /2
MSELoss /= y.shape[0]
print('MSELoss = ',loss(y_hat,y).item())

import matplotlib.pyplot as plt
import torch

x = torch.linspace(-2, 2, steps =100,requires_grad=True) 
y = x**2
y.backward(torch.ones_like(x))

z = x.grad
# 激活第一个 subplot
plt.subplot(2,  1,  1)  
# 绘制第一个图像 
plt.plot(x.detach().numpy(), y.detach().numpy()) 
plt.title('Loss')  
# 将第二个 subplot 激活，并绘制第二个图像
plt.subplot(2,  1,  2) 
plt.plot(x.detach().numpy(),-z)
plt.title('grad')  
# 展示图像
plt.tight_layout() 
plt.show()

fig = plt.figure(figsize=(10,8), dpi= 80)
plt.subplot(2,  1,  1)  
x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)
y = torch.relu(x)
plt.plot(x.detach(), y.detach())
plt.title('ReLU')

plt.subplot(2,  1, 2)  
y = torch.sigmoid(x)
plt.plot(x.detach(), y.detach())
plt.title('Sigmod')

import matplotlib.pyplot as plt
def step_func(x): # 参数x可以接受numpy数组
    y = x >= 0 # y是布尔型数组
    return y.type(torch.int)

x = torch.arange(-5., 5., .1)
y = step_func(x)
plt.plot(x,y)
plt.ylim(-0.1, 1.1) # y轴范围
plt.title('step function')
plt.show()

import numpy as np
import torch

# 定义单个神经元 2输入
net = torch.nn.Sequential(torch.nn.Linear(2,1))#torch.nn.Hardtanh(min_val=0,max_val=3,inplace=True)) #

# 定义权重
w = torch.tensor([1,1]).type(torch.float32)
b = -2

net[0].weight.data = w.reshape(net[0].weight.shape)
net[0].bias.data.fill_(b)

# 验证输出
x = torch.tensor([1.0, 1.0]).type(torch.float32)
print('The result of 1 and 1 is', step_func(net.forward(x)).item())
x = torch.tensor([0, 1.0]).type(torch.float32)
print('The result of 1 and 1 is', step_func(net.forward(x)).item())
x = torch.tensor([0, 0]).type(torch.float32)
print('The result of 1 and 1 is', step_func(net.forward(x)).item())

torch.matmul(x, w) + b

import torch
from torch import nn
import matplotlib.pyplot as plt # 绘图与图像显示
import torch.utils.data as Data # 数据操作
from torchvision.datasets import MNIST,FashionMNIST # 数据集
from torchvision import transforms # 图像变换、数据预处理

#Compose是一个容器，传入的参数是列表，ToTensor()，类型变换，Normalize是数据标准化，去均值，除标准差
# transforms.ToTensor() 把取值[0, 255]的PIL图像形状为[H,W,C]转换为形状[C,H,W] 取值范围[0,1.0]的张量
transform = transforms.Compose([transforms.ToTensor()])

data_train = MNIST(root = "data/", ## 数据的路径，如果存在数据则加载，否则下载至此路径
                            transform = transform, ## 图像变换操作
                            train =True, ## 决定使用训练集还是测试集
                            download = True) ## 选择是否需要下载数据
data_test = MNIST(root = "data/",
                            transform = transform,
                            train =False)

for x,y in data_train:
    break

data_train[2][0].shape, len(data_train), len(data_test)

# plt.imshow(x[0].numpy().reshape(28,28))
# plt.show()
fig = plt.figure(figsize=(6,6))
for i in range(9):
  plt.subplot(3,3,i+1)
  plt.tight_layout()
  plt.imshow(data_train[i][0].numpy().reshape(28,28), cmap='gray', interpolation='none')
  plt.title("Digit: {}".format(data_train[i][1]))
  plt.xticks([])
  plt.yticks([])

fig = plt.figure(figsize = (10,6))
plt.subplot(2,1,1)
plt.imshow(data_train[0][0].numpy().reshape(28,28), cmap='gray', interpolation='none')
plt.title("Digit: {}".format(data_train[0][1]))
plt.xticks([])
plt.yticks([])
plt.subplot(2,1,2)
plt.hist(data_train[0][0].numpy().reshape(784))
plt.title("Pixel Value Distribution")

## 定义数据加载器
batch_size = 256

train_loader = Data.DataLoader(dataset = data_train, ## 使用的数据集
                                            batch_size = batch_size, ## 批处理样本大小
                                            shuffle = True ## 是否打乱数据顺序
                                            )

test_loader = Data.DataLoader(dataset = data_test,
                                            batch_size = batch_size,
                                            shuffle = True  #将顺序随机打乱
                                            )

## 定义网络模型
net = nn.Sequential(nn.Flatten(), ## 将二维图像展平位一维数组，输入层
                    nn.Linear(in_features = 784, ## 隐藏层的输入，数据的特征数
                              out_features = 512, ## 隐藏层的输出，对应神经元的数量
                             bias = True
                             ),  ## 
                    nn.ReLU(), ## 激活函数
                    nn.Dropout(p=0.2),
                    nn.Linear(512,512), nn.ReLU(),nn.Dropout(p=0.2),nn.Linear(512,10)) # 深度网络模型

# net = nn.Sequential(nn.Flatten(), nn.Linear(784, 256), nn.ReLU(), nn.Linear(256, 10)) # MLP模型

# net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10)) # softmax回归模型

## 初始化模型参数
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)

net.apply(init_weights);

len(train_loader),60000/256

for X, y in train_loader:
    break
output = net.forward(X)
X.shape, output.shape

lr, num_epochs = 0.1, 20 ## 定义学习率及训练次数
optimizer = torch.optim.SGD(net.parameters(), lr = lr) ## 定义优化器
loss_func = nn.CrossEntropyLoss(reduction='mean') ## 定义损失函数，分类问题一般使用交叉熵损失

train_loss_all = []
train_acc_all = []
test_acc_all = []
test_loss_all = []

for epoch in range(num_epochs):
    print("Epoch {}/{}".format(epoch+1,num_epochs))
    print("-"*10)
    
    running_loss = 0.0
    running_correct = 0.0
    
    for X, y in train_loader:
        net.train() ## 表明模型在训练
        output = net.forward(X) ## 模型在 X 上的输出: N * num_class
        train_loss = loss_func(output, y ) ## 交叉熵误差
        _, pred = torch.max(output.data, 1) ## 获得预测结果
        optimizer.zero_grad() ## 每次迭代将梯度初始化为0
        train_loss.backward() ## 损失的后向传播， 计算梯度
        optimizer.step() ## 使用梯度进行优化
        running_loss += train_loss.item() ## 统计模型预测损失
        running_correct += torch.sum(pred == y.data) ## 统计模型预测准确个数
        
    test_correct = 0
    val_loss = 0
    for data in test_loader:
        X_test, y_test = data        
        output = net(X_test)
        test_loss = loss_func(output, y_test )
        _, pred = torch.max(output.data, 1)
        test_correct += torch.sum(pred == y_test.data)
        val_loss += test_loss.item()
    print("Loss is:{:.4f}, Train_accuracy is {:.4f}%, Test_accuracy is {:.4f}%"
          .format(running_loss/len(train_loader),100*running_correct/len(data_train), 100*test_correct/len(data_test)))
    train_loss_all.append(running_loss/len(train_loader))
    train_acc_all.append(running_correct/len(data_train))
    test_loss_all.append(val_loss/len(test_loader))
    test_acc_all.append(test_correct/len(data_test))

# plotting the metrics
fig = plt.figure(figsize=(10,5))
plt.subplot(2,1,1)
plt.plot(train_acc_all)
plt.plot(test_acc_all)
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='lower right')

plt.subplot(2,1,2)
plt.plot(train_loss_all)
plt.plot(test_loss_all)
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
# plt.legend(['train'], loc='upper right')
plt.legend(['train', 'test'], loc='upper right')

plt.tight_layout()

# fig

torch.save(net, "result/class_5/mlp.pkl")

net_load = torch.load("result/class_5/mlp.pkl")
net_load.eval()

for X,y in test_loader:
    break
y_hat = net_load(X)

y_hat[0].reshape(-1,10).shape

y_hat.shape,y_hat[4],torch.softmax(y_hat[4].reshape(-1,10),dim=1)

score,pred = torch.max(torch.softmax(y_hat[:10],dim = 1), 1)
score,pred,y[:10]

fig = plt.figure(figsize=(6,6))
for i in range(9):
  plt.subplot(3,3,i+1)
  plt.tight_layout()
  plt.imshow(X[i].reshape(28,28), cmap='gray', interpolation='none')
  plt.title("Predicted {}, Truth {}".format(pred[i],y[i]))
  plt.xticks([])
  plt.yticks([])

fig = plt.figure(figsize=(6,6))
for i in range(9):
  plt.subplot(3,3,i+1)
  plt.tight_layout()
  plt.imshow(X[i].reshape(28,28), cmap='gray', interpolation='none')
  plt.title("Predicted {}, score {:.2f}".format(pred[i],score[i]))
  plt.xticks([])
  plt.yticks([])

import torch
import cv2
import numpy as np
# import matplotlib.colors as mat_color
from matplotlib import pyplot as plt

path = r"./https://haodong-li.com/zju/assets/img/vision_2022/loft.jpg"
img_bgr = cv2.imread(path)
print(np.shape(img_bgr))

# img_bgr = img_bgr.astype(np.float32)/255
plt.figure(figsize=(6,6))
img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
plt.imshow(img_rgb)

img_gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(img_gray, cmap='gray')
img_h, img_w = img_gray.shape

plt.subplot(1,2,2)

img_canny = cv2.Canny(img_gray, threshold1=70, threshold2=140,
                     apertureSize=3, L2gradient=False)
plt.imshow(img_canny,'gray')

# 获得模型输入
img_tensor = torch.from_numpy(img_gray.reshape((1,1,img_h,img_w)))

## 边缘提取
kersize = 7
ker = torch.ones(kersize,kersize,dtype=torch.float32)*-1
ker[3,3] = 48.0
ker = ker.reshape((1,1,kersize,kersize))
cov2d = torch.nn.Conv2d(1,1,(kersize,kersize),bias=False)
cov2d.weight.data[0] = ker
cov_out = cov2d(img_tensor/255)
cov_out = cov_out.data.squeeze()

plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(cov_out,cmap='gray')
plt.axis('off')

_, img_edge = cv2.threshold(cov_out.byte().numpy(), 200,255,cv2.THRESH_BINARY)
plt.subplot(1,2,2)
plt.imshow(img_edge,cmap='gray')
plt.axis('off')

contours, hierarchy = cv2.findContours(img_edge, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)  
print("number of contours: " + str(len(contours)))
img_rgb_copy = np.copy(img_rgb)
img_con = cv2.drawContours(img_rgb_copy, contours, -1, (0,0,255), 5)
plt.imshow(img_con)

img_rgb_copy = np.copy(img_rgb)
i = 0
for obj in contours:
    area = cv2.contourArea(obj)  #计算轮廓内区域的面积
#     cv2.drawContours(img_rgb_copy, obj, -1, (255, 0, 0), 4)  #绘制轮廓线
    perimeter = cv2.arcLength(obj,True)  #计算轮廓周长
    approx = cv2.approxPolyDP(obj,0.02*perimeter,True)  #获取轮廓角点坐标
    CornerNum = len(approx)   #轮廓角点的数量
    x, y, w, h = cv2.boundingRect(approx)  #获取坐标值和宽度、高度

    #轮廓对象分类
    if CornerNum ==3: objType ="triangle"
    elif CornerNum == 4:
        if area >= 1000:
            i += 1
            if i >=5:
                print(area)
                break

cv2.rectangle(img_rgb_copy,(x,y),(x+w,y+h),(0,255,0),2)  #绘制边界框
cv2.putText(img_rgb_copy,objType,(x+(w//2),y+(h//2)),cv2.FONT_HERSHEY_COMPLEX,0.6,(0,0,0),1)  #绘制文字
print('end')

x, y, w, h

plt.subplot(1,2,1)
num = img_gray[y+30:y+h-20,x+30:x+w-20] # img_bin
plt.imshow(num,'gray')

plt.subplot(1,2,2)
num = cv2.resize(num, (28, 28))
_, img_bin = cv2.threshold(num/255, 0.3,1,cv2.THRESH_BINARY_INV)
plt.imshow(img_bin,'gray')

net_load = torch.load("result/class_5/mlp.pkl")
net_load.eval()

sample = torch.tensor(img_bin,dtype = torch.float).reshape(-1,28,28)

y_hat = net_load(sample)
score,pred = torch.max(torch.softmax(y_hat[:10],dim = 1), 1)

plt.title("Predicted {}, score {:.2f}".format(pred.item(),score.item()))
plt.imshow(img_bin,'gray')

fig = plt.figure(figsize=(6,18))
for k in range(9):
    img_rgb_copy = np.copy(img_rgb)
    i = 0
    for obj in contours:
        area = cv2.contourArea(obj)  #计算轮廓内区域的面积
    #     cv2.drawContours(img_rgb_copy, obj, -1, (255, 0, 0), 4)  #绘制轮廓线
        perimeter = cv2.arcLength(obj,True)  #计算轮廓周长
        approx = cv2.approxPolyDP(obj,0.02*perimeter,True)  #获取轮廓角点坐标
        CornerNum = len(approx)   #轮廓角点的数量
        x, y, w, h = cv2.boundingRect(approx)  #获取坐标值和宽度、高度

        #轮廓对象分类
        if CornerNum ==3: objType ="triangle"
        elif CornerNum == 4:

            if area >= 1000:
                i += 1
                if i >=k+2:
                    break

    cv2.rectangle(img_rgb_copy,(x,y),(x+w,y+h),(0,255,0),2)  #绘制边界框
    cv2.putText(img_rgb_copy,objType,(x+(w//2),y+(h//2)),cv2.FONT_HERSHEY_COMPLEX,0.6,(0,0,0),1)  #绘制文字

    num = img_gray[y+30:y+h-20,x+30:x+w-20] # img_bin
    num = cv2.resize(num, (28, 28))
    _, img_bin = cv2.threshold(num/255, 0.3,1,cv2.THRESH_BINARY_INV)
    sample = torch.tensor(img_bin,dtype = torch.float).reshape(-1,28,28)
    y_hat = net_load(sample)
    score,pred = torch.max(torch.softmax(y_hat[:10],dim = 1), 1)
    
    plt.tight_layout()
    plt.subplot(9,2,k*2+1)
    plt.imshow(num,'gray')

    plt.subplot(9,2,k*2+2)
    plt.imshow(img_bin,'gray')
    plt.title("Predicted {}, score {:.2f}".format(pred.item(),score.item()))