[22 일차] ABC 부트캠프 : 머신러닝 (4) Code12~Code17

Code12

# sklearn.linear_model에서 Perceptron 클래스를 가져옵니다.
from sklearn.linear_model import Perceptron
# numpy를 가져와서 배열을 생성할 수 있도록 합니다.
import numpy as np

# 샘플 데이터: X는 입력 데이터, y는 레이블(정답)입니다.
# X는 2차원 배열로 4개의 샘플을 포함하고 있습니다.
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
# y는 각 샘플에 대한 레이블로, XOR 문제의 정답을 나타냅니다.
y = np.array([0, 1, 1, 0])

# Perceptron 모델을 초기화합니다.
# tol: 수렴 기준을 설정합니다. 여기서는 0.001로 설정.
# random_state: 난수 생성의 시드를 설정하여 결과의 재현성을 보장합니다.
percept = Perceptron(tol=0.001, random_state=0)

# 모델을 학습시킵니다. X는 입력 데이터, y는 해당 레이블입니다.
percept.fit(X=X, y=y)

# 학습된 모델을 사용하여 입력 데이터 X에 대한 예측을 수행합니다.
print(percept.predict(X=X))

XOR 문제 실패함, [0,1,1,0]이 나와야 성공

• sklearn.linear_model: 사이킷런의 선형 모델 모듈로, 다양한 선형 모델을 제공합니다. 여기서는 Perceptron 클래스를 사용합니다.

간단한 퍼셉트론 모델을 사용하여 XOR 문제를 해결하는 것입니다. 퍼셉트론은 선형 분류기이지만, XOR 문제는 선형적으로 구분할 수 없기 때문에 이 코드의 결과는 기대한 대로 나오지 않을 수 있습니다. 퍼셉트론을 통해 입력 데이터 X에 대해 예측을 수행한 후, 그 결과를 출력합니다.

이 코드를 실행하면 XOR 문제에 대한 예측 결과가 출력됩니다. 하지만 퍼셉트론으로는 XOR 문제를 완벽하게 해결할 수 없다는 점을 유의해야 합니다.

 

---

Code13

import numpy as np  # 수치 계산을 위한 numpy 라이브러리 가져오기
import matplotlib.pyplot as plt  # 그래프 그리기를 위한 matplotlib 라이브러리 가져오기

# 시그모이드 함수 정의
def sigmoid(x: float) -> float:
    return 1.0 / (1.0 + np.exp(-x))  # 시그모이드 함수 계산

# -10에서 10까지 0.1 간격으로 배열 생성
X = np.arange(-10.0, 10.0, 0.1)
# 시그모이드 함수에 X 배열을 적용
y = sigmoid(x=X)

# 시그모이드 함수 그래프 그리기
plt.plot(X, y)
plt.title("Sigmoid Function")  # 그래프 제목
plt.xlabel("Input")  # x축 레이블
plt.ylabel("Output")  # y축 레이블
plt.grid(True)  # 그리드 추가
plt.show()  # 그래프 출력

# -100에서 100까지 100개의 점을 생성
x = np.linspace(-100, 100, 100)
# 하이퍼볼릭 탄젠트 함수 계산
y = np.tanh(x)
# 하이퍼볼릭 탄젠트 함수 그래프 그리기
plt.plot(x, y)
plt.title("Tanh Function")  # 그래프 제목
plt.xlabel("Input")  # x축 레이블
plt.ylabel("Output")  # y축 레이블
plt.grid(True)  # 그리드 추가
plt.show()  # 그래프 출력

# ReLU 함수 정의
def relu(x: float) -> int:
    return np.maximum(x, 0)  # 0보다 크면 자기 자신, 아니면 0을 반환

# -10에서 10까지 0.1 간격으로 배열 생성
x = np.arange(-10, 10, 0.1)
# ReLU 함수에 x 배열을 적용
y = relu(x=x)
# ReLU 함수 그래프 그리기
plt.plot(x, y)
plt.title("ReLU Function")  # 그래프 제목
plt.xlabel("Input")  # x축 레이블
plt.ylabel("Output")  # y축 레이블
plt.grid(True)  # 그리드 추가
plt.show()  # 그래프 출력

시그모이드 함수 그래프:

• 출력값은 0과 1 사이로 제한되며, 입력값이 0일 때 출력값이 0.5입니다.
• 입력값이 양수일 경우 출력은 1에 가까워지고, 음수일 경우 출력은 0에 가까워지는 S자 형태의 곡선입니다.
  
  
  

 

