# -*- coding:utf-8 -*-

import torch

from torch.autograd import Variable

import torchvision

import torchvision.transforms as transforms

#数据预处理：转换为Tensor，归一化，设置训练集和验证集以及加载子进程数目

transform = transforms.Compose([transforms.ToTensor() , transforms.Normalize((0.5 , 0.5 , 0.5) , (0.5 , 0.5 , 0.5))])  #前面参数是均值，后面是标准差

trainset = torchvision.datasets.CIFAR10(root = './data' , train = True , download = True , transform = transform)

trainloader = torch.utils.data.DataLoader(trainset , batch_size = 4 , shuffle = True , num_workers =2)  #num_works = 2表示使用两个子进程加载数据

testset = torchvision.datasets.CIFAR10(root = './data' , train = False , download = True , transform = transform)

testloader = torch.utils.data.DataLoader(testset , batch_size = 4 , shuffle = True , num_workers = 2)

classes = ('plane' , 'car' , 'bird' , 'cat' , 'deer' , 'dog' , 'frog' , 'horse' , 'ship' , 'truck')

import matplotlib.pyplot as plt

import numpy as np

import pylab

def imshow(img):

    img = img / 2 + 0.5

    npimg = img.numpy()

    plt.imshow(np.transpose(npimg , (1 , 2 , 0)))

    pylab.show()

dataiter = iter(trainloader)

images , labels = dataiter.next()

for i in range(4):

    p = plt.subplot()

    p.set_title("label: %5s" % classes[labels[i]])

    imshow(images[i])

#构建网络

from torch.autograd import Variable

import torch.nn as nn

import torch.nn.functional as F

import torch.optim as optim

class Net(nn.Module):

    def __init__(self):

        super(Net , self).__init__()

        self.conv1 = nn.Conv2d(3 , 6 , 5)

        self.pool = nn.MaxPool2d(2 , 2)

        self.conv2 = nn.Conv2d(6 , 16 , 5)

        self.fc1 = nn.Linear(16 * 5 * 5 , 120)

        self.fc2 = nn.Linear(120 , 84)

        self.fc3 = nn.Linear(84 , 10)

    def forward(self , x):

        x = self.pool(F.relu(self.conv1(x)))

        x = self.pool(F.relu(self.conv2(x)))

        x = x.view(-1 , 16 * 5 * 5)  #利用view函数使得conv2层输出的16*5*5维的特征图尺寸变为400大小从而方便后面的全连接层的连接

        x = F.relu(self.fc1(x))

        x = F.relu(self.fc2(x))

        x = self.fc3(x)

        return x

net = Net()

net.cuda()

#define loss function

criterion = nn.CrossEntropyLoss()

optimizer = optim.SGD(net.parameters() , lr = 0.001 , momentum = 0.9)

#train the Network

for epoch in range(2):

    running_loss = 0.0

    for i , data in enumerate(trainloader , 0):

        inputs , labels = data

        inputs , labels = Variable(inputs.cuda()) , Variable(labels.cuda())

        optimizer.zero_grad()

        #forward + backward + optimizer

        outputs = net(inputs)

        loss = criterion(outputs , labels)

        loss.backward()

        optimizer.step()

        running_loss += loss.data[0]

        if i % 2000 == 1999:

            print('[%d , %5d] loss: %.3f' % (epoch + 1 , i + 1 , running_loss / 2000))

            running_loss = 0.0

print('Finished Training')

dataiter = iter(testloader)

images , labels = dataiter.next()

imshow(torchvision.utils.make_grid(images))

print('GroundTruth:' , ' '.join(classes[labels[j]] for j in range(4)))

outputs = net(Variable(images.cuda()))

_ , predicted = torch.max(outputs.data , 1)

print('Predicted: ' , ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

correct = 0

total = 0

for data in testloader:

    images , labels = data

    outputs = net(Variable(images.cuda()))

    _ , predicted = torch.max(outputs.data , 1)

    correct += (predicted == labels.cuda()).sum()

    total += labels.size(0)

print('Accuracy of the network on the 10000 test images: %d %%' % (100 * correct / total))

class_correct = torch.ones(10).cuda()

class_total = torch.ones(10).cuda()

for data in testloader:

    images , labels = data

    outputs = net(Variable(images.cuda()))

    _ , predicted = torch.max(outputs.data , 1)

    c = (predicted == labels.cuda()).squeeze()

    #print(predicted.data[0])

    for i in range(4):

        label = labels[i]

        class_correct[label] += c[i]

        class_total[label] += 1

for i in range(10):

    print('Accuracy of %5s : %2d %%' % (classes[i] , 100 * class_correct[i] / class_total[i]))

# -*- coding:utf-8 -*-

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 numpy as np

import torchvision

from torchvision import datasets , models , transforms

import matplotlib.pyplot as plt

import time

import os

import pylab

#data process

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])

    ]) ,

}

