
import numpy as np
def mean_squared_error(y_true, y_pred):
    return np.mean(np.square(y_pred - y_true), axis=-1)

def mean_absolute_error(y_true, y_pred):
    return np.mean(np.abs(y_pred - y_true), axis=-1)


def mean_squared_logarithmic_error(y_true, y_pred):
    first_log = np.log(np.clip(y_pred, 10e-6, None) + 1.)
    second_log = np.log(np.clip(y_true, 10e-6, None) + 1.)
    return np.mean(np.square(first_log - second_log), axis=-1)

def mean_absolute_percentage_error(y_true, y_pred):
    diff = np.abs((y_pred - y_true) / np.clip(np.abs(y_true), 10e-6, None))
    return 100 * np.mean(diff, axis=-1)


def cross_entropy(y_true, y_pred):
    return -np.mean(y_true * np.log(y_pred + 10e-6))


def exponential(y_true, y_pred):
    return np.sum(np.exp(-y_true * y_pred))


import torch
from torch import nn     # 导入nn模块
class Sample(nn.Module):
    def __init__(self):
        super(Sample, self).__init__()
        self.conv = nn.Sequential(
            nn.Conv2d(1, 1, 5),     # 卷积层
            nn.Sigmoid(),     # 激活函数
            nn.MaxPool2d(2, 2),     # 最大池化层
        )
        self.fc = nn.Sequential(
            nn.Linear(14*14, 10),     # 全连接层
            nn.Sigmoid(),     # 激活函数
        )
    def forward(self, img):     # 定义前向计算
        feature = self.conv(img)     # 卷积层
        output = self.fc(feature.view(img.shape[0], -1))     # 全连接层
        return output


import torch
from torch import nn
class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        '''
        这里搭建卷积层，需要按顺序定义卷积层、
        激活函数、最大池化层、卷积层、激活函数、最大池化层，
        具体形状见测试说明
        '''
        self.conv = nn.Sequential( # 输入(32*32*1)
            ########## Begin ##########
            nn.Conv2d(1,6,5),  # (batch_size, 6, 28, 28)
            nn.Sigmoid(),
            nn.MaxPool2d(2,2), # (batch_size, 6, 14, 14)
            nn.Conv2d(6,16,5), # (batch_size, 6, 10, 10)
            nn.Sigmoid(),
            nn.MaxPool2d(2,2), # (batch_size, 16, 5, 5)
            ########## End ##########
        )
        '''
        这里搭建全连接层，需要按顺序定义全连接层、
        激活函数、全连接层、激活函数、全连接层，
        具体形状见测试说明
        '''
        self.fc = nn.Sequential(
            ########## Begin ##########
            nn.Linear(16*5*5,120), # 输入大小为16*5*5=400
            nn.Sigmoid(),
            nn.Linear(120,84),
            nn.Sigmoid(),
            nn.Linear(84,10),
            ########## End ##########
        )

    def forward(self, img):
        '''
        这里需要定义前向计算
        '''
        ########## Begin ##########
        feature=self.conv(img)
        output=self.fc(feature.view(img.shape[0],-1)) 
        # img.shape[0] 是 batch_size
        # -1 表示自动计算该维度的大小，使得总元素数量保持不变。 例如 (batch_size, 16, 5, 5) --> (batch_size, 16*5*5)
        # view(img.shape[0], -1) 会将其变形为 (batch_size, 16*5*5)
        # img.shape[0] 改为 feature.shape[0] 可能有一定风险：卷积操作不会改变 batch size，但在某些特殊情况下（如自定义操作或错误的数据流），两者可能不一致。
        return output

        ########## End ##########


import torch
from torch import nn


