네이버 클라우드 캠프 11일차 230509

#1 교육정리

오늘은 데이터 셋에서 Train과 Test 을 활용하는 방법을 배웠습니다.

두번째로는 회귀분석과 분류분석을 살펴보았고, 이진분류와 다중분류에 대해서 이해하였습니다.

세번째로는 회귀분석과 분류분석의 손실함수에 대해서 학습하였습니다.

마지막으로는 각기 다른 데이터 셋을 가져와 실습을 해보았습니다.

각각의 금일 배운 내용을 아래에서 자세하게 정리해보겠습니다!

 

 

 

#2 데이터 셋 - Train, Test

dataset 개념)

1. 연관된 데이터를 모아서 특정 규칙에 따라 하나의 묶음으로 만든 데이터의 집합.

2. 데이터 통신 분야에서 데이터 전송용의 신호를 생성하는 기기와 전화기를 일체화한 장치.

 

출처 : http://terms.tta.or.kr/dictionary/dictionaryView.do?subject=%EB%8D%B0%EC%9D%B4%ED%84%B0+%EC%84%B8%ED%8A%B8

 

데이터 셋은 특성(feature)과 결과값(target, label)로 구성되어 있습니다. 단순하게 특성은 독립변수를, 결과값은 (특성에 의해서 결정된다고 믿어지는) 종속변수에 해당됩니다. 그러나 특성이 반드시 하나일 필요는 없으며 특성의 개수를 데이터 셋의 차원(dimension)이라 합니다. 데이터 셋을 시각화하면 다음과 같습니다.

출처 : https://ybdata-sci.tistory.com/19

 

 

 

Train / Test / Validation)

Trainset : 

모델의 학습만을 위해서 사용 parameter나 feature 등을 수정하여 모델의 성능을 높이는 작업에 사용

(모델이 학습하는데 사용 되는 훈련용 데이터)

 

Test set : 

최종적으로 모델의 성능을 평가, 실사용 되었을 때 모델이 얼마나 좋은 성능을 발휘 할 수 있을지 알아보는 것

(학습 후에 모델의 성능을 평가하기 위해서만 사용되는 테스트용 수능 데이터)

 

Validation set : 모델의 학습에 직접적으로 관여하지 않음, 학습이 끝난 모델에 적용, 최종적으로 모델을 fine tuning 하는 데에 사용

(모델의 일반화 능력을 높이기 위해 학습 중에 평가에 사용되는 모의고사 데이터)

 

출처 : https://eunchankim-dev.tistory.com/55

 

 

 

#3 회귀분석과 분류분석

 

이미지 출처: https://www.simplilearn.com/regression-vs-classification-in-machine-learning-article

 

회귀분석-Regression)

연속된 값을 예측, 과거의 주가 데이터를 가지고 미래 주가를 예측하거나, 자동차 배기량이나 연식 등 중고차 정보를 이용하여 가격을 예측 / 가지고 있는 데이터에 독립변수*와 종속변수**가 있고, 종속변수가 숫자일 때 회쉬를 이용하면 됩니다.

 

회귀분석 사례)

독립변수	종속변수	학습시킬 데이터를 만드는 방법
공부시간	시험점수 (10점, 20점)	사람들의 공부시간을 입력받고 점수를 확인한다.
온도	레모네이드 판매량	온도와 그날의 판매량을 기록한다.
역세권, 조망 등	집 값	집과 역까지의 거리, 수치화된 조망의 평점 등을 집 값과 함께 기록한다
온실 기체량	기온 변화량	과거에 배출된 온실 기체량과 기온의 변화량을 기록한다.
자동차 속도	충돌 시 사망 확률	충돌시 속도와 사상자를 기록한다.
나이	키	학생들의 나이에 따른 키를 기록한다.

 

*독립변수는 다른 변수에 영향을 받지 않습니다. 오히려 종속 변수에 영향을 주는 변수 입니다.

**종속변수는 연구자가 독립변수의 변화에 따라 어떻게 변하는지 알고 싶어하는 변수를 말합니다.

 

 

분류분석-Classification)

