본 포스트는 패스트캠퍼스 파이썬 기초부터 시작하는 딥러닝 영상인식 바이블 강의를 정리한 글입니다.

올해 상반기가 지나가기 전 딥러닝 공부를 깊게 해보고 싶었다. CNN, RNN, LSTM 등의 이론은 학부생활을 하면서 꽤나 익혔는데, 딥러닝 프레임워크를 사용하여 모델링하는 것은 해보지 않았기에, 프레임워크 중 한 가지 정도는 능숙하게 사용하는 것을 목표로 삼게 되었다. 강의를 따라 keras를 사용할 예정인데, 

keras 문서 를 들어가 사용법을 볼 수 있고, 기본적인 모델링은 문서를 통해 배울 수 있을 것 같다. 

1. 필요 라이브러리 import 

# TensorFlow and tf.keras
import tensorflow as tf 
from tensorflow import keras 
#  Helper libraries 
import numpy as np 
import matplotlib.pyplot as plt 
import math

print(tf.__version__) # tensorflow 버전 확인

tensorflow, keras를 import 해준다.  필자는 google colab 에서 실습을 진행하였고, 글을 쓰는 시점을 기준으로 tf 버전 2.8.0 을 사용한다. 이 밖에 필요한 numpy, matplotlib, math를 import 해 준다. 

2. batch size, epochs, num_classes 정의

# Define Constants 
batch_size = 128 
epochs = 100 
num_classes = 10

batch_size: 데이터를 몇개씩 묶어서 학습할 것인가? -> 128개씩 묶어서 학습하겠다

ephocs: 학습을 반복하는 횟수 -> 100번 학습하겠다

num_classes: 클래스의 개수 -> MNIST는 0~9까지 10개이므로 10

• 60000장의 데이터를 한번에 학습하지 않고 batch size를 설정하는 이유

배치를 나눠서 학습하게되면 모든 데이터가 스트레이트로 쭉 학습되는 것이 아니라, batch size만큼 학습되면서 예측 값이 맞거나 틀린 경우가 각 배치마다 업데이트 되기 때문에 중간중간 가중치가 조절될 수 있으므로 더 좋은 성능을 기대해볼 수 있다.

(실제로 실험해보았더니 batch size를 60000장으로 했을 때 정확도가 0.02정도 낮게 나왔다. (MNIST 데이터 기준) 그리고 batch size가 작아질 수록 학습 속도가 느려진다. 아직 배치사이즈를 조정할 레벨은 아니지만, 배치사이즈에 따라 성능이 달라지는 것을 직접 확인하니 적절한 배치사이즈를 설정해주는 것도 중요한 부분인 것 같아보인다. )

3. MNIST 데이터셋 불러오기

# Download MNIST dataset 
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

워낙 유명한 MNIST 데이터셋은 keras에서 제공해주므로 따로 다운받을 필요 없이 위와 같은 코드를 작성하여 사용할 수 있다.  

len(train_images), len(test_images)

 (60000, 10000) 

train은 60000장, test는 10000장임을 알 수 있다. 

4. 딥러닝 모델 학습

(1) normailze (0.0 ~ 1.0 사이의 값이 되도록) 

# Normalize the input image so that each pixel value is between 0 to 1 
train_images = train_images / 255.0 
test_images = test_images / 255.0

데이터를 float형으로 만들면서 0.0~1.0 사이로 정규화해준다. 

(2) 딥러닝 모델 정의

# Define the model architecture 
model = keras.Sequential([
                          keras.layers.Flatten(input_shape=(28, 28)),
                          keras.layers.Dense(128, activation=tf.nn.relu),
                          keras.layers.Dense(num_classes, activation='softmax')
])
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

모델은 keras.Sequential에 층을 하나하나 추가해주는 방식이다. 직관적으로 모델링을 할 수 있다는 장점이 있다. flatten으로 한 장당 2차원 배열 28x28인 이미지를 1차원으로 만들어 준다. 그다음 Dense layer를 사용하고, activation 함수는 relu를 사용한다. 마지막 층에는 클래스의 개수와 softmax 함수를 사용함으로써 예측 결과를 클래스 별 확률로 나오게끔 만들어준다. 

model.complie로 optimizer와 loss함수, metrics (평가지표)를 설정해 준다. 

이제 모델 학습할 모든 준비가 되었다. 

(3) 딥러닝 모델 학습

history = model.fit(train_images, train_labels, epochs=epochs, batch_size=batch_size)

train 데이터셋과 앞서 지정했던 ephocs, batch_size를 설정해 준다. 

5. 딥러닝 모델 평가

(1) loss, accuracy 확인

test_loss, test_acc = model.evaluate(test_images, test_labels)
print("Test Loss: ", test_loss)
print("Test Accuracy: ", test_acc)

 Test Loss: 0.12909765541553497 

 Test Accuracy: 0.98089998960495 

아주 기본적인 딥러닝 모델을 사용하였음에도 불구하고 0.98이라는 높은 정확도가 나왔다. 모든 학습 결과가 이랬으면 좋겠다. 

(2) 필요 함수 정의 

# 1. 원하는 개수만큼 이미지를 보여주는 함수 
def show_sample(images, labels, sample_count=25):
  # Create a square with can fit {sample_count} images
  grid_count = math.ceil(math.ceil(math.sqrt(sample_count)))
  grid_count = min(grid_count, len(images), len(labels))

  plt.figure(figsize=(2*grid_count, 2*grid_count))
  for i in range(sample_count):
    plt.subplot(grid_count, grid_count, i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(images[i], cmap=plt.cm.gray)
    plt.xlabel(labels[i])
  plt.show()

###################################################################
# 2. 특정 숫자의 이미지를 보여주는 함수 
# Helper function to display specific digit images 
def show_sample_digit(images, labels, digit, sample_count=25):
  # Create a square with can fit {sample_count} images
  grid_count = math.ceil(math.ceil(math.sqrt(sample_count)))
  grid_count = min(grid_count, len(images), len(labels))

  plt.figure(figsize=(2*grid_count, 2*grid_count))
  i = 0 
  digit_count = 0 
  while digit_count < sample_count:
    i += 1 
    if digit == labels[i]: 
      plt.subplot(grid_count, grid_count, digit_count+1)
      plt.xticks([])
      plt.yticks([])
      plt.grid(False)
      plt.imshow(images[i], cmap=plt.cm.gray)
      plt.xlabel(labels[i])
      digit_count += 1 
  plt.show()


###################################################################
# 3.이미지 한개를 크게 보여주는 함수 
def show_digit_image(image):
  # Draw digit image 
  fig = plt.figure()
  ax = fig.add_subplot(1, 1, 1)
  # Major ticks every 20, minor ticks every 5 
  major_ticks = np.arange(0, 29, 5)
  minor_ticks = np.arange(0, 29, 1)
  ax.set_xticks(major_ticks)
  ax.set_xticks(minor_ticks, minor=True)
  ax.set_yticks(major_ticks)
  ax.set_yticks(minor_ticks, minor=True)
  # And a corresponding grid 
  ax.grid(which='both')
  # Or if you want different settings for the grids:
  ax.grid(which='minor', alpha=0.2)
  ax.grid(which='major', alpha=0.5)
  ax.imshow(image, cmap=plt.cm.binary)

  plt.show()

28x28 배열의 이미지를 시각화로 확인해볼 수 있도록 해주는 함수이다. 

위 함수를 사용하여 잠깐 이미지를 확인해 보자. 

• show_sample 함수 사용 (원하는 개수만큼 사진 출력)

show_sample(train_images, ['Label: %s' % label for label in train_labels])

이렇게 원하는 개수 만큼 이미지를 확인해볼 수 있다. 

• show_sample_digit 함수 사용 (특정 숫자에 대한 원하는 개수만큼의 사진 출력)

show_sample_digit(train_images, train_labels, 7)

특정 숫자를 원하는 개수만큼 확인해볼 수 있다. 

(3) train 데이터셋 학습 시 ephoch에 따른 loss와 accuracy 값 시각화

# Evaluate the model using test dataset. - Show performance 
fig, loss_ax = plt.subplots()
fig, acc_ax = plt.subplots()

loss_ax.plot(history.history['loss'], 'ro')
loss_ax.set_xlabel('ephoc')
loss_ax.set_ylabel('loss')

acc_ax.plot(history.history['accuracy'], 'bo')
acc_ax.set_xlabel('ephoc')
acc_ax.set_ylabel('accuracy')

(4) test data의 예측 값과 정답 값 비교해보기

• 실제값: 그림
• 예측값: x label

# Predict the labels of digit images in our test datasets.
predictions = model.predict(test_images)

# Then plot the first 25 test images and their predicted labels.
show_sample(test_images, ['predicted: %s' % np.argmax(result) for result in predictions])

(5) show_digit_image 함수 사용

• 특정 인덱스의 사진과 그때의 예측값을 비교해 봄

Digit = 2005 #@param {type:'slider', min:1, max:10000, step:1}
selected_digit = Digit - 1 

result = predictions[selected_digit]
result_number = np.argmax(result)
print('Number is %2d' % result_number)

show_digit_image(test_images[selected_digit])

#@param을 사용하면 위와 같이 슬라이더가 생긴다. 랜덤으로 슬라이드를 해서 인덱스 값을 지정해 주면,

Number is 7

이와 같이 Number is 7 은 예측 값, 이미지는 test 이미지 (정답 값)으로 두개를 비교 확인해볼 수 있다. 

이번 포스트에서 사용한 MNIST데이터셋은 아주 간단한 딥러닝 모델인데도 성능이 좋았다. 

다음 포스팅에서는 이미지 모델학습에 최적화 되어있는 CNN 모델링을 함으로써 MNIST의 성능을 더욱 높여보는 공부를 해 볼 것이다. 

사용 데이터셋 

https://www.data.go.kr/dataset/3035522/fileData.do

현재 이 데이터셋은 폐기 되었다고 나온다. 

위 공공데이터를 사용하여 인프런강의 (공공데이터로 파이썬 데이터 분석) (https://bit.ly/3sISk6Z) 의 방법으로 전처리한 데이터로 시각화 정리 진행한다. 

cf1) figure, axes 생성

fig=plt.figure(figsize=(10,3), dpi=100)
ax1=fig.subplots()

cf2) 모든 x tick 표현하기 

