onesword 님의 블로그

• 비지도학습

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번이나 있어 강의를 많이 수강하지 못했다.

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

• 머신러닝
• 머신러닝 학습
• 라이브러리
• Kaggle
• 데이터 전처리
• 실습
• 지도학습
• 회고

📚  머신러닝의 정의

• 컴퓨터가 명시적으로 프로그래밍 되지 않아도 데이터를 통해 학습하고, 예측할 수 있도록 하는 기능
• 대량의 데이터를 알고리즘에 입력하여 학습과정을 통해 모델을 생성하고 예측을 수행

☑️ 머신러닝의 구성요소

데이터셋 

• 머신러닝은 데이터셋을 통해서 학습하며, 일반적으로 데이터셋은 입력/출력 데이터(레이블)로 구성됩니다.
• 머신러닝의 베이스가 데이터 셋이기 때문에 중요!
• 입력 데이터(Feature): 정답을 추론하기 위한 정보 데이터
• 출력 데이터(레이블): 정답을 맞추기 위한 데이터

특징(Feature) 

• 데이터셋에서 모델이 학습할 수 있는 개별 속성
• 주택가격예측을 예시로 들 경우 주택의 크기, 위치, 방의 개수 등이 Feature에 해당합니다​

레이블(label)

• 예측하고자 하는 목표 변수(맞추기 위한 변수 = 정답이 목표 변수다)
• 지도학습 모델에서는 레이블이 있는 데이터셋을 이용하여 모델을 학습 시킵니다
•  

모델

• 데이터의 특징으로 부터 정답(레이블)을 예측할 수 있는 지식을 학습할 수 있는 프로그램/함수
• 입력데이터와 출력 데이터간의 관계를 학습하여 새로운 데이터에 대한 예측 수행
• 데이터가 있을 때 특징과 규칙을 찾는 알고리즘

학습

• 모델이 데이터를 통해서 패턴을 인식하고, 이를 기반으로 예측을 수행 할 수 있도록 함수 내의 가중치를 조정하는 과정

 📚  머신러닝의 학습

데이터 수집 

• 모델을 학습시키기 위한 필요 데이터 수집

데이터 전처리 

• 결측값 처리, 이상치 제거, 정규화 등등

Feature 선택 

• 중요 feature(특징)을 선택하고 불필요한 Feature를 제거하여 학습효율 높임
• 여러가지 특징을 결합해서 수학적, 알고리즘적 작업을 진행해 성능을 높여주는 중요한 단계

모델 선택 

• 문제에 적합한 머신러닝 알고리즘을 선택
• 여러 특징들의 조합으로 시도해보고 성능을 늘리는 단계

모델 훈련

• 트레이닝 데이터셋을 사용해서 모델을 학습시킴
• 훈련을 하며 모든 단계에서 추가, 제거 등 많은 시도가 필수적 (무엇을 보고 추가 제거를 하는거지?)

모델 평가

• 테스트 데이터셋을 사용하여 모델 성능을 평가

모델 배포 

• 학습된 모델을 실제 환경에 배포하여 예측 수행

☑️ 학습 방법

지도 학습 (Supervised Learning)

레이블이 있는 데이터셋을 이용하여 모델을 학습시키는 방법

• 회귀(Regression) : 연속적인 값을 예측하는 문제 ex : 주택 가격 예측, 주식 가격예측
• 분류(Classification) : 이산적인 값을 예측하는 문제 ex : 이메일 스팸 필터링, 이미지 분류

비지도 학습 (Unsupervised Learning)

레이블이 없는 데이터셋을 이용하려 모델을 학습시키는 방법

• 군집화(Clustering) : 데이터를 유사한 그룹으로 묶는 문제 ex : 고객 세분화, 이미지 세그멘테이션
• 차원축소 (Dimensionality Reduction) : 고차원 데이터를 저차원으로 변환 ex : PCA, t-SNE

앙상블 학습 (Ensemble Learning)

여러개의 머신러닝 모델을 결합하여 더 나은 성능을 얻는 방법

• 배깅(Bagging) : 여러 모델을 독립적으로 학습시키고, 예측을 평균내거나 다수결 투표로 최종 예측 ex : 랜덤포레스트
• 부스팅(Boosting) : 여러 모델을 순차적으로 학습시키고, 이전 모델의 오차를 보완하여 최종 예측을 수행 ex : 그래디언트 부스팅, XGboost
• 스태킹(Stacking) : 여러 모델을 학습시키고 예측결과를 새로운 데이터로 사용하여 메타 모델을 학습

📚 머신 러닝을 위한 라이브러리 (Scikit-learn)

• 다양한 머신러닝 알고리즘을 제공하며, 데이터 전처리, 모델 학습, 평가 및 예측을 위한 도구를 포함

설치

conda install scikit-learn
# conda를 사용하여 Scikit-learn 설치

pip install scikit-learn

# pip를 사용하여 Scikit-learn 설치

Scikit-learn 주요기능

• 데이터 전처리: 스케일링, 인코딩, 결측값 처리 등 다양한 데이터 전처리 기능을 제공합니다.
• 모델 학습: 회귀, 분류, 군집화 등 다양한 머신러닝 알고리즘을 제공합니다.
• 모델 평가: 교차 검증, 성능 평가 지표 등 모델 평가를 위한 도구를 제공합니다.
• 모델 예측: 학습된 모델을 사용하여 새로운 데이터에 대한 예측을 수행할 수 있습니다.

☑️  kaggle

📚 캐글이란?

