1. 이진분류(binary classification)
2. 다중분류(multinomial classification)

• 위의 그림처럼 독립변수 1개인 직선을 그려 이중으로 분류를 할 수 있다.
• 이진분류를 확장하여 다중분류를 실행할 수 있다.
• Logistic Regression으로 예를 들어 구현해보자.
• 위의 예는 성적, 출석, 학점이 있는 데이터이다.
• 빨간선은 hyperplane으로 초평면을 말합니다.
• 초평면은 P차원 공간속에서 평면을 일반화하여 P-1차원으로 보는 부분공간입니다.
• 파란선과 보라선 성적과 출석에 대한 선형 회귀선입니다.
• 우리가 알고싶어하는 점은 성적은 C보다는 높고, B와는 비슷하고, A보다는 낮습니다. 출석은 C와는 비슷하고 B보다는 출석률이 높고, A보다는 낮습니다.
• 이때 우리 목표는 검은점이 받을 성적은 무엇인가를 예측하는 것입니다.
• 위의 식은 기존 이진분류에서 다중분류로 넘어와서 독립변수 한개가 추가 되어 생성된 식입니다.

로지스틱 회귀 실습

• kaggle을 이용한다.

  유방암 데이터로 실습하기

  1. 필요한 module import

  import numpy as np
  import pandas as pd
  import matplotlib.pyplot as plt
  from sklearn.datasets import load_breast_cancer
  from sklearn.preprocessing import MinMaxScaler
  from sklearn.model_selection import train_test_split
  from sklearn import linear_model
  from sklearn.model_selection import cross_val_score
  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import Flatten, Dense
  from tensorflow.keras.optimizers import Adam

2. 데이터 로드 및 전처리

# Imbalanced Data Problem을 해결해 보아요!
# SMOTE 알고리즘을 이용해 보아요!

# 불균형한 데이터가 있어야 해요!
# 유방암 예측 데이터셋으로 해 보아요!

# Raw Data Loading
cancer = load_breast_cancer()
# x_data(feature), t_data(0, 1), 데이터의 설명, .....

# x_data => cancer.data
# t_data => cancer.target

print(cancer.data.shape, cancer.target.shape)
# (569, 30) => x_data는 총 569개의 행으로 구성, 컬럼(feature)은 30개
# (569,) => t_data 역시 총 569개 있어요. 0과 1로 구성되어 있어요!

print(np.unique(cancer.target, return_counts=True))
# (array([0, 1]), array([212, 357]))
#                        0.37, 0.63
# 0은 악성종양(나쁜거), 1은 양성종양(괜찮은거)
# 약간의 데이터 불균형이 존재.(imbalanced data)

# 데이터셋 저장
x_data = cancer.data
t_data = cancer.target

# boxplot을 이용해서 이상치와 데이터 분포를 간단하게 확인!
# plt.boxplot(x_data)
# plt.show()

# 데이터 정규화가 필요해요!
# 원래 정규화는 당연히 이상치를 제거하고 진행하는게 맞아요!
# 실제적인 이상치는 존재하지 않는다고 가정하고 진행!
scaler = MinMaxScaler()
scaler.fit(x_data)
x_data_norm = scaler.transform(x_data)

# 데이터를 분리해야 해요! 학습용과 평가용으로 분리
# train data와 test data로 분리(데이터를 섞어서 분리)
x_data_train_norm, x_data_test_norm, t_data_train, t_data_test = \
train_test_split(x_data_norm,
                 t_data,
                 stratify=t_data,
                 test_size=0.2,   # default값은 0.25
                 random_state=3)

# 섞어서 분리했기 때문에 데이터의 편향이 없을거라 생각되는데
# 확인은 해야 겠죠.
np.unique(t_data_test, return_counts=True )
# (array([0, 1]), array([42, 75]))  # 35% , 65%

3. sklearn, Tensorflow 구현

sklearn

# sklearn model 구현

sklearn_model = linear_model.LogisticRegression()

# 학습하기 전에 cross validation을 한번 수행해 볼꺼예요!
# train data를 가지고 수행해요!
score = cross_val_score(sklearn_model,
                        x_data_train_norm,
                        t_data_train,
                        cv=5)
print(score)
# [0.97802198 0.94505495 0.95604396 0.98901099 0.94505495]

print(f'sklearn의 평균 validation accuracy : {np.mean(score)}')
# 0.9626373626373625

# 학습진행
sklearn_model.fit(x_data_train_norm,
                  t_data_train)

# 모델최종평가
test_score = sklearn_model.score(x_data_test_norm,
                                 t_data_test)
print(f'모델의 최종 score : {test_score}')  # 0.9649

Tensorflow

# Tensorflow 구현

keras_model = Sequential()

keras_model.add(Flatten(input_shape=(30,)))
keras_model.add(Dense(units=1,
                      activation='sigmoid'))

# 학습할 때 매 epoch마다 validation을 수행하고
# validation의 평가 기준은 accuracy를 사용하겠어요!
keras_model.compile(optimizer=Adam(learning_rate=1e-1),
                    loss='binary_crossentropy',
                    metrics=['acc'])

keras_model.fit(x_data_train_norm,
                t_data_train,
                epochs=300,
                verbose=1,
                validation_split=0.2)

# Epoch 300/300
# 12/12 [==============================] - 0s 6ms/step 
# - loss: 0.0437 - acc: 0.9890 - val_loss: 0.1034 - val_acc: 0.9560
# training data로 학습한 후
# training data로 평가 vs. validation data로 평가

# loss : training data로 학습한 후 training data를 이용해서 계산한 loss
# val_loss : validation data로 계산한 loss

# 학습이 다 끝났어요!
# Evaluation(평가)
result = keras_model.evaluate(x_data_test_norm,
                              t_data_test)
print(result)
#       loss값             accuracy값
# [0.1397516131401062, 0.9649122953414917]

타이타닉 데이터

1. 필요한 module import

# Titanic data를 이용한 Logistic Regression 구현
# Kaggle에 있는 데이터를 이용.
# Kaggle에 있는 데이터를 전처리 한 후
# 모델을 만들어서 학습을 진행
# 자체 평가를 진행(validation)
# 모델을 이용해서 예측값을 추출(test.csv)
# 예측된 결과를 kaggle에 upload해서 우리 모델의 성능을 검증.

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import Adam

2. 데이터 로드 및 전처리

# Raw Data Loading
df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/titanic/train.csv')

# display(df)  # 891 rows × 12 columns

# 데이터 전처리!(feature engineering)
train = df

# 사용하는 coulmn만 추출. 사용되지 않는(불필요한) column을 삭제
# print(train.columns)
# 필요없는 컬럼은(종속변수에 영향을 주지 않거나 의미상 중복 컬럼)
train.drop(['PassengerId', 'Ticket', 'Name', 'Fare', 'Cabin'],
           axis=1,
           inplace=True)
# display(df)

# 성별처리 (male:0, female:1)
gender_mapping = {'male': 0,
                  'female': 1}
train['Sex'] = train['Sex'].map(gender_mapping)


train['Family'] = train['SibSp'] + train['Parch']

train.drop(['SibSp', 'Parch'],
           axis=1,
           inplace=True)
# df.info()

# Embarked의 결측치를 처리해 보아요!
train['Embarked'] = train['Embarked'].fillna('Q')

# Embarked 처리
Embarked_mapping = {'S': 0,
                    'C': 1,
                    'Q': 2}
train['Embarked'] = train['Embarked'].map(Embarked_mapping)

# 나이를 처리해야 해요! 나이에는 결측치가 많아요!
train['Age'] = train['Age'].fillna(train['Age'].mean())

# 나이에 대해서는....Binning 처리를 해요!
train.loc[train['Age'] < 8, 'Age'] = 0
train.loc[(train['Age'] >= 8) & (train['Age'] < 20), 'Age'] = 1
train.loc[(train['Age'] >= 20) & (train['Age'] < 65), 'Age'] = 2
train.loc[train['Age'] >= 65, 'Age'] = 3

x_data = train.drop('Survived', axis=1, inplace=False).values
t_data = train['Survived'].values.reshape(-1,1)

# 정규화!
scaler = MinMaxScaler()
scaler.fit(x_data)

x_data_norm = scaler.transform(x_data)

# train데이터와 test데이터를 분리하나요?
# 원래 내가 만든 모델의 최종 평가를 하기 위해서는 test데이터가 당연히 있어야 해요!
# 하지만 우리예제는 kaggle에서 제공한 test데이터를 이용한 예측결과값을
# 파일로 만들어서 kaggle에 제출하는 것이기 때문에 test 데이터가 필요 없어요!

3. 모델 학습

# Keras Model을 만들어 보아요!

keras_model = Sequential()

keras_model.add(Flatten(input_shape=(5,)))
keras_model.add(Dense(units=1,
                      activation='sigmoid'))

keras_model.compile(optimizer=Adam(learning_rate=1e-2),
                    loss='binary_crossentropy',
                    metrics=['acc'])

keras_model.fit(x_data_norm,
                t_data,
                epochs=300,
                verbose=1,
                validation_split=0.2)