하이퍼볼릭 탄젠트(tanh) 함수 그래프:

• 출력값은 -1과 1 사이로 제한됩니다.
• 입력값이 0일 때 출력은 0이며, 양수일 경우 1에 가까워지고 음수일 경우 -1에 가까워지는 형태입니다.

ReLU 함수 그래프:

• 입력값이 0보다 작으면 출력은 0이고, 0보다 크면 출력은 입력값과 동일합니다.
• 따라서, 0에서 수평선이 나타나고, 그 이후로는 직선으로 상승하는 형태입니다.

각 그래프는 해당 활성화 함수의 동작 방식을 시각적으로 보여주며, 신경망에서의 장단점을 이해하는 데 도움을 줍니다.

---

Code14

import numpy as np  # 수치 계산을 위한 numpy 라이브러리 가져오기
import tensorflow as tf  # 딥러닝 모델을 위한 tensorflow 라이브러리 가져오기

# MNIST 데이터셋 로드: 훈련 데이터와 테스트 데이터로 나누어 반환
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.mnist.load_data()

# 훈련 데이터의 배열 출력
print(X_train)
# 훈련 데이터의 형태 출력 (샘플 수, 높이, 너비)
print(X_train.shape)

# 훈련 데이터의 샘플 수 저장
data_size = X_train.shape[0]
print(data_size)  # 훈련 데이터의 샘플 수 출력

# 배치 크기 설정
batch_size = 12
# 훈련 데이터에서 무작위로 12개의 샘플 선택
selected = np.random.choice(data_size, batch_size)

# 구분선 출력
print('-' * 60)
# 선택된 샘플의 인덱스 출력
print(selected)
# 선택된 샘플의 이미지 데이터 출력
print(X_train[selected])
# 선택된 샘플의 레이블 출력
print(y_train[selected])

결과 설명

1. X_train 출력: MNIST 데이터셋의 훈련 이미지 배열이 출력됩니다. 각 이미지는 28x28 픽셀의 배열로 구성되어 있습니다.
2. X_train.shape 출력: 훈련 데이터의 형태가 출력됩니다. 예를 들어 (60000, 28, 28)로 나타날 수 있으며, 이는 60,000개의 이미지가 각 28x28 픽셀로 구성되어 있음을 의미합니다.
3. data_size 출력: 훈련 데이터의 샘플 수인 60,000이 출력됩니다.
4. selected 출력: 무작위로 선택된 12개의 샘플 인덱스가 출력됩니다. 예를 들어, [234, 456, 789, ...]와 같은 형태로 나타납니다.
5. X_train[selected] 출력: 선택된 인덱스에 해당하는 이미지 데이터가 출력됩니다. 이 데이터는 12개의 (28, 28) 배열로 나타날 것입니다.
6. y_train[selected] 출력: 선택된 인덱스에 해당하는 레이블이 출력됩니다. 각 레이블은 해당 이미지의 숫자(0~9)를 나타냅니다.

이 코드는 MNIST 데이터셋을 로드하고, 훈련 데이터에서 무작위로 샘플을 선택하여 그 샘플의 이미지와 레이블을 확인하는 간단한 예제입니다.

 

---

Code15

import tensorflow as tf  # 딥러닝 모델을 구축하기 위한 TensorFlow 라이브러리 가져오기

# Sequential 모델 생성: 층을 순차적으로 쌓아가는 신경망 모델
model = tf.keras.models.Sequential([], name="XOR_MODEL")

# 입력 레이어 정의: 2개의 입력을 받는 레이어
input = tf.keras.layers.Input(shape=(2,), name="INPUT")
model.add(input)  # 입력 레이어를 모델에 추가

# 첫 번째 은닉층 정의: 4개의 유닛을 가지며 sigmoid 활성화 함수를 사용
layer1 = tf.keras.layers.Dense(units=4, activation='sigmoid', name='LAYER1')
model.add(layer1)  # 첫 번째 은닉층을 모델에 추가

# 두 번째 은닉층 정의: 2개의 유닛을 가지며 sigmoid 활성화 함수를 사용
layer2 = tf.keras.layers.Dense(units=2, activation='sigmoid', name='LAYER2')
model.add(layer2)  # 두 번째 은닉층을 모델에 추가

