```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数据集

就想弄个生成数字,不知道为什么就一直训练不出来(急急急

**生成的图(2个epoch)(多次尝试的其中一个,其他的更离谱,这个至少模式坍塌的不那么彻底)**

![](https://content.hackertalk.net/pub/Vrq0Mw-eaWz107)

loss图(也是2epoch

**loss: D**

![](https://content.hackertalk.net/pub/77QvVy-N651Kdr)

**loss: G**

![](https://content.hackertalk.net/pub/J7dyBP-7VBz4M5)

我寻思这loss差不多都ln2简直完美(用的BCELoss

而且训练时间(5min+/epoch)(cpu)也比全连接GAN长(悲

**生成器**

```python
def __init__(self):
    super(G, self).__init__()
    self.linear = nn.Sequential(
        nn.Linear(110, 3 * 11 * 11),
        nn.LeakyReLU()
    )
    self.conv = nn.Sequential(
        nn.ConvTranspose2d(3, 64, 4),
        nn.BatchNorm2d(64),
        nn.LeakyReLU(),
        nn.ConvTranspose2d(64, 1, 2, 2),
        nn.Tanh()
    )

def forward(self, inputs, label_tensors):
    return self.conv(self.linear(torch.cat((inputs, label_tensors), 1)).view(-1, 3, 11, 11))
```

**判别器**

```python
def __init__(self):
    super(D, self).__init__()
    self.conv = nn.Sequential(
        nn.Conv2d(1, 10, 3),
        nn.LeakyReLU(),
        nn.MaxPool2d(2),
        nn.Conv2d(10, 20, 4),
        nn.LeakyReLU(),
        nn.MaxPool2d(2),
    )
    self.linear = nn.Sequential(
        nn.Linear(500 + 10, 100),
        nn.LeakyReLU(),
        nn.BatchNorm1d(100),
        nn.Linear(100, 1),
        nn.Sigmoid()
    )

def forward(self, inputs, label_tensors):
    inputs = torch.cat((self.conv(inputs).view(-1, 500), label_tensors), 1)
    return self.linear(inputs)
```

**优化器(一样)**

```python
self.optimiser = torch.optim.Adam(self.parameters(), lr=0.0001)
```

真蚌埠住了,看网上的都是1000多个通道的卷积层,电脑是在8是很行,就是说想找那种判别器生成器参数都不是很多(最好别超50w)

还有就是想知道为什么明明loss完美但是生成的图却这么......一言难尽

谢谢