onesword 님의 블로그

머신러닝의 구성요소

• 데이터 셋: 데이터 모음
• 입력 데이터 특징(Feature): 데이터셋의 개별 속성
• 출력 데이터 레이블(lable): 예측하고자 하는 예측 변수
• 모델: 정다(레이블)을 예측할 수 있는 지식을 학습할 수 있는 프로그램
• 학습: 모델이 데이터를 통해 패턴을 인식하고, 이를 기반으로 예측을 수행 할 수 있도록 함수 내의 가중치를 조정하는 과정
• 훈련: 모델이 데이터를 통해 학습하는 과정
• 테스트: 학습된 모델의 성능을 평가하는 과정

🔎 학습방법

지도학습(레이블 O)

회귀: 연속적인 값 예측 (주택 가격, 주식 가격)

분류: 이산적인 값 예측(스팸 필터링, 이미지 분류)

비지도 학습(레이블 X)

군집화: 데이터를 유사 그룹으로 묶는 문제(고객 세분화, 이미지 세그멘테이션)

이미지 세그멘테이션: 이미지을 픽셀단위로 나누어 어떤 객체에 또는 어떤 영역에 속하는지 구분하는 기술

차원축소: 고차원 데이터를 저차원으로 변환(PCA, t-SNE)

앙상블 학습(여러개의 모델 결합)

배깅: 여러 모델을 독립적으로 학습시키고, 에측을 평균내거나 다수결 투표(랜덤 포레스트)

부스팅: 여러 모델을 순차적 학습시키고, 이전 모델의 오차를 보완

스태킹: 여러 모델을 학습시키고 예측결과를 새로운 데이터로 사용하여 메타 모델을 학습

☑️ 데이터 셋 다운 및 기본정보 확인

kaggle

예시 : 타이타닉 데이터셋 다운로드

• kaggle competitions download -c titanic

다운로드한 데이터 import

• import pandas as pd
• train_df = pd.read_csv('train.csv')
• test_df = pd.read_csv('test.csv')

데이터 확인

• 행열 확인 print(df.shape)
• 컬럼명 확인 print(df.columns)
• 타입확인 print(df.dtypes)
• 통계 확인 print(df.describe())
• 정보확인(NULL갑스 타입 등) print(df.info()) 

☑️ 데이터 전처리

🔎 결측치 처리

• 제거

df_dropped_rows = df.dropna() # null 행 제거

df_dropped_cols = df.dropna(axis=1) #null 열 제거

• 대체

df_filled = df.fillna(0) 0으로 대체

df_filled_mean = df.fillna(df.mean())평균값으로 대체

df_filled_median = df.fillna(df.median()) 중간값으로 대체

df_filled_mode = df.fillna(df.mode().iloc[0]) 각 열의 최빈값으로 대체

• 예측

#sklearn의 linear에서 LinearRegression 회귀모델 임포트

from sklearn.linear_model import LinearRegression

#결측치 있는 열과 없는 열 구분

df_with_na = df[df['column_with_na'].isnill()]

df_without_na = df[df['column_with_na'].notnull()]

model = LinearRegression()

model.fit(df_without_na[['feature1', 'feature2']], df_without_na['column_with_na'])