_=plt.xticks(ticks=np.arange(len(df)), labels=df.index)

cf3) x축 소수점 제거

from matplotlib.ticker import MaxNLocator
ax1.xaxis.set_major_locator(MaxNLocator(integer=True))

(cf4) 그래프의 밖에 Legend 표시하도록 설정

plt.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)

 lineplot 

1. pandas plot

(1) pandas plot의 기본 plot - lineplot 

- df의 index 또는 column 값을 기준으로 그려짐 

df.plot(figsize=(10,3))

cf) 모든 x tick 표현하기 

_=plt.xticks(ticks=np.arange(len(g)), labels=g.index)

- df 의 column이 여러 개 존재할 때  (df의 column이 seaborn의 hue역할)

2. seaborn plot 

sns.lineplot(data=df, x="연도", y="평당분양가격", hue="지역명", ci=None, ax=ax1)
ax1.legend(bbox_to_anchor=(1.02, 1), loc=2)

 pointplot 

sns.pointplot(data=df, x="연도", y="평당분양가격", hue="지역명", ci=None, ax=ax2)
ax2.legend(bbox_to_anchor=(1.02, 1), loc=2)

 barplot 

1. pandas plot 

(1) df.plot(kind='bar')

- df의 index 또는 columm 값을 기준으로 그려짐

df.plot.bar(rot=0, figsize=(10, 3))
# or
df.plot(kind='bar',rot=0, ax=ax1)

(2) df.plot.bar()

df.plot.bar(color='g',rot=0, figsize=(10,3)) # cmap='Pastel1' 또한 가능

- column 여러개일 때 ( df의 column이 seaborn의 hue와 같은 역할)

ax=df2.plot.bar(figsize=(10,3), rot=0)
ax.set_ylabel('평당분양가격')

2. seaborn plot 

sns.barplot(data=df, x="지역명", y="평당분양가격")
# estimator default: mean
# color changable
# palette (https://seaborn.pydata.org/tutorial/color_palettes.html)
# ci: bootstrap resampling (with replacement), sorted means

palette 색 모음 링크

- hue 지정 

sns.barplot(data=df, x="지역명", y="평당분양가격", hue='연도', ci=None)

 histplot 

1. pandas plot

(1) df.plot(kind='hist') or df.plot.hist()

df.plot(kind='hist', figsize=(10, 3), title='평당분양가격')
# or
ax=df.plot(kind='hist', figsize=(10, 3))
ax.set_title('평당분양가격')

df["평당분양가격"].plot.hist(bins=50)

(2) df.hist(bins=)

df["평당분양가격"].hist(bins=50)

axs=df.hist(bins=50, figsize=(10,10))
ax1,ax2,ax3,ax4=axs.flatten()
ax2.set_title('ax별 제목 지정 가능')

2. seaborn plot 

sns.histplot(df["평당분양가격"], kde=True)

 kdeplot 

1. seaborn plot 

sns.kdeplot(data=df['평당분양가격'])

sns.kdeplot(data=df[['평당분양가격','분양가격']])

 boxplot 

1. pandas plot

(1) df.plot(kind='box')

df.plot(kind='box', figsize=(5, 5))

(2) df.plot.box()

- df 의 column이 x축 

df.plot.box(fontsize=15)

- 이중 column일 경우 

df.plot.box(figsize=(15, 3), rot=30)

(3) df.boxplot(column='', by='')

- by: x축 

df.boxplot(column='평당분양가격',by='연도', figsize=(5,3), rot=30)

- by가 리스트일 때 

df.boxplot(column='평당분양가격',by=['연도','전용면적'], figsize=(20,3), rot=30)

2. seaborn plot 

sns.boxplot(data=df, x="연도", y="평당분양가격")

- hue 지정

plt.figure(figsize=(12, 3))
sns.boxplot(data=df_last, x="연도", y="평당분양가격", hue="전용면적")

 violinplot 

1. seaborn plot 

sns.violinplot(data=df, x="연도", y="평당분양가격")

- hue 지정

plt.figure(figsize=(12, 3))
sns.violinplot(data=df, x="연도", y="평당분양가격", hue="전용면적")

 heatmap 

1. seaborn plot 

plt.figure(figsize=(15, 7), dpi=100)
ax=sns.heatmap(df, cmap="Blues", annot=True, fmt=".0f")

2. matplotlib pcolor  

fig=plt.figure(figsize=(15,5), dpi=100)
ax=fig.subplots()

t2=t.iloc[::-1]
t2
hm1=ax.pcolor(t2, cmap="Blues")
_=fig.colorbar(hm1, ax=ax)

col_len=len(t2.columns)
row_len=len(t2.index)
for r in range(row_len):
    for c in range(col_len):
        _=ax.text(c+0.5, r+0.5, int(t2.iloc[r, c]),ha="center", va="center", color="k", fontsize=11)

_=ax.set_xticks(np.arange(col_len)+0.5)
_=ax.set_xticklabels(t2.columns)

_=ax.set_yticks(np.arange(row_len)+0.5)
_=ax.set_yticklabels(t2.index)

이것이 코딩테스트다 with 파이썬 개념 정리 

구현

• 머릿속에 있는 알고리즘을 소스코드로 바꾸는 과정 
• 풀이를 떠올리는 것은 쉽지만 소스코드로 옮기기 어려운 문제를 의미 

구현하기 어려운 문제 

