如何在深度学习竞赛中获得前五名

# Imports here
import torch
import numpy as np
from torchvision import datasets, transforms, models
import matplotlib.pyplot as plt
%matplotlib inline
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim import lr_scheduler
from torch.autograd import Variable
from PIL import Image
from PIL import ImageFile

train_dir = 'train_expanded_character'
test_dir = 'test'
valid_dir = 'valid'

transforms.ColorJitter(brightness=.05, saturation=0, contrast=0)

from torchvision import datasets
import torchvision.transforms as transforms
from torch.utils.data.sampler import SubsetRandomSampler
 
 
# convert data to a normalized torch.FloatTensor for validation set
# validation set is preprocessed to be of appropriate shape to fit into the ResNext model
# validation set's preprocessing does not include transfomration for augmentation
valid_transforms = transforms.Compose([transforms.Resize(255),
                                      transforms.CenterCrop(224),
                                      transforms.ToTensor(),
                                      transforms.Normalize([0.485, 0.456, 0.406],
                                      [0.229, 0.224, 0.225])])
 
 
# training set is preprocessed like validation
# but has the additional transformation for random brightness, for augmentation
augmentation_transforms = transforms.Compose([transforms.Resize(255),                                      
                                      transforms.CenterCrop(224),
                                      transforms.ColorJitter(brightness=.05, saturation=0, contrast=0),  #for AUGMENTATION                        
                                      transforms.ToTensor(),
                                      transforms.Normalize([0.485, 0.456, 0.406],
                                      [0.229, 0.224, 0.225])])

# load the training and test datasets with the appropriate preprocessing
train_data = datasets.ImageFolder(train_dir, transform=augmentation_transforms)
valid_data = datasets.ImageFolder(valid_dir, transform=valid_transforms)
 
# number of subprocesses to use for data loading
num_workers = 0
# how many samples per batch to load
batch_size = 50
 
# obtain indices for training and validation
num_train = len(train_data)
print("Total number of training images: " + str(num_train))
indices = list(range(num_train))
np.random.shuffle(indices)
train_size = int(np.floor(num_train))
train_idx = indices[:train_size]
 
# define samplers for obtaining training and validation batches
train_sampler = SubsetRandomSampler(train_idx)
valid_sampler = SubsetRandomSampler(list(range(len(valid_data))))
 
# prepare data loaders to be used in training model later (prepare data in batches)
trainloader = torch.utils.data.DataLoader(train_data, batch_size=batch_size,
    sampler=train_sampler, num_workers=num_workers)
 
validloader = torch.utils.data.DataLoader(valid_data, batch_size=batch_size,
    sampler=valid_sampler, num_workers=num_workers)

# Select the model
model = models.resnext101_32x8d(pretrained=True)
model

# Freeze parameters so we don't backprop through them
for param in model.conv1.parameters():
    param.requires_grad = False
for param in model.bn1.parameters():
    param.requires_grad = False
for param in model.relu.parameters():
    param.requires_grad = False
for param in model.maxpool.parameters():
    param.requires_grad = False
for param in model.layer1.parameters():
    param.requires_grad = False
for param in model.layer2.parameters():
    param.requires_grad = False

layer_freeze_onwards = 18
 
# in model.layer 3, freeze all weights until the 18th layer
# layers above this are all frozen and not trained
for param in model.layer3[0:layer_freeze_onwards].parameters():
    param.requires_grad = False

# Replace FC layers of pretrained model
model.fc = nn.Sequential(nn.Linear(2048, 42))
print(model)

# No need for logsoftmax on model output when this is used
criterion = nn.CrossEntropyLoss()
 
# Only train the classifier parameters, feature parameters are frozen
optimizer1 = optim.Adam(model.layer3[layer_freeze_onwards:].parameters(), lr=0.00005)
optimizer2 = optim.Adam(model.layer4.parameters(), lr=0.00005)
optimizer3 = optim.Adam(model.fc.parameters(), lr=0.0005)

# number of epochs to train the model
n_epochs = 4
 
# track change in validation loss, start with maximum loss, i.e. infinity
valid_loss_min = np.Inf
 
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
 
