pkm7628의 IT공부!

기본환경

jupyter lab / notebook 이 아닌 google colaboratory를 활용한다.

파일을 google drive에 업로드하여 연결 앱에서 지정해주는데 없다면 다음과 같이 진행하여 설치해 준다.

딥러닝 학습 절차

1. 가중치 초기값을 할당한다. (초기 모델을 만든다. / 초기값은 random하게 할당됨)
2. (초기)모델로 예측한다.
3. 오차를 계산한다. (loss function)
4. 가중치 조절 : 오차를 줄이는 방향으로 가중치를 적절히 조절한다.(optimizer)
   • 적절히 조절 → 얼마 만큼 조절할 지 결정하는 하이퍼파라미터 : learning rate (lr)
5.  다시 처음으로 가서 반복한다.
   • 전체 데이터를 적절히 나눠서(mini batch) 반복 : batch_size
   • 전체 데이터를 몇 번 반복 학습할 지 결정 : epoch

딥러닝 모델링 : Regression

딥러닝 전처리 : 스케일링

Normalization(정규화) - 모든 값의 범위를 0 ~ 1로 변환

Standardization(표준화) - 모든 값을, 평균 = 0, 표준편차 = 1 로 변환

Dense

Input : Input(shape = ( , ))

• 분석단위에 대한 shape
• 1차원 : (feature 수, )
• 차원 : (rows, columns)

Output : Dense( n )

• 예측 결과가 1개 변수(y가 1개 변수)
• 이진분류 : activation  = 'sigmoid'  / 0과 1 사이의 확률값으로 지
• 다중분류 : activation  = 'softmax ' 

Hidden Layer  : Dense( n, activation = 'relu' )

• activation  : 현재 레이어(각 노드)의 결과값을 다음 레이어(연결된 각 노드)로 어떻게 전달할지 결정/변환해주는 함수
  • Hidden Layer에서는 : 선형함수를 비선형 함수로 변환
  • Output Layer에서는 : 결과값을 다른 값으로 변환해 주는 역할

Hidden Layer에서 무슨 일이 일어나는가?

• 기존 데이터를 받아들임.
• (우리는 정확히 알기 어렵지만) 뭔가 새로운 특징(New Feature)을 만듬
• 특징은 분명히 예측된 값과 실제 값 사이의 오차를 최소화 해주는 유익한 특징일 것으로 생각.
• Hidden Layer에서는 기존 데이터가 새롭게 표현(Representation) 
• Feature Engineering이 진행

Compile

컴파일(Compile)

• 선언된 모델에 대해 몇 가지 설정을 한 후 컴퓨터가 이해할 수 있는 형태로 변환하는 작업

loss function(오차함수)

• Cost Function, Objective Function 과 같은(유사한) 의미
• 오차 계산을 무엇으로 할지 결정
• 회귀모델 : mse 
• 분류모델 : cross entropy

optimizer 

• 오차를 최소화 하도록 가중치를 업데이트하는 역할 
• Adam - 최근 딥러닝에서 가장 성능이 좋은 Optimizer로 평가 됨.
• learning_rate - 업데이트 할 비율 / 기울기(gradient)에 곱해지는 조정 비율 (걸음걸이의 ‘보폭’을 조정한다고 표현)

학습

Epoch

•  주어진 train set을 몇 번 반복 학습할 지 결정

validation_split = 0.2 

• train 데이터에서 20%를 검증셋으로 분리

batch_size

• 배치 단위로 학습(가중치 업데이트), 기본값 32
• 전체 데이터를 적절히 나눠서(mini batch)

.history 

• 학습을 수행하는 과정 중에 가중치가 업데이트 되면서 학습 시 계산된 오차 기록

학습 곡선

• 모델 학습이 잘 되었는지 파악하기 위한 그래프
• 정답은 아니지만, 학습 경향을 파악하는데 유용.
• 각 Epoch 마다 train error와 val error가 어떻게 줄어들고 있는지 확인

바람직한 학습 곡선

1. 초기 epoch에서는 오차가 크게 줄어듬.
2. 오차 하락이 꺾이임. 
3. 점차 완만해짐 - 그러나 학습곡선의 모양새는 다양함

바람직 하지 않은 학습 곡선

Case 1

• 학습이 덜 됨
• 오차가 줄어들다가 학습이 끝남
• 조치 : 학습을 더! / epoch 수를 늘리거나 learning rate을 크게 한다.

Case 2

• train_err가 들쑥날쑥

  

• 가중치 조정이 세밀하지 않음
• 조치 : 조금씩 업데이트 / learning rate을 작게

Case 3

• 과적합

  

• Train_error는 계속 줄어드는데, val_error는 어느 순간부터 커지기 시작
• 너무 과도하게 학습이 된 경우
• 조치 - Epoch 수 줄이기

# 라이브러리 로딩
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.metrics import *
from sklearn.preprocessing import MinMaxScaler

from keras.models import Sequential
from keras.layers import Dense, Input
from keras.backend import clear_session
from keras.optimizers import Adam

#학습곡선 그래프 함수 만들기
def dl_history_plot(history):
    plt.figure(figsize=(10,6))
    plt.plot(history['loss'], label='train_err', marker = '.')
    plt.plot(history['val_loss'], label='val_err', marker = '.')

    plt.ylabel('Loss')
    plt.xlabel('Epoch')
    plt.legend()
    plt.grid()
    plt.show()

#데이터로딩
path = 'https://raw.githubusercontent.com/DA4BAM/dataset/master/Carseats.csv'
data = pd.read_csv(path)

#데이터 준비
target = 'Sales'
x = data.drop(target, axis=1)
y = data.loc[:, target]

#가변수화
cat_cols = ['ShelveLoc', 'Education', 'US', 'Urban']
x = pd.get_dummies(x, columns = cat_cols, drop_first = True)

#데이터분할
x_train, x_val, y_train, y_val = train_test_split(x, y, test_size=.2, random_state = 20)

#Scaling
scaler = MinMaxScaler()
x_train = scaler.fit_transform(x_train)
x_val = scaler.transform(x_val)

#모델 설계
nfeatures = x_train.shape[1]
model = Sequential([Input(shape = (nfeatures, )), Dense(7, activation = 'relu'), #선형을 비선형으로
                    Dense(1)])
model.summary()

#컴파일 + 학습
model.compile(optimizer = Adam(learning_rate = 0.05), loss = 'mse')
result = model.fit(x_train, y_train, epochs = 40, validation_split= 0.2).history