data_dir = 'hymenoptera_data'

image_datasets = {x : datasets.ImageFolder(os.path.join(data_dir , x) , data_transforms[x]) for x in ['train' , 'val']}

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']}

class_names = image_datasets['train'].classes

print(class_names)

use_gpu = torch.cuda.is_available()

#show several images

def imshow(inp , title = None):

    inp = inp.numpy().transpose((1 , 2 , 0))

    mean = np.array([0.485 , 0.456 , 0.406])

    std = np.array([0.229 , 0.224 , 0.225])

    inp = std * inp + mean

    inp = np.clip(inp , 0 , 1)

    plt.imshow(inp)

    if title is not None:

        plt.title(title)

    pylab.show()

    plt.pause(0.001)

inputs , classes = next(iter(dataloders['train']))

out = torchvision.utils.make_grid(inputs)

imshow(out , title = [class_names[x] for x in classes])

#train the model

def train_model(model , criterion , optimizer , scheduler , num_epochs = 25):

    since = time.time()

    best_model_wts = model.state_dict()  #Returns a dictionary containing a whole state of the module.

    best_acc = 0.0

    for epoch in range(num_epochs):

        print('Epoch {}/{}'.format(epoch , num_epochs - 1))

        print('-' * 10)

        #set the mode of model

        for phase in ['train' , 'val']:

            if phase == 'train':

                scheduler.step()  #about lr and gamma

                model.train(True)  #set model to training mode

            else:

                model.train(False)  #set model to evaluate mode

            running_loss = 0.0

            running_corrects = 0

            #Iterate over data

            for data in dataloders[phase]:

                inputs , labels = data

                if use_gpu:

                    inputs = Variable(inputs.cuda())

                    labels = Variable(labels.cuda())

                else:

                    inputs = Variable(inputs)

                    lables = Variable(labels)

                optimizer.zero_grad()

                #forward

                outputs = model(inputs)

                _ , preds = torch.max(outputs , 1)

                loss = criterion(outputs , labels)

                #backward

                if phase == 'train':

                    loss.backward()  #backward of gradient

                    optimizer.step()  #strategy to drop

                running_loss += loss.data[0]

                running_corrects += torch.sum(preds.data == labels.data)

            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))

            if phase == 'val' and epoch_acc > best_acc:

                best_acc = epoch_acc

                best_model_wts = model.state_dict()

        print()

    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))

    model.load_state_dict(best_model_wts)

    return model

#visualizing the model predictions

def visualize_model(model , num_images = 6):

    images_so_far = 0

    fig = plt.figure()

    for i , data in enumerate(dataloders['val']):

        inputs , labels = data

        if use_gpu:

            inputs , labels = Variable(inputs.cuda()) , Variable(labels.cuda())

        else:

            inputs , labels = Variable(inputs) , Variable(labels)

        outputs = model(inputs)

        _ , preds = torch.max(outputs.data , 1)

        for j in range(inputs.size()[0]):

            images_so_far += 1

            ax = plt.subplot(num_images // 2 , 2 , images_so_far)

            ax.axis('off')

            ax.set_title('predicted: {}'.format(class_names[preds[j]]))

            imshow(inputs.cpu().data[j])

            if images_so_far == num_images:

                return

#Finetuning the convnet

from torchvision.models.resnet import model_urls

model_urls['resnet18'] = model_urls['resnet18'].replace('https://' , 'http://')

model_ft = models.resnet18(pretrained = True)

num_ftrs = model_ft.fc.in_features

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

if use_gpu:

    model_ft = model_ft.cuda()

criterion = nn.CrossEntropyLoss()

optimizer_ft = optim.SGD(model_ft.parameters() , lr = 0.001 , momentum = 0.9)

exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft , step_size = 7 , gamma = 0.1)

#start finetuning

model_ft = train_model(model_ft , criterion , optimizer_ft , exp_lr_scheduler , num_epochs = 25)

torch.save(model_ft.state_dict() , '/home/zf/resnet18.pth')

visualize_model(model_ft)

model_conv = torchvision.models.resnet18(pretrained=True)

for param in model_conv.parameters():

    param.requires_grad = False

# Parameters of newly constructed modules have requires_grad=True by default

num_ftrs = model_conv.fc.in_features

model_conv.fc = nn.Linear(num_ftrs, 2)

if use_gpu:

    model_conv = model_conv.cuda()

criterion = nn.CrossEntropyLoss()

# Observe that only parameters of final layer are being optimized as

# opoosed to before.

optimizer_conv = optim.SGD(model_conv.fc.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_conv, step_size=7, gamma=0.1)

model_conv = train_model(model_conv, criterion, optimizer_conv,

                         exp_lr_scheduler, num_epochs=25)