# 출력 레이어 정의: 1개의 유닛을 가지며 sigmoid 활성화 함수를 사용
output_layer = tf.keras.layers.Dense(units=1, activation='sigmoid', name='OUTPUT')
model.add(output_layer)  # 출력 레이어를 모델에 추가

# 모델 요약 출력: 모델의 구조와 각 레이어의 파라미터 수를 출력
model.summary()

# 모델 컴파일: SGD 옵티마이저와 평균 제곱 오차 손실 함수 사용
model.compile(optimizer=tf.keras.optimizers.SGD(0.7), loss="mse")

# XOR 문제의 입력 데이터 정의: 4개의 샘플 (0,0), (0,1), (1,0), (1,1)
X = tf.constant([[0, 0], [0, 1], [1, 0], [1, 1]])
# XOR 문제의 정답 레이블 정의: 각 입력에 대한 출력 결과
y = tf.constant([0, 1, 1, 0])

# 모델 학습: 입력 데이터 X와 레이블 y를 사용하여 10,000 에폭 동안 학습
model.fit(X, y, epochs=10_000)

# 모델 예측: 학습된 모델을 사용하여 입력 데이터 X에 대한 예측 결과 출력
print(model.predict(X))

결과 설명

1. 모델 요약: model.summary() 명령어는 모델의 구조를 출력합니다. 각 레이어의 이름, 출력 형태, 파라미터 수 등이 포함됩니다.
2. 모델 학습: 10,000 에폭 동안 학습이 진행되며, 그 과정에서 모델은 XOR 문제를 해결하는 방법을 학습합니다.
3. 예측 결과: print(model.predict(X))는 학습된 모델이 입력 데이터에 대해 예측한 결과를 출력합니다.

---

Code16

import numpy as np  # 수치 계산을 위한 numpy 라이브러리 가져오기
import time  # 시간 관련 함수 사용을 위한 라이브러리
from matplotlib import pyplot as plt  # 데이터 시각화를 위한 matplotlib 라이브러리 가져오기

# 샘플 수 설정 및 난수 시드 초기화
SAMPLE_NUMBER = 10_000  # 샘플 수를 10,000으로 설정
np.random.seed(int(time.time()))  # 현재 시간을 기반으로 난수 시드 초기화
Xs = np.random.uniform(low=-2.0, high=0.5, size=SAMPLE_NUMBER)  # -2.0에서 0.5 사이의 균등 분포에서 난수 생성

# 균등 분포를 따르는 난수 생성 및 섞기
np.random.shuffle(Xs)  # 생성된 난수를 무작위로 섞기
print(Xs[:10])  # 첫 10개의 난수 출력

# 이차 방정식 및 시각화
ys = 2 * np.square(Xs) + 3 * Xs + 5  # 이차 방정식: y = 2X^2 + 3X + 5
plt.plot(Xs, ys, 'r,')  # 이차 방정식 그래프를 빨간색 점으로 시각화
plt.show()  # 그래프 출력

# 노이즈 추가 및 시각화
ys += 0.1 * np.random.randn(SAMPLE_NUMBER)  # 표준편차가 0.1인 랜덤 노이즈를 ys에 추가
plt.plot(Xs, ys, 'b.')  # 노이즈가 추가된 데이터의 그래프를 파란색 점으로 시각화
plt.show()  # 그래프 출력

import tensorflow as tf  # TensorFlow 라이브러리 가져오기
model = tf.keras.Sequential(name='NonLinear_MODEL')  # Sequential 모델 생성
input = tf.keras.Input(shape=(1,))  # 입력 레이어 정의: 1개의 입력
model.add(input)  # 입력 레이어를 모델에 추가
model.add(tf.keras.layers.Dense(units=16, activation='relu', name='LAYER1'))  # 첫 번째 은닉층 추가
model.add(tf.keras.layers.Dense(units=8, activation='relu', name='LAYER2'))  # 두 번째 은닉층 추가
model.add(tf.keras.layers.Dense(units=4, activation='relu', name='LAYER3'))  # 세 번째 은닉층 추가
model.add(tf.keras.layers.Dense(units=1, activation='relu', name='OUTPUT'))  # 출력 레이어 추가
model.summary()  # 모델 요약 출력

# 모델 컴파일: MSE 손실 함수와 Adam 옵티마이저 사용
model.compile(loss='mse', optimizer='adam')

