프로그래밍 공부

전체 글 700

카테고리 설명
프로그래밍 공부하는 블로그
  • ImageAiCon PP진행중Unreal의 ImageAI공부하기알고리즘 관련 강의 학습사전지식더보기https://inradestrt.tistory.com/680 경사도 사라짐 문제(Vanishing Gradient Problem) & LSTM & GRU경사도 사라짐 문제(Vanishing Gradient Problem)정의경사도 사라짐 문제는 딥러닝 모델을 훈련할 때, 역전파 과정에서 아웃풋 레이어의 에러값이 이전 레이어로 전달될 때기울기(Gradient)가 점점 작inradestrt.tistory.comhttps://inradestrt.tistory.com/681 임베딩 & Char-RNN임베딩 (Embedding)개념 임베딩은 머신러닝, 특히 자연어 처리 문제에서 데이터를 효율적으로 표현하기 위해 사..

  • 파라미터 저장tf.train.Chackpoint 클래스의 인자값으로 저장하고자 하는 tf.kears.Model 인스턴스와 전역 반복횟수를 지정해서 선언한다.ckpt = tf.train.Checkpoint(step=.tf.Variable(0), model=CNN_model) tf.train.ChackpointManager에 인자값으로 선언한 tf.train.Chackpoint 인스턴스와 중간 파라미터를 저장할 경로를 설정한다.ckpt_manager=tf.train.CheckpointManager(ckpt, directory=SAVER_DIR, max_to_keep=5) 파라미터를 저장하고자 하는 시점에 해당 시점의 전역 반복횟수를 인자값으로 선언한tf.train.ChackpointManager의 save ..

  • from __future__ import absolute_import, division, print_function, unicode_literalsfrom absl import appimport tensorflow as tfimport numpy as npimport osimport time# input 데이터와 input 데이터를 한글자씩 뒤로 민 target 데이터를 생성하는 utility 함수를 정의합니다.def split_input_target(chunk): input_text = chunk[:-1] target_text = chunk[1:] return input_text, target_text# 학습에 필요한 설정값들을 지정합니다.data_dir = tf.keras.utils.get_fi..

  • 임베딩 (Embedding)개념 임베딩은 머신러닝, 특히 자연어 처리 문제에서 데이터를 효율적으로 표현하기 위해 사용되는 기법이다.이는 고차원의 희소 벡터를 저차원의 밀집 벡터로 변환하여 단어 간의 유사성을 반영할 수 있도록한다. 임베딩은 One-Hot Encoding 을 보완하기 위해 생성된 것 이기 때문에,임베딩에 대해 알려면 One-Hot Encoding의 문제점 에 대해 알아야 한다.One-Hot Encoding 의 문제점 머신러닝에서 데이터를 표현하는 일반적인 방법 중 하나는 One-Hot Encoding이다. 그러나, 이 방법에는 몇 가지 문제가 있다. 데이터 표현형태가 Sparse하다.데이터 표현 형태가 희박(Sparse)하다는 문제점인데예를들어 10,000개의 단어사전에 있는 단어들 중 단..

  • 경사도 사라짐 문제(Vanishing Gradient Problem)정의경사도 사라짐 문제는 딥러닝 모델을 훈련할 때, 역전파 과정에서 아웃풋 레이어의 에러값이 이전 레이어로 전달될 때기울기(Gradient)가 점점 작아져서 거의 사라지는 현상을 말한다. 이는 특히 깊은 신경망이나 RNN(순환 신경망) 에서 두드러진다.RNN에서의 경사도 사라짐 문제RNN은 시간 축을 따라 시계열 데이터를 처리하는데,시간이 지남에 따라 초기 데이터의 영향력이 감소하여 장기적인 패턴을 학습하는 데 어려움을 겪는다. 이는 RNN이 장기 기억을 유지하지 못하고, 현재 시간과 가까운 데이터만을 고려하게 만들어 모델 성능을 저하시킨다.LSTM ( Long Short-Term Memory Networks )정의 및 목적LSTM은 R..

  • ImageAiCon PP진행중Unreal의 ImageAI공부하기알고리즘 관련 강의 학습사전지식더보기https://inradestrt.tistory.com/669 인공신경망(Artificial Neural Networks[ANN])퍼셉트론이전에 인공신경망의 개념을 제안하였지만, 개념적인 시도로써 공학적인 구현을 최초로 제안한 개념무려 1958년에 나온 논문이다. 퍼셉트론 은 생물학적 뉴런을 공학적인 구조로 변형inradestrt.tistory.comhttps://inradestrt.tistory.com/671 오토인코더(Autoencoder)오토인코더 는 대표적인 비지도 학습을 위한 인공신경망 구조 중 하나이다.비지도 학습은 어떤값을 예측하거나 분류하는 목적인 지도학습 과 는 다르게 데이터의 숨겨진 구조를..

작성일
2024. 6. 21. 02:35
작성자
WDmil
728x90

ImageAiCon PP

진행중

  1. Unreal의 ImageAI공부하기
    1. 알고리즘 관련 강의 학습

사전지식


결과물

https://inradestrt.tistory.com/682

 

TensworFlow 2.0을 이용한 Char-RNN구현

from __future__ import absolute_import, division, print_function, unicode_literalsfrom absl import appimport tensorflow as tfimport numpy as npimport osimport time# input 데이터와 input 데이터를 한글자씩 뒤로 민 target 데이터를 생성하

inradestrt.tistory.com

https://inradestrt.tistory.com/683

 

TensorFlow 2.0 파라미터 저장 & 불러오기

파라미터 저장tf.train.Chackpoint 클래스의 인자값으로 저장하고자 하는 tf.kears.Model 인스턴스와 전역 반복횟수를 지정해서 선언한다.ckpt = tf.train.Checkpoint(step=.tf.Variable(0), model=CNN_model) tf.train.Chackpoin

inradestrt.tistory.com


 

진행 예정 작업

  1. Unreal ImageRetargeting 코드제작
    1. 언리얼 함수 상으로 지정된 카메라의 타겟뷰를 이미지값으로 저장 반환하는 방식이 존재함.
    2. TCP방식으로 데이터 통신처리를 진행
    3. TensorFlow를 사용하여 전달받은 이미지로 학습 알고리즘 연산.
    4. 연산결과를 다시 언리얼로 전달하여 학습된 데이터를 갱신.
    5. 4번과 3번을 반복
  2. 학습결과확인 후 재학습
  3.  5와 6을 원하는 AI행동패턴이 나타날때까지 반복

목표

  1. TensorFlow를 사용하여 알고리즘이 동작하는지 직접적인 확인을 진행.
  2. TensorFlow 를 사용하지 않고, 스스로의 C++코드로 알고리즘 함수 구현부를 직접 제작하여 사용하는것
    (파이썬만으로 k means clustering를 구현하였을 때, 구현객체가 C++의 연산처리속도를 따라잡지 못하는 상황이 있었음)
  3. UI관련 제작방식은 C#으로, 함수부는 DLL파일로 포팅하여 언리얼 엔진에 집어넣기.