# loss: 0.4550 - acc: 0.7992 - val_loss: 0.3913 - val_acc: 0.8212

4. kaggle에 제출할 파일 생성하기

# 학습이 끝났으니... 제출파일을 생성해야 해요!
# 모델이 만들어 졌으니 test 데이터로 예측된 결과를 csv파일로
# 만들어서 kaggle에 제출하고 그 결과를 확인해보아요!

# 어떻게 해야 할까요
test = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/titanic/test.csv')
submission = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/titanic/gender_submission.csv')

# test 데이터 전처리
# 사용하는 coulmn만 추출. 사용되지 않는(불필요한) column을 삭제
# print(train.columns)
# 필요없는 컬럼은(종속변수에 영향을 주지 않거나 의미상 중복 컬럼)
#
test.drop(['PassengerId', 'Ticket', 'Name', 'Fare', 'Cabin'],
           axis=1,
           inplace=True)

# 성별처리 (male:0, female:1)
gender_mapping = {'male': 0,
                  'female': 1}
test['Sex'] = test['Sex'].map(gender_mapping)


test['Family'] = test['SibSp'] + test['Parch']

test.drop(['SibSp', 'Parch'],
           axis=1,
           inplace=True)


# df.info()
# Embarked의 결측치를 처리해 보아요!
test['Embarked'] = test['Embarked'].fillna('Q')

# Embarked 처리
Embarked_mapping = {'S': 0,
                    'C': 1,
                    'Q': 2}
test['Embarked'] = test['Embarked'].map(Embarked_mapping)

# 나이를 처리해야 해요! 나이에는 결측치가 많아요!
test['Age'] = test['Age'].fillna(test['Age'].mean())

# 나이에 대해서는....Binning 처리를 해요!
test.loc[test['Age'] < 8, 'Age'] = 0
test.loc[(test['Age'] >= 8) & (test['Age'] < 20), 'Age'] = 1
test.loc[(test['Age'] >= 20) & (test['Age'] < 65), 'Age'] = 2
test.loc[test['Age'] >= 65, 'Age'] = 3

# display(test)

x_data_test_norm = scaler.transform(test.values)

predict = keras_model.predict(x_data_test_norm)
# print(predict)

submission['Survived'] = predict
submission['Survived'] = np.where((submission['Survived'] >= 0.5), 1, 0)

submission.to_csv('./sub.csv', index=False)

예제로는 77.75%가 나온 모습이다.

실습 예제

• 만든 모델이 좋은지 안좋지 판단하는것은 평가를 진행하면 됩니다.
• 데이터를 분할해서 학습하고 평가를 진행합니다
• 학습에 사용된 데이터는 평가에 사용하지 않습니다

분류 모델 성능 평가지표

오차행렬(Confusion Matrix)

• 실제 정답이 True(1) => True
• 실제 정답이 False(0) => False
• 모델의 예측값이 True(1) => Positive
• 모델의 예측값이 False(0) => Nagative
• TP,와 TN은 실제값을 맞게 예측한 부분이고, FP와 FN은 실제값과 다르게 예측한 부분을 의미한다. 모델 평가 기준에 사용됩니다.*

모델 평가 기준

1. 정확도(Accuracy) : 전체 중 모델을 바르게 분류한 비율입니다.

• 가장 직관적인 성능 평가 지표입니다.

• 단점으로는 데이터의 편향이 심한 경우 오류가 발생할 수도 있습니다.

• ex) 희귀병환자 데이터에서 모델은 0을 출력할 때가 더 많습니다.

  2. 재현률(Recall, hit rate)

  

  • 실제 값이 True인 것 중 모델이 True라 분류한 비율입니다.
  • 위의 오차행렬에서 행방향에 해당하는 부분을 분모로 사용합니다.(TP / TP + FN) (정답 + 정답)
  • ex) 희귀병환자 데이터에서 우리의 recall 모델은 무조건 1이라고 판단한다.

  3. 정밀도(Precision)

  

  • 모델이 True 로 분류한것 중 실제값이 True인 비율입니다.
  • recall과 헷갈릴수 있습니다. 실제 오차행렬에서 열방향에 해당하는 부분을 분모로 사용합니다. (TP / TP + FP) (예측 + 예측)
  • recall의 관계와는 반비례 관계를 가지고 있습니다

- A모델에서는 검출률이 99%, B모델에서는 검출률이 60%라고 했을때
- 어느 모델이 좋은지는 검출률만보고 판단하기 어렵습니다.
- 이유는 A와 B둘다 오검출을 고려하지 않았기때문입니다.
- A에서 강아지, 고양이 모든 애완동물을 검출해서 99%가 나온 것일 수도 있기 때문입니다.
- B에서는 고양이만 검출했다고 해도 검출률이 낮기 때문에 모델이 좋은지 판단이 되지 않습니다.

4. F1 Score

- Precision과 Recall의 조화평균입니다. - 주로 데이터가 불균형할때 사용합니다

5. Fall-out

• False 중 True로 잘못 예측한 비율입니다. (FP / FP+ TN) 오차행렬에서 오른쪽의 열부분입니다.

  6. ROC curve/AUC

• ROC curve : FPR(fall-out)이 변할 때, TPR(recall)의 변화를 그린 그림입니다.

  • FPR을 x축, TPR을 y축으로 그립니다.
  • 곡선이 직선 위에 있어야 좋은 모델이고, 직선 아래에 있으면 나쁜 모델, 모델과 함께 직선이면 Random하게 때려맞추는 모델입니다.

• AUC

  • ROC곡선 아래의 면적입니다, 1에 가까울수록 좋은 수치입니다.
  • 기울기가 1인 직선 아래의 면적이 0.5 -> AUC는 0.5보다 커야합니다.
  • 초록색 선이 기준이 되는 직선이고, 빨간선인 ROC curve가 직선에서 멀어져 파란 화살표쪽으로 갈수록, 모델의 성능이 좋은 것 입니다.

    7. log-loss(cross-entropy)

  • 실제 값을 예측하는 확률에 로그를 취하여 부호를 반전시킨 값입니다.
  • 즉 ,분류 모델 자체의 잘못 분류된 수치적인 손실값(loss)를 계산합니다.
  • log-loss는 낮을수록 좋은 지표이다.

  ---

  추가적으로 알아야하는 사항들

  1. Learning rate

  

  • hyperparameter로 사용하고 기준은 없지만 대부분 1e-4로 시작한다.

  • 미분, 경사하강법에 사용이되고, 알파가 크면 최적의 W를 못찾게 된다.

  • 이런 현상을 Overshooting이라고 한다.

  • 반대로 알파가 작게되면 학습이 적게되어 그것보다 더 좋은 값이 있는데 진행이 되지 못하고 멈추는 것을 말합니다.

  • 이런 값을 local minimum이라고 합니다.

2. 정규화(Normalization)

• 머신러닝을 할 때, 입력데이터를 0 ~ 1 사이의 값으로 만드는 것
  • 1. 모든 feature의 scale을 동일하게 만든다.
  • 2. overfitting을 피하고 Noise를 감소시켜준다.
    • 방법
    • 1. Min-Max Normalizaiton(최대, 최소법)
    • 2. standardization(평균, 표준편차)

         3. Overfitting

• 과적합
  • 과대적합(overfitting) : 데이터 모델이 너무 잘 들어맞아서 문제다.
  • 과소적합(underfitting) : 모델 학습이 안됐습니다. (큰 문제 X)

    Overfitting 해결법

• Training data set에 아주 적합한 모델이지만 실제 데이터에는 적용이 잘 안되는 경우를 말합니다.
• 거의 항상 발생합니다. (정도를 줄이는것이 매우 중요합니다.

1. 많은 Training Data를 사용

   • Overfitting의 주된 이유는 데이터가 희박하기 때문입니다.

2. 독립변수(Feature)의 개수를 줄입니다 -> 다중공선성 문제해결

   • 다중공선성이란 독립변수가 독립변수에 상관 영향이 높아 모델에 영향을 주는것을 말합니다.

3. Deep Learning

   • Dropout기법을 사용합니다.

4. 규제(Regularization)

   • Weight값이 너무 커지지 않도록 인위적으로 조절합니다.
   • L1규제, L2규제 2가지가 있고 수식이 다릅니다.

5. 데이터 비대칭 문제(Imbalanced Data Problem)

   • 1. undersampling : 데이터의 개수를 줄이는 방법.
        • 90개의 데이터 -> 20개의 데이터
   • 2. oversampling : 데이터의 개수를 늘리는 방법.
        • 1. 복제 : 같은 데이터가 많아져서 overfitting 가능성
        • 2. 합성 데이터를 생성 -> SMOTE 알고리즘 사용

6. K-Fold Cross Validation

   • validation data set이 가지고 있는 bias 문제를 해결할 수 있다.
   • 적은 데이터를 이용해서 validation이 가능하다.
   • 하지만 시간이 오래걸리는 단점이 존재한다.
   • ex) K의 값을 5라고 지정하면 Fold가 5개가 생기고 이것을 통과해서 결과값의 평균을 낸다.

파이썬 구현

1. 필요한 module import

# Logistic Regression을 구현해 보아요!

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 이상치 처리를 위한 import
from scipy import stats

