Kaggle-자동차가격예측

"자동차 가격 예측하기"

본 데이터 셋은 kaggle open dataset으로, 영국의 중고차량 정보들로 구성되어있습니다

해당 데이터 셋은 중고 차량에 대한 가격, 변속기, 마일리지, 연료 유형, 도로세, 갤런당 마일리지(mpg), 제조회사 및 엔진 크기 등을 확인할 수 있습니다.
위에 언급한 차량의 정보들(제조회사, 엔진크기, 변속기 등)을 통하여 해당 차량의 가격을 예측하는 문제입니다.

-Date set-

• ID - 자동자 제품의 인덱스 넘버를 의미합니다.
  • company - 자동차 제조 회사를 의미하며, 총 5개(bmw, ford, hyundai, audi, toyota)의 회사로 구성되어있습니다.
• model - 해당 차량의 제품명(모델)을 의미합니다.
• year - 해당 차량의 제조년도를 의미합니다.
• transmission - 해당 차량의 변속기를 의미합니다.
• mileage - 해당 차량의 마일리지를 의미합니다.
• fueltype - 해당 차량의 연료 유형을 의미합니다.
• tax - 해당 차량의 세금을 의미합니다.
• mpg - 해당 차량의 마일 당 갤런 사용량(연비)를 의미합니다.
• enginesize - 해당 차량의 엔진 크기를 의미합니다.
• price - 해당 차량의 가격을 의미합니다.

-Code-

Data Load

# This Python 3 environment comes with many helpful analytics libraries installed
# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python
# For example, here's several helpful packages to load

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
import torch
import torch.optim as optim
from sklearn import preprocessing
# For reproducibility
torch.manual_seed(1)

# Input data files are available in the read-only "../input/" directory
# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using "Save & Run All" 
# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session

train_df = pd.read_csv("/kaggle/input/2021-ai-w3-p2/train_data.csv")
test_df = pd.read_csv("/kaggle/input/2021-ai-w3-p2/test_data.csv")
submit_df = pd.read_csv("/kaggle/input/2021-ai-w3-p2/sample_submit.csv")

전처리에 사용되는 sklearn 라이브러리의 preprocessing 모듈을 사용했으며
학습에 도출되는 값들이 일정하게 고정시키기 위해 torch.manual_seed를 1로 고정시켜주었습니다.

Preprocessing

## preprocessing LabelEncoding "Model" Column
le = preprocessing.LabelEncoder()
le.fit(train_df['model'])
train_df['model'] = le.transform(train_df['model'])
test_df['model'] = le.transform(test_df['model'])

LabelEncoder 객체를 만들어준 후 라벨데이터가 되는 'model'열의 데이터 기준으로 라벨 데이터를 학습시켜 train과 test데이터의 모든 model데이터에 라벨링을 해주었습니다.

Data Parsing

x1_train = torch.FloatTensor(train_df['company']).cuda()
x2_train = torch.FloatTensor(train_df['model']).cuda()
x3_train = torch.FloatTensor(train_df['year']).cuda()
x4_train = torch.FloatTensor(train_df['transmission']).cuda()
x5_train = torch.FloatTensor(train_df['mileage']).cuda()
x6_train = torch.FloatTensor(train_df['fueltype']).cuda()
x7_train = torch.FloatTensor(train_df['tax']).cuda()
x8_train = torch.FloatTensor(train_df['mpg']).cuda()
x9_train = torch.FloatTensor(train_df['engineSize']).cuda()
y_train = torch.FloatTensor(train_df['price']).cuda()

행렬을 사용하지 않고 Naive하게 진행해보기 위해 x의 모든 데이터들을 학습에 사용하기 위해 각각 텐서화 시켜주고, 모든 텐서는 GPU를 사용하기 위해 cuda()를 적용시켜 주었습니다.

Parameters setting

# 모델 초기화
w1 = torch.zeros(1, requires_grad=True, device = "cuda")
w2 = torch.zeros(1, requires_grad=True,device = "cuda")
w3 = torch.zeros(1, requires_grad=True,device = "cuda")
w4 = torch.zeros(1,requires_grad= True,device = "cuda")
w5 = torch.zeros(1, requires_grad=True,device = "cuda")
w6 = torch.zeros(1, requires_grad=True,device = "cuda")
w7 = torch.zeros(1, requires_grad=True,device = "cuda")
w8 = torch.zeros(1,requires_grad= True,device = "cuda")
w9 = torch.zeros(1,requires_grad= True,device = "cuda")
b = torch.zeros(1, requires_grad=True,device = "cuda")
# optimizer 설정
optimizer = optim.SGD([w1, w2, w3,w4,w5,w6,w7,w8,w9, b], lr=9.64e-10)

nb_epochs = 2000000

W값을 모두 0으로 초기화 해주고, b도 0으로 초기화 시켜주면서 모든 디바이스는 cuda를 사용하게 해주었습니다.
Optimizer 방식은 SGD를 채택했으며 learning rate는 9.64e-10로 했을 때 성능이 더 좋았습니다.

epochs는 총 2000000번 학습하도록 설정합니다.

for epoch in range(nb_epochs + 1):
    
    # H(x) 계산
    hypothesis = x1_train * w1 + x2_train * w2 + x3_train * w3 + x4_train * w4 + x5_train * w5+ x6_train * w6+x7_train * w7+x8_train * w8+x9_train * w9 + b

    # cost 계산
    cost = torch.mean((hypothesis - y_train) ** 2)

    # cost로 H(x) 개선
    optimizer.zero_grad()
    cost.backward()
    optimizer.step()

    # 100번마다 로그 출력
    if epoch % 500000 == 0:
        print('Epoch {:4d}/{}  Cost: {:.6f}'.format(
            epoch, nb_epochs, cost.item()
        ))

행렬을 사용하지 않고 Naive 하게 모든 Data들을 곱해주어 가설을 설정하고, Cost도 기존 Cost방식을 사용하였습니다.
forward와 backward를하여 다음 step으로 건너가는 과정을 반복해주며 epoch가 500000번 반복될 때 마다 cost값이 출력 되도록 해주었습니다.

Predict

x1_test = torch.FloatTensor(test_df['company']).cuda()
x2_test = torch.FloatTensor(test_df['model']).cuda()
x3_test = torch.FloatTensor(test_df['year']).cuda()
x4_test = torch.FloatTensor(test_df['transmission']).cuda()
x5_test = torch.FloatTensor(test_df['mileage']).cuda()
x6_test = torch.FloatTensor(test_df['fueltype']).cuda()
x7_test = torch.FloatTensor(test_df['tax']).cuda()
x8_test = torch.FloatTensor(test_df['mpg']).cuda()
x9_test = torch.FloatTensor(test_df['engineSize']).cuda()
y_pred = x1_test * w1 + x2_test * w2 + x3_test * w3 + x4_test * w4 + x5_test * w5+ x6_test * w6+x7_test * w7+x8_test * w8+x9_test * w9 + b
print(y_pred)

Naive하게 코드를 짰으므로 test데이터로 예측할 때도 모든 데이터를 Naive하게 해주었습니다.
test 데이터들도 모두 학습에 사용하기 위해 텐서화를 시켜주고 학습된 모델에 태워 예측값을 도출해냈습니다.

Submit

submit_df['price'] = y_pred.cpu().detach().numpy()
submit_df.to_csv("sample_submit.csv",index=False)

이렇게 예측된 값을 제출 답안지의 price열에 GPU에서 CPU로 꺼내어 numpy화 시켜 대입해줍니다. 제출하면 Baseline보다 높은 성능을 보였습니다.