완료된 작업

 

Unreal의 ImageAI공부하기

  1. CNN알고리즘 다시 복기하기
  2. 알고리즘 선별(DQN)
728x90

'작업사항 정리 > UnrealC++' 카테고리의 다른 글

UnrealC++ PP 20240626_9  (0) 2024.06.26
UnrealC++ PP 20240624_8  (0) 2024.06.24
UnrealC++ PP 20240618_6  (0) 2024.06.18
UnrealC++ PP 20240614_5  (0) 2024.06.14
UnrealC++ PP 20240609_4  (1) 2024.06.09
카테고리
작성일
2024. 6. 21. 02:34
작성자
WDmil
728x90

파라미터 저장

  • tf.train.Chackpoint 클래스의 인자값으로 저장하고자 하는 tf.kears.Model 인스턴스와 전역 반복횟수를 지정해서 선언한다.
ckpt = tf.train.Checkpoint(step=.tf.Variable(0), model=CNN_model)

 

  • tf.train.ChackpointManager에 인자값으로 선언한 tf.train.Chackpoint 인스턴스와 중간 파라미터를 저장할 경로를 설정한다.
ckpt_manager=tf.train.CheckpointManager(ckpt, directory=SAVER_DIR, max_to_keep=5)

 

  • 파라미터를 저장하고자 하는 시점에 해당 시점의 전역 반복횟수를 인자값으로 선언한
    tf.train.ChackpointManager의 save 메소드를 호출한다.
ckpt_manager.save(chackpoint_number=ckpt.step)

 

  • tf.train.Chackpoint의 전역 반복 횟수 값(ckpt.step)을 매 반복마다 1씩 증가시킨다.
ckpt.step.assign_add(1)

파라미터 불러오기

  • tf.train.latest_checkpoint의 인자값으로 파라미터가 저장된 폴더 경로를 지정해서 가장 최근의 체크 포인트 파일의 경로(full path)를 가져온다.
lates_ckpt=tf.train.latest_checkpoint(SAVER_DIR)

 

  • 선언한 tf.train_CheckpointManager의 restore함수의 인자값으로 불러올 체크포인트 파일의 경로를 지정해서 파라미터 값을 복원한다.
ckpt.restore(latest_ckpt)

코드예시

import tensorflow as tf

# MNIST 데이터를 다운로드 합니다.
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
# 이미지들을 float32 데이터 타입으로 변경합니다.
x_train, x_test = x_train.astype('float32'), x_test.astype('float32')
# 28*28 형태의 이미지를 784차원으로 flattening 합니다.
x_train, x_test = x_train.reshape([-1, 784]), x_test.reshape([-1, 784])
# [0, 255] 사이의 값을 [0, 1]사이의 값으로 Normalize합니다.
x_train, x_test = x_train / 255., x_test / 255.
# 레이블 데이터에 one-hot encoding을 적용합니다.
y_train, y_test = tf.one_hot(y_train, depth=10), tf.one_hot(y_test, depth=10)

# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져옵니다.
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.repeat().shuffle(60000).batch(50)
train_data_iter = iter(train_data)

# tf.keras.Model을 이용해서 CNN 모델을 정의합니다.
class CNN(tf.keras.Model):
  def __init__(self):
    super(CNN, self).__init__()
    # 첫번째 Convolution Layer
    # 5x5 Kernel Size를 가진 32개의 Filter를 적용합니다.
    self.conv_layer_1 = tf.keras.layers.Conv2D(filters=32, kernel_size=5, strides=1, padding='same', activation='relu')
    self.pool_layer_1 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2)

    # 두번째 Convolutional Layer
    # 5x5 Kernel Size를 가진 64개의 Filter를 적용합니다.
    self.conv_layer_2 = tf.keras.layers.Conv2D(filters=64, kernel_size=5, strides=1, padding='same', activation='relu')
    self.pool_layer_2 = tf.keras.layers.MaxPool2D(pool_size=(2, 2), strides=2)

    # Fully Connected Layer
    # 7x7 크기를 가진 64개의 activation map을 1024개의 특징들로 변환합니다.
    self.flatten_layer = tf.keras.layers.Flatten()
    self.fc_layer_1 = tf.keras.layers.Dense(1024, activation='relu')

    # Output Layer
    # 1024개의 특징들(feature)을 10개의 클래스-one-hot encoding으로 표현된 숫자 0~9-로 변환합니다.
    self.output_layer = tf.keras.layers.Dense(10, activation=None)

  def call(self, x):
    # MNIST 데이터를 3차원 형태로 reshape합니다. MNIST 데이터는 grayscale 이미지기 때문에 3번째차원(컬러채널)의 값은 1입니다.
    x_image = tf.reshape(x, [-1, 28, 28, 1])
    # 28x28x1 -> 28x28x32
    h_conv1 = self.conv_layer_1(x_image)
    # 28x28x32 -> 14x14x32
    h_pool1 = self.pool_layer_1(h_conv1)
    # 14x14x32 -> 14x14x64
    h_conv2 = self.conv_layer_2(h_pool1)
    # 14x14x64 -> 7x7x64
    h_pool2 = self.pool_layer_2(h_conv2)
    # 7x7x64(3136) -> 1024
    h_pool2_flat = self.flatten_layer(h_pool2)
    h_fc1 = self.fc_layer_1(h_pool2_flat)
    # 1024 -> 10
    logits = self.output_layer(h_fc1)
    y_pred = tf.nn.softmax(logits)

    return y_pred, logits

# cross-entropy 손실 함수를 정의합니다.
@tf.function
def cross_entropy_loss(logits, y):
  return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y))

# 최적화를 위한 Adam 옵티마이저를 정의합니다.
optimizer = tf.optimizers.Adam(1e-4)

# 최적화를 위한 function을 정의합니다.
@tf.function
def train_step(model, x, y):
  with tf.GradientTape() as tape:
    y_pred, logits = model(x)
    loss = cross_entropy_loss(logits, y)
  gradients = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(gradients, model.trainable_variables))

# 모델의 정확도를 출력하는 함수를 정의합니다.
@tf.function
def compute_accuracy(y_pred, y):
  correct_prediction = tf.equal(tf.argmax(y_pred,1), tf.argmax(y,1))
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

  return accuracy

# Convolutional Neural Networks(CNN) 모델을 선언합니다.
CNN_model = CNN()

# tf.train.CheckpointManager를 이용해서 파라미터를 저장합니다.
SAVER_DIR = "./model"
ckpt = tf.train.Checkpoint(step=tf.Variable(0), model=CNN_model)
ckpt_manager = tf.train.CheckpointManager(
      ckpt, directory=SAVER_DIR, max_to_keep=5)
latest_ckpt = tf.train.latest_checkpoint(SAVER_DIR) # 불러오기 가장최근 알고리즘 학습값