#학습곡선
dl_history_plot(result)

#검증
pred = model.predict(x_val)
print(mean_absolute_error(y_val, pred))

딥러닝 모델링 : 이진분류 / 다중분

Output Layer

• 결과를 0, 1로 변환하기 위해 각 범주에 대한 결과를 범주별 확률 값으로 변환
• 이진분류 : activation = 'sigmoid'
  • Loss Function : binary_crossentropy

• 다중분류 : activation = 'softmax' - 0~1사이 확률 값으로 변환
  • Loss Function : sparse_categorical_crossentropy(정수 인코딩) 
  • Loss Function : categorical_crossentropy(one-hot 인코딩) / 기능적으로는 둘다 동일

수를 n만큼 입력받고 어떠한 수 N으로 나눴을 때 나머지가 모두 동일하다면 N을 출력하는 문제이다.

n = int(input())
L = []
for i in range(n):
    L.append(int(input()))
    
min_num = min(L)

for i in range(1, min_num+1):
    check = [x%i for x in L]
    if check.count(check[0]) == len(check):
        # print(check)
        print(i, end =' ')

생각보다 쉽게 풀이했다

독립변수 개수로 회귀분석을 단순 회귀와 다중 회귀로 분류 

Linear Regression

단순 회귀(Simple Regression) 

• 독립변수 하나가 종속변수에 영향을 미치는 선형 회귀
• 𝑥 값 하나만으로 𝑦값을 설명할 수 있는 경우 예) 행복지수가 연수입만으로 결정됨
• 회귀식: 𝑦ො = 𝑤0 + 𝑤1𝑥1
• 독립변수의 최선의 가중치와(w1)와 편향(w0)을 찾음
• 단순 회귀의 회귀 계수
  • 모델 학습 후 회귀계수 확인 가능
  • model.coef_: 회귀계수(=가중치)
  • model.intercept_: 편향
  • y_hat = x * model.coef_ + model.intercept_

다중 회귀(Multiple Regression)

• 여러 독립변수가 종속변수에 영향을 미치는 선형 회귀
• 𝑦 값을 설명하기 위해서는 여러 개의 𝑥 값이 필요한 경우 예: 여러 요인들에 의해 보스턴 지역 집 값이 결정 됨
• 회귀식: 𝑦ො = w0 + w1𝑥1 + w2𝑥2 + w3𝑥3 + ⋯ + w𝑛𝑥𝑛
• 각 독립변수의 최선의 가중치와(w1, w2, w3, w4…)와 편향(w0)을 찾음
• 단순 회귀의 회귀 계수
  • 회귀계수가 여럿이므로 독립변수 이름과 같이 확인하기를 권고
  • model.coef_: 회귀계수(=가중치)
  • model.intercept_: 편향
  • y_hat = x * model.coef_ + model.intercept_

K-Nearest Neighbor

• k-Nearest Neighbor: k 최근접 이웃(가장 가까운 이웃 k개)
• 학습용 데이터에서 k개의 최근접 이웃의 값을 찾아 그 값들로 새로운 값을 예측하는 알고리즘
• 회귀와 분류에 사용되는 매우 간단한 지도학습 알고리즘
• 다른 알고리즘에 비해 이해하기 쉽지만, 연산 속도가 느림
• Regression - k개 값의 편균을 계산하여 값을 예측
• Classification - 가장 많이 포함된 유형으로 분류
• k(탐색하는 이웃 개수)에 따라 데이터를 다르게 예측할 수도 있음
  • k 값에 따라 예측 값이 달라지므로 적절한 k 값을 찾는 것이 중요(기본값=5)
  • 일반적으로 k를 1로 설정 안함 → 이웃 하나로 현재 데이터를 판단하기에는 너무 편향된 정보
  • k를 홀수로 설정 → 짝수인 경우 과반수 이상의 이웃이 나오지 않을 수 있음
• MinMaxScaler를 사용하면 더 나은 결과값을 얻을 수 있다.
  • from sklearn.preprocessing import MinMaxScaler
  • 평가용 데이터에도 학습용 데이터를 기준으로 스케일링을 수행함(학습용 데이터의 최댓값, 최솟값, 평균 등을 사용)

scaler = MinMaxScaler()
x_train_s = scaler.fit_transform(x_train)
x_test_s = scaler.transform(x_test)
# x_train이 array형태로 저장됨 다시 DF로 바꿔주는 작업 필요
x_train = pd.DataFrame(x_train_s, columns = list(x))

#인덱스 지정을 해야된다면 다음과 같은 방법 활용 가능
# scaler = MinMaxScaler().set_output(transform="pandas")

Decision Tree

• 결정 트리, 의사 결정 나무 등으로 번역
• 특정 변수에 대한 의사결정 규칙을 나무 가지가 뻗는 형태로 분류해 나감
• 분류와 회귀 모두에 사용되는 지도학습 알고리즘
• 분석 과정이 직관적이며, 이해와 설명하기가 쉬움
• 스케일링 등의 전처리 영향도가 크지 않음
• 분석 과정을 실제로 눈으로 확인할 수 있음 → 화이트박스 모델
• 스무고개처럼 의미 있는 질문을 먼저 하는 것이 중요
• 훈련 데이터에 대한 제약 사항이 거의 없는 유연한 모델 → 과적합으로 모델 성능이 떨어지기 쉬움 → 트리 깊이를 제한하는(=가지치기) 튜닝이 필요

용어 정리

• Root Node(뿌리 마디): 전체 자료를 갖는 시작하는 마디
• Child Node(자식 마디): 마디 하나로부터 분리된 2개 이상의 마디
• Parent Node(부모 마디): 주어진 마디의 상위 마디
• Terminal Node(끝 마디): 자식 마디가 없는 마디(=Leaf Node)
• Internal Node(중간 마디): 부모 마디와 자식 마디가 모두 있는 마디
• Branch(가지): 연결되어 있는 2개 이상의 마디 집합
• Depth(깊이): 뿌리 마디로부터 끝 마디까지 연결된 마디 개수(층을 연결한 선의 갯수라 생각하면 편함)

분류와 회귀

분류

• 비용 함수 : 불순도
• 마지막 노드에 있는 샘플들의 최빈값을 예측값으로 반환.
• 불순도를 수치화 할 수 있는 지표(지니 불순도 / 엔트로피)

