2 of 125

강의 교수 소개

왕재민

학력처 박사 2024 포항공과대학교�학력처 (Pohang University of Science & Technology, POSTECH)�학력처 학사 2019 포항공과대학교�학력처 (Pohang University of Science & Technology, POSTECH)

경력처 2026.03- 경북대학교 조교수

경력처 2025.05-2026.02 Postdoctoral Researcher at Max-Planck-Institut für

경력처 Nachhaltige Materialien

경력처 2024.02-2025.04 포항공과대학교 항공재료연구센터 박사후연구원

연락처 전화번호 : 053-950-5562

연락처 오피스가 : 미래창직관 510호

연락처 이메일가 : jmwang@knu.ac.kr

2 / 124

3 of 125

재료과학에서 인공지능의 필요성

합금 조성에서 비롯되는 구조-미세조직-특성 관계

수십 원소가 결합할 수 있는 합금 조성 공간은 10⁸⁰ 이상으로 사실상 무한하며, 인공지능 기술은 인간이 탐색하기 힘든 이 무한한 공간을 탐색할 수 있습니다.

인공지능, 즉 머신러닝은 조성-공정-미세조직-특성 관계를 예측하는 것을 넘어,�인간이 발견하기 힘든 복잡한 패턴, 새로운 물리적 인사이트를 발견 가능합니다.

3 / 124

4 of 125

인공지능 (AI), 머신러닝 (ML), 딥러닝 (DL)

인공지능 기술의 타임라인

인공지능 (Artificial Intelligence): 인공지능은 인간의 지능적 행동을 기계가 수행하도록 만드는 모든 기술�- 사람이 일일이 모든 경우에 대해 규칙을 지정해 놓은 것도 AI

머신러닝 (Machine Learning): 데이터로부터 규칙을 스스로 학습하는 AI의 한 분야�- 사람이 규칙을 직접 쓰지 않음 (데이터 → 모델 학습 → 예측/판단)

딥러닝(Deep Learning): 딥러닝은 인공신경망(Neural Network)을 깊게 쌓아 자동으로 특징까지 학습하는 ML의 한 분야

AI 기법의 관계

4 / 124

5 of 125

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

	지도학습	비지도학습	강화학습
데이터의 특성	입력 데이터와 정답이 함께 제공	정답 없이 입력 데이터만 제공	환경과 상호작용하며 보상으로 학습
모델의 목적	입력과 정답 간의 관계를 학습하여 예측	데이터의 구조·패턴·군집 등을 스스로 발견	누적 보상을 최대화하는 행동 전략 학습

머신러닝의 종류

5 / 124

6 of 125

지도학습 – 분류

스팸 분류를 위한 레이블된 훈련 세트

레이블(Label): 각 입력 데이터에 대해 미리 정해진 정답 값� 분류 문제에서는 보통 범주(category) 형태� 예시: 스팸(1) / 정상 메일(0)

분류(Classification)의 목적: 입력 데이터를 미리 정의된 범주 중 하나로 할당하는 것� 예시: 이메일 → 스팸 / 정상� 예시: 공정 조건 → 결함 발생 / 결함 없음

6 / 124

7 of 125

지도학습 – 회귀

주어진 입력 특성으로 값을 예측

회귀(Regression)의 목적: 입력 데이터를 이용해 연속적인 값을 예측하는 것� 예시: 합금 조성 → 항복 강도 (MPa)� 예시: 공정 조건 → 기공 분율 (%)

분류와의 차이�- 분류: 범주 예측 (0/1, FCC/BCC/HCP 등)�- 회귀: 연속 값 예측 (실수 값)

7 / 124

8 of 125

비지도학습 – 군집

유사한 입력들을 여러 군집으로 표현

비지도학습(Unsupervised Learning): 입력데이터만 주어지고, 정답은 제공되지 않음� 데이터 내 구조, 패턴, 유사성을 스스로 발견

군집(Clustering)의 목적: 서로 유사한 데이터들을 하나의 군집(cluster)로 묶는 것� 서로 다른 군집 간에는 최대한 구분되도록 분리� 예시: 여러 합금 → 초내열 합금, 자성재료, 구조재료

분류 모델은 미리 정해진 범주로 나누지만, 군집 모델은 스스로 범주를 만듭니다.

8 / 124

9 of 125

비지도학습 – 차원 축소

3차원 데이터를 2차원 데이터로 표현

차원 축소(Dimensionality Reduction)의 목적�- 고차원 데이터를 더 낮은 차원 공간으로 변환�- 예시: 고차원 조성 데이터 → 2D map 상에서 합금 그룹 시각화

차원 축소의 필요성: 고차원 데이터는 시각화가 어려움� 불필요한 변수(중복 정보, 노이즈) 제거 가능� 모델 학습 속도 및 일반화 성능 향상 가능

9 / 124

10 of 125

강화학습

강화학습의 예시

강화학습 (Reinforcement Learning)�- 에이전트가 환경과 상호작용하며 학습�- 각 행동에 대해 보상과 페널티를 받음�- 누적 보상을 최대화하는 행동 전략을 학습

예시�- 로봇이 스스로 걷는 방법을 학습�- 게임 AI가 최적 전략을 학습

10 / 124

11 of 125

나쁜 데이터 – 스몰 데이터와 편향된 데이터