predicted_values = model.predict(df_with_na[['feature1', feature2']])

df.loc[df['column_with_na'].isnull(), 'column_with_na'] = predicted_valuse

🔎이상치 처리

데이터 셋에서 비정상적인 값 처리

• 확인IQR

#특정 열의 이상치 확인

#25%보다 작거나 75%보다 크면 이상치로 처리

#quantile로 이상치의 기준점 설정

Q1 = df['C'].quantile(0.25)

Q3 = df['C'].quantile(0.75)

IQR = Q3 - Q1 

#이상치 범위 설정

lower_bound = Q1 - 1.5 * IQR

upper_bound = Q3 + 1.5 * IQR

#여기서 |는 OR의 논리연산자

#C열의 값중 lower_bound보다 작거나 upper_bound보다 큰 수를 이상치로 간주해 outliers에 저장해서 확인

outliers = df[(df['C'] < lower_bound) | (df['C'] > upper_bound)]

print(outliers)

#C 열의 값이 lower_bound와 크거나 같은 값 그리고upper_bound보다 작거나 같은 값을 df_no_outliers에 저장

df_no_outliers = df[(df['C'] >= lower_bound) & (df['C'] <= upper_bound)]
print(df_no_outliers)

#C열의 평균값을 mean_value에 저장

#apply를 사용해서 C에 대해 특정 함수나 연산을 적용

#lambda로 함수식을 한줄로 정리 x에는 c열의 각 값이 들어간다.

#C 열의 각 값을 검사하여, 값이 lower_bound보다 작거나 upper_bound보다 크면 그 값을 해당 열의 평균값으로 대체, 아니면 값 유지

mean_value = df['C'].mean()

df['C'] = df['C'].apply(lambda x: mean_value if x < lower_bound or x > upper_bound else x)

🔎중복값 제거

#중복된 행 확인

print(df.duplicated().sum())

#제거

df_no_duplicates = df.drop_duplicates()

🔎데이터 타입 변환

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

df['column_name'] = df['column_name'].astype(str)

df['column_name'] = df['column_name'].astype(float)

🔎인코딩

머신러닝은 수치형 데이터를 인자로 받기 때문에 범주형 데이터를 수치형으로 변환 하는거다.

원핫 인코딩

#get_dummies를 활용해 수치형 데이터로 바꾼다.

#get_dummies를 진행할 df데이터 프레임의 category_column카테고리 컬럼을 지정

df_encoded = pd. get_dummies(df, columns=['category_column'])

print(de_encoded.head())

🔎샘플링 랜덤으로 추출

#50% 샘플 추출

#비율 frac

df_sampled = df.sample(frac=0.5)

#100개 샘플 추출

#개수 n

df_sampled_n = df.sample(n=100)

🔎특징 선택 및 추출

#SelectKBest k개의 특징을 선택하는 방법을 제공하는 클래스

#f_classif 독립변수와 종속변수 사이의 상관성을 측정하여 높은 상관성을 가진 특성을 선택(분류문제에서 사용)

from sklearn.feature_selection import SelectKBest, f_classif

#selector객체 생성

#score_func = f_classif 특징에 F-값을 계산해 높은 값 가진 특징이 더 중요하다고 간주

#k는 가장 중요한 5개의 특징 선택 지정 

selector = SelectKBest(score_func=f_classif, k=5)

#fit_transform입력 데이터(주어진 데이터)X, 타겟 레이블(정답 값)y 특징 선택 수행

#X_new에 선택된 5개의 특징으로 된 새로운 데이터셋 지정

X_new = selector.fit_transform(X, y)

#get_support(indices=True)는 선택된 특징들의 인덱스를 반환

selected_features = selector.get_support(indices=True)

print(selected_features)

# 두 열의 곱을 새로운 특징으로 추가
df['new_feature'] = df['feature1'] * df['feature2']

# 두 열의 합을 새로운 특징으로 추가
df['new_feature_sum'] = df['feature1'] + df['feature2']

☑️ 회귀모델 학습

Scikit_learn

기능

데이터 전처리

모델 학습

모델 평가

모델 예측

Scikilt-learn 설치

conda install scikit-learn

pip install scikit-learn

회귀 모델 예제

import pandas as pd

import numpy as np

# train_test_split 데이터를 훈련 세트와 테스트 세츠로 나누기 위한 함수

#  LinearRegression연속적인 값 예측하는 회귀 문제 해결

# mean_squared_error, r2_score모델의 성능을 평가하기 위한 메트릭

from sklearn.model_selection import train_test_split

from sklearn.linear import LinearRegression

from sklearn.metrics import mean_squared_error, r2_score

#데이터 생성

#X는 독립변수(특징) 데이터 (6개의 샘플, 2개의 특징)

#y는 종속변수(타겟) 데이터(각 샘플의 정답값)

X = np.array([[1, 1], [2, 2], [3, 3], [4, 4], [5, 5],[6,6]])
y = np.array([1, 2, 3, 4, 5, 6])

#데이터 분할

# train_test_split(...)주어진 데이터를 훈련 데이터와 테스트 데이터로 나누는 함수

#test_size=0.2 전체 데이터의 20%를 데스트 데이터로 설정 나머지는 훈련 데이터 설정

#random_state=42 데이터 분할의 일관성을 위해 랜덤 시드를 설정

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

랜덤 시드는 어떻게 결정해야하는가?

임의로 정한다. 일반적으로 정수 값을 사용하며, 0 이상의 정수를 설정한다

42라는 정수를 사용했을 뿐, 특별한 의미는 없다.

#회귀 모델 생성 및 학습

model = LinearRegression() #선형 회귀 모델의 인스턴스 생성

model.fit(X_train, y_train) #생성한 모델에 훈련 데이터를 학습 시킨다. x_train과 y_train 데이터 기반으로 학습

인스턴스는 왜 생성하는가?

선형 회귀 알고리즘을 사용하여 데이터에 대해 학습(fit)하고 예측(predict), 모델 파라미터 확인(model.coed_로 회귀계수를 model.intercept_로 절편을 확인 가능)하기 위함

#예측

# model.predict(X_test) 학습된 모델을 사용하여 테스트데이터 X_test에 대한 예측값을 계산.예측 결과는 y_pred에 저장

y_pred = model.predict(X_test)

 model.predict도 메서드 함수인가?

메서드이다. 메서드는 특정 클래스의 인스턴스에서 사용할 수 있는 함수

#모델 평가

# mean_squared_error(y_test, y_pred): 테스트 데이터에 대한 실제 값 y_test와 예측 값 y_pred 간의 평균 제곱 오차(MSE)를 계산

# MSE는 예측의 정확성을 나타내는 지표로, 값이 작을수록 모델의 성능이 좋다는 의미

mse = mean_squared_error(y_test, y_pred)

# r2_score(y_test, y_pred): 결정 계수 R2R^2R2를 계산. R2R^2R2 값은 모델의 설명력을 나타내며, 1에 가까울수록 모델이 실제 데이터를 잘 설명한다는 뜻. 0이면 모델이 종속 변수의 평균으로 예측하는 것과 같고, 음수일 경우 모델이 평균보다 더 나쁜 성능을 보이는 것.
r2 = r2_score(y_test, y_pred)
print(f'Mean Squared Error: {mse}')
print(f'R^2 Score: {r2}')

☑️ 로지스틱모델 학습

import numpy as np
import pandas as pd

#  load_breast_cancer 유방암 데이터셋 로드
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

# StandardScaler데이터의 평균을 0, 분산을 1로 스케일링
from sklearn.preprocessing import StandardScaler

스케일링을 왜 진행하고 왜 평균을 0, 분산을 1로 만드는 건가

모델 성능과 학습 속도에 긍정적인 영향

스케일링을 통해 입력 특징이 동일한 스케일로 변환되면, 알고리즘이 더욱 빠르고 효율적으로 수렴하고 정규화 가능

평균을 0으로 만드는 이유: 스케일링을 통해 데이터의 중심을 원점으로 이동시킴으로써 모델이 각 변수에 대한 가중치를 더 공정하게 학습할 수 있도록 합니다.

분산을 1로 만드는 이유: 데이터의 변동성을 통일하여 스케일 차이로 인해 발생하는 문제를 완화.

# 데이터 로드
data = load_breast_cancer()
X = data.data
y = data.target

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 데이터 스케일링
scaler = StandardScaler()

#훈련 세트, 테스트 세트를 스케일링하고 변환
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

#모델 학습

# LogisticRegression 이진 분류 문제를 해결

from sklearn.linear_model import LogisticRegression

# accuracy_score 모델의 정화도 계산 함수

# classifcation_report 정밀도, 재현율, F1점수 등 모델의 성능을 요약한 보고서 생성 함수

# confusion_matrix 예측 결과와 실제 값을 비교하여 혼동 행렬 생성 함수(모델의 분류 성능 시각화)

from sklearn.metrics import accuracy_score, classifcation_report, confusion_matrix

model = LogisticRegression()

model.fit(X_train, y_train)

y_pred = model.predict(X_test)

# accuracy_score(y_test, y_pred) 실제값 y_test와 예측 값 y_pred를 비교하여 정확도 계산

print(f"Accuracy: {accuracy_score(y_test, y_pred)}")

# classification_report(y_test, y_pred) 모델의 성능을 요약하여 출력(정밀도, 재현율,F1점수, 지원)

print(f"Classification Report:\n{classification_report(y_test, y_pred)}")

# confusion_matrix(y_test, y_pred) 혼동 행렬을 생성하여 모델의 성능을 시각적으로 나타낸다.

print(f"Confusion Matrix:\n{confusion_matrix(y_test, y_pred)}")

정밀도Precision

재현율 Recall

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

지원Support 각 클래스의 속한 실제 샘플 수

평균 Average 나온 숫자들이 비슷할 수록 좋다.

혼동행렬에서 행은 실제 클래스, 열을 예측 클래스

☑️ 생성형 AI를 활용한 학습 방법과 Prompt Engineering

프로그래밍 vs인공지능 모델

공통점: 개발자가 주어진 입력이 무엇을 출력할지 설계

차이점:

프로그래밍은 입출력의 관계에 대한 알고리즘을 직접구현

인공지능 모델을 입출력의 관계를 데이터를 통해 학습

생성형AI

이미지 생성AI DALL-E, Midjourney, Stable Diffusion Web UI

동영상 생성AI Gen-3, 

텍스트 생성 AI: 챗지피티, Claide, Gemimi, Preflexty

음악 생성AI Suno, Udio

LLM대규모 언어 모델

텍스트 생성, 번역, 질문 답변, 요약 등

다양한 언어 관련 작업을 하나의 모델에서 수행

대표적

OpenAI(GPT)

Google(Gemini)

Meta(LLaMA3)

LLM의 원리

입력과 출력 사이의 조건부 확률 분포를 학습합니다.

새로운 입력이 주어졌을 때 학습된 조건부 확률 분포를 통해 모든 토큰별 확률을 예측하고, 그 중 가장 가능성이 높은 토큰을 선택하여 답변

몬티홀 문제(조건부 문제)

LLM의 한계

실제로 계산 하는게 아니라서 학습 데이터 분포를 벗어난 입력을 넣으면 신뢰할 수 없는 출력을 생성할 확률이 매우 큼

데이터 편향

데이터 오류

모호한 지시 처리: 다양한 해석을 할 수 있는 질문이나 지시 => 세부적인 정보와 구체적인 답변 예시 등을 통해 답변 할 수 있도록 유도

맥락 유지의 어려움: 핵심정보 요약해 맥락 유지

할루시네이션: 문맥에 맞는 듯 보이지만 실제로는 근거없는 내용을 생성하는 현상으로, 사용자에게 잘못된 정보를 제공할 수 있음

외부 지식 및 데이터 베이스의 내용을 프롬프트에 넣어 해당 내용에 근거해 답변을 생성하도록 함 (RAG, Retrieval-Augmented Generation)

정보의 한계: 최신 정보 및 새로운 전문적인 지식을 제공 못함

질문에 대한 내용을 인터넷에서 검색 후 LLM

프롬프트 엔지니어링 기초

명확한 지침 제공: 중요한 세부 사항이나 문맥 및 제약 조건 등을 명시

페르소나 부여: 시스템 메세지를 사용하여 모델에 페르소나 부여

프롬프트 명시적 구조화(형식적 구조 예시화)

줄임말 순화 프로그램 만들기

☑️ 회고

랜덤 시드는 어떻게 결정해야하는가?

임의로 정한다. 일반적으로 정수 값을 사용하며, 0 이상의 정수를 설정한다

42라는 정수를 사용했을 뿐, 특별한 의미는 없다.

인스턴스는 왜 생성하는가?

선형 회귀 알고리즘을 사용하여 데이터에 대해 학습(fit)하고 예측(predict), 모델 파라미터 확인(model.coed_로 회귀계수를 model.intercept_로 절편을 확인 가능)하기 위함

 model.predict도 메서드 함수인가?

메서드이다. 메서드는 특정 클래스의 인스턴스에서 사용할 수 있는 함수

스케일링을 왜 진행하고 왜 평균을 0, 분산을 1로 만드는 건가

모델 성능과 학습 속도에 긍정적인 영향

스케일링을 통해 입력 특징이 동일한 스케일로 변환되면, 알고리즘이 더욱 빠르고 효율적으로 수렴하고 정규화 가능

평균을 0으로 만드는 이유: 스케일링을 통해 데이터의 중심을 원점으로 이동시킴으로써 모델이 각 변수에 대한 가중치를 더 공정하게 학습할 수 있도록 합니다.

분산을 1로 만드는 이유: 데이터의 변동성을 통일하여 스케일 차이로 인해 발생하는 문제를 완화.

합성곱 신경망(CNN)

순환 신경망(RNN)

어테션(Atention) 메커니즘

자연어 처리(NLP) 모델

회고

☑️ 합성곱 신경망(CNN)

🔎합성곱 신경망(CNN)이란?

• 이미지와 같은 2차원 데이터의 특징을 효과적으로 추출하기 위해 설계 된 신경망
• 필터를 통해 필터 내부의 값들을  학습함으로써 
• 합성곱 층, 풀링 층, 완전연결 층으로 구성
  • 합성곱 층:                                                                                                                                                                   - 다차원 데이터의 특징을 효과적으로 추출                                                                                                               - 입력 이미지에 필터(커널)을 적용하여 특징 맵을 생성                                                                                             - 필터는 이미지의 국소적인 패턴을 학습
  • 풀링 층                                                                                                                                                                         - 특징 맵의 크기를 줄이고 중요한 특징을 추출                                                                                                           - 주로 Max Pooling 과 Average Pooling이 사용
  • 완전 연결 층                                                                                                                                                                - 추출된 특징을 바탕으로 최종 예측을 수행                                                                                                              - CNN이라는 분석레이어를 통해 추출한 특성을 바탕으로 결론을 내리는 부분

🔎 합성곱 연산의 원리와 필터의 역할

• 합성곱 연산은 입력 이미지에 필터(커널)를 적용하여 특징 맵을 생성하는 과정입니다. 필터는 작은 크기의 행렬로, 이미지의 국소적인 패턴을 학습합니다.

1. 합성곱 연산:
   • 필터를 이미지의 각 위치에 슬라이딩하며, 필터와 이미지의 해당 부분 간의 점곱(dot product)을 계산합니다.
   • 계산된 값은 특징 맵의 해당 위치에 저장됩니다.
2. 필터의 역할:
   • 필터는 이미지의 에지(edge), 코너(corner), 텍스처(texture) 등 다양한 국소적인 패턴을 학습합니다.
   • 여러 개의 필터를 사용하여 다양한 특징 맵을 생성할 수 있습니다.

🔎 풀링 레이어의 필요성과 종류

• 풀링 층은 특징 맵의 크기를 줄이고, 중요한 특징을 추출하는 역할을 합니다. 풀링 층은 주로 Max Pooling과 Average Pooling이 사용됩니다.

1. Max Pooling:
   • 필터 크기 내에서 최대 값을 선택합니다.
   • 중요한 특징을 강조하고, 불필요한 정보를 제거합니다.
2. Average Pooling:
   • 필터 크기 내에서 평균 값을 계산합니다.
   • 특징 맵의 크기를 줄이면서, 정보의 손실을 최소화합니다.

🔎 플래튼 레이어의 역할

• 플래튼 층(Flatten Layer)은 2차원 특징 맵을 1차원 벡터로 변환하는 역할을 합니다. 이는 완전 연결 층에 입력으로 사용하기 위해 필요합니다. 

📚CNN 모델 정의

calss SimpleCNN(nn.Module): #nn.module을 import
    def__init__(self):
        super(SimpleCNN, self).__init__()
        #nn.Conv2d(입력채널, 출력 채널, 커널크기 3*3)
        #입력채널에 흑백사진은 1, RGB(컬러)인 경우에 3
        #출력채널이 증가하는 이유는 필터의 개수를 조절할 수 있기 때문
        self.conv1 = nn.Conv2d(3, 32, 3, padding=1) 
        self.pool = nn.MaxPool2d(2, 2)
        #다음 레이어의 입력은 그 전의 출력과 동일해야 한다.
        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)
        self.fc1 = nn.Linear(64 * 8 * 8, 512)
        self.fc2 = nn.Linear(512,10)
        

    def forward(self, x):
        #relu 컨볼루션할 네트워크 뒤에 활성화 함수가 와야한다.(복잡한 데이터 특성 학습하기 위해)
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 64 * 8 * 8)  # 플래튼 (차원 축소 즉. 펼친다)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x        

☑️ 순환 신경망(RNN)

🔎 순환 신경망(RNN)

• 시퀀스 데이터를 다루는데 유용 (주가 / 문장 등 데이터가 숱서를 이루고있을 때)
• 시계열 데이터를 처리하기 위해서 각 시점에서 입력을 받는다. tn => 그 때 출력을 바로 다음 시간에 입력으로 받는다 => 이 과정에서 이전 시점의 정보를 저장하는 숨겨진 상태
• RNN의 기본 요소는 순환노드 일반적으로 쉘 각 시점의 입력과 숨겨진 상태를 결합해 새로운 숨겨진 상태와 출력을 만든다 이렇게 새롭게 만들어진 hidden state는 다시 순환을 한다.
• 시퀀스의 각 시간 단계에서 동일한 가중치 공유 (가중치가 전체적으로 업데이트 된다.)

🔎LSTM & GRU

• 기울기 소실 문제 해결 위한 방법

1. LSTM은 셀 + 게이트(입력게이트 / 망각 게이트/출력 게이트)로 구성

• 셀: 각 시점 정보흐름 조절, 정보 장기 유지
• 게이트: 정보를 선택적으로 저장하거나 삭제
• 입력 게이트: 새로운 입력과 이전의 숨겨진 상태를 결합해서 새로운 정보가 새 상태에 얼마나 반영할지 조절해준다.
• 망각 게이트: 새 상태에서 어떤 정보를 잊을지 정해준다.
• 입력 / 망각 게이트의 출력을 바탕으로 쉘상태 업데이트 한다.
• 출력 게이트: 새로운 쉘 상태와 입력 데이터를 바탕으로 출력을 생성
• 그리고 다시 순환한다.

2. GRU

• LSTM의 변형으로 더 간단한 구조
• 쉘상태와 hidden state를 통합한다.
• 리셋/ 업데이트 게이트로 구성
• 리셋 게이트: 새정보와 이전 정보를 결합해 이전 정보를 얼마나 잊어 버리는기 결정하는데 사용
• 업데이트 게이트: 이전 상태와 새로운 입력을 결합 그리고 새로운 정보가 상태에 반영할지 결정

=> RNN은 시퀀스 데이터에 적합하다 이전 단계를 반영할 수 있어서 근데 긴 시퀀스에선 정상적이지 않아 게이트를 활용해 정보를 체계적으로 관리하는 LSTM과 GRU가 나왔다.

🔎시계열 데이터 처리

1. 데이터 전처리:
   • 시계열 데이터를 적절한 형태로 변환하고, 정규화(normalization)합니다.
   • 입력 시퀀스와 출력 시퀀스를 정의합니다.
2. 모델 구축:
   • RNN, LSTM, GRU 등의 모델을 정의합니다.
   • 입력 크기, 은닉 상태 크기, 출력 크기 등을 설정합니다.
3. 모델 학습:
   • 손실 함수와 최적화 알고리즘을 정의합니다.
   • 순전파와 역전파를 통해 모델을 학습시킵니다.
4. 모델 평가:
   • 테스트 데이터를 사용하여 모델의 성능을 평가합니다.

📚데이터 셋 생성 및 전처리

# Sine 파형 데이터 생성 (sine함수는 위아래로 구불구불하게 반복되는 것)
def create_sine_wave_data(seq_length, num_samples):
    X = []
    y = []
    for _ in range(num_samples):
        start = np.random.rand()
        x = np.linspace(start, start + 2 * np.pi, seq_length)
        X.append(np.sin(x))
        y.append(np.sin(x + 0.1))
    return np.array(X), np.array(y)

seq_length = 50
num_samples = 1000
X, y = create_sine_wave_data(seq_length, num_samples)

# 데이터셋을 PyTorch 텐서로 변환(pytorch에서tensor라는건 기울기를 계산할 수 있는 자료구조)
X = torch.tensor(X, dtype=torch.float32).unsqueeze(-1)
y = torch.tensor(y, dtype=torch.float32).unsqueeze(-1)

📚RNN 모델 정의

class SimpleRNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleRNN, self).__init__()
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True) #RNN만들기( batch_first=True는 첫번째 batch 결정)
        self.fc = nn.Linear(hidden_size, output_size) #출력레이어

    def forward(self, x):
        h0 = torch.zeros(1, x.size(0), hidden_size)  # 초기 은닉 상태 (초기 값에는 hidden state가 없기 때문)
        out, _ = self.rnn(x, h0) #rnn에 x를 전달해주고 다시 은닉상태 전달
        out = self.fc(out[:, -1, :])  # 마지막 시간 단계의 출력
        return out