# 정규화 진행을 위한 import
from sklearn.preprocessing import MinMaxScaler
from sklearn import linear_model

# keras import
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import SGD

2. 데이터 로드 및 전처리

# Raw Data Loading
df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/admission/admission.csv')
# display(df)  # 400 rows × 4 columns

# 결측치 부터 알아보아요!
df.info()
df.isnull().sum()
#  #   Column  Non-Null Count  Dtype  
# ---  ------  --------------  -----  
#  0   admit   400 non-null    int64  
#  1   gre     400 non-null    int64  
#  2   gpa     400 non-null    float64
#  3   rank    400 non-null    int64   
# 결측치는 존재하지 않네요!

# 이상치도 알아보아야 해요!
# 이상치를 눈으로 확인하려면 boxplot을 그려보면 되요!
fig = plt.figure()
fig_gre = fig.add_subplot(1,3,1)
fig_gpa = fig.add_subplot(1,3,2)
fig_rank = fig.add_subplot(1,3,3)

fig_gre.boxplot(df['gre'])
fig_gpa.boxplot(df['gpa'])
fig_rank.boxplot(df['rank'])

plt.tight_layout()
plt.show()

# 수치상 이상치로 표현이 되지만
# 실제 데이터예요!(이상치가 아니예요!)
# 하지만 우리학습을 위해 이상치로 판별된 데이터를 삭제하고 진행

zscore_threshold = 2.0  # zscore 임계값 -2이하, 2이상이면 이상치

for col in df.columns:
    outlier = df[col][np.abs(stats.zscore(df[col])) > zscore_threshold]
    df = df.loc[np.isin(df[col], outlier, invert=True)]

print(df.shape)   # (382, 4)  18개의 데이터가 이상치로 제거!

# 정규화를 진행해야 해요!
x_data = df.drop('admit', axis=1, inplace=False).values
t_data = df['admit'].values.reshape(-1,1)

scaler = MinMaxScaler()
scaler.fit(x_data)
x_data_norm = scaler.transform(x_data)

3. sklearn, Tensorflow 구현

# Model을 구현해 보아요!
# sklearn부터 구현해 보아요!

sklearn_model = linear_model.LogisticRegression()
sklearn_model.fit(x_data,
                  t_data.ravel())

# predict
predict_value = np.array([[600, 3.8, 1]])
result_proba = sklearn_model.predict_proba(predict_value)
print(result_proba)     # [[0.43740782 0.56259218]]

----------------------------------------------------------
# Tensorflow로 구현해 보아요!

keras_model = Sequential()

keras_model.add(Flatten(input_shape=(3,)))
keras_model.add(Dense(units=1,
                      activation='sigmoid'))

keras_model.compile(optimizer=SGD(learning_rate=1e-4),
                    loss='binary_crossentropy')

keras_model.fit(x_data_norm,
                t_data,
                epochs=500,
                verbose=0)

# predict
predict_value = np.array([[600, 3.8, 1]])
predict_value_norm = scaler.transform(predict_value)
result = keras_model.predict(predict_value_norm)
print(result)  

# sklearn : [[0.43740782 0.56259218]]
# tensorflow : [[0.57682455]]

12.04 총 정리

다중 선형 회귀

• 기존 단일 선형 회귀와는 다르게 독립변수가 여러개인 선형 회귀이다.
• 실습예제 ozone에서 ozone은 temp, 태양광, 바람 모두 영향을 받지만 우리는 단일 선형 회귀를 진행했기때문에 독립변수를 하나만 사용했다.
• 이제는 다중 선형 회귀에 대해서 알아보겠습니다.

모델식

모델식이 기존 단일 선형과는 다릅니다.

• 위에 wx + b가 기존 식이라면 wx1, x2 추가적으로 y에 영향을 줍니다.
• 여기서 식을 조금 바꾸게 되면 오른쪽의 식으로 바뀝니다.

keras 구현

• 식을 보시면 선형회귀와는 다른점은 독립변수의 개수와 input_layer에서의 feature 개수의 차이정도입니다.

회귀 종류

1. 연속적인 숫자값을 예측하는 회귀

   • 1. 단일 선형 회귀
   • 2. 다중 선형 회귀

2. 이산적인 분류(Classification)값을 예측하는 회귀

   • 로지스틱(Logistic) 회귀
     • 이항분류(이진분류)에 대해서 진행합니다. ex) 합격, 불합격
     • deep learning의 기본 component입니다.

분류(classification)

이항분류(이진분류)

• 위에서 보면 병이 있다 없다로 신용카드가 정상 비정상으로 체크할 수 도 있습니다.
• 하지만 공부시간 몇시간을 했을때 내가 합격을 할 수 있을지 없을지도 확인할 수 있습니다.
• 위의 예를들어 모델의 값이 3시간일때 0.6라고 가정할때 6시간을 했을때의 값이 0.9이라고 나오면 합격이라고 나올 확률이 높습니다.

• 위의 표의 선이 모델의 값입니다.
• 모델의 선을 기준으로 위쪽이 1 아래가 0 이라고 모델이 판단한 것입니다.
• 모두 정확하게 나눠지는것은 아닙니다. 하나씩 다르게 판단할때도 있습니다.

11.29 복습

위의 상태로 진행되게 됩니다. 이때 맨밑 그림에서 이상치들이 발생합니다.

데이터 전처리

1. 결측치 처리
2. 이상치 처리
3. 정규화 처리 순서대로 진행하는것이 좋습니다.

이상치

모델이 회귀모델 즉 조건부 평균을 구하는 것인데 이런 이상치가 발생하게되면 모델이 좋아지지 않는다. 독립변수(Temp) => 여기서 발생하는 편차가 큰 값은 => 지대점 종속변수(Ozone) => 여기서 발생하는 편차가 큰 값 => 이상치(outlier)

이상치 제거 방법

1. Tukey's Fense 방식 => 사분위를 이용 boxplot을 그린 후 maximum보다 더 크거나 minimum 더 작으면 이상치로 판단한다.
2. 정규분포(Z -score)

Z-score는 각 포인터들 평균과의 거리가 얼마나 멀어져있는지 확인을 한 후 +-2이 넘어가면 이상치로 판단한다.

이상치를 모두 제거한다고 하더라도 우리가 원하는 모델이 완성되지 않았습니다. 왜 why? 정규화를 진행하지 않았기때문입니다.

정규화

정규화를 해야하는 이유

1. feature scale을 조정한다.
2. 학습속도를 향상시켜준다.
3. 특정 feature에 가중치가 더 부여되는 overfitting을 피할 수 있다.
4. 수치안정성(계산의 정확도가 높아진다)
5. 거리기반 알고리즘들이 존재하는데 이 알고리즘을 사용할때는 필수적으로 사용해야한다.

정규화 방법

1. Min-Max normalization(scaling)

• 정규화를 하는 가장 일반적인 방법이다.
• 모든 feature에 대해 최소 0 ~ 최대 1의 값을 설정하는 것이다.
• 이상치에 민감하다. 2. Standardization(Z-score Nomalization)
• 평균 및 표준편차와의 관계측면에서 데이터 포인트를 설명하는 방법이다.
• 이상치에 둔감하다

파이썬 구현

Ozone 데이터 실습 예제

python 직접 구현

# python 직접구현
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 수치미분코드
def numerical_derivative(f, x): # x가 다변수함수이기때문에 2개가 들어가야함

    delta_x =1e-4
    derivative_x = np.zeros_like(x) # [0.0, 0.0]

    it = np.nditer(x, flags=['multi_index'])

    while not it.finished:

        idx = it.multi_index   # 현재의 index를 추출 => tuple형태로 리턴

        tmp = x[idx]    # 현재 index의 값을 일단 잠시 보존해요.
                        # 밑에서 이 값을 변경해서 중앙차분 값을 계산해야함
                        # 그런데 우리 편미분을 해야하는데 다음 변수 편미분을 할때에
                        # 원래값으로 복원해야 정상적으로 진행되기 때문에
                        # 이 값을 잠시 보관했다가 원상태로 복구해야함
        x[idx] = tmp + delta_x
        fx_plus_delta_x = f(x)   # f(x + delta_x)

        x[idx] = tmp - delta_x
        fx_minus_delta_x = f(x)

        derivative_x[idx] = (fx_plus_delta_x - fx_minus_delta_x) / (2 * delta_x)

        x[idx] = tmp

        it.iternext()
    return derivative_x

# Raw Data Loading
df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/ozone/ozone.csv')
# display(df)

# 그러면 먼저 사용할 데이터를 추출해보자
training_data = df[['Temp', 'Ozone']]
# display(training_data)   # 153 rows × 2 columns

# 삭제해서 사용해보자
training_data = training_data.dropna(how='any')
# display(training_data)   # 116 rows × 2 columns

# Training Data Set
x_data = training_data['Temp'].values.reshape(-1,1)
t_data = training_data['Ozone'].values.reshape(-1,1)

# Model을 만들어야하는데.. y = Wx + b
W = np.random.rand(1,1)
b = np.random.rand(1)