1. 알고리즘은 간단한데 코드가 지나칠 만큼 길어지는 문제 
2. 특정 소수점 자리까지 출력해야 하는 문제 
3. 문자열이 입력으로 주어졌을 때 한 문자 단위로 끊어서 리스트에 넣어야하는 (파싱을 해야하는) 문제 
4. 사소한 조건 설정이 많은 문제

완전탐색 

• 모든 경우의 수를 주저 없이 다 계산하는 해결 방법 

시뮬레이션 

• 문제에서 제시한 알고리즘을 한 단계씩 차례대로 직접 수행 

구현 문제 접근

- 사소한 입력 조건 등을 문제에서 명시해주며 문제의 길이가 꽤 긴 편임 

cf) 메모리 ,시간 제한 고려 사항 

파이썬에서 리스트 크기 

• 파이썬은 1초에 2000만 번의 연산을 수행한다고 가정하고 문제를 풀면 시간제한에 안정적임
• (ex) 시간제한이 1초, 데이터 개수가 100만개 -> 시간복잡도 O(NlogN) 이내의 알고리즘을 이용하여 풀어야 함  (N=1,000,000일 때 NlogN은 20,000,000 이기 때문) 
• 시간 제한과 데이터 개수를 확인하고 어느 정도의 시간 복잡도의 알고리즘으로 작성해야 풀 수 있을 것인지 예측할 수 있어야 함. 

<예제 출처> 

https://wikidocs.net/22803

사용법이 익숙치 않아 항상 찾아보는 map, filter함수를 확실히 정리해 놓는다. 

map(적용시킬 함수, 적용할 요소들) 

: 반복가능한 iterable 객체를 받아서 각 요소에 함수를 적용해주는 함수 

#1. for문 사용

def add_1(n): 
    return n + 1

target = [1, 2, 3, 4, 5]
result = []

for value in target: 
    result.append(add_1(value))
    
print(result)

[2, 3, 4, 5, 6]

#2. map함수 사용

# map 함수 사용 
def add_1(n): 
    return n + 1

target = [1, 2, 3, 4, 5]

result = map(add_1, target)

print(result)  # 출력결과: iterator -> next함수를 이용하여 확인 가능 
print(list(result))  # list 타입으로 형변환 하여 확인 가능

<map object at 0x000001B7457EF3C8>

[2, 3, 4, 5, 6]

#3. map함수 + lambda 사용

# map + lambda: add_1 과 같은 함수가 재사용 목적이 없다면 lambda 함수 사용
target = [1, 2, 3, 4, 5]

result = map(lambda x: x + 1, target)

print(list(result))

[2, 3, 4, 5, 6]

# 추가 예제: 모든 요소들을 str 타입으로 변경 
target = [1, 2, 3, 4, 5]
list(map(str, target))

['1', '2', '3', '4', '5']

filter(적용시킬 함수, 적용할 요소들) 

: 특정 조건으로 걸러서 걸러진 요소들로 iterator 객체를 만들어서 리턴 

#1. for문 사용

target = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = []

def is_even(n):
    return True if n % 2 == 0 else False 

for value in target: 
    if is_even(value): 
        result.append(value)
        
print(result)

#2. filter 함수 사용

[2, 4, 6, 8, 10]

# filter 함수 사용 
target = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def is_even(n): 
    return True if n % 2 == 0 else False

result = filter(is_even, target)

print(list(result))

[2, 4, 6, 8, 10]

#3. filter 함수 + lambda 사용

# filter + lambda
target = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = filter(lambda x: x%2==0, target)

print(list(result))

[2, 4, 6, 8, 10]

응용: Map + Filter 예제

## target리스트의 모든 요소들에 1을 더하고 홀수만 return
target = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list(filter(lambda x: x%2!=0, map(lambda x: x+1, target)))

[3, 5, 7, 9, 11]

러닝스푼즈 수업 정리 

<이전 글>

https://silvercoding.tistory.com/71

1. 데이터 소개 & 데이터 불러오기 

[ Home Credit Data ]

원본 데이터: 캐글 

학습용 데이터: 러닝스푼즈 제공 

• 고객의 대출 상환능력 예측: 고객의 인적 정보, 거래 데이터를 바탕으로 해당 고객에게 돈을 빌려주었을 때 이를 상환할지 여부를 예측

train.csv - 학습 데이터
test.csv - 예측해야 할 test 데이터
loan_before.csv - 각 사람이 이전에 진행했던 대출에 대한 상세 정보

import pandas as pd
import os

os.chdir('../data')

lb = pd.read_csv("loan_before.csv")
train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")

train.head()

lb.head()

- loan before 컬럼 정보 

- train, test 컬럼 정보 

1. 문제 정의 

질문 1 - 어떤 요소가 대출금 상환 여부에 큰 영향을 주는가? 

질문 2 - 그 요소들이 상환여부에 어떤 영향을 주는가? 

2. 방법론 

- 분석 과정 

질문에 대한 해답을 얻기 위해 해석가능한 머신러닝 (xAI) 활용 

(1) Feature Engineering

- AMT_CREDIT_TO_ANNUITY_RATIO 변수 생성: 해당 사람이 몇개월에 걸쳐 돈을 갚아야 하는지 

train['AMT_CREDIT_TO_ANNUITY_RATIO'] = train['AMT_CREDIT']/train['AMT_ANNUITY']
test['AMT_CREDIT_TO_ANNUITY_RATIO'] = test['AMT_CREDIT']/test['AMT_ANNUITY']

- lb데이터: groupby 후 평균 

• AMT_CREDIT_SUM (이전 대출의 금액) 
• DAYS_CREDIT (train, test의 대출로부터 며칠 전에 이전 대출을 진행했는지) 
• CNT_CREDIT_PROLONG (대출연장을 몇 번 했는지) 

train = pd.merge( train,lb.groupby(['SK_ID_CURR'])['AMT_CREDIT_SUM'].mean().reset_index(),on='SK_ID_CURR',how='left' )
test = pd.merge( test,lb.groupby(['SK_ID_CURR'])['AMT_CREDIT_SUM'].mean().reset_index(),on='SK_ID_CURR',how='left' )

train = pd.merge( train,lb.groupby(['SK_ID_CURR'])['DAYS_CREDIT'].mean().reset_index(),on='SK_ID_CURR',how='left' )
test = pd.merge( test,lb.groupby(['SK_ID_CURR'])['DAYS_CREDIT'].mean().reset_index(),on='SK_ID_CURR',how='left' )

train = pd.merge( train,lb.groupby(['SK_ID_CURR'])['CNT_CREDIT_PROLONG'].mean().reset_index(),on='SK_ID_CURR',how='left' )
test = pd.merge( test,lb.groupby(['SK_ID_CURR'])['CNT_CREDIT_PROLONG'].mean().reset_index(),on='SK_ID_CURR',how='left' )

- lb 데이터: groupby 후 갯수 

• count 컬럼 생성: 해당 사람이 이전에 대출을 몇 번 진행했는지

train = pd.merge(train , lb.groupby(['SK_ID_CURR']).size().reset_index().rename(columns={0:'count'}),on='SK_ID_CURR', how='left')
test = pd.merge(test , lb.groupby(['SK_ID_CURR']).size().reset_index().rename(columns={0:'count'}),on='SK_ID_CURR', how='left')

- 변수 제거 

해당 프로젝트의 목적은 모델 해석이기 때문에, 이에 방해를 주는 변수는 모두 제거

제거 변수목록

• CODE_GENDER : 범주형 변수
• FLAG_OWN_CAR : 범주형 변수
• NAME_TYPE_SUITE : 범주형 변수
• NAME_INCOME_TYPE : 범주형 변수
• NAME_EDUCATION_TYPE : 범주형 변수
• NAME_HOUSING_TYPE : 범주형 변수
• ORGANIZATION_TYPE : 범주형 변수
• EXT_SOURCE_1 : 변수의 의미를 정확히 모름
• EXT_SOURCE_2 : 변수의 의미를 정확히 모름
• EXT_SOURCE_3 : 변수의 의미를 정확히 모름

