ABC 부트캠프 데이터 탐험가 4기

[20 일차] ABC 부트캠프 : 머신러닝 (3) Code06~Code11

marriina 2024. 7. 31. 13:58

Code06 

import matplotlib.pyplot as plt  # 데이터 시각화를 위한 matplotlib 라이브러리 임포트
import numpy as np  # 수치 계산을 위한 numpy 라이브러리 임포트
from sklearn.linear_model import LinearRegression  # 선형 회귀 모델을 위한 클래스 임포트
from sklearn import datasets  # 다양한 데이터셋을 로드하기 위한 sklearn의 datasets 모듈 임포트

# 당뇨병 데이터 가져오기
diabetes_X, diabetes_y = datasets.load_diabetes(return_X_y=True)  # 당뇨병 데이터셋을 X(특징)와 y(타겟)로 로드

# 데이터 출력
print(diabetes_X)  # 특징 데이터 출력
print(diabetes_X.shape)  # 특징 데이터의 형태(행, 열) 출력
print(diabetes_y)  # 타겟 데이터 출력
print(diabetes_y.shape)  # 타겟 데이터의 형태 출력
print('-'*60)  

bmi = diabetes_X[:, np.newaxis, 2]  # 당뇨병 데이터의 3번째 열(BMI)만 선택하여 새로운 차원 추가
print(bmi)  # BMI 데이터 출력
print(bmi.shape)  # BMI 데이터의 형태 출력

from sklearn.model_selection import train_test_split  # 데이터셋을 훈련 세트와 테스트 세트로 나누기 위한 함수 임포트
(X_train, X_test, y_train, y_test) = train_test_split(bmi, diabetes_y, test_size=0.2)  # 80% 훈련, 20% 테스트 비율로 데이터 나누기
print('-'*60)  
print(X_train)  # 훈련 데이터 출력
print(X_train.shape)  # 훈련 데이터의 형태 출력
print(X_test)  # 테스트 데이터 출력
print(X_test.shape)  # 테스트 데이터의 형태 출력

regression = LinearRegression()  # 선형 회귀 모델 객체 생성
regression.fit(X_train, y_train)  # 훈련 데이터를 사용하여 모델 학습
# 테스트
y_predicts = regression.predict(X_test)  # 테스트 데이터를 사용하여 예측 수행
print(y_predicts)  # 예측 결과 출력
print(y_test)  # 실제 테스트 데이터 출력

plt.plot(y_predicts, y_test, '.')  # 예측값과 실제값을 산점도로 시각화
plt.show()  # 그래프 출력

 

 

 

당뇨병 데이터셋을 로드하여 BMI를 입력 변수로 사용하여 선형 회귀 모델을 학습하고, 테스트 데이터에 대한 예측을 수행합니다. 마지막으로 예측 결과와 실제 결과를 산점도로 시각화합니다.

Code07 

from sklearn.datasets import load_iris  # 아이리스 데이터셋을 로드하기 위한 모듈 임포트

iris = load_iris()  # 아이리스 데이터셋을 로드
print(iris)  # 데이터셋의 전체 정보를 출력
print(iris.data)  # 입력 변수(꽃의 특성) 데이터를 출력
print(iris.target)  # 출력 변수(꽃의 종류) 데이터를 출력

import pandas as pd  # 데이터 조작을 위한 pandas 라이브러리 임포트
iris_df = pd.DataFrame(iris.data, columns=iris.feature_names)  # 데이터프레임을 생성하고 특성 이름을 열 이름으로 사용
iris_df['target'] = pd.Series(iris.target)  # 데이터프레임에 출력 변수(target) 추가
print(iris_df.head())  # 데이터프레임의 첫 5개 행을 출력
print(iris_df['target'].value_counts())  # 각 꽃 종류의 개수를 출력

from sklearn.neighbors import KNeighborsClassifier  # K-최근접 이웃 분류기를 위한 클래스 임포트
from sklearn.model_selection import train_test_split  # 데이터 분할을 위한 train_test_split 함수 임포트

