AI (train set/ test set/ validation set/ 회귀분석과 분류분석/ 이진분류/ 다중분류/ 이항교차 엔트로피/ 범주형교차 엔트로피/ mse/ r2 score/ onehotencoding)

●Train Set  

- 모델의 학습만 을 위해 사용

- parameter 나 feature 등을 수정하여 모델의 성능을 높이는 작업에 사용

 

---

● Test Set

- 최종적으로 모델의 성능 평가

- 실사용 되었을 때 모델이 얼마나 좋은 성능을 보일 수 있을지 알아보는 것

 

---

● Validation Set

- 모델의 학습에 직간접적으로 관여하지 않음

- 학습이 끝난 모델에 적용, 최종적으로 모델을 fine tuning하는데 사용한다

 

---

● 회귀분석과 분류분석

회귀분석 (Regression)	분류분석 (Classfication)
연속된 값을 예측	종류를 예측
ex) 과거의 주가를 토대로 미래 주가 예측 자동차 배기량 , 연식 등 중고차 정보 이용해 가격을 예측	클래스 0 또는 1 중에서 선택하는 이진 분류  3개 이상의 클래스 중 하나를 선택하는 다중분류  ex) 강아지 or 고양이
선형회귀 / 랜덤 포레스트 / 그래디언트 부스팅	이진분류/ 다중분류 / 로지스틱 회귀

 

 

● 이진 분류

- True or False 판별하기 때문에 출력값은 오직 하나

- 출력값을 sigmoid 함수를 이용해 0과 1로 가공한다

- 직선보다 적절한 곡선을 통해 분류 

- 로지스틱 회귀는 이진분류 모델을 분석하기 좋은 모델

 

● 다중 분류

- 다중 분류모델은 타겟의 종류가 여러개 -> 출력값도 여러개

- softmax 함수를 사용하여 0과 1사이 값으로 가공

-  one-hot-encoding 이라는 기법을 사용

 

---

♣ 손실 함수

 

●이진 분류- binary_crossentropy(이항교차 엔트로피)

- y값이 0과 1인 이진 분류기를 훈련할 때 자주 사용되는 손실 함수

- 활성화 함수(activation) : sigmoid 사용 (출력값이 0과 1사이의 값)

 

● 다중 분류- categorical_crossentropy (범주형 교차 엔트로피)

- Y 클래스가 3개 이상일 경우, 즉 다중 분류에서 사용

- 활성화 함수(activation) : softmax 사용 (모든 벡터 요소의 값은 0 과 1사이의 값이 나오고, 모든 합이 1이 됨)

- 라벨이 (0,0,1,0,0) , (0,1,0,0,0) 과 같이 one-hot encoding 된 형 태로 제공될 때 사용 가능

 

● 다중 분류- sparse_categorical_crossentropy

- categorical crossentropy와 같이 다중 분류에서 사용

- one-hot encoding 된 상태일 필요 없이 정수 인코딩 된 상태에서 수행 가능

- 라벨이 (1,2,3,4) 와 같이 정수형태로 사용

 

●categorical_crossentropy/ sparse_categorical_crossentropy 의 차이점

: one-hot encoding의 자동화 여부

 

 

● 평균 제곱 오차 손실 (means squared error, MSE)

- 회귀 문제에서 널리 사용됨 회귀문제에 사용될 수 있는 다른 손실 함수

(1) 평균 절댓값 오차 (Mean absolute error, MAE)

(2) 평균 제곱근 오차(Root mean squared error, RMSE)-예측값과 실제값의 차이를 제곱하여 평균한 값(모두 실숫값 계산) 

MSE가 크다는 것은 평균 사이에 차이가 크다는 뜻 /

MSE가 작다는 것 은 데이터와 평균사이의 차이가 작다는 뜻

 

---

● MSE 와 MAE의 차이 

ex) 데이터 크기가 10, 10, 10, 10, 10, 10,2500,10,10,10 일때 

 

mse(평균 제곱 오차) 는 오차가 크게 적용된다 : 이상치에 더 민감

-> 2500을 최대한 반영

mae(평균 절대 오차) 는 오차를 변수들간의 오차가 완화된다 :이상치에 덜 민감

->2500을 최소한 반영

 

---