del_list = ['CODE_GENDER','FLAG_OWN_CAR','NAME_TYPE_SUITE','NAME_INCOME_TYPE','NAME_EDUCATION_TYPE','NAME_HOUSING_TYPE','ORGANIZATION_TYPE',
'EXT_SOURCE_1','EXT_SOURCE_2','EXT_SOURCE_3']

train = train.drop(del_list,axis=1)
test = test.drop(del_list,axis=1)

train.columns

(2) 모델링 

- 상관관계가 높은 input변수는 삭제한다. 

: Input 변수가 높은 상관성을 띌 때 shap value는 제대로 된 설명력을 발휘하지 못함. 

input_var = ['FLAG_OWN_REALTY', 'CNT_CHILDREN',
       'AMT_INCOME_TOTAL', 'AMT_CREDIT', 'AMT_ANNUITY',
       'REGION_POPULATION_RELATIVE', 'DAYS_BIRTH', 'DAYS_EMPLOYED',
       'DAYS_ID_PUBLISH', 'OWN_CAR_AGE', 'CNT_FAM_MEMBERS',
       'HOUR_APPR_PROCESS_START', 'DAYS_LAST_PHONE_CHANGE',
       'AMT_REQ_CREDIT_BUREAU_YEAR', 'AMT_CREDIT_TO_ANNUITY_RATIO',
       'AMT_CREDIT_SUM', 'DAYS_CREDIT', 'CNT_CREDIT_PROLONG', 'count']

타겟변수인 TARGET  을 제외한 변수들을 input_var 에 저장해준다. 

corr = train[input_var].corr()
corr.style.background_gradient(cmap='coolwarm')

위와 같은 형태의 시각화 그래프가 그려지고, 높은 상관성을 띄는 변수들을 나열하면 다음과 같다. 

[ 높은 상관성을 띄는 변수 목록 ]  

• CNT_FAM_MEMBERS & CNT_CHILDREN 0.883051
• AMT_CREDIT_TO_ANNUITY_RATIO & AMT_CREDIT 0.656337
• AMT_ANNUITY & AMT_CREDIT 0.770938

cf) 피어슨 상관계수의 해석 

r이 -1.0과 -0.7 사이이면, 강한 음적 선형관계,

r이 -0.7과 -0.3 사이이면, 뚜렷한 음적 선형관계,

r이 -0.3과 -0.1 사이이면, 약한 음적 선형관계,

r이 -0.1과 +0.1 사이이면, 거의 무시될 수 있는 선형관계,

r이 +0.1과 +0.3 사이이면, 약한 양적 선형관계,

r이 +0.3과 +0.7 사이이면, 뚜렷한 양적 선형관계,

r이 +0.7과 +1.0 사이이면, 강한 양적 선형관계

타겟 변수와의 상관성이 더 낮은 변수를 제거한다. 

print(train['CNT_FAM_MEMBERS'].corr(train['TARGET']))
print(train['CNT_CHILDREN'].corr(train['TARGET']))

0.018876651698723705

0.025357359317615676

del train['CNT_FAM_MEMBERS']
del test['CNT_FAM_MEMBERS']

CNT_FAM_MEMBERS가 TARGET과의 상관계수가 더 낮으므로 제거해 준다. 

print(train['AMT_CREDIT_TO_ANNUITY_RATIO'].corr(train['TARGET']))
print(train['AMT_CREDIT'].corr(train['TARGET']))

-0.024740288335190132

-0.02255843084934759

del train['AMT_CREDIT']
del test['AMT_CREDIT']

AMT_CREDIT과 TARGER의 상관계수가 더 낮으므로 제거해 준다. 

input_var = ['FLAG_OWN_REALTY', 'CNT_CHILDREN',
       'AMT_INCOME_TOTAL', 'AMT_ANNUITY', 'REGION_POPULATION_RELATIVE',
       'DAYS_BIRTH', 'DAYS_EMPLOYED', 'DAYS_ID_PUBLISH', 'OWN_CAR_AGE',
       'HOUR_APPR_PROCESS_START', 'DAYS_LAST_PHONE_CHANGE',
       'AMT_REQ_CREDIT_BUREAU_YEAR', 'AMT_CREDIT_TO_ANNUITY_RATIO',
       'AMT_CREDIT_SUM', 'DAYS_CREDIT', 'CNT_CREDIT_PROLONG', 'count']

제거한 변수들을 제외한 나머지 변수들을 input_var에 다시 저장해 준다. 

-xgboost 모델링 

: shap value를 활용하기 위해서는 모델이 랜덤 포레스트 형태의 tree형 모델이어야 한다. 이 중 xgboost가 속도가 빠르면서 높은 성능을 유지하므로 선택. 

from xgboost import XGBClassifier

model = XGBClassifier(n_estimators=100, learning_rate=0.1)
model.fit(train[input_var],train['TARGET'])

(3) shap value 

import shap

shap_values = shap.TreeExplainer(model).shap_values(train[input_var])

shap.summary_plot(shap_values, train[input_var], plot_type='bar')

타겟값에 가장 큰 영향을 미치는 상위 5가지 변수 목록

• AMT_CREDIT_TO_ANNUITY_RATIO
• DAYS_EMPLOYED
• DAYS_CREDIT
• DAYS_BIRTH
• DAYS_LAST_PHONE_CHANGE

(4) 5개의 예측변수와 타겟변수(대출금 상환 여부) 와의 관계 

-1. AMT_CREDIT_TO_ANNUITY_RATIO: 대출 상환 기간

shap.dependence_plot('AMT_CREDIT_TO_ANNUITY_RATIO', shap_values, train[input_var])

해당 그래프는 세로축의 값이 낮을 수록 대출 상환을 잘 한다고 해석(TARGET이 0일 확률이 높음)할 수 있다. 기간이 12-20개월일 때 상환을 잘 하지 못하며, 12개월 이하, 20개월 이상일 때는 비교적 상환을 잘 하는 것으로 보인다. 

- 2. DAYS_EMPLOYED: 언제 취업했는지

shap.dependence_plot('DAYS_EMPLOYED', shap_values, train[input_var])

대출일 기준으로 9000일 보다 전에 취업했을 때 대출 상환 능력이 급 상승하는 것을 볼 수 있다. 

- 3. DAYS_CREDIT: 해당 대출이 home credit으로부터 받은 대출보다 며칠 이전에 일어났는지

shap.dependence_plot('DAYS_CREDIT', shap_values, train[input_var])

-3000일 부터 -2000일까지 대출 상환 능력이 상승하다가 그 이후부터 하락하는 것을 볼 수 있다. 즉 너무 오래 전에 대출을 받았거나, 최근에 대출을 받았을 때 대출 상환 능력이 떨어진다고 할 수 있다. 

- 4. DAYS_BIRTH: 나이

shap.dependence_plot('DAYS_BIRTH', shap_values, train[input_var])

태어난지 오래 되었을 수록(나이가 많을 수록) 대출상환을 잘하는 경향을 보인다. 

- 5. DAYS_LAST_PHONE_CHANGE: 마지막 핸드폰을 바꾼 시기

shap.dependence_plot('DAYS_LAST_PHONE_CHANGE', shap_values, train[input_var])

핸드폰을 오래 전에 바꾸었을 수록 대출 상환을 잘하는 경향이 보인다. 

3. 결론 

• 대출 상환 기간이 상환여부에 가장 큰 영향을 준다. 해당 영향은 비선형적 관계이다. (영향이 크다고 해서 인과관계가 있다고 단정짓기는 어렵다. )
• 주택 보유 여부와 자식의 수는 대출 상환능력에 영향을 거의 미치지 않는다.
• 최근에 취업했을 수록, 최근에 대출을 받았을 수록, 최근에 핸드폰을 바꿨을 수록, 나이가 어릴수록 대출금 상황 가능성이 낮다.  