input_size = 1
hidden_size = 32
output_size = 1
model = SimpleRNN(input_size, hidden_size, output_size)

📚LSTM모델 정의

class SimpleLSTM(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleLSTM, self).__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        h0 = torch.zeros(1, x.size(0), hidden_size)  # 초기 은닉 상태
        c0 = torch.zeros(1, x.size(0), hidden_size)  # 초기 셀 상태
        out, _ = self.lstm(x, (h0, c0))
        out = self.fc(out[:, -1, :])  # 마지막 시간 단계의 출력
        return out

model = SimpleLSTM(input_size, hidden_size, output_size)

📚모델학습

# 손실 함수와 최적화 알고리즘 정의
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01) #여기선 Adam을 쓰고있는데 SGD나 다른 것들도 있지만 실험적으로 사요해보아야한다.

# 모델 학습
num_epochs = 100
for epoch in range(num_epochs):
    outputs = model(X)
    optimizer.zero_grad()
    loss = criterion(outputs, y)
    loss.backward()
    optimizer.step()

    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')

print('Finished Training')

☑️ 어텐션 (Attention) 메커니즘

🔎 어텐션 (Attention) 메커니즘란?

• 시퀀스 데이터의 중요한 부분에 많은 가중치를 할당해서 종보를 효율적
• 자연어 처리, c계열 데이터에서 사용 (번, 요약, 질의 응답 등)
• 입력의 시퀀스를 보고 중요도를 평가해 가중치로 바뀌어 각 요소에 부여

🔎 어텐션 (Attention) 메커니즘란 동작방식

• Atention score(중요도) = query와 key간의 유사도를 dot product를 사용해 계산
• 계산된 Atention score(중요도)는 Softmax 함수를 통해 확률로 변환
• 모든 Atention score (가중치)의 합은 1이 된다
• 이 Atention score(가중치)를 value에 곱한다
• 그러면 value에는 가중치가 반영된 정보다 된다.(중요한 부분이 어딘지 판별할 수 있게 되는 것이다)

• 비유

1. 독서클럽에서 책을 읽는다(책=시퀀스입력데이터)
2. 멤버들이 서로 질문을하고 답을 참고하며 중요도를 찾는다
3. 답(key), 질문(query쿼리)을 비교해서 얼마나 중요한지 평가 후 가중치 부여
4. 최종덕으로 답에 기반해서 최종 요약(value)을 만든다.

🔎 Multi-Head Attention

• Multi-Head Attention은 여러 개의 Self-Attention을 병렬로 수행하는 메커니즘입니다.
• 각 헤드는 서로 다른 부분의 정보를 학습하며, 이를 통해 모델이 다양한 관점에서 데이터를 처리할 수 있습니다.

☑️ 자연어 처리(NLP) 모델

🔎  자연어 처리(NLP)란?

• 자연어를 컴퓨터가 이해하고 처리할 수 있도록 돕는 기술을 자연어 처리(NLP)라고 합니다. 이를 통해 컴퓨터는 사람의 언어를 분석하고, 번역하거나 질문에 답하는 등의 작업을 수행할 수 있습니다

🔎워드 임베딩 기법

• 단어를 고정된 크기의 백터(숫자)로 변환 시킨다.
• 대표적인 워드 임베딩 기법으로는 Word2Vec과 GloVe가 있습니다.

Word2Vec

단어를 백터로 변환하는 2가지 모델 제공

• CBOW (Continuous Bag of Words): 주변 단어(context)로 중심 단어(target)를 예측합니다.                                          ( 나 장한검 백수 라고 하면 "나" 와 "백수"를 사용해 예측한다.)
• Skip-gram: 중심 단어(target)로 주변 단어(context)를 예측합니다.                                                                                    ( 나 장한검 백수에서 "장한검"을 보고 "나"와 "백수" 예측)

GloVe

단어-단어 공기행렬(word-word co-occurrence matrix)을 사용, 단어 벡터를 학습합니다

🔎 Transformer의 구조와 원리

• Transformer는 순차적인 데이터를 병렬로 처리할 수 있는 모델로, 자연어 처리에서 뛰어난 성능을 보입니다.
• Transformer는 인코더-디코더(Encoder-Decoder) 구조로 구성됩니다

인코더

입력 문장을 인코딩(고차원 백터로 변환)

• 입력 백터들이 각각 고정된 크기의 백터(임베딩)으로 변환(이 때 포지셔널 인코딩이라는 것을 포함해서 단어의 순서정보를 백터에 포함 시켜준다)
• Multi-Head의 selfatention이 동작한다. 입력 백터들이 각기 다른 헤드를 통해 서로의 중요도를 평가하고 이 정보로부터 새로운 백터를 만든다.
• selfatention메커니즘을 사용해서 문장 내에 관계를 학습하게 된다.

디코더

• 위 백터를 보고 출력하고자하는 목적에 따라 문장을 생성
• 타겟문장의 각 단어를 고정 된 크기의 백터로 변환한다
• 포지셔널 인코딩을 추가
• 마스크드 멀티헤드 셀프 어텐션이 동작한다. (이전의 단어들만 참고할 수 있도록 selfatention을 마스킹해서 참고한다)
• 인코더 디코더 어텐션이 동작(디코더는 인코더의 출력백터를 참고하고 입력문장의 정보를 바탕으로 타겟문장의 다음 단어를 예측한다.)
• 어텐션으로 변환 된 백터가 나오는데 피드포워드신경망을 통해 추가로 변환된다.
• 이러한걸 여러 층을 통해 반복해서  인코딩 백터를 만들고 이걸 이용해 디코딩 백터를 만든다.

어텐션 메커니즘

• 어텐션 메커니즘은 입력 시퀀스의 각 위치에 가중치를 부여하여, 중요한 정보를 강조합니다.
• 셀프 어텐션은 입력 시퀀스 내의 단어 간의 관계를 학습합니다.

=> 인코더 디코더를 통해 입력문장을 인코딩하고 디코더를 통해 출력을 생성 이 과정에서 어텐션 메커니즘이 사용 되고 이는 단어간의 관계를 학습하는데 사용하게 된다. 

인코더 디코더 어텐션을 통해 입력과 출력을 연결하고 모델은 데이터의 의미적 유사성을 학습하고 이를 바탕으로 번역을 진행하게 된다.

🔎 BERT란?

• Transformer 인코더를 기반으로 한 사전 학습된 언어 모델입니다.
• 양방향으로 문맥을 이해할 수 있어, 다양한 자연어 처리 작업에서 뛰어난 성능을 보입니다.
• 사전학습: 대규모 텍스트 코퍼스를 사용해 학습 된다. (마스킹 언어 모델, 다음 문장 예측 작업으로 학습)
• 입력을 처리해서 입력문장은 토큰화해서 단어토큰으로 변환
• 마스킹해서 일부 스퀀시를 마스킹한다.
• 인코더는 마스킹 된 시쿼스를 인코더로 처리해서 각 단어의 컨텍스트를 이해하고 마스킹 된 단어를 예측하고 다음 문장이 올바른지 예측하는 방식으로 동작

=> 사전학습된 bert모델은 특정 작업에 맞게 파인 튜닝 되는에 이를 통해 번역, 질의응답, 분류 등 다양한 목적에 맞춰 모델을 튜닝하게 된다.

☑️회고

최근 회고에는 궁금하거나 새롭게 알게 된 정보가 적게 들어 가는 것 같습니다.

그도그럴게 현재 배우는 부분이 머신러닝 딥러닝이다 보니 정의나 개념 새롭게 보게 되는 코드들이 어떤 작용을 하는지에 대한 부분만 주의 깊게 공부하고있기 때문입니다.

그래서 오전에 공부한 용어 공부 중 

마음 속 한켠에 자리잡고있던 궁금증을 해결한 것을 적으려고 합니다.

그것은 바로 차원 배열 ndarray에 대한것 입니다.

1차원 2차원 3차원 4차원 처음 들었을 때는 저게 뭐지 싶었고

설명을 들으면 들을수록 코드를 작동시켜 답을 출력 시켜보아도 어떤 것인지 모르겟고 

그냥 저런게 있구나 하고 넘어 갓는데 

오늘 어느정도 이해했습니다.

• 3차원에 대한 이해

shape함수로 차원을 확인할 수 있습니다. 1차원 (n,)#(행) / 2차원 (n, n)#(행, 열) / 3차원(n, n, n)#(높이,행,열)

저는 3 차원이 이해가 안 가서

제가 이해하기 쉽게 하려고 엑셀 표 형식을 떠 올려서 정리를 했습니다.

arr_3d = np.array([ [[1, 2], [3, 4]], [[5, 6], [7, 8]] ])

print(arr_3d.shape) #출력: (2, 2, 2)

각 셀마다 한 개의 숫자들이 들어간 2x2표가 2개가 만들어진 것이다.

셀 8개 중에 4개씩 1개의 표를 만들어 2개의 표가 된 것이 3차원

차원의 수로 표의 수가 정해지는 건지 궁금해져서 gpt에 물어보니 그건 또 아니네요

표가 늘어나는건 3차원 (n1,n2,n3)에서 n1인 높이 숫자가 올라가는거라고 하네요

• 브로드캐스팅

브로드캐스팅에서 두 개의 배열 중 하나라도 크기가 1인 것이 없으면 오류가 난다고 했는데 1은 바로 열의 크기였습니다.

쉽게 말해 대괄호[] 안에 1가지의 숫자만 들어간 배열이여야지 차원이 다른 배열끼리 브로드캐스팅이 된다고 합니다.

차원의 수가 올라갈수록 배열에 대괄호가 많아지는 것 같은데 정확히 어떻게 짜야하는 이해가 안되더군요.

그래도 고차원의 배열을 직접 손으로는 칠일은 없겟지 하는 마음으로 대괄호가[] 늘어나는구나 정도로 이해하고 넘어가겟습니다. 감사합니다. 

• 딥러닝 개념
• 신경망의 기본 원리
• 인공 신경망
• 회고

☑️ 딥러닝 개념

🔎딥러닝이란?

• 딥러닝은 인공신경망(Artificial Neural Networks)을 기반으로 한 기계 학습의 한 분야입니다.
• 다층 신경망을 사용하여 데이터로부터 특징을 자동으로 학습하고, 이를 통해 복잡한 문제를 해결합니다.
• 입력 데이터에서 중요한 패턴을 추출하고, 이를 바탕으로 예측, 분류, 생성 등의 다양한 작업을 수행할 수 있습니다.
• 머신러닝에서 중요한 패턴은 큰영향을 주는 데이터를 말한다.(문제해결을 위해 가장 잘 동작하는 특징)

🔎딥러닝의 특징

• 비선형 추론: 딥러닝은 비선형 추론을 통해 복잡한 데이터의 패턴을 학습할 수 있습니다.
• 다층 구조: 여러 층의 신경망을 사용하여 데이터의 고차원 특징을 학습합니다.
• 자동 특징 추출: 데이터로부터 중요한 특징을 자동으로 추출하여 별도의 특징 공학(feature engineering) 과정이 필요 없습니다.

🔎머신러닝과의 차이 

• 머신러닝: 데이터 전처리를 통하여 중요한 데이터를 추출해서 사용
• 딥러닝: 데이터만 줘도 자동으로 추출, 작동까지 가능

🔎딥러닝 활용(대표적)

• 이미지 인식
• 자연어 처리
• 음성인식
• 의료 분야

☑️ 신경망의 기본 원리

🔎 신경망이란? (사람의 뇌)

• 인공 신경망이란 퍼셉트론으로 이루어진 네트워크 

🔎 퍼센트론이란?(뇌속의 뉴런)

