머신러닝 기초

ML(머신러닝)

과거의 데이터에서 미래의 데이터를 예측(회기 또는 분류)함.

• 정형데이터 : sklearn 모듈

  숫자나 문서같은 데이터

• 비정형데이터 : tensorflow, pytorch

  사운드나 영상 같은 대용량 데이터

지도학습, 비지도학습

• 지도학습 : y값이 있음

• 비지도학습 : y값이 없음(Gan,강화학습)

회귀, 분류

• 회귀(regression) : y값의 결과가 임의의 숫자 1개일 때

  • 단순선형회귀 : x데이터가 한개

    $y=wx+b$

  • 다중선형회귀 : x데이터가 여러개

• 분류(classification) : 중복을 제거한 y값의 결과가 n개의 경우만 있을 때

  • 이항 : y결과가 0~1사이값이 되도록 하는 함수가 필요

  • 다항 : y결과가 카테고리 개수만큼 나올 수 있또록 하는 함수 필요

활성화 함수

활성한 함수란 $ y=f(x) $

x데이터와 y데이터 간의 수식을 찾는 과정

기본수식은 wx+b -> 로그값을 취하면 이항분류 -> 여러개의 로그값을 확률로 변홯나면 다항분류

회귀분석의 예측 y 값의 예 : 300

이항분류 예측 y 값의 예 : 0.2

사용자가 일정값을 기준으로 0과 1로 변경해야함 (임계값) - 시그모이드 함수

다항분류 예측 y 값의 예 : [0,2,0.8]

사용자가 여러 값 중에 가장 큰 값이 있는 위치를 찾아야함 - 소프트맥스 함수

sklearn은 이항분류 다항분류 모두 소프트맥스함수를 사용

정형데이터 필수 전처리

x, y데이터는 무조건 숫자여야함(bias weight값을 구하려면 평균을 내야하는데 null이나 문자가잇으면 계산이 불가능). 결측치(null)값 안됌

최소제곱법 : MSE

오차의 제곱의 합이 가장 최소가 되는 지점

권장사항

• x데이터의 정규화(스케일링) : MSE(min, max), MAE(절대값)

• x데이터의 더미변수화 : one-hot encoding

정형, 비정형데이터 모델 작업전 사항

훈련 데이터, 테스트 데이터, 검증 데이터 분할

훈련 데이터에서 w,b값을 추출하고 테스트 데이터에서는 적용만 함.

테스트 데이터가 잘 안나오면 훈련 데이터를 변경해야 함.

테스트 데이터까지 잘 나오면 검증 데이터에 적용.

(적용: 검증 데이터의 y값과 검증 데이터의 x값으로 예측한 y값이 잘 맞는가)

import pandas as pd
from sklearn.linear_model import LinearRegression
import numpy as np

##########데이터 로드

train_df = pd.read_excel('https://github.com/cranberryai/todak_todak_python/blob/master/machine_learning/regression/%E1%84%8B%E1%85%A1%E1%84%87%E1%85%A5%E1%84%8C%E1%85%B5%E1%84%8B%E1%85%A1%E1%84%83%E1%85%B3%E1%86%AF%E1%84%8F%E1%85%B5.xlsx?raw=true', sheet_name='train')
test_df = pd.read_excel('https://github.com/cranberryai/todak_todak_python/blob/master/machine_learning/regression/%E1%84%8B%E1%85%A1%E1%84%87%E1%85%A5%E1%84%8C%E1%85%B5%E1%84%8B%E1%85%A1%E1%84%83%E1%85%B3%E1%86%AF%E1%84%8F%E1%85%B5.xlsx?raw=true', sheet_name='test')

##########데이터 분석

##########데이터 전처리

x_train = train_df.drop(['Son'], axis=1) # 아들 컬럼을 버림 train_df['Father']와 같지만 n-1개의 데이터를 넣는것 보다 전체에서 -1하는게 더 빠름
x_test = test_df.drop(['Son'], axis=1)
y_train = train_df['Son']
y_test = test_df['Son']

print(x_train.head())
'''
    Father
0  160.782
1  166.116
2  165.608
3  169.672
4  176.530
'''

x_train = x_train.to_numpy() # x_train.values
x_test = x_test.to_numpy()