train['DAYS_EMPLOYED'].quantile(0.75)

-748.0

위와 같은 방법으로 상위 25%의 값을 구할 수 있다. 이를 이용하여 4개의 변수의 상위 25% 이상 그룹과 하위 25%미만 그룹을 나누어 시각화 결과를 확인 해 본다. 

- 상위 25%

group1 = train.loc[ (train['DAYS_EMPLOYED'].quantile(0.75)< train['DAYS_EMPLOYED']) &
           (train['DAYS_CREDIT'].quantile(0.75)< train['DAYS_CREDIT']) &
           (train['DAYS_LAST_PHONE_CHANGE'].quantile(0.75)< train['DAYS_LAST_PHONE_CHANGE']) &
           (train['DAYS_BIRTH'].quantile(0.75)< train['DAYS_BIRTH']) ]

- 하위 25 %

group2 = train.loc[ (train['DAYS_EMPLOYED'].quantile(0.25)> train['DAYS_EMPLOYED']) &
           (train['DAYS_CREDIT'].quantile(0.25)> train['DAYS_CREDIT']) &
           (train['DAYS_LAST_PHONE_CHANGE'].quantile(0.25)> train['DAYS_LAST_PHONE_CHANGE']) &
           (train['DAYS_BIRTH'].quantile(0.25)> train['DAYS_BIRTH']) ]

group1['group'] = 1
group2['group'] = 0

group1은 group변수에 1을, group2는 group 변수에 0을 넣어 준다. 

full = pd.concat([group1,group2],axis=0)

group1과 group2를 합쳐준다. 

import seaborn as sns

sns.barplot('group','TARGET',data=full)

group2 (group=0, 하위 25%)  의 Target값이 낮은 것을 볼 수 있다(0이 많다=정상 상환). 각 변수들의 값이 작을 수록 대출 상환 가능성이 높다는 결론과 같음을 알 수 있다. 

문제점

temp.info()

결측값을 간단히 확인해 보기 위하여 pandas의 info함수를 사용했는데 Non-Null Count 부분이 나오지 않는 문제가 생길 때가 있다. 

해결방법 

temp.info(null_counts=True)

인자에 null_counts=True를 넣어주면 위와 같이 나오는 것을 볼 수 있다.

러닝스푼즈 수업 정리 

<이전 글>

https://silvercoding.tistory.com/70

1. 데이터 소개 & 데이터 불러오기 

<Rossmann Store Sales> 

https://www.kaggle.com/c/rossmann-store-sales/data?select=test.csv 

해당 링크의 캐글 대회에서 사용되었던 로스만 데이터이다. 

• train.csv - historical data including Sales
• test.csv - historical data excluding Sales
• sample_submission.csv - a sample submission file in the correct format
• store.csv - supplemental information about the stores

본 포스팅에서는 축소된 데이터를 사용하여 상점의 매출 예측을 진행한다.  

(데이터: 러닝스푼즈 제공)

import os
import pandas as pd

os.chdir('../data')

train = pd.read_csv("lspoons_train.csv")
test = pd.read_csv("lspoons_test.csv")
store = pd.read_csv("store.csv")

lspoons_train.csv - 학습 데이터
lspoons_test.csv - 예측해야 할 test 데이터

store.csv - 상점에 대한 정보가 담긴 보조 데이터

train.head()

컬럼 정보 

• id
• Store: 각 상점의 id
• Date: 날짜
• Sales: 날짜에 따른 매출
• Promo: 판매촉진 행사 진행 여부
• StateHoliday: 공휴일 여부/ 공휴일 X-> 0, 공휴일-> 공휴일의 종류(a, b, c)
• SchoolHoliday: 학교 휴일인지 여부

위의 컬럼들을 사용하여 Sales(매출) 을 예측하는 모델을 생성한다. 

- 분석 절차 수립 

1. 베이스 모델링 ( feature engineering - 변수선택 - 모델링 ) 

2. 2차 모델링 ( store 데이터 merge - feature engineering - 변수 선택 - 모델링 )

3. 파라미터 튜닝 

... 모델링 반복 ( 이 후 모델링은 자율, 깃헙 정리 ) 

1. 베이스 모델링 

: 가장 기본적인 모델을 만든다. (결측값 처리, 원핫 인코딩) 

피쳐 엔지니어링이란? 

• 예측을 위해 기존의 input 변수를 이용하여 새로운 input 변수 생성
• 머신러닝 예측 성능 올릴 수 있는 방법

train.info()

결측값은 없는 것을 알 수 있고, object 타입인 Date, StateHoliday 컬럼을 전처리 해준다. 

- StateHoliday column one-hot encoding 

train = pd.get_dummies(columns=['StateHoliday'],data=train)
test = pd.get_dummies(columns=['StateHoliday'],data=test)

get_dummies 함수를 사용하여 StateHoliday 컬럼을 원핫인코딩 해준다. 

print("train_columns: ", train.columns, end="\n\n\n")
print("test_columns: ", test.columns)

새로 생성된 칼럼을 보면 train에는 b, c 가 있지만 test에는 b, c 가 존재하지 않는다. 이 경우 학습 과정에서 문제가 발생할 수 있다. 

test['StateHoliday_b'] = 0
test['StateHoliday_c'] = 0

따라서 같은 칼럼을 test 데이터셋에 생성해 준다.

- feature engineering using Date column

train['Date']

Date 칼럼은 날짜형 형태로 되어 있지만 dtype이 object이므로 날짜로서의 의미가 없다. 

train['Date'] = pd.to_datetime( train['Date'] )
test['Date'] = pd.to_datetime( test['Date'] )

따라서 pandas에서 날짜 계산을 편리하게 해주는 to_datetime 함수를 사용하여 날짜형 변수로 변환해 준다. 

# 요일 컬럼 weekday 생성 

train['weekday'] = train['Date'].dt.weekday
test['weekday'] = test['Date'].dt.weekday

# 년도 컬럼 year 생성 

train['year'] = train['Date'].dt.year
test['year'] = test['Date'].dt.year

# 월 컬럼 month 생성 

train['year'] = train['Date'].dt.year
test['year'] = test['Date'].dt.year

- 베이스라인 모델링 

from xgboost import XGBRegressor

train.columns

xgb = XGBRegressor( n_estimators= 300 , learning_rate=0.1 , random_state=2020 )
xgb.fit(train[['Promo','SchoolHoliday','StateHoliday_0','StateHoliday_a','StateHoliday_b','StateHoliday_c','weekday','year','month']],
        train['Sales'])

XGB 모델을 사용하여 학습을 시켜 준다. 

from sklearn.model_selection import cross_val_score
cross_val_score(xgb, train[['Promo', 'weekday', 'month','year', 'SchoolHoliday']], train['Sales'], scoring="neg_mean_squared_error", cv=3)

cross validation 으로 오류율을 구해보았더니 위와 같이 나왔다.  추가 작업으로 오류율을 줄여나가 보자! 

cf.  캐글 제출 파일 만들기 

test['Sales'] = xgb.predict(test[['Promo','SchoolHoliday','StateHoliday_0','StateHoliday_a','StateHoliday_b','StateHoliday_c','weekday','year','month']])

test 데이터셋으로 학습된 모델에 넣어 예측을 진행한다. 

test[['id','Sales']].to_csv("submission.csv",index=False)

- 변수 선택 

xgb.feature_importances_

feature_importances_ 를 사용하여 변수의 중요도를 알 수 있다. 

input_var = ['Promo','SchoolHoliday','StateHoliday_0','StateHoliday_a','StateHoliday_b','StateHoliday_c','weekday','year','month']

input_var에 Sales를 제외한 인풋 변수를 저장해 준다. 

imp_df = pd.DataFrame({"var": input_var,
                       "imp": xgb.feature_importances_})

