목록:
리스트 대괄호로 분류하기
train_test_split //sklearn
scatter 산점도 //import matplotlib.pyplot as plt
r2score
california
california-activation
cancer sigmoid
tf10_Iris_softmax
tf10_Iris_onehotencoding
와인
리스트 [ : ] 대괄호로 분류해보기
#라이브러리 구성, 정리
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])
'''
x_train = np.array(x[0:14]) / 0 생략 가능
y_train = np.array(x[0:14])
x_test = np.array(x[14:21]) / 맨 마지막 21 생략 가능
y_test = np.array(y[14:21])
'''
#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)
'''
loss는 1.738347576996091e-09
1/1 [==============================] - 0s 160ms/step
21의 예측값 : [[20.999928]]
'''model.evaluate() 함수에서는 loss 값 출력
model.predict() 함수는 학습된 모델을 사용하여 입력 데이터에 대한 예측값을 반환하는 함수입니다. 모델에 입력 데이터를 주면 모델이 예측한 결과를 출력합니다. 따라서 학습과정에서 사용되지 않은 새로운 데이터에 대한 예측을 수행할 수 있습니다. 이를 통해 모델이 얼마나 일반화되어 있는지 확인할 수 있습니다.
train_test_split //sklearn
#라이브러리 구성, 정리
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,
test_size=0.3, #보통 30퍼
train_size=0.7, #보통 70퍼
random_state=100, # 데이터를 난수값에 의해 추출한다는 의미, 중요한 하이퍼파라미터임임
shuffle=True #데이터를 섞어서 가지고 올 것인지 정함
#괄호 안 순서는 상관 없음
)
#테스트를 넣어도 되고 트레인 넣어도 되고 둘다 넣으려면 100을 맞춰야함
#random_state: 난수값을 지정해줌. 랜덤을 정해줌. 그래서 돌릴때마다 값이 변하지 않음
#shuffle 리스트를 섞을지 말지 /불리언(안적으면 기본값 true)(안하고 싶음 False)
train_test_split() 함수는 입력 데이터 x와 그에 해당하는 정답 레이블 y를 받아서 랜덤하게 train 데이터와 test 데이터를 분리하는 함수입니다. 분리된 데이터는 순서대로 x_train, x_test, y_train, y_test 변수에 할당됩니다.
따라서, 괄호 밖에서 x_train, x_test, y_train, y_test 순서를 지정하는 것은 할당될 변수의 이름을 지정하는 것입니다. 이 때 변수명은 개발자의 개인적인 취향에 따라 자유롭게 지정할 수 있으며, 변수명이 지정된 순서대로 데이터가 할당됩니다. 따라서 괄호 안에서 x와 y를 넣을 때는 train_test_split() 함수에서 지정된 순서대로 입력해야 합니다.
scatter 산점도 //import matplotlib.pyplot as plt
#라이브러리 구성, 정리
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, test_size=0.3, train_size=0.7,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) # 산점도 그리기, x.와 y값
plt.plot(x, y_predict, color='pink')
plt.show()
result = model.predict([21])
print('21의 예측값 : ', result)
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, test_size=0.3, train_size=0.7,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)
### R2score
from sklearn.metrics import r2_score, accuracy_score #회귀는 r2, 분류는 acc
r2 = r2_score(y, y_predict) #실제 y값이라 예측 y값 비교교
print('r2스코어 : ', r2)
#result
#loss는 2.251454134238884e-09
#r2스코어 : 0.9999999999455071 // 1에 가까울수록 높은 연관성
#result
#노드수를 늘리고 히든레이어의 갯수를 늘리면 r2 score가 좋지 않다california
사이킷런 사이트 : 오픈 api 제공 //7. Dataset loading utilities — scikit-learn 1.2.2 documentation
from re import X
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)
#['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']
#print(datasets.DESCR) #세부 내용 보기 description
# :속성 정보:
# - 그룹의 중위수 소득
# - 그룹의 주택 연령 중위수
# - 가구당 평균 객실 수
# - 평균 가구당 침실 수
# - 모집단 그룹 모집단
# - 평균 가구원수
# - Latitude 그룹 위도
# - 경도 그룹 경도
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, input_dim=8)) #input_dim은 열에 나오는 컬럼 수
model.add(Dense(100))
model.add(Dense(100))
model.add(Dense(1000))
model.add(Dense(1000))
model.add(Dense(1)) #회귀분석이니까 주택가격 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 성능을 올리기 위해서
기본값: linear
# [실습] 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)
#['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']
#print(datasets.DESCR) #세부 내용 보기 description
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)
print(y_train.shape)
#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(1000, activation='relu'))
model.add(Dense(1000, activation='relu'))
model.add(Dense(1, activation='linear')) #회귀모델에서 인풋과 아웃풋 활성화함수는 "linear" - 기본값임
#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)
# result
# r2 스코어:
# 모든 히든레이어에 activation='relu'를 사용하면 성능이 향상됨선형(linear) 활성화 함수와 ReLU(Rectified Linear Unit) 활성화 함수는 딥러닝에서 가장 많이 사용되는 활성화 함수
선형(linear) 활성화 함수는 입력값에 가중치를 곱한 뒤 편향을 더해주는 과정을 거칩니다.
이를 수식으로 나타내면 y = wx + b와 같습니다. 즉, 입력값과 출력값이 1:1로 대응되기 때문에, 층을 깊게 쌓아도 출력값이 입력값에 비례하여 증가하거나 감소하므로 딥러닝 모델의 표현력이 한계를 가지게 됩니다.
반면, ReLU(Rectified Linear Unit) 활성화 함수는 입력값이 0보다 작으면 0으로, 0보다 크면 입력값을 그대로 출력합니다. 이는 다음 층으로 값을 전달하는 역할을 하게 됩니다. 이러한 함수를 사용하면 입력값이 0보다 작은 경우에는 출력값이 0으로 수렴하게 되고, 이를 통해 네트워크의 표현력이 향상되고 효율적인 학습이 가능합니다.
따라서, 선형 활성화 함수는 다층 퍼셉트론(MLP)에서는 사용되지만, 딥러닝에서는 ReLU 함수가 많이 사용되는 것이 일반적입니다.
회귀모델에서 인풋레이어와 아웃풋레이어에는 무조건 linear 함수를 사용하는 것은 일반적인 규칙은 아니지만, 주로 사용되는 방법 중 하나입니다. 이유는 선형 함수는 모든 입력에 대해 선형적인 변화를 보이므로, 모델이 학습한 가중치와 편향을 사용하여 입력 데이터에 대한 선형적인 결합을 통해 출력을 예측할 수 있기 때문입니다.
예를 들어, 회귀 문제에서는 출력이 연속적인 값을 가지기 때문에 출력 레이어에 선형 함수를 사용할 수 있습니다. 또한 입력 변수들 간의 선형적인 관계를 나타내기 위해 인풋 레이어에도 선형 함수를 사용할 수 있습니다.
하지만 이 규칙이 반드시 지켜져야 하는 것은 아니며, 데이터에 따라 적절한 활성화 함수를 선택해야 합니다. 예를 들어, 일부 회귀 문제에서는 sigmoid나 tanh와 같은 활성화 함수를 사용하여 출력을 제한할 수 있습니다.
네, 인풋 레이어와 아웃풋 레이어에는 선형 활성화 함수를 사용해야 합니다. 이는 선형 결합의 출력을 예측하는 것이 목적이기 때문입니다.
중간에 ReLU 레이어를 사용하더라도, 이는 비선형 변환을 수행하며 인풋과 아웃풋 레이어에는 영향을 주지 않습니다. 따라서 중간 레이어에서 사용되는 활성화 함수는 비선형 함수를 사용해도 되며, ReLU 함수는 일반적으로 사용되는 활성화 함수 중 하나입니다.
tf09_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 # r2=적합도, ac=정확도
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' '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, activation='relu'))
model.add(Dense(1, activation='sigmoid')) #0이냐 1이냐 찾는 이진분류이기때문에 뉴런 1, 이진분류는 무조건 아웃풋 활성화 함수를: sigmoid
#컴파일, 훈련
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy','mse']) #손실함수는 바이너리 넣어야함, metrics, accuracy 역할할 확인 하기**
start_time= time.time()
model.fit(x_train, y_train, epochs=100, batch_size=200,
verbose=2) #verbose 훈련과정 안 보고 싶을 때 0, 기본보기 1, 막대기 안보기 2
end_time = time.time() - start_time
#평가 예측
loss =model.evaluate(x_test,y_test)
y_predict=model.predict(x_test) #소수점 나와서 0인지 1인지 만들어줘야함
#[실습] accurancy score를 출력하라
# 1번 방법 : y_predict 반올림하기
'''
y_predict = np.where(y_predict > 0.5, 1, 0) #0.5보다 크면 1, 아니면 0 할거야
print('loss : ', loss) #loss : [0.34362778067588806, 0.05551309883594513] 2개 나온 이유: metrics: mse 해서 같이 뽑힘힘
print('accuracy : ', acc) #accuracy : 0.9298245614035088
'''
'''
# 2번방법
y_predict = np.round(y_predict)
acc = accuracy_score(y_test, y_predict)
print('loss : ', loss) #loss :[0.18420802056789398, 0.053063519299030304] 2개 나온 이유: metrics: mse 해서 같이 뽑힘힘
print('accuracy : ', acc) #accuracy : 0.9298245614035088
'''
y_predict = np.round(y_predict)
acc = accuracy_score(y_test, y_predict)
print('loss : ', loss) #loss : [0.3225121796131134, 0.9064327478408813, 0.08121472597122192]
print('accuracy : ', acc) #accuracy : 0.9064327485380117
print('걸린 시간: ', end_time) #걸린 시간: 1.084829568862915
#시그모이드랑 바이너리 넣으면 끝, 분류기 때문에 r2scoore가 아니라 accurancy score 체크tf10_Iris_softmax
#loss='sparse_categorical_crossentropy'
#다중분류 아웃풋 3개,activation='softmax'
from tracemalloc import start
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) #0은 꽃1, 1은 꽃2, 2는 꽃3
#2. 모델링
model=Sequential()
model.add(Dense(100, input_dim=4)) #컬럼 수
model.add(Dense(100))
model.add(Dense(50))
model.add(Dense(50))
model.add(Dense(3, activation='softmax')) #아웃풋 3개
#3. 컴파일, 훈련
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam',metrics=['accuracy'])
#loss='sparse_categorical_crossentropy' 원핫인코딩 안하고 0.1.2 정수로 인코딩 상태에서 수행가능
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)
# accuracy: 1.0000 => 과적합일 가능성이 높음
# loss : 0.020110951736569405#4 예측 평가
model.evaluate() 함수는 모델을 평가한 결과를 반환하는데, 그 결과는 [손실값, 정확도] 형태의 리스트입니다.
따라서 loss, acc = model.evaluate(x_test, y_test) 코드에서 model.evaluate(x_test, y_test)는 [손실값, 정확도] 형태의 리스트를 반환하게 됩니다. 이 리스트에서 첫 번째 값이 손실값이 되고, 두 번째 값이 정확도가 되어 loss와 acc 변수에 각각 할당되는 것입니다.
model.compile() 함수에서 metrics에 accuracy를 지정했기 때문에 모델이 학습하는 동안 정확도를 계산하게 됩니다. 만약 accuracy 대신 다른 지표를 지정했다면 그 지표가 모델의 학습 및 평가 지표로 사용됩니다.
만약 metrics를 지정하지 않으면 디폴트값인 loss만 계산합니다. 따라서, model.evaluate() 함수에서는 loss 값만 출력됩니다.
tf10_Iris_onehotencoding
loss='categorical_crossentropy' -- +one hot encoding
#다중분류 아웃풋 3개,activation='softmax', 원핫인코딩딩
from tracemalloc import start
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,)
##모델구성전에 원핫인코딩하기- 3가지 방법잇음
###one hot encoding
from keras.utils import to_categorical
y = to_categorical(y) # 끝
print(y) #[1. 0. 0.] '''
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) #0은 꽃1, 1은 꽃2, 2는 꽃3
#2. 모델링
model=Sequential()
model.add(Dense(100, input_dim=4)) #컬럼 수
model.add(Dense(100))
model.add(Dense(50))
model.add(Dense(50))
model.add(Dense(3, activation='softmax')) #아웃풋 3개
#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)
# accuracy: 1.0000 => 과적합일 가능성이 높음
# loss : 0.020110951736569405
'''tf11_wine_onehotencoding
#[실습] one hot encoding을 사용하여 분석 (세 가지 방법 중 한 가지 사용)
from tracemalloc import start
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()
x = datasets.data
y = datasets.target
from keras.utils import to_categorical
y = to_categorical(y)
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=13))
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)
# 예측, 평가
loss, acc = model.evaluate(x_test,y_test)
print('loss: ', loss)
print('acc: ', acc)
#loss: 0.15465861558914185
#acc: 0.9629629850387573tf11_wine_somftmax
# 실습 loss = 'sparse_categorical_crossentropy'를 사용하여 분석
from tracemalloc import start
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.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, 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) #[0 1 2]
#2. 모델링
model=Sequential()
model.add(Dense(100,input_dim=13))
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)
# 예측, 평가
loss, acc = model.evaluate(x_test, y_test)
print('loss :', loss)
print('acc : ', acc)
#걸린시간: 2.6191811561584473
# loss : 0.2452908307313919
# acc : 0.9444444179534912'[네이버클라우드] 클라우드 기반의 개발자 과정 7기 > AI' 카테고리의 다른 글
| Ai 개념 정리 3 (1) | 2023.05.10 |
|---|---|
| [수업자료] Ai 3일차 코드 (0) | 2023.05.10 |
| ai 개념정리 2 (1) | 2023.05.10 |
| AI 개념 정리 (2) | 2023.05.08 |
| AI (0) | 2023.05.08 |