• 데이터 과학 및 머신러닝 경진대회 플랫폼
• 데이터 사이언티스트 / 머신러닝 엔지니어들이 다양한 문제를 해결하고 데이터를 분석
• 모델을 개발하는데 필요한 데이터셋과 도구를 제공

📚 데이터셋 다운 받기

kaggle competitions download -c 데이터셋 이름

# 타이타닉 데이터셋 다운로드

unzip 데이터셋 이름.zip

# 다운로드된 파일 압축 해제

☑️  데이터 전처리

📚 데이터 전처리란?

• 데이터 분석 및 머신러닝 모델링을 위해 데이터를 준비하는 과정
• 원시 데이터(raw data)는 종종 불완전하거나, 노이즈가 많거나, 형식이 일관되지 않아 직접 모델링에 사용하기 어려움
• 데이터 전처리는 데이터의 품질을 높이고, 분석 결과의 신뢰성을 확보하기 위한 필수적인 과정

☑️ 실습

📚 결측치

1. 제거

# 결측값이 포함된 행 제거
df_dropped_rows = df.dropna()

# 결측값이 포함된 열 제거
df_dropped_cols = df.dropna(axis=1)

2. 대체

# 결측값을 0으로 대체

df_filled = df.fillna(0)

# 결측값을 각 열의 평균값으로 대체

df_filled_mean = df.fillna(df.mean())

# 결측값을 각 열의 중간값으로 대체

df_filled_median = df.fillna(df.median())

# 결측값을 각 열의 최빈값으로 대체

df_filled_mode = df.fillna(df.mode().iloc[0])

📚 이상치

1. 확인 (IQR)

# 특정 열의 이상치 확인 (IQR 방법)
Q1 = df['column_name'].quantile(0.25)
Q3 = df['column_name'].quantile(0.75)
IQR = Q3 - Q1

# 이상치 범위 설정
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# 이상치 확인
outliers = df[(df['column_name'] < lower_bound) | (df['column_name'] > upper_bound)]
print(outliers)

2. 대체

# 이상치를 평균값으로 대체
mean_value = df['column_name'].mean()
df['column_name'] = df['column_name'].apply(lambda x: mean_value if x < lower_bound or x > upper_bound else x)

3. 제거

# 이상치 제거
df_no_outliers = df[(df['column_name'] >= lower_bound) & (df['column_name'] <= upper_bound)]

📚 중복 데이터

1. 확인

# 중복된 행 확인
print(df.duplicated().sum())

2. 제거
# 중복된 행 제거
df_no_duplicates = df.drop_duplicates()

📚 데이터 타입 변환

df['column_name'] = df['column_name'].astype(변환할 타입)

📚 인코딩

범주형 데이터 => 더미 변수

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

📚 샘플링

# 데이터셋에서 50% 샘플 추출

df_sampled = df.sample(frac=0.5)

# 데이터셋에서 100개의 샘플 추출

df_sampled_n = df.sample(n=100)

☑️  지도학습: 회귀모델

📚 지도학습이란?

• 정답이있고 정답을 데이터를 통해 학습하는 방법을 말한다.

📚 회귀 모델

• 연속적인(간단한) 값을 예측하는 모델 (키, 가격 등을 예측)

☑️선형회귀

• 선형회귀는 종속 변수와 하나 이상의 독립 변수 간의 선형 관계를 모델링 하는 방법입니다
• 독립변수의 수에 따라 단순 선형회귀와 다중 선형회귀로 나뉩니다
• 독립변수: 예측하기 위해 사용하는 정보
• 선형관계: 곱셈과 덧셈만으로 이루어진 관계

• 단순 선형회귀: B1 + B2 * 독립변수
• 다중 선형회귀 : B1 + B2 * 독립변수1 + B3 * 독립변수2 (독립변수가 여러개 들어가있어서)
• 가중치 (B1, B2, B3) = 학습(목적함수를 최소화한 B1과 B2를 찾는게 학습이다.)
• 목적함수(loss function): 예측값과 정답값 사이의 차이를 수치로 나타내는 것(값이 줄어들수록 가중치를 잘찾은 것)

목적함수에서 미분과 최적화함수를 사용해서 구한다.

미분에서 대표적으로 경사하강법이 있다.

경사하강법: 특정함수가 줄어드는 방향으로 특정변수들의 값을 업데이트 하는 방법

정리: 학습이란 머신러닝에는 가중치가 있고 이것들로 예측값이 결정 된다. 예측치와 실제값을 비교해서 얼마나 차이나는지 오차를 계산하고 이를 최소화 하기 위해 가중치를 바꿔가며 오차가 줄어들게 하여 정답에 가깝게하는 것이다.

한번에 최저값으로 만들지 않는 것은 비효율적이기 때문이다.

📚Scikit-learn을 사용한 선형 회귀 모델 구현 및 평가

import pandas as pd

import numpy as np
from sklearn.model_selection import train_test_split #데이터 분할 기능
from sklearn.linear_model import LinearRegression #선형 모델을 가져오고 선형 회귀로 지정
from sklearn.metrics import mean_squared_error, r2_score #모델의 성능을 평가하는 메트릭을 가져온다.

데이터 분할

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

train_test_split(독립변수, 종속변수, 테스트의 비율, random_state값에 따라 데이터셋을 랜덤하게 분할하게 한다.)

선형모델 생성 및 실행

model = LinearRegression() #선형모델이 자동 생성
model.fit(X_train, y_train) #(테스트 데이터, 테스트 정답)넣어주면 자동으로 학습이 진행 된다.

• X_train: 모델이 학습할 때 사용할 입력 데이터(독립 변수들).
• y_train: 출력 데이터(종속 변수 또는 타겟값)입니다

예측