• 지니 불순도(Gini Impurity)
  • 지니 불순도 = 1 − (양성 클래스 비율2+음성 클래스 비율2 )
  • 분류 후에 얼마나 잘 분류했는지 평가하는 지표
  • 얼마나 순도가 증가했는지, 불순도가 감소했는지
• 지니 불순도 특징
  • 지니 불순도가 낮을수록 순도가 높음
  • 지니 불순도는 0~0.5 사이의 값(이진 분류의 경우)
    • 순수하게(완벽하게) 분류되면 → 0
    • 완벽하게 섞이면(50:50) → 0.5
  • 지니 불순도가 낮은 속성으로 의사결정 트리 노드 결정
   
• 엔트로피(Entropy)
  • 엔트로피 = −음성클래스비율× 𝑙𝑜𝑔2 음성클래스비율 − 양성클래스비율 × 𝑙𝑜𝑔2(양성클래스비율)
  • 𝑝𝑖 : 집합 안에서 속성 i의 확률을 나타냄
    • 예를 들어 𝑝𝑖=1이면 집합 안의 모든 항목이 i 속성을 가진 경우
  • 엔트로피는 0~1 사이의 값
    • 순수하게(완벽하게) 분류되면 → 0
    • 완벽하게 섞이면(50:50) → 1

정보 이득(Information Gain)

• Information Gain
• 엔트로피는 단지 속성의 불순도를 표현
• 우리가 알고 싶은 것 = 어떤 속성이 얼마나 많은 정보를 제공하는가!
• 정보 이득 공식 • 정보 이득이 크다 = 어떤 속성으로 분할할 때 불순도가 줄어든다
• 모든 속성에 대해 분할한 후 정보 이득 계산
• 정보 이득이 가장 큰 속성부터 분할

가지치기

• 가지치기를 하지 않으면 모델이 학습 데이터에는 매우 잘 맞지만, 평가 데이터에는 잘 맞지 않음
  • → 과대적합, 일반화되지 못함
• 여러 하이퍼파라미터 값을 조정해 가지치기 할 수 있음
  • max_depth, min_samples_leaf, min_samples_split 등
•  학습 데이터에 대한 성능은 낮아지나, 평가 데이터에 대한 성능을 높일 수 있음
• 가장 적절한 하이퍼파라미터 값을 찾도록 노력해야 함

max_depth ☆

• 트리의 최대 깊이(기본값: None)
• 기본값으로 설정하면 완벽히 분류될 때 까지 분할하거나, 노드가 갖는 샘플 개수가 min_samples_split 설 정 값 보다 작아질 때 까지 계속 분할
• 계속 분할되면 트리 깊이가 너무 깊어져 과적합이 발생할 수 있으니 적절한 값 설정 필요

min_samples_split ☆

• 노드를 분할하기 위한 최소한의 샘플 개수(기본값: 2)
• 값을 작게 설정할 수록 계속 분할되어 트리 깊이가 깊어져 과적합 발생 가능
• 적절한 값을 지정해 과적합을 방지할 필요가 있음

min_samples_leaf ☆

• 리프 노드가 되기 위한 최소한의 샘플 수(기본값: 1)
• min_samples_split과 함께 과적합을 방지할 목적으로 사용
• 불균형 클래스인 경우 이를 고려하여 작은 값을 설정할 필요가 있음

max_feature