# 만약 저장된 모델과 파라미터가 있으면 이를 불러오고 (Restore)
# Restored 모델을 이용해서 테스트 데이터에 대한 정확도를 출력하고 프로그램을 종료합니다.
if latest_ckpt:
  ckpt.restore(latest_ckpt)
  print("테스트 데이터 정확도 (Restored) : %f" % compute_accuracy(CNN_model(x_test)[0], y_test))
  exit()

# 10000 Step만큼 최적화를 수행합니다.
while int(ckpt.step) < (10000 + 1):
  # 50개씩 MNIST 데이터를 불러옵니다.
  batch_x, batch_y = next(train_data_iter)
  # 100 Step마다 training 데이터셋에 대한 정확도를 출력하고 tf.train.CheckpointManager를 이용해서 파라미터를 저장합니다.
  if ckpt.step % 100 == 0:
    ckpt_manager.save(checkpoint_number=ckpt.step)
    train_accuracy = compute_accuracy(CNN_model(batch_x)[0], batch_y)
    print("반복(Epoch): %d, 트레이닝 데이터 정확도: %f" % (ckpt.step, train_accuracy))
  # 옵티마이저를 실행해 파라미터를 한스텝 업데이트합니다.
  train_step(CNN_model, batch_x, batch_y)

  ckpt.step.assign_add(1)

# 학습이 끝나면 테스트 데이터에 대한 정확도를 출력합니다.
print("정확도(Accuracy): %f" % compute_accuracy(CNN_model(x_test)[0], y_test))

세이브 파일

 

세이브 파일을 생성하고 불러오는 부분만 리뷰한다.


세이브 파일 사전설정

# tf.train.CheckpointManager를 이용해서 파라미터를 저장합니다.
SAVER_DIR = "./model"
ckpt = tf.train.Checkpoint(step=tf.Variable(0), model=CNN_model)
ckpt_manager = tf.train.CheckpointManager(
      ckpt, directory=SAVER_DIR, max_to_keep=5)
latest_ckpt = tf.train.latest_checkpoint(SAVER_DIR) # 불러오기 가장최근 알고리즘 학습값

 

  • SAVER_DIR : 세이브 파일 경로설정
  • ckpt : Checkpoint의 핸들값 지정
    • step : 해당 번호위치부터. 0임으로 0번째부터 저장.
    • model : 저장하려는 모델 또는 불러오려는 모델
  • ckpet_manager : 저장하려는 디렉토리와 가장 최근에 얼마나 저장할것인지 지정
    • ckpt : 저장에 대한 핸들값
    • directory : 저장위치
    • max_to_keep : 가장 최근 저장값에서부터 몃번째까지 저장할 것 인지. 5임으로 5개의 모델데이터만 저장

스텝마다 저장

# 10000 Step만큼 최적화를 수행합니다.
while int(ckpt.step) < (10000 + 1):
  # 50개씩 MNIST 데이터를 불러옵니다.
  batch_x, batch_y = next(train_data_iter)
  # 100 Step마다 training 데이터셋에 대한 정확도를 출력하고 tf.train.CheckpointManager를 이용해서 파라미터를 저장합니다.
  if ckpt.step % 100 == 0:
    ckpt_manager.save(checkpoint_number=ckpt.step)
    train_accuracy = compute_accuracy(CNN_model(batch_x)[0], batch_y)
    print("반복(Epoch): %d, 트레이닝 데이터 정확도: %f" % (ckpt.step, train_accuracy))
  # 옵티마이저를 실행해 파라미터를 한스텝 업데이트합니다.
  train_step(CNN_model, batch_x, batch_y)

  ckpt.step.assign_add(1)

 

  • ckpt_manager.save() : 해당되는 checkpoint에 대한 이름과 경로로 학습데이터 저장

불러오기

# 만약 저장된 모델과 파라미터가 있으면 이를 불러오고 (Restore)
# Restored 모델을 이용해서 테스트 데이터에 대한 정확도를 출력하고 프로그램을 종료합니다.
if latest_ckpt:
  ckpt.restore(latest_ckpt)
  print("테스트 데이터 정확도 (Restored) : %f" % compute_accuracy(CNN_model(x_test)[0], y_test))
  exit()

 

  • latest_ckpt : 경로에 가장 최근의 저장알고리즘이 존재할 경우를 확인
  • ckpt.restore() : ckpt는 모델과 저장step의 핸들임으로, 여기에 저장된 알고리즘 핸들과 모델step을 덮어씌운다.
  • compute_accuracy(CNN_model(x_test[0], y_test)) : 지정된 학습 스텝으로 CNN을 돌린다.
728x90

'알고리즘' 카테고리의 다른 글

MP(Markov Process)  (0) 2024.06.24
강화학습  (0) 2024.06.23
TensworFlow 2.0을 이용한 Char-RNN구현  (0) 2024.06.20
임베딩 & Char-RNN  (0) 2024.06.18
경사도 사라짐 문제(Vanishing Gradient Problem) & LSTM & GRU  (0) 2024.06.18
카테고리
작성일
2024. 6. 20. 00:38
작성자
WDmil
728x90
from __future__ import absolute_import, division, print_function, unicode_literals

from absl import app
import tensorflow as tf

import numpy as np
import os
import time

# input 데이터와 input 데이터를 한글자씩 뒤로 민 target 데이터를 생성하는 utility 함수를 정의합니다.
def split_input_target(chunk):
  input_text = chunk[:-1]
  target_text = chunk[1:]

  return input_text, target_text

# 학습에 필요한 설정값들을 지정합니다.
data_dir = tf.keras.utils.get_file('shakespeare.txt', 'https://storage.googleapis.com/download.tensorflow.org/data/shakespeare.txt')  # shakespeare
#data_dir = './data/linux/input.txt'  # linux
batch_size = 64      # Training : 64, Sampling : 1
seq_length = 100     # Training : 100, Sampling : 1
embedding_dim = 256  # Embedding 차원
hidden_size = 1024   # 히든 레이어의 노드 개수
num_epochs = 10

# 학습에 사용할 txt 파일을 읽습니다.
text = open(data_dir, 'rb').read().decode(encoding='utf-8')
# 학습데이터에 포함된 모든 character들을 나타내는 변수인 vocab과
# vocab에 id를 부여해 dict 형태로 만든 char2idx를 선언합니다.
vocab = sorted(set(text))  # 유니크한 character 개수
vocab_size = len(vocab)
print('{} unique characters'.format(vocab_size))
char2idx = {u: i for i, u in enumerate(vocab)}
idx2char = np.array(vocab)

# 학습 데이터를 character에서 integer로 변환합니다.
text_as_int = np.array([char2idx[c] for c in text])

# split_input_target 함수를 이용해서 input 데이터와 input 데이터를 한글자씩 뒤로 민 target 데이터를 생성합니다.
char_dataset = tf.data.Dataset.from_tensor_slices(text_as_int)
sequences = char_dataset.batch(seq_length+1, drop_remainder=True)
dataset = sequences.map(split_input_target)

# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져옵니다.
dataset = dataset.shuffle(10000).batch(batch_size, drop_remainder=True)

