用神经网络解决Titanic问题

使用神经网络解决Titanic问题，主要用两种实现，一种是纯pytorch实现神经网络的搭建，另一种是使用skorch包装好的以pytorch为后端的API实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
import time
import copy
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim import lr_scheduler
import torch.nn.functional
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
import warnings
import torch
torch.manual_seed(0)
warnings.filterwarnings("ignore")
print(torch.__version__)
0.4.1

读入数据文件，这里省去了特征工程的部分，特征采用之前特征工程提取出的特征。

1
2
3
train=pd.read_csv('train_features.csv')
test=pd.read_csv('test_features.csv')
train.head()
1
train.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 13 columns):
PassengerId        891 non-null int64
Pclass             891 non-null int64
Sex                891 non-null int64
Title              891 non-null int64
Family_size        891 non-null int64
Family_Survival    891 non-null float64
FareBin_Code       891 non-null int64
AgeBin_Code        891 non-null int64
Embarked_C         891 non-null int64
Embarked_None      891 non-null int64
Embarked_Q         891 non-null int64
Embarked_S         891 non-null int64
Survived           891 non-null float64
dtypes: float64(2), int64(11)
memory usage: 90.6 KB

1
train.describe()
1
2
3
4
5
6
7
8
9
10
X_train=train.drop(['PassengerId','Survived'],axis=1).as_matrix()
Y_train=train['Survived'].astype(int).as_matrix()
X_test=test.drop(['PassengerId','Survived'],axis=1).as_matrix()
IDtest=test['PassengerId']
# scalar
scaler=MinMaxScaler()
X_train=scaler.fit_transform(X_train)
X_test=scaler.transform(X_test)

使用Pytorch搭建模型