# 아버지의 키를 입력하면 아들의 키를 예측(아들의 키는 무한대의 숫자 중 1개)
# 즉 가장 단순한 선형회귀(linearregression)를 사용

##########모델 생성

model = LinearRegression() # fit_intercept : bias를 살릴 것인지 체크하는 bool

##########모델 학습

model.fit(x_train, y_train)

##########W,b값 확인
model.coef_, model.intercept_ # w, b 값

##########모델 검증

print(model.score(x_test, y_test)) #0.251997790584662

##########모델 예측

x_test = np.array([
    [164.338]
])

y_predict = model.predict(x_test)

print(y_predict[0]) #169.66660924268297

    Father
0  165.100
1  165.100
2  167.132
3  155.194
4  160.020
0.2519977905846619
170.46931035654347

트레이닝 자료값의 오차가 작아야 이 w,b값을 사용할 수 있음.

훈련자료의 오차 확인하기(MSE)

y_train - (x_train*model.coef_+model.intercept_)

각각의 항목을 1번의 제곱근으로 작업하고, 더한 뒤 평균을 냄

# print(model.score(x_test,y_test)) # 회귀 공식에서만 사용되는 R2제곱 공식, 1에 가까울수록 좋음

# 위의 자료가 잘 나왔다면 테스트자료에 사용
model.predict(x_test)

# 기존의 y값과 비교하여 결과값이 좋다면 y값이 존재하지 않는 자료에 넣음(최종목적)

array([170.46931036])

로지스틱 회기 모델

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

##########데이터 로드

# [x1,x2] 데이터
x_data = np.array([
    [2, 1],
    [3, 2],
    [3, 4],
    [5, 5],
    [7, 5],
    [2, 5],
    [8, 9],
    [9, 10],
    [6, 12],
    [9, 2],
    [6, 10],
    [2, 4]
])
y_data = np.array([0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0])

labels = ['fail', 'pass'] # 0 = fail, 1= pass로 사용자규정해 둠

model2 = LinearRegression()
model2.fit(x_data,y_data)
model2.coef_,model2.intercept_

# 선형회귀로 했다면 [2,1]의 예측 값 공식 == predict 함수
2*model2.coef_[0]+1*model2.coef_[1]+model2.intercept_, model2.predict(x_data)[0]

(-0.043413257582836484, -0.043413257582836484)

# 편항성 확인은 직접 코드를 짜야함
def check_bias(y_data):
    import numpy as np
    import matplotlib.pyplot as plt
    uniquedData = np.unique(y_data, return_counts=True) #편향성 확인 Ture | y값이 얼마나 한쪽에 치우쳐져 있는지 확인
    print(f"""
        데이터 단일값 : {uniquedData[0]}
        데이터 단일값 개수 : {uniquedData[1]}
        """
        )
    for idx in range(len(uniquedData[0])):
        print(uniquedData[0][idx],'==>',uniquedData[1][idx]/np.sum(uniquedData[1]))
    plt.bar(uniquedData[0],uniquedData[1])
    plt.show()
    
check_bias(y_data)

        데이터 단일값 : [0 1]
        데이터 단일값 개수 : [5 7]
        
0 ==> 0.4166666666666667
1 ==> 0.5833333333333334

훈련 데이터, 테스트 데이터 나누기(train_test_split함수 사용)

훈련자료에는 모든 클래스가 있어야 하며, 편향 없이 데이터를 잘 나누어 주어야 함.

##########데이터 분석

##########데이터 전처리

x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.3, random_state=777)
# random_state : 한번 나누어진 train, test를 유지하는데, 이는 다른 값 때문에 잘 나온 것인지 데이터를 잘 만나서 잘 나온 것인지 확인하기 위함
# stratify : 지정한 클래스(카테고리) 별 분포를 비율에 따라 맞춰줌 | 권장

check_bias(y_train), check_bias(y_test)

        데이터 단일값 : [0 1]
        데이터 단일값 개수 : [3 5]
        
0 ==> 0.375
1 ==> 0.625

        데이터 단일값 : [0 1]
        데이터 단일값 개수 : [2 2]
        
0 ==> 0.5
1 ==> 0.5

(None, None)

x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.3, random_state=777, stratify=y_data)

