본문 바로가기
데이터 분석 및 시각화

[DL] 텐서플로우를 활용한 예제(손글씨, mnist활용)

by 바다의 공간 2024. 9. 15.

 

 

#텐서플로우 기본
# 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


텐서플로우 예제

https:/tensorflow.org

 

https://www.tensorflow.org/tutorials/keras/classification?hl=ko&_gl=1*1pn86bm*_up*MQ..*_ga*MTI4NTkyNTczLjE3MjU3Nzk3NDY.*_ga_W0YLR4190T*MTcyNTc3OTc0NS4xLjAuMTcyNTc3OTc1Ny4wLjAuMA..

튜토리얼을 보면 초보자,전문가를 위한 예제들이 나와있음.

 

지금해보려고 하는건 기본 이미지 분류(손글씨데이터셋)를 해보려고합니다.

 

# 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

 

기본 분류: 의류 이미지 분류  |  TensorFlow Core

기본 분류: 의류 이미지 분류 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. 이 튜토리얼에서는 운동화나 셔츠 같은 옷 이미지를 분류하는 신경망 모델을

www.tensorflow.org

 

 

## 텍스트 분류

텍스트분류
https://www.tensorflow.org/tutorials/keras/text_classification

 

영화 리뷰를 사용한 텍스트 분류  |  TensorFlow Core

영화 리뷰를 사용한 텍스트 분류 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. 이 튜토리얼은 디스크에 저장된 일반 텍스트 파일에서 시작하는 텍스트 분

www.tensorflow.org

 

이건 스스로 한 번 해보기!