• 퍼셉트론(Perceptron)은 인공 신경망의 가장 기본적인 단위로, 하나의 뉴런을 모델링한 것입니다.
• 퍼셉트론은 입력 값을 받아 가중치(weight)를 곱하고, 이를 모두 더한 후 활성화 함수(activation function)를 통해 출력 값을 결정합니다.
• 곱하고 더하고 함수적용시켜 출력

🔎 다층 퍼센트론이란?

• 다층 퍼셉트론(Multi-Layer Perceptron, MLP)은 여러 층의 퍼셉트론을 쌓아 올린 신경망 구조입니다.
• MLP는 입력층(input layer), 은닉층(hidden layer), 출력층(output layer)으로 구성되며, 각 층의 뉴런들이 서로 연결되어 있습니다
• 입력 레이어(Input Layer) : 외부 데이터가 신경망에 입력되는 부분입니다. 입력 레이어의 뉴런 수는 입력 데이터의 특징 수와 동일합니다.
• 은닉 레이어(Hidden Layer) : 은닉 레이어는 입력 레이어와 출력 레이어 사이에 위치한 층으로, 입력 데이터를 처리하고 특징을 추출하는 역할을 합니다. 은닉 레이어의 뉴런 수와 층 수는 모델의 복잡성과 성능에 영향을 미칩니다.
• 출력 레이어(Output Layer) : 출력 레이어는 신경망의 마지막 층으로, 최종 예측 값을 출력합니다. 출력 레이어의 뉴런 수는 예측하려는 클래스 수 또는 회귀 문제의 출력 차원과 동일합니다.

🔎 활성화 함수란?

• 활성화 함수는 신경망의 각 뉴런에서 입력값을 출력값으로 변환하는 역할을 합니다.
• 활성화 함수가 없다면 신경망은 단순 선형변환만 수행하게 되어 복잡한 패턴을 학습할 수 없습니다.
• 활성화 함수는 비 선형성을 도입하여 신경망이 복잡한 패턴을 학습할 수 있게합니다.
• ReLU (Rectified Linear Unit): 계산이 간단하고, 기울기 소실 문제 완화
• Sigmoid: 확율을 나타내기 적합
• Tanh (Hyperbolic Tangent)

🔎 손실 함수

• 손실 함수(Loss Function)는 모델의 예측 값과 실제 값 사이의 차이를 측정하는 함수입니다.
• 손실 함수는 모델의 성능을 평가하고, 최적화 알고리즘을 통해 모델을 학습시키는 데 사용됩니다.
• 회귀문제에서 주로 사용 된다.

🔎 최적화 알고리즘

• 최적화 알고리즘(Optimization Algorithm)은 손실 함수를 최소화하기 위해 모델의 가중치를 조정하는 방법입니다.
• 최적화 알고리즘은 손실 함수의 기울기를 계산하고, 이를 바탕으로 가중치를 업데이트합니다.

🔎 역전파 

• 연쇄 법칙(Chain Rule)을 사용해 손실함수의 기울기를 계산합니다.
• 각 층의 기울기는 이전 층의 기울기와 현재 층의 기울기를 곱하여 계산합니다.
• 이를 통해 신경망의 모든 가중치가 업데이트 됩니다

☑️ 인공 신경망(ANN)

🔎 인공 신경망(ANN)

• 인공 신경망(Artificial Neural Network, ANN)은 생물학적 신경망을 모방하여 설계된 컴퓨팅 시스템입니다
• ANN은 입력층(Input Layer), 은닉층(Hidden Layer), 출력층(Output Layer)으로 구성되며, 각 층은 뉴런(Neuron)으로 이루어져 있습니다.
• 입력층: 입력 데이터를 받아들이는 층. 입력층의 뉴런수는 입력데이터 피펴수와 동일
• 은닉층 : 입력데이터를 처리하고 특징을 처리하는 층.은닉층의 뉴런수와 층수는 모델의 복잡성과 성능에 영향
• 출력층 : 최종 예측값을 출력하는 층. 출력층의 뉴런수는 예측하려는 클래스 수 또는 회귀문제 출력차원과 동일

🔎 동작방식

1. 순전파 (Forward Propagation)
   • 입력 데이터를 통해 각 층의 뉴런이 활성화되고, 최종 출력 값을 계산합니다.
   • 각 뉴런은 입력 값에 가중치(weight)를 곱하고, 바이어스(bias)를 더한 후 활성화 함수(activation function)를 통해 출력 값을 결정합니다.
2. 손실 계산 (Loss Calculation)
   • 예측 값과 실제 값의 차이를 손실 함수(Loss Function)로 계산합니다.
3. 역전파 (Backpropagation)
   • 손실 함수의 기울기를 출력층에서 입력층 방향으로 계산하고, 이를 바탕으로 가중치를 업데이트합니다.
    

🔎 출력 레이어의 유형

1. 회귀 문제 (Regression):
   • 출력 레이어의 뉴런 수는 예측하려는 연속적인 값의 차원과 동일합니다.
   • 활성화 함수로는 주로 선형 함수(linear function)를 사용합니다.
2. 이진 분류 문제 (Binary Classification):
   • 출력 레이어의 뉴런 수는 1입니다.
   • 활성화 함수로는 시그모이드 함수(Sigmoid Function)를 사용하여 출력 값을 0과 1 사이의 확률로 변환합니다.
3. 다중 클래스 분류 문제 (Multi-Class Classification):
   • 출력 레이어의 뉴런 수는 예측하려는 클래스 수와 동일합니다.
   • 활성화 함수로는 소프트맥스 함수(Softmax Function)를 사용하여 각 클래스에 대한 확률을 출력합니다.

📚  PyTorch 및 필요한 라이브러리 임포트

import torch #핵심 라이브러리 

import torch.nn as nn #신경망 구축을 위한 네트워크들이 포함 되어있다

import torch.optim as optim #최적화 (어떤 함수들의 최소나 최대로 만드는 변수를 찾는 것)

import torchvision #이미지처리 라이브러리

import torchvision.transforms as transforms #데이터 전처리를 위한 라이브러리

📚  데이터셋 로드 및 전처리

#데이터셋 전처리

# transform 이라는 분분은 여러 부분을 순차적으로 변환 시켜준다.

# transforms.ToTensor() 이미지를 tensor라고 하는 파이토치에서 사용하는 기본 자료구조로 변환.

# transforms.Normalize 이미지를 정규화 해준다.평균을 0.5, 표준편차를 0.5로 설정했다.

transform = transforms.Compose([

            transforms.ToTensor(),

            transforms.Normalize((0.5,), (0.5,))

])

정규화란

data의 평균(data가 어떤 값을 가지냐)과 분산(data가 얼마나 퍼졌있냐)

예시)

키 0~3m

나이 0~200세

재산 0~1000억

ax+b 형태로 페셉트론이 형성 된다

x가 0~200일때랑 0~1000억일때 어느쪽이 더 영향력이 큰가 재산이다. 그런데 재산이 문제를 해결하기 위해 키나 나이보다 중요한 의미를 가질까? 아닐 수 있다(재산이 너무 크면 키나 나이가 반영이 안될 수 있다,). 그래서 각각의 표준과 평균을 맞춰 주는게 학습을 원활하게 해준다.

#MNIST 데이터셋 로드 

# sorchvision.datasets.MNIST 토치비젼에있는MNIST를 다운로드 한다.

# root='./data 다운로드 하기 위한 경로

# train=True train셋인지 본다.

# download=True 다운로드 할것인지 본다.

# transform=transform transform을 전달해주면서 데이터를 전처리 한상태로 다운로드 해주는 것

trainset = sorchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,suffle=True)

# torch에 utils에 data에 DataLoader를 가져온다.

# batch_size는 데이터를 쪼개준다 (학습속도를 높이기 위해)

# suffle 데이터를 쪼갤때 손상이 갈 수 있어 섞어서 batch를 만들게해준다.

testset = torchvision.datasets.MNIST(root='./data', train=False, downlad=True, transform=transform)

testloader = torch.utils.dataDataLoader(testset, batch_size=64, shuffle=False)

📚 간단한 ANN 모델 정의

class SimpleANN(nn.Module): #클래스 정의 이름정하기 nn.module 상속받기 (nn.module을 상속받음으로써 딥러닝모델을 만들기 위한 기본기능을 사전에 가져오는 것)
#class가 생성되는 순간 model을 만들고  그때 자동으로 호출 된다 

#부모 클래스에서 기능을 작동하는 super함수를 불러준다.

   def __init__(self): 
        super(SimpleANN, self).__init__()
       #  self.fc1 레이어를 만들어준다.

       # nn.Linear(28 * 28, 128) ANN모델을 설정해준다. 28*28은 data의 크기/128은 fc2의128로 64는 fc3의 64로

        self.fc1 = nn.Linear(28 * 28, 128)  # 입력층에서 은닉층으로
        self.fc2 = nn.Linear(128, 64)       # 은닉층에서 은닉층으로
        self.fc3 = nn.Linear(64, 10)        # 은닉층에서 출력층으로

    def forward(self, x):
        x = x.view(-1, 28 * 28)  # 입력 이미지를 1차원 벡터로 변환
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

📚 모델 학습

#모델 초기화
model = SimpleANN()

#학습 전 결과 출력 (비교를 위해)
correct = 0
total = 0
#no_grad는 메모리 효율성을 위해 사용
#no_grad는 평가단계에서 기울기를 계산하지 않는다 지정(오차함수를 줄이는 방향으로 업데이트 한다는 의미)
#no_gard 동안에는 학습을 진행하지 않는다.
with torch.no_grad():
    #학습을 진행하지 않는 상황에서 데어로더에서 데이터를 하나씩 꺼내서
    for data in testloader:
        #데이터의 이미지와 레이블을 본다
        images, labels = data
        #그뒤 모델에 전달해서 예측 값을 본다(outputs).
        outputs = model(images)
        #torch.max를 통해서 가능성의 최대값을 찾는다.
        _, predicted = torch.max(outputs.data, 1)
        #레이블의 사이즈를 total에 더해준다
        total += labels.size(0)
        #batch의 크기를 반환해서 실제 데이터를 알수있는 상태
        #예측값과 실제값이 일치하는 샘플을 찾는거다.
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the 10000 test images: {100 * correct / total:.2f}%')

# 손실 함수와 최적화 알고리즘 정의
#CrossEntropyLoss는 분류모델에서 성능을 확인하기 위한 손실함수
criterion = nn.CrossEntropyLoss()
#SGD는 최적화에서 기울기(가중치)를 업데이트를 할 때 사용
#전체를 보게하면 너무 느리니 일부만 보게해서 기울기 계산
#lr 학습율 정하기 (가중치 변화량 조절) 값은 적당히 작게하고 문제와 데이터크기에 따라 달라서 실험적으로 정해야한다.
#parameters 업데이트를 하기 위한 파라미터 지정
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

#epoch 전체데이터를 몇번 반복할건지를 말한다.
#range(10) 10번 선택
for epoch in range(10):
    #손실함수가 어느정도 발생했는지 보기 위함?
    running_loss = 0.0
    #i는 인덱스
    #data는 data
    for i, data in enumerate(trainloader,0):
        inputs, labels = data
        
        #optimizer는 연쇄계산이라 기울기 초기화
        optimizer.zero_grad()
        
        #순전파로 계산
        outputs = model(inputs)
        #loss계산
        loss = criterion(outputs, labels)
        #loss를 다시 뒤로 전달해서 각각의 loss가 어떻게 반영해야 되는지 알려준다
        #기울기를 찾는다.
        loss.backward()
        #기울기를 바탕으로 가중치를 업데이트
        optimizer.step()
        
        #loss출력
        running_loss += loss.item()
        #100개의 미니배치마다 출력
        if i%100 == 99:
            print(f'[Epoch {epoch + 1}, Batch{i + 1}] loss: {running_loss / 100:.3f}')
            running_loss = 0.0
            
print('Finished Training')

☑️ 회고

오늘은 고민이 해결 되는 날이였다.

내용은 어렵다 보니 집중력이 떨어져 많은 공부를 하지 못했지만

이때까지 내가 근본적으로 궁금해했지만 그걸 어떻게 설명해야할지 모르겟던 질문이 생각났고 답을 찾게 되었다.

그 질문은 바로

이렇게 머신러닝 딥러닝 코드를 짜고 학습시켜서 이미지 분류하는 모델를 만든다고 했지만 실제로는 어떻게 적용시켜? 뭐 할 때 써?