# loss function(MSE)
def loss_func(input_data):

    input_w = input_data[0]
    input_b = input_data[1]

    y = np.dot(x_data, input_w) + input_b

    # loss 함수는 mse를 리턴해줌
    return np.mean(np.power((t_data - y), 2))

# 예측작업을 해야 해요! 그래서 예측을 해주는 함수를 하나 정의
def predict(x):   # 입력값 x

    return np.dot(x, W) + b

# 하이퍼파라미터 설정
# epoch => 전체를 한번 도는것
# lenaring rate 정의
learning_rate = 1e-4

# 학습을 진행
for step in range(300000):

    # 현재 W는 2차원, b는 1차원입니다
    # 그런데 이게 loss함수 안으로 들어갈때는 1차원 안에 두 값이
    # 순서대로 들어가 있어야 한다
    # ravel() 1차원으로 펴주는 함수
    # concatenate로 둘의 1차원 값을 합쳐줌.
    # 어디로 붙일지 지정을 해줘야함.
    # 축을 설정해주어야함.
    # 입력인자를 설정해주었음.
    input_param = np.concatenate((W.ravel(), b.ravel()), axis=0)
    derivative_result = learning_rate * numerical_derivative(loss_func, input_param)

    # 이제 입력인자를 미분해주어야함.
    # 미분함수에 loss함수를 넣고, 입력인자를 넣어줌.
    # learning rate를 설정하고 함수 결과를 선언해줌
    W = W - derivative_result[0].reshape(-1,1)
    b = b - derivative_result[1]

    # 확인 작업
    if step % 30000 == 0:
        print(f'W: {W}, b: {b}, loss: {loss_func(input_param)}')

# 학습종료 후 예측
# 온도가 62도일때 Ozone량은 얼마?
print(predict(np.array([[62]])))  # [[16.88607015]]
# 이거 맞는거야???
# 그래프로 확인해 보아요!
# (독립변수 1개니까 2차원 평면에 모델을 그릴수 있어요!)

# 데이터를 2차원 평면에 찍어보아요!
plt.scatter(x_data, t_data)   # [[16.88607015]]
# 우리 모델을 그려보아요!
plt.plot(x_data, x_data*W.ravel() + b, color='r')
plt.show()

Tensorflow 구현

# 같은 내용을 이제 Tensorflow Keras를 이용해서 구현!

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import SGD

# Raw Data Loading
df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/ozone/ozone.csv')

training_data = df[['Temp', 'Ozone']]

# 이렇게 데이터를 가져온 후 당연히 데이터 전처리를 해야 해요!
# 1. 결측치 처리!
training_data = training_data.dropna(how='any')

# Training Data Set 준비
x_data = training_data['Temp'].values.reshape(-1,1)
t_data = training_data['Ozone'].values.reshape(-1,1)

# Model 생성
model = Sequential()

model.add(Flatten(input_shape=(1,)))

output_layer = Dense(units=1,
                     activation='linear')

model.add(output_layer)

# model 설정
model.compile(optimizer=SGD(learning_rate=1e-4),
              loss='mse')

# model 학습
model.fit(x_data,
          t_data,
          epochs=2000,
          verbose=0)

# 학습이 끝났으니 예측을 해 보아요!
print(model.predict(np.array([[62]])))  # [[39.92358]]

# 그래프로 확인해 보아요!
# W와 b가 필요해요!
weights, bias = output_layer.get_weights()

# 데이터를 2차원 평면에 찍어보아요!
plt.scatter(x_data, t_data)
# 우리 모델을 그려보아요!
plt.plot(x_data, x_data*weights + bias, color='r')
plt.show()   # [[39.92358]]

sklearn 구현

# 정답(?)을 확인하기 위해 sklearn 구현을 해 보아요!

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import linear_model


# Raw Data Loading
df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/ozone/ozone.csv')

training_data = df[['Temp', 'Ozone']]

# 이렇게 데이터를 가져온 후 당연히 데이터 전처리를 해야 해요!
# 1. 결측치 처리!
training_data = training_data.dropna(how='any')

# Training Data Set 준비
x_data = training_data['Temp'].values.reshape(-1,1)
t_data = training_data['Ozone'].values.reshape(-1,1)

# Model 생성
sklearn_model = linear_model.LinearRegression()

# Model 학습
sklearn_model.fit(x_data, t_data)

# W와 b를 알아야지 나중에 그래프를 그릴 수 있겠죠.
weights = sklearn_model.coef_
bias = sklearn_model.intercept_

# 예측을 해 보아요!
print(sklearn_model.predict(np.array([[62]])))  # [[3.58411393]]

# 데이터를 2차원 평면에 찍어보아요!
plt.scatter(x_data, t_data)
# 우리 모델을 그려보아요!
plt.plot(x_data, x_data*weights + bias, color='r')
plt.show()

이상치 제거

# Tukey's Fence 방식으로 이상치를 검출해보아요!

import numpy as np
import matplotlib.pyplot as plt

data = np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,22.1])

fig = plt.figure()

fig_1 = fig.add_subplot(1,2,1)  # 1행 2열의 첫번째
fig_2 = fig.add_subplot(1,2,2)  # 1행 2열의 두번째

print(np.median(data))  # 8.0
print(np.percentile(data,25))  # 4.5
print(np.percentile(data,75))  # 11.5

# IQR value
iqr_value = np.percentile(data,75) - np.percentile(data,25)
print(iqr_value)  # 7.0

upper_fence = np.percentile(data,75) + 1.5 * iqr_value
print(upper_fence)  # 22.0
lower_fence = np.percentile(data,25) - 1.5 * iqr_value
print(lower_fence)  # -6.0

# 아하!! 이렇게 tukey fence방식을 이용하면 이상치를 구분하는
# 기준선을 알아낼 수 있네요!

# 내가 가지고 있는 데이터에 대해 이상치를 출력해보세요!
# boolean indexing을 이용해요!

print(data[(data > upper_fence) | (data < lower_fence)])  # [22.1]

# 데이터를 정제하는게 목적이예요. 이상치를 제거하는게 목적!
result_data = data[(data <= upper_fence) & (data >= lower_fence)]
print(result_data)

fig_1.set_title('Original Data')
fig_1.boxplot(data)

fig_2.set_title('Remove Outlier Data')
fig_2.boxplot(result_data)

plt.tight_layout()
plt.show()

# 정규분포(Z-score)를 이용한 이상치 구별방식
# 이 방식을 이용하려면
# 기본적으로 우리 데이터를 정규분포화 시켜서 우리 데이터에 대한
# z-score값을 각각 구해야 되요!
# 그리고 기준치를 설정한 다음 그 기준치를 넘는 데이터를 이상치로 판별

from scipy import stats

data = np.array([1,2,3,4,5,6,7,8,9,10,11,12,13,14,22.1])

zscore_threshold = 2.0 # 일반적으로 2.0을 많이 사용.

# print(np.abs(stats.zscore(data)) > zscore_threshold)
outlier = data[np.abs(stats.zscore(data)) > zscore_threshold] # [22.1]

# 이상치를 제거한 결과
print(data[np.isin(data,outlier, invert=True)])  
# [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14.

from scipy import stats

# 데이터는 공통으로 사용하니 먼저 사용하는 데이터 정제부터 하고
# 각각 구현하는게 좋을 듯 싶어요!

# Raw Data Loading
df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/ozone/ozone.csv')

training_data = df[['Temp', 'Ozone']]

# 이렇게 데이터를 가져온 후 당연히 데이터 전처리를 해야 해요!
# 1. 결측치 처리!
training_data = training_data.dropna(how='any')
# 2. 이상치 처리!
zscore_threshold = 1.8

outlier = training_data['Ozone'][np.abs(stats.zscore(training_data['Ozone'].values)) > zscore_threshold]

# print(outlier)

# 이상치를 제거한 결과를 얻어야 해요!
# 내가 가진 DataFrame에서 이상치를 제거하면 되요!
training_data = training_data.loc[np.isin(training_data['Ozone'],outlier, invert=True)]

# Training Data Set 준비
x_data = training_data['Temp'].values.reshape(-1,1)
t_data = training_data['Ozone'].values.reshape(-1,1)

이상치 제거 후 구현

python 직접 구현

# Python 직접구현

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

## 수치미분 코드
def numerical_derivative(f,x):

    # f : 미분하려고하는 다변수 함수
    # x : 모든 변수를 포함하는 ndarray  [1.0 2.0]
    # 리턴되는 결과는 [8.0 15.0]

    delta_x = 1e-4
    derivative_x = np.zeros_like(x)   #  [0.0 0.0]

    it = np.nditer(x, flags=['multi_index'])

    while not it.finished:

        idx = it.multi_index  # 현재의 index를 추출 => tuple형태로 리턴.

        tmp = x[idx]    # 현재 index의 값을 일단 잠시 보존해야해요!
                        # 밑에서 이 값을 변경해서 중앙차분 값을 계산해야 해요!
                        # 그런데 우리 편미분해야해요. 다음 변수 편미분할때
                        # 원래값으로 복원해야 편미분이 정상적으로 진행되기 때문에
                        # 이값을 잠시 보관했다가 원상태로 복구해야 해요!
        x[idx] = tmp + delta_x
        fx_plus_delta_x = f(x)  # f(x + delta_x)

        x[idx] = tmp - delta_x
        fx_minus_delta_x = f(x) # f(x - delta_x)

        derivative_x[idx] = (fx_plus_delta_x - fx_minus_delta_x) / (2 * delta_x)

        x[idx] = tmp

        it.iternext()

    return derivative_x

