[人工智能]pytorch框架（2）

试验四：

import numpy as np
import torch
# Dataset 是一个抽象类，需要子类来继承
from torch.utils.data import Dataset
# DataLoad 是可以实例化的
from torch.utils.data import DataLoader

class DiabetesDataset(Dataset):
    def __init__(self, filepath):
        # filepath: 路径下是.csv文件
        xy = np.loadtxt(filepath, delimiter=',', dtype=np.float32)
        self.len = xy.shape[0]
        self.x_data = torch.from_numpy(xy[:,:-1])
        selg.y_data = torch.from_numpy(xy[:,[-1]])

    # 可以提取出样本的索引
    def __getitem__(self, index):
        return x_data[index], y_data[index]

    def __len__(self):
        return self.len

dataset = DiabetesDataset('diabetes.csv.gz')

# batch_size: 一次32个样本； shuffle: 表示打乱样本顺序； num_workers:表示几个线程读取数据
train_load = DataLoader(dataset = dataset, batch_size = 32, shuffle = True, num_workers = 2)




class Model(torch.nn.Module):
    del __init__(self):
        super(Model, self).__init__()
        self.linear1 = torch.nn.Linear(8, 6)
        self.linear2 = torch.nn.Linear(6, 4)
        self.linear3 = torch.nn.Linear(4, 1)
        self.sigmoid = torch.nn.Sigmoid()

del forward(self, x):
        x = self.sigmoid(self.linear1(x))
        x = self.sigmoid(self.linear2(x))
        x = self.sigmoid(self.linear3(x))
        return x

model = Model()



criterion = torch.nn.BCELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)




if __name__=='__main__':
    for epoch in range(100):
        for i, data in enumerate(train_load, 0):

            inputs, label = data
            y_pred = model(inputs)
            loss = criterion(y_pred, label)
            print (epoch, i, loss.item())

            optimizer.zero_grad()
            loss.backward()

            optimizer.step()

试验五：

# coding:utf-8
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim


batch_size = 64

# (N, 1, 28, 28)
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ), (0.3081, ))
])

train_dataset = datasets.MNIST(root = './dataset',
                               train=True,
                               download=True,
                               transform=transform)

train_loader = DataLoader(train_dataset,
                          shuffle=True,
                          batch_size=batch_size)

test_dataset = datasets.MNIST(root='./dataset',
                              train=False,
                              download=True,
                              transform=transform)

test_loader = DataLoader(test_dataset,
                         shuffle=False,
                         batch_size=batch_size)


# 牛啊 ！！！
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = nn.Linear(784, 512)
        self.l2 = nn.Linear(512, 256)
        self.l3 = nn.Linear(256, 128)
        self.l4 = nn.Linear(128, 64)
        self.l5 = nn.Linear(64, 10)

    def forward(self,x):
        # (N, 784)
        x = x.view(-1, 784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)

model = Net()


# 交叉熵损失
criterion = torch.nn.CrossEntropyLoss()
# momentum:带冲量的随机梯度优化器
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_size % 300 == 299:
            print ('[%d, %5d] loss: %.3f' %(epoch + 1, batch_size + 1, running_loss/300))
            running_loss = 0.0

def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, label = data
            outputs = model(images)  # (b, 10)
            _, predict = torch.max(outputs.data, dim=1)
            total += label.size(0)
            correct += (predict==label).sum().item()

        print ('Accuracy on test set: %d %%' %(100*correct/total))


if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

试验六：

import torch

in_channels, out_channels = 5, 10
width, height = 100, 100
kernel_size = 3
batch_size = 1

input = torch.randn(batch_size,
                    in_channels,
                    width,
                    height)

conv_layer = torch.nn.Conv2d(in_channels,
                             out_channels,
                             kernel_size = kernel_size)

output = conv_layer(input)

print (input.shape)
print (output.shape)
print (conv_layer.weight.shape)