• 최선의 분할을 위해 고려할 Feature 수(기본값: None)
• 기본값으로 설정하면 모든 Feature를 사용해서 분할 수행
• 정수형으로 선언하면 Feature 수, 실수형으로 선언하면 Feature 비율
• 'sqrt'로 선언하면 전체 Feature 수의 루트 값
• 'auto'로 설정하면 'sqrt'와 같은 의미
• 'log'로 선언하면 log2(전체 Feature 수

max_leaf_node

• 리프 노드 최대 개수

Logistic Regression

• 알고리즘은 분류모델에만 사용할 수 있음
• 알고리즘 함수: sklearn.linear_model.LogisticRegression
• 성능평가 함수: sklearn.metrics.confusion_matrix, sklearn.metrics.classification_report 등

로지스틱 함수

• 시그모이드(sigmoid) 함수라고도 부름
• 확률 값 𝑝 는 선형 판별식 값이 커지면 1, 작아지면 0에 가까운 값이 됨
• (-∞, ∞) 범위를 갖는 선형 판별식 결과로 (0, 1) 범위의 확률 값을 얻게 됨
• 기본적으로 확률 값 0.5를 임계값(Threshold)로 하여 이보다 크면 1, 아니면 0으로 분류함
• 𝑥 데이터가 주어졌을 때 확률을 예측하는 로지스틱 회귀분석은 학습 데이터를 잘 설명하는 선형 판별식의 기울기(𝑎)와 절편(𝑏)을 찾는 문제
• from sklearn.linear_model import LogisticRegression

K-Fold Cross Validation

• 모든 데이터가 평가에 한 번, 학습에 k-1번 사용
• K개의 분할(Fold)에 대한 성능을 예측 → 평균과 표준편차 계산 → 일반화 성능
• 단, k는 2 이상이 되어야 함(최소한 한 개씩의 학습용, 검증용 데이터가 필요)

장점

• 모든 데이터를 학습과 평가에 사용할 수 있음
• 반복 학습과 평가를 통해 정확도를 향상시킬 수 있음
• 데이터가 부족해서 발생하는 과소적합 문제를 방지할 수 있음
• 평가에 사용되는 데이터의 편향을 막을 수 있음 
• 좀 더 일반화된 모델을 만들 수 있음 

단점 

• 반복 횟수가 많아서 모델 학습과 평가에 많은 시간이 소요됨

Hyperparameter 튜닝

Random Search

1. 성능을 테스트할 파라미터 값의 범위를 지정(딕셔너리 형태)
2. 위 파라미터 값 범위를 모두 사용하는 Grid Search 모델 선언 후 학습
3. 학습 데이터에 대해 가장 좋은 성능을 보인 파라미터 값으로 자동으로 학습함
4. 이후 예측 및 평가 과정을 바로 진행하면 됨

# 함수 불러오기
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import RandomizedSearchCV

# 파라미터 선언
param = {'n_neighbors': range(1, 500, 10), 'metric': ['euclidean', 'manhattan']}
# 기본모델 선언
knn_model = KNeighborsClassifier()
# Random Search 선언
model = RandomizedSearchCV(knn_model, param, cv=3, n_iter=20)

# 학습하기
model.fit(x_train, y_train)
# 수행 정보
model.cv_results_
# 최적 파라미터
model.best_params_
# 최고 성능
model.best_score_

Grid Search

1. 성능을 테스트할 파라미터 값의 범위를 지정(딕셔너리 형태)
2. 위 파라미터 값 범위에서 몇 개 선택할 지 정하여 Random Search 모델 선언 후 학습
3. 학습 데이터에 대해 가장 좋은 성능을 보인 파라미터 값으로 자동으로 학습함
4. 이후 예측 및 평가 과정을 바로 진행하면 됨

# 함수 불러오기
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
# 파라미터 선언
param = {'n_neighbors': range(1, 500, 10), 'metric': ['euclidean', 'manhattan']}
# 기본모델 선언
knn_model = KNeighborsClassifier()
# Grid Search 선언
model = GridSearchCV(knn_model, param, cv=3)

회귀

• 비용 함수 : MSE(표준편차?)
• 마지막 노드에 있는 샘플들의 평균을 예측값으로 반환

앙상블(Ensemble)

여러 개의 모델을 결합하여 훨씬 강력한 모델을 생성하는 기법

보팅(Voting)

• 여러 모델들(다른 유형의 알고리즘 기반 )의 예측 결과를 투표를 통해 최종 예측 결과를 결정하는 방법
• 하드 보팅: 다수 모델이 예측한 값이 최종 결괏값
• 소프트 보팅: 모든 모델이 예측한 레이블 값의 결정 확률 평균을 구한 뒤 가장 확률이 높은 값을 최종 선택

배깅(Bagging)

• Bootstrap Aggregating의 약자
• 데이터로부터 부트스트랩 한 데이터로 모델들을 학습시킨 후, 모델들의 예측 결과를 집계해 최종 결과를 얻는 방법
• 같은 유형의 알고리즘 기반 모델들을 사용
• 데이터 분할 시 중복을 허용(복원 랜덤 샘플링 방식이라고 함)
• 범주형 데이터(Categorical Data)는 투표 방식(Voting)으로 결과를 집계
• 연속형 데이터(Continuous Data)는 평균으로 결과를 집계
• 대표적인 배깅 알고리즘: Random Forest
  •  

부스팅(Boosting)

• 같은 유형의 알고리즘 기반 모델 여러 개에 대해 순차적으로 학습을 수행
• 이전 모델이 제대로 예측하지 못한 데이터에 대해서 가중치를 부여하여 다음 모델이 학습과 예측을 진행하는 방법
• 계속하여 모델에게 가중치를 부스팅하며 학습을 진행해 부스팅 방식이라 함
• 예측 성능이 뛰어나 앙상블 학습을 주도함
• 배깅에 비해 성능이 좋지만, 속도가 느리고 과적합 발생 가능성이 있음 → 상황에 맞게 적절히 사용해야 함
• 대표적인 부스팅 알고리즘: XGBoost, LightGBM

스태킹(Stacking)

평가지표

성능평가

분류 모델 평가

• 분류 모델은 0인지 1인지를 예측하는 것
• 실제 값도 0과 1이고 예측 값도 0과 1임
• 하지만 0을 1로 예측하거나 1을 0으로 예측할 수 있음
• 예측 값이 실제 값과 많이 같을 수록 좋은 모델이라 할 수 있음  → 정확히 예측한 비율로 모델 성능을 평가

오분류표(Confusion Matrix)

• TN(True Negative, 진음성): 음성으로 잘 예측한 것(음성을 음성이라고 예측한 것)
• FP(False Positive, 위양성): 양성으로 잘 못 예측한 것(음성을 양성이라고 예측한 것)
• FN(False Negative, 위음성): 음성으로 잘 못 예측한 것(양성을 음성이라고 예측한 것)
• TP(True Positive, 진양성): 양성으로 잘 예측한 것(양성을 양성이라고 예측한 것)

정확도(Accuracy) - 1과 0을 정확히 예측한 비율

• 정분류율 이라고 부르기도 함

  

• 전체 중에서 Positive와 Negative 로 정확히 예측한(TN + TP) 비율 
• Negative를 Negative로 예측한 경우도 옳은 예측임을 고려하는 평가지표
• 가장 직관적으로 모델 성능을 확인할 수 있는 평가지표
• from sklearn.metrics import accuracy_score
• accuracy_score(y_test, y_pred)

정밀도(Precision) - 1이라 예측한 것 중에서 정말 1인 비율

• Positive로 예측한 것(FP + TP) 중에서 실제 Positive(TP)인 비율

  

• 예) 비가 내릴 것으로 예측한 날 중에서 실제 비가 내린 날의 비율
• 예) 암이라 예측한 환자 중에서 실제 암인 환자의 비율
• 정밀도가 낮을 경우 발생하는 상황
  • 비가 오지 않는데 비가 온다고 했으니 불필요한 우산을 챙기는 수고 발생
  • 암이 아닌데 암이라 했으니 불필요한 치료 발생
• from sklearn.metrics import precision_score
• precision_score(y_test, y_pred, average = None) - average는 생략가능 하지만 추천하지는 않음
  • average = [ 'binary' - 기본값 / 'macro' - 정밀도 평균 / 'weighted' - 정밀도 가중치 평균 ]

재현율(Recall) - 실제 1인 것을 1이라고 예측한 비율

• 실제 Positive(FN + TP) 중에서 Positive로 예측한(TP) 비율
• 민감도(Sensitivity)라고 부르는 경우가 많음 

  

• 예) 실제 비가 내린 날 중에서 비가 내릴 것으로 예측한 날의 비율
• 예) 실제 암인 환자 중에서 암이라고 예측한 환자의 비율
• 재현율이 낮을 경우 발생하는 문제
  • 비가 내리는 날 내리지 않을 것이라 했으니 우산을 챙기지 않아 비를 맞음
  • 암인 사람에게 암이 아니라 했으니 심각한 결과 초래
• from sklearn.metrics import recall_score
• recall_score(y_test, y_pred, average = None)

특이도(Specificity) - 실제 Negative(TN + FP) 중에서 Negative로 예측한(TN) 비율