(X_train, X_test, y_train, y_test) = train_test_split(iris.data, iris.target, test_size=0.2)  # 데이터를 학습 세트와 테스트 세트로 분할
print('-' * 60)  
print(X_train)  # 학습 세트의 입력 변수 출력
print(X_train.shape)  # 학습 세트의 입력 변수 형태 출력

# k = 3, 5, 7 (홀수로)
k = 5  # K 값 설정 (최근접 이웃의 수)
knn = KNeighborsClassifier(n_neighbors=k)  # KNN 분류기 객체 생성
knn.fit(X_train, y_train)  # 학습 세트를 사용하여 모델 학습
y_predicts = knn.predict(X_test)  # 테스트 세트에 대한 예측 수행
print('-' * 60)  
print(knn.score(X_train, y_train))  # 학습 세트에 대한 정확도 출력
print(y_predicts)  # 예측 결과 출력
print(y_test)  # 실제 테스트 결과 출력

from sklearn import metrics  # 성능 평가를 위한 metrics 모듈 임포트
score = metrics.accuracy_score(y_test, y_predicts)  # 정확도 점수 계산
print(score)  # 계산된 정확도 점수 출력

import numpy as np  # 수치 계산을 위한 numpy 라이브러리 임포트
found_new_iris = np.array([[4.0, 2.0, 1.3, 0.4]])  # 새로운 아이리스 데이터 생성
index = knn.predict(found_new_iris)  # 새로운 데이터에 대한 예측 수행
print('-' * 60)  
print(knn.predict(found_new_iris))  # 예측 결과 출력
Classes = {0: 'SETOSA', 1: 'VERSICOLOR', 2: 'VIRGINICA'}  # 클래스 이름을 매핑하는 딕셔너리
print(Classes[index[0]])  # 예측된 클래스 이름 출력

found_new_iris = np.array([[4.0, 3.0, 3.2, 2.2]])  # 또 다른 새로운 아이리스 데이터 생성
index = knn.predict(found_new_iris)  # 새로운 데이터에 대한 예측 수행
print('-' * 60)  
print(knn.predict(found_new_iris))  # 예측 결과 출력
print(Classes[index[0]])  # 예측된 클래스 이름 출력

 

 

 

 

아이리스 데이터셋을 사용하여 K-최근접 이웃(KNN) 분류기를 학습하고, 주어진 새로운 아이리스 데이터에 대해 꽃의 종류를 예측하는 과정을 보여줍니다. 데이터셋을 로드하고, 데이터를 분할한 후 KNN 모델을 학습하고, 테스트 세트에 대한 예측을 수행합니다. 마지막으로 새로운 데이터에 대한 예측 결과를 출력합니다.

Code08

import numpy as np  # 수치 계산을 위한 numpy 라이브러리 임포트
import matplotlib.pyplot as plt  # 데이터 시각화를 위한 matplotlib 라이브러리 임포트

# 닥스훈트 데이터
dachshund_length = [77, 78, 88, 85, 73, 77, 73, 80]  # 닥스훈트의 길이
dachshund_height = [25, 28, 29, 30, 21, 22, 17, 35]  # 닥스훈트의 높이

# 사모예드 데이터
samoyed_length = [75, 77, 86, 86, 79, 83, 83, 88]  # 사모예드의 길이
samoyed_height = [56, 57, 50, 53, 60, 53, 49, 61]  # 사모예드의 높이

# 산포도 그림 그리기
plt.scatter(dachshund_length, dachshund_height, c='red', marker='o', label='Dachshund')  # 닥스훈트 데이터 산포도
plt.scatter(samoyed_length, samoyed_height, c='blue', marker='*', label='Samoyed')  # 사모예드 데이터 산포도
plt.xlabel("Length")  # x축 레이블 설정
plt.ylabel("Height")  # y축 레이블 설정
plt.title("DOG SIZE")  # 그래프 제목 설정
plt.legend(loc="upper left")  # 범례 위치 설정
plt.show()  # 그래프 출력