check_bias(y_train), check_bias(y_train)

        데이터 단일값 : [0 1]
        데이터 단일값 개수 : [3 5]
        
0 ==> 0.375
1 ==> 0.625

        데이터 단일값 : [0 1]
        데이터 단일값 개수 : [3 5]
        
0 ==> 0.375
1 ==> 0.625

(None, None)

데이터의 개수가 적어서 random_state의 값과 stratify의 값을 주어도 차이를 볼 수 없음

##########모델 생성

model = LogisticRegression(penalty='none')

##########모델 학습

model.fit(x_train, y_train)

y_predict = model.predict(x_train)

# 내가 직접 만든 score값
result = y_predict == y_train
print(result)

[ True  True  True  True  True  True  True  True]

c:\devtools\Miniconda3\envs\meta\Lib\site-packages\sklearn\linear_model\_logistic.py:1173: FutureWarning: `penalty='none'`has been deprecated in 1.2 and will be removed in 1.4. To keep the past behaviour, set `penalty=None`.
  warnings.warn(

import pandas as pd
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import make_column_transformer
from sklearn.linear_model import Lasso
import numpy as np

##########데이터 로드

train_df = pd.read_excel('https://github.com/cranberryai/todak_todak_python/blob/master/machine_learning/regression/carprice_E1SUl6b.xlsx?raw=true', sheet_name='train')
test_df = pd.read_excel('https://github.com/cranberryai/todak_todak_python/blob/master/machine_learning/regression/carprice_E1SUl6b.xlsx?raw=true', sheet_name='test')

##########데이터 분석

##########데이터 전처리

x_train = train_df.drop(['가격'], axis=1)
x_test = test_df.drop(['가격'], axis=1)
y_train = train_df['가격']
y_test = test_df['가격']

print(x_train.head())

     년식   종류    연비   마력    토크   연료  하이브리드   배기량    중량 변속기
0  2015  준중형  11.8  172  21.0  가솔린      0  1999  1300  자동
1  2015  준중형  12.3  204  27.0  가솔린      0  1591  1300  자동
2  2015   소형  15.0  100  13.6  가솔린      0  1368  1035  수동
3  2014   소형  14.0  140  17.0  가솔린      0  1591  1090  자동
4  2015   대형   9.6  175  46.0   디젤      0  2497  1990  자동

문자 데이터는 사용할 수 없음

만약 문자 데이터를 x데이터로 사용하려면 더미데이터화 해야함

fit은 train 데이터에만 사용하는데, train데이터에는 모든 클래스를 포함하지만, test에는 그렇지 않다.

그러므로 train데이터에서 one-hot 인코딩으로 종류를 대형 소형 준준형 준형으로 나누었는데

test 데이터에서는 대형 데이터가 들어오지 않아서 one-hot 인코딩이 바뀔수 있는 이슈가 있다.

데이터 전처리

레이블 인코딩(백터화)

문자로 된 y값을 숫자로 변형해야 할 때 주로 사용.

x데이터는 one-hot 인코딩까지 해주어야 함.

train과 test로 나누기 전에 처음부터 숫자로 변경한 뒤, 나누는 것을 권장.

이미 나뉘어져 있는 자료라면 train에만 fit을 적용해야 함.

피팅에는 min max 스케일링을 위한 min max도 설정되는데 위의 표를보면

test 데이터의 min 값이 2이지만 test데이터에는 피팅을 하지 않으므로 min 값이 1로 계산된다.

items = ('tv,냉장고,전자레인지,컴퓨터,선풍기,선풍기,믹서,믹서').split(',')
items

['tv', '냉장고', '전자레인지', '컴퓨터', '선풍기', '선풍기', '믹서', '믹서']

from sklearn.preprocessing import LabelEncoder

encoder = LabelEncoder()
encoder.fit(items) # items의 중복을 제거하고 순서번호를 갖게함 | 절대 test 데이터에는 fit해선 안됌

print(encoder.classes_) # fitting하면 중복을 제거한 클래스들이 생성된다.

encoder.transform(items) # fit해서 나온 결과물을 items에 적용

['tv' '냉장고' '믹서' '선풍기' '전자레인지' '컴퓨터']

array([0, 1, 4, 5, 3, 3, 2, 2])

encoder.fit_transform(items) # fit과 transform을 동시에 하는 함수

array([0, 1, 4, 5, 3, 3, 2, 2], dtype=int64)

one-hot encoding

x값에서 주로 사용 0,1(no,yes) 외에 3개 이상의 카테고리 변수는 원핫인코딩을 권장

인곤지능에서는 y값도 이항 또는 다항분류에 소프트맥스 함수를 적용할 때는 반드시 원핫인코딩을 적용해야함.

더미변수화와 다른 점은 더미 전처리는 필드 별로 0,0,1,0,0 식으로 변환하고

원핫인코딩은 array로 [0,0,1,0,0] 식으로 변환한다.

판다스의 get_dummies()와 기능이 같다.

from sklearn.preprocessing import OneHotEncoder

items = np.array(items).reshape(-1,1) # 원핫인코딩 피팅은 반드시 2차원 배열을 요구한다.

oh_encoder=OneHotEncoder()
oh_encoder.fit(items)
oh_encoder.categories_

[array(['tv', '냉장고', '믹서', '선풍기', '전자레인지', '컴퓨터'], dtype='<U5')]

oh_lables = oh_encoder.transform(items)

oh_lables

<8x6 sparse matrix of type '<class 'numpy.float64'>'
	with 8 stored elements in Compressed Sparse Row format>

sparse matrix : 0값이 많은 행렬(희소행렬)

1. 텍스트 분석을 할 때는 희소행렬을 0값이 있는 자료를 제외하고 값이 있는 값만으로 다시 자료를 구성함.

2. 공간적인 낭비: 텍스트 데이터는 대부분이 희소한 형태를 가지며, 많은 단어가 0 또는 매우 작은 빈도로 발생합니다. 이로 인해 많은 0 값을 저장하는 것은 메모리 공간의 낭비가 될 수 있습니다.

3. 계산 비효율성: 희소 행렬은 대부분이 0 값을 가지기 때문에, 0을 고려하지 않고 행렬 연산을 수행하는 것은 비효율적입니다. 많은 연산을 수행해야 하므로 연산 시간이 길어질 수 있습니다.

4. 모델의 성능 저하: 일부 머신러닝 알고리즘은 밀집된 행렬을 기대합니다. 희소 행렬을 사용할 경우 모델의 성능이 저하될 수 있습니다. 이는 모델이 0이 아닌 값들 사이의 패턴을 파악하지 못하거나, 희소한 데이터로 인해 정보의 손실이 발생할 수 있기 때문입니다.

따라서, 텍스트 분석에서는 sparse matrix의 문제를 해결하기 위해 희소 행렬을 효율적으로 표현하고 처리하기 위한 방법을 사용합니다. 이를 위해 희소 행렬을 압축하거나, 중요한 단어나 특성을 선택하거나, 단어의 빈도를 가중치로 변환하는 등의 전처리 기법을 적용하여 문제를 해결합니다.

arryData = oh_lables.toarray()
arryData

array([[1., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 0., 1.],
       [0., 0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0., 0.],
       [0., 0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0.]])

# 역 백터화 하기

classData=('냉장고, 믹서, 선풍기, 전자레인지, 컴퓨터, tv').split(',')
max_in_data=np.argmax(arryData, axis=1) # 행단위로 가장 큰 값 찾는 함수
print(max_in_data)

for idx in max_in_data:
    print(classData[idx])

[0 1 4 5 3 3 2 2]
냉장고
 믹서
 컴퓨터
 tv
 전자레인지
 전자레인지
 선풍기
 선풍기

스케일링

• 표준화스케일링 : standardScaler

• 정규화스케일링 : minmaxScaler

표준편차가 필요한 이유

평균은 같지만 B데이터에서는 이상치라 볼 수 있는 큰 값이 들어있다.

평균이 아닌 편차로 비교하면 이상치를 확인할 수 있다.

실습

import pandas as pd
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import make_column_transformer
from sklearn.linear_model import Lasso
import numpy as np

##########데이터 로드

train_df = pd.read_excel('https://github.com/cranberryai/todak_todak_python/blob/master/machine_learning/regression/carprice_E1SUl6b.xlsx?raw=true', sheet_name='train')
test_df = pd.read_excel('https://github.com/cranberryai/todak_todak_python/blob/master/machine_learning/regression/carprice_E1SUl6b.xlsx?raw=true', sheet_name='test')

# 컬럼 확인
display(train_df.head(2), test_df.head(2))

# train데이터 test 데이터 합치기
df = pd.concat([train_df,test_df])
display(df.info)

	가격	년식	종류	연비	마력	토크	연료	하이브리드	배기량	중량	변속기
0	1885	2015	준중형	11.8	172	21.0	가솔린	0	1999	1300	자동
1	2190	2015	준중형	12.3	204	27.0	가솔린	0	1591	1300	자동

	가격	년식	종류	연비	마력	토크	연료	하이브리드	배기량	중량	변속기
0	1915	2015	대형	6.8	159	23.0	LPG	0	2359	1935	수동
1	1164	2012	소형	13.3	108	13.9	가솔린	0	1396	1035	자동

<bound method DataFrame.info of       가격    년식   종류    연비   마력    토크   연료  하이브리드   배기량    중량 변속기
0   1885  2015  준중형  11.8  172  21.0  가솔린      0  1999  1300  자동
1   2190  2015  준중형  12.3  204  27.0  가솔린      0  1591  1300  자동
2   1135  2015   소형  15.0  100  13.6  가솔린      0  1368  1035  수동
3   1645  2014   소형  14.0  140  17.0  가솔린      0  1591  1090  자동
4   1960  2015   대형   9.6  175  46.0   디젤      0  2497  1990  자동
..   ...   ...  ...   ...  ...   ...  ...    ...   ...   ...  ..
26  6910  2015   대형   8.9  334  40.3  가솔린      0  3778  1915  자동
27  2545  2015   대형   8.7  175  46.0   디젤      0  2497  2383  수동
28  1960  2015   대형   9.6  175  46.0   디젤      0  2497  1990  자동
29   870  2010   소형  13.0   95  12.7  가솔린      0  1399  1046  자동
30  2879  2015   중형  14.8  200  43.0   디젤      0  2199  1760  수동

[102 rows x 11 columns]>

# 결측치 확인
df.isna().sum()

가격       0
년식       0
종류       0
연비       0
마력       0
토크       0
연료       0
하이브리드    0
배기량      0
중량       0
변속기      0
dtype: int64

# x,y 변수를 나누고 y값에 영향을 주는 x값을 알기 위해서는 EDA를 실행해야 함.(이번 실습에선 제외)
# 현대자동차 가격을 예측하는 회기분석

y_data = df['가격']
x_data = df.drop(['가격'],axis=1)
display(x_data.head(2),y_data.head(2))

	년식	종류	연비	마력	토크	연료	하이브리드	배기량	중량	변속기
0	2015	준중형	11.8	172	21.0	가솔린	0	1999	1300	자동
1	2015	준중형	12.3	204	27.0	가솔린	0	1591	1300	자동

0    1885
1    2190
Name: 가격, dtype: int64

# x데이터의 문자데이터가 어떤 자료가 있는지 확인
df.dtypes

가격         int64
년식         int64
종류        object
연비       float64
마력         int64
토크       float64
연료        object
하이브리드      int64
배기량        int64
중량         int64
변속기       object
dtype: object

# 더미변수화
x_dummy=pd.get_dummies(x_data)
display(x_dummy.head(2))

	년식	연비	마력	토크	하이브리드	배기량	중량	종류_대형	종류_소형	종류_준중형	종류_중형	연료_LPG	연료_가솔린	연료_디젤	변속기_수동	변속기_자동
0	2015	11.8	172	21.0	0	1999	1300	0	0	1	0	0	1	0	0	1
1	2015	12.3	204	27.0	0	1591	1300	0	0	1	0	0	1	0	0	1

# train, test 데이터 분리하기
x_train,x_test,y_train,y_test = train_test_split(x_dummy, y_data, test_size=0.3, random_state=777)

display(x_train.head(2),x_test.head(2),y_train.head(2),y_test.head(2))

	년식	연비	마력	토크	하이브리드	배기량	중량	종류_대형	종류_소형	종류_준중형	종류_중형	연료_LPG	연료_가솔린	연료_디젤	변속기_수동	변속기_자동
9	2015	14.0	100	13.6	0	1368	1103	0	1	0	0	0	1	0	0	1
8	2015	10.8	245	36.0	0	1998	1570	0	0	0	1	0	1	0	0	1

	년식	연비	마력	토크	하이브리드	배기량	중량	종류_대형	종류_소형	종류_준중형	종류_중형	연료_LPG	연료_가솔린	연료_디젤	변속기_수동	변속기_자동
26	2015	11.3	200	44.5	0	2199	1905	0	0	0	1	0	0	1	0	1
61	2015	16.0	159	21.0	1	2359	1680	1	0	0	0	0	1	0	0	1

9    1492
8    2695
Name: 가격, dtype: int64

26    3585
61    3450
Name: 가격, dtype: int64

# train 데이터 스케일링
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()

# fit은 스케일러에 따른 필요 값을 추출하는 과정
x_train = scaler.fit_transform(x_train)

print(x_train)

[[1.         0.65811966 0.01557632 ... 0.         0.         1.        ]
 [1.         0.38461538 0.46728972 ... 0.         0.         1.        ]
 [1.         0.24786325 0.58255452 ... 0.         0.         1.        ]
 ...
 [0.4        0.65811966 0.05919003 ... 0.         0.         1.        ]
 [1.         0.37606838 0.49844237 ... 1.         0.         1.        ]
 [1.         0.23076923 0.68535826 ... 0.         0.         1.        ]]

# test 데이터는 스케일링만 진행
x_test = scaler.transform(x_test)

# 회귀분석
# 사용자가 3개 이상의 모델을 돌려서 가장 성능이 좋은 모델을 선택하게 됌
lr = LinearRegression()

lr.fit(x_train, y_train) # w,b값을 최소제곱법에 의해서 결정하는 수식 적용 | 독립변수(x)의 개수는 16개

print(f'w값: {lr.coef_}, \nb값:{lr.intercept_}')

w값: [-115.19522289 1834.16515529 3329.73161962 -393.39526525  172.77975355
 5800.12995696  849.52051433 -348.92760046  389.72289904   -7.0410203
  -33.75427828  225.7595262   -73.84216155 -151.91736465  -84.30076098
   84.30076098], 
b값:-568.2001711344778

분산팽창지수

x변수끼리는 독립적이어야 하는데, 이러한 독립성을 확인하는 방법으로 분산팽창지수(VIF)가 있다.

VIF가 10 이상이면 서로 종속적(다중공선성)이라고 볼 수 있다.

서로 연관성이 높은 변수가 있다면 하나는 제거해야 한다.

평가지표

# 회기자료 에러율 및 성공률 확인
# r2 score = 성공률, 설명력

from sklearn.metrics import mean_squared_error, r2_score

# train 데이터는 볼 필요가 없다. w,b값을 구하여 정해져있기 때문에
y_preds = lr.predict(x_test) # 테스트 데이터 예측값
mse = mean_squared_error(y_test, y_preds) # 예측값과 테스트 데이터의 y값을 확인하자
rmse = np.sqrt(mse)

print('MSE : {0: .3f}, RSME : {1: 3F}'.format(mse,rmse))
print('variance score : {0: .3f}'.format(r2_score(y_test, y_preds)))

MSE :  236569769906254.031, RSME :  15380824.747271
variance score : -39033813.275

c:\devtools\Miniconda3\envs\meta\Lib\site-packages\sklearn\base.py:432: UserWarning: X has feature names, but LinearRegression was fitted without feature names
  warnings.warn(

성공률이 매우 낮음

1. 변수영향력을 확인함. w 값(coef)_에서 값이 클수록 영향령이 많은 변수

coef = pd.Series(data=np.round(lr.coef_,1),index=x_dummy.columns)
coef.sort_values(ascending=False)

배기량       5800.1
마력        3329.7
연비        1834.2
중량         849.5
종류_소형      389.7
연료_LPG     225.8
하이브리드      172.8
변속기_자동      84.3
종류_준중형      -7.0
종류_중형      -33.8
연료_가솔린     -73.8
변속기_수동     -84.3
년식        -115.2
연료_디젤     -151.9
종류_대형     -348.9
토크        -393.4
dtype: float64

배기량 마력 연비가 가격(y)값에 가장 많은 영향을 줌

그러나 데이터개수가 적어서 신빙성은 없음