imp_df = imp_df.sort_values(['imp'],ascending=False)
imp_df

변수 중요도 데이터프레임을 생성한 후 높은 순서대로 정렬을 해 준다. Promo가 압도적으로 변수중요도가 높은 것을 볼 수 있다. State_Holiday는 대체적으로 낮은 것으로 보인다. 

import matplotlib.pyplot as plt
plt.bar(imp_df['var'],imp_df['imp'])
plt.xticks(rotation=90)
plt.show()

한눈에 보기위해 그래프를 그려 보았더니 SchoolHoliday 이후 컬럼들은 별 의미가 없어 보인다. 

cross_val_score(xgb, train[['Promo', 'weekday', 'month','year', 'SchoolHoliday']], train['Sales'], scoring="neg_mean_squared_error", cv=3)

모든 컬럼을 사용했을 때 보다 오류율이 줄어들었다. 그렇다면 컬럼을 몇개 사용하는 것이 가장 오류율을 줄게 하는지 실험해 본다. 

import numpy as np
score_list=[]
selected_varnum=[]

for i in range(1,10):
    selected_var = imp_df['var'].iloc[:i].to_list()
    scores = cross_val_score(xgb, 
                             train[selected_var], 
                             train['Sales'], 
                             scoring="neg_mean_squared_error", cv=3)
    score_list.append(-np.mean(scores))
    selected_varnum.append(i)
    print(i)

plt.plot(selected_varnum, score_list)

변수의 개수 별로 cross validation을 수행한 결과 2개일 때 가장 낮은 것을 볼 수 있다. 

예측변수가 2개일 때 cross validation을 수행한다. 

cross_val_score(xgb, train[['Promo', 'weekday']], train['Sales'], scoring="neg_mean_squared_error", cv=3)

두번째 빼고는 모두 줄어든 것을 볼 수 있다. 예측변수가 2개일 때 모델 학습을 한 후, 테스트 데이터로 제출한 캐글 스코어도 더 줄어들었다. (반복작업이므로 포스팅에서 생략) 

2. 2차 모델링 

- store 데이터 합병 

store

store 데이터셋: 각 상점에 대한 특징을 정리한 것 

컬럼 의미

• Store: 상점의 유니크한 id
• Store Type: 상점의 종류
• Assortment: 상점의 종류
• CompetitionDistance: 가장 가까운 경쟁업체 상점과의 거리
• CompetitionOpenSinceMonth: 가장 가까운 경쟁업체 오픈 월
• CompetitionOpenSinceYear: 오픈 년도
• Promo2: 지속적인(주기적인) 판매촉진 행사 여부
• Promo2SinceWeek/ promo2SinceYear: 해당 상점이 promo2를 하고있다면 언제 시작했는지
• PromoInterval: 주기가 어떻게 되는지

train = pd.merge(train, store, on=['Store'], how='left')
test = pd.merge(test, store, on=['Store'], how='left')

Store 컬럼을 기준으로 train, test 데이터셋과 store 데이터셋을 합병해 준다. 

- CompetitionOpen 컬럼 생성

: 경쟁업체가 언제 개장했는지 (해당 가게 이전 개장: 양수, 이후 개장: 음수) 

train['CompetitionOpen'] = 12*( train['year'] - train['CompetitionOpenSinceYear'] ) + \
                             (train['month'] - train['CompetitionOpenSinceMonth'])

test['CompetitionOpen'] = 12*( test['year'] - test['CompetitionOpenSinceYear'] ) + \
                             (test['month'] - test['CompetitionOpenSinceMonth'])

해당 가게가 개장한 년도에서 경쟁업체가 개장한 년도를 뺀 후 12를 곱하면 개월 수로 변환할 수 있다. 이를 해당 가게 개장 달에서 경쟁업체 개장 달의 차이와 더해주면 해당 가게를 기준으로 언제 개장했는지 알 수 있다. 

- PromoOpen 컬럼 생성 

: 해당 가게 개장 후 몇개월 후에 프로모션2가 시작되었는지 

train['WeekOfYear'] = train['Date'].dt.weekofyear # 현재 날짜가 몇번째 주인지
test['WeekOfYear'] = test['Date'].dt.weekofyear

프로모션2에 대한 날짜 정보가 년도(Year)와 주(Week)로 되어있기 때문에 Date컬럼에서 날짜가 몇번째 주인지 계산하여 WeekOfYear 컬럼에 저장해 준다. 

train['PromoOpen'] = 12* ( train['year'] - train['Promo2SinceYear'] ) + \
                        (train['WeekOfYear'] - train['Promo2SinceWeek']) / 4

test['PromoOpen'] = 12* ( test['year'] - test['Promo2SinceYear'] ) + \
                        (test['WeekOfYear'] - test['Promo2SinceWeek']) / 4

이전과 같이 년도를 개월수로 바꿔주고, 주를 4로 나누어 개월수로 변환해 준것을 더하여 개장 후 몇개월 뒤에 프로모션2가 진행되었는지에 대한 개월 수가 나오게 된다. 

- 원핫인코딩 ( get_dummies() ) 

train.dtypes

데이터타입을 확인 해 보면 object인 컬럼이 3가지 있다. 3개의 컬럼을 get_dummies를 이용하여 원핫인코딩 해준다. 

train = pd.get_dummies(columns=['StoreType'],data=train)
test = pd.get_dummies(columns=['StoreType'],data=test)

train = pd.get_dummies(columns=['Assortment'],data=train)
test = pd.get_dummies(columns=['Assortment'],data=test)

train = pd.get_dummies(columns=['PromoInterval'],data=train)
test = pd.get_dummies(columns=['PromoInterval'],data=test)

train.columns

test.columns

train column과 test column 이 동일한 것을 확인하였다. 

- 모델링 

input_var = ['Promo', 'SchoolHoliday',
       'StateHoliday_0', 'StateHoliday_a', 'StateHoliday_b', 'StateHoliday_c',
       'weekday', 'year', 'month', 'CompetitionDistance',
       'Promo2',
       'CompetitionOpen', 'WeekOfYear',
       'PromoOpen', 'StoreType_a', 'StoreType_b', 'StoreType_c', 'StoreType_d',
       'Assortment_a', 'Assortment_b', 'Assortment_c',
       'PromoInterval_Feb,May,Aug,Nov', 'PromoInterval_Jan,Apr,Jul,Oct',
       'PromoInterval_Mar,Jun,Sept,Dec']

필요없는 컬럼은 삭제하고 input_var에 저장해 준다. 

set(train) - set(input_var)

(참고) input_var에 들어가지 않은 컬럼들 목록이다. 

xgb = XGBRegressor( n_estimators=300, learning_rate= 0.1, random_state=2020)
xgb.fit(train[input_var],train['Sales'])

앞과 동일하게 xgb 모델을 사용한다.  

cross_val_score(xgb, train[input_var], train['Sales'], scoring="neg_mean_squared_error", cv=3)

store 데이터셋을 합병하여 전처리 후 모델링을 했더니 오류율이 대폭 하락하였다. 

- 변수중요도 

imp_df = pd.DataFrame({'var':input_var,
                       'imp':xgb.feature_importances_})
imp_df = imp_df.sort_values(['imp'],ascending=False)

plt.bar(imp_df['var'],
        imp_df['imp'])
plt.xticks(rotation=90)
plt.show()

변수중요도를 시각화 해보았더니, 모든 변수를 사용하는 것보다 선택해서 학습하는 것이 좋을 것 같다고 판단된다. 

score_list=[]
selected_varnum=[]

for i in range(1,25):
    selected_var = imp_df['var'].iloc[:i].to_list()
    scores = cross_val_score(xgb, 
                             train[selected_var], 
                             train['Sales'], 
                             scoring="neg_mean_squared_error", cv=3)
    score_list.append(-np.mean(scores))
    selected_varnum.append(i)
    print(i)

plt.plot(selected_varnum, score_list)