class AlexNet(nn.Module):
    def __init__(self):
        super(AlexNet, self).__init__()
        '''
        这里搭建卷积层，需要按顺序定义卷积层、
        激活函数、最大池化层、卷积层、激活函数、
        最大池化层、卷积层、激活函数、卷积层、
        激活函数、卷积层、激活函数、最大池化层，
        具体形状见测试说明
        '''
        self.conv = nn.Sequential(
            ########## Begin ##########
            nn.Conv2d(3,96,kernel_size=(11,11),stride=(4,4)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3,stride=2,padding=0),
            nn.Conv2d(96,256,kernel_size=(5,5),stride=(1,1),padding=(2,2)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3,stride=2,padding=0),
            nn.Conv2d(256,384,kernel_size=(3,3),stride=(1,1),padding=(1,1)),
            nn.ReLU(),
            nn.Conv2d(384,384,kernel_size=(3,3),stride=(1,1),padding=(1,1)),
            nn.ReLU(),
            nn.Conv2d(384,256,kernel_size=(3,3),stride=(1,1),padding=(1,1)),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=3,stride=2,padding=0),
            ########## End ##########
        )
        '''
        这里搭建全连接层，需要按顺序定义
        全连接层、激活函数、丢弃法、
        全连接层、激活函数、丢弃法、全连接层，
        具体形状见测试说明
        '''
        self.fc = nn.Sequential(
            ########## Begin ##########
            nn.Linear(in_features=6400,out_features=4096,bias=True),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(in_features=4096,out_features=4096,bias=True),
            nn.ReLU(),
            nn.Dropout(p=0.5),
            nn.Linear(in_features=4096,out_features=1000,bias=True),
            ########## End ##########
        )

    def forward(self, img):
        '''
        这里需要定义前向计算
        '''
        ########## Begin ##########
        feature=self.conv(img)  
        result=self.fc(feature.view(img.shape[0],-1))    
        ########## End ##########

model = AlexNet()
print(model)


import matplotlib.pyplot as plt
import numpy as np

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision

# 设置种子和其他配置。

seed = 42
torch.manual_seed(seed)
torch.backends.cudnn.benchmark = False
torch.backends.cudnn.deterministic = True

# 设置批大小、学习周期和学习率。

batch_size = 512
epochs = 30
learning_rate = 1e-3

# 载入 MNIST 数据集中的图片进行训练。

transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()])


train_dataset = torchvision.datasets.MNIST(
    root="~/torch_datasets", train=True, transform=transform, download=True
)

train_loader = torch.utils.data.DataLoader(
    train_dataset, batch_size=batch_size, shuffle=True
)

# AE 自编码器
# 为了简化实现，我们在一个类中编写编码器和解码器层。我们为编码器和解码器层的组件都定义了全连接层。

class AE(nn.Module):
    def __init__(self, **kwargs):
        super().__init__()
        self.encoder_hidden_layer = nn.Linear(
            in_features=kwargs["input_shape"], out_features=128
        )
        self.encoder_output_layer = nn.Linear(
            in_features=128, out_features=128
        )
        self.decoder_hidden_layer = nn.Linear(
            in_features=128, out_features=128
        )
        self.decoder_output_layer = nn.Linear(
            in_features=128, out_features=kwargs["input_shape"]
        )

    def forward(self, features):
        activation = self.encoder_hidden_layer(features)
        activation = torch.relu(activation)
        code = self.encoder_output_layer(activation)
        code = torch.sigmoid(code)
        activation = self.decoder_hidden_layer(code)
        activation = torch.relu(activation)
        activation = self.decoder_output_layer(activation)
        reconstructed = torch.sigmoid(activation)
        return reconstructed
    
# 在使用我们定义的 AE 类之前，我们有以下事情要做:

# 配置要在哪个设备上运行；
# 实例化一个 AE 对象；
# 要定义优化器；
# 要定义重建损失。

device = torch.device("cpu")

# 建立 AE 模型并载入到 CPU 设备
model = AE(input_shape=784).to(device)

# Adam 优化器，学习率 10e-3
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

# MSE 损失
criterion = nn.MSELoss()

# 我们在 CPU 设备上运行，实例化一个输入大小为 784 的 AE 自编码器，并用 Adam 作为我们的训练优化器。用 MSELoss 作为损失函数。接下来我们就可以训练了。