• 예) 실제 비가 내리지 않은 날 중에서 비가 내리지 않을 것으로 예측한 날의 비율
• 예) 실제 암이 아닌 환자 중에서 암이 아니라고 예측한 환자의 비율
• 특이도가 낮을 경우 발생하는 문제
  • 비가 오지 않는데 비가 온다고 했으니 불필요한 우산을 챙기는 수고 발생
  • 암이 아닌데 암이라 했으니 불필요한 치료 발생

정밀도가 높으면 재현율이 낮을 수 있다.

F1-Score - 정밀도와 재현율의 조화 평균

• 분자가 같지만 분모가 다를 경우, 즉 관점이 다른 경우 조화 평균이 큰 의미를 가짐
• 정밀도와 재현율이 적절하게 요구 될 때 사용
• from sklearn.metrics import f1_score
• f1_score(y_test, y_pred, average = None)

이중 분류 성능 평가★

• from sklearn.metrics import classification_report, confusion_matrix
• confusion_matrix (y_test, y_pred) - 구조 확인 가능
• classification_report(y_test, y_pred) - 모든 지표를 확인 가능

분류모델 머신러닝 예제

선언 및 데이터 읽어오기

# 라이브러리 불러오기
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings

warnings.filterwarnings(action='ignore')
%config InlineBackend.figure_format = 'retina'

# 데이터 읽어오기
path = 'https://raw.githubusercontent.com/Jangrae/csv/master/admission_simple.csv'
data = pd.read_csv(path)

데이터 확인

• data.head()
• data.tail()
• data.info()
• data.describe()
• data.corr(numeric_only=True).style.background_gradient()

x와 y 분리

# target 확인
target = 'ADMIT'

# 데이터 분리
x = data.drop(target, axis=1)
y = data.loc[:, target]

# 모듈 불러오기
from sklearn.model_selection import train_test_split

# 7:3으로 분리
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=1 )

모델링

# 1단계: 불러오기
from sklearn.neighbors import KNeighborsClassifier

# 2단계: 선언하기
model = KNeighborsClassifier()

# 3단계: 학습하기
model.fit(x_train, y_train)

# 4단계: 예측하기
y_pred = model.predict(x_test)

분류 성능 평가

# 모듈 불러오기
from sklearn.metrics import confusion_matrix

# 성능 평가
print(confusion_matrix(y_test, y_pred))

plt.figure(figsize = (5, 2))
sns.heatmap(confusion_matrix(y_test, y_pred),
           annot = True, cbar = False, cmap = 'Purples',
           annot_kws = {'size' : 16})

plt.show()

# 모듈 불러오기
from sklearn.metrics import classification_report

# 성능 평가
print(classification_report(y_test, y_pred))

• Accuracy
  • from sklearn.metrics import accuracy_score
  • print('정확도(Accuracy) =', accuracy_score(y_test, y_pred))
• Precision  
  • from sklearn.metrics import precision_score
  • print('정밀도(Precision) =', precision_score(y_test, y_pred, average = None)) # 권고  

• Recall
  • from sklearn.metrics import recall_score
  • print('재현율(Recall) =', recall_score(y_test, y_pred, average = None)
• F1-Score
  • from sklearn.metrics import f1_score
  • print('F1_score) =', f1_score(y_test, y_pred, average = None))

회귀 모델 평가

• 회귀 모델이 정확한 값을 예측하기는 사실상 어려움
• 예측 값과 실제 값에 차이(=오차)가 존재할 것이라 예상
• 예측 값이 실제 값에 가까울 수록 좋은 모델이라 할 수 있음 → 예측한 값과 실제 값의 차이(=오차)로 모델 성능을 평가

𝑦 : 실젯값

• 우리가 실제로 예측하고 싶은 값, Target, 목푯값
• 실제값과 비교해 모델의 성능을 평가
• 우리가 관심을 갖는 오차는 이 값과 예측값의 차이

ȳ : 평균값

• 이미 알고 있는, 이미 존재하고 있는 평균으로 예측한 값
• 최소한 이 평균값 보다는 실젯값에 가까운 예측값을 원함
• 우리 모델의 예측값이 평균값보다 오차를 얼마나 더 줄였는지 확인

y^ : 예측값

• 우리 모델로 새롭게 예측한 값
• 이 예측값이 얼마나 정확한지 알고 싶은 상황
• 최소한, 평균값 보다는 좋아야 의미가 있음
• 우리 모델이 평균값보다 얼마나 잘 예측했을지 검증

오차 합 구하기

오차 제곱의 합

• SSE(Sum Squared Error) - 제곱해서 더함
• MSE(Mean squared Error) - 제곱해서 더한것을 n(행수)으로 나눔 / 손실함수
• RMSE(Root MSE) - MSE에 루트를 씌움 

오차 절대값의 합

• MAE(Mean Absolute Error) - 오차의 절대값으로 더하고 n으로 나눔
• MAPE(Mean Absolute Percentage Error) - 절대값의 합을 y로 나누어 퍼센테이지로 구함

• SST(Sum Squared Total) - 전체 오차(최소한 평균 보다는 성능이 좋아야 하니, 우리에게 허용된(?) 오차)
  • 실제값과 평균값의 오차를 제곱
• SSR(Sum Squared Regression) - 전체 오차 중에서 회귀식이 잡아낸 오차 (우리가 해결한 것 / 클수록 좋음)
  • 예측값과 평균값의 오차를 제곱
• SSE(Sum Squared Error) - 전체 오차 중에서 회귀식이 여전히 잡아내지 못한 오차
  • 예측값과 실제값의 오차를 제곱
• SST = SSR + SSE

결정계수 R^2 (R-Squared)

• 모델 성능을 잘 해석하기 위해서 만든 MSE의 표준화된 버전이 결정 계수
• 전체 오차 중에서 회귀식이 잡아낸 오차 비율(일반적으로 0 ~ 1 사이)
• 오차의 비 또는 설명력이라고도 부름
• 𝑅 2 = 1이면 𝑀𝑆𝐸 = 0이고 모델이 데이터를 완벽하게 학습한 것

회귀모델 머신러닝 예제

선언 및 데이터 읽어오기

# 라이브러리 불러오기
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings

warnings.filterwarnings(action='ignore')
%config InlineBackend.figure_format = 'retina'

# 데이터 읽어오기
path = 'https://raw.githubusercontent.com/Jangrae/csv/master/airquality_simple.csv'
data = pd.read_csv(path)

데이터 확인

• data.head()
• data.tail()
• data.info()
• data.describe()
• data.corr(numeric_only=True).style.background_gradient()

전처리 - 결측치 처리, 변수 제

# 결측치 확인
data.isnull().sum()

Ozone      0
Solar.R    7
Wind       0
Temp       0
Month      0
Day        0
dtype: int64

# 전날 값으로 결측치 채우기
#data.fillna(method='ffill', inplace=True)
data.ffill(inplace = True)
# 확인
data.isnull().sum()

Ozone      0
Solar.R    0
Wind       0
Temp       0
Month      0
Day        0
dtype: int64

# 변수 제거
drop_cols = ['Month', 'Day']
# data.drop(drop_cols, axis=1, inplace=True)
data.drop(columns = drop_cols, inplace=True)
# 확인
data.head(1)

x와 y 분리

# target 확인
target = 'Ozone'

# 데이터 분리
x = data.drop(target, axis=1)
y = data.loc[:, target]

# 모듈 불러오기
from sklearn.model_selection import train_test_split

# 7:3으로 분리
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=1)
# stratify=y를 활용하면 일정한 기준으로 나뉘어진 y값으로 분리됨

