深度學習練手小常式：cifar-10

PATH_to_SAVE = model/#model/cifar-10-model.pt

class Net(nn.Module):
def __init__(self, model=None):
super(Net, self).__init__()
# input_size : 3 x H x W
self.model = model
if self.model == simple:
......

if self.model == plain:
......
if self.model == residual:
......
# output :
self.fc1 = nn.Linear(64*8*8, 384)
self.fc2 = nn.Linear(384, 192)
self.fc3 = nn.Linear(192, 10)

def num_flat_features(self, x):
size = x.size()[1:]
num_features = 1
for s in size:
num_features *= s
return num_features

def forward(self, net_0):
if self.model == simple:
......

if self.model == plain:
......

if self.model == residual:
......

return output

if __name__ == "__main__":
net = Net(simple)
#print(net)
print(torch.cuda.device_count())
device = torch.device("cuda")
net.to(device)
criterion = nn.CrossEntropyLoss()
lr = 0.01
optimizer = optim.SGD(net.parameters(), lr=lr)
#optimizer = adabound.AdaBound(net.parameters())

print(-------------- get train data ----------------)
path_to_data = CIFAR/cifar-10/cifar_train/
X, Y = tools.get_train_data(path_to_data, train)
batch = 100
x_image_total = X.reshape(-1,batch,32*32*3)
y_label_total = Y.reshape(-1,batch,1)
print(-- image train data size : , x_image_total.shape)
print(-- label train data size : , y_label_total.shape)
running_loss = 0.0
loss_all = []
accuracy = 0.0
accuracy_all = []
train_epochs = 70

print("-------------- start training ----------------")
for epoch in range(train_epochs):
if epoch == int(train_epochs * 0.5) or epoch == int(train_epochs * 0.75):
lr = lr*0.1
for param_group in optimizer.param_groups:
param_group[lr] = lr
print("------------- ",epoch," epoch -------------")
for i in range(y_label_total.shape[0]):
imgbatch = torch.tensor(x_image_total[i], dtype=torch.float).to(device).view(-1, 3, 32, 32)
labelbatch = torch.tensor(y_label_total[i], dtype=torch.float).view(-1).to(device)
optimizer.zero_grad()

pred = net(imgbatch)
# 計算當前的預測準確度
accuracy_now = (torch.argmax(torch.softmax(pred.data,1), 1) == labelbatch.long()).sum().item() / batch
accuracy += accuracy_now
accuracy_all.append(accuracy_now)
# 計算當前的預測損失
loss = criterion(pred, labelbatch.long())
loss_all.append(loss.item())
# 建立反向傳播的OP
loss.backward()
# 優化、更新
optimizer.step()

running_loss += loss.item()
if (i+1) % 100 == 0:
print(i+1, " steps, the loss : ", running_loss / 100.0, " the accuracy : ", accuracy / 100.0)
running_loss = 0.0
accuracy = 0.0
if epoch % 5 ==0:
torch.save(net.state_dict(), PATH_to_SAVE+/simple/+cifar-10-model-+str(epoch)+-epoch.pt)
# save trained model
loss_all = np.array(loss_all)
accuracy_all = np.array(accuracy_all)
np.savetxt(train_results/simple/train_error.txt, loss_all)
np.savetxt(train_results/simple/train_accuracy.txt, accuracy_all)
#torch.save(net.state_dict(), PATH_to_SAVE)

# load trained model

print("-------------- start testing ----------------")
print(-------------- get test data ----------------)
path_to_data = CIFAR/cifar-10/cifar_test/
X, Y = tools.get_train_data(path_to_data, test)
batch = 1000
x_image_total = X.reshape(-1,batch,32*32*3)
y_label_total = Y.reshape(-1,batch,1)
print(-- image test data size : , x_image_total.shape)
print(-- label test data size : , y_label_total.shape)
accuracy = 0.0
model_name_list = os.listdir(PATH_to_SAVE + /simple/)
#print(model_name_list)
for model in model_name_list:
net.load_state_dict(torch.load(PATH_to_SAVE + /simple/ + model), strict=False)
net.eval()
with torch.no_grad():
for i in range(y_label_total.shape[0]):
imgbatch = torch.tensor(x_image_total[i], dtype=torch.float).to(device).view(-1, 3, 32, 32)
labelbatch = torch.tensor(y_label_total[i], dtype=torch.long).view(-1).to(device)
pred = net(imgbatch)
accuracy += (torch.argmax(torch.softmax(pred.data,1), 1) == labelbatch).sum().item() / batch

print("The test accuracy of " + model + " : ", accuracy / y_label_total.shape[0])
accuracy = 0