스몰 데이터�- 데이터 수가 너무 적으면 일부 구간의 경향이 전체 경향으로 왜곡될 위험�- 모델이 노이즈를 학습할 위험 증가

편향된 데이터�- 제한된 구간의 데이터만으로 학습한 모델은 전체 경향을 왜곡하여 예측�- 대표성이 부족한 데이터는 잘못된 일반화를 초래�- 일반화: 학습에 사용하지 않은 새로운 데이터에서도 모델이 잘 작동하는 능력

데이터 편향에 의해 왜곡된 선형 모델

11 / 124

12 of 125

나쁜 데이터 – 이상치와 노이즈

이상치 (Outlier): 대부분의 데이터 경향에서 벗어난 극단적인 값�- 측정 오류, 데이터 입력 실수, 특이한 실험 조건 등에서 발생�- 일부 이상치는 물리적으로 의미 있는 신호일 수도 있습니다.�→ 무조건 제거가 아니라 원인 분석이 중요

노이즈 (Noise): 실제 측정값과 무관한 무작위 변동�- 실험 오차, 환경 변동, 장비 한계 등에서 발생�- 노이즈가 많으면 모델이 실제 경향을 학습하기 어렵습니다.

이상치가 존재하는 데이터셋

12 / 124

13 of 125

특성 공학

특성(Feature): 모델이 입력으로 사용하는 변수
특성 공학(Feature Engineering)�- 입력 데이터를 모델이 더 잘 학습할 수 있는 형태의 특성으로 변환하는 과정

특성 공학(Feature Engineering)의 목적�- 단순 조성 정보가 아닌 물리적으로 의미 있는 표현으로 변환�- 모델의 일반화 성능 향상�- 훈련 데이터에 없는 조성/원소에 대해서도 예측 가능하게 함

특성 공학 사례

13 / 124

14 of 125

나쁜 모델 – 과대 적합과 과소 적합

과소적합 (Underfitting)�- 모델이 너무 단순하여 데이터의 경향을 충분히 학습하지 못함�- 훈련 데이터에서도 성능이 낮음�- 문제 원인: 모델 복잡도 부족, 특성 부족, 학습 부족

과대적합 (Overfitting)�- 훈련 데이터의 노이즈까지 과도하게 학습�- 훈련 성능은 매우 높지만, 새로운 데이터에서 성능 저하�- 문제 원인: 모델이 지나치게 복잡, 데이터 수 부족, 노이즈가 많음

과소적합 모델, 최적 모델, 과대적합 모델

14 / 124

15 of 125

데이터 전처리

데이터 정제 (Data Cleaning)�- 결측값 처리 (삭제, 평균/중앙값 대체, 물리 기반 보간)�- 이상치 점검 (제거 혹은 원인 분석)�- 단위 통일 (MPa vs GPa, at% vs wt%)�- 중복 데이터 제거�- 목적: 오류와 불일치 제거

데이터 변환 (Data Transformation)�- 스케일링 (정규화, 표준화)� - 스케일 차이가 크면 일부 변수가 모델 학습을 지배할 수 있기 때문�- 로그 변환 (분포 왜곡 완화)� - 평형 압력, 입자 크기는 로그 스케일이 자연스러울 수 있기 때문�- 범주형 변수 인코딩� - 적은 데이터 환경에서는 회귀보다 높음/중간/낮음 분류가 유리할 수 있기 때문�- 물리 기반 feature 생성 (특성 공학)�- 목적: 모델이 학습하기 좋은 형태로 변환

15 / 124

16 of 125

손실 함수 (Loss Function)

16 / 124

17 of 125

평가 지표 (Evaluation Metric)

17 / 124

18 of 125

머신러닝 모델의 평가

Holdout Validation�- 전체 데이터를 훈련 데이터(Train set)와 테스트 데이터(Test set)로 한 번만 분할�- 훈련 데이터로 모델 학습 / 테스트 데이터로 최종 성능 평가�- 구현이 간단하고 계산 비용이 낮지만, 데이터가 적을 때 평가 결과의 변동성이 큼
K-fold Cross Validation�- 데이터를 K개의 fold로 나눈 후, 각 fold를 한 번씩 테스트 데이터로 사용�- K번 학습 및 평가 후 평균 성능 계산�- 데이터 활용 효율이 높으나, 계산 비용이 증가해 데이터가 클 경우 비효율적

Holdout Validation vs K-fold Cross Validation

18 / 124

19 of 125

하이퍼파라미터 튜닝

하이퍼파라미터 (Hyperparameter): 모델이 학습되기 전에 사람이 설정하는 값�- 학습 과정에서 자동으로 최적화되지 않음�- 모델의 복잡도와 학습 방식을 결정�- 예시: 신경망의 층 수, 노드 수
하이퍼파라미터 튜닝 (Hyperparameter Tuning)�- 다양한 하이퍼파라미터 조합을 시도하여 성능이 가장 좋은 조합을 선택하는 과정
그리드 탐색 (Grid Search): 미리 정해둔 값들의 모든 조합을 체계적으로 탐색
랜덤 탐색 (Random Search): 탐색 범위 내에서 무작위로 조합을 선택하여 평가

필수 라이브러리 설치

pip install numpy pandas matplotlib scikit-learn torch certifi

40 / 124

41 of 125

새 주피터 노트북 파일 만들기

41 / 124

42 of 125

새 주피터 노트북 파일 만들기

42 / 124