for epoch in range(epochs):
    loss = 0
    for batch_features, _ in train_loader:
        # 将小批数据变形为 [N, 784] 矩阵，并加载到 CPU 设备
        batch_features = batch_features.view(-1, 784).to(device)
        
        # 梯度设置为 0，因为 torch 会累加梯度
        optimizer.zero_grad()
        
        # 计算重构
        outputs = model(batch_features)
        
        # 计算训练重建损失
        train_loss = criterion(outputs, batch_features)
        
        # 计算累积梯度
        train_loss.backward()
        
        # 根据当前梯度更新参数
        optimizer.step()
        
        # 将小批量训练损失加到周期损失中
        loss += train_loss.item()
    
    # 计算每个周期的训练损失
    loss = loss / len(train_loader)
    
    # 显示每个周期的训练损失
    print("epoch : {}/{}, recon loss = {:.8f}".format(epoch + 1, epochs, loss))

# 我们用训练过的自编码器提取一些测试用例来重构。

test_dataset = torchvision.datasets.MNIST(
    root="~/torch_datasets", train=False, transform=transform, download=True
)

test_loader = torch.utils.data.DataLoader(
    test_dataset, batch_size=10, shuffle=False
)

test_examples = None

with torch.no_grad():
    for batch_features in test_loader:
        batch_features = batch_features[0]
        test_examples = batch_features.view(-1, 784).to(device)
        reconstruction = model(test_examples)
        break

# 可视化
# 用我们训练过的自编码器重建一些测试图像。

with torch.no_grad():
    number = 10
    plt.figure(figsize=(20, 4))
    for index in range(number):
        # 显示原始图
        ax = plt.subplot(2, number, index + 1)
        plt.imshow(test_examples[index].cpu().numpy().reshape(28, 28))
        plt.gray()
        ax.get_xaxis().set_visible(False)
        ax.get_yaxis().set_visible(False)

        # 显示重构图
        ax = plt.subplot(2, number, index + 1 + number)
        plt.imshow(reconstruction[index].cpu().numpy().reshape(28, 28))
        plt.gray()
        ax.get_xaxis().set_visible(False)
        ax.get_yaxis().set_visible(False)
    plt.show()
# 可以看出，重构图片和原始图片差别不大，我们的训练还是比较成功的。


import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt


class ConvAE(nn.Module):
    def __init__(self, **kwargs):
        super().__init__()
        
        # 编码器 (Encoder)：通过卷积层逐步压缩特征
        self.encoder = nn.Sequential(
            # 输入: (batch_size, 3, 64, 64) 假设输入为3通道64x64图像
            nn.Conv2d(3, 16, kernel_size=3, stride=2, padding=1),  # 输出: (16, 32, 32)
            nn.ReLU(inplace=True),
            nn.Conv2d(16, 32, kernel_size=3, stride=2, padding=1),  # 输出: (32, 16, 16)
            nn.ReLU(inplace=True),
            nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1),  # 输出: (64, 8, 8)
            nn.ReLU(inplace=True),
            nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1),  # 输出: (128, 4, 4)
            nn.ReLU(inplace=True)
        )
        
        # 解码器 (Decoder)：通过转置卷积层恢复图像
        self.decoder = nn.Sequential(
            # 输入: (128, 4, 4)
            nn.ConvTranspose2d(128, 64, kernel_size=3, stride=2, padding=1, output_padding=1),  # 输出: (64, 8, 8)
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1),  # 输出: (32, 16, 16)
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(32, 16, kernel_size=3, stride=2, padding=1, output_padding=1),  # 输出: (16, 32, 32)
            nn.ReLU(inplace=True),
            nn.ConvTranspose2d(16, 3, kernel_size=3, stride=2, padding=1, output_padding=1),  # 输出: (3, 64, 64)
            nn.Sigmoid()  # 使用Sigmoid将输出归一化到[0,1]范围
        )

    def forward(self, x):
        # 编码过程：得到潜在特征
        x = self.encoder(x)
        # 解码过程：重建输入图像
        x = self.decoder(x)
        return x


# 测试代码
if __name__ == "__main__":
    # 实例化模型
    model = ConvAE()
    print(model)
    
    # 创建随机测试数据 (batch_size=4, 3通道, 64x64图像)
    test_input = torch.randn(4, 3, 64, 64)
    
    # 前向传播
    output = model(test_input)
    
    # 打印输入输出形状（应保持一致）
    print(f"输入形状: {test_input.shape}")
    print(f"输出形状: {output.shape}")