● 결정 계수 R2 Score

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

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

- r2 score는 0과 1 사이의 값을 가지며, 1에 가까울수록 선형회귀 모델이 데이터에 대해 높은 연관성을

갖는다고 해석한다

 

---

●One Hot Encoding

- 범주형 데이터를 이진 형태의 백터로 변환하는 방법

-각 범주에 대해 고유한 이진 벡터를 생성, 해당 범주에 해당하는 원소는1, 나머지 원소는 0으로 표현

-이를 통해 범주형 데이터를 머신러닝 알고리즘이 처리할 수 있는 형태로 변환 가능

 

ex)

품종		setosa	virginica	versicolor
setosa		1	0	0
virginica		0	1	0
versicolor		0	0	1
setosa		1	0	0

---

●난수값 ( random_state)

- 머신러닝 알고리즘 및 데이터 분할 작업에서 사용되는 난수 생성기의 시드 값\

- random_state 설정 시 무작위로 생성되는 난수 패턴이 고정, 알고리즘 결과의 재현을 가능하게 함

 

---

●코드실습

# train_test_split01
import numpy as np
from keras.models import Sequential
from keras.layers import Dense

# 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 = np.array(range(1, 21))
# y = np.array(range(1, 21))

# print(x.shape)
# print(y.shape)
# print(x)
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)

 

#train_test_split
import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_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_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=100,  # 데이터를 난수값에 의해 추출한다는 의미, 중요한 하이퍼파라미터
    shuffle=True    # 데이터를 섞어서 가지고 올 것인지를 True/False 로 정함
)

# 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)

 

#scatter 산점도 그리기
import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_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_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=100,  # 데이터를 난수값에 의해 추출한다는 의미이며, 중요한 하이퍼파라미터임
    shuffle=True    # 데이터를 섞어서 가지고 올 것인지를 정함
)

# 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)

y_predict = model.predict(x)

##### scatter 시각화
import matplotlib.pyplot as plt

plt.scatter(x, y)  # 산점도 그리기
plt.plot(x, y_predict, color='red')
plt.show()

# r2 안좋은 예 만들기 
#1. R2 를 음수가 아닌 0.5 이하로 
#2. 데이터는 조작 x
#3. 레이어는 인풋, 아웃풋 포함 7개 이상(히든레이어 5개 이상)으로 만들기
#4. batch_size=1
#5. 히든레이어의 노드(뉴런) 갯수는 10개 이상 100개 이하
#6. train_size = 0.7
#7. epochs=100 이상

import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_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,4,3,5,7,9,3,8,12,13,8,14,15,9,16,17,23,18,20])

x_train, x_test, y_train, y_test = train_test_split(
    x, y, train_size=0.7, shuffle=True, random_state=0
)
#shuffle=False 일때 0.5441042097346507

#2. 모델구성
model = Sequential()
model.add(Dense(5, input_dim=1))
model.add(Dense(10))
model.add(Dense(50))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(100))
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)

y_predict = model.predict(x)  

from sklearn.metrics import r2_score
r2 = r2_score(y, y_predict)
print('r2 스코어: ', r2)  


# result
# loss :  39.7522087097168
# r2 스코어:  0.49266916260562
# 노드수를 늘리고 히든레이어의 갯수를 늘리면 r2 score 가 좋지 않음

 

# r2score
import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from sklearn.model_selection import train_test_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_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=100,  # 데이터를 난수값에 의해 추출한다는 의미이며, 중요한 하이퍼파라미터임
    shuffle=True    # 데이터를 섞어 가져올 것인지 TRUE/FALSE로 정함 
)

# 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)

y_predict = model.predict(x)

### R2score
from sklearn.metrics import r2_score, accuracy_score
r2 = r2_score(y, y_predict)
print('r2스코어 : ', r2)

# result(1)
# loss :  3.037989699805621e-07
# r2스코어 :  0.9999999942704495

#result(2)
#loss: 2.659254278114531e-06
#r2스코어: 0.9999999507534805

#california
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 load_boston # 윤리적 문제로 제공안됨
from sklearn.datasets import fetch_california_housing


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

print(datasets.feature_names)
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=72, shuffle=True
)
print(x_train.shape)    # (14447, 8)
print(y_train.shape)    # (14447,)

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

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

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