43 of 125

새 주피터 노트북 파일 만들기

43 / 124

44 of 125

라이브러리 import

라이브러리(Library): 이미 만들어진 함수 모음집�NumPy: 벡터 / 행렬 연산, 수치 계산 라이브러리�Pandas: 엑셀 같은 표 형태 데이터 처리 라이브러리�Matplotlib: 그래프 시각화 라이브러리�scikit-learn: 머신러닝 모델 라이브러리

import numpy as np�- 이 코드에서 numpy라는 라이브러리를 np로 줄여서 사용하겠다는 뜻

from sklearn.linear_model import LinearRegression�- sklearn 라이브러리 안의 linear_model 모듈에서 LinearRegression이라는 함수를 가져오겠다는 뜻

44 / 124

45 of 125

캘리포니아 주택 가격 데이터 회귀 예제

회귀: 입력 데이터를 이용해 연속적인 수치 값을 예측하는 문제

입력: 소득, 방 개수, 위도/경도 등
예측 목표: 주택 가격 (median house value) 예측

캘리포니아 주택 가격

45 / 124

46 of 125

캘리포니아 주택 가격 데이터 다운로드

import ssl # HTTPS 연결 시 사용할 SSL 보안 설정 모듈

import certifi # 신뢰할 수 있는 CA 인증서 번들을 제공하는 패키지

import urllib.request # URL을 통해 데이터를 다운로드하기 위한 모듈

import tarfile # .tar / .tgz 압축 파일을 읽고 해제하는 모듈

from pathlib import Path # 파일 경로를 객체 형태로 다루기 위한 모듈

import pandas as pd

def load_housing_data(): # 주택 데이터셋을 다운로드하고 불러오는 함수 정의

tarball_path = Path("datasets/housing.tgz") # 다운로드할 파일의 경로 설정

Path("datasets").mkdir(parents=True, exist_ok=True) # 폴더가 없으면 생성

url = "https://github.com/ageron/data/raw/main/housing.tgz"

ctx = ssl.create_default_context(cafile=certifi.where()) # certifi 인증서를 사용해 SSL 검증 컨텍스트 생성

with urllib.request.urlopen(url, context=ctx) as response: # URL 데이터 열기

tarball_path.write_bytes(response.read()) # 다운로드한 데이터를 저장

with tarfile.open(tarball_path) as housing_tarball: # 압축 파일 열기

housing_tarball.extractall(path="datasets") # 압축 해제

return pd.read_csv(Path("datasets/housing/housing.csv"))

housing = load_housing_data() # 함수 실행하여 데이터 로드

print(housing.head()) # 데이터의 상위 5개 행 출력

46 / 124

47 of 125

데이터 히스토그램 표시

실습

import matplotlib.pyplot as plt

housing.hist(bins=50, figsize=(16, 12))

plt.show()

47 / 124

48 of 125

Holdout Validation (Train/Test split)

훈련용, 시험용 데이터셋 분리 (scikit-learn 라이브러리 이용)

규칙 없이 무작위 8:2 분할

출력:

from sklearn.model_selection import train_test_split

train_set, test_set = train_test_split(housing, test_size=0.2, random_state=42)

print(train_set.shape)

print(test_set.shape)

(16512, 10)

(4128, 10)

48 / 124

49 of 125

Pearson Correlation (피어슨 상관계수, r)

피어슨 상관계수: 두 변수 간 선형 관계를 나타내는 지표
r이 1에 가까울수록 양의 선형관계, -1에 가까울수록 음의 선형 관계,�0에 가까울수록 선형 관계 없음

실습

출력:

corr_matrix = housing.corr(numeric_only=True)

print(corr_matrix["median_house_value"].sort_values(ascending=False))

median_house_value 1.000000

median_income 0.688075

total_rooms 0.134153

housing_median_age 0.105623

households 0.065843

total_bedrooms 0.049686

population -0.024650

longitude -0.045967

latitude -0.144160

Name: median_house_value, dtype: float64

49 / 124

50 of 125

Pearson Correlation (피어슨 상관계수, r)

실습

plt.scatter(

housing["median_income"],

housing["median_house_value"]

)

plt.xlabel("Median Income")

plt.ylabel("House Value")

plt.show()

r=0.688

50 / 124

51 of 125

Pearson Correlation (피어슨 상관계수, r)

실습

plt.scatter(

housing["population"],

housing["median_house_value"]

)

plt.xlabel("population")

plt.ylabel("House Value")

plt.show()

r=-0.025

51 / 124

52 of 125

결측치 제거

원본 데이터 보존을 위한 데이터 복사

결측치 제거

housing = train_set.drop("median_house_value", axis=1)

housing_labels = train_set["median_house_value"].copy()

print(housing)

print(housing_labels)

housing.dropna(inplace=True)

print(housing)

52 / 124

53 of 125

텍스트 특성 변환

텍스트 특성

출력:

housing_cat = housing[["ocean_proximity"]]

print(housing_cat.head(5))

ocean_proximity

13096 NEAR BAY

14973 <1H OCEAN

3785 INLAND

14689 INLAND

20507 NEAR OCEAN

53 / 124

54 of 125

텍스트 특성 변환

Ordinal Encoding

출력:

from sklearn.preprocessing import OrdinalEncoder

ordinal_encoder = OrdinalEncoder()

housing_cat_encoded = ordinal_encoder.fit_transform(housing_cat)