import torch
from torch import nn

class ConvBNReLU(nn.Module):# 定义标准的卷积层：Conv+BN+ReLU
    def __init__(self,nin,nout,ks,stride=1):
        super().__init__()
        pad=(ks-1)//2

        self.layers=nn.Sequential(
            nn.Conv1d(nin,nout,ks,stride,padding=pad), 
            # 输入：(batch_size, nin, sequence_length) 
            # 输出：(batch_size, nout, sequence_length)（当 stride=1 时长度不变）
            nn.BatchNorm1d(nout), # 一维批标准化
            nn.ReLU(),
        )

    def forward(self,x):
        y=self.layers(x)
        return y    
    
class ConvUpBNReLU(nn.Module):# 上采样+卷积
    def __init__(self,nin,nout,ks,stride=1):
        super().__init__()

        self.layers = nn.Sequential(
            nn.Upsample(scale_factor=stride, mode="nearest"),  # 上采样
            ConvBNReLU(nin,nout,ks,stride)
        )

    def forward(self, x):
        y=self.layers(x)
        return y


# 生成器
class ImageGeneration(nn.Module):
    def __init__(self,nclass=10):
        super().__init__()

        self.emb=nn.Embedding(nclass,64*4*4)
        self.layers=nn.Sequential(
            ConvBNReLU(64,64,1),
            ConvUpBNReLU(64,32,2),
            ConvBNReLU(32,32,1),
            ConvUpBNReLU(32,16,2),
            ConvBNReLU(16,16,1),
            ConvUpBNReLU(16,8,2),
            nn.Conv2d(8,3,1,1),
            nn.Sigmoid() # 输出[0,1]
        )

    def forward(self,d):
        h=self.emb(d)
        h=h.reshape([-1,64,4,4])
        x=self.layers(h)
        return x


# 判别器
class ImageClassify(nn.Module):
    def __init__(self):
        super().__init__()

        # DNN输出长度为2的表示向量
        self.dnn=nn.Sequential(
            ConvBNReLU(3,16,2),
            ConvBNReLU(16,16,1),
            ConvBNReLU(16,32,2),
            ConvBNReLU(32,32,1),
            ConvBNReLU(32,64,2),
            ConvBNReLU(64,64,1),
            nn.Flatten(),
            nn.Linear(4*4*64,128),
        )

        self.classify=nn.Linear(128,10)
        self.ganout=nn.Linear(128,1) 

    def forward(self,x):
        h=self.dnn(x)
        y1=self.classify(h)
        y2=self.ganout(h)
        return y1,y2


# 损失函数，交替迭代
# 定义生成器
gen=ImageGeneration()
gen.train()
# 定义判别器
dis=ImageClassify()
dis.train()
optim_gen=torch.optim.Adam(gen.parameters(),1e-3,weight_decay=0.0) # gen.parameters()获取需要训练的参数，无权重衰减
optim_dis=torch.optim.Adam(dis.parameters(),1e-3,weight_decay=0.0)

for epoch in range(10):
    for x,d in dataloader: # x: 真实图像, d: 条件标签
        # 训练判别器
        dis.zero_grad()
        # 噪声向量
        z=torch.randn([len(x),100]),device=device,dtype=torch.float32
        # 生成假图像
        fake=gen(d,z)
        # 生成图像输入到判别器
        y1,y2=dis(fake.detach()) # 判别器对假图像的输出，阻止梯度传到生成器
        # 真实图像输入到判别器
        y3,y4=dis(x)
        # 生成图像判别接近0
        loss1=lossmse(y2,torch.zeros_like(y2)) # 判别器输出 y2 应接近 0
        # 真实图像损失=类别损失+判别损失
        loss2=lossce(y3,d)*0.2+lossmse(y4,torch.ones_like(y4)) # 判别器的分类输出 y3 应与真实标签 d 一致，判别器的真假输出 y4 应接近 1
        # 优化
        loss=loss1+loss2
        loss.backward()
        optim_dis.step()
        optim_dis.zero_grad()
        optim_gen.zero_grad()

        # 训练生成器
        gen.zero_grad()
        z=torch.randn([len(x),100]),device=device,dtype=torch.float32
        fake=gen(d,z)
        y1,y2=dis(fake)
        loss=lossce(y1,d)*0.2+lossmse(y2,torch.ones_like(y2))
        loss.backward()
        optim_gen.step()
        optim_gen.zero_grad()
        optim_dis.zero_grad()