y_pred = model.predict(X_test) #값을 저장할 변수 생성 후 모델에서 predict함수 호출해 테스트할 독립변수를 넣어준다.

정확도 평가

mse = mean_squared_error(y_test, y_pred) #0에 가까울수록 좋다
r2 = r2_score(y_test, y_pred) #1에 가까울수록 좋다

☑️ 다항회귀

• 다항 회귀(Polynomial Regression)는 종속 변수와 독립 변수 간의 비선형 관계를 모델링하는 방법
• 독립변수의 다항식을 사용하여 관계를 모델링 합니다.

다항회귀 차수 선택

• 다항회귀 차수(degree) : 독립 변수의 최대 차수
• 차수가 높을수록 모델이 더 복잡해지며 과적합(overfitting)의 위험 존재 → 적절한 차수 선택 필요

📚 Scikit-learn을 사용한 다항 회귀 모델 구현 및 평가

import pansdas as pd

import numpy as np

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import PolynomialFeatures #Features의 차수를 선택해준다.

from sklearn.linear_model import LinearRegression

from sklearn.metrics import mean_squared_error, r2_score

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

y = np.array([1, 4, 9, 16, 25, 36]) # 데이터 생성

poly = PolynomialFeatures(degree=2) #2차항까지 만들어주게 설정

X_poly = poly.fit_transform(X) #데이터를 만들어둔 Polynomial생성기에 전달해서 실제로 2차항으로 만든다.

X_poly를 실행해보면

array([[ 1.,  1.,  1.],
       [ 1.,  2.,  4.],
       [ 1.,  3.,  9.],
       [ 1.,  4., 16.],
       [ 1.,  5., 25.],
       [ 1.,  6., 36.]])

순서대로 0차항, 1차항, 2차항 값이 나온다.

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

#데이터 분할

model = LinearRegression()
model.fit(X_train, y_train)

#선형식을 넣는 이유: 위 poly = PolynomialFeatures(degree=2)에서 다항식을 만들어주었는데 이걸

LinearRegression()에 넣으면 다항회귀식으로 나타내주기 때문이다.

#Features을 생성해주는 것 만으로 선형회귀식을 다항회귀식으로 활용가능

y_pred = model.predict(X_test)

mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f'Mean Squared Error: {mse}')
print(f'R^2 Score: {r2}')

☑️ 로지스틱 회귀 

• 종속 변수가 이진형일 때(즉, 결과가 두 가지 중 하나일 때) 사용되는 통계 기법
• 로지스틱 회귀는 선형 회귀와 달리 결과값이 0과 1 사이에 위치하게 하기 위해 시그모이드 함수(Sigmoid Function)를 사용합니다.
• 실제로는 분류모델에 사용한다.

로지스틱 회귀 사용 목적

• 로지스틱 회귀는 데이터를 학습하여 각 데이터 포인트가 특정 클래스에 속할 확률을 예측합니다.
• 예를 들어, 유방암 데이터에서는 환자가 암에 걸렸을 확률, 타이타닉 데이터 에서는 승객이 생존할 확률을 예측합니다.

로지스틱 회귀의 비용함수란?

• 로지스틱 회귀의 비용 함수는 모델의 예측 확률과 실제 레이블 사이의 차이를 측정합니다.
• 로그 손실 함수(Log Loss) 또는 크로스 엔트로피 손실 함수(Cross-Entropy loss)라고 불립니다.
• 확률을 높여주어야 한다.
• 값이 1에 가까울수록 정확한 값이다.(0에 가까우면 잘못한거다.)

개념

-m개는 데이터이다. 데이터 전체의 확률을 계산 한다.

-y(i)는 확률 ex)1

-h는 실제로 예측한 값 ex) 0.2

-로그 함수는 값이 작아질수록 굉장히 작은 값이 나온다.

-1 - y(i)는 실제로 아닐 확률 ex)0

📚 데이터 로드 및 전처리

import numpy as np

import pandas as pd

from sklearn.datasets import load_breast_cancer # sklearn에 포함된 datasets중 사용할 load_breast_cancer데이터 가져오기

from sklearn.model_selection import train_test_split #test train을 나누기 위한 모듈 import

from sklearn.preprocessing import StandardScaler # StandardScaler는 데이터가있을 때 데이터의 분포를 맞춰주는 역할(데이터 정규화)

data = load_breast_cancer() # 데이터 로드

X = data.data #X에 Feature만 가져온다.

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)

#만들어진 스케일러에 트레이닝 데이터를 fit해준다. 그러면 스케일러는 학습을 한다

#fit이라는건 학습을 말한다.

#스케일링을 하는 이유는 데이터가 있을때 표준과 표준편차를 정규분포를 따르도록 해주는것

#간단하게 데이터가 평균과 분산이 같도록 바꿔주는 작업

X_test = scaler.transform(X_test)

# X_train에 대해서 평균과 편차를 찾아 정규화 해준다.

# transform은 실제데이터에 적용하는 것을 말한다.

📚 모델학습

from sklearn.linear_model import LogisticRegression

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix

# LogisticRegression 모델과 다양한 metrics 가져오기

모델 생성 및 학습 

model = LogisticRegression()

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)}")

9강 강의자료 아래에 타이타닉 데이터를 활용한 전처리 내용 (내용이 길어서 작성은 X, 복습은 필수)

인코딩 부분에서 안좋은 예시로 들어있음 (데이터들을 너무 간단하게 0,1,2로 표현했기 때문)

# 특성과 타겟 분리

X = titanic.drop('survived', axis=1)

y = titanic['survived']

survived는 종속변수라서 학습에 필요X = y(종속변수로 지정)