종류를 예측, 클래스 0 또는 1중에서 선택하는이진분류(binary classification) 또는 3개 이상의 클래스 중에서 하나를 선택하는 다중분류(Multi Classification) / 가지고 있는 데이터에 독립변수*와 종속변수**가 있고, 종속변수가 이름일 때 분류를 이용하면 됩니다.

 

분류분석 사례)

독립변수	종속변수	학습시킬 데이터를 만드는 방법
공부시간	합격 여부 (합격/불합격)	사람들의 공부시간을 입력받고, 최종 합격여부를 확인한다.
X-ray 사진과 영상 속 종양의 크기, 두께	악성 종양 여부 (양성/음성)	의학적으로 양성과 음성이 확인된 사진과 영상 데이터를 모은다.
품종, 산도, 당도, 지역, 연도	와인의 등급	소믈리에를 통해서 등급이 확인된 와인을 가지고 품종, 산도 등의 독립변수를 정하고 기록한다.
키, 몸무게, 시력, 지병	현역, 공익, 면제	키, 몸무게, 시력, 지병 등을 토대로 현역, 공익, 면제인지를 확인한다.
메일 발신인, 제목, 본문 내용 (사용된 단어,  이모티콘 등)	스팸 메일 여부	이제까지 받은 메일을 모으고, 이들을 스팸 메일과 일반 메일로 구분한다.
고기의 지방함량, 지방색, 성숙도,  육색	소고기 등급	소고기의 정보를 토대로 등급을 측정한다.

 

출처 : https://opentutorials.org/module/4916/28942

 

 

 

이진분류)

타깃의 값이 어떤기준에 대하여 참(True) 또는 거짓(False)의 값을 가집니다. 그래서 출력 값이 하나 입니다.

직선보다 적절한 곡선을 통해 분류를 합니다.

 

  -  활성화 함수 : relu

  -  마지막 층의 활성화 함수 : sigmoid (출력값 : 0 or 1)

  -  손실 함수 : binary_crossentropy

  -  옵티마이저 : rmsprop, adam

  -  metrics : accuracy

 

출처 https://wikidocs.net/41256

 

 

 

다중분류)

타깃이 가질 수 있는 값이 3개 이상입니다.

 

  -  활성화 함수 : relu

  -  마지막 층의 활성화 함수 : softmax 로 0과 1 사이의 값으로 가공

  -  마지막 층의 크기 : 출력 클래스의 개수

  -  중간층의 크기 : 마지막 층의 크기보다 커야 함  (for 정보의 병목 방지)

  - 손실 함수 : categorical_crossentropy

                         (레이블을 정수로 인코딩하는 경우에는 sparse_categorical_crossentropy 사용)

  -  옵티마이저 : rmsprop, adam

  -  metrics : accuracy

  -  다중 분류 모델 : one-hot-encoding 기법

 

출처 : https://yhyun225.tistory.com/14

 

 

 

#4 결정계수 R2 score

R-squared는 선형 회귀 모델에 대한 적합도 측정값 입니다.

선형회귀 모델을 훈련한 후, 모델이 데이터에 얼마나 적합한지 확인하는 통계 방법 중 하나 입니다.

r2 score는 0과 1 사이의 값을 가지며 1에 가까울수록 선형회귀 모델이 데이터에 대하여 높은 연관성을 가지고 있다고 해석합니다.

 

출처 : https://go-hard.tistory.com/125

 

 

r2 score의 공식은  식을 정리해 보면 아래와 같습니다.

SST는 전체 제곱의 합, SSE는 제곱 오차항을 의미한다.

Mean Squared Error, 평균 제곱오차

 

 

 

#5 One Hot Encoding

one hot encoding은 데이터 벡터의 각 값을 column labelling 하고 해당 값을 1로 표시하는 방식의 행렬로 인코딩하는 방법입니다. 당연히 해당 값 외의 다른 column에 대해서는 해당하지 않으므로 0으로 채워집니다.

그리고 N 크기의 벡터를 N * N의 크기의 행렬로 인코딩합니다.

 

추가적으로 keras는 원 핫 코딩을 수행하는 유용한 도구 to_categorical()를 지원합니다. 