print(housing_cat_encoded[:5])

print(ordinal_encoder.categories_)

[[3.]

[0.]

[1.]

[4.]]

[array(['<1H OCEAN', 'INLAND', 'ISLAND', 'NEAR BAY', 'NEAR OCEAN'],

dtype=object)]

54 / 124

55 of 125

텍스트 특성 변환

One-hot Encoding

출력:

from sklearn.preprocessing import OneHotEncoder

cat_encoder = OneHotEncoder()

housing_cat_1hot = cat_encoder.fit_transform(housing_cat)

print(housing_cat_1hot.toarray()[:5])

print(cat_encoder.categories_)

[[0. 0. 0. 1. 0.]

[1. 0. 0. 0. 0.]

[0. 1. 0. 0. 0.]

[0. 0. 0. 0. 1.]]

[array(['<1H OCEAN', 'INLAND', 'ISLAND', 'NEAR BAY', 'NEAR OCEAN'],

dtype=object)]

55 / 124

56 of 125

특성 스케일링 (정규화)

Min-max scaling (0과 1 사이 값으로 정규화)

Mean-std scaling (-1과 1 사이 값으로 정규화)

from sklearn.preprocessing import MinMaxScaler

�housing_num = housing.select_dtypes(include=['number'])

�min_max_scaler = MinMaxScaler()

housing_num_min_max_scaled= min_max_scaler.fit_transform(housing_num)

print(housing_num_min_max_scaled[:5])

from sklearn.preprocessing import StandardScaler

housing_num = housing.select_dtypes(include=['number'])

�std_scaler = StandardScaler()

housing_num_std_scaled = std_scaler.fit_transform(housing_num)

print(housing_num_std_scaled[:5])

56 / 124

57 of 125

데이터 전처리 총정리

실습

from sklearn.compose import ColumnTransformer

### Load Data ###

housing = load_housing_data()

### Drop Missing Data ###

housing.dropna(inplace=True)

### Separate label ###

X = housing.drop("median_house_value", axis=1)

y = housing["median_house_value"]

### Train/Test Split ###

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42

)

### Feature Scaling & One-hot encoding ###

num_cols = X_train.select_dtypes(include=['number']).columns

cat_cols = X_train.select_dtypes(exclude=['number']).columns

preprocessor = ColumnTransformer([

('num', StandardScaler(), num_cols),

('cat', OneHotEncoder(handle_unknown='ignore'), cat_cols)

])

X_train = preprocessor.fit_transform(X_train)

X_test = preprocessor.transform(X_test)

print(X_train[:5], y_train[:5])

57 / 124

58 of 125

선형 회귀 모델

선형 모델

58 / 124

59 of 125

선형 회귀 모델의 예측과 손실 함수

선형 모델

59 / 124

60 of 125

경사 하강법 (Gradient Descent)

손실 함수 (비용)과 경사 하강법

60 / 124

61 of 125

학습률 (Learning rate)

너무 작은 learning rate

61 / 124

62 of 125

학습률 (Learning rate)

너무 큰 learning rate

62 / 124

63 of 125

경사 하강법의 문제점

대부분의 손실 함수 그래프는 2차 함수 (볼록 함수) 그래프가 아님

경사 하강법은 가장 최적의 해를 구하지 못하고 초기 파라미터 근처의 지역 최적해에 빠질 위험이 존재

기울기가 0에 가까워지는 구간 (평지)에서는 기울기가 너무 작아 파라미터가 �더 이상 조정되지 않을 수 있음

지역 최소 값과 평지

63 / 124

64 of 125

스케일링 (정규화, 표준화의 필요성)

정규화된 데이터는 원시 데이터에 비해 더 빠르게 (더 적은 스텝으로) 최적해를 구하는 게 가능

고차원의 데이터일수록 스케일링이 더 효과적이므로 모델링 전 데이터 전처리를 반드시 수행해야 함

정규화된 데이터 vs 원시 데이터

64 / 124

65 of 125

손실 함수의 미분 값 계산

65 / 124

66 of 125

과소적합과 과대적합

단순 선형 모델: 모델이 너무 단순하여 데이터를 제대로 표현하지 못함 (과소적합)

300차 다항 회귀: 모델이 너무 복잡하여 일반화 성능이 좋지 못함 (과대적합)

단순 선형 회귀와 2차, 300차 다항 회귀

66 / 124

67 of 125

선형 회귀 모델 훈련

실습

출력:

from sklearn.linear_model import LinearRegression

from sklearn.metrics import root_mean_squared_error

�lin_reg = LinearRegression()

lin_reg.fit(X_train, y_train)

�housing_predictions = lin_reg.predict(X_train)

print(housing_predictions[:5].round(-2)) # -2 = 십의 자리에서 반올림

lin_rmse = root_mean_squared_error(y_train, housing_predictions)

print(lin_rmse)

[228900. 138300. 228400. 211200. 225400.]

68508.07343981159

67 / 124

68 of 125

결정 트리 회귀 모델 훈련

실습

출력:

from sklearn.tree import DecisionTreeRegressor

tree_reg = DecisionTreeRegressor(random_state=42)

tree_reg.fit(X_train, y_train)

�housing_predictions = tree_reg.predict(X_train)

tree_rmse = root_mean_squared_error(y_train, housing_predictions)

print(tree_rmse)