타이타닉에서 열을 기준으로 survived분리/ 나머지는그대로 놔둔다.

☑️  회고

1. 모델훈련에서 무엇을 보고 추가 제거를 하는거지?

2. 이상치 대체

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

• 람다 함수lambda는 이름 없이 간단하게 한 줄로 함수를 정의
• lambda x: x는 column_name의 각 개별 값을 나타냅니다.
• if x < lower_bound or x > upper_bound: 만약 x가 lower_bound(하한값)보다 작거나 upper_bound(상한값)보다 큰 경우, 즉 값이 범위 밖에 있는 경우,
• mean_value: 그 값을 **평균값(mean_value)**으로 대체합니다.
• else x: 그렇지 않다면, 값은 변경하지 않고 그대로 유지됩니다.

3. 인코딩 부분 실습하면서 이해필요

4. 데이터 분할

train_test_split() 함수

• 이 함수는 주어진 데이터를 훈련용 데이터와 테스트용 데이터로 나눕니다. 훈련 데이터는 모델을 학습시키는 데 사용되고, 테스트 데이터는 모델의 성능을 평가하는 데 사용됩니다.

5. 정확도 평가

**MSE (Mean Squared Error)**와 **R² (R-squared, 결정계수)**는 회귀 모델의 성능을 평가하는 데 사용되는 지표입니다. 두 지표는 서로 다른 측면에서 모델의 정확도를 평가합니다.

r2 = r2_score(y_test, y_pred) 

 R²는 모델이 전체 변동을 얼마나 잘 설명하는지 나타내는 지표로, 타겟 변수의 변동성 중에서 독립 변수가 얼마나 설명할 수 있는지를 보여줍니다.  

mse = mean_squared_error(y_test, y_pred)
평균 제곱 오차는 모델이 예측한 값과 실제 값 간의 차이를 평가하는 지표로, 그 차이(오차)의 제곱 평균을 계산합니다.

6. 모델 학습

accuracy_score, classification_report, confusion_matrix

7. .predict() 함수

1) 선형회귀

LinearRegression 모델에서 .predict()를 사용하면 주어진 입력 데이터에 대해 연속적인 값을 예측합니다.

2) 로지스틱 회귀

LogisticRegression에서 .predict()를 사용하면 주어진 데이터에 대한 클래스 라벨을 예측합니다. 로지스틱 회귀는 이진 또는 다중 클래스 분류를 수행할 수 있습니다.

3) 로지스틱 회귀에서 확율 예측

로지스틱 회귀와 같은 분류 모델에서는 .predict_proba() 메서드를 사용하여 각 클래스에 속할 확률을 예측할 수 있습니다.

• 도전과제 1번 
• 도전과제 2번 
• 도전 과제 3번 
• 총평 
• 새롭게 알게 된것 
• 까먹은 것
•  궁굼한 것

도전과제 1번

숫자 맞추기 게임 (선택)

추가 도전 과제

• 플레이어가 입력한 숫자가 범위를 벗어날 경우, 적절한 안내 메시지를 출력하여 유효한 범위 내의 숫자를 입력하도록 유도하세요.

        if user_num > 10: #입력 값이 10보다 클 때 작동
            print(f'숫자가 너무 큽니다. 10 이하의 숫자만 입력해주세요.') #위 조건이 충족 되었을 때 출력 되는 메세지 작성

• 플레이어가 게임을 반복하고 싶을 경우, 게임 재시작 여부를 묻고 그에 따라 게임을 초기화하거나 종료하는 기능을 추가하세요.

    restart = input('다시 시작하겟습니까? (y/n)') #다시 시작여부 입력 받는 restart 생성

    if restart != 'y': #y가 아닐 때 작동
        print('게임이 끝났습니다.')  #위 조건에 맞으면 출력 되는 메세지       
 
    
        break #조건 충족 시 멈춤

도전과제 2번 

추가 도전 과제

• Person 클래스 생성자에서 사용자의 성별 입력값에 대한 유효성 검사를 추가해주세요.

while True:
    gender = input('성별을 입력해주세요 (male OR female): ').strip().lower()  # 소문자로 변환하여 비교를 용이하게 함
    if gender == 'male' or gender == 'female':  # gender 조건
        break
    else:
        print('male과 female 중 하나만 입력해주세요.')

• Person 클래스에 나잇대에 맞는 인사 메시지를 출력할 수 있도록 greet() 함수를 추가해주세요

        
    def greet(self): #조건식에 따라 성인 미성년자를 구분해서 인사하는 함수 추가
        if age >= 20:
            print("안녕하세요!name님 성인이군요!!")
        else:
            print("안녕하세요!name님 미성년자군요!!")
    

위 코드를 실행 시킬 때 

person1.display(), person1.greet() 각각 호출해서 함수를 작동 시켜야하는데 한번에 작동 시키는 방법이있을까?

도전 과제 3번

추가 도전 과제

1. Python 라이브러리 함수를 사용하여 인구 데이터(pop_kor.csv) 파일을 불러오고, DataFrame을 출력해주세요.

• Quiz에서 수행한 DataFrame의 구별 index를 기준으로 merge를 할 것이므로, index를 셋팅해서 불러와 주세요.

pop_kor_df = pd.read_csv("pop_kor.csv", index_col='구별', encoding='utf-8') 

#csv파일 가져오기, '구별' 열을 인덱스 지정, 한글파일 읽어오기

df_csv = pd.DataFrame(pop_kor_df)

#df_csv라는 데이터 프레임 생성

df_csv2 = df_csv.dropna() 
df2 = df.dropna() 

#결측치 존재하는 행 제거