• stratify=y를 활용하면 일정한 기준으로 나뉘어진 y값으로 분리됨

모델링

# 1단계: 불러오기
from sklearn.linear_model import LinearRegression

# 2단계: 선언하기
model = LinearRegression()

# 3단계: 학습하기
model.fit(x_train, y_train)

# 4단계: 예측하기
y_pred = model.predict(x_test)

회귀 성능 평가

# 모듈 불러오기
from sklearn.metrics import mean_absolute_error

# 성능 평가
print('MAE =', mean_absolute_error(y_test, y_pred))

MAE = 13.976843190385708

• MAE(Mean Absolute Error)
  • from sklearn.metrics import mean_absolute_error
  • print('MAE =', mean_absolute_error(y_test, y_pred))
• MSE(Mean Squared Error)
  • from sklearn.metrics import mean_squared_error
  • print('MSE =', mean_squared_error(y_test, y_pred))
• RMSE(Root Mean Squared Error)  
  • from sklearn.metrics import root_mean_squared_error
  • print('RMSE =', root_mean_squared_error(y_test, y_pred))
• MAPE(Mean Absolute Percentage Error)
  • from sklearn.metrics import mean_absolute_percentage_error
  • print('MAPE =', mean_absolute_percentage_error(y_test, y_pred))
• R2-Score
  • from sklearn.metrics import r2_score
  • print('R2 =', r2_score(y_test, y_pred))

리스트 안에 찾는 수가 있으면 몇 번째에 있는지 출력

없다면 -1 출력하는 문제였다.

try / except 문을 활용하여 풀었다.

n, target = map(int, input().split())
L = list(map(int, input().split()))

try:
    print(L.index(target)+1)
except:
    print(-1)

중앙값에 도달하는지 확인하고 원래 받은 데이터에서 찾아서 출력

n = int(input())  
apart = [] 
check = []

for i in range(n):
    x, y = map(int, input().split())
    apart.append((x, y))      
    check.append(y)

apart.sort()

peple = sum(a[1] for a in apart)
count = 0  


for i in range(n):
    count += apart[i][1] 
    if count >= peple / 2:  
        print(check.index(apart[i][1]) + 1)  
        break

코드해설

n = int(input())  # 아파트 단지 수 입력
apart = []   # 아파트 위치와 거주 인구를 저장할 리스트
check = []

# 아파트 위치와 거주 인구 입력 받기
for i in range(n):
    x, y = map(int, input().split())  # x: 아파트 위치, y: 아파트에 거주하는 사람 수
    apart.append((x, y))         # (위치, 거주 인구) 쌍으로 리스트에 추가
    check.append(y)
# 아파트 위치를 기준으로 정렬 (번호가 작은 아파트를 먼저 고려해야 하므로 위치를 기준으로 정렬)
apart.sort()
print(apart)
# 전체 인구의 절반을 넘는 순간을 찾기 위한 준비
peple = sum(a[1] for a in apart)  # 전체 거주 인구의 합
count = 0  # 누적 인구

# 아파트 단지를 순차적으로 보면서 중앙값에 해당하는 단지 찾기
for i in range(n):
    count += apart[i][1]  # 현재 아파트까지의 누적 인구 수 계산
    if count >= peple / 2:  # 누적 인구가 절반을 넘으면 해당 아파트가 중앙값
        print(check.index(apart[i][1]) + 1)  # 아파트 단지는 1번부터 시작하므로 i+1을 출력
        break

카드를 위 아래로 선택해 하나를 뺐을때 모든 카드를 순서대로 낼 수 있는지 확인하는 문제

n = int(input())
card = list(map(int, input().split()))
count = 1
check = True
while (len(card) > 0):
    if(card[0] == count):
        card.pop(0)
    elif(card[-1] == count):
        card.pop()
    else:
        check = False
        break
    
if check:
    print('YES')
else:
    print('NO')

이렇게 풀이했는데 완전히 연속되는 숫자가 아닌지 실패했다.

n = int(input())
card = list(map(int, input().split()))

check = True
while (len(card) > 0):
    if(card[0] == min(card)):
        card.pop(0)
    elif(card[-1] == min(card)):
        card.pop()
    else:
        check = False
        break
    
if check:
    print('YES')
else:
    print('NO')

가장 작은 카드를 비교하는거로 해결했다.

머신러닝 개념과 관련 용어

머신러닝 이해

인간의 개념은 머신의 데이터이다.

우리가 일정한 패턴을 통해 스스로 학습하는 과정을 컴퓨터에 적용했다고 비유할 수 있다.

간단한 패턴이라면 사람의 두뇌로 해결할 수 있지만, 복잡한 패턴을 일일히 분석하는건 힘들고 비효율적인 일이다.

문제 해결 순서

• 문제의 유형을 파악 > 알고리즘과 평가 방법을 선택 > 관련 함수를 사용해 모델링

지도학습

• 학습 대상이 되는 데이터에 정답을 준다.
• 규칙성, 즉 데이터의 패턴을 배우게 하는 학습 방법이다.
• 분류문제
  • 적절히 분류된 데이터를 학습하여 분류 규칙을 찾는다.
  • 규칙을 기반으로 새롭게 주어진 데이터를 적절히 분류하는것이 목적이다.
  • 범주형 자료
  • A일까? B일까 고민하는 문제