# tf.keras.Model을 이용해서 RNN 모델을 정의합니다.
class RNN(tf.keras.Model):
 def __init__(self, batch_size):
   super(RNN, self).__init__()
   self.embedding_layer = tf.keras.layers.Embedding(vocab_size, embedding_dim,
                                                    batch_input_shape=[batch_size, None])
   self.hidden_layer_1 = tf.keras.layers.LSTM(hidden_size,
                                             return_sequences=True,
                                             stateful=True,
                                             recurrent_initializer='glorot_uniform')
   self.output_layer = tf.keras.layers.Dense(vocab_size)

 def call(self, x):
   embedded_input = self.embedding_layer(x)
   features = self.hidden_layer_1(embedded_input)
   logits = self.output_layer(features)

   return logits

# sparse cross-entropy 손실 함수를 정의합니다.
def sparse_cross_entropy_loss(labels, logits):
  return tf.reduce_mean(tf.keras.losses.sparse_categorical_crossentropy(labels, logits, from_logits=True))

# 최적화를 위한 Adam 옵티마이저를 정의합니다.
optimizer = tf.keras.optimizers.Adam()

# 최적화를 위한 function을 정의합니다.
@tf.function
def train_step(model, input, target):
  with tf.GradientTape() as tape:
    logits = model(input)
    loss = sparse_cross_entropy_loss(target, logits)
  grads = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  return loss

def generate_text(model, start_string):
  num_sampling = 4000  # 생성할 글자(Character)의 개수를 지정합니다.

  # start_sting을 integer 형태로 변환합니다.
  input_eval = [char2idx[s] for s in start_string]
  input_eval = tf.expand_dims(input_eval, 0)

  # 샘플링 결과로 생성된 string을 저장할 배열을 초기화합니다.
  text_generated = []

  # 낮은 temperature 값은 더욱 정확한 텍스트를 생성합니다.
  # 높은 temperature 값은 더욱 다양한 텍스트를 생성합니다.
  temperature = 1.0

  # 여기서 batch size = 1 입니다.
  model.reset_states()
  for i in range(num_sampling):
    predictions = model(input_eval)
    # 불필요한 batch dimension을 삭제합니다.
    predictions = tf.squeeze(predictions, 0)

    # 모델의 예측결과에 기반해서 랜덤 샘플링을 하기위해 categorical distribution을 사용합니다.
    predictions = predictions / temperature
    predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()

    # 예측된 character를 다음 input으로 사용합니다.
    input_eval = tf.expand_dims([predicted_id], 0)
    # 샘플링 결과를 text_generated 배열에 추가합니다.
    text_generated.append(idx2char[predicted_id])

  return (start_string + ''.join(text_generated))

def main(_):
  # Recurrent Neural Networks(RNN) 모델을 선언합니다.
  RNN_model = RNN(batch_size=batch_size)

  # 데이터 구조 파악을 위해서 예제로 임의의 하나의 배치 데이터 에측하고, 예측결과를 출력합니다.
  for input_example_batch, target_example_batch in dataset.take(1):
    example_batch_predictions = RNN_model(input_example_batch)
    print(example_batch_predictions.shape, "# (batch_size, sequence_length, vocab_size)")

  # 모델 정보를 출력합니다.
  RNN_model.summary()

  # checkpoint 데이터를 저장할 경로를 지정합니다.
  checkpoint_dir = './training_checkpoints'
  checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt_{epoch}")

  for epoch in range(num_epochs):
    start = time.time()

    # 매 반복마다 hidden state를 초기화합니다. (최초의 hidden 값은 None입니다.)
    hidden = RNN_model.reset_states()

    for (batch_n, (input, target)) in enumerate(dataset):
      loss = train_step(RNN_model, input, target)

      if batch_n % 100 == 0:
        template = 'Epoch {} Batch {} Loss {}'
        print(template.format(epoch+1, batch_n, loss))

    # 5회 반복마다 파라미터를 checkpoint로 저장합니다.
    if (epoch + 1) % 5 == 0:
      RNN_model.save_weights(checkpoint_prefix.format(epoch=epoch))

    print ('Epoch {} Loss {:.4f}'.format(epoch+1, loss))
    print ('Time taken for 1 epoch {} sec\n'.format(time.time() - start))

  RNN_model.save_weights(checkpoint_prefix.format(epoch=epoch))
  print("트레이닝이 끝났습니다!")

  sampling_RNN_model = RNN(batch_size=1)
  sampling_RNN_model.load_weights(tf.train.latest_checkpoint(checkpoint_dir))
  sampling_RNN_model.build(tf.TensorShape([1, None]))
  sampling_RNN_model.summary()

  # 샘플링을 시작합니다.
  print("샘플링을 시작합니다!")
  print(generate_text(sampling_RNN_model, start_string=u' '))

if __name__ == '__main__':
  # main 함수를 호출합니다.
  app.run(main)

 

 

동작 방식을 순서대로 대략 설명하면,

처음에 띄어쓰기 한개가 들어간다.

 

띄어쓰기 다음 단어에 가장 가까운 단어 한개를 출력한다.

그리고 그 단어에 가장 가까운 단어를 출력한다. 를 반복하면서 모든 문장을 생성하는 것이다.

 

이 결과로 완벽하지는 않지만, 셰익스피어 어투의 문장이 생성되는 것이다.

https://namu.wiki/w/%EC%A4%91%EA%B5%AD%EC%96%B4%20%EB%B0%A9

 

중국어 방

중국어 방 문제 또는 중국어 방 논변 (the "Chinese Room" argument)는 미국 의 철학자

namu.wiki

위 링크를 참고해서 읽어보면 대강 어떤느낌으로 문장이 생성되고 연결되는지 알 수 있다.


1. 데이터 준비 및 전처리

# input 데이터와 input 데이터를 한글자씩 뒤로 민 target 데이터를 생성하는 utility 함수를 정의합니다.
def split_input_target(chunk):
  input_text = chunk[:-1]
  target_text = chunk[1:]

  return input_text, target_text

# 학습에 필요한 설정값들을 지정합니다.
data_dir = tf.keras.utils.get_file('shakespeare.txt', 'https://storage.googleapis.com/download.tensorflow.org/data/shakespeare.txt')  # shakespeare
batch_size = 64      # Training : 64, Sampling : 1
seq_length = 100     # Training : 100, Sampling : 1
embedding_dim = 256  # Embedding 차원
hidden_size = 1024   # 히든 레이어의 노드 개수

# 학습에 사용할 txt 파일을 읽습니다.
text = open(data_dir, 'rb').read().decode(encoding='utf-8')
vocab = sorted(set(text))  # 유니크한 character 개수
vocab_size = len(vocab)
char2idx = {u: i for i, u in enumerate(vocab)}
idx2char = np.array(vocab)

# 학습 데이터를 character에서 integer로 변환합니다.
text_as_int = np.array([char2idx[c] for c in text])