2. join 을 사용하여 Quiz에서 수행한 DataFrame과 인구 데이터 DataFrame을 merge하고, DataFrame을 출력해주세요.

df3 = df2.join(df_csv2)

 #df2와 df_csv2를 join해서 df3 생성 

df3.dropna()

 #df3에서 결측치가 존재해 sort가 진행 되지않아 제거

3. 새롭게 merge 된 DataFrame에서 검거율 기준으로 오름차순 정렬 후, DataFrame을 출력해주세요.

sort_df = df3.sort_values(by = '검거율',ascending=True)  

#검거율을 기준으로 정렬

총평
 

도전과제 1-1: 간단한 조건문은 쓰는데 익숙해지고있다.

도전과제 1-2: 조건을 추가 할 때 위치는 어느정도 감을 잡은 듯. 약간 복잡해져도 잘 모르겟어서 검색을 통해 진행했다.                            코드 전체를 보는 감각이 부족하다.

도전과제 2-1번: 어제 걸었던 조건식으로 해결 가능할 것 같아 건들이지 않았다.

도전과제 2-2번: 처음에는 greet함수 문법이 생각 나지 않아 검색해서 첫 줄 문법만 보고

                       작성하였고 매개변수인 self, 조건식, print문은 직접 작성했다.

도전과제 3-1번: 데이터 불러오기는 익숙해 져서 코드를 보지 않아도 작성 가능해졌다..

도전과제 3-2번: 데이터끼리 병합하는 단계는 강의보고 따라 했었지만 기억나지 않았고 검색을 통해 작성하였다.

                         병합하는 방법과 예시들이 많았기에 실습을 더 진행해 보아야 할 것 같다.

도전과제 3-3번: 결측치 확인을 하지 않아 진행이 안되었지만 결측치 제거 후 진행이 깔끔해짐

                          결측치 처리의 중요성을 인지 했습니다.

총평: 조금씩 익숙해지고 있지만 문법, 함수 / 메서드의 기능 등 부족한 부분이 많다.

새롭게 알게 된것

1. 파일을 read 할 때 인덱스를 정해서 가져오는 방법

df = pd.read_csv('test.csv', index_col = "")

#index_col = " "과 숫자로 가져오는 방법이있다.

2. join 사용 문법

DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)

• other: 결합할 다른 데이터프레임
• on: 결합할 기준이 되는 열이나 인덱스 (기본값은 인덱스)
• how: 결합 방식 (left, right, outer, inner)
• lsuffix, rsuffix: 동일한 열 이름이 있을 때 구분을 위한 접미사
• sort: 결합된 결과를 정렬할지 여부 (기본값은 False)

3. `\t`는 탭을 의미

4. `\n'`은 줄바꿈을 의미

5. 같은 줄에 여러 함수 쓰는 법 

print("first");print("second")

6. 줄바꿈 없이 출력 방법 end = ""

print("first", end=""); print("second")

7. 바인딩이란

 변수 속성을 이름, 자료형, 자료값으로 할당 하는 것

8. 변수를 출력할 때 기호 붙이기(s와t는변수)

print(s+"!",t)

9. 슬라이싱의 기능

string = "홀짝홀짝홀짝"
print(string[::2])

시작인덱스:끝인덱스:오프셋(오프셋은 몇칸씩 건너 뛸지 지정)

                                              (오프셋을 -1로 지정하면 문자열을 뒤집어서 출력 한다.)

10. 문자열에 값 넣기 % formatting

포맷 코드설명

문자열 포맷팅 ex)

name = "Alice"

greeting = "Hello, %s!" % name

print(greeting) # Hello, Alice!

2가지 다른 문자열 포맷팅 ex)

message = '이름: %s, 나이: %d' %(name, age)

11. 문자열에 값 넣기 .format()

print("이름: {} 나이: {}".format(name, age))

12. 문자열에 값 넣기 f"

print(f"이름: {name} 나이: {age}")

13. 첫글자만 대문자로 .capitalize()

#첫 글자에 숫자나 기호가 있을 때는 변화 없음

14. 특정 접미사로 끝나는지 확인 .endswith()

string.endswith(suffix[, start[, end]])

• suffix: 확인할 접미사 문자열 또는 문자열의 튜플.
• start (선택적): 검색을 시작할 위치(인덱스).
• end (선택적): 검색을 끝낼 위치(인덱스).

15. 특정 접두사로 확인

file_name.startswith("2020")

까먹은 것

1. merge 사용 문법

DataFrame.merge(right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, suffixes=('_x', '_y'))

• right: 결합할 다른 데이터프레임.
• how: 조인 방식 (default: 'inner').
  • 'left': 왼쪽 데이터프레임을 기준으로 결합.
  • 'right': 오른쪽 데이터프레임을 기준으로 결합.
  • 'inner': 교집합 (공통된 값만 결합).
  • 'outer': 합집합 (모든 값 결합, 일치하지 않는 값은 NaN).
• on: 결합할 공통 열의 이름 (열 이름이 같을 때 사용).
• left_on: 왼쪽 데이터프레임에서 결합할 열 이름.
• right_on: 오른쪽 데이터프레임에서 결합할 열 이름.
• left_index, right_index: 인덱스를 기준으로 결합할지 여부.
• suffixes: 동일한 열 이름에 대한 접미사 (기본값: ('_x', '_y')).

2. 변수에서 글자 지정해서 출력

letters = 'python'

print(letters[0], letters[2])

3. replace 메서드

text = "banana"
new_text = text.replace("a", "o") # new_text = text.replace("a", "o", 1) # 1번만 치환
print(new_text)  # "bonono"         # "bonana"