# 解压数据集
import zipfile
zip_file = zipfile.ZipFile('/data/bigfiles/faces.zip')
zip_extract = zip_file.extractall('/data/faces')

batch_size = 72           # 批量大小
image_size = 64           # 训练图像空间大小
lr = 0.0002               # 学习率
beta1 = 0.5               # Adam优化器的beta1超参数

# 通过 paddle.vision.datasets 库读取数据：
import numpy as np
import paddle
import paddle.vision.datasets as ds
from paddle.vision.transforms import Compose, Resize, CenterCrop, ToTensor

def create_dataset_imagenet(dataset_path):
    """数据加载"""
    
    transforms = Compose([Resize(image_size), CenterCrop(image_size), ToTensor()])
    

    dataset = ds.DatasetFolder(root = dataset_path, transform=transforms)


    return dataset

dataset = create_dataset_imagenet('/data/faces')

data_loader = paddle.io.DataLoader(dataset, batch_size=batch_size, shuffle=True)

# 可视化一部分卡通头像数据：

import matplotlib.pyplot as plt

def plot_data(data):
    # 可视化部分训练数据
    plt.figure(figsize=(10, 3), dpi=140)
    for i, image in enumerate(data[:30], 1):
        plt.subplot(3, 10, i)
        plt.axis("off")
        plt.imshow(image.transpose(1, 2, 0))
    plt.show()

# 读取第一批数据    
sample_data = iter(data_loader)

# 绘制第一批数据的部分图片
plot_data(next(sample_data)[0].numpy())

# 在加载好数据集以后，接着我们定义 DCGAN 模型，首先是生成器 Generator：

import paddle
import paddle.nn.functional as F
import paddle.nn as nn

##################################################################
#生成器定义
class Generator(nn.Layer):
    def __init__(self, nz=100):
        super().__init__()
        #100*1*1
        self.layer1 = nn.Sequential(
            nn.Conv2DTranspose(nz, 1024, 4, 1, 0),
            nn.BatchNorm2D(1024),
            nn.ReLU()
        )
        #1024*4*4 （Paddle 默认的 NCHW 数据格式，N 为批量大小，C 为通道数，H 为高，W 为宽）
        self.layer2 = nn.Sequential(
            nn.Conv2DTranspose(1024, 512, 4, 2, 1),
            nn.BatchNorm2D(512),
            nn.ReLU()
        )
        #512*8*8
        self.layer3 = nn.Sequential(
            nn.Conv2DTranspose(512, 256, 4, 2, 1),
            nn.BatchNorm2D(256),
            nn.ReLU()
        )
        #256*16*16
        self.layer4 = nn.Sequential(
            nn.Conv2DTranspose(256, 128, 4, 2, 1),
            nn.BatchNorm2D(128),
            nn.ReLU()
        )
        #128*32*32
        self.layer5 = nn.Sequential(
            nn.Conv2DTranspose(128, 3, 4, 2, 1),
            nn.Tanh()
        )
        self.seq = nn.Sequential(
            self.layer1, 
            self.layer2,
            self.layer3,
            self.layer4,
            self.layer5
        )
    
    def forward(self, x):
        return self.seq(x)
    
# 接着是判别器 Discriminator：

