[TensorFlow] 아이리스 분류 예제와 함수 설명

이 예제에서는 케라스 대신 텐서플로우의 저수준 API를 사용하며, 크로스 엔트로피 손실 함수를 사용합니다. 아래는 전체 코드입니다.

기본 예제

import tensorflow as tf
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import OneHotEncoder
import numpy as np

# 아이리스 데이터 로드
iris = datasets.load_iris()
X = iris.data
y = iris.target.reshape(-1, 1)

# 원핫 인코딩
encoder = OneHotEncoder(sparse=False)
y = encoder.fit_transform(y)

# 표준화
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 파라미터
learning_rate = 0.01
num_epochs = 1000
batch_size = 32
display_step = 50

# 네트워크 구성
n_input = X_train.shape[1]
n_classes = y_train.shape[1]

# 입력과 레이블을 위한 플레이스홀더
X = tf.placeholder(tf.float32, [None, n_input])
Y = tf.placeholder(tf.float32, [None, n_classes])

# 가중치와 편향 변수
W = tf.Variable(tf.random.normal([n_input, n_classes]))
b = tf.Variable(tf.random.normal([n_classes]))

# 모델
logits = tf.add(tf.matmul(X, W), b)

# 손실 함수
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits, labels=Y))

# 최적화 알고리즘
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss)

# 변수 초기화
init = tf.global_variables_initializer()

# 모델 학습
with tf.Session() as sess:
    sess.run(init)

    for epoch in range(1, num_epochs + 1):
        avg_cost = 0
        total_batch = int(len(X_train) / batch_size)
        for i in range(total_batch):
            batch_x = X_train[i * batch_size: (i + 1) * batch_size]
            batch_y = y_train[i * batch_size: (i + 1) * batch_size]
            _, c = sess.run([optimizer, loss], feed_dict={X: batch_x, Y: batch_y})
            avg_cost += c / total_batch
        if epoch % display_step == 0:
            print(f"Epoch {epoch}/{num_epochs}, Loss: {avg_cost:.4f}")

    print("Optimization Finished!")

    # 테스트 모델
    correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(Y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    print("Accuracy:", accuracy.eval({X: X_test, Y: y_test}))

위 코드는 텐서플로우를 사용하여 아이리스 데이터를 분류하는 예제입니다. 이 예제에서는 로지스틱 회귀 모델을 사용하며, 크로스 엔트로피 손실 함수를 최소화하기 위해 경사 하강법을 사용하여 모델을 학습합니다. 결과적으로 모델의 정확도가 출력됩니다.

함수 설명

.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits, labels=Y))

tf.nn.softmax_cross_entropy_with_logits_v2의 시그니처

logits: 모델의 출력값 (일반적으로 형태는 [batch_size, num_classes]).
labels: 실제 클래스 레이블 (일반적으로 원-핫 인코딩된 형태, [batch_size, num_classes])

tf.reduce_mean의 시그니처

input_tensor: 입력 텐서로, 크로스 엔트로피 손실의 값이 들어갑니다.
axis (선택적): 평균을 계산할 축을 지정하는 매개변수입니다. 여기서는 생략하거나 None으로 설정하면 모든 요소의 평균을 계산합니다.
keepdims (선택적): 출력 텐서의 차원 유지 여부를 지정하는 매개변수입니다.

tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss)

tf.train.GradientDescentOptimizer의 시그니처

learning_rate: 학습률로, 파라미터 업데이트 단계에서 얼마나 크게 가중치와 편향을 조정할지 결정합니다.
minimize(loss) 함수는 최적화 동작을 수행하며, 해당 함수의 시그니처는 별도로 제공되지 않습니다. 이 함수는 주어진 손실을 최소화하기 위해 최적화 변수의 업데이트를 처리합니다.

tf.equal(tf.argmax(logits, 1), tf.argmax(Y, 1))

tf.argmax의 시그니처

input: 입력 텐서로, 최댓값을 찾을 텐서를 나타냅니다.
axis (선택적): 최댓값을 찾을 축을 지정합니다. 여기서는 1을 사용하여 각 데이터 포인트에 대한 최댓값을 찾습니다.
output_type (선택적): 결과 텐서의 데이터 타입을 지정합니다. 기본적으로 tf.int64입니다.

tf.equal의 시그니처

x: 비교할 첫 번째 텐서입니다.
y: 비교할 두 번째 텐서입니다.

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

이 부분은 모델의 정확도를 계산합니다.
correct_prediction은 각 데이터 포인트에 대한 예측이 맞았는지 여부를 나타내는 불리언(True/False) 값의 텐서입니다.
tf.cast(correct_prediction, "float")는 이 불리언 값을 0 또는 1로 변환하여 정확도를 계산합니다.
마지막으로, tf.reduce_mean을 사용하여 정확도를 모든 데이터 포인트에 대해 평균을 내어 계산합니다.