Color	one hot encoding (접근법) =============>	Red	Yellow	Green
Red		1	0	0
Red		1	0	0
Yellow		0	1	0
Green		0	0	1

 

 

 

#6 난수값(random_state)

먼저, 난수란 정의된 범위 내에서 무작위로 추출된 수를 말합니다.

 

random_state는 호출할 때마다 동일한 학습.테스트용 데이터 세트를 생성하기 위해 주어지는 난수 값입니다.

train_test_split()는 랜덤으로 데이터를 분리하므로 random_state를 설정하지 않으면 수행할 때마다 다른 학습/테스트 데이터 세트가 생성딥니다. 따라서 random_state를 설정하여 수행 시 결과값을 동일하게 맞춰주는 것입니다. 이 때 random_state에는 어떤 숫자를 넣든 그 기능은 같기 때문에 어떤 숫자를 넣든 상관 없습니다.

 

그렇기에 중요한건 이 random_state를 None으로 두냐 정수를 넣느냐 입니다.

그래서 random_status가 None인 경우 한번 Decision tree를 생성할 때 1,3,47...번 데이터를 이용했다고 해서 다시 이 Decision tree를 생성할 때 1,3,47...번째 데이터를 이용하지는 않습니다. 또 다른 어떤 난수번째의 데이터를 이용하게 되는거죠.

 

만약 random_state가 None이면 정말 규칙없는 어떤 데이터를 뽑아서 Decision tree를 생성하게 되지만 random_state에 어떤 값이 있다면 난수 생성에 어떠한 규칙(이건 만든사람 말고는 알 수 없음)을 넣어서 동일한 결과가 나오게 합니다. 예를 들어 1이라는 값을 넣어서 1,3,47,5...번째 데이터를 이용했다면 또다시 1을 넣으면 1,3,47,5...번째 데이터를 사용하게 되는거죠.

이걸 일반적으로는 random seed라고 합니다.

 

글출처 : https://jerry-style.tistory.com/entry/Decisiontreeclassifier-%ED%95%A8%EC%88%98%EC%9D%98-%ED%8C%8C%EB%9D%BC%EB%AF%B8%ED%84%B0-randomstate%EB%9E%80

 

출처 : https://bigdaheta.tistory.com/54

 

 

 

#7 실습

train_split_test)

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split    # sklearn trai split


#1. 데이터
x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
              11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
y = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
              11, 12, 13, 14, 15, 16, 17, 18, 19, 20])

# 아래와 같이 x 와 y 데이터를 파이썬 리스트 스필릿으로 분리하기
# 트레인, 테스트 데이터 순서에 따라 값도 달라진다
x_train, x_test, y_train, y_test = train_test_split(    
    x, y,   # x, y 데이터
    test_size=0.3,    # test의 사이즈 보통 30%
    train_size=0.7,     # train의 사이즈는 보통 70%
    random_state=73,    # 데이터를 난수값에 의해 추출한다는 의미이며, 중요한 하이퍼파라미터임
    shuffle=True    # 데이터를 섞어서 가지고 올 것인지를 정함
)


x_train = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
y_train = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])

x_test = np.array([15, 16, 17, 18, 19, 20])
y_test = np.array([15, 16, 17, 18, 19, 20])


#2. 모델구성
model = Sequential()
model.add(Dense(14, input_dim=1))
model.add(Dense(50))
model.add(Dense(1))


#3. 컴파일, 훈련
model.compile(loss='mse', optimizer='adam')
model.fit(x_train, y_train, epochs=100, batch_size=1)


#4. 평가, 예측
loss = model.evaluate(x_test, y_test)
print('loss : ', loss)

result = model.predict([21])
print('21의 예측값 : ', result)

# result
# loss :  1.515824466814808e-12
# 21의 예측값 :  [[21.]]

 

scatter)

 

위의 코드에 아래 코드를 추가로 입력해서 run 하시면 시각적으로 값을 볼 수 있습니다.

y_predict = model.predict(x)    # 예측값
########### scatter 시각화 #############
import matplotlib.pyplot as plt
plt.scatter(x, y)   #산점도 그리기
plt.plot(x, y_predict, color='green')
plt.show()

 