#判别器定义
class Discriminator(nn.Layer):
    def __init__(self):
        super().__init__()
        #3*64*64
        self.layer1 = nn.Sequential(
            nn.Conv2D(3, 64, 4, 2, 1),
            nn.BatchNorm2D(64),
            nn.LeakyReLU(0.2)
        )
        #64*32*32
        self.layer2 = nn.Sequential(
            nn.Conv2D(64, 128, 4, 2, 1),
            nn.BatchNorm2D(128),
            nn.LeakyReLU(0.2)
        )
        #128*16*16
        self.layer3 = nn.Sequential(
            nn.Conv2D(128, 256, 4, 2, 1),
            nn.BatchNorm2D(256),
            nn.LeakyReLU(0.2)
        )
        #256*8*8
        self.layer4 = nn.Sequential(
            nn.Conv2D(256, 512, 4, 2, 1),
            nn.BatchNorm2D(512),
            nn.LeakyReLU(0.2)
        )
        #512*4*4
        self.layer5 = nn.Sequential(
            nn.Conv2D(512, 1, 4, 1, 0),
            nn.Sigmoid()  
        )
        self.seq = nn.Sequential(
            self.layer1,
            self.layer2,
            self.layer3,
            self.layer4,
            self.layer5
        )
    
    def forward(self, x):
        out = self.seq(x)
        return out
####################################################################    
# 接着将生成器 Generator 与 Discriminator 组合起来构成 DCGAN：

import paddle.vision
from paddle.io import DataLoader
import paddle.optimizer
import paddle.vision.transforms as transforms
import matplotlib.pyplot as plt

noise_eval = paddle.randn((batch_size, 100, 1, 1)) # 随机噪声

class DCGAN:
    def __init__(self):
        self.generator = Generator() # 生成器
        self.discriminator = Discriminator() # 判别器
        self.optim_for_gen = paddle.optimizer.Adam(lr, parameters=self.generator.parameters(), beta1=0.5) # 生成器优器
        self.optim_for_dis = paddle.optimizer.Adam(lr, parameters=self.discriminator.parameters(), beta1=0.5) # 判别器优化器
        self.loss_for_gen = nn.BCELoss() # 生成器损失 
        self.loss_for_dis = nn.BCELoss() # 判别器损失
        self.true_label = 1 # 真实数据标签
        self.false_label = 0 # 生成假数据标签
        self.label = paddle.to_tensor([1]*72)

    def load_data(self, data):
        # 导入数据
        self.data_loader = data
        
    def train(self, epochs):
        ## 导入之前的训练参数##
        # self.generator.set_state_dict(paddle.load( os.path.join('model', 'generator.pdmodel')))
        # self.discriminator.set_state_dict(paddle.load( os.path.join('model', 'discriminator.pdmodel'))) 
        for epoch in range(1, epochs+1):
            for i, img in enumerate(self.data_loader):
                
                # 训练生成器
                img = img[0]
                self.optim_for_dis.clear_grad()
                output = self.discriminator(img).squeeze()
                self.label = paddle.to_tensor([self.true_label]*img.shape[0], dtype='float32')
                err1 = self.loss_for_dis(output, self.label)
                err1.backward()
                self.label = paddle.to_tensor([self.false_label]*img.shape[0], dtype='float32')
                noise = paddle.randn((img.shape[0], 100, 1, 1))
                fake = self.generator(noise)
                output = self.discriminator(fake.detach()).squeeze()
                err2 = self.loss_for_dis(output, self.label)
                err2.backward()
                err = err1+err2
                self.optim_for_dis.step()
                
                
                # 训练判别器
                self.optim_for_gen.clear_grad()
                self.label = paddle.to_tensor([self.true_label]*img.shape[0], dtype='float32')
                output = self.discriminator(fake).squeeze()
                err3 = self.loss_for_gen(output, self.label)
                err3.backward()
                self.optim_for_gen.step()
                
                # 打印损失
                if i%5==0:
                    print('epoch/Epoch {}/{} iter/Iter {}/{} lossD {:.4f}, lossG {:.4f}'.format(epoch, 
                                                                                                epochs, 
                                                                                                i+1, 
                                                                                                len(self.data_loader), 
                                                                                                err.item(), 
                                                                                                err3.item()))
# 模型训练
# 下面实例化 DCGAN，并导入上面加载好的数据 data_loader 进行模型训练。

dcgan = DCGAN() # 实例化 DCGAN
dcgan.load_data(data_loader) # 导入上面的数据集
dcgan.train()

# 模型测试
# 这里是输入随机噪声并测试训练了一个epoch的模型，生成卡通头像的代码和效果图：