0.0

68 / 124

69 of 125

머신러닝 모델의 평가

Holdout Validation�- 전체 데이터를 훈련 데이터(Train set)와 테스트 데이터(Test set)로 한 번만 분할�- 훈련 데이터로 모델 학습 / 테스트 데이터로 최종 성능 평가�- 구현이 간단하고 계산 비용이 낮지만, 데이터가 적을 때 평가 결과의 변동성이 큼
K-fold Cross Validation�- 데이터를 K개의 fold로 나눈 후, 각 fold를 한 번씩 테스트 데이터로 사용�- K번 학습 및 평가 후 평균 성능 계산�- 데이터 활용 효율이 높으나, 계산 비용이 증가해 데이터가 클 경우 비효율적

Holdout Validation vs K-fold Cross Validation

69 / 124

70 of 125

K-fold Cross Validation (결정 트리)

실습

출력:

from sklearn.model_selection import cross_val_score

�

tree_rmses = -cross_val_score(tree_reg, X_train, y_train,

scoring="neg_root_mean_squared_error", cv=10)

print(pd.Series(tree_rmses).describe())

count 10.000000

mean 68301.029041

std 2604.590694

min 64656.305437

25% 66464.904762

50% 68151.087180

75% 69118.006052

max 73557.007177

dtype: float64

70 / 124

71 of 125

K-fold Cross Validation (선형 회귀)

실습

출력:

lin_rmses = -cross_val_score(lin_reg, X_train, y_train,

scoring="neg_root_mean_squared_error", cv=10)

print(pd.Series(lin_rmses).describe())

count 10.000000

mean 68680.107227

std 1729.837660

min 65488.438180

25% 67887.430681

50% 69254.426193

75% 69621.550214

max 71116.627933

dtype: float64

71 / 124

72 of 125

K-fold Cross Validation (랜덤 포레스트)

실습

출력:

from sklearn.ensemble import RandomForestRegressor

forest_reg = RandomForestRegressor(random_state=42)

forest_rmses = -cross_val_score(forest_reg, X_train, y_train,

coring="neg_root_mean_squared_error", cv=10)

print(pd.Series(forest_rmses).describe())

count 10.000000

mean 49198.025690

std 1620.880465

min 47022.417532

25% 47954.443320

50% 49384.212936

75% 49744.933929

max 52802.076811

dtype: float64

72 / 124

73 of 125

Holdout Validation (랜덤 포레스트)

실습

출력:

forest_reg.fit(X_train, y_train)

housing_train_predictions = forest_reg.predict(X_train)

forest_train_rmse = root_mean_squared_error(y_train, housing_train_predictions)

print(forest_train_rmse)

housing_test_predictions = forest_reg.predict(X_test)

forest_test_rmse = root_mean_squared_error(y_test, housing_test_predictions)

print(forest_test_rmse)

18260.8865300175

48821.99815195788

73 / 124

74 of 125

하이퍼파라미터 튜닝

하이퍼파라미터 (Hyperparameter): 모델이 학습되기 전에 사람이 설정하는 값�- 학습 과정에서 자동으로 최적화되지 않음�- 모델의 복잡도와 학습 방식을 결정�- 예시: 신경망의 층 수, 노드 수
하이퍼파라미터 튜닝 (Hyperparameter Tuning)�- 다양한 하이퍼파라미터 조합을 시도하여 성능이 가장 좋은 조합을 선택하는 과정
그리드 탐색 (Grid Search): 미리 정해둔 값들의 모든 조합을 체계적으로 탐색
랜덤 탐색 (Random Search): 탐색 범위 내에서 무작위로 조합을 선택하여 평가

그리드 탐색과 랜덤 탐색

74 / 124

75 of 125

그리드 탐색

실습

출력:

from sklearn.model_selection import GridSearchCV

�forest_reg = RandomForestRegressor(random_state=42)

param_grid = {

"max_features": [4, 6, 8, 10]

}

grid_search = GridSearchCV(forest_reg, param_grid, cv=3,

scoring='neg_root_mean_squared_error')

grid_search.fit(X_train, y_train)

print(grid_search.best_params_)

{'max_features': 6}

75 / 124

76 of 125

랜덤 탐색

실습

출력:

from sklearn.model_selection import RandomizedSearchCV

from scipy.stats import randint

�forest_reg = RandomForestRegressor(random_state=42)

�param_distribs = {"max_features": randint(low=2, high=20)}

�rnd_search = RandomizedSearchCV(

forest_reg, param_distributions=param_distribs, n_iter=5, cv=3,

scoring='neg_root_mean_squared_error', random_state=42)

�rnd_search.fit(X_train, y_train)

�print(rnd_search.best_params_)

{'max_features': 9}

76 / 124

77 of 125

모델 저장 및 불러오기

모델 저장

모델 불러오기

import joblib

�

forest_reg.fit(X_train, y_train)

�

joblib.dump(forest_reg, "my_california_housing_model.pkl")

forest_reg_reloaded = joblib.load("my_california_housing_model.pkl")

predictions = forest_reg_reloaded.predict(X_train)

print(predictions[:5])

77 / 124

78 of 125

로지스틱 회귀

로지스틱 함수

78 / 124

79 of 125

로지스틱 회귀의 손실 함수 및 미분 값 계산

79 / 124

80 of 125

붓꽃 데이터셋 (Iris dataset)