new_dog_length = [79]  # 새로운 강아지의 길이
new_dog_height = [35]  # 새로운 강아지의 높이

plt.scatter(new_dog_length, new_dog_height, c='cyan', marker='p', label='New dog')  # 새로운 강아지 데이터 산포도
plt.xlabel("Length")  # x축 레이블 설정
plt.ylabel("Height")  # y축 레이블 설정
plt.title("DOG SIZE")  # 그래프 제목 설정
plt.legend(loc="upper left")  # 범례 위치 설정
plt.show()  # 그래프 출력

# 닥스훈트 데이터 배열로 변환
dachshund_data = np.column_stack((dachshund_length, dachshund_height))  # 길이와 높이를 합쳐 2D 배열로 변환
print(dachshund_data)  # 닥스훈트 데이터 출력
print(dachshund_data.shape)  # 닥스훈트 데이터의 형태 출력

# 닥스훈트 레이블 설정
dachshund_label = np.array([0, 0, 0, 0, 0, 0, 0, 0])  # 모든 닥스훈트에 대해 레이블 0 설정
print(dachshund_label)  # 닥스훈트 레이블 출력
print(dachshund_label.shape)  # 닥스훈트 레이블의 형태 출력

# 사모예드 데이터 배열로 변환
samoyed_data = np.column_stack((samoyed_length, samoyed_height))  # 길이와 높이를 합쳐 2D 배열로 변환
print(samoyed_data)  # 사모예드 데이터 출력
print(samoyed_data.shape)  # 사모예드 데이터의 형태 출력

# 사모예드 레이블 설정
samoyed_label = np.ones(len(samoyed_data))  # 모든 사모예드에 대해 레이블 1 설정
print(samoyed_label)  # 사모예드 레이블 출력
print(samoyed_label.shape)  # 사모예드 레이블의 형태 출력

# 새로운 강아지 데이터 배열로 변환
new_dog_data = np.array([[79, 35]])  # 새로운 강아지의 길이와 높이를 2D 배열로 변환
print(new_dog_data)  # 새로운 강아지 데이터 출력
print(new_dog_data.shape)  # 새로운 강아지 데이터의 형태 출력

# 모든 강아지 데이터 결합
dogs_data = np.concatenate((dachshund_data, samoyed_data), axis=0)  # 닥스훈트와 사모예드 데이터를 합침
print(dogs_data)  # 모든 강아지 데이터 출력
print(dogs_data.shape)  # 모든 강아지 데이터의 형태 출력

# 모든 강아지 레이블 결합
dogs_label = np.concatenate((dachshund_label, samoyed_label))  # 닥스훈트와 사모예드 레이블을 합침
print(dogs_label)  # 모든 강아지 레이블 출력
print(dogs_label.shape)  # 모든 강아지 레이블의 형태 출력

k = 5  # KNN 모델에서 사용할 K 값 설정
from sklearn.neighbors import KNeighborsClassifier  # KNN 분류기를 위한 클래스 임포트
knn = KNeighborsClassifier(n_neighbors=k)  # KNN 분류기 객체 생성
knn.fit(dogs_data, dogs_label)  # 모든 강아지 데이터를 사용하여 모델 학습
print(knn.score(X=dogs_data, y=dogs_label))  # 학습 데이터에 대한 정확도 출력

y_predicts = knn.predict(dogs_data)  # 모든 강아지 데이터에 대한 예측 수행
print(y_predicts)  # 예측 결과 출력
print(dogs_label)  # 실제 레이블 출력

predicts_new_dog = knn.predict(X=new_dog_data)  # 새로운 강아지 데이터에 대한 예측 수행
print(predicts_new_dog)  # 새로운 강아지 예측 결과 출력

classes = {0: 'Dachshund', 1: 'Samoyed'}  # 레이블을 클래스 이름으로 매핑하는 딕셔너리
print(f"새로운 강아지는 {classes[predicts_new_dog[0]]} 라고 예측됩니다.")  # 예측된 강아지 종류 출력