• 회귀문제
  
  • 결과값이 있는 데이터를 학습하여 입력 값과 결과 값의 연관성을 찾는다.
  • 연관성을 기반으로 새롭게 주어진 데이터에 대한 값을 예측하는것이 목적이다.
  • 숫자형 자료 - 연속적인 숫자 예측
    • 두 값 사이에 중간값이 의미가 있는가?
    • 두 값에 대한 연산 결과가 의미있는 숫자인가?
  • 얼마나 많이? 라고 질문을 던질 수 있는 문제

비지도 학습

• 정답이 없는 데이터 만으로 배우게 하는 학습 방법
• 클러스터링
  • 데이터를 학습하여 적절한 분류 규칙을 찾아 데이터를 분류하는 것이 목적.
  • 정답이 없으니 성능을 평가하기 어렵다.
• 군집화 - 비슷한것을 그룹으로 묶음
• 변환 - 쉽게 이해할 수 있는 형태로 데이터 표현
• 연관 - 서로 연관된 특징을 찾음

강화 학습

• 선택한 결과에 배해 보상을 받아 행동을 개선하면서 배우게 하는 학습 방법

용어정리

모델(model)

• 데이터로부터 패턴을 찾아 수학식으로 정리해 놓는것
• 모델링(Modeling): 오차가 적은 모델을 만드는 과정

모델의 목적( 모델을 만드는 과정 -> 모델링)

• 샘플을 가지고 전체를 추정
  • 샘플: 표본, 부분집합, 일부, 과거의 데이터
  • 전체: 모집단, 전체집합, 현재와 미래의 데이터
  • 추정: 예측, 추론

독립변수(원인), 종속변수(결과)

• x값이 변함에 따라 y값이 변한다. 라고 할때
• 독립변수를 x, 종속변수를 y로 표시함 ex) y = ax + b

평균과 오차

• 통계학에서 사용되는 가장 단순한 모델 중 하나가 평균이다.
• 관측값(=실젯값)과 모델 예측값의 차이: 이탈도(Deviance) → 오차
• 범주에서는 최빈값(가장 많이 나온 값)으로 예측할 수 있다.

데이터 분리

• 데이터 셋을 학습용 검증용 평가용 데이터로 분리함
• 실전에서 평가용 데이터는 별도로 제공되는 데이터일 경우가 많다.
• 검증용 데이터로 평가 전에 모델 성능을 검증해 볼 수 있다.(튜닝시 사용)
• x(독립변수)와 y(종속변수)를 분리 - DF의 열을 분리 : DF.drop(열이름, axis = 1) / DF.loc[ ]
• 학습용, 편가용 분리 - DF의 행을 분리 : train_test_split(x, y, test_size = float) : size의 최대크기는 1

과대적합과 과소적합

• 과대적합(Overfitting)
  • 학습 데이터에 대해서는 성능이 매우 좋은데, 평가 데이터에 대해서는 성능이 매우 좋지 않은 경우
  • 학습 데이터에 대해서만 잘 맞는 모델 → 실전에서 예측 성능이 좋지 않음
• 과소적합(Underfitting)
  • 학습 데이터보다 평가 데이터에 대한 성능이 매우 좋거나, 모든 데이터에 대한 성능이 매우 안 좋은 경우
  • 모델이 너무 단순하여 학습 데이터에 대해 적절히 훈련되지 않은 경우

모델링 코드 구조

Scikit-Learn(사이킷런)

불러오기 - 사용할 알고리즘과 평가를 위한 함수 import

1. 알고리즘

• from sklearn.linear_model import LinearRegression - 회귀
• from sklearn.neighbors import KNeighborsClassifier - 분류 (0, 1로 분류)
• from sklearn.tree import DecisionTreeClassifier - 분류 (str 형태의 분류)

2. 평가 

• from sklearn.metrics import mean_absolute_error -  회귀  
• from sklearn.metrics import accuracy_score - 분류 
  

3. 선언하기 - 사용할 알고리즘용 함수로 모델 선언

• model = LinearRegression()  -  회귀
• model =  KNeighborsClassifier() - 분류 
• model =  DecisionTreeClassifier() - 분류 

4. 학습하기 - 모델.fit(x_train, y_train) 형태로 모델 학습 시키기

• model.fit(x_train, y_train)

5. 예측하기 - 모델.predict(x_test) 형태로 예측한 결과 변수로 저장

• y_pred = model.predict(x_test)

6. 평가하기 - 실젯값과 예측값을 평가 함수에 전달해 성능 평가

• mean_absolute_error( y_test, y_pred )
• mean_absolute_error( y_test, y_mean )
  • y_mean = [ y_train.mean() ] * len(y_test) - 평균값으로 Base Model을 만들어 기본오차를 구함 -회귀
• mean_absolute_error( y_test, y_freq )
  
  • y_freq = [ y_train.mode()[0] ] * len(y_test) - 최빈값으로 Base Model을 만들어 기본오차를 구함 -분류

모델링 예제

자료준비

# 라이브러리 불러오기
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings

warnings.filterwarnings(action='ignore')
%config InlineBackend.figure_format = 'retina'

# 데이터 읽어오기
path = 'https://raw.githubusercontent.com/Jangrae/csv/master/airquality_simple.csv'
data = pd.read_csv(path)

데이터 구조 확인

data.tail(2)

변수확인 - Solar.R에 결측치가 존재함을 확인

# 변수 확인 #결측치 확인 Solar.R
data.info()

통계 확인

# 기술통계 확인
data.describe().T

상관 관계 분석 및 시각화

# 상관관계 확인
data.corr(numeric_only = True).style.background_gradient()

# 상관관계 시각화 Purples
sns.heatmap(data.corr(numeric_only = True), 
            annot = True, cmap = 'Blues', 
            cbar = False, square = True,
           fmt = '.3f', annot_kws = {'size' : 8})
plt.yticks(rotation = 0) #y측 
plt.show()

데이터 전처리

결측치 처리

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

# 위에값으로 결측치 채우기 / 아래값, bfill()
data['Solar.R'] = data['Solar.R'].ffill()
# data.ffill(inplace = True)

# 확인
data.isna().sum()

변수 제거

# 분석에 의미 없는변수 제거
drop_cols = ['Month', 'Day']
data.drop(columns = drop_cols, inplace = True)
# 확인
data.head(1)

x, y, 분리

알아내고자 하는것 = target = 오존 농도

# target 확인
target = 'Ozone'