y_predict = model.predict(x_test)

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

 

# [실습] activation  함수를 사용하여 성능 향상시키기
# activation='relu'

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 load_boston # 윤리적 문제로 제공안됨
from sklearn.datasets import fetch_california_housing


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

print(datasets.feature_names)
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=72, 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=100, batch_size=200)

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

y_predict = model.predict(x_test)

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

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

 

#cancer_sigmoid
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 time

#1. 데이터
datasets = load_breast_cancer()
print(datasets.DESCR)
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'' ractal 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(1, activation='sigmoid')) # 이진분류는 모조건 아웃풋 레이어의 
                                          # 활성화 함수를 'sigmoid'로 해줘야 한다

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

start_time = time.time()
model.fit(x_train, y_train, epochs=100, batch_size=200, verbose=2)
end_time = time.time() - start_time

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

# [실습] accuracy_score를 출력하라!!!
# y_predict 반올림하기

# y_predict = np.where(y_predict > 0.5, 1, 0)
y_predict = np.round(y_predict)
acc_test = accuracy_score(y_test, y_predict)
print('loss : ', loss)
print('acc : ', acc)  
print('걸린 시간 : ', end_time)

# loss :  [0.25783923268318176, 0.06376346945762634]
# acc :  0.9181286549707602  #==> np.round() 사용
# acc :  0.9298245614035088  #==> np.where() 사용
# 걸린 시간 :  1.1319026947021484

# loss :  [0.48961251974105835, 0.9239766001701355, 0.0635608434677124]
# acc :  0.9239766081871345
# 걸린 시간 :  1.2248423099517822

 

#iris_one_hot_encoding
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 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,)

### one hot encoding
from keras.utils import to_categorical
y = to_categorical(y)
print(y)
print(y.shape)  # (150, 3)

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)


#2. 모델 구성
model = Sequential()
model.add(Dense(100, input_dim=4))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(50))
model.add(Dense(10))
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)

### argmax 로 accuracy score 구하기
y_predict = model.predict(x_test)
y_predict = y_predict.argmax(axis=1)
y_test = y_test.argmax(axis=1)
argmax_acc = accuracy_score(y_test, y_predict)
print('argmax_acc', argmax_acc)

 

#iris_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 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)

#2. 모델 구성
model = Sequential()
model.add(Dense(100, input_dim=4))
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(50))
model.add(Dense(10))
model.add(Dense(3, activation='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
print('걸린 시간 : ', end_time)

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

 

# wine_one_hot_encoding
#		one hot encoding을 사용하여 분석 
#       (세 가지 방법 중 한가지 사용)
#       (1) keras.utils 의 to_categorical
      # (2) pandas의 get_dummies
      # (3) sklearn.preprocessing의 OneHotEncoder

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_wine
import time

#1. 데이터

datasets = load_wine()
print(datasets.DESCR)
print(datasets.feature_names)

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

### One Hot Encoding 
from keras.utils import to_categorical
y = to_categorical(y)
print(y)
print(y.shape)  # (178, 3)

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


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

#3. 훈련
model.compile(loss='categorical_crossentropy', optimizer='adam',    # 다중분류에서 loss = 'categorical_crossentropy'를 사용함
              metrics=['accuracy'])   

start_time = time.time()
model.fit(x_train, y_train, epochs=1000, batch_size=128)
end_time = time.time() - start_time
print(end_time)

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

### argmax 로 accuracy score 구하기
y_predict = model.predict(x_test)
y_predict = y_predict.argmax(axis=1)
y_test = y_test.argmax(axis=1)
argmax_acc = accuracy_score(y_test, y_predict)
print('argmax_acc', argmax_acc)

#wine_softmax
#loss = 'sparse_categorical_crossentropy'를 사용하여 분석
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_wine
import time

#1. 데이터

datasets = load_wine()
print(datasets.DESCR)
print(datasets.feature_names)

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

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


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

#3. 훈련
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam',    # 다중분류에서 loss = 'categorical_crossentropy'를 사용함
              metrics=['accuracy'])   

start_time = time.time()
model.fit(x_train, y_train, epochs=1000, batch_size=128)
end_time = time.time() - start_time
print(end_time)

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