text = "apples are red, apples are sweet"
new_text = text.replace("apples", "oranges") # ("apples", "oranges",1)을 하면 1번만 치환
print(new_text)  # "oranges are red, oranges are sweet" # "oranges are red, apples  are sweet" 

4. 문자열을 나누어 리스트로 반환 .split()

text.split(sep=None, maxsplit=-1)

• sep: 문자열을 분리할 때 사용할 구분자. (기본값은 공백)
• maxsplit: 분리할 최대 횟수. (기본값은 -1, 즉 제한 없음)

4-1 공백 기준 분리 # words = text.split()

4-2 특정 구분자를 기준으로 분리 # fruits = text.split(",")

4-3 최대 분리 횟수 지정 # parts = text.split(", ", 2) =>  ['one', 'two', 'three, four']

4-4 한 글자씩 분리 list로 분리하는게 적합하다. # letters = list(text)

5. .apply() 적용 방법

apply(func, axis=0, raw=False, result_type=None, args=(), **kwds)

• func: 적용할 함수. 직접 정의한 함수나 내장 함수를 사용할 수 있습니다.
• axis: 함수를 적용할 축을 선택.
  • 0 (기본값): 열(column) 단위로 함수 적용.
  • 1: 행(row) 단위로 함수 적용.
• raw: True일 경우, 행이나 열을 ndarray로 전달. (기본값은 False)
• result_type: 결과 형식을 지정 (expand, reduce 등).
• args: 추가적인 인자를 전달.

6. 대/소문자 upper()/lower()

대문자로 바꾸는 ex)

ticker = "btc_krw"

ticker1 = ticker.upper()

print(ticker1)

입력값을 대/소문자로 바꿔서 받게하는 ex)

data = input("적어 봐").upper() / .lower()

7. 리스트 사이에 요소 넣기 .insert()

movie_rank = ['닥터 스트레인지', '스플릿', '럭키', '배트맨']

movie_rank.insert(1,'슈퍼맨')

#(위치 지정, 넣을 요소 지정)

궁굼한 것

1번은 y가 아닌 다른 어떤 문자나 숫자가 와도 프로그램이 종료 되는데  해결 방법을 못찾음 

1번에서 숫자가 아닌 다른 문자나 공백이 써졌을때를 대비한 조건문도 넣어보자

2번은 person1.display(), person1.greet() 각각 호출해서 함수를 작동 시켜야하는데 한번에 작동 시키는 방법이있을까?

3번은 정확한 건지 모르겟음

• 개인 과제 2번
• 개인 과제 3번
• 총평
• 알게 된 것들
• 까먹은 것들

2. 클래스 함수 사용

과제 내용

• 이름, 성별, 나이를 입력받고, 이를 출력하는 프로그램을 작성해주세요.

4차 시도

class person: #person 클래스 정의
    def __init__(self, name, gender, age):#초기화 메서드
        self.name = name #속성정의
        self.gender = gender
        self.age = age
        
    def display(self): #정보출력함수 적용
        print(f"""이름:{self.name},성별: {self.gender}
나이: {self.age}""")   
    
name = input('이름을 입력해주세요') #객체별 input함수 적용
gender = input('male  OR female')
age = input(int('나이를 숫자로 입력해주세요'))

whlie True:
    if gender == 'male' or gender == 'female': #gender 객체에 조건 추가
        break
    else:
        print('male과 female중 하나만 입력해주세요') #조건에 맞지 않을 때 사용할 문장
whlie True:
    if age > 0: #age 객체에 조건 추가
        break
    else:
        print('0보다 큰 숫자만 입력해 주세요') #조건에 맞지 않을 때 사용할 문장
    
person1 = person({self.name}, {slef.gender}, {self.age})

#팀 회의 때 질문해보고 입력값을 어떻게 넣는지 듣고 다시 display()함수와 조건문을 추가해 써보았다.

그래서 코드 작성을 위와 같이 하였고 결과는

SyntaxError: invalid syntax

가 나왔다.

더 이상 진행이 되지않아 GPT에게 위 코드의 잘못된 부분을 물어 보았다.

• whlie 오타 => while
• input(int('나이를 숫자로 입력해주세요')) => int(input( '나이를 숫자로 입력해주세요' ))
• person1 = person({self.name}, {self.gender}, {self.age}): => person1 = person(name, gender, age)                     - {}는 문자열 포맷팅을 의미하지만, 여기서는 필요 없습니다. 단순히 변수만 넘기면 됩니다.                                         -  self는 인스턴스 메서드에서만 사용하며, 객체 생성 시에는 사용하지 않아야 합니다.
• while조건문으로 객체 조건 걸기

수정 된 코드

class Person: # 클래스 이름은 관례상 첫 글자를 대문자로 시작합니다.

        def __init__(self, name, gender, age): # 초기화 메서드

               self.name = name # 속성 정의

               self.gender = gender

               self.age = age

       def display(self): # 정보 출력 함수

               print(f"이름: {self.name}, 성별: {self.gender}, 나이: {self.age}") 

name = input('이름을 입력해주세요: ')

while True:

       gender = input('성별을 입력해주세요 (male OR female): ').strip().lower() # 소문자로 변환하여 비교를 용이하게 함

       if gender == 'male' or gender == 'female': # gender 조건

             break

       else:

             print('male과 female 중 하나만 입력해주세요.')

while True:

     try:

      age = int(input('나이를 숫자로 입력해주세요: ')) # 나이 입력을 숫자로 받음

      if age > 0: # age 조건

            break

      else:

            print('0보다 큰 숫자만 입력해 주세요.')

      except ValueError:

            print('유효한 숫자를 입력해주세요.') # 숫자가 아닌 값을 입력했을 때 예외 처리