# 데이터 분리
x = data.drop(target, axis = 1) #( columns = target)
y = data.loc[ :, target] #data['Ozone']

머신러닝을 위한 변수 생성

# 모듈 불러오기
from sklearn.model_selection import train_test_split

# 7:3으로 분리 중요함!!!
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state = 1)
#random_state = n 으로 같은 random값을 준다면 같은 결과를 줌 seed와 같은 원리
#만약 회귀가 아닌 분류라면stratify = y 를 활용하여 일정한 데이터로 분리

모델링

# 1단계: 불러오기
from sklearn.linear_model import LinearRegression #회귀
from sklearn.metrics import mean_absolute_error

# 2단계: 선언하기
model = LinearRegression()

# 3단계: 학습하기
model.fit(x_train, y_train)

# 4단계: 예측하기
y_pred = model.predict(x_test)

# 5단계: 평가하기
mean_absolute_error(y_test, y_pred)

13.976843190385708

예측값과 실제값 비교 / 시각화

# 예측값과 실젯값 시각화 비교

print('실제값 :',y_test.values[:10])
print('예측값 :',y_pred[:10])

실제값 : [24 18 97 47 34 22 66 18 69 27]
예측값 : [13.84003067  5.82919112 81.93563027 58.41267418 50.86150737 31.52971121
 66.8083547  -8.56411529 50.2136544  39.13346172]

기본모델 오차와 비교

#기본 모델(Base Model) 오차
# 평가 데이터 행수 만큼 평균값 준비
y_mean = [y_train.mean()] * len(y_test)
print("MAE = ", mean_absolute_error(y_test, y_mean))

plot

plt.figure(figsize = (14, 4))
plt.plot(y_test.values, label = 'Actual')
plt.plot(y_pred, label = 'Predicted')
#plt.legend(['Actual', 'Predicted'])
plt.legend()
plt.show()

Graphvis

그래프를 좀더 시각적으로 좋게 볼 수 있다.

Graphvis > Downlod > 각자 환경에 맞는 버전 선택 > 기본 설정으로 설치 

설치 후 설정

내pc > 속성 > 고급시스템 설정

환경변서 > path > 편집 > 찾아보기

C드라이브 > Program Files >  Graphviz > bin 선택후 확인

시스템 변수도 마찬자기로 진행 > 재부팅

숫자형 변수

기초 통계량

• 평균(mean)
• 중앙값(median)
• 최빈값(mode)
• 사분위수(Quantile)
  • 데이터를 정렬(오름차순)
  • 전체를 4등분하고 각 분위는 결계의 값( 25%, 50%, 75%) 을 의미
  • ( 25%, 50%, 75%) 를 각각 1사분위수, 2사분위수, 3사분위수 라고 부름
  • DF.describe()를 통해 전체적으로 파악 가능
• Box plot을 활용하여 데이터 분석 가능
• Box Plot
  • plt.boxplot( DF['열 이름'] )
  • vert = 횡(False), 종(True, 기본값)
  • 사전에 반드시 NaN을 제외(sns.boxplot 은 NaN을 알아서 제거해 줌)
  • 수염 - 박스 -수염 의 형태를 가지고 있다.
  • 사분위수를 확인 가능
  • IQR > Q1(1사분위수) 에서 Q3(3사분위수) 까지의 길
  • 1.5*IQR 범위 이내의 최소, 최대값으로 결정

도수분포 (frequency table)

• Histogram
  • plt.hist(DF.열이름, bins = 구간 수) / plt.hist(x = 열이름, data = DF, bins = 구간 수) - 그림1
  • edgecolor = bar의 윤곽선을 색으로 표시 ex) 'gray'
  • x, y 라벨이 없음으로 직접 지정
  • plt.xlabel('str') / plt.ylabel('str')
  • 밀집구간과 희박구간을 확인하고 비즈니스 의미를 파악
  • 단점 - 구간(bin)의 너비에 따라 모양이 달라지며 의미가 다르게 해석
  • sns.histplot(DF['열 이름'], bins = 구간수)
    • kde = True로 설정하면 kde도 같이 출력 - 그림2

• Density plot(KDE)
  • sns.kdeplot(DF['열 이름'])
  • 데이터의 밀도 추정 - 측정된(관측된) 데이터로부터 전체 데이터 분포의 특성을 추정
  • 면적으로 구간에 대한 확률 추정

범주형 변수

범주형 데이터는 법주별 빈도수 / 범주별 비율 등으로 데이터를 가공해야된다.

• 범주별 빈도수  - DF['열 이름'].value_counts() / 시리즈.value_counts()
• 범주별 비율  - DF['열 이름'].value_counts(normalize = True) 
• sns.countplot( DF['열 이름'] )
  • 알아서 범주 별 빈도수가 계산되고  bar plot으로 그려짐.
  • plt.bar( DF['열 이름'] )를 활용하려변 직접 범주별 빈도수를 계산해야 됨

• plt.pie(시리즈.values, labels = 시리즈.index , autopct = '%/2f%%')  -  시리즈의 values, index를 기준으로한 원형 차트 생성, autopct = '%/2f%%'는 소수점 2자리까지 나타내게 함.
  • 시리즈 = DF['열 이름']
  • startangle = n :  차트를 n도 회전
  • counterclock = True/False : False = 시계 방향으로
  • explode = [0.05, 0.05, 0.05] : 중심으로 부터 각 차트요소(n개)를 얼마만큼 띄울지 지정
  • shadow = True : 그림자 추가

처음 n(인원수)를 입력받고

이름과, iq를 입력받는다.

iq가 높은순으로 3명 출력한다. 단, iq가 같으면 먼저 측정한 사람을 출력한다.

dict을 활용해서 풀려했지만 잘 되지 않아 리스트의 index를 찾아 해결하였다.

<망한코드>

n = int(input())
L = []
for i in range(n):
    L.append(list(input().split()))
    
    
dict_L = dict(L)
print('dict_L', dict_L)
sorted_dict = sorted(dict_L.items(), key = lambda a : a[1] , reverse = True)
print('sorted_dict', sorted_dict)

for i in range(3):
    print(list(sorted_dict[i])[0])

<문제 해결>

n = int(input())
L = []
name = []
iq = []
for i in range(n):
    a, b = input().split()
    name.append(a)
    iq.append(int(b))

for i in range(3):
    max_index = iq.index(max(iq))
    print(name[max_index])
    name.pop(max_index)
    iq.pop(max_index)