# split_input_target 함수를 이용해서 input 데이터와 input 데이터를 한글자씩 뒤로 민 target 데이터를 생성합니다.
char_dataset = tf.data.Dataset.from_tensor_slices(text_as_int)
sequences = char_dataset.batch(seq_length+1, drop_remainder=True)
dataset = sequences.map(split_input_target)

# tf.data API를 이용해서 데이터를 섞고 batch 형태로 가져옵니다.
dataset = dataset.shuffle(10000).batch(batch_size, drop_remainder=True)

 

  • split_input_target 함수: 이 함수는 입력 시퀀스를 받아서 마지막 문자를 제외한 부분을 input_text로, 첫 번째 문자를 제외한 부분을 target_text로만든다. 이 함수는 데이터셋을 생성할 때 사용.
  • data_dir: 텍스트 파일의 경로나 URL을 지정하여 데이터를 가져온다.
    여기서는 셰익스피어의 작품을 다운로드 받는다.
  • text: 파일에서 읽은 데이터를 utf-8로 디코딩하여 전체 텍스트로 저장.
  • vocab: 텍스트에서 사용된 고유한 문자들의 집합을 정렬하여 저장.
  • char2idx와 idx2char: 각 문자를 해당 인덱스로 매핑하는 딕셔너리를 생성.
    이 딕셔너리는 텍스트를 정수 배열로 변환하거나 반대로 변환할 때 사용한다.
  • text_as_int: 전체 텍스트를 정수 배열로 변환하여 저장
    각 문자가 그에 해당하는 정수로 매핑된다. 키 Value값 형태로 기억하자
  • char_dataset과 sequences: tf.data API를 사용하여 정수 배열을 입력 데이터와 타겟 데이터로 나누어
    데이터셋을 생성.
    sequences는 입력과 타겟 시퀀스를 나누고, dataset은 데이터를 섞고 배치 형태로 준비.

2. 모델 정의

# tf.keras.Model을 이용해서 RNN 모델을 정의합니다.
class RNN(tf.keras.Model):
    def __init__(self, batch_size):
        super(RNN, self).__init__()
        self.embedding_layer = tf.keras.layers.Embedding(vocab_size, embedding_dim)
        self.hidden_layer_1 = tf.keras.layers.LSTM(hidden_size,
                                                   return_sequences=True,
                                                   stateful=True,
                                                   recurrent_initializer='glorot_uniform')
        self.output_layer = tf.keras.layers.Dense(vocab_size)

    def call(self, x):
        embedded_input = self.embedding_layer(x)
        features = self.hidden_layer_1(embedded_input)
        logits = self.output_layer(features)
        return logits
  • RNN 클래스: tf.keras.Model을 상속받아 RNN 모델을 정의

  • embedding_layer: Embedding 레이어로, 문자 인덱스를 임베딩 벡터로 변환

  • hidden_layer_1: LSTM 레이어로, 임베딩된 입력을 받아 시퀀스를 처리하고 hidden state를 유지

  • output_layer: 출력 레이어로, LSTM의 출력을 받아 각 문자의 다음 글자일 확률을 출력

  • call 함수: 입력 데이터 x를 받아 임베딩, LSTM, 출력 레이어를 순차적으로 적용하여 logits(확률 분포)를 반환

3. 손실 함수와 최적화

def sparse_cross_entropy_loss(labels, logits):
  return tf.reduce_mean(tf.keras.losses.sparse_categorical_crossentropy(labels, logits, from_logits=True))

optimizer = tf.keras.optimizers.Adam()

 

  • sparse_cross_entropy_loss : 희소 교차 엔트로피 손실 함수 정의.

  • optimizer : Adam 옵티마이저 정의.

4. 훈련 함수

# 최적화를 위한 function을 정의합니다.
@tf.function
def train_step(model, input, target):
  with tf.GradientTape() as tape:
    logits = model(input)
    loss = sparse_cross_entropy_loss(target, logits)
  grads = tape.gradient(loss, model.trainable_variables)
  optimizer.apply_gradients(zip(grads, model.trainable_variables))

  return loss

 

  • train_step : 훈련 단계를 정의.

  • model : 훈련할 모델.

  • input : 입력 데이터.

  • target : 목표 데이터.

  • tape : 그래디언트 계산을 위한 테이프.
  • grads : 계산된 그래디언트.

 


5. 텍스트 생성 함수

def generate_text(model, start_string):
  num_sampling = 4000  # 생성할 글자(Character)의 개수를 지정합니다.

  # start_sting을 integer 형태로 변환합니다.
  input_eval = [char2idx[s] for s in start_string]
  input_eval = tf.expand_dims(input_eval, 0)

  # 샘플링 결과로 생성된 string을 저장할 배열을 초기화합니다.
  text_generated = []

  # 낮은 temperature 값은 더욱 정확한 텍스트를 생성합니다.
  # 높은 temperature 값은 더욱 다양한 텍스트를 생성합니다.
  temperature = 1.0

  # 여기서 batch size = 1 입니다.
  model.reset_states()
  for i in range(num_sampling):
    predictions = model(input_eval)
    # 불필요한 batch dimension을 삭제합니다.
    predictions = tf.squeeze(predictions, 0)

    # 모델의 예측결과에 기반해서 랜덤 샘플링을 하기위해 categorical distribution을 사용합니다.
    predictions = predictions / temperature
    predicted_id = tf.random.categorical(predictions, num_samples=1)[-1,0].numpy()

    # 예측된 character를 다음 input으로 사용합니다.
    input_eval = tf.expand_dims([predicted_id], 0)
    # 샘플링 결과를 text_generated 배열에 추가합니다.
    text_generated.append(idx2char[predicted_id])

  return (start_string + ''.join(text_generated))
  • generate_text : 텍스트를 생성하는 함수.
  • num_sampling : 생성할 글자의 개수.
  • input_eval : 시작 문자열을 정수로 변환한 값.
  • text_generated : 생성된 텍스트를 저장할 리스트.
  • temperature : 텍스트 생성의 다양성을 조절하는 파라미터.
  • predicted_id : 예측된 다음 문자.

6. 메인 함수