질문 자체가 이걸 내가 왜 배우고있어? 이런 뉘앙스여서 여태 쉽게 정의 하지 못한듯하다.

하지만 정말 간단했고 답을 찾았을 땐 시원했다. (이제는 나를 불편하게 했던 녀석이 없어졌기 때문!!)

위 질문의 해답은 MNIST나 비슷한 모델들이 사용 되고있는 실제사례를 알게 되었고

가장 궁금했던 어떻게 적용하고 쓰냐 이건데

복잡한 과정이 많아 보이지만 짧게 정리한다면

로컬환경(어플리케이션 등)을 만들어서 학습모델 코드를 집어넣어 작동시키는 것이였다.

모델도 만들고 그것을 사용하기 위한 환경도 만든다니 너무 어려워 보이지만

매우 기대가 된다.

• 비지도학습

1. 군집화 모델 - k-means clustering
2. 군집화모델 - 계층적 군집화
3. 군집화모델 - DBSCAN
4. 차원축소 -  PCA
5. 차원축소 - t-SNE
6. 차원축소 - LDA

• 앙상블 학습

1. 배깅과 부스팅
2. 랜덤 포레스트
3. 그래디언트 부스팅 머신(GBM)
4. XGBoost

• GITHUB특강
• 회고

☑️ 비지도학습 : 군집화모델 - k-means clustering

🔎비지도학습이란?

• 입력 데이터에 대한 정답(타깃 값)이 없는 상태에서 데이터의 구조나 패턴을 찾아내는 것이 목표입니다. 비지도 학습은 데이터를 미리 정의된 클래스나 카테고리로 분류하지 않고, 데이터 내의 유사성, 상관관계 또는 특성을 기반으로 그룹화하거나 변환하는 데 초점을 맞춥니다.

🔎k-means clustering란?

• 비지도 학습에서 가장 널리 사용되는 군집화(clustering) 알고리즘 중 하나입니다. 이 알고리즘은 주어진 데이터를 미리 정의된 수 **K개의 클러스터(cluster)**로 나누는 작업을 수행합니다. 각 클러스터는 비슷한 특성을 가진 데이터 포인트들로 이루어지며, 각 클러스터의 중심(centroid)이 기준이 됩니다.

📚알고리즘 단계

1. 초기화

• k개의 군집 중심을 랜덤하게 설정합니다.
• 몇개로 데이터를 그룹화할지 결정하는 단계

2. 할당 단계

•  각 데이터 포인트를 가장 가까운 군집 중심에 할당합니다.

3. 업데이트 단계

• 각 군집의 중심을 해당 군집에 속한 데이터 포인트들의 평균으로 업데이트합니다.

4. 반복

• 할당 단계와 업데이트 단계를 군집 중심이 더 이상 변화하지 않을 때까지 반복합니다

📚거리측정 방법

• k-means 알고리즘은 주로 유클리드 거리(Euclidean Distance)를 사용하여 데이터 포인트와 군집 중심 간의 거리를 계산합니다.

📚엘보우 방법

• 최적의 k를 선택하는 데 사용됩니다.
• k를 증가시키면서 각 k에 대한 군집의 응집도(또는 관성, Inertia)를 계산하고, 이를 그래프로 나타내어 그래프에서 응집도가 급격히 감소하는 지점을 찾습니다

📚데이터 로드 및 전처리

import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
#라이브러리로 StandardScaler를 적용하기 위한sklearn의preprocessing 모듈
from sklearn.cluster import KMeans
#sklearn의cluster모듈에서 KMeans알고리즘을 가져올거다.
import matplotlib.pyplot as plt
import seaborn as sns

# 데이터 로드
data = pd.read_csv('Mall_Customers.csv')

# 필요한 열 선택(거리를 구할 수 있는 수치형 데이터) 및 결측값 처리
data = data[['Age', 'Annual Income (k$)', 'Spending Score (1-100)']]

# 데이터 스케일링
scaler = StandardScaler()
data_scaled = scaler.fit_transform(data)

📚모델 학습 및 군집화

# 최적의 k 찾기 (엘보우 방법)
inertia = [] #엘보우를 저장하기위한 코드
K = range(1, 11) #k개수 지정
for k in K:
    kmeans = KMeans(n_clusters=k, random_state=42) #k를 하나하나 돌아가며 클러스터링 작업
    kmeans.fit(data_scaled)
    inertia.append(kmeans.inertia_)
    #kmeans에는inertia_기본적으로 변수가 저장 되어있어서 값을 쉬게 구할 수 있다.

# 엘보우 그래프 그리기
#최적 엘보우를 보기 위해 그래프 시각화
plt.figure(figsize=(10, 8))
plt.plot(K, inertia, 'bx-')
plt.xlabel('k')
plt.ylabel('Inertia')
plt.title('Elbow Method For Optimal k')
plt.show()

# k=5로 모델 생성 및 학습
kmeans = KMeans(n_clusters=5, random_state=42)
kmeans.fit(data_scaled)

# 군집 결과를 데이터프레임에 할당 해 어떤레이블에 어떤 데이터가 할당 되었구나 확인
data['Cluster'] = kmeans.labels_

• sklearn.cluster.KMeans: k-means 군집화 모델을 생성합니다
  • n\_clusters=k: 군집의 수를 설정합니다.
  • random\_state=42: 랜덤 시드 값으로, 결과의 재현성을 위해 사용됩니다.
  • fit(data\_scaled): 데이터를 학습하여 군집을 형성합니다.
  • labels\_: 각 데이터 포인트가 속한 군집 레이블을 반환합니다.

📚군집 시각화

# 2차원으로 군집 시각화 (연령 vs 소득)
plt.figure(figsize=(10, 8))
sns.scatterplot(x=data['Age'], y=data['Annual Income (k$)'], hue=data['Cluster'], palette='viridis')
plt.title('Clusters of customers (Age vs Annual Income)')
plt.show()

# 2차원으로 군집 시각화 (소득 vs 지출 점수)
plt.figure(figsize=(10, 8))
sns.scatterplot(x=data['Annual Income (k$)'], y=data['Spending Score (1-100)'], hue=data['Cluster'], palette='viridis')
plt.title('Clusters of customers (Annual Income vs Spending Score)')
plt.show()

• matplotlib.pyplot.plot: 그래프를 그립니다.
  • K, inertia, 'bx-': x축, y축 데이터와 그래프 스타일을 설정합니다.}$
• seaborn.scatterplot: 산점도를 그립니다.
  • x=data['Age']: x축 데이터
  • y=data['Annual Income (k\$)']: y축 데이터
  • hue=data['Cluster']: 색상에 따라 군집을 구분합니다.
  • palette='viridis': 색상 팔레트를 설정합니다.

☑️ 비지도학습 : 군집화모델 - 계층적 군집화

🔎계층적 군집화란?

• 계층적 군집화(Hierarchical Clustering)는 데이터포인트를 계층 구조로 그룹화하는 방법입니다.
• 데이터 포인트를 점진적으로 병합하거나 분할하여 군집을 형성합니다

🔎계층적 군집화의 작동 원리

• 거리 행렬 계산: 데이터 포인트 간의 거리를 계산하여 거리 행렬을 만듭니다.
• 군집 병합/분할: 거리 행렬을 기반으로 가장 가까운 군집을 병합하거나, 가장 멀리 떨어진 군집을 분할합니다.
• 덴드로그램 생성: 군집화 과정을 시각화한 덴드로그램을 생성합니다.

📚데이터 로드 및 전처리

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt​
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import AgglomerativeClustering
#AgglomerativeClustering 사용할 병합군집화
import scipy.cluster.hierarchy as sch
#scipy에서 계층적 군집화를 하기 위한 sch클래스 가져오기

# 데이터셋 불러오기
df = pd.read_csv('Mall_Customers.csv')


# 데이터 확인
print(df.head())

# 필요한 열만 선택
X = df[['Age', 'Annual Income (k$)', 'Spending Score (1-100)']]

# 데이터 정규화
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

📚덴드로그램 생성

plt.figure(figsize=(10, 7))
dendrogram = sch.dendrogram(sch.linkage(X_scaled, method='ward'))
#sch의 dendrogram을 가져와 설정
plt.title('Dendrogram') #타이틀 이름
plt.xlabel('Customers') #xlable 이름
plt.ylabel('Euclidean distances') #ylable 이름
plt.show()

📚계층적 군집화 모델 생성

hc = AgglomerativeClustering(n_clusters=5, metric='euclidean', linkage='ward')
#n_clusters를 감으로 적당한 값을 넣고 metric으로 euclidean을 넣었다

#metric은 데이터 포인트 간의 거리 계산  ward는 클러스터 간의 거리를 계산

#ward의 계산은 클러스터를 합쳣을 때 클러스터 내부 데이터가 퍼지는 정도를 보고 최소화하게 병합한다.

# 모델 학습 및 예측
y_hc = hc.fit_predict(X_scaled)

# 결과 시각화
plt.figure(figsize=(10, 7))
plt.scatter(X_scaled[y_hc == 0, 0], X_scaled[y_hc == 0, 1], s=100, c='red', label='Cluster 1')
plt.scatter(X_scaled[y_hc == 1, 0], X_scaled[y_hc == 1, 1], s=100, c='blue', label='Cluster 2')
plt.scatter(X_scaled[y_hc == 2, 0], X_scaled[y_hc == 2, 1], s=100, c='green', label='Cluster 3')
plt.scatter(X_scaled[y_hc == 3, 0], X_scaled[y_hc == 3, 1], s=100, c='cyan', label='Cluster 4')
plt.scatter(X_scaled[y_hc == 4, 0], X_scaled[y_hc == 4, 1], s=100, c='magenta', label='Cluster 5')
plt.title('Clusters of customers')
plt.xlabel('Age')
plt.ylabel('Annual Income (k$)')
plt.legend()
plt.show()

📚평가 (-1 ~ 1까지 있으며 1에 가까울수록 좋다.)

from sklearn.metrics import silhouette_score

# 실루엣 점수 계산
silhouette_avg = silhouette_score(X_scaled, y_hc)
print(f'Silhouette Score: {silhouette_avg}')

☑️ 비지도학습 : 군집화모델 - DBSCAN

🔎DBSCAN이란?

• DBSCAN(Density-Based Spatial Clustering of Applications with Noise)은 밀도 기반 군집화 알고리즘입니다
• DBSCAN은 데이터 밀도가 높은 영역을 군집으로 간주하고, 밀도가 낮은 영역은 노이즈로 처리합니다
• 비유: 놀이터에 퍼져서 노는 아이들에게 친구가 되는 기준을 말해준다. 가까운 아이들 3명이 친구다. 한 아이를 선택해서 친구를 찾아본다. (3명 이상이 있다면 코어아이 / 너무 적다면 외톨이) 만약 코어아이라면 아이들이 모여 무리를 만들고 다시한번 찾아보고 밖에있는 아이까지 친구가 되게 만들고 공원에있는 아이들 중 친구를 맺거나 외톨이라고 결론이 날 때까지 반복하는 알고리즘이다.

🔎DBSCAN의 작동원리

• 임의의 데이터 포인트를 선택합니다.
• 선택한 데이터 포인트의 eps 반경내에 있는 모든 데이터 포인트를 찾습니다.
• eps 반경 내의 데이터수 ≥ min_samples : 해당 데이터 포인트를 중심으로 새로운 군집 형성.
• eps 반경 내의 데이터수 < min_samples : 해당 데이터 포인트를 노이즈로 간주
• 군집에 속한 데이터 포인트에 대해 2~4 단계를 반복합니다.
• 모든 데이터 포인트가 처리될 때까지 이 과정을 반복합니다.

eps 반경: 친구가 되기 위한 거리 

min_samples: 한 포인트가 코어포인트로 간주 되기 위한 숫자 

경계 포인트: 자신의 eps 반경 안에 min_samples 보다는 적은 갯수가 있지만 코어 포인트의 eps반경안에있는 친구들 (외톨이도 되지 않는데 코어도 되지 않는 친구)

노이즈포인트: 코어나 경계 포인트가 아닌 친구(외톨이)

전문적인 설명

데이터셋의 모든 포인트를 미방문 상태로 둔다. 아직 친구를 찾지않은 상태 => 미방문 상태인 포인트 중 하나를 찾아 탐색을 시작한다.=> 탐색한 포인트 내에서 eps내에 이웃 포인트가 몇개있는지 탐색을 한다. => 코어 포인트인지 구분을 하고 코어포인트가 아니라면 탐색을 중단하고 다른 포인트를 탐색한다.

