3일차: KNN 분류 학습

3일차 요약

• 오전
  - 넘파이 관련 공부
  • 머신 러닝 개요
• 오후
  - 머신 러닝 개념 공부

Numpy

1. Numpy 배열

• 넘파이 배열은 ndarray 객체로 되어 있음
• 넘파이 배열은 각 요소가 모두 같은 데이터타입을 가져야 함
• 그래서 넘파이 배열의 타입이 바꼈다면 하나의 원소로 인해 바뀔 가능성이 있음 -> 이상치 탐지 가능

arr = [1,2,3,4,5]
a = np.array(arr)

2. 배열 생성 함수

• arange() 함수

arr = np.arange(12) # list의 range와 같은 의미
arr = arr.reshape(3,4)

# 0으로 초기화 하는 방법
np.zeros(3)
np.zeros(arr)

# 1로 초기화 하는 방법
np.ones(3)
np.ones_like(arr)

3. 차원 변환

• reshape()

a = np.arange(12)
a = a.reshape(3,4)

# 값을 다시 1차원 벡터로 만들기 위해
a.reshape(12)
a.reshape(-1)
a.reshape(3,-1) # 앞에 3개로 끊어서 reshape 해줘
a.reshape(3,4,-1)

4. 범용함수

• argmax(), argmin() 등 다양한 범용 함수가 있음

# argmax()
a = np.array([1,4,4,5,234])
a.argmax()

5. 인덱싱(indexing), 슬라이싱(slicing)

• 인덱싱을 하면 차원이 줄어든다.
• 슬라이싱은 차원이 보존된다.

a = np.arange(12).reshape(3,-1)

# fancy indexing
a[[0,2]]

# boolean indexing
a = np.arange(5)
idx = [True, False, False, True, False]
a[idx]

6. 브로드캐스팅(Broad Casting)

a =np.array([3,4,5])
a+1

x = np.arange(6).reshape(3,2)
y = np.arange(6).reshape(2,3)
z = np.array([1,2,3])

x + z -> 안 됨
y + z -> 됨

7. 배열 합치기

• stack: 축이 증가함(axis 갯수가 증가함)
  - 여러 장의 이미지를 쌓으려면 stack을 써야 함
• concatenate: 축이 유지됨(axis 갯수가 유지)

X = np.array([[1,1],[2,2]])
Y = np.array([[3,3],[4,4]])

np.concatenate((X,Y), axis = 1)
np.stack((X,Y))

머신 러닝 개요

머신 러닝을 사용할 수 있는 경우

1. 데이터를 구할 수 있어야 한다.
2. 데이터에 우리가 관심을 가지는 규칙이 있다고 판단될 때
3. 기존의 명시적인 프로그래밍 방법으로는 해결 방법이 없는 복잡한 문제

데이터

• 비정형, 반정형, 정형 데이터

지도학습, 비지도학습, 강화학습

1. 지도학습
   • 회귀
   • 분류
2. 비지도 학습
   • 클러스터링
3. 강화학습

좋은 모델이란

• 훈련 데이터에서만 강한 게 아니라 새로운 데이터가 들어왔을 때도 잘 예측하는 것(== 일반화, generalization)

실습: knn을 활용하여 orange, grapefruit 분류하기

• 환경: colab

1. 데이터 세트 준비

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
!wget https://raw.githubusercontent.com/devdio/datasets/main/citrus.csv
citrus = pd.read_csv('./citrus.csv')

2. train, test 데이터 분리

# 데이터 섞기
df = df.sample(frac=1)

# 테스트 데이터 분리(dataframe 슬라이싱 기능 이용)
X = df[['diameter', 'weight','red','green','blue']]
y = df['name']

X_trian = X[:int(len(X)*0.8)]
X_Test = X[int(len(X)*0.8):]
y_train = y[:int(len(X)*0.8)]
y_test = y[int(len(X)*0.8):]

print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

• 내가 짠 코드

# 내가 짠 코드

from sklearn.model_selection import train_test_split
X = df[['diameter', 'weight','red','green','blue']]
y = df['name']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=True, random_state=1004)

3. 데이터 전처리

# 평균: z-score로 스케일링
def z_score_scaling(df):
  X_train = df
  mu_dict= {}
  std_dict = {}
  for idx in X_train.columns:
    mu_dict[idx] = X_train[idx].mean()
    std_dict[idx] = X_train[idx].std()
    X_train[idx] = (X_train[idx]-mu_dict[idx])/std_dict[idx]
  return X_train
  
label = {'orange':1, 'grapefruit':0}
y_train = y_train.map(label)

4. 학습:knn 알고리즘

from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=5, weights='distance',metric='euclidean')
knn.fit(X_train.values, y_train.values)

5. 평가

X_test = z_score_scaling(X_test)
y_test = y_test.map(label)
y_pred = knn.predict(X_test.values)
np,sum(y_pred == y_test)/len(y_test) # 정확도 계산

# 오차행렬
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred) # 정답, 예측값 순서대로 넣어야 함
s = sns.heatmap(cm, annot=True, cmap = 'Blues', fmt='d', cbar=False)
s.set(xlabel='Prediction', ylabel='Actual')
plt.show()

# 평가지표로 평가
from sklearn.metrics import accuracy_score, recall_score, precision_score, f1_score
acc = accuracy_score(y_test,y_pred)
recall = recall_score(y_test,y_pred)
precision = precision_score(y_test,y_pred)
f1 = f1_score(y_test,y_pred)
print(f'accuracy: {acc}')
print(f'recall: {recall}')
print(f'precision: {precision}')
print(f'f1 score: {f1}')

6. 모델 튜닝

from tqdm import tqdm
score = []

for k in tqdm(range(3, 100)):
  knn = KNeighborsClassifier(n_neighbors = k)
  knn.fit(X_train.values, y_train.values)
  y_pred = knn.predict(X_test.values)
  acc = accuracy_score(y_test, y_pred)
  score.append(acc)

plt.plot(range(3,100), score)
plt.show()

# k가 n일 때 베스트라고 하면, n으로 재학습
bestk = np.array(score).argmax() + 4
best_knn = KNeighborsClassifier(n_neighbors = bestk)
best_knn = best_knn.fit(X_train.values, y_train.values)