环境

• Anaconda3
• pycharm (安利一波！颜值很高！有教育版，一般用学校邮箱注册就可以）其他IDE也可以
• python 3.6
• opencv-python 4.1.0.25
• torch 0.4.0
• torchvision 0.2.1
  其实环境也不用太在意，运行程序后，如果遇到
  ModuleNotFoundError: No module named 'requset'
  之类的错误，都用conda install <package_name> 就可以了。

Anaconda

一般写python的应该都装了这个把~简单说这是个包管理器，以为python的程序很多都需要加载非常多的包，把包都放在全局很难管理，所以一般开始一个项目都会新建一个包管理环境，简单介绍一下最基本的创建一个包管理环境的方法。

切换到Environment界面，点击Create就可以创建一个包环境。

这时候创建的环境是最基本的环境，你可以根据需要在anaconda中继续install你需要的包。

图形界面的install包的方式就点来点去就好了，当然也可以用命令行的方式。

在pycharm的Terminal可以采用activate basic_env 来**我们刚刚创建的环境，然后你就可以在这个环境中try what you want.一般常用的是安装包。这里可以采用两种方式，pip install <package_name> 和conda install <package_name> 。这两个的区别可以搜一下，这里推荐大家使用conda install 吧。

Pytorch

pytorch就是类似tensorflow的一种神经网络框架吧。神经网络一层层的嘛，要是整个一层层都自己代码一行行建起来多麻烦呀，然后大家就有了框架了。像pytorch你想建一层网络只需要一行代码的，贼方便。我也没用过tensorflow，听说pytorch好上手，我就先试pytorch了。
推荐莫烦的pytorch教程。他出了好多课了，python啥啥的讲的都挺好的，然后也都是免费的，看起来可快了,入门刚刚好。当然，不看也可以先跟着这篇博客，不用懂啥原理，也可以完成识别hhhh。(我也还没搞明白

安装pytorch

这里推荐先去官网下载选择一下自己需要的版本

像我，就是整个配置。可以看到有一行是cuda，可以看看自己的显卡是不是NVIDIA的，如果不是的话，果断选none就行，如果是的话，你要是想用GPU跑快点的话可以配置一下cuda，这篇教程就不涉及了。
这里选好自己的配置后，复制网页上"Run this Command" 的内容到命令行就可以了。然后等它装完就行啦~

Let’s gogo

一共会有两个.py文件，一个就是训练网络的代码，一个是拿到训练好的网络的参数后，用这个网络去识别图片的代码。
先贴代码,整个训练网络的代码都在这里了，是不是很短，然后就看下要改哪些地方就可以了：

from __future__ import print_function, division

import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
from torch.autograd import Variable
import torchvision
from torchvision import datasets, models, transforms
import time
import os
def train_model(model, criterion, optimizer, scheduler, num_epochs=25):
    since = time.time()

    best_model_wts = model.state_dict()
    best_acc = 0.0

    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch, num_epochs - 1))
        print('-' * 10)

        # Each epoch has a training and validation phase
        for phase in ['train', 'val']:
            if phase == 'train':
                scheduler.step()
                model.train(True)  # Set model to training mode
            else:
                model.train(False)  # Set model to evaluate mode

            running_loss = 0.0
            running_corrects = 0.0

            # Iterate over data.
            for data in dataloders[phase]:
                # get the inputs
                inputs, labels = data

                # wrap them in Variable
                if use_gpu:
                    inputs = Variable(inputs.cuda())
                    labels = Variable(labels.cuda())
                else:
                    inputs, labels = Variable(inputs), Variable(labels)

                # zero the parameter gradients
                optimizer.zero_grad()

                # forward
                outputs = model(inputs)
                _, preds = torch.max(outputs.data, 1)
                loss = criterion(outputs, labels)

                # backward + optimize only if in training phase
                if phase == 'train':
                    loss.backward()
                    optimizer.step()

                # statistics
                running_loss += loss.data
                running_corrects += torch.sum(preds == labels.data).to(torch.float32)

            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects / dataset_sizes[phase]

            print('{} Loss: {:.4f} Acc: {:.4f}'.format(
                phase, epoch_loss, epoch_acc))

            # deep copy the model
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = model.state_dict()

    time_elapsed = time.time() - since
    print('Training complete in {:.0f}m {:.0f}s'.format(
        time_elapsed // 60, time_elapsed % 60))
    print('Best val Acc: {:4f}'.format(best_acc))

    # load best model weights
    model.load_state_dict(best_model_wts)
    return model

if __name__ == '__main__':

    # data_transform, pay attention that the input of Normalize() is Tensor and the input of RandomResizedCrop() or RandomHorizontalFlip() is PIL Image
    data_transforms = {
        'train': transforms.Compose([
            transforms.RandomSizedCrop(224),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
        'val': transforms.Compose([
            transforms.Scale(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
    }

    # your image data file
    data_dir = 'D:/aaaaooooo/zhongkong/pytorchtry/tempdata'
    image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x),
                                              data_transforms[x]) for x in ['train', 'val']}
    # wrap your data and label into Tensor
    dataloders = {x: torch.utils.data.DataLoader(image_datasets[x],
                                                 batch_size=4,
                                                 shuffle=True,
                                                 num_workers=4) for x in ['train', 'val']}

    dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}

    # use gpu or not
    use_gpu = torch.cuda.is_available()

    # get model and replace the original fc layer with your fc layer
    model_ft = models.resnet18(pretrained=True)
    num_ftrs = model_ft.fc.in_features
    model_ft.fc = nn.Linear(num_ftrs, 10)

    if use_gpu:
        model_ft = model_ft.cuda()

    # define loss function
    criterion = nn.CrossEntropyLoss()

    # Observe that all parameters are being optimized
    optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)

    # Decay LR by a factor of 0.1 every 7 epochs
    exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1)

    model_ft = train_model(model=model_ft,
                           criterion=criterion,
                           optimizer=optimizer_ft,
                           scheduler=exp_lr_scheduler,
                           num_epochs=25)

    torch.save(model_ft, 'D:/aaaaooooo/zhongkong/pytorchtry/model3.pth')

稍微解释几句我会的代码呀~（可跳

这里就是在定义一种对图像的变幻。大家可以在训练集里放随便什么格式，随便什么分辨率的图像，反正经过这几行代码，图像都会被改成训练网络需要用的那种。具体有关transforms.Compose 可以看官网的文档。

    data_transforms = {
        'train': transforms.Compose([
            transforms.RandomSizedCrop(224),
            transforms.RandomHorizontalFlip(),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
        'val': transforms.Compose([
            transforms.Scale(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
        ]),
    }

pytorch里面已经有很多效果很好的网络模型了，比方说vgg16、resnet18等等，就用代码加载一下模型就好了。不满足的话，也可以用pytorch一层层写hhh，网上教程也有很多。

    # get model and replace the original fc layer with your fc layer
    model_ft = models.resnet18(pretrained=True)
    num_ftrs = model_ft.fc.in_features

训练的图片放哪里啊!

准备一个文件夹随便取名字啦，然后把data_dir的路径改成你这个文件夹的路径，然后里面放两个文件夹，分别命名"train"和"val“就好。这两个文件夹里面放的图像可以是一模一样滴。

把每一类你要识别的图像建一个文件夹，名字就取成那个东西就好，然后把跟这个东西的图片全部塞到这个文件夹。

再改一个地方

这里的10表示你要分类的东西的个数，就是你有几个图片的文件夹。把这个数字改成你要的分类个数。

model_ft.fc = nn.Linear(num_ftrs, 10)

有一个可改可不改的地方

这里num_epochs 好像是类似迭代次数的东西，你嫌慢的话可以稍微改小点，当然这样准确性可能会低一点。

    model_ft = train_model(model=model_ft,
                           criterion=criterion,
                           optimizer=optimizer_ft,
                           scheduler=exp_lr_scheduler,
                           num_epochs=25)

保存模型

这里它把训练好的网络的信息输出，选一个你想保存的路径就好。

 torch.save(model_ft, 'D:/aaaaooooo/zhongkong/pytorchtry/model3.pth')

开始训练！

点run就行！看你图片多不多了，多的话可能慢点，一开始尝试的话可以先把num_epochs改成1然后运行！

开始识别！

from __future__ import print_function, division

import torch
from torchvision import datasets, models, transforms
from PIL import Image
from torch.autograd import Variable

model = torch.load('D:/aaaaooooo/zhongkong/pytorchtry/model2.pth')
#这个变换你就把训练网络代码里的变换复制过来好了
test_transforms = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
image = Image.open('D:/aaaaooooo/zhongkong/pytorchtry/tempdata/train/ADgainai/0005.png')  #打开一张图片，路径你改成你的
pic = test_transforms(image).float()   #用上面写的变换把图像变换一下
pic.unsqueeze_(0)        #我也不知道这是啥，不加好像也没事
input = Variable(pic)    #variable是pytorch里面新的一种变量把，它把梯度信息也加进去了
out = model(input)       #把图放到那个网络里跑一跑，然后就得到了输出的结果
_, pred = torch.max(out, 1)   #把概率最大的类别的号码输出来

print(pred)

你看，它输出了预测结果0！就是ADgainai的下标

tensor是pytorch的一种数据类型，类似numpy的narray把

DONE!