# Model을 만들어야 하는데.. y = Wx + b
W = np.random.rand(1,1)
b = np.random.rand(1)

# loss function(MSE)
def loss_func(input_data):

    input_w = input_data[0]
    input_b = input_data[1]

    y = np.dot(x_data, input_w) + input_b

    return np.mean(np.power((t_data-y),2))

# 모델이 완성된 후 예측하는 함수를 하나 만들어요!
def predict(x):

    return np.dot(x, W) + b

# learning rate 정의(hyperparameter)
learning_rate = 1e-4

# 학습진행
for step in range(300000):

    input_param = np.concatenate((W.ravel(), b.ravel()), axis=0)
    derivative_result = learning_rate * numerical_derivative(loss_func, input_param)

    W = W - derivative_result[0].reshape(-1,1)
    b = b - derivative_result[1]

    if step % 30000 == 0:
        print(f'W : {W}, b : {b}, loss : {loss_func(input_param)}')

# 학습종료 후 예측
# 온도가 62도일때 Ozone량은 얼마?
print(predict(np.array([[62]])))  # [[15.51232223]]

Tensorflow 구현

# 같은 내용을 이제 Tensorflow Keras를 이용해서 구현!

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import SGD

# Model 생성
model = Sequential()

model.add(Flatten(input_shape=(1,)))

output_layer = Dense(units=1,
                     activation='linear')

model.add(output_layer)

# model 설정
model.compile(optimizer=SGD(learning_rate=1e-4),
              loss='mse')

# model 학습
model.fit(x_data,
          t_data,
          epochs=2000,
          verbose=0)

# 학습이 끝났으니 예측을 해 보아요!
print(model.predict(np.array([[62]])))  # [[37.21062]]

# 그래프로 확인해 보아요!
# W와 b가 필요해요!
weights, bias = output_layer.get_weights()

sklearn 구현

# 정답(?)을 확인하기 위해 sklearn 구현을 해 보아요!

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import linear_model


# Model 생성
sklearn_model = linear_model.LinearRegression()

# Model 학습
sklearn_model.fit(x_data, t_data)

# 예측을 해 보아요!
print(sklearn_model.predict(np.array([[62]])))  # [[4.51299041]]

그래프로 확인해보기

####### 결과를 그래프로 확인해 보아요! #########

fig = plt.figure()

fig_python = fig.add_subplot(1,3,1)
fig_tensorflow = fig.add_subplot(1,3,2)
fig_sklearn = fig.add_subplot(1,3,3)

fig_python.set_title('python')
fig_tensorflow.set_title('tensorflow')
fig_sklearn.set_title('sklearn')

fig_python.scatter(x_data, t_data)
fig_python.plot(x_data, x_data*W.ravel() + b, color='r')

fig_tensorflow.scatter(x_data, t_data)
fig_tensorflow.plot(x_data, x_data*weights + bias, color='b')

fig_sklearn.scatter(x_data, t_data)
fig_sklearn.plot(x_data,
                 x_data*sklearn_model.coef_ + sklearn_model.intercept_,
                 color='g')

plt.tight_layout()
plt.show()

우리는 지난날에 회귀에 대해 기본적인 틀을 알아보았다. 정리를 하자면 회귀는 조건부 평균을 구하는 방법이며 평균을 구하는 식(Regression Model(회귀 모델))을 우리가 찾아내는 것이다.

1. 평균을 구하는 기법이기때문에 평균이 의미를 가지는 Data에 대해 회귀 모델이 더 잘 만들어집니다.
2. 단변량을 가정합니다
3. 기반 모델은 고전적 선형 회귀 모델(Classical Linear Regression Model)을 사용합니다
4. 회귀는 Target(Label)의 형태에 따라 종류가 나뉩니다.
   • 연속적인 숫자값 :Linear Regression(선형 회귀)
   • 이산적인 분류값 : Classification(분류) ex) Logistic Regression

그림으로 보게되면

위와 같이 입력에 데이터 셋을 모델에 넣고 예측을 하게 됩니다.

이때의 식은 아래와 같습니다.

오차(Error)

• 회귀 모델은 결과적으로 우리가 어떤 값을 넣게 되면 그 값이 어떤 값이 나오는지 예측하는 것입니다.
• 모델이 좋으면 평균과 오차가 적으면 좋을 것 입니다. 위의 그림처럼 평균선에 대해서 크면+ 작으면-로 나타낼 수 있습니다. 우리는 여기서 이 오차를 하나의 값으로 계산을 하려고 합니다.

오차 함수(Loss function)

• 여기서 예측값과 실제값의 차이를 나타내는 매커니즘을 오차 함수라고 표현합니다.

Loss 함수를 만드는 방법입니다.

1. error를 더한다 -> 부호때문에 이상적인 loss값으로 사용하기 힘듭니다. X
2. error의 절대값의 합을 구한다. -> 좋습니다! loss값을 이 방식으로 계산할 수 있습니다. O
3. error의 제곱의 평균을 구한다 -> 평균 제곱 오차(Mean Squared Error) O

오차 함수와 학습률

여기서 모델과 오차의 식을 보겠습니다 여기서 수학식으로 대입을 하여 바꿔주면 위와 같은 그림에서 식이 완성되게 됩니다. loss는 모든 데이터에 대한 평균 오차값이라고도 할 수 있습니다.

loss는 W의 2차함수이고, 이 그래프는 포물선 그래프입니다. loss는 작으면 작을수록 좋기때문에 loss가 최소가 되는 w ~ b를 찾으면 됩니다.

• W에서의 값에서의 미분을 하게 되면 해당 지점의 기울기를 나타냅니다.
• 그 값이 포물선의 중앙에 오게 되면은 평평해지며 기울기가 0이 됩니다.
• 기울기 식은 학습률(learning rate)와 관련이 있습니다.
• 미분을 하면서 가장 최적의 값을 찾으려고 내려가기때문입니다. 이걸 경사 하강(gradient descent)라고 한다.

구현 flow

1. feature와 label이 같이 있는 데이터를 입력하고 Model을 거쳐 예측값과 정답을 비교한다.
2. loss 함수를 learning rate만큼 거쳐서 오차범위를 줄이고, 다시 모델로 들어간다 이 한바퀴 반복 과정을 Epoch이라고 한다.
3. 설정한 Epoch을 거쳐 모델의 학습이 완료된다.

구현 flow 수식

모델의 식에 입력 데이터 값인 x1,x2,x3,x4에 값이 들어가고, 그 값에 가중치와 bias가 더해지면서 값이 나오게된다. 이렇게 반복하게 되면서 모델이 생성된다.

Tensorflow

Tensorflow란

1. open source library
2. 수치계산용 library
3. data flow graph를 이용해서 Tensor처리(다차원 data)

Keras

1. Tensorflow keras 구현은 상자(Sequential)모델 2차원 matrix에서 input_layer(Flatten)를 통해 feature 1개에 모델이 하나가 mapping이되서 들어가고
2. output_layer(Dense)에서 W가중치가 계산이 되고, bias가 더해진 후 actvation이 추가로 계산되어 밖으로 나가게된다.
3. 그 후 예측값과 정답을 비교하고 설정해둔 optimizer를 통해 다시 epoch을 돌게된다.

파이썬 구현

간단 선형 회귀

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

df = pd.DataFrame({'공부시간(x)': [1,2,3,4,5,7,8,10,12,13,14,15,18,20,25,28,30], '시험점수(t)':[5,7,20,31,40,44,46,49,60,62,70,80,85,91,92,97,98]})

display(df.head())

plt.scatter(df['공부시간(x)'],df['시험점수(t)'])
plt.plot(df['공부시간(x)'], df['공부시간(x)']*2 + 3, color='r')
plt.plot(df['공부시간(x)'], df['공부시간(x)']*5 - 7, color='g')
plt.plot(df['공부시간(x)'], df['공부시간(x)']*1 + 8, color='b')
plt.plot(df['공부시간(x)'], df['공부시간(x)']*4 - 10, color='magenta')
plt.show()

import numpy as np

# Training Data Set
x_data = np.array([1,2,3,4,5]).reshape(5,1)
t_data = np.array([3,5,7,9,11]).reshape(5,1)

# model => y = Wx + b
# rand() => 0과 1사이의 난수를 균등분포에서 발생시켜요!
W = np.random.rand(1,1)
b = np.random.rand(1)

# loss function
def loss_func(input_data):

    input_W = input_data[0]
    input_b = input_data[1]

    # Y = XW + b
    y = np.dot(x_data, input_W) + input_b

    return np.mean(np.power((t_data - y), 2))