입력: 붓꽃의 꽃잎의 너비와 길이, 꽃받침의 너비와 길이

타겟: Iris-setosa [0], Iris-versicolor [1], iris-virginica [2], 셋 중 하나로 분류

붓꽃의 종류

80 / 124

81 of 125

로지스틱 회귀 모델의 결정 경계

보통 확률 0.5를 기점으로 분류를 시행�- 여기서 0.5를 로지스틱 회귀 모델의 결정 경계라고 함�- 0.5 미만은 Iris-Virginica가 아닐 확률, 즉 0으로 분류하고� 0.5 이상은 Iris-Virginica가 맞을 확률, 즉 1로 분류

추정 확률과 결정 경계

81 / 124

82 of 125

로지스틱 회귀 모델의 결정 경계

결정 경계가 이동함에 따라 양성 레이블 예측에 보수적이 될 수도�음성 레이블 예측에 보수적이 될 수도 있음�- 결정 경계를 0.9로 설정하면 Iris-Virginica라고 예측한 것들은 예측이 맞는 것으로 � 드러나지만, Iris-Virginica가 아니라고 예측한 것 중에서 실제론 맞는 것들이� 늘어남�- 결정 경계를 0.15로 설정하면, 정반대의 효과가 남

선형 결정 경계

82 / 124

83 of 125

소프트맥스 회귀 (Softmax regression)

소프트맥스 함수

83 / 124

84 of 125

소프트맥스 회귀의 손실 함수 및 미분 값 계산

84 / 124

85 of 125

결정 트리 분류

결정 트리(Decision Tree): 특성(feature)을 기준으로 데이터를 반복적으로 분할하여 예측(분류/회귀)을 수행하는 트리 구조의 모델

부모 노드: 어떤 노드의 상위 노드

자식 노드: 어떤 노드의 하위 노드

리프 노드: 자식 노드가 없는 최하위 말단 노드

결정 트리 분류 예시

85 / 124

86 of 125

지니 불순도

결정 트리의 결정 경계

86 / 124

87 of 125

CART (Classification and Regression Tree) 훈련 알고리즘

87 / 124

88 of 125

규제 매개변수

규제 매개변수: 훈련 데이터에 대한 과대적합을 피하기 위해 학습할 때 결정 트리의 자유도를 제한하는 매개변수(하이퍼파라미터)�- max_depth: 결정 트리의 최대 깊이�- max_features: 각 노드에서 분할에 사용할 특성의 최대 수�- max_leaf_nodes: 리프 노드의 최대 수�- min_samples_split: 분할되기 위해 노드가 가져야 하는 최소 샘플 수�- min_samples_leaf: 리프 노드가 생성되기 위해 가지고 있어야 할 최소 샘플 수

규제하지 않은 결정트리와 규제를 추가한 결정트리의 결정 경계

88 / 124

89 of 125

결정 트리 회귀

두 개의 결정 트리 회귀 모델의 예측

89 / 124

90 of 125

앙상블 (Ensemble)

앙상블�- 여러 개의 모델을 결합해 단일 모델보다 더 정확하고 안정적인 예측을 만드는 방법�- 앙상블 모델을 만들 때에는 앙상블을 구성하는 모델들의 다양성이 중요

여러 분류기 훈련시키기

90 / 124

91 of 125

직접 투표 (hard voting)

직접 투표 분류기�- 가장 많은 표를 얻은 분류 예측 결과가 앙상블의 예측이 됨�- 즉, 다수결 투표로 정해지는 분류기�- 예시: 5개 중 4개의 분류기가 True라고 예측한다면, 앙상블의 예측도 True로 정해짐

직접 투표 분류기의 예측

91 / 124

92 of 125

직접 투표 (hard voting)

직접 투표 분류기의 예측

92 / 124

93 of 125

랜덤 포레스트 (Random Forest)

랜덤 포레스트

랜덤 포레스트�- 배깅 방법과 무작위 특성 선택으로 여러 결정트리를 학습시키고 평균 또는 투표하는 앙상블 방법
Extra trees�- 랜덤 포레스트보다 더 무작위성을 강화한 결정 트리 앙상블 방법�- 노드 생성 시 특성 중 하나를 무작위로 여러 개 고르고 각 특성마다 임의의 분할값을 생성한 뒤, 그 중 가장 좋은 것을 선택

93 / 124

94 of 125

부스팅 (Boosting)

AdaBoost

부스팅�- 이전 모델의 오차에 더 집중하면서 약한 모델들을 순차적으로 학습시켜 점점 강한 모델로 만드는 앙상블 방법 (이전 모델을 보완해 나가면서 새 예측기 학습)
AdaBoost�- 이전 모델이 틀린 샘플에 더 높은 가중치를 부여하며 약한 모델들을 순차적으로 결합해 성능을 높이는 부스팅 알고리즘�- 예측이 어려운 샘플을 더 잘 맞출 수 있도록 모델이 훈련됨

94 / 124

95 of 125

스태킹 (Stacking)

스태킹과 블렌더

스태킹: 여러 모델의 예측 결과를 다시 입력으로 사용해 별도의 메타 모델이 최종 예측을 학습하는 앙상블 방법

블렌더 (Blender): 스태킹 작업을 수행하는 마지막 예측기

95 / 124

96 of 125

MNIST 분류 데이터 예제