x, y 산점도

 

r2score)

r2_score는 회귀 문제에서 예측 결과와 실제 결과의 적합도를 평가하는 지표 중 하나입니다. 회귀 분석 모델이 예측하는 값의 변동성을 데이터의 총 변동성 중에서 얼마나 설명할 수 있는지를 나타내는 값으로, 1에 가까울수록 예측 성능이 좋은 것입니다.

 

accuracy_score는 분류 문제에서 예측 결과와 실제 결과가 일치하는 비율을 계산하는 지표입니다. 분류 모델이 예측한 클래스 레이블과 실제 클래스 레이블을 비교하여 일치하는 비율을 나타내며, 값이 1에 가까울수록 좋은 성능을 나타냅니다.

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split    
from sklearn.metrics import r2_score, accuracy_score	# scikit 에서 r2_score와 accuracy_score 가져오기

#1. 데이터
x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
              11, 12, 13, 14, 15, 16, 17, 18, 19, 20])
y = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
              11, 12, 13, 14, 15, 16, 17, 18, 19, 20])


x_train, x_test, y_train, y_test = train_test_split(    
    x, y,   
    test_size=0.3,   
    train_size=0.7,     
    random_state=73,    
    shuffle=True   
)


x_train = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
y_train = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])

x_test = np.array([15, 16, 17, 18, 19, 20])
y_test = np.array([15, 16, 17, 18, 19, 20])


#2. 모델구성
model = Sequential()
model.add(Dense(14, input_dim=1))
model.add(Dense(50))
model.add(Dense(25))
model.add(Dense(1))


#3. 컴파일, 훈련
model.compile(loss='mse', optimizer='adam')
model.fit(x_train, y_train, epochs=100, batch_size=1)


#4. 평가, 예측
loss = model.evaluate(x_test, y_test)
print('loss : ', loss)
result = model.predict([21])
print('21의 예측값 : ', result)

y_predict = model.predict(x)

###### R2Score #######

r2 = r2_score(y, y_predict)
print('r2스코어 : ', r2)

# result(1)
# loss :  1.8189894035458565e-12
# 21의 예측값 :  [[20.999998]]
# r2스코어 :  0.999999999999981

 

그렇다면 r2스코어가 낮게 나오려면?)

히든층의 수를 늘려서 모델의 구성을 뒤죽박죽으로 만들면 r2스코어가 낮게 나올겁니다.

저는 잘 안나왔지만 한번 시도 해보시길 바랍니다~

 

California_activation)

sckit에서 fetch_california_housing data를 가져와서 datasets를 해서 activation을 주어 좀 더 정확한 r2score를 도출 해보겠습니다.

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from sklearn.datasets import fetch_california_housing
import ssl
ssl._create_default_https_context = ssl._create_unverified_context  # data 가져올 때 오류시 인증서 무시 명령어


#1. 데이터
# datasets = load_boston()
datasets = fetch_california_housing()
x = datasets.data
y = datasets.target

print(datasets.feature_names)
# ['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms',
#'Population', 'AveOccup', 'Latitude', 'Longitude']

print(datasets.DESCR)

print(x.shape)  #(20640, 8)
print(y.shape)  #(20640,)

x_train, x_test, y_train, y_test = train_test_split(
    x, y, train_size=0.7, random_state=100, shuffle=True
)
print(x_train.shape)    #(14447, 8)
print(y_train.shape)    #(14447,)

#2. 모델구성
model = Sequential()
model.add(Dense(100, activation='linear', input_dim=8))
model.add(Dense(100, activation='relu'))
model.add(Dense(100, activation='relu'))
model.add(Dense(100, activation='relu'))
model.add(Dense(1, activation='linear'))    # 회귀모델에서 인풋과 아웃풋 활성화 함수는 'linear'

#3. 컴파일, 훈련
model.compile(loss='mse', optimizer='adam')
model.fit(x_train, y_train, epochs=250, batch_size=200)

#4. 평가, 예측
loss = model.evaluate(x_test, y_test)
print('loss : ', loss)

