【2020暑假学习】第一次作业：深度学习基础

视频学习

发展：

1956年美国达特茅斯会议：“人工智能” 概念诞生

1957年Rosenblatt感知机 第一次兴起

1968年专家系统

1969年Minsky提出感知机缺陷 第一次低谷

1986年Hinton和Rumelhart提出BP算法 第二次兴起

1989年Yann LeCun 反向传播在手写邮政编码上的应用、CNN

1995年Vapnik提出SVM 第二次低谷

Hinton 神经网络改名为深度学习

BP解决单层网络到单隐层 RBM单隐层到多隐层

吴恩达，使用GPU，提速70倍

2009年李菲菲，做了ImageNet数据集

ImageNet图像分类比赛，2012年转折点，Hinton和研究生，使用CNN+Dropout+RELU，错误率只有15.3%。人工智能技术的突破点，引起工业界注意。

Bengio，发明RELU函数。第一个将神经网络用于自然语言处理中。

代码练习

• 代码最后一行的分号删除时，输出多了一行“(-0.5, 603.5, 405.5, -0.5)”是什么原因，含义是什么？（未解决）
  猜测与图本身大小604*406有关。

  # Plot all channels of a real image
  plt.subplot(121) #1代表行，2代表列，所以一共有2个图，1代表此时绘制第一个图
  plt.imshow(colony[:,:,:])
  plt.title('3-channel image')
  plt.axis('off') #不显示坐标轴
  
  # Plot one channel only
  plt.subplot(122)
  plt.imshow(colony[:,:,0])
  plt.title('1-channel image')
  plt.axis('off');
  

  

• opencv的接口使用BGR，matplotlib.pyplot 使用RGB。Google colab解决cv2.imshow()无法使用问题如下：

  from google.colab.patches import cv2_imshow
  BGR_cat = cat[:, :, ::-1]
  cv2_imshow(BGR_cat)
  

  

• 螺旋数据分类 传统训练函数，进来一个batch的数据，计算一次梯度，更新一次网络；梯度累加，每次获取1个batch的数据，计算1次梯度，梯度不清空，不断累加，累加一定次数后，根据累加的梯度更新网络参数。

  ”一定条件下，batchsize越大训练效果越好，梯度累加则实现了batchsize的变相扩大，如果accumulation_steps为8，则batchsize '变相' 扩大了8倍，是我们这种乞丐实验室解决显存受限的一个不错的trick，使用时需要注意，学习率也要适当放大。“

  # 反向传播前把梯度置 0 
  optimizer.zero_grad()
  # 反向传播优化 
  loss.backward()
  # 更新全部参数
  optimizer.step()
  

• 回归分析 使用 ReLU 激活函数，收敛较快；使用 Tanh 激活函数，一开始收敛较慢，但随后也快速收敛达到较好的效果。

  Tanh的梯度在饱和区域非常平缓，接近于0，很容易造成vanishing gradient的问题，减缓收敛速度。相反，ReLU的梯度大多数情况下是常数，有助于解决深层网络的收敛问题。https://www.cnblogs.com/alexanderkun/p/6918029.html

• 为什么使用 ReLU 激活函数是分段线性函数，使用 Tanh 激活函数是连续平稳回归？（未解决）

猫狗大战

import copy

criterion = nn.NLLLoss()
lr = 0.001
optimizer_vgg = torch.optim.Adam(model_vgg_new.classifier[6].parameters(), lr=lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=0)  #2

def train_model(model,dataloader,loader_valid,size,size_val,epochs=1,optimizer=None):
    model.train()
    
    best_acc = 0.0
    best_model_wts = copy.deepcopy(model.state_dict())

    for epoch in range(epochs):
        running_loss = 0.0
        running_corrects = 0
        count = 0
        for inputs,classes in dataloader:
            inputs = inputs.to(device)
            classes = classes.to(device)
            outputs = model(inputs)
            loss = criterion(outputs,classes)           
            optimizer = optimizer
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            _,preds = torch.max(outputs.data,1)
            # statistics
            running_loss += loss.data.item()
            running_corrects += torch.sum(preds == classes.data)
            count += len(inputs)
        epoch_loss = running_loss / size
        epoch_acc = running_corrects.data.item() / size
        print('Train Loss: {:.4f} Acc: {:.4f}'.format(
                     epoch_loss, epoch_acc))
        
        epoch_val_acc = test_model(model,loader_valid,size=dset_sizes['valid'])
        if epoch_val_acc > best_acc:
          best_acc = epoch_val_acc
          best_model_wts = copy.deepcopy(model.state_dict())

    model.load_state_dict(best_model_wts)
    print('Best val Acc: {:4f}'.format(best_acc))
    return model

def test_model(model,dataloader,size):
    model.eval()
    predictions = np.zeros(size)
    all_classes = np.zeros(size)
    all_proba = np.zeros((size,2))
    i = 0
    running_loss = 0.0
    running_corrects = 0
    for inputs,classes in dataloader:
        inputs = inputs.to(device)
        classes = classes.to(device)
        outputs = model(inputs)
        loss = criterion(outputs,classes)           
        _,preds = torch.max(outputs.data,1)
        # statistics
        running_loss += loss.data.item()
        running_corrects += torch.sum(preds == classes.data)
        predictions[i:i+len(classes)] = preds.to('cpu').numpy()
        all_classes[i:i+len(classes)] = classes.to('cpu').numpy()
        all_proba[i:i+len(classes),:] = outputs.data.to('cpu').numpy()
        i += len(classes)  
    epoch_loss = running_loss / size
    epoch_acc = running_corrects.data.item() / size
    print('Val Loss: {:.4f} Acc: {:.4f}'.format(
                     epoch_loss, epoch_acc))
    return epoch_acc

best_model = train_model(model_vgg_new,loader_train,loader_valid,size=dset_sizes['train'], size_val=dset_sizes['valid'], epochs=10, 
            optimizer=optimizer_vgg)      

将Drive中的文件与Colab关联，挂载到‘/content/drive’下。

from google.colab import drive
drive.mount('/content/drive')

from PIL import Image

def predict(model, img_path):
    model.eval()
    torch.no_grad()
    img = Image.open(img_path)
    img_transform = vgg_format(img).unsqueeze(0)
    img_transform = img_transform.to(device)
    outputs = model(img_transform)
    _, predicted = torch.max(outputs,1)
    return predicted

import csv
import os

f = open('/content/drive/My Drive/prediction.csv','w',encoding='utf-8')
csv_writer = csv.writer(f)

file_dir = '/content/drive/My Drive/test'
for i in range(2000):
    prediction = predict(best_model, file_dir + '/' + str(i) + '.jpg')
    print(prediction.item())
    csv_writer.writerow([str(i),str(prediction.item())])

f.close()

提交结果如下：

尝试了一下，不知道训练集和预测数据集有没有重合。有错误请指正，纠错中学习。

图片预测结果应按照0、1、2、3、4……的图片名称顺序写入csv文件。第一次遍历文件顺序写入csv文件评审得分为0。

for root, dirs, files in os.walk(file_dir):
  for file in files:
    prediction = predict(best_model, file_dir + '/' + file)
    print(prediction.item())
    csv_writer.writerow([file.strip('.jpg'),str(prediction.item())])