[hongong_machine_study1] 3, 4주차 활동 인증 / 5, 6주차 활동 인증

week03/김다연/Chapter04/3주차 과제.md

@@ -0,0 +1,44 @@
+# 3주차 과제
+
+1. **Momentum**
+    1. 기본 gradient descent는 진동 심함, 수렴 속도 느림, 최적점 지나침
+    2. gradient descent의 이동 경로에 inertia(관성) 개념 도입 → 이전 단계의 이동 방향을 일정 비율로 유지하면서 새로운 방향으로 조금씩 수정
+        1. 현재 기울기 + 이전 단계의 이동량
+        2. local minimum을 해결할 수 있음
+        3. 수식
+            ![v : 속도, alpha : 모멘텀 계수](https://github.com/user-attachments/assets/2f42c800-33e3-425b-b11b-e9a224a49737)
+
+            v : 속도, alpha : 모멘텀 계수
+
+
+1. **AdaGrad (Adaptive Gradient)**
+    1. 각 파라미터마다 학습률을 다르게 조정
+        1. 모든 파라미터에 같은 학습률을 적용하면 비효율적
+        2. 자주 업데이트되는 파라미터는 학습률 작게, 드물게 업데이트되는 파라미터는 학습률 크게
+    2. 각 파라미터별로 기울기 제곱의 누적합 저장, 이를 이용해 학습률 조정
+        1. but 누적합이 계속 커져서 학습률이 점점 0에 가까워지면 → 학습 멈춤
+        2. 수식
+
+            ![image.png](https://github.com/user-attachments/assets/b5f833aa-0a33-4431-af7d-555b44df328e)
+
+1. **RMSProp (Root Mean Square Propagation)**
+    1. AdaGrad 단점 개선 → 최근의 기울기만 고려하도록 만듦
+    2. 지수 이동 평균 (Exponential Moving Average)로 계산
+        1. 수식
+
+            ![image.png](https://github.com/user-attachments/assets/fecd9044-5a68-41b2-aec8-cc32554a00b6)
+
+
+1. **Adam (Adaptive Moment Estimation)**
+    1. Momentum + RMSProp
+        1. Momentum : 방향 부드럽게 조정
+        2. RMSProp : 학습률 자동 조정
+    2. 1차 모멘트(기울기의 평균), 2차 모멘트(기울기의 제곱 평균) 둘 다 추적 + bias correction 적용
+
+        ![image.png](https://github.com/user-attachments/assets/ba620236-f874-493f-b17f-f7a61d26a2bd)
+
+    3. L2 regularization 추가된 loss func를 Adam을 이용해서 최적화 할 경우 일반화 효과 떨어짐
+
+1. **AdamW**
+    1. Adam에서 Weight Decay(가중치 감소) 올바르게 개선
+    2. weight decay를 기울기 업데이트와 분리해서 적용 → 파라미터 업데이트 시 별도로 decay시켜 과적합 방지

week03/김다연/Chapter04/Chapter 04-1.md

@@ -0,0 +1,158 @@
+# Chapter 04-1
+
+1. **다중 분류 (multi-class classification)** : 타깃 데이터에 **2개 이상의 클래스**가 포함된 문제
+    1. ↔ 이진 분류 but 모델을 만들고 훈련하는 방식은 동일
+    2. **소프트맥스(softmax)** 함수를 사용하여 n개의 z 값을 확률로 변환
+        1. 이진 분류와 달리 여러 개의 선형 방정식의 출력값을 0~1 사이로 압축, 합이 1이 되도록 함
+2. **로지스틱 회귀 (logistic regression)**
+    1. 이름은 회귀지만 **분류** 모델
+    2. **선형 방정식** 학습
+
+        ![image.png](https://github.com/user-attachments/assets/c1c2700e-d913-40ec-ae57-ee1130755b74)
+
+        a, b, c, d, e는 가중치 or 계수 → 특성은 늘어났지만 선형 방정식
+
+    3. z는 어떤 값도 가능하지만 확률이 되려면 0~1 사이 값이어야 함 → **시그모이드 함수(sigmoid function)** 사용
+
+        ![image.png](https://github.com/user-attachments/assets/e049901a-ee07-4df5-b3c8-d0369a57acc3)
+
+    4. 이진 분류일 때 : 0.5보다 크면 양성 클래스, 작으면 음성 클래스
+    5. 규제 제어 매개변수 : **C**
+        1. C가 작을수록 규제 커짐
+        2. C의 기본값 : 1
+3. **불리언 인덱싱 (boolean indexing)**
+    1. 넘파이 배열에서 **true, false 값을 전달**하여 행을 선택하는 것
+
+        ```python
+        char_arr = np.array[['A', 'B', 'C', 'D', 'E'])
+        print(char_arr[[True, False, True, False, False]]) # 이러면 A, C만 출력됨
+        ```
+
+4. 실습
+    1. to_numpy() : 데이터프레임 → 넘파이로 변환
+    2. predict_proba() : 클래스별 확률값
+
+        ![image.png](https://github.com/user-attachments/assets/8d3e963c-6f47-458f-883b-7a650a443fa8)
+
+    - 코드
+
+        ```python
+        import pandas as pd
+
+        fish = pd.read_csv('https://bit.ly/fish_csv_data')
+        # fish.head()
+
+        print(pd.unique(fish['Species']))
+        ```
+
+        ```python
+        fish_input = fish[['Weight', 'Length', 'Diagonal', 'Height', 'Width']].to_numpy()
+        print(fish_input[:5])
+
+        fish_target = fish['Species'].to_numpy()
+        ```
+
+        ```python
+        from sklearn.model_selection import train_test_split
+
+        # 훈련 세트, 테스트 세트 분리
+        train_input, test_input, train_target, test_target = train_test_split(fish_input, fish_target, random_state=42)
+
+        from sklearn.preprocessing import StandardScaler
+
+        # 전처리
+        ss = StandardScaler()
+        ss.fit(train_input)
+        train_scaled = ss.transform(train_input)
+        test_scaled = ss.transform(test_input)
+        ```
+
+        ```python
+        from sklearn.neighbors import KNeighborsClassifier
+
+        kn = KNeighborsClassifier(n_neighbors=3)
+        kn.fit(train_scaled, train_target)
+
+        print(kn.score(train_scaled, train_target))
+        print(kn.score(test_scaled, test_target))
+        ```
+
+        ```python
+        print(kn.classes_)
+
+        print(kn.predict(test_scaled[:5]))
+        ```
+
+        ```python
+        import numpy as np
+
+        proba = kn.predict_proba(test_scaled[:5])
+        print(np.round(proba, decimals=4)) # 소수 네 번째 자리까지
+        ```
+
+        ```python
+        distances, indexes = kn.kneighbors(test_scaled[3:4])
+        print(train_target[indexes]) # Roach 1개(0.3333), Perch 2개(0.6667)
+        ```
+
+        ```python
+        import matplotlib.pyplot as plt
+
+        z = np.arange(-5, 5, 0.1)
+        phi = 1 / (1 + np.exp(-z))
+        plt.plot(z, phi)
+        plt.xlabel('z')
+        plt.ylabel('phi')
+        plt.show() # 시그모이드 함수
+        ```
+
+        ```python
+        bream_smelt_indexes = (train_target == 'Bream') | (train_target == 'Smelt')
+        # 도미, 빙어일 경우 true / 그 외는 모두 false
+        train_bream_smelt = train_scaled[bream_smelt_indexes]
+        target_bream_smelt = train_target[bream_smelt_indexes]
+
+        from sklearn.linear_model import LogisticRegression
+
+        lr = LogisticRegression()
+        lr.fit(train_bream_smelt, target_bream_smelt)
+
+        print(lr.predict(train_bream_smelt[:5]))
+        print(lr.predict_proba(train_bream_smelt[:5]))
+        # 첫 번째 열 : 0에 대한 확률, 두 번째 열 : 1에 대한 확률 -> 이때 smelt가 0, bream이 1
+        print(lr.coef_, lr.intercept_)
+        ```
+
+        ```python
+        decisions = lr.decision_function(train_bream_smelt[:5])
+        print(decisions)
+
+        from scipy.special import expit
+        print(expit(decisions)) # z : predict_proba()의 두 번째 열(0)과 값 동일
+        ```
+
+        ```python
+        lr = LogisticRegression(C=20, max_iter=1000)
+        lr.fit(train_scaled, train_target)
+
+        print(lr.score(train_scaled, train_target))
+        print(lr.score(test_scaled, test_target))
+        print(lr.predict(test_scaled[:5]))
+
+        proba = lr.predict_proba(test_scaled[:5])
+        print(np.round(proba, decimals=3))
+
+        print(lr.coef_.shape, lr.intercept_.shape)
+        ```
+
+        ```python
+        decisions = lr.decision_function(test_scaled[:5])
+        print(np.round(decisions, decimals=3))
+
+        from scipy.special import softmax
+        proba = softmax(decisions, axis=1) # axis 매개변수를 지정하지 않음녀 배열 전체에 대해 소프트맥스 계산함
+        print(np.round(proba, decimals=3))
+        ```
+
+
+    [04_1.ipynb](04_1.ipynb)

week03/김다연/Chapter04/Chapter 04-2.md

@@ -0,0 +1,110 @@
+# Chapter 04-2
+
+1. **확률적 경사 하강법 (stochastic gradient descent)**
+    1. 전체 샘플을 사용하지 않고 **하나의 샘플**을 훈련 세트에서 랜덤하게 골라 가장 가파른 길 찾음
+        1. 전체 샘플 모두 사용할 때까지
+        2. 모든 샘플을 다 사용했는데 내려오지 못했다면 다시 처음부터
+
+1. **미니배치 경사 하강법 (minibatch gradient descent)**
+    1. **여러 개의 샘플**을 사용해 경사 하강법을 수행하는 방식
+    2. 전체 샘플 사용 → **배치 경사 하강법 (batch gradient descent)**
+        1. 데이터가 너무 많으면 **느림**
+
+1. **손실 함수 (loss function)**
+    1. 머신러닝 알고리즘이 **얼마나 틀렸는지** 측정
+    2. 손실 함수의 값이 **작을수록 좋음**
+    3. but 어떤 값이 최솟값인지는 알지 못함 (**local minimum**)
+    4. **연속적**이어야 gradient descent 사용 가능
+
+1. **logistic loss function (= binary cross-entropy loss function)**
+    1. 타깃이 1일 때 손실은 **-log(예측 확률)**
+        1. 확률이 1에서 멀어질수록 손실은 아주 큰 양수 됨
+    2. 타깃이 0일 때 손실은 **-log(1 - 예측 확률)**
+        1. 확률이 0에서 멀어질수록 손실은 아주 큰 양수 됨
+    3. 다중 분류라면 → **cross-entropy loss function**
+
+1. **에포크 (epoch)** : 훈련 세트 한 번을 모두 사용하는 과정
+    1. epoch 횟수 너무 **적으면** 학습 덜함 → **과소적합**
+    2. epoch 횟수 너무 **많으면** → **과대적합**
+    3. **조기 종료 (early stopping)**
+        1. 테스트 세트 점수가 감소하는 지점에서 훈련 멈춤 (**과대적합 방지**)
+
+1. 힌지 손실 (hinge loss = support vector machine)
+
+1. 실습
+    - 코드
+
+        ```python
+        import pandas as pd
+        fish = pd.read_csv('https://bit.ly/fish_csv_data')
+
+        fish_input = fish[['Weight', 'Length', 'Diagonal', 'Height', 'Width']].to_numpy()
+        fish_target = fish['Species'].to_numpy()
+
+        from sklearn.model_selection import train_test_split
+        train_input, test_input, train_target, test_target = train_test_split(fish_input, fish_target, random_state=42)
+
+        from sklearn.preprocessing import StandardScaler
+        ss = StandardScaler()
+        ss.fit(train_input)
+
+        train_scaled = ss.transform(train_input)
+        test_scaled = ss.transform(test_input)
+        ```
+
+        ```python
+        from sklearn.linear_model import SGDClassifier
+        sc = SGDClassifier(loss='log_loss', max_iter=10, random_state=42) # log : 로지스틱, max_iter : epoch
+        sc.fit(train_scaled, train_target)
+
+        print(sc.score(train_scaled, train_target))
+        print(sc.score(test_scaled, test_target))
+        ```
+
+        ```python
+        sc.partial_fit(train_scaled, train_target)
+        print(sc.score(train_scaled, train_target))
+        print(sc.score(test_scaled, test_target))
+        ```
+
+        ```python
+        import numpy as np
+
+        sc = SGDClassifier(loss='log_loss', max_iter=100, tol=None, random_state=42)
+        train_score = []
+        test_score = []
+
+        classes = np.unique(train_target)
+
+        for _ in range(0, 300):
+          sc.partial_fit(train_scaled, train_target, classes=classes)
+
+          train_score.append(sc.score(train_scaled, train_target))
+          test_score.append(sc.score(test_scaled, test_target))
+
+        import matplotlib.pyplot as plt
+        plt.plot(train_score)
+        plt.plot(test_score)
+        plt.xlabel('epoch')
+        plt.ylabel('accuracy')
+        plt.show()
+        ```
+
+        ```python
+        sc = SGDClassifier(loss='log_loss', max_iter=1000, tol=None, random_state=42) # None : 자동으로 멈추는 것 방지
+        sc.fit(train_scaled, train_target)
+
+        print(sc.score(train_scaled, train_target))
+        print(sc.score(test_scaled, test_target))
+        ```
+
+        ```python
+        sc = SGDClassifier(loss='hinge', max_iter=100, tol=None, random_state=42)
+        sc.fit(train_scaled, train_target)
+
+        print(sc.score(train_scaled, train_target))
+        print(sc.score(test_scaled, test_target))
+        ```
+
+
+    [04_2.ipynb](04_2.ipynb)

week03/이효진/chapter04-1.md

@@ -0,0 +1,35 @@
+# 04-1 | 로지스틱 회귀
+
+다중 분류 : 타깃 데이터에 2개 이상의 데이터가 포함된 문제
+
+### **로지스틱 회귀**
+
+: 분류 모델, 선형 방정식 학습. 
+
+이진분류에서는 시그모이드 함수를 이용해 z가 큰 음수일 때 0이 되고 큰 양수일 때 1이 되게 하여 0~1 사이 값이 되도록 함.
+
+### 로지스틱 회귀로 다중 분류 수행
+
+LogisticRegression클래스는 반복적인 최적화 알고리즘을 사용한다. max_iter매개변수로 반복 횟수를 지정할 수 있다.
+
+또한, 계수의 제곱을 규제하며 매개변수는 C(1/람다)이다. C는 L2규제의 강도를 조절하며 C가 작을 수록 규제가 커진다. 
+
+다중 분류에서는 소프트맥스 함수를 사용하여 z값을 확률로 변환한다.
+
+**소프트맥스** 함수 : 여러 개의 선형 방정식 출력값을 0~1사이의 확률로 압축하고 전체 합이 1이 되게 한다. 일반적인 맥스 함수는 최댓값 중 하나를 고르지만 소프트맥스는 최댓값에 높은 확률을 할당하면서 다른값에도 작은 확률을 부여한다.
+
+---
+
+궁금한 점
+
+Q . p.198- LogisticRegression클래스는 반복적인 알고리즘 사용? 반복 횟수 기본값 100?
+
+A . 반복적인 알고리즘은 Gradient discent 같은 최적화 알고리즘을 말하는 것으로, 이는 손실을 줄이는 방향으로 가중치를 조금씩 수정하며 반복해 손실이 최소가 되는 시점을 찾는 최적화 알고리즘임..  종류는 newton-cg, lbfgs, liblinear, sag, saga 로 5가지가 있고 기본값은 lbfgs임.
+
+1. newton-cg : 손실함수의 2차 미분정보를 사용해 곡률도 고려하여 최적화함. L2 규제 사용 가능
+2. lbfgs : 2차 미분행렬을 직접 계산하지않고 근사해서 속도를 개선함. L2 규제 사용가능
+3. liblinear : 경사하강법과 비슷하지만 한번에 하나의 파라미터만 업데이트한다는 차이점이 있다. L1,L2 규제 사용가능
+4. sag : 경사하강법과 비슷하지만 이전 경사값을 현재 업데이트에 사용한다.  L2 규제 사용 가능
+5. saga : sag의 업그레이드 버전으로 L1,L2,elasticent 규제 모두 사용가능한 방식
+
+[https://coduking.tistory.com/entry/로지스틱-회귀-Solver-종류와-장단점](https://coduking.tistory.com/entry/%EB%A1%9C%EC%A7%80%EC%8A%A4%ED%8B%B1-%ED%9A%8C%EA%B7%80-Solver-%EC%A2%85%EB%A5%98%EC%99%80-%EC%9E%A5%EB%8B%A8%EC%A0%90)

week03/이효진/chapter04-2.md

@@ -0,0 +1,25 @@
+# 04-2 | 확률적 경사 하강법
+
+1. **stocastic gradient descent** : train set에서 랜덤하게 하나의 샘플을 골라 gradient descent를 수행
+
+**epoch** : train set을 한 번 모두 수행하는 것
+
+1. **minibatch gradient descent** : train set에서 여러 개의 샘플을 골라 gradient descent를 수행
+2. **batch gradient descent** : train set 전체 샘플을 사용
+
+### 손실함수 ( **loss function )**
+
+ : 어떤 문제에서 모델이 얼마나 틀렸는지 측정하는 기준. 미분 가능해야함.
+
+1. **logistic loss function** : 이진 분류 손실함수. 
+2. **cross-entropy loss function** : 다중 분류 손실함수
+
+### **에포크와 과대/과소적합 관계**
+
+에포크 횟수가 너무 적으면 모델이 train set을 덜 학습하는 과소적합
+
+에포크 횟수가 너무 많으면 모델이 train set에 너무 잘 맞는 과대적합
+
+조기 종료 : 과대적합이 시작되기 전에 훈련을 멈추는 것
+
+SGDClassifier의 loss매개변수의 기본값은 hinge임.