#텐서플로우 기본
# tensorbasic.py
def p(str):
print(str, '\n')
#텐서플로우 라이브로리
import tensorflow as tf
#텐서플로우 버전 확인
# p(f'텐서플로우버전 : {tf.__version__}')
#정수형 상수텐서
#5의값을 가진 4바이트 정수 상수 텐서
tensor_int = tf.constant(5, dtype=tf.int32)
p(tensor_int)
tensor1 = tf.constant([5,3])
p(tensor1)
#정수형 변수 텐서
tensor2 = tf.Variable(5)
p(tensor2)
tensor2.assign(10) #변수 텐서 값 변경
p(tensor2)
#너파이 배열을 텐서로 변환
import numpy as np
numpy_arr = np.array([1,2,3,4]) #넘파이배열
tensor_numpy = tf.convert_to_tensor(numpy_arr)
p(tensor_numpy)
#리스트를 텐서로 변환
li = [1, 3, 3.14, 7, 10]
tensor_list = tf.convert_to_tensor(li)
p(tensor_list)
#텐서를 넘파이 배열로 변환
numpy_arr1 = tensor_numpy.numpy()
numpy_ar2 = tensor2.numpy()
# print(numpy_arr1)
# print(numpy_ar2)
#0908~~~~~~~~~
#텐서플로우 함수
# 두 정수형 상수 텐서 생성
tensor1 = tf.constant(5, dtype=tf.int32)
tensor2 = tf.constant(7, dtype=tf.int32)
#텐서들끼리 덧셈 연산
result = tf.add(tensor1, tensor2)
# p(result)
#텐서들끼리 곱샘연산
matrix1 = tf.constant([[1,2], [3,4]])
matrix2 = tf.constant([[5,6], [7,8]])
result = tf.matmul(matrix1, matrix2)
p(result)
#텐서 슬라이싱 연산
#텐서를 쪼개는 것
#2차원 텐서 생성하기
tensor = tf.constant([[1,2,3],[4,5,6],[7,8,9]])
slice_tensor = tensor[0:2, 1:3]
#텐서
p(slice_tensor)
#결과에서 넘파이 배열로 변환
p(slice_tensor.numpy())
## 활성화 함수(Activation Function)
'''
인공신경망에서 각각의 뉴런의 출력을 경정하는 함수.
비선형 데이터를 추가해서 신경망이 복잡한 모델링을 하거나
다양한 문제를 해결할 수 있도록 하는데 사용되는 함수
ReLU(Recitified Linear Unit)
- 은닉층에서 주로 사용되고 양수인 경우 양수를 출력
- 음수인 경우에는 0을 출력함
'''
#실수 텐서 생성
tensor = tf.constant([-5.14, 2.51, -4.14, -0.05])
relu = tf.nn.relu(tensor) # relu
# p(f'활성화함수를 적용한 결과 {relu.numpy()}') #활성화함수를 적용한 결과 [0. 2.51 0. 0. ]
#텐서 크기 변경
tensor = tf.constant([1, 2, 3, 4, 5, 6])
tensor_re = tf.reshape(tensor, (2,3))
# p(tensor_re)
#모든 요소가 0인 텐서
zeros_tf= tf.zeros((5,2))
p(zeros_tf)
#모든 요소가 1인 텐서
ones_tf= tf.ones((5,2))
p(ones_tf)
#주어진 값으로 요소를 채운 텐서
fill_tf = tf.fill((3,2), 10)#3행2열, 10의값으로 채울거야~
p(fill_tf)
# 정규분포에서 난수 생성하는 함수
# 평균이 0.0이고, 표준편차가 1.0인 3행 4열짜리(2차원) 텐서
tensor = tf.random.normal((3,4), mean=0.0, stddev=1.0)
p(tensor)
# tf_beginner.py
def p(str):
print(str, '\n')
# 라이브러리
import tensorflow as tf
# mnist 데이터셋 로딩
mnist = tf.keras.datasets.mnist
# 트레이닝셋/테스트셋 분리
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 실수로 변경
x_train, x_test = x_train/255.0, x_test/255.0
# Sequential모델
# 케라스의 레이어들을 순차적으로 적용하는 모델
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
# 모델 컴파일
# 활성화함수, 손실함수, 결과를 지정
model.compile(
optimizer='adam', # 활성화 함수
loss='sparse_categorical_crossentropy', # 손실 함수
metrics=['accuracy'] # 결과는 정확도
)
# 예측값
predictions = model(x_train[:1]).numpy()
#p(predictions)
# 예측값들을 확률로 변환
p(tf.nn.softmax(predictions).numpy())
# 손실함수 정의
loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
p(loss_fn(y_train[:1], predictions).numpy())
# 모델 컴파일
model.compile(
optimizer='adam',
loss=loss_fn,
metrics=['accuracy']
)
# 모델 훈련
# epochs : 회수
model.fit(x_train, y_train, epochs=5)
# 예측 모델
probability_model = tf.keras.Sequential([
model,
tf.keras.layers.Softmax()
])
# 예측값
p(probability_model(x_test[:5]))
##mnist 데이터
# tf_advanced.py
def p(str):
print(str, '\n')
# 라이브러리
import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten, Conv2D
from tensorflow.keras import Model
pip install pytest
# mnist 데이터셋
mnist = tf.keras.datasets.mnist
# 트레인/테스트 분리
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# 실수화
x_train, x_test = x_train / 255.0, x_test / 255.0
# 차원 추가
# ...:기존, tf.newaxis:새로운 차원, astype("float32"):4바이트 실수로 변환
x_train = x_train[..., tf.newaxis].astype("float32")
x_test = x_test[..., tf.newaxis].astype("float32")
# 데이터셋 섞고 배치 생성
train_ds = tf.data.Dataset.from_tensor_slices((x_train, y_train)) \
.shuffle(10000).batch(32)
test_ds = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
# 모델클래스 생성
class MyModel(Model):
def __init__(self):
super(MyModel, self).__init__()
self.conv1 = Conv2D(32, 3, activation='relu')
self.flatten = Flatten()
self.d1 = Dense(128, activation='relu')
self.d2 = Dense(10)
def call(self, x):
x = self.conv1(x)
x = self.flatten(x)
x = self.d1(x)
return self.d2(x)
# 모델 생성
model = MyModel()
# 활성화 함수, 손실 함수
optimizer = tf.keras.optimizers.Adam()
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
# 트레인/테스트 활성화, 손실
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='train_accuracy')
test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(name='test_accuracy')
# 모델 훈련
@tf.function
def train_step(images, labels):
with tf.GradientTape() as tape:
predictions = model(images, training=True)
loss = loss_object(labels, predictions)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss(loss)
train_accuracy(labels, predictions)
# 모델 테스트
@tf.function
def test_step(images, labels):
predictions = model(images, training=False)
t_loss = loss_object(labels, predictions)
test_loss(t_loss)
test_accuracy(labels, predictions)
# 회수
EPOCHS = 5
for epoch in range(EPOCHS):
p('epoch')
train_loss.reset_state()
train_accuracy.reset_state()
test_loss.reset_state()
test_accuracy.reset_state()
for images, labels in train_ds:
train_step(images, labels)
for test_images, test_labels in test_ds:
test_step(test_images, test_labels)
print(
f'Epoch {epoch + 1}, '
f'Loss : {train_loss.result()}, '
f'Accuracy : {train_accuracy.result() * 100}, '
f'Test Loss : {test_loss.result()}, '
f'Test Accuracy : {test_accuracy.result() * 100}'
)
Epoch결과 (소요시간 약 15분)
epoch
Epoch 1, Loss : 0.1374218612909317, Accuracy : 95.88999938964844, Test Loss : 0.05870795249938965, Test Accuracy : 97.97999572753906
epoch
Epoch 2, Loss : 0.044754184782505035, Accuracy : 98.58000183105469, Test Loss : 0.05215563625097275, Test Accuracy : 98.3699951171875
epoch
Epoch 3, Loss : 0.024776458740234375, Accuracy : 99.19000244140625, Test Loss : 0.05278272181749344, Test Accuracy : 98.4000015258789
epoch
Epoch 4, Loss : 0.01443169079720974, Accuracy : 99.52832794189453, Test Loss : 0.06260816752910614, Test Accuracy : 98.29999542236328
epoch
Epoch 5, Loss : 0.0109100928530097, Accuracy : 99.63500213623047, Test Loss : 0.06252223253250122, Test Accuracy : 98.48999786376953
텐서플로우 예제
튜토리얼을 보면 초보자,전문가를 위한 예제들이 나와있음.
지금해보려고 하는건 기본 이미지 분류(손글씨데이터셋)를 해보려고합니다.
# tf_mnist.py
def p(str):
print(str, '\n')
# 라이브러리 임포트
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential, load_model
from keras.datasets import mnist
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Dense, Flatten, Dropout
from keras.utils import to_categorical
# mnist데이터셋
img_rows = 28 # 행 수
img_cols = 28 # 컬럼 수
# 트레인/테스트 분리
(X_train, y_train), (X_test, y_test) = mnist.load_data()
#print(X_train.shape, X_test.shape)
# 입력 크기
input_shape = (img_rows, img_cols, 1)
X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)
X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)
#print(X_train.shape, X_test.shape)
# 실수 변환
X_train = X_train.astype('float32') / 255.0
X_test = X_test.astype('float32') / 255.0
#p(X_train.shape[0])
#p(X_test.shape[0])
# 분류화
num_classes = 10 # 분류 10개
y_train = to_categorical(y_train, num_classes)
y_test = to_categorical(y_test, num_classes)
#p(y_train)
#p(y_test)
# 모델 생성
model = Sequential()
model.add(Conv2D(32, kernel_size=(5,5), strides=(1, 1), \
padding='same', activation='relu', input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(Conv2D(64, (2,2), activation='relu', padding='same'))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1000, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
# 모델 컴파일
model.compile(
loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy']
)
# 모델 훈련
model.fit(X_train, y_train, batch_size=128, epochs=3, \
verbose=1, validation_data=(X_test, y_test))
# 손실점수, 정확도
score = model.evaluate(X_test, y_test)
p(f'test loss : {score[0]}')
p(f'test accuracy : {score[1]}')
test loss: 0.0264~~ /손실률
test accuracy: 0.99129~ /정확도
# 예측값
predicted_result = model.predict(X_test)
predicted_labels = np.argmax(predicted_result, axis=1)
test_labels = np.argmax(y_test, axis=1)
p(test_labels)
count = 0
plt.figure(figsize=(12, 8))
for i in range(16):
count += 1
plt.subplot(4, 4, count)
plt.imshow(X_test[i].reshape(28, 28), cmap='Greys', interpolation='nearest')
tmp = 'Label : ' + str(test_labels[i]), ', prediction : ' + str(predicted_labels[i])
plt.title(tmp)
plt.tight_layout()
plt.show()
이후 예측값을 확인하고 데이터셋을 확인해보려고 합니다.
##이미지 분류 url
이미지분류
https://www.tensorflow.org/tutorials/keras/classification?hl=ko
## 텍스트 분류
텍스트분류
https://www.tensorflow.org/tutorials/keras/text_classification
이건 스스로 한 번 해보기!
'데이터 분석 및 시각화' 카테고리의 다른 글
[DL] CNN,RNN을 활용한 정확도, 예측도 확인하기 (0) | 2024.11.22 |
---|---|
[DL] basic _딥러닝 기본 (0) | 2024.09.14 |
[ML] 연관규칙 (1) | 2024.09.13 |
[ML]K-Means 클러스터링, DBSCAN(밀도기반 클러스터링) (0) | 2024.09.12 |
[ML]클러스터링_집값 상관관계 분석해보기 (0) | 2024.09.11 |