분류: 입력 데이터를 이용해 불연속적인 클래스 (이산적인 범주)를 예측하는 문제

입력: 손 글씨 이미지 (28*28 픽셀)
예측 목표: 숫자

MNIST 손글씨 데이터셋

96 / 124

97 of 125

MNIST 데이터셋 다운 및 확인

실습

출력:

from sklearn.datasets import fetch_openml

�mnist = fetch_openml('mnist_784', as_frame=False)

X, y = mnist.data, mnist.target

�print(X)

print(X.shape)

print(y)

print(y.shape)

[[0 0 0 ... 0 0 0]

[0 0 0 ... 0 0 0]

...

[0 0 0 ... 0 0 0]

[0 0 0 ... 0 0 0]]

(70000, 784)

['5' '0' '4' ... '4' '5' '6']

(70000,)

97 / 124

98 of 125

MNIST 이미지 확인

실습

import matplotlib.pyplot as plt

def plot_digit(image_data):

image = image_data.reshape(28, 28)

plt.imshow(image, cmap="binary")

plt.axis("off")

some_digit = X[0]

plot_digit(some_digit)

plt.show()

98 / 124

99 of 125

Train/Test 분리

실습

출력:

X_train, X_test, y_train, y_test = train_test_split(

X, y, test_size=0.2, random_state=42

)

print(X_train.shape)

print(y_train.shape)

print(X_test.shape)

print(y_test.shape)

(56000, 784)

(56000,)

(14000, 784)

(14000,)

99 / 124

100 of 125

이진 분류 (Binary Classification)

실습

출력:

from sklearn.tree import DecisionTreeClassifier

from sklearn.model_selection import cross_val_score

y_train_5 = (y_train == '5') # 5는 True고, 다른 숫자는 모두 False

y_test_5 = (y_test == '5')

tree_clf = DecisionTreeClassifier(random_state=41)

tree_clf.fit(X_train, y_train_5)

print(tree_clf.predict([some_digit]))

print(y[0])

print(cross_val_score(tree_clf, X_train, y_train_5, cv=3, scoring="accuracy"))

[ True]

[0.97241121 0.97150051 0.9710704 ]

100 / 124

101 of 125

분류 평가 지표 (Evaluation Metric)

분류 평가 지표�- TP (True Positive): 실제 양성인 데이터를 양성으로 올바르게 예측�- FP (False Positive): 실제 음성인 데이터를 양성으로 잘못 예측�- FN (False Negative): 실제 양성인 데이터를 음성으로 잘못 예측�- TN (True Negative): 실제 음성인 데이터를 음성으로 올바르게 예측�- Accuracy: 전체 중 맞춘 비율 [(TP+TN)/(TP+TN+FP+FN)]�- Precision: 양성이라고 예측한 것 중 실제 양성 비율 [(TP)/(TP+FP)]�- Recall: 실제 양성 중 맞춘 비율 [(TP)/(TP+FN)]�- F1-score: Precision과 Recall의 조화 평균

101 / 124

102 of 125

Confusion Matrix

실습

출력:

from sklearn.metrics import confusion_matrix

from sklearn.model_selection import cross_val_predict

y_train_pred = cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)

�cm = confusion_matrix(y_train_5, y_train_pred)

print(cm)

[[50183 777]

[ 810 4230]]

102 / 124

103 of 125

Precision, Recall, F1-score

실습

출력:

from sklearn.metrics import precision_score, recall_score, f1_score

print(precision_score(y_train_5, y_train_pred))

print(cm[1, 1] / (cm[0, 1] + cm[1, 1]))

print(recall_score(y_train_5, y_train_pred))

print(cm[1, 1] / (cm[1, 0] + cm[1, 1]))

print(f1_score(y_train_5, y_train_pred))

print(cm[1, 1] / (cm[1, 1] + (cm[1, 0] + cm[0, 1]) / 2))

0.8448172558418214

0.8392857142857143

0.8420424007166318

103 / 124

104 of 125

모델 변화에 따른 예측 성능 변화

실습

출력:

from sklearn.ensemble import RandomForestClassifier

forest_clf = RandomForestClassifier(random_state=42)

�y_train_pred = cross_val_predict(forest_clf,X_train,y_train_5,cv=3)

cm = confusion_matrix(y_train_5, y_train_pred)

print(cm)

print(precision_score(y_train_5, y_train_pred))

print(recall_score(y_train_5, y_train_pred))

print(f1_score(y_train_5, y_train_pred))

[[50914 46]

[ 679 4361]]

0.9895620603585206

0.8652777777777778

0.9232560601249074

104 / 124

105 of 125

다중 분류 (Multiclass Classification)

실습

출력:

from sklearn.ensemble import RandomForestClassifier

from sklearn.model_selection import cross_val_score

rf_clf = RandomForestClassifier(random_state=42)

rf_clf.fit(X_train[:2000], y_train[:2000])

print(rf_clf.predict([some_digit]))

some_digit_scores = rf_clf.predict_proba([some_digit])

print(some_digit_scores.round(2))

print(some_digit_scores.argmax())

print(cross_val_score(rf_clf, X_train[:2000], y_train[:2000], cv=3, scoring="accuracy"))

['5']

[[0.04 0.02 0.04 0.28 0. 0.45 0.04 0.07 0.05 0.01]]

[0.92803598 0.89505247 0.88438438]

105 / 124

106 of 125