기본예제 케라스 사용

import tensorflow as tf
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import OneHotEncoder

# 아이리스 데이터 로드
iris = datasets.load_iris()
X = iris.data
y = iris.target.reshape(-1, 1)

# 원핫 인코딩
encoder = OneHotEncoder(sparse=False)
y = encoder.fit_transform(y)

# 표준화
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 생성
model = tf.keras.Sequential([
    tf.keras.layers.Dense(3, activation='softmax', input_shape=(X_train.shape[1],))
])

# 모델 컴파일
model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])

# 모델 학습
model.fit(X_train, y_train, epochs=1000, batch_size=32, verbose=1)

# 모델 평가
loss, accuracy = model.evaluate(X_test, y_test)
print(f'Test Loss: {loss:.4f}, Test Accuracy: {accuracy:.4f}')

히든레이어 추가 예제

import tensorflow as tf
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import OneHotEncoder
import numpy as np

# 아이리스 데이터 로드
iris = datasets.load_iris()
X = iris.data
y = iris.target.reshape(-1, 1)

# 원핫 인코딩
encoder = OneHotEncoder(sparse=False)
y = encoder.fit_transform(y)

# 표준화
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 파라미터
learning_rate = 0.01
num_epochs = 1000
batch_size = 32
display_step = 50

# 네트워크 구성
n_input = X_train.shape[1]
n_hidden = 256  # 히든 레이어의 뉴런 수
n_classes = y_train.shape[1]

# 입력과 레이블을 위한 플레이스홀더
X = tf.placeholder(tf.float32, [None, n_input])
Y = tf.placeholder(tf.float32, [None, n_classes])

# 가중치와 편향 변수
weights = {
    'hidden': tf.Variable(tf.random.normal([n_input, n_hidden])),
    'out': tf.Variable(tf.random.normal([n_hidden, n_classes]))
}
biases = {
    'hidden': tf.Variable(tf.random.normal([n_hidden])),
    'out': tf.Variable(tf.random.normal([n_classes]))
}

# 모델
def neural_net(x):
    # 히든 레이어의 활성화 함수: ReLU
    hidden_layer = tf.add(tf.matmul(x, weights['hidden']), biases['hidden'])
    hidden_layer = tf.nn.relu(hidden_layer)
    # 출력 레이어
    out_layer = tf.matmul(hidden_layer, weights['out']) + biases['out']
    return out_layer

# 손실 함수
logits = neural_net(X)
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=logits, labels=Y))

# 최적화 알고리즘
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss)

# 변수 초기화
init = tf.global_variables_initializer()

# 모델 학습
with tf.Session() as sess:
    sess.run(init)

    for epoch in range(1, num_epochs + 1):
        avg_cost = 0
        total_batch = int(len(X_train) / batch_size)
        for i in range(total_batch):
            batch_x = X_train[i * batch_size: (i + 1) * batch_size]
            batch_y = y_train[i * batch_size: (i + 1) * batch_size]
            _, c = sess.run([optimizer, loss], feed_dict={X: batch_x, Y: batch_y})
            avg_cost += c / total_batch
        if epoch % display_step == 0:
            print(f"Epoch {epoch}/{num_epochs}, Loss: {avg_cost:.4f}")

    print("Optimization Finished!")

    # 테스트 모델
    correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(Y, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    print("Accuracy:", accuracy.eval({X: X_test, Y: y_test}))

히든레이어 추가 케라스 버전

import tensorflow as tf
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import OneHotEncoder

# 아이리스 데이터 로드
iris = datasets.load_iris()
X = iris.data
y = iris.target.reshape(-1, 1)

# 원핫 인코딩
encoder = OneHotEncoder(sparse=False)
y = encoder.fit_transform(y)

# 표준화
scaler = StandardScaler()
X = scaler.fit_transform(X)

# 데이터 분할
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 모델 생성
model = tf.keras.Sequential([
    tf.keras.layers.Dense(256, activation='relu', input_shape=(X_train.shape[1],)),
    tf.keras.layers.Dense(3, activation='softmax')
])

# 모델 컴파일
model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])

# 모델 학습
model.fit(X_train, y_train, epochs=1000, batch_size=32, verbose=1)

# 모델 평가
loss, accuracy = model.evaluate(X_test, y_test)
print(f'Test Loss: {loss:.4f}, Test Accuracy: {accuracy:.4f}')

해당 게시글은 ChatGPT의 도움을 받아 작성되었습니다.