Titanic - Predict survival on the Titanic and get familiar with ML basics (kaggle) 2부 (학습 진행)

데이터셋 구성

학습과 검증 데이터의 비율을 80:20 으로 구성하였습니다.

그리고 1부에서 진행하였던 데이터 구성으로 학습 데이터와 검증데이터를 구성하였습니다.

 

그리고 test.csv를 이용하여 테스트 데이터셋을 구성하였습니다.

    def make_Tensor(array):
    	return torch.from_numpy(array).float()
    
    data_percent = 0.8
    train_data_len = int(len(x_data) * data_percent)
    train_x = np.array(x_data[:train_data_len])
    val_x = np.array(x_data[train_data_len:])
    train_y = np.array(y_data[:train_data_len])
    val_y = np.array(y_data[train_data_len:])

    train_x = make_Tensor(train_x)
    val_x = make_Tensor(val_x)
    train_y = make_Tensor(train_y)
    val_y = make_Tensor(val_y)
    test_x = make_Tensor(x_test_data)
    test_y = make_Tensor(y_test_data)

    train_dataset = Dataset(train_x, train_y)
    val_dataset = Dataset(val_x, val_y)
    test_dataset = Dataset(test_x, test_y)

위의 데이터 셋을 학습을 위해 dataloader로 구성 합니다.

class Dataset():
    def __init__(self, data, label):
        self.data = data
        self.label = label

    def __len__(self):
        return len(self.data)

    def __getitem__(self, index):
        return self.data[index], self.label[index]
        
    train_dataloader = DataLoader(train_dataset, batch_size=1, shuffle=True)
    val_dataloader = DataLoader(val_dataset, batch_size=1, shuffle=True)
    train_dataloader_dict = {'train':train_dataloader, 'val':val_dataloader}
    test_dataloader = DataLoader(test_dataset, batch_size=1, shuffle=False)

학습을 위한 모델 구성

아래와 같이 다층퍼셉트론 모델을 구성하였습니다. 각 hidden layer 사이의 활성화 함수는 ReLU로 구성하였습니다.

class DNNModel(nn.Module):
    def __init__(self, inputs):
        super(DNNModel, self).__init__()
        input_layer = nn.Linear(inputs, 128)
        hidden1 = nn.Linear(128, 64)
        hidden2 = nn.Linear(64, 32)
        hidden3 = nn.Linear(32, 16)
        output_layer = nn.Linear(16,1)
        self.hidden = nn.Sequential(
            input_layer,
            nn.ReLU(),
            hidden1,
            nn.ReLU(),
            hidden2,
            nn.ReLU(),
            hidden3,
            nn.ReLU(),
            output_layer,
        )
        if torch.cuda.is_available():
            self.hidden = self.hidden.cuda()

    def forward(self, x):
        o = self.hidden(x)
        return o.view(-1)

Loss function 과 optimizer를 다음과 같이 설정하였습니다.

def train_model(model, dataloader_dict, epoch_num, criterion, optimizer):
    for epoch in range(1, epoch_num+1):
        print(" {} epochs--------------".format(epoch))
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
            epoch_loss = 0.0
            epoch_acc = 0
            for inputs, labels in tqdm(dataloader_dict[phase]):
                optimizer.zero_grad()
                with torch.set_grad_enabled(phase=='train'):
                    output = model(inputs)
                    loss = criterion(output, labels)
                    if output <= 0.7:
                        preds = 0
                    else :
                        preds = 1
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
                    epoch_loss += loss.item() * inputs.size(0)
                    epoch_acc += torch.sum(preds==labels.data)
            epoch_loss = epoch_loss/len(dataloader_dict[phase].dataset)
            epoch_acc = epoch_acc.double()/len(dataloader_dict[phase].dataset)
            print("")
            print("[{}] {} epoch loss: {:.4}---------------------------".format(phase, epoch, epoch_loss))
            print("[{}] {} epoch acc : {:.4}---------------------------".format(phase, epoch, epoch_acc))
     return model
def inference(model, dataset_loader):
    result_list = list()
    for inputs, labels in dataset_loader:
        model.eval()
        output = model(inputs)
        if output <= 0.5:
            preds = 0
        else:
            preds = 1
        result_list.append(preds)
    friend_ordered_dict = OrderedDict(
        [
            ('Survived',result_list)
        ]
    )
    df = pd.DataFrame.from_dict(friend_ordered_dict)
    df.to_csv('./dataset/result.csv')

이후 학습과 예측을 실행한 결과 아래와 같은 기록을 kaggle에 달성하였습니다.

정확도가 많이 낮아서 이후 수정이 필요할 것 같습니다.

코드 : https://github.com/22ema/Deep-learning-research-based-on-time-series-data/tree/main/2.Titanic