from sklearn.model_selection import train_test_split  # 데이터셋 분할을 위한 라이브러리 가져오기
(X_train, X_test, y_train, y_test) = train_test_split(Xs, ys, test_size=0.2)  # 데이터를 훈련 세트와 테스트 세트로 분할

# 훈련 데이터와 테스트 데이터 시각화
plt.plot(X_train, y_train, 'b.', label="Train")  # 훈련 데이터 시각화
plt.plot(X_test, y_test, 'r.', label="Test")  # 테스트 데이터 시각화
plt.legend()  # 범례 추가
plt.show()  # 그래프 출력

# 모델 학습: 훈련 데이터를 사용하여 500 에폭 동안 모델을 학습
model.fit(X_train, y_train, epochs=500)

# 테스트 데이터에 대한 예측 수행
y_predict = model.predict(X_test)
print(y_predict)  # 예측 결과 출력
print(y_test)  # 실제 테스트 레이블 출력

# 예측값과 실제값 시각화
plt.plot(y_predict, y_test, 'r.')  # 예측값과 실제값의 관계를 시각화
plt.show()  # 그래프 출력

1. 샘플 데이터: 첫 10개의 난수 값이 출력됩니다.
2. 이차 방정식 그래프: 이차 방정식의 형태가 빨간색으로 시각화됩니다.
3. 노이즈가 추가된 데이터: 노이즈가 추가된 데이터가 파란색 점으로 시각화됩니다.
4. 모델 요약: 모델의 레이어 구조와 각 레이어의 파라미터 수가 출력됩니다.
5. 훈련 및 테스트 데이터 시각화: 훈련 데이터와 테스트 데이터가 각각 파란색과 빨간색으로 시각화됩니다.
6. 예측 결과: 테스트 데이터에 대한 예측 결과와 실제 레이블이 출력됩니다.
7. 예측 및 실제값 시각화: 모델의 예측값과 실제값의 관계가 시각화되어 모델의 성능을 평가할 수 있습니다.

이 코드는 비선형 회귀 문제를 해결하는 신경망 모델을 구축하고 학습하여, 주어진 이차 방정식을 근사하는 과정을 보여줍니다.

 

---

Code17

import pandas as pd  # 데이터 처리를 위한 pandas 라이브러리 가져오기
import matplotlib.pyplot as plt  # 데이터 시각화를 위한 matplotlib 라이브러리 가져오기
import seaborn as sns  # 고급 시각화를 위한 seaborn 라이브러리 가져오기

# 데이터셋 읽기
df = pd.read_csv(filepath_or_buffer='pima-indians-diabetes3.csv')  # CSV 파일에서 데이터셋 읽기
print(df.head())  # 데이터셋의 첫 5행 출력

# 당뇨병 여부 카운트 출력
print(df['diabetes'].value_counts())  # 'diabetes' 열의 각 클래스의 수 출력

# 데이터셋의 통계적 요약 출력
print(df.describe())  # 데이터프레임의 통계적 요약 출력

# 상관관계 히트맵
print(df.corr())  # 각 변수 간의 상관관계 출력
color_map = plt.cm.gist_heat  # 히트맵 색상 맵 설정
plt.figure(figsize=(12, 12))  # 히트맵의 크기 설정
sns.heatmap(df.corr(), linewidths=0.1, vmax=0.5, cmap=color_map, linecolor='white', annot=True)  # 상관관계 히트맵 그리기
plt.show()  # 히트맵 출력

# 딥러닝 모델을 위한 데이터 준비
X = df.iloc[:, 0:8]  # 독립 변수: 0부터 7까지의 열 선택
y = df.iloc[:, 8]  # 종속 변수: 8번째 열 선택 (당뇨병 여부)

# 딥러닝 모델 구축
model = Sequential(name="PIMA_INDIANS")  # 순차 모델 생성
model.add(Input(shape=(8,)))  # 입력 레이어: 8개의 특성 입력
model.add(Dense(units=16, activation='relu', name='LAYER1'))  # 첫 번째 은닉층: 16 유닛, ReLU 활성화 함수
model.add(Dense(units=8, activation='relu', name='LAYER2'))  # 두 번째 은닉층: 8 유닛, ReLU 활성화 함수
model.add(Dense(units=4, activation='relu', name='LAYER3'))  # 세 번째 은닉층: 4 유닛, ReLU 활성화 함수
model.add(Dense(units=1, name='OUTPUT'))  # 출력 레이어: 1 유닛 (당뇨병 예측)
model.summary()  # 모델 요약 출력

