【深度学习】卷积神经网络（CNN）详解

# 导入库import torchfrom torch import nnimport torchvisionfrom torchvision import datasets,transformsimport torch.nn.functional as Fimport matplotlib.pyplot as plt

class Net(nn.Module):   def __init__(self):      super().__init__()      self.layer = nn.Sequential(                   nn.Conv2d(in_channels=1,out_channels=32,kernel_size=3),nn.ReLU(),                   nn.MaxPool2d(kernel_size=2),                   nn.Conv2d(32,64,2),nn.ReLU(),                   nn.MaxPool2d(2,2),                   nn.Flatten(),                   nn.Linear(64 * 6 * 6,10),nn.Softmax(),                   )
   def forward(self,x):      x = self.layer(x)      return x

# 如果GPU没有就会调到CPUdevice = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = Net().to(device)print(model.parameters)# 训练时还需要优化器（Optimizer）optimizer = torch.optim.Adam(model.parameters())print(optimizer)

model.train() # 启用BatchNormalization和Dropoutmodel.eval() # 因为是测试，所以取消两者

i = torch.tensor([    [1,2,3],    [4,5,6]])# 输出最大的值和它的索引print(i.max(1,keepdim=True))# torch.return_types.max(values=tensor([[3],[6]]), indices=tensor([[2],[2]]))# 一般只要索引的话：print(i.max(1,keepdim=True))[1]# tensor([[2],#         [2]])

a = torch.tensor([1,2,3,4])b = torch.tensor([[1],                  [-1],                  [-2],                  2])# 将a转换为与b形状相同a.view_as(b)print(a)# tensor([[1],#        [2],#        [3],#        [4]])
# 相对于numpy的equal函数，判断tensor里每一个值是否相等# 输出为True 或者 Falseprint(b.eq(a.view_as(b)))
# tensor([[ True],#        [False],#        [False],#        [False]])
# 求和用来判断损失和准确率# True --> 1，False --> 0print(b.eq(a.view_as(b)).sum())
# tensor(1)
# 最后将PyTorch的tensor转换为Python中标准值print(b.eq(a.view_as(b)).sum().item())# 1

# 下载训练和测试数据集# transforms函数可以对下载的数据做一些预处理# Compose 指的是将多个transforms操作组合在一起# ToTensor 是将[0,255] 范围 转换为[0,1]


    
# 灰度图片（channel=1），所以每一个括号内只有一个值，前者代表mean，后者std（标准差）# 彩色图片（channel=3），所以每一个括号内有三个值，如# transforms.Normalize((0.5,0.5,0.5),(0.5,0.5,0.5))transform = transforms.Compose([    transforms.ToTensor(),    transforms.Normalize((0.5,),(0.5,))])
data_train = datasets.MNIST(root="填自己的主路径",                            transform=transform,                            train=True,                            download=True)
data_test = datasets.MNIST(root="填自己的主路径",                           transform=transform,                           train=False)

# 加载数据集# Load Datatrain_loader = torch.utils.data.DataLoader(dataset=data_train,                                                batch_size=64,                                                shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=data_test,                                               batch_size=64,                                               shuffle=True)

def train(model,device,train_loader,optimizer,epoch):    model.train()    for batch_idx,(data,target) in enumerate(train_loader):        data,target = data.to(device),target.to(device)        optimizer.zero_grad() # 梯度清零        output = model(data)        loss = F.nll_loss(output,target) # negative likelihood loss        loss.backward() # 误差反向传播        optimizer.step() # 参数更新        if (batch_idx + 1) % 200 == 0:            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(                epoch, batch_idx * len(data), len(train_loader.dataset),                100. * batch_idx / len(train_loader), loss.item())) # .item()转换为python值    return loss.item()

# 定义测试函数def test(model, device, test_loader):    model.eval()    test_loss,correct = 0 , 0    with torch.no_grad(): # 不track梯度        for data, target in test_loader:            data, target = data.to(device), target.to(device)            output = model(data)            test_loss += F.nll_loss(output, target, reduction = 'sum') # 将一批的损失相加            pred = output.max(1, keepdim = True)[1] # 找到概率最大的下标            correct += pred.eq(target.view_as(pred)).sum().item() # equals    test_loss /= len(test_loader.dataset)    acc = correct / len(test_loader.dataset)    print("\nTest set: Average loss: {:.4f}, Accuracy: {} ({:.0f}%) \n".format(        test_loss, acc ,        100.* correct / len(test_loader.dataset)            ))
    return acc

