提示:pytorch学习记录:
例如:随着人工智能的不断发展,机器学习这门技术也越来越重要,很多人都开启了学习机器学习,本文就介绍了机器学习的基础内容。
提示:以下是本篇文章正文内容,下面案例可供参考
Scalar
Vector
Matrix
Tensor
张量Tensor可以是高维的,pytorch运算的基本单元,基础数据定义和运算,在pytorch中支持GPU运算,自动求导等操作。
import torch
# tensor(data, *, dtype=None, device=None, requires_grad=False, pin_mimory=False)
?torch.tesnor
# 创建tensor,用dtype指定类型,注意类型要匹配
a = torch.tensor(1.0, dtype=torch.float)
b = torch.tensor(1, dtype=torch.long)
c = torch.tensor(1.0, dtype=torch.int8)
# 使用指定类型函数随机初始化指定大小的tensor
d = torch.FloatTensor(2, 3)
e = torch.IntTensor(2) # 默认是int32
f = torch.IntTensor([1, 2, 3, 4]) # 对于python已经定义号的数据结构可以直接转换
# tensor和numpy array 之间的相互转换
g = np.array([[1, 2, 3], [4, 5, 6]])
h = torch.tensor(g)
i = h.numpy()
# 常见的构造Tensor的函数
k = torch.rand(1, 2) # 随机
l = torch.ones(2, 3)
m = torch.zeros(2, 3)
n = torch.arrange(0, 10, 2) # [0, 10)
# 查看tensor的维度信息
k.shape
k.size()
# tensor的运算
o = torch.add(k, l)
# tensor的索引方式
o[:, 1]
o[0, :]
# 改变tensor形状的神器:view
o.view(3, 2)
o.view(-1, 2) # -1自动推导出大小
# tensor的广播机制(使用时需要注意这个特性)
p = torch.arange(1, 3).view(1, 2)
q = torch.arange(1, 4).view(3, 1)
p + q # 如果未对齐,将自动对齐
# 1 x 2
# 3 x 1
# 3 x 2
# 扩展&压缩tensor的维度: squeeze unsqueeze
o # 2 x 3
r = o.unsqueeze(1) # 在第二个维度扩展
r # 2 x 1 x 3
# 只有维度等于1才能压缩
### 第二部分:自动求导示例
这里将通过一个简单的函数y = x1 + 2 * x2
import torch
x1 = torch.tensor(1.0, requires_grad=True)
x2 = torch.tensor(2.0, requires_grad=True)
y = x1 + 2 * x2
y
# 首先查看每个变量是否需要求导
print(x1.requires_grad)
print(x2.requires_grad)
print(y.requires_grad)
# 查看每个变量导数大小,此时因为还没有反向传播,因此导数不存在
print(x1.grad.data)
print(x2.grad.data)
print(y.grad.data)
x1
## 反向传播后看导数的大小
y = x1 + 2 * x2
y.backward()
print(x1.grad.data)
print(x2.grad.data)
# 导数是会累积的,重复运行相同命令,grad会增加
y = x1 + 2 * x2
y.backward()
print(x1.grad.data)
print(x2.grad.data)
# 所以每次计算前需要清除当前导数值避免累积,这一功能可以通过pytorch的optimizer实现,后续会将
# 尝试,如果不允许求导,会出现什么情况?
x1 = torch.tensor(1.0, requires_grad=False)
x2 = torch.tensor(2.0, requires_grad=False)
y = x1 + 2 * x2
y.backward()
## 读取方式二:使用csv格式的数据,自行构建Dataset类
class FMDataset(Dataset):
def __init__(self, df, transform=None):
self.df = df
self.transform = transform
self.images = df.iloc[:, 1:].values.astype(np.uint8)
self.labels = df.iloc[:, 0].values
def __len__(self):
return len(self.images)
def __getitem__(self, idx):
image = self.images[idx].reshape(28, 28, 1)
label = int(self.labels[idx])
if self.transform is not None:
image = self.transform(image)
else:
image = torch.tensor(image/255, dtype=torch.float)
label = torch.tensor(label, dtype=torch.long)
return image, label
train_df = pd.read_csv("D:/人工智能/pytorch/数据集/fashion-mnist_train.csv")
test_df = pd.read_csv("D:/人工智能/pytorch/数据集/fashion-mnist_test.csv")
train_data = FMDataset(train_df, data_transform)
test_data = FMDataset(test_df, data_transform)
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True, num_workers=num_workers, drop_last=True) # batch_size每一批读入数据,shuffle打乱数据,num_workers读的时候用多少线程读,drop_last是否丢弃最后不满一个batch的数据, pin_memory锁用内存,运行更快,占用内存
test_loader = DataLoader(test_data, batch_size=batch_size, shuffle=False, num_workers=num_workers)
神经网络的构造:基于nn.Module
神经网络是通过“层定义 + 层顺序”的方式构建起来的
神经网络常见层
代码演示
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv = nn.Sequential(
nn.Conv2d(1, 32, 5),
nn.ReLU(),
nn.MaxPool2d(2, stride=2),
nn.Dropout(0.3),
nn.Conv2d(32, 64, 5),
nn.ReLU(),
nn.MaxPool2d(2, stride=2),
nn.Dropout(0.3)
)
self.fc = nn.Sequential(
nn.Linear(64*4*4, 512),
nn.ReLU(),
nn.Linear(512, 10))
def forward(self, x):
x = self.conv(x)
x = x.view(-1, 64*4*4)
x = self.fc(x)
# x = nn.functional.normalize(x)
return x
model = Net()
model = model.cuda()
criterion = nn.CrossEntropyLoss()
# criterion = nn.CrossEntropyLoss(weight=[1, 1, 1, 1, 1, 1, 1, 1, 1, 1])
模型状态设置
训练流程:读取、转换、梯度清零、输入、计算损失、反向传播、参数更新
验证流程:读取、转换、输入、计算损失、计算指标
代码演示
def train(epoch):
model.train()
train_loss = 0
for data, label in train_loader:
data, label = data.cuda(), label.cuda()
optimizer.zero_grad() # 梯度清零
output = model(data)
loss = criterion(output, label)
loss.backward()
optimizer.step()
train_loss += loss.item()*data.size(0)
train_loss = train_loss/len(train_loader.dataset)
print("Epoch:{} \tTraining Loss:{:.6f}".format(epoch, train_loss))
def val(epoch):
model.eval()
val_loss = 0
gt_labels = []
pred_labels = []
with torch.no_grad():
for data, label in test_loader:
data, label = data.cuda(), label.cuda()
output = model(data)
preds = torch.argmax(output, 1)
gt_labels.append(label.cpu().data.numpy())
pred_labels.append(preds.cpu().data.numpy())
loss = criterion(output, label)
val_loss += loss.item()*data.size(0)
val_loss = val_loss/len(test_loader.dataset)
gt_labels, pred_labels = np.concatenate(gt_labels), np.concatenate(pred_labels)
acc = np.sum(gt_labels==pred_labels)/len(pred_labels)
print('Epoch:{} \tValidation Loss:{:.6f}, Accuracy:{:.6f}'.format(epoch, val_loss, acc))
提示:这里对文章进行总结:
例如:以上就是今天要讲的内容,本文仅仅简单介绍了pytorch的使用,而pytorch提供了能使我们快速便捷地训练模型和优化模型的函数和方法。