多日学习，决定试试以前不敢搞的kaggle
下载了TiTanic数据集，入门尝试

首先

数据集是csv格式，所以引入了pandas的学习，之前偶尔有看到相关的代码，却一直没有上手写
今天就试了试，主要的操作就是读取，以及对行列数据的切割和合并
相关知识的参考链接https://blog.csdn.net/chenKFKevin/article/details/62049060
还有一个就是关于可以使用shape获取数据的行列数信息，其中有一个大坑就是

  1. df = df.iloc[0:2, [0, 2]]

这里的0:2相当于[0,2）前闭后开，2是不在范围之内的。这就导致了我的数据一直少了一行，提交一直不成功。

然后

对数据进行处理，对于性别源数据是male，female。修改为0，1等等

接着

建立神经网络，目前我比较熟悉的也就是线性层，于是就使用线性层加上ReLu

最后

写一个预测的接口，预测结果，写回test.csv

总结

下附代码和运行评定结果

  1. 在数据的导入处理上不熟悉
  2. 可以考虑把网络和激活函数等组件封装为Module，然后返回预测结果，既可以训练又可以预测，本次是散的，才单独写一个预测的接口
  3. 对于如何提高预测结果，考虑增加隐藏层的神经元数目，增厚线性层和Relu交杂的结构，取得了一定的进展，同时加大了epoch训练量
  4. 代码以及模型相关的接口不熟。代码基本是这边抄一点，那边抄一点

运行结果

image.png

三个运行error就是由于数据少了一行，幸幸苦苦训练半天成果还没有默认的女性全部存活的分数高。。
一开始是单纯的两层线性层，一层ReLU，256的隐藏层神经元，300epoch
然后把数据和代码迁移到了Colab上，配置如下附代码：3线性层，2ReLu层，2048隐藏神经元，同时调低了batch_size到8，原来是32。在本地验证在训练集上的表现是从81%左右的正确率到了83%。
image.png

image.png

  1. import pandas as pd
  2. import numpy as np
  3. from sklearn.preprocessing import MinMaxScaler
  4. import time
  5. import copy
  6. import torch.nn as nn
  7. import torch.nn.functional as F
  8. import torch.optim as optim
  10. import torch.nn.functional
  11. from torch.utils.data import Dataset, DataLoader
  12. from torchvision import transforms
  13. import warnings
  14. import torch
  15. USE_CUDA = torch.cuda.is_available()
  17. base_path="/content/"
  18. read_train=pd.read_csv(base_path+'train.csv')
  19. #print(read_train.shape[0])
  20. #print(read_train.shape[1])
  21. read_train
  22. train_data=read_train.iloc[0:read_train.shape[0],[2,4,5]]
  23. print(len(train_data))
  24. train_data['Age'] = train_data['Age'].fillna(train_data['Age'].mean())
  25. train_data['Sex'] = [1 if x == 'male' else 0 for x in train_data.Sex]
  26. train_label=read_train.iloc[:read_train.shape[0],[1]]
  27. train_data=torch.tensor(train_data[:read_train.shape[0]].values,dtype=torch.float)
  28. train_label=torch.tensor(train_label[:read_train.shape[0]].values,dtype=torch.float)
  29. if USE_CUDA:
  30.   train_data =train_data.cuda()
  31.   train_label = train_label.cuda()
  33. loss = torch.nn.MSELoss()
  34. feature_num=train_data.shape[1]
  35. print(feature_num)
  36. print(feature_num)
  37. def get_net(feature_num):
  38.     net = nn.Sequential(
  39.         nn.Linear(feature_num, 2048),
  40.         nn.ReLU(),
  41.         nn.Linear(2048, 2048),  
  42.         nn.ReLU(),
  43.         nn.Linear(2048, 1),
  44.         )
  45.     if USE_CUDA:
  46.       net=net.cuda()
  47.     #net = nn.Linear(feature_num, 1)
  48.     for param in net.parameters():
  49.         nn.init.normal_(param, mean=0, std=0.01)
  50.     return net
  51. def train(net, train_data, train_label,num_epochs, learning_rate,  batch_size):
  52.     train_ls=[]
  53.     dataset = torch.utils.data.TensorDataset(train_data, train_label)
  54.     train_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=True)
  55.     # 这里使用了Adam优化算法
  56.     optimizer = torch.optim.Adam(params=net.parameters(), lr=learning_rate) 
  57.     net = net.float()
  58.     for epoch in range(num_epochs):
  59.         for X, y in train_iter:            
  60.             l = loss(net(X.float()), y.float())
  61.             optimizer.zero_grad()
  62.             l.backward()
  63.             optimizer.step()
  64.         train_ls.append(l.item())
  65.         if epoch % 10 == 0:
  66.             print("epoch ",str(epoch)," : ",l.item())
  67.     return train_ls
  69. net=get_net(feature_num)
  70. num_epochs, lr,  batch_size = 1000 , 0.0002, 8
  71. loss_list=train(net, train_data, train_label, num_epochs,lr, batch_size )
  72. m_loss=0
  73. for i in loss_list:
  74.     m_loss+=i
  75. print(m_loss/num_epochs)
  76. pred=0
  77. with torch.no_grad():
  78.     dataset = torch.utils.data.TensorDataset(train_data, train_label)
  79.     train_iter = torch.utils.data.DataLoader(dataset, batch_size, shuffle=False)
  80.     print(len(train_iter))
  81.     for X, y in train_iter:
  82.             result=net(X.float())
  83.             for i in range(len(result)):
  84.                 if result[i] > 0.5:
  85.                     result[i]= 1
  86.                 else:
  87.                     result[i]=0
  88.             for i in range(len(result)):
  89.                 if result[i]==y[i]:
  90.                     pred+=1
  91. print(pred/891)
  92. read_test=pd.read_csv(base_path+'test.csv')
  93. test_data=read_test.iloc[:read_test.shape[0],[1,3,4]]
  94. test_data['Age'] = test_data['Age'].fillna(test_data['Age'].mean())
  95. test_data['Sex'] = [1 if x == 'male' else 0 for x in test_data.Sex]
  96. length=test_data.shape[0]
  97. #print(length)
  98. test_data=torch.tensor(test_data[:length].values,dtype=torch.float)
  99. all_result=[]
  100. idx=0
  101. with torch.no_grad():
  102.     #print(len(test_data))
  103.     result_dataset = torch.utils.data.TensorDataset(test_data)
  104.     result_dataloader=torch.utils.data.DataLoader(result_dataset,batch_size=32,shuffle=False)
  105.     for X in result_dataloader:
  106.         temp=X[0].cuda()
  108.         result=net(temp.float())
  109.         for i in range(len(result)):
  111.             idx+=1
  112.             if result[i] > 0.5:
  113.                 result[i]= 1
  114.                 all_result.append(1)
  115.             else:
  116.                 result[i]=0
  117.                 all_result.append(0)
  118. #print(idx)
  119. #print(len(all_result))
  120. df_output = pd.DataFrame()
  121. aux = pd.read_csv(base_path+'test.csv')
  122. df_output['PassengerId'] = aux['PassengerId']
  123. #print(len(df_output['PassengerId']))
  124. df_output['Survived'] =all_result
  125. df_output[['PassengerId','Survived']].to_csv(base_path+'s1mple.csv', index=False)