닥스훈트와 사모예드의 길이와 높이를 사용하여 K-최근접 이웃(KNN) 분류기를 학습하고, 새로운 강아지의 종류를 예측하는 과정을 보여줍니다. 데이터를 시각화한 후, KNN 모델을 학습하고, 새로운 강아지에 대한 예측 결과를 출력합니다.

위의 코드 에서 이어서 작성함

Code09

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 닥스훈트의 길이와 높이 데이터의 평균 계산
dachshund_length_mean = np.mean(dachshund_length)
dachshund_height_mean = np.mean(dachshund_height)

# 닥스훈트의 길이와 높이 평균 출력
print(f"닥스훈트의 길이의 평균: {dachshund_length_mean}")
print(f"닥스훈트의 높이의 평균: {dachshund_height_mean}")

# 닥스훈트의 새로운 길이 데이터 생성 (정규분포)
new_normal_dachshund_length_data = np.random.normal(dachshund_length_mean, 8.0, 200)
new_normal_dachshund_height_data = np.random.normal(dachshund_height_mean, 8.0, 200)

# 생성된 닥스훈트 데이터 출력
print(new_normal_dachshund_length_data)
print(new_normal_dachshund_length_data.shape)
print(new_normal_dachshund_height_data)
print(new_normal_dachshund_height_data.shape)

# 사모예드의 길이와 높이 데이터의 평균 계산
samoyed_length_mean = np.mean(samoyed_length)
samoyed_height_mean = np.mean(samoyed_height)

# 사모예드의 길이와 높이 평균 출력
print(f"사모예드의 길이의 평균: {samoyed_length_mean}")
print(f"사모예드의 높이의 평균: {samoyed_height_mean}")

# 사모예드의 새로운 길이 데이터 생성 (정규분포)
new_normal_samoyed_length_data = np.random.normal(samoyed_length_mean, 8.0, 200)
new_normal_samoyed_height_data = np.random.normal(samoyed_height_mean, 8.0, 200)

# 생성된 사모예드 데이터 출력
print(new_normal_samoyed_length_data)
print(new_normal_samoyed_length_data.shape)
print(new_normal_samoyed_height_data)
print(new_normal_samoyed_height_data.shape)

# 산점도 그리기: 닥스훈트는 파란색, 사모예드는 빨간색으로 표시
plt.scatter(new_normal_dachshund_length_data, new_normal_dachshund_height_data, c='b', marker='.')
plt.scatter(new_normal_samoyed_length_data, new_normal_samoyed_height_data, c='r', marker='*')
plt.show()

# 새로운 닥스훈트 데이터 합성 (길이와 높이)
new_dachshund_data = np.column_stack((new_normal_dachshund_length_data, new_normal_dachshund_height_data))

# 새로운 사모예드 데이터 합성 (길이와 높이)
new_samoyed_data = np.column_stack((new_normal_samoyed_length_data, new_normal_samoyed_height_data))

# 닥스훈트의 레이블 생성 (0으로 설정)
new_dachshund_label = np.zeros(len(new_dachshund_data))

# 사모예드의 레이블 생성 (1로 설정)
new_samoyed_label = np.ones(len(new_samoyed_data))

# 생성된 닥스훈트 데이터 출력
print(new_dachshund_data)
print(new_dachshund_data.shape)

# 생성된 사모예드 데이터 출력
print(new_samoyed_data)
print(new_samoyed_data.shape)

# 닥스훈트와 사모예드 데이터를 합쳐서 총 400개의 개 데이터 생성
new_dogs = np.concatenate((new_dachshund_data, new_samoyed_data))
new_labels = np.concatenate((new_dachshund_label, new_samoyed_label))

# 최종 데이터와 레이블의 형태 출력
print(new_dogs.shape)
print(new_labels.shape)