y_predict = model.predict(x_test)
r2_score = r2_score(y_test, y_predict)
print('r2 스코어 : ', r2_score)

# result
# r2 스코어 :  r2 스코어 :  0.6328881810348457
# 모든 히든레이어에 activation='relu'를 사용하면 성능이 향삼됌

 

 

cancer_sigmoid)

이번에는 cancer data인 활성화 함수를 가져와서 activation을 sigmoid로 해서 loss, accuracy 값을 도출해보겠습니다.

추가로 도출하는데 걸린 시간도 구해보겠습니다.

 

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score, accuracy_score
from sklearn.datasets import load_breast_cancer
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
import time

#1. 데이터
datasets = load_breast_cancer()
print(datasets.DESCR)   # describe : 설명
print(datasets.feature_names)
# ['mean radius' 'mean texture' 'mean perimeter' 'mean area'
#  'mean smoothness' 'mean compactness' 'mean concavity'
#  'mean concave points' 'mean symmetry' 'mean fractal dimension'
#  'radius error' 'texture error' 'perimeter error' 'area error'
#  'smoothness error' 'compactness error' 'concavity error'
#  'concave points error' 'symmetry error' 'fractal dimension error'
#  'worst radius' 'worst texture' 'worst perimeter' 'worst area'
#  'worst smoothness' 'worst compactness' 'worst concavity'
#  'worst concave points' 'worst symmetry' 'worst fractal dimension']


x = datasets.data
y = datasets.target

print(x.shape, y.shape) # (569, 30) (569,)

x_train, x_test, y_train, y_test = train_test_split(
    x, y, train_size=0.7, random_state=100, shuffle=True
)

#2. 모델 구성
model = Sequential()
model.add(Dense(100, input_dim=30))
model.add(Dense(100))
model.add(Dense(50))
model.add(Dense(10))
model.add(Dense(1, activation='sigmoid'))   #이진분류는 무조건 아웃풋 레이어의 뉴런 개수를 1개로
                                            #활성화 함수를 'sigmoid'로 해줘야 한다.


#3. 컴파일, 훈련
model.compile(loss='binary_crossentropy', optimizer='adam', 
              metrics='mse')

start_time = time.time()
model.fit(x_train, y_train, epochs=100, batch_size=200,
          verbose=0)    # verbose로 결과값 추출 로딩 제어
end_time = time.time() - start_time

#4. 평가, 예측
loss = model.evaluate(x_test, y_test)
y_predict = model.predict(x_test)


y_predict = np.round(y_predict)   # y_predict를  round로 반올림
# y_predict = np.where(y_predict >= 0.5, 1, 0)    #y_predict where로 반올림

acc = accuracy_score(y_test, y_predict)

print('loss : ', loss)
print('Accuracy 스코어 : ', acc)
print('걸린 시간 : ', end_time)

# result
# loss :  [1.0612512826919556, 0.069186270236969]
# Accurancy 스코어 :  0.9298245614035088
# 걸린 시간 :  0.8653008937835693

 

iris_softmax)

이번에도 sckit에서 iris data를 가져와서 activation*** softmax**** 로 결과를 도출해보겠습니다.

 

***accuracy score : 분류 문제에서 예측값과 실제값이 얼마나 일치하는지를 평가하는 지표 중 하나입니다.

예측값과 실제값을 인자로 받아서 정확도를 계산합니다. 이 함수는 다중 분류 문제에서도 사용할 수 있습니다. 이 경우, 각 클래스마다 정확도를 계산하여 평균값을 구합니다.

 

****Softmax는 로지스틱 함수의 확장판으로, 입력받은 값을 출력으로 0과 1사이의 값으로 모두 정규화하며 출력값들의 총합은 항상 1이 되도록 만들어줍니다. 이는 주로 다중 클래스 분류(multi-class classification) 문제에서 출력층의 활성화 함수로 사용되며, 각 클래스에 속할 확률을 출력합니다.