t = transforms.Transpose(order=(1, 2, 0))
to_plot = dcgan.generator(noise_eval).numpy()
plt.figure(figsize=(8, 8))
for i, img in enumerate(to_plot):
    if i >= 64:
        break
    img = t(img)
    plt.subplot(8, 8, i+1)
    plt.imshow(abs(img))
plt.show()

# 下面，我们导入预训练好的模型参数（80 个 epoch），再生成一批卡通头像：

# 载入模型参数
state_dict = paddle.load("/data/bigfiles/generator_net.pdparams")
# 将load后的参数与模型program关联起来
dcgan.generator.set_state_dict(state_dict)


t = transforms.Transpose(order=(1, 2, 0))
to_plot = dcgan.generator(noise_eval).numpy()
plt.figure(figsize=(8, 8))
for i, img in enumerate(to_plot):
    if i >= 64:
        break
    img = t(img)
    plt.subplot(8, 8, i+1)
    plt.imshow(abs(img))
plt.show()

层名	输出尺寸	卷积核大小	步长	填充	输出通道数	残差块数量
卷积层1	(112×112×64)	(7×7)	2	3	64	-
最大池化层	(56×56×64)	(3×3)	2	1	-	-
残差块组1	(56×56×64)	-	-	-	64	2
残差块组2	(28×28×128)	-	-	-	128	2
残差块组3	(14×14×256)	-	-	-	256	2
残差块组4	(7×7×512)	-	-	-	512	2
全局平均池化层	(1×1×512)	-	-	-	-	-
全连接层	(1×1×1000)	-	-	-	-	-

层名	输出尺寸	卷积核大小	步长	填充	输出通道数	残差块数量
卷积层1	(112×112×64)	(7×7)	2	3	64	-
最大池化层	(56×56×64)	(3×3)	2	1	-	-
残差块组1	(56×56×256)	-	-	-	256	3
残差块组2	(28×28×512)	-	-	-	512	4
残差块组3	(14×14×1024)	-	-	-	1024	6
残差块组4	(7×7×2048)	-	-	-	2048	3
全局平均池化层	(1×1×2048)	-	-	-	-	-
全连接层	(1×1×1000)	-	-	-	-	-

深度学习概念¶

深度学习定义¶

深度学习主要术语¶

神经网络ANNs基础¶

感知机¶

多层感知机¶

前向传播¶

反向传播¶

超参数¶

超参数搜索算法¶

超参数搜索一般过程¶

激活函数¶

优化方法¶

梯度下降算法¶

批量梯度下降法 BGD¶

随机梯度下降 SGD¶

小批量梯度下降法 MBGD¶

自适应学习率AdaGrad¶

AdaDelta¶

RMSProp¶

Adam¶

Momentum 模拟动量¶

启发式算法¶

损失函数¶

回归-损失函数¶

均方误差损失（MSE）¶

平均绝对误差损失函数（MAE）¶

均方误差对数损失函数（MSLE）¶

平均绝对百分比误差损失函数（MAPE）¶

小结¶

分类-损失函数¶

Logistic损失函数¶

负对数似然损失函数¶

交叉熵损失函数¶

铰链损失函数¶

Hinge损失函数¶

指数损失函数¶

CNN¶

局部连接 与 权值共享¶

卷积层¶

池化层¶

激活函数¶

全连接层¶

CNN经典网络¶

LeNet¶

网络结构¶

各层功能¶

参数总量¶

训练过程¶

数据大小计算¶

AlexNet¶

网络结构¶

各层功能¶

创新点¶

训练技巧¶

VGG¶

GoogleNet（Inception网络）¶

ResNet¶

原理¶

核心¶

ResNet - 18网络结构¶

ResNet - 50网络结构¶

原理¶

RNN¶

原理结构¶

长期依赖问题¶

RNN经典网络¶

LSTM¶

核心¶

遗忘门¶

输入门¶

输出门¶

GRU¶

结构与原理¶

与LSTM的比较¶

R-CNN、Fast R-CNN¶

GAN¶

YOLO¶

AE 自编码器¶

其他¶

局部连接与权值共享¶

层归一化批归一化¶