数据载入和处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class TitanicFeaturesDataset(Dataset):
    def __init__(self,X,y=None,transform=None):
        self.X=X
        self.y=y
        self.transform=transform
    
    def __len__(self):
        return self.X.shape[0]
    
    def __getitem__(self,idx):
        if self.y is not None:
            sample={'X':self.X[idx],'y':self.y[idx]}
        else:
            sample={'X':self.X[idx]}
        if self.transform is not None:
            sample=self.transform(sample)
        return sample
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# transform class
class ToTensor(object):
    def __call__(self,sample):
        if 'y' in sample.keys():
            X,y=sample['X'],sample['y']
            return {
                'X':torch.from_numpy(X.astype(np.float32)),
                'y':torch.squeeze(torch.from_numpy(np.array([y.astype(np.int64)])))
            }
        else:
            X=sample['X']
            return {
                'X':torch.from_numpy(X.astype(np.float32))
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Model class
# 自定义Model需要继承nn.Module
class ClassifierModule(nn.Module):
    def __init__(self,D_in=11,D_out=2,num_units=20,nonlin=F.relu,dropout=0.5):
        super(ClassifierModule,self).__init__()
        self.num_units=num_units
        self.nonlin=nonlin
        self.dropout=nn.Dropout(dropout)
        
        self.linear1=nn.Linear(D_in,num_units)
        self.linear2=nn.Linear(num_units,10)
        self.output=nn.Linear(10,2)
        
    def forward(self,X):
        X=self.nonlin(self.linear1(X))
        X=self.dropout(X)
        X=self.nonlin(self.linear2(X))
        X=self.dropout(X)
        X=self.output(X)
        return X
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# train model
def train_model(model,criterion,optimiizer,scheduler,dataset_sizes,num_epochs=100,device='cpu'):
    start=time.time()
    best_model_wts=copy.deepcopy(model.state_dict())
    best_acc=0.0
    
    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch,num_epochs-1))
        print('-'*10)
        
        for phase in ['train','val']:
            if phase == 'train':
                scheduler.step()
                model.train()
            else:
                model.eval()
            running_loss=0.0
            running_corrects=0
            for sample_batches in dataloaders[phase]:
                inputs=sample_batches['X'].to(device)
                labels=sample_batches['y'].to(device)
                
                optimizer.zero_grad()
                
                with torch.set_grad_enabled(phase=='train'):
                    outputs=model(inputs)
                    _,preds=torch.max(outputs,1)
                    loss=criterion(outputs,labels)
                    
                    if phase=='train':
                        loss.backward()
                        optimizer.step()
                    running_loss+=loss.item()*inputs.size(0)
                    running_corrects+=torch.sum(preds==labels.data)
            epoch_loss=running_loss/dataset_sizes[phase]
            epoch_acc=running_corrects.double()/dataset_sizes[phase]
            print('{} loss: {:.4f} Acc: {:.4f}'.format(phase,epoch_loss,epoch_acc))
            
            if phase=='val' and epoch_acc>best_acc:
                best_acc=epoch_acc
                best_model_wts=copy.deepcopy(model.state_dict())
    time_elapsed=time.time()-start
    print('Trainning complete in {:.0f}m {:.0f}s'.format(
            time_elapsed//60,time_elapsed%60))
    print('Best val Acc: {:4f}'.format(best_acc))
    model.load_state_dict(best_model_wts)
    return model
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# load data and train
train_dataset_len=X_train.shape[0]
train_len=train_dataset_len*4//5
transformed_datasets = {
        'train': TitanicFeaturesDataset(X_train[:train_len],Y_train[:train_len], transform=transforms.Compose([ToTensor()])),
        'val': TitanicFeaturesDataset(X_train[train_len:], Y_train[train_len:], transform=transforms.Compose([ToTensor()])),
        'test':TitanicFeaturesDataset(X_test,transform=transforms.Compose([ToTensor()]))
        }
dataloaders = {x: DataLoader(transformed_datasets[x], batch_size=16,
                                 shuffle=True, num_workers=0)
                   for x in ['train', 'val']}
dataloaders['test']=DataLoader(transformed_datasets['test'],batch_size=16,shuffle=False,num_workers=0)
dataset_sizes = {x: len(transformed_datasets[x]) for x in ['train', 'val','test']}
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
1
2
3
4
5
6
7
model=ClassifierModule()
# 这里就包含了softmax
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=2e-2,momentum=0.9)
exp_lr_scheduler=lr_scheduler.StepLR(optimizer,step_size=7,gamma=0.1)
model=train_model(model,criterion,optimizer,exp_lr_scheduler,dataset_sizes,num_epochs=100,device=device)
Epoch 0/99
----------
train loss: 0.6819 Acc: 0.5674
val loss: 0.6576 Acc: 0.6425
Epoch 1/99
----------
train loss: 0.6624 Acc: 0.6096
val loss: 0.6418 Acc: 0.6425
Epoch 2/99
----------
...
Epoch 97/99
----------
train loss: 0.4965 Acc: 0.7598
val loss: 0.3836 Acc: 0.8603
Epoch 98/99
----------
train loss: 0.4819 Acc: 0.7556
val loss: 0.3836 Acc: 0.8603
Epoch 99/99
----------
train loss: 0.4981 Acc: 0.7626
val loss: 0.3836 Acc: 0.8603
Trainning complete in 0m 9s
Best val Acc: 0.877095

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# save model and reload it
torch.save(model.state_dict(),'pytorch_model.pth')
reloaded_model=ClassifierModule()
reloaded_model.load_state_dict(torch.load('pytorch_model.pth'))
# predicts on  test dataset
reloaded_model.eval()
final_predicts=[]
with torch.no_grad():
    for samples in dataloaders['test']:
        inputs=samples['X'].to(device)
        outputs=reloaded_model(inputs)
        _,preds=torch.max(outputs,1)
        for y_predict in list(preds.numpy()):
            final_predicts.append(y_predict)
final_predicts=np.array(final_predicts).reshape(-1,)
predict_survived_pytorch=pd.Series(final_predicts,name='Survived')
pytorch_result=pd.concat([IDtest,predict_survived_pytorch],axis=1)
pytorch_result.to_csv('pytorch_result.csv',index=False)
pytorch_result.head()

使用skorch搭建模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
from skorch import NeuralNetClassifier
from skorch.dataset import CVSplit
from sklearn.model_selection import GridSearchCV
import skorch
print(skorch.__version__)
class skorchModule(nn.Module):
    def __init__(self,num_units=20):
        super(skorchModule,self).__init__()
        self.net=ClassifierModule(num_units=num_units)
    
    def forward(self,X):
        X=self.net(X)
        X=F.softmax(X,dim=-1)
        return X
        
        
model = NeuralNetClassifier(
        skorchModule,
        max_epochs=200,
        lr=0.02,
        train_split=CVSplit(5),
        #     device='cuda',  # uncomment this to train with CUDA
    )
   
X = X_train.astype(np.float32)
Y = Y_train.astype(np.int64)
params = {
        'lr': [0.02],
        'max_epochs': [200],
        'module__num_units': [20],
}
# 用scoring='neg_log_loss'训练不正确？不知道为啥，只好在Module层加入softmax
gs = GridSearchCV(model, params, refit=True, cv=2, scoring='accuracy')
gs.fit(X, Y)
print(gs.best_score_, gs.best_params_)
gs.estimator.set_params(**gs.best_params_).fit(X, Y)
predict_Survived_skorch = pd.Series(gs.predict(X_test.astype(np.float32)), name='Survived')
skorch_result = pd.concat([IDtest, predict_Survived_skorch], axis=1)
skorch_result.to_csv('skorch_result.csv', index=False)
skorch_result.head()
0.3.0
  epoch    train_loss    valid_acc    valid_loss     dur
-------  ------------  -----------  ------------  ------
      1        0.7777       0.3596        0.7712  0.0215
      ...

  epoch    train_loss    valid_acc    valid_loss     dur
-------  ------------  -----------  ------------  ------
      1        0.6797       0.6704        0.6408  0.0250
      2        0.6756       0.6704        0.6409  0.0250
      3        0.6767       0.6704        0.6409  0.0250
      ...
    200        0.5370       0.7709        0.4915  0.0200
0.7845117845117845 {'lr': 0.02, 'max_epochs': 200, 'module__num_units': 20}
  epoch    train_loss    valid_acc    valid_loss     dur
-------  ------------  -----------  ------------  ------
      1        0.7113       0.6704        0.6715  0.0190
      2        0.7007       0.6704        0.6704  0.0264
    ...
    199        0.5825       0.7989        0.5358  0.0220
    200        0.5838       0.7989        0.5350  0.0240

参考

1、Pytorch data_loading tutorial

2、Pytorch_transfer_learning_tutorial

3、skorch basic usage

4、notebook

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true