for epoch in range(1, n_epochs+1):
 
    # keep track of training and validation loss
    train_loss = 0.0
    valid_loss = 0.0
    train_accuracy = 0.0
    valid_accuracy = 0.0
 
    ###################
    # train the model #
    ###################
 
    model.train()
    for batch_idx, (data, target) in enumerate(trainloader):
        # move tensors to GPU if CUDA is available
        if train_on_gpu:
            data, target = data.cuda(), target.cuda()
        # clear the gradients of all optimized variables
        optimizer1.zero_grad()
        optimizer2.zero_grad()
        optimizer3.zero_grad()
        # forward pass: compute predicted outputs by passing inputs to the model
        output = model(data)
        # calculate the batch loss
        loss = criterion(output, target)
        # backward pass: compute gradient of the loss with respect to model parameters
        loss.backward()
        # perform a single optimization step (parameter update)
        optimizer1.step()
        optimizer2.step()
        optimizer3.step()
        # update training loss
        train_loss += loss.item()*data.size(0)        
        top_p, top_class = output.topk(1, dim=1)
        correct_tensor = top_class.eq(target.data.view_as(top_class))
        correct = np.squeeze(correct_tensor.numpy()) if not train_on_gpu else np.squeeze(correct_tensor.cpu().numpy())
        train_accuracy += np.mean(correct)
     
          
    ######################    
    # validate the model #
    ######################
    model.eval()
    for batch_idx, (data, target) in enumerate(validloader):
        # move tensors to GPU if CUDA is available
        if train_on_gpu:
            data, target = data.cuda(), target.cuda()
        # forward pass: compute predicted outputs by passing inputs to the model
        output = model(data)
        # calculate the batch loss
        loss = criterion(output, target)
        # update average validation loss
        valid_loss += loss.item()*data.size(0)
        top_p, top_class = output.topk(1, dim=1)
        correct_tensor = top_class.eq(target.data.view_as(top_class))
        correct = np.squeeze(correct_tensor.numpy()) if not train_on_gpu else np.squeeze(correct_tensor.cpu().numpy())
        valid_accuracy += np.mean(correct)
        
        
    # calculate average losses
    train_loss = train_loss/len(trainloader.dataset)
    valid_loss = valid_loss/len(validloader.dataset)
    train_accuracy = train_accuracy/len(trainloader)
    valid_accuracy = valid_accuracy/len(validloader)
        
    # print training/validation statistics
    print('Epoch: {} \tTraining Loss: {:.6f} \t Training Acc: {:.6f} \tValidation Loss: {:.6f} \tValidation Acc: {:.6f}'.format(
        epoch, train_loss, train_accuracy, valid_loss, valid_accuracy))
    
    # check if validation loss has decreased
    # this requires
    if valid_loss <= valid_loss_min:
        print('Validation loss decreased ({:.6f} --> {:.6f}).'.format(
        valid_loss_min,
        valid_loss))
        valid_loss_min = valid_loss

from bs4 import BeautifulSoup
import requests
import re
import urllib.request
import os
import http.cookiejar
import json
 
categories = [name for name in os.listdir("./train/")]
print(categories)
 
def get_soup(url,header):
    return BeautifulSoup(urllib.request.urlopen(urllib.request.Request(url,headers=header)),'html.parser')
 
for category in categories:
 
    raw_query = category + " shirt doll" # you can change the query for the image  here
    image_type="ActiOn"
    query= raw_query.split()
    query='+'.join(query)
    url="https://www.google.com/search?q="+query+"&source=lnms&tbm=isch"
    print(url)
    #directory for image
    DIR="expand_train_set_character"
    header={'User-Agent':"Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/43.0.2357.134 Safari/537.36"
    }
    soup = get_soup(url,header)
 
 
    ActualImages=[]# contains the link for Large original images, type of  image
    for a in soup.find_all("div",{"class":"rg_meta"}):
        link , Type =json.loads(a.text)["ou"]  ,json.loads(a.text)["ity"]
        ActualImages.append((link,Type))
 
    print("For " + raw_query + ", there are a total of " + str(len(ActualImages)) + " images.")
 
    if not os.path.exists(DIR):
                os.mkdir(DIR)
    DIR = os.path.join(DIR, category)
 
    if not os.path.exists(DIR):
                os.mkdir(DIR)
 
    DIR = DIR + "/"
 
    print(DIR)
 
    ###print images
    for i, (img , Type) in enumerate( ActualImages):
        try:
            r = requests.get(img, allow_redirects=True)
            if not Type:
                print("No type.")
            else:
                open(DIR + str(i) + "." + Type, 'wb').write(r.content)
                print("Saving " + img)
            #print(img,Type)
            #print()
 
 
        except Exception as e:
            print("could not load : "+img)
            print(e)