# 미분해주는 함수가 있어야 해요!
def numerical_derivative(f,x):

    # f : 미분하려고하는 다변수 함수
    # x : 모든 변수를 포함하는 ndarray  [1.0 2.0]
    # 리턴되는 결과는 [8.0 15.0]

    delta_x = 1e-4
    derivative_x = np.zeros_like(x)   #  [0.0 0.0]

    it = np.nditer(x, flags=['multi_index'])

    while not it.finished:

        idx = it.multi_index  # 현재의 index를 추출 => tuple형태로 리턴.

        tmp = x[idx]    # 현재 index의 값을 일단 잠시 보존해야해요!
                        # 밑에서 이 값을 변경해서 중앙차분 값을 계산해야 해요!
                        # 그런데 우리 편미분해야해요. 다음 변수 편미분할때
                        # 원래값으로 복원해야 편미분이 정상적으로 진행되기 때문에
                        # 이값을 잠시 보관했다가 원상태로 복구해야 해요!
        x[idx] = tmp + delta_x
        fx_plus_delta_x = f(x)  # f(x + delta_x)

        x[idx] = tmp - delta_x
        fx_minus_delta_x = f(x) # f(x - delta_x)

        derivative_x[idx] = (fx_plus_delta_x - fx_minus_delta_x) / (2 * delta_x)

        x[idx] = tmp

        it.iternext()

    return derivative_x

# 학습이 다 종료되면(모델이 다 만들어지면)
# 예측작업을 해야 해요! 그래서 예측을 해주는 함수를 하나 정의
def predict(x):

    return np.dot(x,W) + b

# learning rate 정의
learning_rate = 1e-4

# 학습을 진행
for step in range(300000):

    # 현재 W는 2차원, b는 1차원이예요!
    # 그런데 이게 loss함수안으로 들어갈때는 1차원 안에 두 값이
    # 순서대로 들어가 있어야 해요!
    input_param = np.concatenate((W.ravel(), b.ravel()), axis=0)
    derivative_result = learning_rate * numerical_derivative(loss_func, input_param)

    W = W - derivative_result[0].reshape(-1,1)
    b = b - derivative_result[1]

    # 확인작업
    if step % 30000 == 0:
        print(f'W : {W}, b: {b}, loss: {loss_func(input_param)}')


# W: [[0.8533673]], b: [0.10691388], loss: 21.505695738228287
# W: [[2.05368836]], b: [0.806168], loss: 0.006839013386449011
# W: [[2.0194703]], b: [0.92970603], loss: 0.0008994533618923671
# W: [[2.00706099]], b: [0.9745076], loss: 0.00011829430716160621
# W: [[2.0025607]], b: [0.99075508], loss: 1.5557830677745438e-05
# W: [[2.00092865]], b: [0.99664729], loss: 2.0461347735503135e-06
# W: [[2.00033678]], b: [0.99878413], loss: 2.691035529462717e-07
# W: [[2.00012213]], b: [0.99955906], loss: 3.5391961050585345e-08
# W: [[2.00004429]], b: [0.99984009], loss: 4.6546799299037875e-09
# W: [[2.00001606]], b: [0.99994201], loss: 6.121741945875743e-10

# 결과 예측하기 7을 넣었을때의 값
predict_result = predict(np.array([7]).reshape(1,1))

print(predict_result)   # [[15.00001975]]

Tensorflow 구현

# Tensorflow Keras 구현

import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import SGD

# Training Data Set
x_data = np.array([1,2,3,4,5]).reshape(5,1)
t_data = np.array([3,5,7,9,11]).reshape(5,1)

# Model 생성
model = Sequential()

# Model 안에 layer를 생성
# Flatten == input_layer
# input_shape안에는 반드시 tuple이 들어가야함
# 1이라는건 feature를 의미
# activation 함수 설정
model.add(Flatten(input_shape=(1,)))
model.add(Dense(units=1, activation="linear"))

# 모델이 완성되었으면 기타 옵션들을 설정해야 한다.
# 어떤 최적화 알고리즘 방식을 사용할지 설정하는 optimizer
# learning_rate도 같이 설정
# loss는 평균제곱오차 mse를 사용
model.compile(optimizer=SGD(learning_rate=1e-2), loss='mse')

# 모델 학습
model.fit(x_data,
          t_data,
          epochs=5000,
          verbose=0)

# 예측을 해 보아요!
print(model.predict(np.array([[10]])))  # [[21.000032]]

sklearn 구현

# sklearn을 이용해 해보자
# sklearn은 일반사람들도 쉽고 편하게 머신러닝을 할 수 있도록
# 모델을 제공해줘요!

import numpy as np
from sklearn import linear_model

# Training Data Set
x_data = np.array([1,2,3,4,5]).reshape(5,1)
t_data = np.array([3,5,7,9,11]).reshape(5,1)

sklearn_model = linear_model.LinearRegression()

sklearn_model.fit(x_data,
                  t_data)

print(sklearn_model.predict(np.array([[10]])))   # [[21.]]

Ozone 데이터 실습 예제

# ozone.csv 파일을 이용해서 머신러닝 모델을 만들어 보아요
# python 구현

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 수치미분함수가 있어야함
# 수치미분함수.
def numerical_derivative(f, x):

    delta_x =1e-4
    derivative_x = np.zeros_like(x) # [0.0, 0.0]

    it = np.nditer(x, flags=['multi_index'])

    while not it.finished:

        idx = it.multi_index   # 현재의 index를 추출 => tuple형태로 리턴

        tmp = x[idx]    # 현재 index의 값을 일단 잠시 보존해요.
                        # 밑에서 이 값을 변경해서 중앙차분 값을 계산해야함
                        # 그런데 우리 편미분을 해야하는데 다음 변수 편미분을 할때에
                        # 원래값으로 복원해야 정상적으로 진행되기 때문에
                        # 이 값을 잠시 보관했다가 원상태로 복구해야함
        x[idx] = tmp + delta_x
        fx_plus_delta_x = f(x)   # f(x + delta_x)

        x[idx] = tmp - delta_x
        fx_minus_delta_x = f(x)

        derivative_x[idx] = (fx_plus_delta_x - fx_minus_delta_x) / (2 * delta_x)

        x[idx] = tmp

        it.iternext()
    return derivative_x

# Raw Data Loading
df = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/ML/data/ozone/ozone.csv')
# display(df)

# 아직은 simple linear regression 얘기를 하는 중이기 때문에
# 독립변수를 1개만 사용할것. ==> Temp
# 종속변수는 Ozone을 사용

# 그러면 먼저 사용할 데이터를 추출해보자
training_data = df[['Temp', 'Ozone']]
# display(training_data)   # 153 rows × 2 columns

# 데이터 처리를 좀 해야함
# 결측치 처리를 해야함
# 이런 결측치 처리하는 방식이 두가지 있음
# 1. 결측치 삭제
#    데이터량이 충분히 많을때 삭제
#    일반적으로 총 데이터가 10만개를 기준으로 데이터가 많고 적음을 삼음
#
# 2. 결측치 대체 => imputation 진행
#    데이터량이 충분하지 않은경우
#    그럼 어떤값으로 대체하는가 => 평균 중위 최빈
#
# 머신러닝을 이용해서 값을 대체

# 삭제해서 사용해보자
training_data = training_data.dropna(how='any')
display(training_data)   # 116 rows × 2 columns

AI를 구현하는 방법에는 여러가지가 존재합니다. 우리는 이 중에서 머신러닝(Mechine Learning 통칭 ML)에 대해 이야기를 하고자 합니다.

ML(Mechine Learning)

프로그래밍 방식

먼저 기존 프로그래밍 방식은 Rule-based 방식으로 규칙에 기반한 방식으로 프로그래밍이 됩니다.

Data(입력) => 함수와 Method를 통한 로직처리 =>해답(출력)을 하게 됩니다.

머신러닝 방식

그에 반해 머신러닝은 다른 방식을 사용하게 됩니다. Data,해답(입력) 모두 입력 데이터에 같이 들어가게 되고, 학습에서는 Query를 통과 후 규칙성을 출력하게 됩니다. 이 규칙성이 인공지능에서 필요한 Model이 생성되게 됩니다. 이 Model은 수식으로 표현이 되고 다른말로는 Prediction 예측이라고도 합니다. 한 줄로 표현하자면 입력안에는 Data와 해답이 모두 존재하고 이것을 학습을 진행 => 데이터를 일반화하는 Model이 생성되게 됩니다. 여기서 학습이란 => 데이터와 정답간의 규칙성을 찾아내는 작업입니다.

ML과 DL

흔히 우리가 말하는 딥러닝 Deep Learning(DL)은 크게 머신러닝안에 포함되어 있습니다. ML과 DL의 차이점은 Data의 특성이 다르다는 것입니다. ML은 정형 데이터를 사용하고 DL은 비정형 데이터를 사용하게 됩니다.

머신러닝 알고리즘

머신러닝의 알고리즘에는 다양한 많은 것들이 존재합니다

• Regression
  • 회귀로 여러가지가 존재한다.
• SVM(Support Vector Mechine) 서포트 벡터 머신
  • 패턴 인식, 자료 분석을 위한 지도 학습 모델이며, 주로 분류와 회귀 분석을 위해 사용한다