def visualize(lis,epoch,*label):    plt.xlabel("epochs")    plt.ylabel(label)    plt.plot(epoch,lis)    plt.show()

BATCH_SIZE = 512 # 大概需要2G的显存EPOCHS = 20 # 总共训练批次DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") 

train_ = []test_acc = []for epoch in range(1,EPOCHS+1):    train_loss = train(model,DEVICE,train_loader,optimizer,epoch)    acc = test(model,DEVICE,test_loader)    train_.append(train_loss)    test_acc.append(acc)
visualize(train_,[i for i in range(20)],"loss")visualize(test_acc,[i for i in range(20)],"accuracy")

from tensorflow import kerasimport numpy as npimport matplotlib.pyplot as plt


    
import tensorflow as tfimport matplotlib as mplimport sys 
# solve could not create cudnn handle: CUDNN_STATUS_INTERNAL_ERRORconfig = tf.compat.v1.ConfigProto()config.gpu_options.allow_growth = Truesession = tf.compat.v1.InteractiveSession(config=config)
# 不同库版本，使用此代码块查看print(sys.version_info)for module in mpl,np,tf,keras:  print(module.__name__,module.__version__)
'''sys.version_info(major=3, minor=6, micro=9, releaselevel='final', serial=0)matplotlib 3.3.4numpy 1.16.0tensorflow 1.14.0tensorflow.python.keras.api._v1.keras 2.2.4-tf'''# If you get numpy futurewarning,then try numpy 1.16.0
# load train and test(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
# Scale images to the [0, 1] rangex_train = x_train.astype("float32") / 255x_test = x_test.astype("float32") / 255
# 1 Byte = 8 Bits，2^8 -1 = 255。[0,255]代表图上的像素，同时除以一个常数进行归一化。1 就代表全部涂黑。0 就代表没涂
# Make sure images have shape (28, 28, 1)x_train = np.expand_dims(x_train, -1)x_test = np.expand_dims(x_test, -1)
# CNN 的输入方式必须得带上channel，这里扩充一下维度
# convert class vectors to binary class matricesy_train = keras.utils.to_categorical(y_train, 10)y_test = keras.utils.to_categorical(y_test, 10)
# y 属于 [0,9]代表手写数字的标签，这里将它转换为0-1表示，可以类比one-hot，举个例子，如果是2
# [[0,0,1,0,0,0,0,0,0,0]……]
model = keras.Sequential(    [        keras.Input(shape=(28, 28, 1)),        keras.layers.Conv2D(filters=32, kernel_size=(3, 3), activation="relu"),        keras.layers.MaxPooling2D(pool_size=(2, 2)),        keras.layers.Conv2D(filters=64, kernel_size=(3, 3), activation="relu"),        keras.layers.MaxPooling2D(pool_size=(2, 2)),        keras.layers.Flatten(),        keras.layers.Dense(units=10, activation="softmax"),    ])
# 注意，Conv2D里面有激活函数不代表在卷积和池化的时候进行。而是在DNN里进行，最后拉直后直接接softmax就行

# kernel_size 代表滤波器的大小，pool_size 代表池化的滤波器的大小
model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
model.summary()
history = model.fit(x_train, y_train, batch_size=128, epochs=15, validation_split=0.1) #10层交叉检验score = model.evaluate(x_test, y_test)print("Test loss:", score[0])print("Test accuracy:", score[1])
# Test loss: 0.03664601594209671# Test accuracy: 0.989300012588501
# visualize accuracy and lossdef plot_(history,label):    plt.plot(history.history[label])    plt.plot(history.history["val_" + label])    plt.title("model " + label)    plt.ylabel(label)    plt.xlabel("epoch")    plt.legend(["train","test"],loc = "upper left")    plt.show()
plot_(history,"acc")plot_(history,"loss")