# 모델 컴파일
model.compile(loss='binary_crossentropy', optimizer='adam')  # 손실 함수: 이진 교차 엔트로피, 옵티마이저: Adam

# 모델 학습
model.fit(X, y, epochs=500)  # 훈련 데이터로 500 에폭 동안 모델 학습

# 예측 수행
y_predict = model.predict(X)  # 훈련 데이터에 대한 예측 수행
print(y_predict)  # 예측 결과 출력
print(y)  # 실제 종속 변수 출력

# 예측 결과 시각화
plt.plot(y, y_predict, 'r.')  # 실제 값과 예측 값의 관계 시각화
plt.show()  # 그래프 출력

코드 설명

1. 라이브러리 가져오기:
   • pandas: 데이터 처리를 위한 라이브러리.
   • matplotlib.pyplot: 기본적인 데이터 시각화를 위한 라이브러리.
   • seaborn: 보다 고급의 시각화 기능을 제공하는 라이브러리.
2. 데이터셋 읽기:
   • pd.read_csv: 지정된 경로에서 CSV 파일을 읽어 데이터프레임으로 변환합니다.
   • print(df.head()): 데이터프레임의 처음 5행을 출력하여 데이터의 구조를 확인합니다.
3. 당뇨병 여부 카운트 출력:
   • 'diabetes' 열의 각 클래스(0 또는 1)의 수를 세어 출력하여 데이터의 클래스 분포를 확인합니다.
4. 데이터셋의 통계적 요약:
   • df.describe(): 데이터프레임의 각 열에 대한 통계적 정보를 출력합니다.
5. 상관관계 히트맵:
   • df.corr(): 데이터프레임의 모든 열 간의 상관관계를 계산합니다.
   • sns.heatmap: 상관관계 히트맵을 그려 변수 간의 관계를 시각적으로 확인합니다.
6. 딥러닝 모델을 위한 데이터 준비:
   • X: 독립 변수로 사용할 데이터 (0~7열).
   • y: 종속 변수로 사용할 데이터 (8열).
7. 딥러닝 모델 구축:
   • Sequential: Keras의 순차적 모델을 생성합니다.
   • 여러 개의 Dense 레이어를 추가하여 신경망을 구성합니다.
   • 마지막 레이어는 1개의 유닛으로 당뇨병 여부를 예측합니다.
8. 모델 요약 및 컴파일:
   • model.summary(): 모델의 구조와 각 레이어에 대한 정보를 출력합니다.
   • model.compile: 손실 함수와 옵티마이저를 설정하여 모델을 컴파일합니다.
9. 모델 학습:
   • model.fit: 훈련 데이터로 모델을 500 에폭 동안 학습합니다.
10. 예측 및 결과 시각화:
    • model.predict: 훈련 데이터에 대한 예측을 수행합니다.
    • 예측 결과와 실제 값을 시각화하여 모델의 성능을 평가합니다.

결과 설명

1. 데이터셋의 첫 5행: 데이터의 형식을 보여줍니다. 각 열은 당뇨병 예측에 관련된 특성들입니다.
2. 당뇨병 여부 카운트: 0과 1의 수를 보여주어 클래스 불균형 여부를 확인할 수 있습니다.
3. 통계적 요약: 각 변수의 평균, 표준편차, 최소값, 최대값 등의 정보를 제공합니다.
4. 상관관계 히트맵: 변수 간의 상관관계를 시각적으로 나타내며, 강한 상관관계를 가진 변수들을 쉽게 식별할 수 있습니다.
5. 모델 요약: 모델의 구조를 보여주며, 각 레이어의 유닛 수와 활성화 함수 등을 확인할 수 있습니다.
6. 예측 결과: 모델이 예측한 값과 실제 값이 출력되며, 이를 통해 모델의 성능을 평가할 수 있습니다.
7. 예측 결과 시각화: 실제 값과 예측 값의 관계를 시각화하여 모델이 얼마나 잘 예측했는지를 확인할 수 있습니다.

이 코드는 PIMA 인디언 당뇨병 데이터셋을 분석하고, 딥러닝 모델을 사용하여 당뇨병 여부를 예측하는 과정을 보여줍니다.