Confusion Matrix

실습

from sklearn.metrics import ConfusionMatrixDisplay

y_train_pred = cross_val_predict(rf_clf, X_train[:2000],

y_train[:2000], cv=3)

ConfusionMatrixDisplay.from_predictions(y_train[:2000], y_train_pred)

plt.show()

106 / 124

107 of 125

인공지능 (AI), 머신러닝 (ML), 딥러닝 (DL)

인공지능 기술의 타임라인

인공지능 (Artificial Intelligence): 인공지능은 인간의 지능적 행동을 기계가 수행하도록 만드는 모든 기술�- 사람이 일일이 모든 경우에 대해 규칙을 지정해 놓은 것도 AI

머신러닝 (Machine Learning): 데이터로부터 규칙을 스스로 학습하는 AI의 한 분야�- 사람이 규칙을 직접 쓰지 않음 (데이터 → 모델 학습 → 예측/판단)

딥러닝(Deep Learning): 딥러닝은 인공신경망(Neural Network)을 깊게 쌓아 자동으로 특징까지 학습하는 ML의 한 분야

AI 기법의 관계

107 / 124

108 of 125

인공 뉴런

생물학적 뉴런과 인공 뉴런

108 / 124

109 of 125

인공 뉴런

생물학적 뉴런과 인공 뉴런

109 / 124

110 of 125

인공신경망

Neural Network는 여러 Neuron을 Layer 형태로 연결한 구조�- Input Layer: 입력 Feature를 전달�- Hidden Layer: 입력을 새로운 Representation으로 변환�- Output Layer: 최종 예측값 계산

Hidden Layer가 여러 개 존재하는 Neural Network를 일반적으로 �Deep Neural Network라고 한다.

입력, 은닉, 출력 층으로 구성된 인공신경망

110 / 124

111 of 125

Activation Function이 필요한 이유

111 / 124

112 of 125

대표적 Activation Functions

Sigmoid와 ReLU

112 / 124

113 of 125

Forward and Back Propagation

인공신경망의 Back Propagation

113 / 124

114 of 125

Convolutional Neural Network (CNN)

기본적인 인공신경망의 문제�- 이미지를 인공신경망에 입력하면 모든 Pixel을 독립적인 Feature처럼 처리
그러나 Image에는 공간적 위치, 인접 Pixel 관계, Local Pattern이 중요
Convolutional Neural Network (CNN)�- 공간적으로 가까운 정보를 함께 처리�- 동일한 Filter (가중치 행렬)를 이미지 전체에 적용�- Image Feature를 자동으로 학습

CNN의 구조

114 / 124

115 of 125

Convolution

Convolution�- 작은 Filter (Kernel)를 Image 위에서 이동시키면서 Local Pattern을 추출�- Image → Kernel 이동 → Image × Kernel 곱셈 & 모두 더하기� → Feature Map (Output array)

Convolution의 과정

115 / 124

116 of 125

Pooling

Pooling�- Feature Map의 공간 크기를 감소시키는 연산�- Max Pooling: 영역에서 가장 큰 값 선택�- Average Pooling: 영역 평균 사용
효과�- Feature Map 크기 감소�- 계산량 감소�- Local Feature 요약

Max Pooling과 Average Pooling

116 / 124

117 of 125

Recurrent Neural Network (RNN)

기본적 인공신경망과 RNN의 비교

117 / 124

118 of 125

Long Short-Term Memory

기본 RNN의 문제�- 긴 Sequence에서 과거 정보를 유지하기 어려움�- Vanishing Gradient 문제
LSTM (Long Short-Term Memory)�- Memory Cell과 Gate를 이용하여� > 어떤 정보를 기억할지,� > 어떤 정보를 버릴지,� > 어떤 정보를 출력할지 학습

LSTM

118 / 124

119 of 125

Attention

RNN의 한계�- 긴 Sequence의 모든 정보를 하나의 Hidden State에 유지하기 어려움
Attention의 핵심 아이디어�- 현재 Prediction을 위해 입력의 어느 부분이 중요한지 가중치를 학습
Self-Attention�- 하나의 입력 안에서 각 정보가 다른 정보와 얼마나 관련 있는지 계산하는 방법�- 중요한 정보에는 큰 가중치를 주고, 덜 중요한 정보에는 작은 가중치를 줌

Self-Attention

119 / 124

120 of 125

Self-Attention

120 / 124

121 of 125

Transformer

Transformer�- Self-Attention을 핵심으로 하는 Neural Network Architecture
주요 구성�- Embedding: 텍스트 등의 입력을 숫자 벡터로 변환�- Positional Encoding: 입력 순서 정보 제공�- Multi-Head Attention: 서로 다른 관계를 동시에 학습�- Feed Forward Network: 각 Representation을 비선형 변환

GPT = Generative Pre-trained Transformer

121 / 124

122 of 125

Graph Neural Network (GNN)

그래프 (Graph)�- 객체를 나타내는 노드와 객체 간 관계를 나타내는 엣지로 구성된 데이터 구조
GNN(Graph Neural Network):�- 그래프에서 연결된 이웃 노드들의 정보를 주고받고 종합하여 노드·엣지·그래프의 � 특징을 학습하는 신경망
많은 재료 구조는 그래프로 표현 가능�- Atom → Node�- Atomic Relationship → Edge

그래프로 표현된 합금 시스템

122 / 124