def main(_):
  # Recurrent Neural Networks(RNN) 모델을 선언합니다.
  RNN_model = RNN(batch_size=batch_size)

  # 데이터 구조 파악을 위해서 예제로 임의의 하나의 배치 데이터 에측하고, 예측결과를 출력합니다.
  for input_example_batch, target_example_batch in dataset.take(1):
    example_batch_predictions = RNN_model(input_example_batch)
    print(example_batch_predictions.shape, "# (batch_size, sequence_length, vocab_size)")

  # 모델 정보를 출력합니다.
  RNN_model.summary()

  # checkpoint 데이터를 저장할 경로를 지정합니다.
  checkpoint_dir = './training_checkpoints'
  checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt_{epoch}")

  for epoch in range(num_epochs):
    start = time.time()

    # 매 반복마다 hidden state를 초기화합니다. (최초의 hidden 값은 None입니다.)
    hidden = RNN_model.reset_states()

    for (batch_n, (input, target)) in enumerate(dataset):
      loss = train_step(RNN_model, input, target)

      if batch_n % 100 == 0:
        template = 'Epoch {} Batch {} Loss {}'
        print(template.format(epoch+1, batch_n, loss))

    # 5회 반복마다 파라미터를 checkpoint로 저장합니다.
    if (epoch + 1) % 5 == 0:
      RNN_model.save_weights(checkpoint_prefix.format(epoch=epoch))

    print ('Epoch {} Loss {:.4f}'.format(epoch+1, loss))
    print ('Time taken for 1 epoch {} sec\n'.format(time.time() - start))

  RNN_model.save_weights(checkpoint_prefix.format(epoch=epoch))
  print("트레이닝이 끝났습니다!")

  sampling_RNN_model = RNN(batch_size=1)
  sampling_RNN_model.load_weights(tf.train.latest_checkpoint(checkpoint_dir))
  sampling_RNN_model.build(tf.TensorShape([1, None]))
  sampling_RNN_model.summary()

  # 샘플링을 시작합니다.
  print("샘플링을 시작합니다!")
  print(generate_text(sampling_RNN_model, start_string=u' '))

if __name__ == '__main__':
  # main 함수를 호출합니다.
  app.run(main)
  • main : 메인 함수.
  • RNN_model : 훈련할 RNN 모델.
  • example_batch_predictions : 예제 배치의 예측 결과.
  • checkpoint_dir : 체크포인트 저장 디렉터리.
  • checkpoint_prefix : 체크포인트 파일명 접두사.
  • start : 에포크 시작 시간.
  • hidden : 초기 hidden state.
  • sampling_RNN_model : 샘플링을 위한 RNN 모델.
728x90
카테고리
작성일
2024. 6. 18. 23:25
작성자
WDmil
728x90

임베딩 (Embedding)


개념

 

임베딩은 머신러닝, 특히 자연어 처리 문제에서 데이터를 효율적으로 표현하기 위해 사용되는 기법이다.

이는 고차원의 희소 벡터를 저차원의 밀집 벡터로 변환하여 단어 간의 유사성을 반영할 수 있도록한다.

 

임베딩은 One-Hot Encoding 을 보완하기 위해 생성된 것 이기 때문에,

임베딩에 대해 알려면 One-Hot Encoding의 문제점 에 대해 알아야 한다.


One-Hot Encoding 의 문제점

 

머신러닝에서 데이터를 표현하는 일반적인 방법 중 하나는 One-Hot Encoding이다. 그러나, 이 방법에는 몇 가지 문제가 있다.

 

  • 데이터 표현형태가 Sparse하다.

    데이터 표현 형태가 희박(Sparse)하다는 문제점인데
    예를들어 10,000개의 단어사전에 있는 단어들 중 단어 한개를 One-Hot Encoding으로 표현한다고 가정해보자,

    One-Hot Encoding으로 첫 번째 단어를 설정하면, 9999개의 숫자는 0으로 표현되고 1개의 숫자만 1로 표현될 것이다.
    9999개의 비트가 표시를 위해 낭비된다는 의미이다. 메모리 낭비가 심하다고 볼 수 있다.
  • 유사성 표현이 불가능하다.

    One-Hot Encoding자체의 방식때문에, 단어간의 유사성을 알아볼 수 없다.
    예를들어 우리는 하늘과 구름을 생각하면 두 단어간의 유사성을 생각할 수 있다. 하늘에 구름이 떠있기 때문,

    그러나, 인코딩 방식에 따르면 구름과 하늘은 전혀 다른 단어이고, 유사성을 발견할 수 없다. 좌표가 다르기 때문

위의 문제점을 해결하기 위해 임베딩이 고안되었다.


임베딩의 역할과 수식

 

임베딩은 이러한 문제점을 해결하기 위해 고안된 기법이다.
Sparse한 One-Hot Encoding벡터를 Dense한 벡터로 변환하여 효율적이고 의미있는 데이터 표현을 가능하게 한다.

 

임베딩은 원본 데이터에 임베딩 행렬(Embedding Matrix)을 곱하여 변환을 수행한다.

$ X_{embedding} = W_{embedding}X_{one-hot} $


예시

위에서 들었던 예시로 설명해보자.

 

10,000개의 단어 사전을 One-Hot Encoding으로 표현한 데이터에 10,000 x 250크기의 임베딩 행렬을 곱하여 임베딩을 수행한다고 해보자.

 

그렇다면, 다음과 같이 이야기할 수 있다.

  • One-Hot Encoding 벡터: 10,000 x 1크기
  • 임베딩 행렬 $ W_{embedding} $ : 10,000 x 250크기
  • 임베딩 벡터 $ X_{embedding} $ : 250 x1 크기

 

임베딩을 통해 10,000개의 비트를 사용하여 의미 정보를 담은 250개의 특징값 벡터로 변환한다. 이로써 유사한 단어끼리 묶을 수 있다.

임의의 벡터키값과 유사한 단어를 고를 수 있기 때문이다.

 

임베딩은 단어간 의미적 유사성을 반영하여 자연어 처리 모델에 어떠한 단어가 유사하고, 어떻게 배치해야하는지를 설명해줄 수 있게 해주기 때문에, 자연어 처리 모델의 성능을 향상시킨다.


Char-RNN


개념

Char-RNN은 RNN(Recurrent Neural Network)의 한 종류로, 입력값으로 하나의 글자(Character)을 받아 다음 글자를 예측하는 문제를 다룬다. 이 모델은 글자 단위로 학습하여 텍스트 생성과 같은 작업에 활용된다.


학습 데이터 구성 방법

Char-RNN을 학습시키기 위해, 입력 문장에서 한 글자씩 뒤로 민 형태의 데이터를 구성한다.

예를 들어 "HELLO" 라는 문장을 학습시키고 싶다면, RNN의 입력과 타겟 쌍을 다음과 같이 만든다.

  • 입력(H) -> 타겟(E)
  • 입력(E) -> 타겟(L)
  • 입력(L) -> 타겟(L)
  • 입력(L) -> 타겟(O)

이미지로 표현한 HELLO 생성과정


예측 과정

Char-RNN의 출력값은 학습에 사용하는 전체 문자 집합에 대한 소프트맥스 출력값이 된다.

 

예를 들어, 알파벳(26)개로 구성된 데이터셋 일 경우, 출력값은 26개의 알파벳 문자에 대한 확률 분포를 나타낸다.

가장 높은 확률을 가진 글자를 다음 글자로 예측하게 된다.

 

그리고, 정해진 문장을 달성할 때 까지 이를 반복한다.


Char-RNN의 출력값

Char-RNN의 출력값은 26 x 1크기의 벡터로, 각 요소는 해당 알파벳 문자가 다음에 나올 확률을 나타낸다.

 

이중 가장 확률이 높은 글자를 argmax함수로 선택하여 다음 글자로 확정한다.

 

Cahr-RNN은 텍스트 생성, 언어 모델링, 철자 교정 등 다양한 자연어 처리 작업에 활용된다.