📚 데이터 로드

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

# 데이터셋 불러오기
df = pd.read_csv('Mall_Customers.csv')


# 데이터 확인
print(df.head())

# 필요한 열만 선택
X = df[['Age', 'Annual Income (k$)', 'Spending Score (1-100)']]

# 데이터 정규화
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

📚 DBSACN 수행

from sklearn.cluster import DBSCAN 

#DBSAC은 sklearn의 cluster에 있다
import matplotlib.pyplot as plt
import seaborn as sns
#시각화를 위한 라이브러리를 가져온다.

# DBSCAN 모델 생성
dbscan = DBSCAN(eps=5, min_samples=5)
#DBSCAN(거리, 친구의 숫자)

# 모델 학습 및 예측
df['Cluster'] = dbscan.fit_predict(X)

# 군집화 결과 시각화
plt.figure(figsize=(10, 7))
sns.scatterplot(x='Annual Income (k$)', y='Spending Score (1-100)', hue='Cluster', data=df, palette='viridis')
plt.title('DBSCAN Clustering of Mall Customers')
plt.show()

📚 파라미터 튜닝

#eps와 min_samples 파라미터를 찾기
# 다양한 조합으로 eps와 min_samples 값 시도
eps_values = [3, 5, 7, 10]
min_samples_values = [3, 5, 7, 10]

for eps in eps_values:
    for min_samples in min_samples_values:
        dbscan = DBSCAN(eps=eps, min_samples=min_samples)
        df['Cluster'] = dbscan.fit_predict(X)
        
        plt.figure(figsize=(10, 7))
        sns.scatterplot(x='Annual Income (k$)', y='Spending Score (1-100)', hue='Cluster', data=df, palette='viridis')
        plt.title(f'DBSCAN Clustering (eps={eps}, min_samples={min_samples})')
        plt.show()

☑️ 비지도학습 : 차원축소 - PCA

🔎PCA이란?

• PCA(Principal Component Analysis, 주성분 분석)는 고차원 데이터를 저차원으로 변환하는 차원 축소 기법입니다
• PCA는 데이터의 분산을 최대한 보존하면서, 데이터의 주요 특징을 추출해 저차원 공간으로 변환합니다
• 데이터의 시각화, 노이즈 제거, 계산 효율성 향상 등의 이점을 얻을 수 있습니다.

📚 비유:

1. 학생의 성적 데이터가 있다. 국영수 다양한 성적이있다. 10차원으로 고차원 데이터이다.
2. 첫번째로 데이터 중심화를 한다(국어성적의 평균을 구해 데이터에서 평균 값을 빼준다. 평균을 빼주었기 때문에 평균은 0이 된다.)
3. 공분산을 계산한다(특징관의 관계를 계산한다/국어점수가 높은 사람은 사회점수도 높더라 등)
4. 성적변화가 가장 큰 방향을 찾는다.(국어 ->수학 -> 영어 차원으로 보니 성적변화가 가장 컷다)
5. 변화에 대부분을 차지하는 국영수를 주성분으로 선택한다.(변화가 적은 것들은 무시할 수 있다 가정.)
6. 학생의 모든 성적을 국영수를 통해 바꿔낸 기준으로 재조정한다. (국영수인 3개의 축으로 데이터를 표현 = 여러가지 과목의 성적 정보를 2개의 과목정보로 요약하게 된다.)

🔎 주요개념

1. data 중심화: 표준을 빼서 데이터의 평균을 0으로 만들어준다.
2. 공분산 행렬: 각 특징간에 얼마나 같이 움직이는지 본다.(특징간의 상관관계를 수치적으로 보여준다. 데이터 분포를 보는데 사용)
3. 고유값/고유백터 계산: 공분산 행렬을 통해 고유값과 고유백터를 계산(데이터가 얼마나 분산 되는지 설명, 고유백터는 방향을 나타낸다. 공분산 행렬을 변환할 때 스케일을 나타내는게 고유값 ) 
4. 주성분 선택: 고유값이 큰 순서대로 고유백터를 찾고 상위 몇개의 고유백터를 골라 주성분으로 지정(새로운 좌표가 된다 / 일반적으로, 전체 분산의 95% 이상을 설명하는 주성분을 선택합니다. )
5. 차원축소: 원본데이터를 주성분 축으로 변환해서 차원축소(중요정보 시각화 불필요 정보 제거)

📚 데이터 로드

#머신러닝에서 자주 사용 되는 mnist_784를 사용할 것
#mnist_784를 사용하기 위해 sklearn의datasets모듈에서fetch_openml함수를 가져온다
from sklearn.datasets import fetch_openml
import pandas as pd

# MNIST 데이터셋 불러오기
#fetch_openml(이름, 버젼)
mnist = fetch_openml('mnist_784', version=1)

# 데이터와 레이블 분리
X = mnist.data
y = mnist.target

# 데이터 프레임의 첫 5행 출력
print(X.head())
print(y.head())

📚 표준화 진행

from sklearn.preprocessing import StandardScaler

# 데이터 표준화
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

📚 PCA실행

#sklearn의decomposition모듈에서 PCA를 사용
from sklearn.decomposition import PCA

# PCA 모델 생성
pca = PCA(n_components=0.95)  # 전체 분산의 95%를 설명하는 주성분 선택

# PCA 학습 및 변환
X_pca = pca.fit_transform(X_scaled)

# 변환된 데이터의 크기 확인
print(X_pca.shape)

📚 주성분 확인

# 선택된 주성분의 수
print(f'선택된 주성분의 수: {pca.n_components_}')

# 각 주성분이 설명하는 분산 비율
print(f'각 주성분이 설명하는 분산 비율: {pca.explained_variance_ratio_}')

# 누적 분산 비율
print(f'누적 분산 비율: {pca.explained_variance_ratio_.cumsum()}')

📚 PCA 결과 시각화

import matplotlib.pyplot as plt
import seaborn as sns

# 2차원 시각화
plt.figure(figsize=(10, 7))
sns.scatterplot(x=X_pca[:, 0], y=X_pca[:, 1], hue=y, palette='viridis', legend=None)
plt.title('PCA of MNIST Dataset (2D)')
plt.xlabel('Principal Component 1')
plt.ylabel('Principal Component 2')
plt.show()

☑️ 비지도학습 : 차원축소 - t-SNE

🔎 t-SNE란?

• t-SNE(t-Distributed Stochastic Neighbor Embedding)는 고차원 데이터를 저차원으로 변환하여 시각화하는 차원 축소 기법입니다.
• 데이터 포인트 간의 유사성을 보존하면서, 고차원 데이터를 2차원 또는 3차원 공간으로 변환합니다
• 데이터의 구조와 패턴을 시각적으로 이해할 수 있습니다.

📚 비유

1. 친구 그룹이있다.
2. 친구들의 성격과 특성을 나타내는 데이ㅓ가 고차원으로 있다.
3. 친구간의 유사성 (같이 보내는 시간, 얼마나 친한지 등) 을 고려해 확률로 변환해서 고차원 공간에서의 친구 관계를 나타낸다. => 고차원의 데이터를 보고 각각 데이터간에 관계의 유사성을 본다.
4. 저차원 데이터 만들기 (친구들을 적은 데이터로 배치한다.) ex) 카페에서 어디 앉는지, 뭘 시키는지
5. 저차원에서 친구들의 관계를 본다
6. 이제 고차원과 저차원 데이터 모두 가진 상태다.
7. 고차원에서 가지는 관계가 최대한 저차원에서도 유사하도록 데이터를 축소하는 방법

고차원 유사성 계산 (가우시안)

저차원 유사성 계산 (T분포)

각각 유사성이 얼마나 유사한지 봐야한다. (Kullback-Leibler divergence: 분산이 얼마나 떨어진지 확인해준다.)

🔎 t-SEN작동 원리

1. 고차원 공간에서의 유사성 계산: 고차원 데이터 포인트 간의 유사성을 확률 분포로 계산합니다.
2. 저차원 공간에서의 유사성 계산: 저차원 데이터 포인트 간의 유사성을 t-분포를 사용하여 계산합니다.
3. KL 발산 최소화: 고차원 공간과 저차원 공간 간의 유사성 분포 차이를 KL 발산(Kullback-Leibler divergence)을 통해 최소화합니다.
4. 반복적 최적화: 저차원 공간에서의 데이터 포인트 위치를 반복적으로 조정하여 최적의 시각화를 얻습니다.

=> 데이터 포인터 간의 유사성을 보존하면서 낮은 차원의 데이터로 바꿀껀데 고차원의 데이터 포인트의 관계는 저차원에서도 보존 되어야한다.

다시들어봐야할듯

☑️ 비지도학습 : 차원축소 - LDA

🔎  LDA란?

• LDA(Linear Discriminant Analysis, 선형 판별 분석)는 차원 축소와 분류를 동시에 수행합니다.
• LDA는 데이터의 클래스 간 분산을 최대화하고, 클래스 내 분산을 최소화하는 방향으로 데이터를 변환합니다
• 데이터의 분류 성능을 향상시키고, 저차원 공간에서 데이터의 구조를 시각화할 수 있습니다.

📚 비유

피크닉을 가기위해 분류를 진행한다.

과일 샌드위치 음료가 있다. => 데이터의 클래스를 정의하는 과정

과일 샌드위치 음료들은 최대한 떨어지게 배치

과일안의 사과나 다른 과일들끼리는 최대한 붙어있게 배치한다.(샌드위치나 음료도 마찬가지)

🔎 LDA작동원리

1. 클래스별 평균 계산: 각 클래스의 평균 벡터를 계산합니다.
2. 클래스 내 분산 행렬 계산: 각 클래스 내 데이터 포인트의 분산을 계산해 클래스 내 분산 행렬을 만듭니다.
3. 클래스 간 분산 행렬 계산: 클래스 간 평균 벡터의 분산을 계산하여 클래스 간 분산 행렬을 만듭니다.
4. 고유값 및 고유벡터 계산: 클래스 내 분산 행렬의 역행렬과 클래스 간 분산 행렬의 곱의 고유값과 고유벡터를 계산합니다.(데이터를 축소하는 기준)
5. 선형 판별 축 선택: 고유값이 큰 순서대로 고유벡터를 정렬하여 선형 판별 축을 선택합니다.
6. 데이터 변환: 선택된 선형 판별 축을 사용하여 데이터를 저차원 공간으로 변환합니다.