• Decision Tree 의사결정 트리 (앙상블 기법 적용 -> Random Forest)
  • 의사결정나무는 분류(classification)와 회귀(regression) 모두 가능합니다

• Naive Bayes 나이브 베이즈

• KNN(K - Nearest Neighbors) K-최근접 이웃
• ANN(Artificial Neural Network) 인공 신경망 => Deep Learning에 주로 사용
• Clustering (K-Means, DBscan) => 비지도학습
• Reinforcement Learning 강화학습

머신러닝 타입

• 1. 지도학습(Supervised learning)
  • 데이터와 정답이 같이 입력으로 들어갑니다.
• 2. 비지도 학습(Unsupervised learning)
  • 데이터만 입력으로 들어감 => clustering 과정을 거침
• 3. 준지도학습(Semisupervised learning)
  • 지도학습과 비지도학습을 합친것
• 4. 강화학습(Reinforcement Learning) ```
• 데이터
  • 입력데이터
  • X_data
  • 독립변수
  • Feature
• 정답
  • label
  • target
  • T_data
  • 종속변수

    ## 지도학습(Supervised Learning)
    ![](https://velog.velcdn.com/images/m1ng_9/post/23f30747-ca5d-4d8d-a174-e1923ed6b74d/image.png)
    지도학습은 `Data(독립변수)` + `정답(종속변수)`이 입력값이다
    이 입력값을 위의 그림처럼 학습을 반복하여 규칙성을 찾아낸다.
    이 규칙성이 `Model`이며 최종적으로 모델이 저장된다.
    

여기서 Target의 형태는 두가지로 나뉜다.

• 1. 연속적인 숫자값일때 => (Linear Regression)
• 2. 이산적인 분류값일때 => (Classification)

회귀(Regression)

• 회귀 : 어떤 데이터에 대해 그 데이터에 영향을 주는 조건들의 평균적인 영향력을 이용해서 데이터에 대한 조건부 평균을 구하는 기법이다. ==> 아주 간단하게 생각하면 회귀는 평균을 구하는 기법이다.

회귀 예시

예를 들어보겠습니다.

ex) 우리나라의 아파트 시세가 얼마인지 조사 -> 아파트 시세를 나타내기위한 대표값은 어떤게 적절할까?
평균, 최대, 최소, 중위, 최빈 값을 사용한다.

ex) 우리나라의 아파트 시세가 얼마인지 조사 -> 아파트 시세를 나타내기위한 대표값은 어떤게 적절할까?
산출평균으로 계산한다 ==> `1억`

아파트 가격에 영향을 주는 요인이 굉장히 많습니다.
ex) 평수, 연식, 학군, 지역, 층수, 방향, 역세권 등등

조금 더 자세하게 특정 조건에 따른 가격 변화(면적)를 보겠습니다. 가격이 파란색 점으로 형성되어있다고 가정하면 면적의 평균은 빨간색 점이다. 여기서 점은 예를 들어 328만원 * 평형 + 3400만원 이라고 가정하면 328만원(가중치) 평형(조건) 3400만원(bias)라고 표현할 수 있다.

아파트 가격은 조건에 따라 또 추가가 되기 때문에 여러 요인들을 더해야합니다. 아파트 가격 = 340(평형) + 500(화장실 개수) + 700*(역세권여부) + 2500 여기서 340, 500, 700은 가중치(W) 평형, 화장실 개수, 역세권 여부는 조건 2500은 bias로 표현할 수 있다.

즉 회귀란 어떤 데이터(아파트 가격)에 대해 그 데이터에 영향을 주는 조건(평형,지역,학군)들의 평균적인 영향력(가중치)를 이용해서 데이터에 대한 조건부 평균을 구하는 기법이다.

회귀 그래프

여기서 우리가 구하고 싶은건 가중치(W), 보정치(Bias)이다. 단순화시켜서 생각을 하게 되면 독립변수가 한개일때는 아래와 같은 직선식이 그려지게 된다.

회귀를 할때 알아두어야하는 사항

1. 회귀는 평균적으로 평균을 구하는 기법이다.

   • 1. 우리나라 근로자의 연봉 => 대체적으로 살짝 기울여진 그래프
   • 2. 우리나라 성인 남자의 키 => 정규분포와 비슷한 모양의 그래프

2. Regression toward the mean

   • 많은 자료를 토대로 결과를 예측할 때 그 결과 값이 평균에 가까워지려는 경향성을 가진다.
   • 이것은 상관이 완전하지 않은 관게에서도 볼 수 있는 특성이다.

3. 종속변수의 개수에 따라 모델이 달라집니다.

   • 단변량 회귀모델
   • 다변량 회귀모델
   • 기본적으로 회귀분석은 단변량을 가정하고 있습니다.

4. 굉장히 많은 회귀 모델의 종류가 존재합니다.

   • 그 중에서 우리가 사용하고 연습할 모델은 가장 기본적인 모델인 Classical Linear Regression Model이고 일반식은 아래와 같습니다.

파이썬 구현

파이썬 수치 미분 코드

# 일변수 함수의 수치미분 코드 구현
# 입력으로 함수를 받아서 미분을 수행하는 함수를 하나 구현해 봅시다!
# 우리 파이썬은 일급함수를 지원합니다!
# 함수의 인자로 다른 함수를 받을 수 있습니다.

def numerical_derivative(f, x):

    # 입력인자 f는 미분하려는 함수
    # 입력인자 x는 미분값을 알고자하는 입력값.

    delta_x = 1e-4

    # 중앙차분을 이용한 미분을 코드로 표현해봅시다!
    result = (f(x + delta_x) - f(x - delta_x)) / (2 * delta_x)
    return result

# 이 미분함수가 정상적으로 값을 계산하는지 확인해 봅시다!

def my_func(x):
    return x**2

# 함수 f(x) = x**2의 미분계수 f'(5)를 구해봅시다!

result = numerical_derivative(my_func, 5)
print(result)  # 9.999999999976694

# 다변수 함수의 수치미분 코드를 구현해보아요!

# f(x,y)=2x+3xy+y^3제곱
# x에 대해 편미분 => 2+3^y
# y에 대해 편미분 -> 3 + 3y^2
# f'(1.0, 2.0)=?
# x에 대해 미분이기에 x자리의 값은 x에 대한 편미분
# y도 마찬가지
# 각각 집어넣게되면 (8.0, 15.0)이 나옴
import numpy as np

def numerical_derivative(f, x): # x가 다변수함수이기때문에 2개가 들어가야함

    # f: 미분하려고하는 다변수 함수
    # x: 모든 변수를 포함하는 ndarray [1.0, 2.0] ==> 2변수
    # 미분의 결과는 [8.0, 15.0]이 나와야함.

    delta_x =1e-4
    derivative_x = np.zeros_like(x) # [0.0, 0.0]

    it = np.nditer(x, flags=['multi_index'])

    while not it.finished:

        idx = it.multi_index   # 현재의 index를 추출 => tuple형태로 리턴

        tmp = x[idx]    # 현재 index의 값을 일단 잠시 보존해요.
                        # 밑에서 이 값을 변경해서 중앙차분 값을 계산해야함
                        # 그런데 우리 편미분을 해야하는데 다음 변수 편미분을 할때에
                        # 원래값으로 복원해야 정상적으로 진행되기 때문에
                        # 이 값을 잠시 보관했다가 원상태로 복구해야함
        x[idx] = tmp + delta_x
        fx_plus_delta_x = f(x)   # f(x + delta_x)

        x[idx] = tmp - delta_x
        fx_minus_delta_x = f(x)

        derivative_x[idx] = (fx_plus_delta_x - fx_minus_delta_x) / (2 * delta_x)

        x[idx] = tmp

        it.iternext()
    return derivative_x

def my_func(x):

    return x**2

# f'(3.0)을 구해보아요!

result = numerical_derivative(my_func, np.array([3.0]))
print(result)    # 6

# 2변수 함수를 다시 만들어보아요!

def my_func(input_data):

    x = input_data[0]
    y = input_data[1]

    # f(x) = 2x + 3xy + y^3
    return 2*x + 3*x*y + np.power(y,3)

result = numerical_derivative(my_func, np.array([1.0, 2.0]))
print(result)   # [ 8.    15.00000001]

# 4변수 함수에 대해서 수치미분을 해보세요
def my_func(input_data):
    w = input_data[0,0]
    x = input_data[0,1]
    y = input_data[1,0]
    z = input_data[1,1]

    # f(x)=2x+3xy+y^3
    return w*x + x*y*z + 3*w + z*np.power(y,2)


data = np.array([[1.0, 2.0],
                 [3.0, 4.0]])
result = numerical_derivative(my_func, data)   # np.array가 들어가야하니까 아예 np.array로 리스트를 생성해서 만듬
print(result)   # [[ 5. 13.]
                # [32. 15.]]

마크다운(markdown)은 일반 텍스트 기반의 경량 마크업 언어다. 일반 텍스트로 서식이 있는 문서를 작성하는 데 사용되며, 일반 마크업 언어에 비해 문법이 쉽고 간단한 것이 특징이다. HTML과 리치 텍스트(RTF) 등 서식 문서로 쉽게 변환되기 때문에 응용 소프트웨어와 함께 배포되는 README 파일이나 온라인 게시물 등에 많이 사용된다. -위키백과

• 쉽게 읽을 수 있고, 쉽게 작성 할 수 있게 만들어졌음.
• README나 온라인 게시물에 많이 사용됨.

1. 제목(Header)

h1부터 h6까지 표현 할 수 있고, #의 개수로 표현이 가능합니다 🖊 마크다운으로 작성 시

# h1
## h2
### h3
#### h4
##### h5
###### h6

✔결과

h1

h2

h3

h4

h5

h6

h1, h2는 다른 방법으로도 작성이 가능합니다

=,-를 각각 2개 이상 사용하면 아래와 같이 h1, h2의 #을 대체할 수 있습니다. 여러개를 사용해도 마찬가지입니다.

🖊 마크다운으로 작성 시

h1
==
h2
--

하이픈을 여러 개 사용한 제목
-------------------

✔ 결과 h1 == h2 --

하이픈을 여러 개 사용한 제목

2. 문단 간격

문단의 간격은 줄 바꿈으로 나타내고, 여러 번 줄 바꿈시 <br/>을 사용하면 가능합니다. <br/>은 html에서 사용하는 문법입니다. 🖊 마크다운으로 작성 시

첫 번째 문단 <br/><br/>
두 번째 문단 <br/>
세 번째 문단

✔ 결과 첫 번째 문단

두 번째 문단
세 번째 문단

3. 목록

순서를 표기하는 목록 / 순서가 없는 목록 두 가지를 작성할 수 있습니다.

3.1 순서를 표기하는 목록

숫자와 .을 사용하여 작성합니다. 🖊 마크다운으로 작성 시

1. first
2. second
3. thrid

✔ 결과

1. first
2. second
3. thrid

3.2 순서가 없는 목록

-, *, + 사용하여 작성합니다 (셋 다 동일하게 적용 됨) inline code, block code를작성 할 수 있으며, Tab키나 Space bar를 이용해 들여쓰기가 가능합니다. 🖊 마크다운으로 작성 시

- 순서가 없는 목록 1
    - 목록 1.1
        - 목록 1.2
        - 목록 1.3
- 순서가 없는 목록 2

        Tab 두번 하면 `code block`을 만들 수 있습니다.
 * 순서가 없는 목록 3
 * 순서가 없는 목록 4
     + `inline code`
        - 들여쓰기(Tab 키를 이용)를 하면 다른 모양으로 표현됩니다.

        ```
        block code
        ```

✔ 결과

• 순서가 없는 목록 1

  • 목록 1.1
    • 목록 1.2
    • 목록 1.3

• 순서가 없는 목록 2

    Tab 두번 하면 `code block`을 만들 수 있습니다.

  • 순서가 없는 목록 3

  • 순서가 없는 목록 4

    • inline code

      • 들여쓰기(Tab 키를 이용)를 하면 다른 모양으로 표현됩니다.

        block code

4. 폰트 스타일

굵기, 기울기, 취소선, 등 기본적은 스타일을 아래와 같이 작성 가능합니다. 🖊 마크다운으로 작성 시

__굵게__
**굵게**
_기울여 쓰기_
*기울여 쓰기*
~취소선~
~~취소선~~

✔ 결과 굵게 굵게 기울여 쓰기 기울여 쓰기 취소선 취소선

5. 인용문

인용문을 작성할 때에는 >을 사용합니다. 🖊 마크다운으로 작성 시

> 인용문 작성하기
-작성자

> 인용문 작성하기
>> (>)의 갯수에 따라
>>> 중첩문 가능

✔ 결과

인용문 작성하기 -작성자

인용문 작성하기

(>)의 갯수에 따라

중첩문 가능

6. inline code

백틱()`을사용하여 inline code를 작성할 수 있습니다. 🖊 마크다운으로 작성 시

