pytorch 实践二

#coding=utf-8
import torch
import numpy as np
import torch.nn as nn
from torchvision import datasets, transforms
from torch.utils import data
import os
from PIL import Image
import torch.nn.functional as F
from torch.autograd import Variable

def default_loader(path):
    return Image.open(path).convert('RGB')

class MyDataset(data.Dataset):
    def __init__(self, txt, transform=None, target_transform=None, loader=default_loader):
        fh = open(txt, 'r')
        imgs = []
        for line in fh:
            line = line.strip('\n')
            line = line.rstrip()
            words = line.split()
            imgs.append((words[0],int(words[1])))
        self.imgs = imgs
        self.transform = transform
        self.target_transform = target_transform
        self.loader = loader

    def __getitem__(self, index):
        fn, label = self.imgs[index]  # fn为路径，label为标签
        img = self.loader(fn)
        if self.transform is not None:
            img = self.transform(img)
        return img,label

    def __len__(self):
        return len(self.imgs)
root="./data"
train_data=MyDataset(txt=root+'train.txt', transform=transforms.ToTensor())
test_data=MyDataset(txt=root+'test.txt', transform=transforms.ToTensor())
train_loader = data.DataLoader(dataset=train_data, batch_size=64, shuffle=True,num_workers=2)
test_loader = data.DataLoader(dataset=test_data, batch_size=64,num_workers=2)
#print train_data[0][1]

num_inputs = 28*28
num_outputs = 10
w = np.random.normal(scale=1.0,size=(num_inputs,num_outputs))
b = np.zeros(num_outputs)
para = [w,b]

def softmax(X):
    exp = torch.exp(X).numpy()
    print exp
    add = np.sum(exp,axis=1,keepdims=True)
    print add

    # partition = torch.div(exp,add)
    partition = exp / add
    return torch.from_numpy(partition)

# X = torch.randn((3,2))
# X_prob = softmax(X)
# print X_prob

def net1(X):
    return softmax(torch.dot(X.view((-1, num_inputs)), w) + b)

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Sequential(
            torch.nn.Conv2d(3, 32, 3, 1, 1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2))
        self.conv2 = torch.nn.Sequential(
            torch.nn.Conv2d(32, 64, 3, 1, 1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2)
        )
        self.conv3 = torch.nn.Sequential(
            torch.nn.Conv2d(64, 64, 3, 1, 1),
            torch.nn.ReLU(),
            torch.nn.MaxPool2d(2)
        )
        self.dense = torch.nn.Sequential(
            torch.nn.Linear(64 * 3 * 3, 128),
            torch.nn.ReLU(),
            torch.nn.Linear(128, 10))
    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        x = x.view(x.size(0),-1)  # 展平多维的卷积图成 (batch_size, 32 * 7 * 7)   x.size(0) 是x的行数
        out = self.dense(x)
        return out

model = Net()
model.cuda()
#print(model)
optimizer = torch.optim.Adam(model.parameters(),lr=0.001)
loss_func = nn.CrossEntropyLoss()

for epoch in range(1):
    train_loss = 0.
    train_acc = 0.
    for x,y in train_loader:
        x = Variable(x).cuda()
        y = Variable(y).cuda()
        out_put = model(x)
        #print 'output',out_put
        loss = loss_func(out_put, y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        train_loss += loss.data[0]
        # print 'loss0',type(loss.data[0])
        # print 'loss1',type(loss.data)
        # print 'loss1111',loss.data
        pred = torch.max(out_put, 1)[1]  # 最大值所在的索引
        train_correct = (pred == y).sum()
        train_acc += train_correct.data[0]
        #print train_correct.data[0]  # 变成了标量
        print len(train_loader)  # 6000
    print('Train Loss: {:.6f}, Acc: {:.6f}'.format(train_loss / (len(
        train_data)), train_acc / (len(train_data))))

 # evaluation--------------------------------
'''
model.eval()
eval_loss = 0.
eval_acc = 0.
for batch_x, batch_y in test_loader:
    batch_x, batch_y = Variable(batch_x, volatile=True), Variable(batch_y, volatile=True)
    out = model(batch_x)
    loss = loss_func(out, batch_y)
    eval_loss += loss.data[0]
    pred = torch.max(out, 1)[1]
    num_correct = (pred == batch_y).sum()
    eval_acc += num_correct.data[0]
print('Test Loss: {:.6f}, Acc: {:.6f}'.format(eval_loss / (len(
    test_data)), eval_acc / (len(test_data))))
'''