# 훈련 데이터와 테스트 데이터로 분리
(X_train, X_test, y_train, y_test) = train_test_split(new_dogs, new_labels, test_size=0.2)

# 훈련 데이터와 테스트 데이터의 형태 출력
print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)

# KNN 분류기 초기화 (k=7)
k = 7
knn = KNeighborsClassifier(k)

# KNN 모델 훈련
knn.fit(X=X_train, y=y_train)

# 훈련 정확도 출력
print(f"훈련 정확도 : {knn.score(X_train, y_train)}")

# 테스트 데이터에 대한 예측 수행
y_predicts = knn.predict(X_test)

# 예측된 값과 실제 테스트 레이블 출력
print(y_predicts)
print(y_test)

# 테스트 정확도 출력
print(f"테스트 정확도 : {accuracy_score(y_test, y_predicts)}")

# 예측 결과와 실제 결과를 산점도로 표시
plt.plot(y_predicts, y_test, 'b.')
plt.show()

 

 

 

닥스훈트와 사모예드의 길이와 높이 데이터를 기반으로 새로운 데이터를 생성하고, KNN 알고리즘을 사용하여 이 두 품종을 분류하는 모델을 훈련 및 평가하는 과정을 포함하고 있습니다. 데이터 증강을 통해 모델의 성능을 향상시킬 수 있도록 다양한 새로운 데이터를 생성하고, 이를 통해 분류 정확도를 측정합니다.

Code10

# 필요한 라이브러리 import
import matplotlib.pyplot as plt  # 이미지 시각화를 위한 라이브러리
from sklearn import datasets, metrics  # 데이터셋과 평가 지표를 위한 라이브러리

# 손글씨 숫자 데이터셋 로드
digits = datasets.load_digits()  
print(digits)  # 데이터셋 정보 출력

# 첫 번째 데이터의 shape 출력 (64개의 픽셀)
print(digits.data[0].shape)  # (64,)

# 첫 번째 이미지를 시각화
plt.imshow(digits.images[0], cmap=plt.cm.gray_r, interpolation='nearest')  
plt.show()  # 시각화된 이미지 출력

# 샘플 개수 계산 (주석 처리된 부분은 오류 발생)
# n_samples = len(digits.images)  # 샘플 개수: 1797
# print(n_samples)  # 샘플 개수 출력
# data = digits.images.reshape(1791, -1)  # 이미지 평탄화 (주석 처리)

# 이미지 평탄화 및 훈련/테스트 데이터 분리
import numpy as np  # numpy 라이브러리 import
from sklearn.model_selection import train_test_split  # 데이터 분리를 위한 라이브러리 import
(X_train, X_test, y_train, y_test) = train_test_split(np.array(digits.data), digits.target, test_size=0.3, random_state=42)  
# 데이터셋을 훈련 세트와 테스트 세트로 70:30 비율로 나누기

k = 5  # KNN의 K 값 설정
from sklearn.neighbors import KNeighborsClassifier  # KNN 분류기 import
knn = KNeighborsClassifier(k)  # KNN 분류기 객체 생성
knn.fit(X_train, y_train)  # 훈련 데이터로 모델 학습

# 훈련 데이터에 대한 정확도 출력
print(knn.score(X_train, y_train))  # 훈련 세트 정확도 출력

# 테스트 데이터에 대한 예측 수행
y_predictions = knn.predict(X_test)  # 테스트 세트에 대한 예측
print(y_predictions)  # 예측값 출력
print(y_test)  # 실제값 출력

# 테스트 정확도 출력
print(metrics.accuracy_score(y_test, y_predictions))  # 테스트 정확도 계산 및 출력

# 첫 번째 테스트 이미지를 시각화
plt.imshow(X_test[0].reshape(8, 8), cmap=plt.cm.gray_r, interpolation='nearest')  
plt.show()  # 시각화된 이미지 출력

# 첫 번째 테스트 데이터에 대한 예측
y_predict = knn.predict([X_test[0]])  # 첫 번째 테스트 데이터에 대한 예측 수행 (2차원 배열로 변환)
print(y_predict)  # 예측값 출력

 