`inline code는 이렇게 작성해요.`

✔ 결과 inline code는 이렇게 작성해요

7. 여러 줄로 된 code block

```백틱 3개를 사용시 띄어쓰기를 확실하게 하여 code block 설정을 제대로 해야합니다. 🖊 마크다운으로 작성 시

    ```
    위 아래 3개로 감싸면 block으로 만들 수 있어요.
    ```

✔ 결과

위 아래 3개로 감싸면 block으로 만들 수 있어요.

💡 코드 하이라이트 🖊 마크다운으로 작성 시

```아래와 같이 백틱 3개 뒤에 언어 이름을 넣어주세요
```python
num_list = ['one', 'two', 'three']
for num in num_list:
  print(num)

✔ 결과

num_list = ['one', 'two', 'three']
for num in num_list:
  print(num)

8. 링크(link)

inline 링크와 url 링크, 참조 링크 나타낼 수 있습니다. 🖊 마크다운으로 작성 시

inline 링크는 아래처럼
[inline 링크](http://velog.io/)

url 링크는 아래처럼
<http://velog.io/>

참조 링크는 아래
[velog]:(http://velog.io/)

✔ 결과 inline 링크는 아래처럼 inline 링크

url 링크는 아래처럼 http://velog.io/

참조 링크는 아래 [velog]:(http://velog.io/)

9. 수평선

*이나 -,_등을 3개 이상 입력하면 작성할 수 있습니다. 띄어쓰기를 중간에 삽입하여도 가능합니다. 다만, 하이픈-은 헤더로 인식할 수도 있으니 주의해서 사용할 필요가 있습니다. 🖊 마크다운으로 작성 시

***
-------
-- -- -- -- --

✔ 결과

10. 이미지 링크

이미지 링크는 아래와 같이 작성할 수 있습니다. 🖊 마크다운으로 작성 시

![이미지 설명](이미지 링크)
![고양이입니다](![](https://velog.velcdn.com/images/m1ng_9/post/d4245c63-3507-405e-8214-635663245101/image.png)

✔ 결과 만약 이미지에 링크를 걸고 싶은 경우에는 아래와 같이 작성합니다

🖊 마크다운으로 작성 시

[![이미지 설명](이미지 링크)](연결하고자하는 url "마우스 오버 시 나타낼 링크 title")
[![고양이입니다](![](https://velog.velcdn.com/images/m1ng_9/post/d4245c63-3507-405e-8214-635663245101/image.png)](https://velog.velcdn.com/images/m1ng_9/post/d4245c63-3507-405e-8214-635663245101/image.png"이미지 무료 사이트 cat")

✔ 결과 [](https://velog.velcdn.com/images/m1ng_9/post/d4245c63-3507-405e-8214-635663245101/image.png"이미지 무료 사이트 cat")

중요 ! 이미지 크기는 10MB 이하만 가능합니다. (gif 포함) 사이즈 조절과 관련된 마크다운은 아직 적용이 되어있지 않은 것 같습니다.

11. 테이블(Table)

테이블은 아래와 같이 작성합니다 |로 구분하며 <4. 폰트 스타일> 에서 이야기 했던 기본적인 스타일 적용이 가능합니다 또한 -(하이픈)으로 구분된 곳 각각 왼쪽, 양쪽, 오른쪽 :(세미콜론)을 붙일 경우 순서대로 왼쪽 정렬, 가운데 정렬, 오른쪽 정렬이 가능합니다. 🖊 마크다운으로 작성 시

| 드라마 제목 | 주연 배우 | 방영일 |
|:----------|:---------|:--------|
|**이두나!**| 수지, 양세종 | 2022년 7월 12일 ~ 2023년 2월 20일 |
| 사내 맞선 | 김세정, 안효섭 | 2022년 2월 28일 ~ 2022년 4월 5일 |

✔ 결과 | 드라마 제목 | 주연 배우 | 방영일 | |:----------|:---------|:--------| |이두나!| 수지, 양세종 | 2022년 7월 12일 ~ 2023년 2월 20일 | | 사내 맞선 | 김세정, 안효섭 | 2022년 2월 28일 ~ 2022년 4월 5일 |

12. 체크박스(Check Box)

-, *, + 뒤에 띄어쓰기 후 대괄호를 넣어 작성해주세요. 대괄호안에 띄어쓰기를 하면 빈 체크박스, x를 넣으면 체크된 체크박스가 생깁니다. 🖊 마크다운으로 작성 시

- [ ] 운동하기
- [x] 강의 듣기

✔ 결과

• 운동하기
• 강의 듣기

13. 이모지⭐

이모지는 트위터 이모지로 https://kr.piliapp.com/twitter-symbols/ 복사 붙여넣기로 사용하시면 됩니다

단축키

window10: 윈도우 키 + 마침표(.) mac: Command + Control + Space Bar

14. 글자 색상

html 태그를 이용하여 작성이 가능합니다. 🖊 마크다운으로 작성 시

<span style="color:red">red</span>
<span style="color:#d3d3d3">#d3d3d3</span>
<span style="color:rgb(245, 235, 13)">rgb(245, 235, 13)</span>

✔ 결과 red #d3d3d3 rgb(245, 235, 13)

글을 마치며,

velog를 시작하면서 Markdown을 작성해보았습니다. velog는 Markdown 문법을 모두 사용하는 것이 아니기때문에 나중에 보고 사용할 수 있도록 작성해보았습니다.