=> 데이터를 축소할 때 클래스를 나누는 동시에 분류를 진행(클래스 내부는 데이터가 뭉치고 클래스 간에는 멀어지게

다시 들어봐야할듯

☑️ 앙상블 학습 - 배깅과 부스팅

🔎 앙상블 학습이란? 

• 앙상블 학습(Ensemble Learning)은 여러 개의 학습 모델을 결합하여 하나의 강력한 모델을 만드는 기법입니다
• 앙상블 학습은 개별 모델의 예측을 결합함으로써, 단일 모델보다 더 높은 예측 성능과 일반화 능력을 얻을 수 있습니다.
• 앙상블 학습의 주요 기법으로는 배깅(Bagging)과 부스팅(Boosting)이 있습니다.

🔎 배깅이란?

• 배깅(Bootstrap Aggregating)은 여러 개의 학습 모델을 병렬(따로)로 학습시키고, 그 예측 결과를 평균 또는 다수결로 결합하는 앙상블 기법입니다.
• 배깅은 데이터의 샘플링 과정에서 부트스트래핑(bootstrap) 기법을 사용하여, 원본 데이터셋에서 중복을 허용한 무작위 샘플을 생성합니다.
• 각 모델은 서로 다른 데이터 샘플을 학습하게 되어, 모델 간의 상관성을 줄이고 예측 성능을 향상시킵니다.

📚배깅모델 구현 및 평가

# 배깅 모델 생성
#estimator 어떤 모델을 복합적으로 만들지 골라준다
#n_estimators 평가개수에 수를 정해준다
bagging_model = BaggingRegressor(estimator=DecisionTreeRegressor(), n_estimators=100, random_state=42)

# 모델 학습
bagging_model.fit(X_train_scaled, y_train)

# 예측
y_pred_bagging = bagging_model.predict(X_test_scaled)

# 평가
mse_bagging = mean_squared_error(y_test, y_pred_bagging)
print(f'배깅 모델의 MSE: {mse_bagging}')

🔎  부스팅이란?

• 부스팅(Boosting)은 여러 개의 약한 학습기(weak learner)를 순차적으로 학습시키고, 그 예측 결과를 결합하여 강한 학습기(strong learner)를 만드는 앙상블 기법입니다
• 부스팅은 이전 모델이 잘못 예측한 데이터 포인트에 가중치를 부여하여, 다음 모델이 이를 더 잘 학습하도록 합니다.

📚 부스팅 모델 구현 및 평가

from sklearn.ensemble import GradientBoostingRegressor

# 부스팅 모델 생성
#estimator모델을 선택하지 않는다. 
#n_estimators 평가개수를 정해준다
boosting_model = GradientBoostingRegressor(n_estimators=100, random_state=42)

# 모델 학습
boosting_model.fit(X_train_scaled, y_train)

# 예측
y_pred_boosting = boosting_model.predict(X_test_scaled)

# 평가
mse_boosting = mean_squared_error(y_test, y_pred_boosting)
print(f'부스팅 모델의 MSE: {mse_boosting}')

☑️ 앙상블 학습 - 랜덤 포레스트

🔎 랜덤 포레스트란?

• 결정트리를 앙상블 학습으로 개선한 것이 랜덤 포레스트이다.
• 랜덤 포레스트(Random Forest)는 배깅(Bagging) 기법을 기반으로 한 앙상블 학습 모델입니다.
• 여러 개의 결정 트리(Decision Tree)를 학습시키고, 그 예측 결과를 결합하여 최종 예측을 수행합니다.
• 각 트리가 독립적으로 학습되기 때문에, 과적합을 방지하고 예측 성능을 향상시킬 수 있습니다.
• 여러개의 결정트리로 구성 되고 데이터를 무작위로 샘플링해서 데이터에 대해 학습을해서 결과를 평균, 다수결로 결합해서 최종예측을 한다.

📚 랜던 포레스트 구현 및 평가

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error

# 랜덤 포레스트 모델 생성
rf_model = RandomForestRegressor(n_estimators=100, random_state=42)

# 모델 학습
rf_model.fit(X_train_scaled, y_train)

# 예측
y_pred_rf = rf_model.predict(X_test_scaled)

# 평가
mse_rf = mean_squared_error(y_test, y_pred_rf)
print(f'랜덤 포레스트 모델의 MSE: {mse_rf}')

📚 중요 특성 확인

import matplotlib.pyplot as plt
import seaborn as sns

# 특성 중요도 추출
feature_importances = rf_model.feature_importances_

# 특성 중요도를 데이터프레임으로 변환
feature_importances_df = pd.DataFrame({
    'Feature': X.columns,
    'Importance': feature_importances
})

# 중요도 순으로 정렬
feature_importances_df = feature_importances_df.sort_values(by='Importance', ascending=False)

# 특성 중요도 시각화
plt.figure(figsize=(10, 7))
sns.barplot(x='Importance', y='Feature', data=feature_importances_df)
plt.title('Feature Importances in Random Forest')
plt.show()

☑️ 앙상블 학습 - 그래디언트 부스팅 머신 (GBM)

🔎 그래디언트 부스팅 머신 (GBM)란?

• 그래디언트 부스팅 머신(Gradient Boosting Machine, GBM)은 여러 개의 약한 학습기(weak learner)를 순차적으로 학습시키고, 그 예측 결과를 결합하여 강한 학습기(strong learner)를 만드는 앙상블 기법입니다.
• GBM은 이전 모델이 잘못 예측한 데이터 포인트에 가중치를 부여하여, 다음 모델이 이를 더 잘 학습하도록 합니다.
• 각 트리가 독립적으로 학습되기 때문에, 과적합을 방지하고 예측 성능을 향상시킬 수 있습니다.
• 첫 번째 초안을 만들고 오류가 나면 해석하고 개선한다. 이 과정을 계속 반복한다.
• 오류 수정을 문법으로 한다.

🔎 그래디언트 부스팅 머신 (GBM)의 원리

1. 초기 모델 학습: 첫 번째 결정 트리를 학습시켜 초기 모델을 만듭니다.
2. 잔여 오차 계산: 초기 모델의 예측 결과와 실제 값 간의 잔여 오차를 계산합니다.
3. 잔여 오차 학습: 잔여 오차를 예측하는 새로운 결정 트리를 학습시킵니다.
4. 모델 업데이트: 새로운 결정 트리를 기존 모델에 추가하여 모델을 업데이트합니다.
5. 반복: 잔여 오차가 충분히 작아질 때까지 2~4 단계를 반복합니다.

# sklearn의 ensemble 모듈에서 GradientBoostingRegressor가져온다.

from sklearn.ensemble import GradientBoostingRegressor
from sklearn.metrics import mean_squared_error

# GBM 모델 생성
gbm_model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)

# 모델 학습
gbm_model.fit(X_train_scaled, y_train)

# 예측
y_pred_gbm = gbm_model.predict(X_test_scaled)

# 평가
mse_gbm = mean_squared_error(y_test, y_pred_gbm)
print(f'GBM 모델의 MSE: {mse_gbm}')

☑️ 앙상블 학습 - XGBoost

🔎 XGBoost란?

• XGBoost(eXtreme Gradient Boosting)는 그래디언트 부스팅 알고리즘을 기반으로 한 고성능 앙상블 학습 기법입니다.
• XGBoost는 효율성, 유연성, 이식성을 목표로 설계되었으며, 다양한 머신러닝 경진대회에서 우수한 성능을 보여주고 있습니다.
• 병렬 처리, 조기 종료, 정규화 등의 기능을 통해 성능을 극대화합니다.
• 여러 약한 학습기를 순차적으로 학습시켜서 이전단계의 오류를 부정
• 학습이 병렬로 할 수 있게 개선
• 목표함수를 최소화 해 가중치를 업데이트한다.

🔎 XGBoost의 원리

1. 초기 모델 학습: 첫 번째 결정 트리를 학습시켜 초기 모델을 만듭니다.
2. 잔여 오차 계산: 초기 모델의 예측 결과와 실제 값 간의 잔여 오차를 계산합니다.
3. 잔여 오차 학습: 잔여 오차를 예측하는 새로운 결정 트리를 학습시킵니다.
4. 모델 업데이트: 새로운 결정 트리를 기존 모델에 추가하여 모델을 업데이트합니다.
5. 반복: 잔여 오차가 충분히 작아질 때까지 2~4 단계를 반복합니다.

🔎 XGBoost의 장점

• 병렬 처리: 트리의 분할을 병렬로 수행하여 학습 속도를 향상시킵니다.
• 조기 종료: 검증 데이터셋의 성능이 향상되지 않으면 학습을 조기에 종료하여 과적합을 방지합니다.
• 정규화: L1 및 L2 정규화를 통해 모델의 복잡도를 조절하고 과적합을 방지합니다.
• 유연성: 다양한 손실 함수와 평가 지표를 지원하여 다양한 문제에 적용할 수 있습니다.

☑️ GITHUB 특강

연결하기

1. 파일 연결하기

파일 만들고 commit까지 한 상태

git remote add origin 링크 

git push origin master

2. 레포 저장소 폴더 가져오기

레포 저장소 만들고

git clone 레포 주소

git add 파일

commit을 진행

git push

TIL작성

홈페이지 만들기

☑️ 회고

오늘은 이번주 내에 딥러닝 강의까지 다 듣고 당장 다음주에 팀과제 발제를 받아 진행해야한다는 생각에 무작정 강의를 들었습니다.

하지만 너무 많은 내용에 모르는 단어들로 이루어진 문장들이 머리를 어지럽히고 집중력을 떨어뜨렸습니다.

강의를 듣는 것은 마치고  슬랙에 올라온 용어 공부를 마지막으로 진행해야겟습니다.

용어

• 리스트 컴프리헨션: 리스트를 간결하게 생성하는 구문으로 반복문과 조건문을 한줄로 표현할 수 있습니다.
• 이터레이터: 반복 가능한 객체에서 값을 하나씩 꺼내주는 객체. for루프에서 자주 사용
• 제너레이터: 이터레이터를 쉽게 생성하 수 있는 함수로 yield키워드를 사용하여 값을 하나씩 반환합니다. 메모리 효율성이 뛰어납니다.
• GIL(Global Interpreter Lock): Python GIL은 여러 스레드가 동시에 실행되는 것을 막고 한 번에 하나의 스레드만 실행되도록하는 잠금 메커니즘입니다.
• 코루틴: Python 코루틴은 함수 실행을 중단하고 재재할 수 있는 비동기 프로그래밍 방식으로 async와 await키워드를 사용해 동시성을 효율적으로 처리합니다.
• 람다 표현식: 익명 함수
• Array: Numpy의 핵심이 되는 데이터 구조로  다차원 배열을 의미 배열연산을 통해 빠르고 효율적인 수학적 계산을 수행
• ndarray: Numpy에서 사용되는 기본 배열 객체로 n차원의 배열을 나타냄 다차원 데이터를 효울적으로 처리하기 위한 핵김 클래스
• 형상(Shape): 배열의 각 차원에서 요소의 개수를 나타내는 튜플. 예를들어  2차원배열레서 (행, 열)의 형태로 나타냄 
• 브로드캐스팅: 크기가 다른 배열 간의 연산을 가능하게 하는 기능. 작은 배열이  큰 배열의 형상에 맞춰 자동으로 확장되어 연산됨
• 뷰: 배열의 데이터를 복사하지 않고, 같은 데이터를 참조하는 새로운 배열을 의미. 뷰를 변경하면 원래 배열에도 영향을 줌
• 백터화 연산: 배열 간의 연산을 반복문 없이 한 번에 수행할 수 있는 기능. Numpy의 모든 연산은 벡터화되어있어 빠르고 효율적
• 집계 함수: 배열의 전체 또는 특정 축에서 값들을 집계하는 함수.  합계,  평균, 최대값, 최소값 등을 구할 수 있음
• 전치: 다차원 배열의 축을 전환하는 기능. 2차원 배열에서는 행과 열을 바꾸는 작업을 수행
• 랜덤배열: 데이터 샘플링 및 시뮬레이션 등에 유용 
• reshape: 배열의 크기를 변경하는 기능. 원소의 개수는 유지하면서 다른 차원의 배열로 변환가능
• 플랫: 다차원 배열을 1차원 배열로 평평하게 변환하는 작업
• 마스크 배열: 배열 내에서 특정 조건을 만족하는 값만 선택할 때 사용하는 배열 조건을 부여하여 필터링된 결과를 얻음.
• NaN(not a number): 숫자가 아닌 값을 나타냄 결측값을 표현하 때 사용되며, np.nan을 통해 NaN을 처리할 수 있음

내일부터 공부 패턴을 조금 바꿔 보려고 합니다.

9 ~ 10시 용어 공부

10 ~ 10:10 팀 회의

10:10 ~ 1시 이전에 공부했던 코드들 뜯어 먹기

1 ~ 2시 점심

2 ~6시 강의

6 ~ 7시 저녁

7 ~ 9시 강의 or 유튜브 강의 or 코드 뜯어먹기

• 지도학습: 분류모델-SVM
• 지도학습: 분류모델-KNN
• 지도학습: 분류모델-나이브베이즈
• 지도학습: 분류모델-의사결정나무
• GITHUB 특강
• 회고

☑️ 지도학습 : 분류모델 - SVM

🔎SVM이란?

• 서포트 벡터 머신(SVM)은 분류와 회귀 분석에 사용되는 강력한 지도학습 모델
• 데이터를 분류하기 위해 결정 경계(결정 초평면, hyperplane)를 찾아 분류합니다.
• 초평면은 두 클래스 사이의 최대 마진을 보장하는 방식으로 선택합니다.

결정경계, 초평면, hyperplane, 마진

몸무게를 억지로 맵핑을 해 평면에 나누어 선으로 표현할 수 있게 한다는데 방법은? 

결정경계: 데이터를 분리한 선

• 2차원에서는 선(line)이 결정 경계가 될 수 있습니다.
• 3차원에서는 평면(plane)이 결정 경계가 됩니다.
• 고차원에서는 초평면(hyperplane)이 결정 경계 역할을 합니다.