글자 단위의 예측을 통해 유연하고 다양한 텍스트 생성이 가능하다.

728x90
카테고리
작성일
2024. 6. 18. 17:36
작성자
WDmil
728x90

경사도 사라짐 문제(Vanishing Gradient Problem)


정의

경사도 사라짐 문제는 딥러닝 모델을 훈련할 때, 역전파 과정에서 아웃풋 레이어의 에러값이 이전 레이어로 전달될 때

기울기(Gradient)가 점점 작아져서 거의 사라지는 현상을 말한다.

 

이는 특히 깊은 신경망이나 RNN(순환 신경망) 에서 두드러진다.


RNN에서의 경사도 사라짐 문제

RNN은 시간 축을 따라 시계열 데이터를 처리하는데,

시간이 지남에 따라 초기 데이터의 영향력이 감소하여 장기적인 패턴을 학습하는 데 어려움을 겪는다.

 

이는 RNN이 장기 기억을 유지하지 못하고, 현재 시간과 가까운 데이터만을 고려하게 만들어 모델 성능을 저하시킨다.


LSTM ( Long Short-Term Memory Networks )


정의 및 목적

LSTM은 RNN의 단점으 ㄹ보완하여 경사도 사라짐 문제를 해결하기 위해 제안된 발전된 RNN구조이다.

 

중요한 정보를 오랜 시간 동안 유지하고 필요하지 않은 정보를 잊어버리는 능력을 갖추고 있다.


LSTM의 구조

LSTM은 메모리블록(Memory Block)으로 구성되며, 각 블록은

인풋게이트(Input Gate), 포겟게이트(Forget Gate), 아웃풋 게이트(Output Gate) 로 이루어져 있다.

LSTM 전체구조

 

  • 인풋 게이트 (Input Gate): 현재 입력 데이터를 얼마나 반영할지 결정
  • 포겟 게이트 (Forget Gate): 이전 시간 단계에서 넘겨받은 정보를 얼마나 잊을지 결정
  • 블럭 인풋 게이트(Block Input Gate): 메모리 입력값에 활성 함수를 씌움
  • 아웃풋 게이트 (Output Gate): 현재 상태를 얼마나 출력할지 결정

LSTM의 연산구조.

은닉층의

아래쪽은 인풋 게이트,

왼쪽은 포겟 게이트,

위쪽은 아웃풋 게이트 를나타낸다.

 

또한

O는 게이트가 열린,

-는 게이트가 닫힌 상태 를 나타낸다.


LSTM의 수식

다음과 같은 수식을 통해 작동한다.

 

  • 인풋게이트
    $ a_{I}^{t} = \sum_{i=1}^{I}W_{iI}X_{i}^{t}\sum_{h=1}^{H}W_{hi}b_{h}^{t-1}+\sum_{c=1}^{C}W_{cI}s_{c}^{t-1} $
    • $ W_{iI} $: 입력 X와 인풋 게이트 간의 가중치 행렬.
    • $ b_{h}^{t-1} $: 이전 시점 t−1에서의 은닉 상태 h.
    • $ W_{hI} $: 이전 은닉 상태 h와 인풋 게이트 간의 가중치 행렬.
    • $ s_{c}^{t-1} $: 이전 시점 t−1에서 셀 상태 s
  • 포겟 게이트
    $ a_{F}^{t} = \sum_{i=1}^{I}W_{iF}X_{i}^{t}\sum_{h=1}^{H}W_{hF}b_{h}^{t-1}+\sum_{c=1}^{C}W_{cF}s_{c}^{t-1} $
  • 블럭 인풋 게이트
    $ a_{c}^{t} = \sum_{i=1}^{I}W_{ic}X_{i}^{t}\sum_{h=1}^{H}W_{hc}b_{h}^{t-1} $
  • 활성함수 g:
    $ g(a_{c}^{t}) = g(a_{c}^{t}) $

  • 아웃풋 게이트
    $ a_{O}^{t} = \sum_{i=1}^{I}W_{iO}X_{i}^{t}\sum_{h=1}^{H}W_{hO}b_{h}^{t-1}+\sum_{c=1}^{C}W_{cO}s_{c}^{t} $

 


GRU ( Grated Recurrent Unit )

LSTM의 간략화된 버전으로, 비슷한 성능을 유지하면서도 계산 비용을 줄이는것 을 목표로 한다.

 

GRU는 리셋 게이트(Reset Gate)와 업데이트 게이트(Update Gate)를 사용하여 데이터를 처리한다.


GRU의 구조

  • 리셋 게이트(Reset Gate): 현재 입력 데이터와 이전시간 단계의 출력값을 얼마나 반영할지 결정한다.
  • 업데이트 게이트(Update Gate) : 현재 시간 단계에서의 새로운 정보와 상태정보를 어떻게 결합할지 결정한다.
  • 메모리 블럭의 내부 셀 출력 h 

 


GRU의 수식

 

    • 리셋 게이트(Reset Gate) z
      $ z = \sigma (x_{t}U^{z} + s_{t-1}W^{z}) $
      • $ U^{z} $ : 입력 $ x_{t} $ 에 대한 가중치 행렬. 이는 입력 데이터와 리셋 게이트 간의 관계를 나타낸다.
      • $ W^{z} $ : 이전 은닉 상태 $ s_{t-1} $ 에 대한 가중치 행렬. 이는 이전의 은닉 상태와 리셋 게이트 간의 관계를 나타낸다.
    • 업데이트 게이트(Update Gate) r
      $ r = \sigma (x_{t}U^{r}+s_{t-1}W^{r}) $
      • $ U^{r} $ : 입력 $ x_{t} $ 에 대한 가중치 행렬. 이는 입력 데이터와 업데이트 게이트 간의 관계를 나타낸다.
      • $ W^{r} $ : 이전 은닉 상태 $ s_{t-1} $ 에 대한 가중치 행렬. 이는 이전의 은닉 상태와 업데이트 게이트 간의 관계를 나타낸다.
    • 메모리 블럭의 내부 셀 출력값 h
      $ h = tanh(x_{t}U^{h} +(s_{t-1}*r)W^{h}) $
      • $ x_{t} $ : 현재 시점 t에서의 입력벡터
      • $ s_{t-1} $ : 이전 시점 t-1 에서의 은닉상태 벡터
      • $ r $ : 리셋 게이트 벡터.
      • $ U^{h} $ : 입력 $x_{t}$ 에 대한 가중치 행렬.
      • $ W^{h} $: 리셋 게이트가 적용된 이전 은닉 상태 $ s_{t-1} $ 에 대한 가중치 행렬
      • $ tanh $ : 하이퍼볼릭 탄젠트 활성화 함수. 입력값을 -1과 1사이로 변환하여, 새로운 은닉상태의 비선형 변환을 수행한다.