person1 = Person(name, gender, age)

person1.display()

3. Python 라이브러리로 데이터 분석하기 (필수)

과제 내용

• Python 라이브러리를 활용하여 주어진 데이터(.xlxs)를 분석 Quiz를 수행해주세요.

Quiz

1. Python 라이브러리 함수를 사용하여 엑셀 파일을 불러오고, DataFrame을 출력해주세요.

import pandas as pd

data_df = pd.read_excel("관서별 5대범죄 발생 및 검거.xlsx")

df = pd.DataFrame(data_df)

df

2. 각 경찰서(관서명)를 해당 구 이름으로 매핑하여 '구별'이라는 새로운 column을 생성하고, DataFrame을 출력해주세요.

1차 시도

df['구별'] = 

'서대문서': '서대문구', '수서서': '강남구', '강서서': '강서구', '서초서': '서초구',
'서부서': '은평구', '중부서': '중구', '종로서': '종로구', '남대문서': '중구',
'혜화서': '종로구', '용산서': '용산구', '성북서': '성북구', '동대문서': '동대문구',
'마포서': '마포구', '영등포서': '영등포구', '성동서': '성동구', '동작서': '동작구',
'광진서': '광진구', '강북서': '강북구', '금천서': '금천구', '중랑서': '중랑구',
'강남서': '강남구', '관악서': '관악구', '강동서': '강동구', '종암서': '성북구', 
'구로서': '구로구', '양천서': '양천구', '송파서': '송파구', '노원서': '노원구', 
'방배서': '서초구', '은평서': '은평구', '도봉서': '도봉구'

#SyntaxError(맵핑이라는 단어를 보지 못한채 진행한 결과)

2차 시도

map_df = {'서대문서': '서대문구', '수서서': '강남구', '강서서': '강서구', '서초서': '서초구',
'서부서': '은평구', '중부서': '중구', '종로서': '종로구', '남대문서': '중구',
'혜화서': '종로구', '용산서': '용산구', '성북서': '성북구', '동대문서': '동대문구',
'마포서': '마포구', '영등포서': '영등포구', '성동서': '성동구', '동작서': '동작구',
'광진서': '광진구', '강북서': '강북구', '금천서': '금천구', '중랑서': '중랑구',
'강남서': '강남구', '관악서': '관악구', '강동서': '강동구', '종암서': '성북구', 
'구로서': '구로구', '양천서': '양천구', '송파서': '송파구', '노원서': '노원구', 
'방배서': '서초구', '은평서': '은평구', '도봉서': '도봉구'}

#맵핑(비교)을 하기 위한 mpa_df 생성

df['구별'] = df['관서명'].map(map_df).fillna('구 없음')

#'구별' 이라는 새로운 열 생성 하며 관서명 열에 .map() 함수를 적용시켜 맵핑 진행

# fillna함수로 결측치에 '구 없음'값 지정

3. pivot_table 을 사용하여 관서별 데이터를 구별 데이터로 변경하고, 같은 구의 경우에는 sum을 적용하여 더해주세요. (index : 관서 이름 -> 구 이름)

1차 시도

pivot = pd.pivot_table(df, index = '구별', values = 소계(발생), 소계(검거), 살인(발생), 살인(검거), 강도(발생), 강도(검거), 강간(발생), 강간(검거), 절도(발생), 절도(검거), 폭력(발생), 폭력(검거), aggfunc = 'sum')

#syntaxError columns을 지정하지 않고 모든 값이 다 나와있는 참고자료를 보고 values에 모든열 추가.

2차 시도

pivot = pd.pivot_table(df, index = '구별', aggfunc = 'sum')

#결과 값에 관서명 열이 사라지지 않음 (colums과 valuse를 지정하지 않고 시도)

pivot_dropped = pivot.drop(columns=['관서명'])

#drop함수를 사용해서 관서명 열 삭제

4. 구 없음 행은 drop 을 활용하여 삭제해주세요.

pivot_dropped.drop(['구 없음'])

5. 각 범죄 별로 검거율을 계산하고, 각 검거율 데이터 column을 DataFrame에 추가해주세요.

pivot_dropped = df #이름이 길어져서 간단하게 바꿈

df['강간검거율'] = df['강간(검거)'] / df['강간(발생)'] * 100
df['강도검거율'] = df['강도(검거)'] / df['강도(발생)'] * 100
df['살인검거율'] = df['살인(검거)'] / df['살인(발생)'] * 100
df['절도검거율'] = df['절도(검거)'] / df['절도(발생)'] * 100
df['폭력검거율'] = df['폭력(검거)'] / df['폭력(발생)'] * 100

#범죄별 검거율 열 생성

1차 시도

df['검거율'] = df.mean(df['강간검거율'], df['강도검거율'], df['살인검거율'], df['절도검거율'], df['폭력검거율'])

#총 검거율을 mean함수로 설정 해보려고 했으나 TypeError

df['강간검거율'] = df['강간검거율'].astype(int)
df['강도검거율'] = df['강도검거율'].astype(int)
df['살인검거율'] = df['살인검거율'].astype(int)
df['절도검거율'] = df['절도검거율'].astype(int)
df['폭력검거율'] = df['폭력검거율'].astype(int)

# float이라 값이 너무 커서 안되나 싶어서 정수 변환시킴 

2차시도

df['검거율'] = df[['강간검거율', '강도검거율', '살인검거율', '절도검거율', '폭력검거율']].mean(axis=1)

