torch相关
从start_dim开始到end_dim结束，将维度相乘即可得到flatten后的值
max
import torch
output = torch.tensor([[1, 2, 3], [3, 4, 5]])
predict = torch.max(output, dim=0)
print(predict)
predict = torch.max(output, dim=1)
print(predict)
_, predicted = torch.max(outputs.data, 1)
在多分类问题中，常用来返回得到结果概率最大的那个类别，转化成相应的索引
卷积神经网络(CNN)
将昨天残留下来的问题给解决了，后面验证了一下正确率是89%，还有待加强，但是刚起步不急，之后可以再调整一下参数啥的，让正确率提上去
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import TensorDataset
from sklearn.model_selection import train_test_split
batch_size = 20
# 加载数据
train_x = pd.read_csv('images_train.csv', header=None)
train_y = pd.read_csv('labels_train.csv', header=None).values.ravel() # 将标签转换为一维数组
x_train, x_val, y_train, y_val = train_test_split( train_x, train_y, test_size=0.2, random_state=42)
trainx=torch.tensor(x_train.values,dtype = torch.float32).reshape(48000,28,28)
trainx = torch.unsqueeze(trainx,1)
trainy=torch.tensor(y_train,dtype = torch.uint8)
testx=torch.tensor(x_val.values,dtype = torch.float32).reshape(12000,28,28)
testx = torch.unsqueeze(testx,1)
testy=torch.tensor(y_val,dtype = torch.uint8)
all_dataset = TensorDataset(trainx,trainy)
all_dataloader = torch.utils.data.DataLoader(all_dataset,batch_size=batch_size,shuffle = True)
all_testdataset = TensorDataset(testx,testy)
all_testdataloader = torch.utils.data.DataLoader(all_testdataset,batch_size=batch_size,shuffle = True)
class net(nn.Module):
def __init__(self):
super().__init__()
self.conv1 = nn.Conv2d(1,3,3) #28-3+1 = 26
self.pool1 = nn.MaxPool2d(2,2) # 26-2/2 +1 13
self.conv2 = nn.Conv2d(3,9,3) #13-3+1 = 11
self.pool2 = nn.MaxPool2d(2,1) #11-2+1=10
self.fc1 = nn.Linear(9*10*10,100)
self.fc2 = nn.Linear(100,50)
self.fc3 = nn.Linear(50, 30)
self.fc4 = nn.Linear(30, 10)
def forward(self,x):
x = self.pool1(F.relu(self.conv1(x)))
x = self.pool2(F.relu(self.conv2(x)))
x = torch.flatten(x,1) # flatten all dimensions except batch
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = F.relu(self.fc3(x))
x = self.fc4(x)
return x
net = net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(5): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(all_dataloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs,labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
running_loss = 0.0
net.eval()
with torch.no_grad():
total_loss = 0
correct_predictions = 0
total_samples = 0
# 迭代验证集
for data, targets in all_testdataloader:
outputs = net(data) # 前向传播
loss = criterion(outputs, targets) # 计算损失
total_loss += loss.item() * data.size(0) # 累加损失
# 转换输出为类别索引
_, predicted = torch.max(outputs.data, 1)
correct_predictions += (predicted == targets).sum().item() # 计算正确预测数量
total_samples += targets.size(0)
# 计算平均损失和准确率
avg_loss = total_loss / total_samples
accuracy = correct_predictions / total_samples
print(f"Validation Loss: {avg_loss:.4f}")
print(f"Validation Accuracy: {accuracy:.4f}")
多层感知机
同样也是python实验课的实验，主要内容是根据11个影响酒品质的因素，数据集是1439条数据，酒的品种有A B C三种，来预测酒的品种
这些代码基本上是我自己手敲上去的，有一点借鉴了之前的卷积神经网络，明天再把一些代码再理解的透彻一些，但是这个实验的正确率不高，只有86%左右，可以再调整下参数或者用其他的能优化的办法
import pandas as pd
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.data import TensorDataset
from sklearn.model_selection import train_test_split
train_x=pd.read_csv("data-train.csv")
traindata=train_x.drop("target",axis = 1)
trainlabel=train_x["target"].values.ravel()
x_train, x_val, y_train, y_val = train_test_split( traindata, trainlabel, test_size=0.2, random_state=42)
batch_size=10
traindata= torch.tensor(x_train.values,dtype = torch.float32)
testdata= torch.tensor(x_val.values,dtype = torch.float32)
labels = torch.zeros(y_train.shape,dtype = torch.uint8)
labels1 = torch.zeros(y_val.shape,dtype = torch.uint8)
for i in range(len(y_train)):
if y_train[i] == 'A':
labels[i] = 0
elif y_train[i] == 'B':
labels[i] = 1
else:
labels[i] = 2
for i in range(len(y_val)):
if y_val[i] == 'A':
labels1[i] = 0
elif y_val[i] == 'B':
labels1[i] = 1
else:
labels1[i] = 2
all_dataset = TensorDataset(traindata,labels)
all_dataloader = torch.utils.data.DataLoader(all_dataset,batch_size=batch_size,shuffle = True)
all_testset = TensorDataset(testdata,labels1)
all_testloader = torch.utils.data.DataLoader(all_testset,batch_size=batch_size,shuffle = True)
class net(nn.Module):
def __init__(self):
super().__init__()
self.fc1=nn.Linear(11,6)
self.fc2=nn.Linear(6,3)
def forward(self, x):
x = torch.flatten(x,1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return x
net = net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(5): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(all_dataloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs,labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
print(f'Epoch [{epoch + 1}/5], Loss: {loss.item():.4f}')
correct = 0
total = 0
net.eval()
with torch.no_grad():
total_loss = 0
correct_predictions = 0
total_samples = 0
# 迭代验证集
for data, targets in all_testloader:
outputs = net(data) # 前向传播
loss = criterion(outputs, targets) # 计算损失
total_loss += loss.item() * data.size(0) # 累加损失
# 转换输出为类别索引
_, predicted = torch.max(outputs.data, 1)
correct_predictions += (predicted == targets).sum().item() # 计算正确预测数量
total_samples += targets.size(0)
# 计算平均损失和准确率
avg_loss = total_loss / total_samples
accuracy = correct_predictions / total_samples
print(f"Validation Loss: {avg_loss:.4f}")
print(f"Validation Accuracy: {accuracy:.4f}")