초평면: 데이터가 4차원 이상일 때 나눠주는 평면이 단순한 2차원이 아닌 평면

초평면 = hyperplane

서포터 백터: 결정 초평면에서 가장 가깝게 위치한 데이터

마진 : 마진은 하이퍼플레인과 가장 가까운 서포트 벡터(support vector) 사이의 거리입니다.

🔎 SVM의 역할

• SVM은 이 마진을 최대화하는 하이퍼플레인을 찾는 것이 목표입니다. 마진이 넓을수록 하이퍼플레인은 더 많은 데이터를 안정적으로 분리할 수 있으며, 이는 모델의 일반화 성능을 향상시킵니다.
• 두 클래스의 데이터 포인트 중에서 하이퍼플레인과 가장 가까운 두 서포트 벡터로부터의 거리를 최대화하는 하이퍼플레인을 찾습니다. 이를 통해 데이터의 불확실성을 줄이고 분류의 정확성을 높입니다.

데이터로드 전처리 과정은 전과 같음

📚 모델학습 코드

from sklearn.svm import SVC
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# 모델 생성 및 학습
model = SVC(kernel='linear') #kernel설정 현재는 선형모델
model.fit(X_train, y_train)

# 예측
y_pred = model.predict(X_test)

# 평가
print(f"Accuracy: {accuracy_score(y_test, y_pred)}")
print(f"Classification Report:\n{classification_report(y_test, y_pred)}")
print(f"Confusion Matrix:\n{confusion_matrix(y_test, y_pred)}")

🔎 scikit learn의 장점으로 인터페이스가 동일해서 모델 가져오기부분과 생성 및 학습 부분만 다름

☑️ 지도학습 : 분류모델 - KNN

🔎KNN이란?

• KNN의 학습은 데이터를 펼쳐 내는 것이다.
• KNN 알고리즘은 분류와 회귀 분석에 사용되는 비모수적 방법 입니다.
• 새로운 데이터 포인트를 기존 데이터 포인트 중 가장 가까운 K개의 이웃과 비교하여 분류합니다
• 데이터 포인트의 특성을 기준으로 거리 계산을 통해 가장 가까운 이웃을 찾습니다.

비모수적: KNN은 데이터의 분포에 대한 가정이 없으므로 비모수적 방법으로 분류됩니다.

🔎 KNN의 역할

• 분류: KNN은 주어진 데이터 포인트에 대해 가장 가까운 K개의 이웃을 찾아 그 이웃들이 속한 클래스의 다수결 투표를 통해 해당 데이터 포인트의 클래스를 결정합니다. 예를 들어, K=3이라면, 가장 가까운 3개의 이웃 중 2개가 클래스 A에 속하고 1개가 클래스 B에 속한다면, 새로운 데이터 포인트는 클래스 A로 분류됩니다.
• 회귀: KNN을 회귀 문제에 사용할 때는 K개의 이웃의 평균 값을 사용하여 예측 값을 결정합니다. 즉, K개의 이웃의 값을 더하고 K로 나누어 새로운 데이터 포인트의 값을 예측합니다.

k개를 설정하는 방법은 없고 임의로 넣어서 가장 적합한 상태가 나올 때까지 테스트해 보아야 한다.

📚 모델학습 코드

from sklearn.neighbors import KNeighborsClassifier #KNN의 알고리즘을 sklearn에서 가져오기
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix #여러가지 matrix 가져오기

# KNN모델 생성 및 학습 (이웃을 5개로 놓음)
model = KNeighborsClassifier(n_neighbors=5)
model.fit(X_train, y_train)

# 예측
y_pred = model.predict(X_test)

# 평가
print(f"Accuracy: {accuracy_score(y_test, y_pred)}")
print(f"Classification Report:\n{classification_report(y_test, y_pred)}")
print(f"Confusion Matrix:\n{confusion_matrix(y_test, y_pred)}")

🔎 scikit learn의 장점으로 인터페이스가 동일해서 모델 가져오기부분과 생성 및 학습 부분만 다름

☑️ 지도학습 : 분류모델 - 나이브베이즈

🔎 나이브베이즈란?

• 나이브베이즈(Naive Bayes) 분류기는 베이즈 정리를 기반으로 하는 통계적 분류 기법입니다.
• 나이브라는 이름이 붙은 이유는 각 특징(feature)이 독립적이라고 가정하기 때문입니다. (독립적이지 않으면 계산할 수 없다)
• 주로 텍스트 분류 문제에서 널리 사용됩니다.
• 하나하나의 단어가 어떤 클래스에 속할 확률을 계산해서 확률들을 종합적으로 고려해서 분류하는 방법
• 나이브 베이즈는 특정 클래스를 선택하는 조건부 확률을 계산하여 분류합니다.

🔎 나이브베이즈 종류

• 가우시안 나이브베이즈: 특징들이 연속적이고 정규 분포를 따른다고 가정합니다.(연속형 데이터)
• 베르누이 나이브베이즈: 특징들이 이진수(0 또는 1)로 표현되는 경우 사용합니다.
• 멀티노미얼 나이브베이즈: 특징들이 다항 분포를 따르는 경우 사용합니다.(텍스트 데이터)

🔎 나이브베이즈 목적

• 나이브베이즈의 목표는 주어진 데이터 포인트가 특정 클래스에 속할 확률을 계산하여 분류하는 것입니다.

📚 모델학습 코드

from sklearn.naive_bayes import GaussianNB #가우시안 나이브베이즈 가져오기
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# 모델 생성 및 학습
model = GaussianNB() #가우시안 나이브베이즈 모델 생성
model.fit(X_train, y_train)

# 예측
y_pred = model.predict(X_test)

# 평가
print(f"Accuracy: {accuracy_score(y_test, y_pred)}")
print(f"Classification Report:\n{classification_report(y_test, y_pred)}")
print(f"Confusion Matrix:\n{confusion_matrix(y_test, y_pred)}")

🔎 scikit learn의 장점으로 인터페이스가 동일해서 모델 가져오기부분과 생성 및 학습 부분만 다름

☑️ 지도학습 : 분류모델 - 의사결정나무

🔎 의사결정나무란?

• 트리 구조로 이루어져 있습니다. 이 구조는 크게 노드와 가지로 이루어져 있으며, 데이터를 나누어가는 과정에서 예측에 필요한 규칙을 도출합니다.
• 규칙은 불확실성이 낮아지도록 만들어야한다.

• 각 내부 노드는 데이터의 특정 특징에 대한 테스트를 나타낸다.
• 각 가지(branch)는 테스트 결과를 나타낸다.
• 각 리프 노드(leaf)는 클래스 레이블을 나타냅니다.

🔎 불확실성을 낮추는 방법

• 정보 이득(Information Gain) : 엔트로피(Entropy)값을 기준으로 데이터를 나눠준다. 엔트로피는 불확실성을 나타내며, 엔트로피가 낮을수록 불확실성이 적습니다.
• 지니 계수(Gini Index): 불순도를 측정하는 방법으로, 지니 계수가 낮을수록 불순도가 적습니다

🔎  데이터의 불확실성이 변화가 없을 때 까지 나누어 주는 것이 의사결정나무의 학습이다.

📚 모델학습(파란글씨는 다른 부분)

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# 모델 생성 및 학습
model = DecisionTreeClassifier(random_state=42)
model.fit(X_train, y_train)

# 예측
y_pred = model.predict(X_test)

# 평가
print(f"Accuracy: {accuracy_score(y_test, y_pred)}")
print(f"Classification Report:\n{classification_report(y_test, y_pred)}")
print(f"Confusion Matrix:\n{confusion_matrix(y_test, y_pred)}")

🔎 scikit learn의 장점으로 인터페이스가 동일해서 모델 가져오기부분과 생성 및 학습 부분만 다름

☑️ GITHUB 특강

🔎 GITHUB란?

• Git은 형상 관리 도구 중 하나로, 컴퓨터 파일의 변경사항을 추적하고 여러 명의 사용자들 간에 해당 파일들의 작업을 조율하기 위한 분산 버전 관리 시스템이다.
• Git은 소프트웨어 개발에서 소스 코드를 효과적으로 관리할 수 있도록 하는 무료, 공개 소프트웨어입니다.
• Git은 프로젝트 폴더 내에서 작업을 기록하고, 버전 관리를 통해 체계적인 개발이 가능하도록 합니다.

📚 git 시작하기

1. git 다운 확인

• git bash => git --version

2. Linux명령어로 파일 만들기

• ls 현재 위치에서의 파일 목록 보기
• ls -al 현재위치에서의 숨김 파일 포함 보기
• pwd 현재 위치 보기
• clear 명령어 지우기
• cd 들어가려는 폴더 ex) cd desktop (만약 한글이름이나 띄어쓰기면 "묶어주세요")
• cd .. 현재위치에서 한단계 뒤로 이동
• mkdir 폴더이름  폴더만들기
• touch 파일명.py 파일만들기
• rm 파일명 파일삭제
• rm -r 파일명 폴더 삭제
• start . 현재파일 열기

3. 버젼관리 시작 로컬 저장소 생성/지정 git init

• 특정 폴더에서 꼭 시작해야한다. 홈이나 바탕화면에서 하면 안된다.
• 이것을 입력하게 되면 숨김파일로 .git이 생성 된다.
• .git이 버젼관리 기록하는 파일이다.

4. 버젼관리 시작

• git add 파일 => 관리를 시작할거다.

5. Commit

• git commit => 이상태로 저장할거다.
• git commit -m "남길 파일을 구분 할 수 있는 이름"
• git status => commit한 내용을 확인
• git log =>

📚  git의 세가지 영역

• Working Directory 현재 git으로 관리하는 폴더(.git이 들어있는 폴더)
• Staging Area 앞으로 Commit으로 남기고싶은 특정버젼으로 관리하고 싶은 파일이 있는 곳 
• Repository Commit들이 저장되는 곳

☑️ 마크다운

🔎 마크다운이란?

• 텍스트 기반의 마크업 문법
• 마크업 = 태그를 이용하여 문서의 구조를 나타내는 표현법

📚 마크다운 실습

1. 헤딩

"#"갯수에 따라 제목의 수준을 구별(h1~h6)

ex)

# 제목

## 소제목

## 소소제목

2. 리스트

3가지 방법으로 사용할 수 있습니다.

-

*

1. 2.  3.

3. 파이썬 코드 넣기

esc밑에 `

ex)

```python

코드들

```

4. url이나 파일경로 넣기

[Google](링크) 를 하게 되면 링크를 걸 수 있다.

[파일 열기도 가능](파일 경로)

5. 이미지 넣기


6. text 글꼴

일반

**뚱뚱**

*기울*

~~취소~~

7. 구분선(수평선)

***

---

___

8. 인용표현

> 인용

>>인용안에 인용

>>> 인용안에 인용안에 인용

🔎 회고

☑️ 지도학습 : 분류모델 - SVM

1. 결정경계:

데이터를 분리한 선

• 2차원에서는 선(line)이 결정 경계가 될 수 있습니다.
• 3차원에서는 평면(plane)이 결정 경계가 됩니다.
• 고차원에서는 초평면(hyperplane)이 결정 경계 역할을 합니다.

2. 초평면:

• 데이터가 4차원 이상일 때 나눠주는 평면이 단순한 2차원이 아닌 평면
• hyperplane = 초평면

3. 마진:

• 마진은 하이퍼플레인과 가장 가까운 서포트 벡터(support vector) 사이의 거리입니다.

4.서포터 백터:

• 결정 초평면에서 가장 가깝게 위치한 데이터

5. 몸무게를 억지로 맵핑을 해 평면에 나누어 선으로 표현할 수 있게 한다는데 방법은? 

☑️ 지도학습 : 분류모델 - SVM

비모수적:

• NN은 데이터의 분포에 대한 가정이 없으므로 비모수적 방법으로 분류됩니다.

오늘은 처음 들어보는 단어들이 많이 나왔지만 내용에 대한 정의가 이해가 가는 부분이 많아 궁금한 부분이 적었다.

오전에 파이썬 응용 문제를 풀는데 많은 시간을 할애하였고 특강이 2번이나 있어 강의를 많이 수강하지 못했다.

아직 사전캠프의 문제들에서도 감을 못잡고있어 오래걸리더라도 문제를 많이 풀어보고 다시 풀어보고 강의 교안의 코드들을 따라 써보는 것이 중요해 보인다.