#검거율 열을 생성하며 df안의 특정 열들을 리스트형식으로 가온다 표시하고 mean(axis=1)으로 평균값을 계산하며 행을 기준으로 계산 지정

6. 필요없는 column을 del 을 사용하여 삭제해주세요.

1차 시도

del.df['소계(발생)', '소계(검거)', '살인(검거)', '강도(검거)', '강간(검거)', '절도(검거)', '폭력(검거)']

# KeyError 인터넷 검색 후

del df['소계(발생)']

# 정상 작동 하는 것을 확인

del df['소계(검거)'], df['살인(검거)'], df['강도(검거)'], df['강간(검거)'], df['절도(검거)'], df['폭력(검거)']

# 정상작동

한번에 적용하는 방법이 있을까?

7. DataFrame의 컬럼명을 rename 을 사용하여 변경해주세요.

df = df.rename(columns = { '강간(발생)' : '강간', '강도(발생)' :'강도', '살인(발생)':'살인', '절도(발생)':'절도', '폭력(발생)':'폭력' })

#검색을 통해 작성법을 보고 적었다.

#정상작동

총평

각 요소의 지칭 단어, 오타, 함수 사용 문법, 코드 작성 순서에 아직 많이 미숙하다.

최대한 GPT도움을 안받고 어떤걸 어떻게 해야하는지 알아가 보면서 스스로 하려했지만 막히는 부분이 많았다.

아직 코드 구조에 대해 정확하게 파악한게 아니니 어쩔 수 없다는 생각을 하지만

그래도 GPT도움없이 익숙해져 나갈 것이고

GPT의 도움을 받았을 땐 코드 하나하나 뜯어 먹어봐야겟다.

새롭게 알게 된 것들

1. try except 

- 프로그램 실행 도중 예외(오류)가 발생했을 때 프로그램의 비정상 종료를 막거나 사용자에게 오류 정보를 제공한다. 

try:
    #오류(예외) 발생 가능성있는 코드 위치

except ValueError: #오류(예외)코드 위치  
    #오류 발생시 수행 코드 위치

2. .strip() ※ .lstrip()  .rstrip() 

- 문자의 공백을 제거해 사용자 입력 값을 계산하기 편하게 만든다.

※앞쪽(왼쪽)문자열 제거 / 뒤쪽(오른쪽)문자열 제거

3. .lower()

- 문자열을 모두 소문자로 변환 시킨다.

- 사용자 입력값을 동일하게 만드는 역할

4. .isdigit() 

-모두 숫자로 이루어져있는지 확인한다.  #age if조건에 추가했다면 try except 구문 없이 else로 끝낼 수 있다.

 while True:
        나이 = input("나이를 입력하세요: ").strip()
        if 나이.isdigit() and int(나이) > 0:  # 나이가 양의 정수인지 확인
            나이 = int(나이)
            break
        else:
            print("잘못된 입력입니다. 양의 정수를 입력해주세요.")

5. 기존 데이터와 2차 데이터를 맵핑 시키기

- {}중괄호 안에 기존 데이터와 : 을 사용해 새로운 정보를 작성 #{서울 : 서울시, 대구 : 대구시}

-위 정보를 본인이 정한 언어로 데이터화 #map_ing = {서울 : 서울시, 대구 : 대구시}

df['시를 붙임'] = df['시 없음'].map(map_ing)

df['시를 붙임'] # 기존 df에 맵핑의 값을 넣을 '시를붙임' 열 생성

 df['시 없음'].map(map_ing)  #기존 df의 '시 없음' 열과 map_ing데이터를 map() 함수로 맵핑 

6. if __name__ == "__main__"

- 모듈이 직접 실행될 때만 특정 코드를 실행할지 여부를 제어

- 다른 파일에서 임포트하면, if __name__ == "__main__": 아래의 코드는 실행되지 않는다.

7. del 을 활용한 삭제 방법

del df['소계(발생)']

#del과 데이터 사이에는 띄어쓰기만 존재함

#[] 대괄호안에 데이터의 없앨 요소 지정

#여러가지를 삭제시킬 때는 del df['소계(발생)'], df['소계(검거)'] 처럼 하나하나 작성해야함

생각지 나지 않던 것들

1. 클래스의 이름 첫글자는 대문자

2. 클래스란? #Person

- 제품의 설계도 

3. 객체란? # person1

- 설계도로 만든 제

- 객체는 클래스의 인스턴스

- 객체는 속성과 메서드를 가질 수 있다.

4. 속성이란? # name, gender, age

- 객체의 데이터를 가리킴

- 클래스안의 변수

5. 메서드란?#def __init__ / def display()

-객체가 어떻게  작동할지 정하는 함수

6. 인스턴스란?#person1 안의 name, gender, age

7. .fillna('구 없음') 

-결측치를 처리할 때 사용하며 결측치가있는 nan, none에 '구 없음' 값을 넣을 수 있다.

8. pivot테이블 작성 방법

pivot = pd.pivot_table(df, index='', columns='', values='', aggfunc='')

#df의 데이터중 index(열), columns(행)을 기준으로  valuse의 값들을 aggfunc로 지정한 함수 적용 시킨 pivot이란 테이블 생성

9. drop함수로 행삭제 열삭제

pivot_dropped.drop(['구 없음'])

#행 삭제

pivot_dropped = pivot.drop(columns=['관서명'])

#열 삭제

10. .astype()

문자열 변경 메서드

11. 테이블에 함수 적용 시 행기준 여기준 잡기

.mean(axis=1)

#axis=0은 열기준

#axis=1은 행기준

12. rename작성법

df = df.rename(columns = {'':''})

#rename메서드안에 columns = {'바뀌기 전' : '바뀐 뒤"}