지속적으로 하락하는 경향을 보이지만 17개 이후로 비슷한 것 같이 보인다. 따라서 17개까지 선택하여 학습을 진행해 본다. 

input_var = imp_df['var'].iloc[:17].tolist()
xgb.fit(train[input_var],
        train['Sales'])

cross_val_score(xgb, train[input_var], train['Sales'], scoring="neg_mean_squared_error", cv=3)

전체적으로 오류율이 줄어들었다. 

3. 파라미터 튜닝 

estim_list = [100,200,300,400,500,600,700,800,900]
score_list = []

for i in estim_list:
    xgb = XGBRegressor( n_estimators=i, learning_rate= 0.1, random_state=2020)
    scores = cross_val_score(xgb, train[input_var], train['Sales'], scoring="neg_mean_squared_error", cv=3)
    score_list.append(-np.mean(scores))
    print(i)

plt.plot(estim_list,score_list)
plt.xticks(rotation=90)
plt.show()

n_estimators를 바꿔가며 오류율을 계산한 것을 시각화 해보았고, n_estimators=400으로 하는 것이 적당해 보인다.  

xgb = XGBRegressor( n_estimators=400, learning_rate= 0.1, random_state=2020)

xgb.fit(train[input_var],
        train['Sales'])

cross_val_score(xgb, train[input_var], train['Sales'], scoring="neg_mean_squared_error", cv=3)

400으로 변경하였더니 오류율이 낮아졌다. 

아쉽게도 파라미터 튜닝을 한 이후로 캐글에서 테스트 데이터셋은 오류율이 더 높게 나왔다. 이외에 결측값, 이상치 등 feature engineering을 지속적으로 시도해 보아야겠다. (추후 github 업로드 예정) 

러닝스푼즈 수업 정리 

< 이전 글 > 

https://silvercoding.tistory.com/69

Menchester United 팀에서 2013년 Alex Ferguson 감독이 은퇴를 하고, 하락세를 타다가 솔샤르 감독이 팀을 맡게되었을 때 2020년 3월 기준 2019/2020 시즌 겨울 시장에서 두명의 선수를 영입하여 하락세를 반전시킬 수 있었다. 

이를 선수들의 데이터 분석을 통해 방출과 영입을 결정한다면, 어떤 결과가 나올까? 

데이터 : FIFA 데이터 (러닝스푼즈 강의 제공)

1. 데이터 불러오기 

import pandas as pd

import warnings 

warnings.filterwarnings(action='ignore')  # 경고문 제거

data = pd.read_csv("./data/FIFA_data.csv")

pd.set_option('display.max_columns', 80)

column이 많으면 ... 으로 생략되어있기 때문에 데이터의 컬럼 수인 80개로 설정해준다. 

data.head()

모든 컬럼을 확인해볼 수 있다. 

2. 데이터 확인, 분석계획 

컬럼 별 의미 확인 

분석 절차 수립 

1. Manchester United 선수 분석 (어떤 선수들이 존재하는가?) 

2. Manchester United 지역라이벌 Manchester City 선수들과 비교 분석 

3. 부족한 포지션 2가지 선택 

4. 다른팀의 선수들 중 2명의 영입 선수 선택 (재정, 현실가능성, 영입방침 고려) 

3. Manchester United 선수들 분석 

(1) EDA 

- 맨유 선수 추출

mu = data[data['Club'] == 'Manchester United']
mu.head()

Club이 Manchester United인 행만 뽑아 mu에 저장해준다.  

mu['Club'].unique()

unique() 함수를 사용하여 확인해 보니 맨유만 잘 뽑힌 것을 볼 수 있다. 

- 맨유 선수들 간략한 정보 출력 

print(f"인원: {mu.shape[0]}")
print(f"맨유 선수들의 포지션: {mu['Position'].unique()}")
print(f"평균 능력치: {mu['Overall'].mean()}")
print(f"평균 잠재 능력치: {mu['Potential'].mean()}")

- 시각화 

import seaborn as sns 
sns.countplot(mu['Age'])

선수들의 나이 분포이다. 19살이 가장 많고, 그다음으론 25살, 28살, 22살인 것을 알 수 있다. 

sns.countplot(mu['Position'])

ㅍ

선수들의 포지션 중 가장 많은 것은 CM, CB 이다. 

sns.boxplot(data=mu, x='Position', y='Overall')

Position별 능력치 boxplot 을 그려보았더니 CB 포지션에서 이상치가 발견되었다. 

* 이상치 & 결측치 처리 

이상치

• 정상 범주에서 크게 벗어난 값
• 이상치를 포함하여 분석을 진행할 경우 분석 결과가 왜곡될 가능성이 있음 

결측치

• 누락값, 비어있는 값 
• 데이터 수집 당시 기록되지 않았거나, 누락된 값

이상치와 결측치 처리법

• 제거: 이상치 및 결측치가 포함되어 있는 행, 혹은 열을 제거한다. (최후의 수단, 데이터 하나하나가 소중하기 때문) 
• 대체: 이상치 및 결측치를 해당 컬럼의 최댓값, 평균값, 중앙값 등으로 대체 (추천하는 방법은 아님.)
• 예측: 이상치 및 결측치가 포함된 컬럼의 특성을 고려하여 예측 값으로 채워 넣음 (추천) 

mu[mu['Overall']>100]

능력치가 100이상인 row를 확인해 본다. 

이상치 처리 - 예측 사용 

mu[mu['Position'] == 'CB'][['Position', 'Overall', 'CB']]

같은 포지션 선수들끼리 비교를 해본다. CB가 비슷한 선수들끼리의 능력치가 같은 것을 알 수 있다. 이상치를 갖고 있는 선수는 11081 번째 선수와 CB가 같으므로 75로 예측할 수 있다. 

mu['Overall'][11422] = 75

11422 번째 선수의 능력치를 75로 바꾸어준다. 

sns.boxplot(data=mu, x='Position', y='Overall')

다시 boxplot을 그려보니 이상치 없이 그려진 것을 볼 수 있다. 

sns.boxplot(data=mu, x='Position', y='Potential')

potential에 대한 boxplot도 그려준다. potential에는 이상치가 나오지 않았다. 

mu.info()

mu는 총 33개의 row인데, 19~44 번째 컬럼에 3개의 결측값이 있는 것이 확인되었다. 

mu[mu.isnull()['LS']]

포지션이 GK인 선수들만 결측값이 있는 것으로 보인다. GK는 골키퍼이고, 골키퍼는 다른 포지션에 대한 능력치를 부여할 필요가 없기 때문에 결측값으로 둔 것으로 예상할 수 있다. 

mu = mu.fillna(-1)

결측값을 -1로 채워준다. (값을 측정할 수 없다는 의미에서 임의의 값 -1, 다른값을 넣어주어도 됨) 

mu.info()

결측값이 모두 채워졌다. 

4. Manchester United vs Manchester City 

(1) 전처리 

df = data[(data['Club'] == 'Manchester United') | (data['Club']=='Manchester City')]

Manchester United와 Manchester City만 뽑아 df 에 저장해준다. 

df['Club'].unique()

df['Value'].head()

이적료 Value가 기호로 써져있으므로, 기호 삭제, 소수점 삭제를 진행한다. 

df['Value'] = df['Value'].str.replace('M', '000000')
df['Value'] = df['Value'].str.replace('K', '000')

M이 써져있으면 0을 6개, K가 써져있으면 0을 3개 붙여 준다. 

df['Value']

df['Value'] = df['Value'].str.slice(1,)

그다음 str.slice를 이용하여 기호를 없애준다. 

df['Value'].iloc[3]

'64.5000000'

이렇게 소수점이 있는 것이 존재하므로, 점을 없애고 뒤의 0을 하나 삭제한다. 

for i in df["Value"]:
    if '.' in i:
        df['Value'] = df['Value'].str.replace('.', '')
        df['Value'] = df['Value'].str.slice(0,-1)