즉, softmax 함수는 입력값을 확률 분포로 변환해주는 함수입니다. 이를 이용해 예측값의 확률 분포를 계산하고, 그 중 가장 높은 확률을 가지는 클래스를 선택하는 방식으로 다중 클래스 분류 문제를 해결할 수 있습니다.

 

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_iris
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
import time

#1. 데이터
datasets = load_iris()
print(datasets.DESCR)
print(datasets.feature_names)
# ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']

x = datasets.data   # x = datasets['data'] 와 같은 명령어
y = datasets.target
print(x.shape, y.shape) # (150, 4) (150,)

x_train, x_test, y_train, y_test = train_test_split(
    x, y, train_size=0.7, random_state=100, shuffle=True
)
print(x_train.shape, y_train.shape) # (105, 4) (105,)
print(x_test.shape, y_test.shape)   # (45, 4) (45,)
# print(y_test)
# print(x_test)

#2. 모델구성
model = Sequential()
model.add(Dense(50, input_dim=4))
model.add(Dense(10))
model.add(Dense(8))
model.add(Dense(4))
model.add(Dense(6))
model.add(Dense(5))
model.add(Dense(3, activation='softmax'))	#softmax 활성화함수

#3. 컴파일, 훈련
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam',
              metrics=['accuracy'])
start_time = time.time()
model.fit(x_train, y_train, epochs=500, batch_size=100)
end_time = time.time() - start_time

#4. 평가, 예측
loss, acc = model.evaluate(x_test, y_test)
print('loss : ', loss)
print('acc : ', acc)
print('걸린 시간 : ', end_time)

# result
# loss :  0.04617173224687576
# acc :  0.9777777791023254
# 걸린 시간 :  2.734331369400024

 

wine_onehotencoding)

wine data를 keras에서 to_categorical 함수를 입력해 onehotencoding 해보겠습니다.

 

Keras는 딥러닝 프레임워크 중 하나로, 쉽고 빠르게 딥러닝 모델을 구축할 수 있는 고수준의 API를 제공합니다. TensorFlow, Theano, CNTK 등의 백엔드 엔진을 지원하며, 다양한 딥러닝 모델, 층(layer), 활성화 함수(activation function), 최적화 알고리즘 등을 쉽게 사용할 수 있습니다. Keras는 간결하고 직관적인 API로 딥러닝 모델을 구현할 수 있어 많은 딥러닝 개발자들이 선호하고 있습니다. 또한, Keras는 컴퓨터 비전, 자연어 처리, 음성 처리 등 다양한 분야에서 활용되고 있습니다.

import numpy as np
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
import time
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import to_categorical	# onehotencoding 가져오기
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.datasets import load_wine	# wine data load

#1. 데이터
datasets = load_wine()
print(datasets.DESCR)
print(datasets.feature_names)
# ['alcohol', 'malic_acid', 'ash', 'alcalinity_of_ash', 'magnesium', 'total_phenols',
# 'flavanoids', 'nonflavanoid_phenols', 'proanthocyanins', 'color_intensity', 'hue', 'od280/od315_of_diluted_wines', 'proline']

x = datasets.data
y = datasets.target
print(x.shape, y.shape) # (178, 13) (178,)

y = to_categorical(y)   # split 전에 onehotencoding 을 해야함
x_train, x_test, y_train, y_test = train_test_split(
    x, y, train_size=0.7, random_state=100, shuffle=True
)

print(x_train.shape, y_train.shape) # (124, 13) (124,)
print(x_test.shape, y_test.shape)   # (54, 13) (54,)
print(y_test)
print(x_test)

#2. 모델구성
model = Sequential()
model.add(Dense(100, input_dim=13))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(3, activation='softmax'))

#3. 컴파일, 훈련
model.compile(loss='categorical_crossentropy', optimizer='adam',
              metrics=['accuracy'])
start_time = time.time()
model.fit(x_train, y_train, epochs=500, batch_size=100)
end_time = time.time() - start_time
print('걸린 시간 : ', end_time)

#4. 평가예측
loss, acc = model.evaluate(x_test, y_test)
print('loss : ', loss)
print('acc : ', acc)

# result
# loss :  0.2606625258922577
# acc :  0.9444444179534912