GRU의 작동원리

 

      1. 리셋 게이트

        리셋게이트는 이전 상태의 정보를 얼마나 무시할 지를 결정한다.
        이는 새로운 정보가 현재 상태에 얼마나 영향을 미칠지를 제어한다.

        리셋 게이트가 0에 가까울 수록 이전 상태의 정보는 무시되고 1에 가까울 수록 이전 상태의 정보가 유지된다.

      2. 업데이트 게이트

        새로운 입력 정보와 기존 정보를 결합하여 현재 상태를 업데이트 한다.

        업데이트 게이트가 0에 가까울수록 새로운 입력정보가 무시되고, 1에 가까울수록 새로운 입력 정보가 크게 반영된다.

 

정리하면, GRU는 LSTM에서 출력 게이트를 제거하고, 인풋 게이트와 포겟 게이트의 역할을 업데이트 게이트와 리셋 게이트가 나눠가진 형태로 볼 수 있다.

 

보통 LSTM이 조금 더 강력한 성능을 보여주지만, GRU도 LSTM과 비슷한 성능을 보여주면서 연산량이 감소되었기 떄문에, 컴퓨팅 환경에 따라 LSTM대신 GRU를 사용하는것 도 좋다.

 

728x90
작성일
2024. 6. 18. 04:08
작성자
WDmil
728x90

ImageAiCon PP

진행중

  1. Unreal의 ImageAI공부하기
    1. 알고리즘 관련 강의 학습

사전지식

더보기

https://inradestrt.tistory.com/669

 

인공신경망(Artificial Neural Networks[ANN])

퍼셉트론이전에 인공신경망의 개념을 제안하였지만, 개념적인 시도로써 공학적인 구현을 최초로 제안한 개념무려 1958년에 나온 논문이다. 퍼셉트론 은 생물학적 뉴런을 공학적인 구조로 변형

inradestrt.tistory.com

https://inradestrt.tistory.com/671

 

오토인코더(Autoencoder)

오토인코더 는 대표적인 비지도 학습을 위한 인공신경망 구조 중 하나이다.비지도 학습은 어떤값을 예측하거나 분류하는 목적인 지도학습 과 는 다르게 데이터의 숨겨진 구조를 발견하는 것이

inradestrt.tistory.com

 

https://inradestrt.tistory.com/673

 

CNN기반 컴퓨터비전처리

컴퓨터 비전, 즉 컴퓨터가 이미지를 인식하고 이해하는 과정은 여러 가지 어려움이 있다. 밝기 변화사진을 찍는 환경에 따라 이미지의 밝기가 달라질 수 있다.예를 들어, 같은 물체라도 낮에 찍

inradestrt.tistory.com

https://inradestrt.tistory.com/674

 

컨볼루션(COnvolution), 풀링(Polling)

컨볼루션 신경망(CNN) 컨볼루션 신경망은 이미지 분야를 다루기에 최적화된 구조이다. 컨볼루선 신경망은 크게 컨볼루션층(COnvolution Layer)과 풀링층(Polling[Subsampling])Layer로 구성된다.풀링은 서브

inradestrt.tistory.com

https://inradestrt.tistory.com/676

 

드랍아웃(Dropout)

대표적인 Regulazation 기법이다. 오버피팅(OverFitting)을 방지할 수 있도록 만들어주는 기법을 총칭해서 Regularization기법 이라고 부른다. 드롭아웃(Dropout)은 대표적인 Regularization 기법 중 하나이다. 

inradestrt.tistory.com

https://inradestrt.tistory.com/678

 

순환신경망 (RNN)[Recurrent Neural Network]

순환신경망 (RNN)[Recurrent Neural Network]은 자연어 처리문제와 시계열 데이터를 다루기에 최적화된 인공신경망이다. 시계열 데이터시간 축을 중심으로 현재 시간의 데이터가 이전 및 이후 시간의

inradestrt.tistory.com

 

 

 

 


결과물

 

https://inradestrt.tistory.com/670

 

TensorFlow 2.0을 이용한 ANN MNIST 숫자분류기 구현

import tensorflow as tf# MNIST 데이터를 다운로드(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()x_train, x_test = x_train.astype('float32'), x_test.astype('float32')x_train, x_test = x_train.reshape([-1, 784]), x_test.resh

inradestrt.tistory.com

 

https://inradestrt.tistory.com/672

 

AutoEncoder를 사용한 MNIST 데이터 재구축

import tensorflow as tfimport numpy as npimport matplotlib.pyplot as plt# MNIST 데이터를 다운로드(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()x_train, x_test = x_train.astype('float32'), x_test.astype('float32')x_train,

inradestrt.tistory.com

https://inradestrt.tistory.com/675

 

CNN을 사용한 MNIST숫자분류기 구현

import tensorflow as tf# MNIST 데이터를 다운로드 합니다.(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()# 이미지들을 float32 데이터 타입으로 변경합니다.x_train, x_test = x_train.astype('float32'), x_tes

inradestrt.tistory.com

https://inradestrt.tistory.com/677

 

TensorFlow 2.0을 이용한 CIFAR-10 이미지 분류 CNN구현

CIFAR-10 데이터셋은 10개의 클래스, 50,000개의 traing images, 10,000 개의 testing images로 구성되어있다. 이미지크기 : 32x32x3 pixels(Color Image) 레이블 : airplane, automobile, bird, cat, deer, dog, frog, horse, ship, truck. 

inradestrt.tistory.com

 


진행 예정 작업

  1. Unreal ImageRetargeting 코드제작
    1. 언리얼 함수 상으로 지정된 카메라의 타겟뷰를 이미지값으로 저장 반환하는 방식이 존재함.
    2. TCP방식으로 데이터 통신처리를 진행
    3. TensorFlow를 사용하여 전달받은 이미지로 학습 알고리즘 연산.
    4. 연산결과를 다시 언리얼로 전달하여 학습된 데이터를 갱신.
    5. 4번과 3번을 반복
  2. 학습결과확인 후 재학습
  3.  5와 6을 원하는 AI행동패턴이 나타날때까지 반복

목표

  1. TensorFlow를 사용하여 알고리즘이 동작하는지 직접적인 확인을 진행.
  2. TensorFlow 를 사용하지 않고, 스스로의 C++코드로 알고리즘 함수 구현부를 직접 제작하여 사용하는것
    (파이썬만으로 k means clustering를 구현하였을 때, 구현객체가 C++의 연산처리속도를 따라잡지 못하는 상황이 있었음)
  3. UI관련 제작방식은 C#으로, 함수부는 DLL파일로 포팅하여 언리얼 엔진에 집어넣기.

완료된 작업

 

Unreal의 ImageAI공부하기

  1. CNN알고리즘 다시 복기하기
  2. 알고리즘 선별(DQN)
728x90

'작업사항 정리 > UnrealC++' 카테고리의 다른 글

UnrealC++ PP 20240624_8  (0) 2024.06.24
UnrealC++ PP 20240621_7  (0) 2024.06.21
UnrealC++ PP 20240614_5  (0) 2024.06.14
UnrealC++ PP 20240609_4  (1) 2024.06.09
UnrealC++ PP 20240606_3  (0) 2024.06.06