df['Value']

적용이 잘 된 것을 볼 수 있다. 

df['Value'] = df['Value'].astype('int')

이제 데이터 타입을 object -> int로 바꿔준다. 

df.head()

- mu, mc 선수 분리 

mu = df[df['Club'] == "Manchester United"]
mc = df[df['Club'] == "Manchester City"]

df에서 Manchester United, Manchester City 선수들을 분리해 준다. 

mc.head()

df['Position'].unique()

위의 포지션을 골기퍼, 수비수, 미드필더, 공격수, 총 4가지로 분류하여 분석을 진행한다. 포지션을 나누면 다음과 같다. 

• 골키퍼 리스트 GK= GK (골키퍼)
• 수비수 리스트 CB = CB(중앙 수비수), LB(왼쪽 수비수), RB(오른쪽 수비수), RCB(오른쪽/중앙 수비수), LCB(왼쪽/중앙 수비수) 
• 미드필더 리스트 MF = RCM(오른쪽/중앙 미드필더), LCM(왼쪽/중앙 미드필더), RDM(오른쪽 수비형 미드필더), CDM(중앙 수비형 미드필더), CM(중앙 미드필더), RM(오른쪽 미드필더), CAM(중앙 공격형 미드필더)
• 공격수 리스트 ST = ST(전방 공격수), LW(왼쪽 공격수), RW(오른쪽 공격수)

* GK(공격수) : 1명, CB(수비수) : 4명, MF(미드필더) : 4명, ST(공격수) : 2명 선발

-> 선발의 기준은 현재능력치(Overall 컬럼)

gk_list = ['GK']
cb_list = ['CB', 'LCB', 'RCB', 'RB', 'LB']
mf_list = ['RCM', 'LCM', 'RDM', 'CDM', 'CM', 'RM', 'CAM']
st_list = ['ST', 'LW', 'RW']

포지션을 분류한대로 리스트를 작성해준다. 

gk_count = 1
cb_count = 4
mf_count = 4
st_count = 2



mu_id = []

for index in mu.index:
    if mu['Position'][index] in gk_list: 
        if gk_count != 0:
            mu_id.append(mu['ID'][index])
            gk_count -= 1 
    elif mu['Position'][index] in cb_list:
        if cb_count != 0:
            mu['Position'][index] = 'CB'
            mu_id.append(mu['ID'][index])
            cb_count -= 1 
    elif mu['Position'][index] in mf_list:
        if mf_count != 0:
            mu['Position'][index] = 'MF'
            mu_id.append(mu['ID'][index])
            mf_count -= 1 
    else:
        if st_count != 0:
            mu['Position'][index] = 'ST'
            mu_id.append(mu['ID'][index])
            st_count -= 1

현재능력치가 높은 순으로 정렬되어있는 데이터이기 때문에 순서대로 상위 포지션 선수들의 ID 값을 리스트에 넣어준다. 

mu[mu['ID'].isin(mu_id)]

11명의 선수가 알맞게 나온 것을 볼 수 있다. 

mu = mu[mu['ID'].isin(mu_id)]

선발된 11명의 선수들만 mu 변수에 넣어 준다. 

같은 절차로 Manchester City 또한 진행한다. 

gk_count = 1
cb_count = 4
mf_count = 4
st_count = 2


mc_id = []

for index in mc.index:
    if mc['Position'][index] in gk_list: 
        if gk_count != 0:
            mc_id.append(mc['ID'][index])
            gk_count -= 1 
    elif mc['Position'][index] in cb_list:
        if cb_count != 0:
            mc['Position'][index] = 'CB'
            mc_id.append(mc['ID'][index])
            cb_count -= 1 
    elif mc['Position'][index] in mf_list:
        if mf_count != 0:
            mc['Position'][index] = 'MF'
            mc_id.append(mc['ID'][index])
            mf_count -= 1 
    else:
        if st_count != 0:
            mc['Position'][index] = 'ST'
            mc_id.append(mc['ID'][index])
            st_count -= 1

mc = mc[mc['ID'].isin(mc_id)]

concat vs merge

merge: 좌우합병, concat: 상하합병

df = pd.concat([mu, mc])

선발된 mu, mc 선수들을 합쳐 df에 저장해준다. 

(2) EDA 

- mu vs mc 포지션별 주전선수의 현재능력치(overall) 비교 

df = pd.concat([mu, mc])

골기퍼를 뺀 타 포지션은 모두 Manchester United 팀이 낮은 것을 볼 수 있다. 

- mu vs mc 포지션별 주전선수의 예상이적료(Value) 비교

sns.boxplot(data=df, x='Position', y='Value', hue='Club')

이적료는 골기퍼를 빼고 거의 차이가 없거나 더 높은 것을 볼 수 있다.

위의 boxplot으로 두 팀을 비교해보았을 때, 이적료 대비 능력치가 떨어지는 포지션은 MF, CB로 판단하여 두 포지션에 대해 어떤 선수를 영입할지 분석을 해본다. 

5. Manchester United는 어떤 선수를 영입해야 하는가? 

(1) EDA

* 방출 선수 선정

영입일, 능력치, 잠재력, 나이를 기준으로 공식 세우기 

 Point = (Overall * 2 + Potential) / Age 

능력치(가중치를 가함)와 잠재력이 높을 수록, 나이가 낮을 수록 좋음. 

mu['Point'] = (mu['Overall'] * 2 + mu['Potential']) / mu['Age']

- MF 포지션 

mu[mu['Position'] == 'MF'][['Name', 'Overall', 'Potential', 'Age', 'Joined', 'Point']]

가장 낮은 포인트는 211번 선수이다.  

- CB 포지션 

mu[mu['Position'] == 'CB'][['Name', 'Overall', 'Potential', 'Age', 'Joined', 'Point']]

가장 낮은 포인트는 377번 선수이다. 

마타, 스몰링 두 선수를 방출하고 MF, CB 포지션을 한명씩 영입한다. 

(2) 시각화 

전체 선수 시각화 - 영입방침에 따른 영입 선수 결정 

Manchester United 영입방침 (솔샤르감독) 

- 선수의 나이는 어릴 수록 좋음

- 잠재력 보다 현재 바로 주전으로 뛸 수 있는 선수 

market = data[(data['Position']=='RM') | (data['Position']=='CB')]

포지션은 방출 선정된 두선수의 세부 포지션인 RM, CB를 선택한다. 

market.head()

import matplotlib.pyplot as plt

f, ax = plt.subplots(2, 4, figsize=(20, 10))

vs_list = ['Age', 'Overall', 'Potential', 'Weak Foot']

for i in range(8):
    if i < 4:
        colors = ['firebrick' if x > market[market['Position']=='CB'][:13][vs_list[i]].mean() else 'gray' for x in market[market['Position']=='CB'][:13][vs_list[i]]]
        sns.barplot(x=vs_list[i], y='Name', data=market[market['Position']=='CB'][:13], ax=ax[i//4, i%4], palette=colors)
        ax[i//4, i%4].axvline(market[market['Position']=='CB'][:13][vs_list[i]].mean(), ls = '--', color='k')
   
    else:
        colors = ['firebrick' if x > market[market['Position']=='RM'][:13][vs_list[i%4]].mean() else 'gray' for x in market[market['Position']=='RM'][:13][vs_list[i%4]]]        
        sns.barplot(x=vs_list[i%4], y='Name', data=market[market['Position']=='RM'][:13], ax=ax[i//4, i%4], palette=colors)        
        ax[i//4, i%4].axvline(market[market['Position']=='RM'][:13][vs_list[i%4]].mean(), ls='--', color='k')

데이터 분석으로 다른 것을 배제하고 나이, 현재 능력치, 잠재력으로만 따진다고 했을 때, 영입방침에 따라 영입을 결정한다면 S. Umtiti, K. Mbappé 선수가 될 것이라 판단하였다.