손글씨 숫자 데이터셋을 로드하고, K-최근접 이웃(KNN) 알고리즘을 사용하여 숫자 이미지를 분류하는 과정입니다. 주요 단계는 다음과 같습니다:

  1. 데이터 로드 및 시각화: 손글씨 숫자 데이터셋을 로드하고, 첫 번째 숫자 이미지를 시각화합니다.
  2. 데이터 전처리: 데이터를 훈련 세트와 테스트 세트로 나누고, KNN 모델을 학습시킵니다.
  3. 모델 평가: 훈련 세트에 대한 정확도를 출력하고, 테스트 세트에 대한 예측을 수행하여 실제값과 비교합니다.
  4. 결과 시각화: 첫 번째 테스트 이미지에 대한 예측 결과를 출력합니다.

이 프로젝트를 통해 KNN 알고리즘을 사용한 이미지 분류의 기본적인 흐름을 이해할 수 있습니다.

 

 

 

 

 

 

Code11

# 입력 데이터 X와 목표 값 y 정의
X = [[174],  # 첫 번째 데이터: 174
     [152],  # 두 번째 데이터: 152
     [138],  # 세 번째 데이터: 138
     [128],  # 네 번째 데이터: 128
     [186]]  # 다섯 번째 데이터: 186
y = [71, 55, 46, 38, 88]  # 각 데이터에 대한 목표 값

# 입력 데이터와 목표 값 출력
print(X)  # X 출력
print(y)  # y 출력

import numpy as np  # numpy 라이브러리 import

# 리스트를 numpy 배열로 변환
X = np.array(X)  # X를 numpy 배열로 변환
y = np.array(y)  # y를 numpy 배열로 변환

from sklearn.linear_model import LinearRegression  # 선형 회귀 모델 import

# 선형 회귀 모델 객체 생성
lr = LinearRegression()  
# 모델 학습
lr.fit(X=X, y=y)  
# 훈련 세트에 대한 결정 계수(R^2) 출력
print(lr.score(X=X, y=y))  # 모델의 성능 평가

# 새로운 데이터에 대한 예측 수행
y_predict = lr.predict(np.array([[168]]))  # 입력 데이터 168에 대한 예측
print(y_predict)  # 예측값 출력

from matplotlib import pyplot as plt  # matplotlib 라이브러리 import

# 전체 데이터에 대한 예측값 계산
y_predicts = lr.predict(X)  # X에 대한 예측값

# 예측값을 산점도로 시각화 (파란색 별)
plt.scatter(X, y_predicts, color='blue', marker='*')  
# 실제 목표값을 산점도로 시각화 (빨간색 원)
plt.scatter(X, y, color='red', marker='o')  
# 그래프 출력
plt.show()

 

 

 

선형 회귀 모델을 사용하여 주어진 입력 데이터와 목표 값 간의 관계를 학습하고, 새로운 입력에 대한 예측을 수행하는 과정입니다. 주요 단계는 다음과 같습니다:

  1. 데이터 정의: 입력 데이터 X와 목표 값 y를 정의합니다.
  2. 데이터 변환: 리스트 형태의 데이터를 NumPy 배열로 변환하여 모델 학습에 적합한 형식으로 만듭니다.
  3. 모델 학습: 선형 회귀 모델을 생성하고, 입력 데이터와 목표 값을 사용하여 학습합니다.
  4. 모델 평가: 학습된 모델의 성능을 결정 계수(R²)로 평가하여 출력합니다.
  5. 예측 수행: 새로운 입력 값(168)에 대한 예측을 수행하고 결과를 출력합니다.
  6. 시각화: 예측값과 실제 목표값을 산점도로 시각화하여 비교합니다.

이 프로젝트를 통해 선형 회귀 분석의 기본적인 개념과 모델 학습, 예측, 시각화 과정을 이해할 수 있습니다.