```python
# -*- coding: utf-8 -*-
# @Time    : 2023/1/6 16:36
# @Author  : 之落花--falling_flowers
# @File    : nndemo_mnist.py
# @Software: PyCharm
import time

import numpy as np
from matplotlib import pyplot as plt

import datasets
import nn
import optim


class Net(nn.LearnLayer):
    def __init__(self):
        self.state = 'train'
        self.loss = []
        self.fc1 = nn.Linear(784, 200)
        self.fc2 = nn.Linear(200, 100)
        self.fc3 = nn.Linear(100, 10, 'x')
        self.flatten = nn.Flatten()
        self.relu = nn.Relu()
        self.softmax = nn.Softmax()

    def forward(self, x: np.ndarray) -> nn.Tensor:
        x = nn.Tensor(x)
        x = self.flatten(x)
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.fc3(x)
        x = self.softmax(x)
        return x

    def backward(self, e, parameter: dict):
        pass

    def __call__(self, x):
        return self.forward(x)

    def parameters(self) -> list:
        parameter = []
        for i in self.__dict__.values():
            if isinstance(i, nn.LearnLayer):
                parameter.extend(i.parameters())
        return parameter


def train(epoches):
    ts = np.eye(10)
    net = Net()
    optimizer = optim.Adam(net.parameters(), 0.001, 0.9, 0.9)
    loss_fn = optim.CrossEntropyLoss()
    batch_size = 10
    trainset = datasets.MNIST(True, batch_size, True)
    testset = datasets.MNIST(False)
    for epoch in range(epoches):
        plt.title('net.loss')
        plt.xlabel('batches')
        plt.ylabel('loss')
        net.state = 'train'
        t = time.time()
        for label, data in trainset:
            target = ts[label]
            out = net(data)
            e = target - out.tensor
            net.loss.append(loss_fn(out, target))
            for i in out.cache[::-1]:
                e = i[0].backward(e, i[1])
            optimizer.step()
        print('epoch: {}    use time: {:.3f}s    '.format(epoch + 1, time.time() - t), end='')
        plt.scatter(np.arange(1, len(net.loss) + 1), np.array(net.loss) / batch_size, 3, marker='.')
        plt.show()
        net.loss.clear()
        net.state = 'test'
        c = 0
        for label, data in testset:
            if np.argmax(net(data).tensor) == label:
                c += 1
        print(f'Correct rate: {c / 100}%')


def main():
    np.random.seed(2)
    epoch = 10
    train(epoch)


if __name__ == '__main__':
    main()
```

自己写的框架,反向传播有点粗糙不过不是残差网络的话还能用,卷积层还没实现

快开学了其他的再说吧hhh

10个epoch, Correct rate到了97.42%

还算不错吧

![](https://content.hackertalk.net/pub/EN1yg8-eaZBDeK)

![](https://content.hackertalk.net/pub/r3woEp-6J4GAmv)

所以还是pytorch省心,自己写框架什么的太麻烦了QAQ

神经网络(无卷积) MNIST数据集

逻辑非常简单，需要`numpy` `pillow`库，需要位运算基础，直接上代码：

```python
from PIL import Image
import numpy as np


def pack(img: np.ndarray[np.uint8], text: str, encoding: str = 'utf-8') -> np.ndarray[np.uint8]:
    img_shape = img.shape  # 存储原始图片大小
    # 将图片转为[r,g,b,r,g,b,...,r,g,b]形式
    img = img.reshape(img_shape[0]*img_shape[1]*img_shape[2])
    text = list(bytearray(text, encoding))  # 文本转字节串列表
    bytes_long = len(text)  # 文本大小
    # 隐写文本大小
    img[-8] = (img[-8] & 0b1111_1100) | ((bytes_long >> 14) & 0b0000_0011)
    img[-7] = (img[-7] & 0b1111_1100) | ((bytes_long >> 12) & 0b0000_0011)
    img[-6] = (img[-6] & 0b1111_1100) | ((bytes_long >> 10) & 0b0000_0011)
    img[-5] = (img[-5] & 0b1111_1100) | ((bytes_long >> 8) & 0b0000_0011)
    img[-4] = (img[-4] & 0b1111_1100) | ((bytes_long >> 6) & 0b0000_0011)
    img[-3] = (img[-3] & 0b1111_1100) | ((bytes_long >> 4) & 0b0000_0011)
    img[-2] = (img[-2] & 0b1111_1100) | ((bytes_long >> 2) & 0b0000_0011)
    img[-1] = (img[-1] & 0b1111_1100) | ((bytes_long     ) & 0b0000_0011)
    # 隐写文本内容
    for i in range(bytes_long):
        byte = text[i]  # 按字节隐写
        img[i * 4    ] = (img[i * 4    ] & 0b1111_1100) | ((byte >> 6) & 0b0000_0011)
        img[i * 4 + 1] = (img[i * 4 + 1] & 0b1111_1100) | ((byte >> 4) & 0b0000_0011)
        img[i * 4 + 2] = (img[i * 4 + 2] & 0b1111_1100) | ((byte >> 2) & 0b0000_0011)
        img[i * 4 + 3] = (img[i * 4 + 3] & 0b1111_1100) | ((byte     ) & 0b0000_0011)
    img = img.reshape(img_shape)  # 复原图片形状
    return img


def unpack(img: np.ndarray[np.uint8], encoding: str = 'utf-8') -> str:
    # 将图片转为[r,g,b,r,g,b,...,r,g,b]形式
    img = img.reshape(img.shape[0]*img.shape[1]*img.shape[2])
    # 解码文本大小
    bytes_long = (((img[-8] << 14) & 0b1100_0000_0000_0000) |
                  ((img[-7] << 12) & 0b0000_0000_0000_0000) |
                  ((img[-6] << 10) & 0b0000_1100_0000_0000) |
                  ((img[-5] << 8 ) & 0b0000_0011_0000_0000) |
                  ((img[-4] << 6 ) & 0b0000_0000_1100_0000) |
                  ((img[-3] << 4 ) & 0b0000_0000_0011_0000) |
                  ((img[-2] << 2 ) & 0b0000_0000_0000_1100) |
                  ((img[-1]      ) & 0b0000_0000_0000_0011))
    # 按字节复原文本内容
    text = b''
    for i in range(bytes_long):
        byte = img[i * 4:i * 4 + 4]
        byte = (((byte[0] << 6) & 0b1100_0000) | ((byte[1] << 4) & 0b0011_0000) |
                ((byte[2] << 2) & 0b0000_1100) | (byte[3]        & 0b0000_0011))
        text += int(byte).to_bytes()
    text = str(text, encoding=encoding)  # 以特定编码转为字符串
    return text


if __name__ == '__main__':
    # 隐写
    img = Image.open(r"E:\Users\Expector\Desktop\lty.png")
    text = open(r"E:\Users\Expector\Desktop\book.txt", 'r', encoding='utf-8')
    img = Image.fromarray(pack(np.array(img), text.read()))
    img.save(r"E:\Users\Expector\Desktop\lty.c.png")

    # 解密
    img = Image.open(r"E:\Users\Expector\Desktop\lty.c.png")
    text = open(r"E:\Users\Expector\Desktop\book.c.txt", 'w', encoding='utf-8')
    text.write(unpack(np.array(img)))
```

附图：![](https://content.hackertalk.net/pub/rM8KdM-01wZY6D)