텐서플로(Tensorflow)로 배우는 딥러닝

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

tf.__version__  # 사용한 텐서플로 버전 확인

# 월별 평균기온을 시각화 하기
temp = [5.2, 5.7, 8.6, 14.9, 18.2, 20.4, 25.5, 26.4, 22.8, 17.5, 11.1, 6.6]
plt.plot(temp, "o-")

# Placeholder x를 정의한다.
x = tf.placeholder(tf.float32, [None, 5])
# Variable w를 정의한다.
w = tf.Variable(tf.zeros([5, 1]))
# 계산식 y를 정의한다.
y = tf.matmul(x, w)
# Placeholder t를 정의한다.
t = tf.placeholder(tf.float32, [None, 1])
# 오차 함수 loss를 정의한다.
loss = tf.reduce_sum(tf.square(y - t))
# 트레이닝 알고리즘 train_step을 정의한다.
# AdamOptimizer는 트레이닝 알고리즘 중 한 종류
train_step = tf.train.AdamOptimizer().minimize(loss)
# 세션을 준비하고 Variable을 초기화한다.
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# 트레이닝 세트 데이터를 준비한다.
train_t = np.array([5.2, 5.7, 8.6, 14.9, 18.2, 20.4, 25.5, 26.4, 22.8, 17.5, 11.1, 6.6])
train_t = train_t.reshape([12, 1])
train_x = np.zeros([12, 5])
for row, month in enumerate(range(1, 13)):
    for col, n in enumerate(range(0, 5)):
        train_x[row][col] = month**n
# 경사 하강법을 이용한 파라미터 최적화를 100000회 반복한다.
i = 0
for _ in range(100000):
    i += 1
    sess.run(train_step, feed_dict={x: train_x, t: train_t})
    if i % 20000 == 0:
        loss_val = sess.run(loss, feed_dict={x: train_x, t: train_t})
        print("Step: %d, Loss: %f" % (i, loss_val))

# 트레이닝 후 파라미터 값을 확인한다.
w_val = sess.run(w)
print("파라미터 값 : ", w_val)


# 트레이닝 후 파라미터를 이용해 예측기온을 계산하는 함수를 정의한다.
def predict(x):
    result = 0.0
    for n in range(0, 5):
        result += w_val[n][0] * x**n
    return result


# 예측기온 그래프를 그린다.
fig = plt.figure()
subplot = fig.add_subplot(1, 1, 1)
subplot.set_xlim(1, 12)
subplot.scatter(range(1, 13), train_t)
linex = np.linspace(1, 12, 100)
liney = predict(linex)
subplot.plot(linex, liney, color="b")
plt.show()

# 필요한 라이브러리를 불러옵니다.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from numpy.random import multivariate_normal, permutation
import pandas as pd
from pandas import DataFrame

# 트레이닝 데이터를 준비한다.
np.random.seed(20180311)  # 난수 생성

n0, mu0, variance0 = 20, [10, 11], 20
data0 = multivariate_normal(mu0, np.eye(2) * variance0, n0)
df0 = DataFrame(data0, columns=["x1", "x2"])
df0["t"] = 0  # 비감염자 데이터

n1, mu1, variance1 = 15, [18, 20], 22
data1 = multivariate_normal(mu1, np.eye(2) * variance1, n1)
df1 = DataFrame(data1, columns=["x1", "x2"])
df1["t"] = 1  # 감염자 데이터

df = pd.concat([df0, df1], ignore_index=True)
train_set = df.reindex(permutation(df.index)).reset_index(drop=True)
train_set.head()  # 트레이닝 데이터 확인

fig = plt.figure(figsize=(6, 6))
subplot = fig.add_subplot(1, 1, 1)
subplot.set_ylim([0, 30])
subplot.set_xlim([0, 30])
subplot.scatter(df1.x1, df1.x2, marker="x", label="Infected")
subplot.scatter(df0.x1, df0.x2, marker="o", label="Normal")
plt.legend()
plt.show()

train_x = train_set[["x1", "x2"]].as_matrix()
train_t = train_set["t"].as_matrix().reshape([len(train_set), 1])

#  트레이닝 세트 데이터에 대해 t=1일 확률을 구하는 계산식 p를 준비한다.
x = tf.placeholder(tf.float32, [None, 2])
w = tf.Variable(tf.zeros([2, 1]))
w0 = tf.Variable(tf.zeros([1]))
f = tf.matmul(x, w) + w0
p = tf.sigmoid(f)  # 로지스틱 회귀
# 오차 함수 loss와 트레이닝 알고리즘 train_step을 정의한다.
t = tf.placeholder(tf.float32, [None, 1])
loss = -tf.reduce_sum(t * tf.log(p) + (1 - t) * tf.log(1 - p))
train_step = tf.train.AdamOptimizer().minimize(loss)  # 최우추정법
# 정답률 accuracy를 정의한다.
correct_prediction = tf.equal(tf.sign(p - 0.5), tf.sign(t - 0.5))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 세션을 준비하고 Variable을 초기화한다.
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# 경사 하강법에 의한 파라미터 최적화를 20000회 반복한다.
i = 0
for _ in range(20000):
    i += 1
    sess.run(train_step, feed_dict={x: train_x, t: train_t})
    if i % 4000 == 0:
        loss_val, acc_val = sess.run(
            [loss, accuracy], feed_dict={x: train_x, t: train_t}
        )
        print("Step: %d, Loss: %f, Accuracy: %f" % (i, loss_val, acc_val))

w0_val, w_val = sess.run([w0, w])
w0_val, w1_val, w2_val = w0_val[0], w_val[0][0], w_val[1][0]
print("파라미터의 값: ", w0_val, w1_val, w2_val)
#  추출한 파라미터 값을 이용해 결과를 그래프로 출력한다.
train_set0 = train_set[train_set["t"] == 0]
train_set1 = train_set[train_set["t"] == 1]

fig = plt.figure(figsize=(6, 6))
subplot = fig.add_subplot(1, 1, 1)
subplot.set_ylim([0, 30])
subplot.set_xlim([0, 30])
subplot.scatter(train_set1.x1, train_set1.x2, marker="x")
subplot.scatter(train_set0.x1, train_set0.x2, marker="o")

linex = np.linspace(0, 30, 10)
liney = -(w1_val * linex / w2_val + w0_val / w2_val)  # 경계선 그리기
subplot.plot(linex, liney)

field = [
    [
        (1 / (1 + np.exp(-(w0_val + w1_val * x1 + w2_val * x2))))
        for x1 in np.linspace(0, 30, 100)
    ]
    for x2 in np.linspace(0, 30, 100)
]
subplot.imshow(
    field, origin="lower", extent=(0, 30, 0, 30), cmap=plt.cm.gray_r, alpha=0.5
)
plt.show()

# 트레이닝 데이터 준비
n0, mu0, variance0 = 800, [10, 11], 20
data0 = multivariate_normal(mu0, np.eye(2) * variance0, n0)
df0 = DataFrame(data0, columns=["x", "y"])
df0["t"] = 0
n1, mu1, variance1 = 600, [18, 20], 22
data1 = multivariate_normal(mu1, np.eye(2) * variance1, n1)
df1 = DataFrame(data1, columns=["x", "y"])
df1["t"] = 1
df = pd.concat([df0, df1], ignore_index=True)
df = df.reindex(permutation(df.index)).reset_index(drop=True)
# 트레이닝 세트 데이터에서 20%의 데이터를 테스트 세트로 분리한다.
num_data = int(len(df) * 0.8)
train_set = df[:num_data]
test_set = df[num_data:]
# (x, y)와 t를 각각 모은 것을 NumPy의 array 오브젝트로 추출해둔다.
train_x = train_set[["x", "y"]].as_matrix()
train_t = train_set["t"].as_matrix().reshape([len(train_set), 1])
test_x = test_set[["x", "y"]].as_matrix()
test_t = test_set["t"].as_matrix().reshape([len(test_set), 1])
# 각종 계산식을 정의한다.
x = tf.placeholder(tf.float32, [None, 2])
w = tf.Variable(tf.zeros([2, 1]))
w0 = tf.Variable(tf.zeros([1]))
f = tf.matmul(x, w) + w0
p = tf.sigmoid(f)
t = tf.placeholder(tf.float32, [None, 1])
loss = -tf.reduce_sum(t * tf.log(p) + (1 - t) * tf.log(1 - p))
train_step = tf.train.AdamOptimizer().minimize(loss)
correct_prediction = tf.equal(tf.sign(p - 0.5), tf.sign(t - 0.5))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
# 세션을 준비하고 Variable을 초기화한다.
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# 경사 하강법에 의한 파라미터 최적화를 2500회 반복하면서 트레이닝 세트와 테스트 세트에 대한 정답률 변화를 기록한다.
train_accuracy = []
test_accuracy = []
for _ in range(2500):
    sess.run(train_step, feed_dict={x: train_x, t: train_t})
    acc_val = sess.run(accuracy, feed_dict={x: train_x, t: train_t})
    train_accuracy.append(acc_val)
    acc_val = sess.run(accuracy, feed_dict={x: test_x, t: test_t})
    test_accuracy.append(acc_val)
# 결과를 그래프로 출력한다.
fig = plt.figure(figsize=(8, 6))
subplot = fig.add_subplot(1, 1, 1)
subplot.plot(
    range(len(train_accuracy)), train_accuracy, linewidth=2, label="Training set"
)
subplot.plot(range(len(test_accuracy)), test_accuracy, linewidth=2, label="Test set")
subplot.legend(loc="upper left")

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from numpy.random import multivariate_normal, permutation
import pandas as pd
from pandas import DataFrame

# 난수를 생성한다.
np.random.seed(20180311)
tf.set_random_seed(20180311)


# 트레이닝 세트 데이터를 생성한다.
def generate_datablock(n, mu, var, t):
    data = multivariate_normal(mu, np.eye(2) * var, n)
    df = DataFrame(data, columns=["x1", "x2"])
    df["t"] = t
    return df


df0 = generate_datablock(15, [7, 7], 22, 0)
df1 = generate_datablock(15, [22, 7], 22, 0)
df2 = generate_datablock(10, [7, 22], 22, 0)
df3 = generate_datablock(25, [20, 20], 22, 1)

df = pd.concat([df0, df1, df2, df3], ignore_index=True)
train_set = df.reindex(permutation(df.index)).reset_index(drop=True)

# (x1, x2)와 t를 각각 모은 것을 NumPy의 array 오브젝트로 추출해둔다.
train_x = train_set[["x1", "x2"]].as_matrix()
train_t = train_set["t"].as_matrix().reshape([len(train_set), 1])

df.tail()  # 생성된 트레이닝 데이터를 확인합니다.

#  단층 신경망을 이용한 이항 분류기 모델을 정의한다.
num_units = 2
mult = train_x.flatten().mean()
x = tf.placeholder(tf.float32, [None, 2])
w1 = tf.Variable(tf.truncated_normal([2, num_units]))
b1 = tf.Variable(tf.zeros([num_units]))
hidden1 = tf.nn.tanh(tf.matmul(x, w1) + b1 * mult)  # 활성화 함수를 하이퍼볼릭 탄젠트로
w0 = tf.Variable(tf.zeros([num_units, 1]))
b0 = tf.Variable(tf.zeros([1]))
p = tf.nn.sigmoid(tf.matmul(hidden1, w0) + b0 * mult)

# 오차 함수 loss, 트레이닝 알고리즘 train_step, 정답률 accuracy를 정의한다.
t = tf.placeholder(tf.float32, [None, 1])
loss = -tf.reduce_sum(t * tf.log(p) + (1 - t) * tf.log(1 - p))
# 지금까지 이용했던 Adamoptimizer대신 GradientDescentOptimzer를 사용했다.
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.sign(p - 0.5), tf.sign(t - 0.5))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 세션을 준비하고 Variable을 초기화한다.
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())

# 파라미터 최적화를 1000회 반복한다.
i = 0
for _ in range(1000):
    i += 1
    sess.run(train_step, feed_dict={x: train_x, t: train_t})
    if i % 200 == 0:
        loss_val, acc_val = sess.run(
            [loss, accuracy], feed_dict={x: train_x, t: train_t}
        )
        print("Step: {}, Loss: {}, Accuracy: {}".format(i, loss_val, acc_val))

# 시각화 함수를 만들어 재사용합니다.
def make_plot():
    train_set1 = train_set[train_set["t"] == 1]
    train_set2 = train_set[train_set["t"] == 0]
    fig = plt.figure(figsize=(6, 6))
    subplot = fig.add_subplot(1, 1, 1)
    subplot.set_ylim([0, 30])
    subplot.set_xlim([0, 30])
    subplot.scatter(train_set1.x1, train_set1.x2, marker="x")
    subplot.scatter(train_set2.x1, train_set2.x2, marker="o")
    locations = []
    for x2 in np.linspace(0, 30, 100):
        for x1 in np.linspace(0, 30, 100):
            locations.append((x1, x2))
    p_vals = sess.run(p, feed_dict={x: locations})
    p_vals = p_vals.reshape((100, 100))
    subplot.imshow(
        p_vals, origin="lower", extent=(0, 30, 0, 30), cmap=plt.cm.gray_r, alpha=0.5
    )  # 얻어진 확률을 색의 농담으로 그림에 표시한다.


make_plot()

# (x1, x2)와 t를 각각 모은 것을 NumPy의 array 오브젝트로 추출해둔다.
train_x = train_set[["x1", "x2"]].as_matrix()
train_t = train_set["t"].as_matrix().reshape([len(train_set), 1])

#  단층 신경망을 이용한 이항 분류기 모델을 정의한다.
num_units = 4  # 노드의 개수를 4개로 변경
mult = train_x.flatten().mean()
x = tf.placeholder(tf.float32, [None, 2])
w1 = tf.Variable(tf.truncated_normal([2, num_units]))
b1 = tf.Variable(tf.zeros([num_units]))
hidden1 = tf.nn.tanh(tf.matmul(x, w1) + b1 * mult)
w0 = tf.Variable(tf.zeros([num_units, 1]))
b0 = tf.Variable(tf.zeros([1]))
p = tf.nn.sigmoid(tf.matmul(hidden1, w0) + b0 * mult)

# 오차 함수 loss, 트레이닝 알고리즘 train_step, 정답률 accuracy를 정의한다.
t = tf.placeholder(tf.float32, [None, 1])
loss = -tf.reduce_sum(t * tf.log(p) + (1 - t) * tf.log(1 - p))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.sign(p - 0.5), tf.sign(t - 0.5))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 세션을 준비하고 Variable을 초기화한다.
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())

# 파라미터 최적화를 1000회 반복한다.
i = 0
for _ in range(1000):
    i += 1
    sess.run(train_step, feed_dict={x: train_x, t: train_t})
    if i % 1000 == 0:
        loss_val, acc_val = sess.run(
            [loss, accuracy], feed_dict={x: train_x, t: train_t}
        )
        print("Step: {}, Loss: {}, Accuracy: {}".format(i, loss_val, acc_val))

# 시각화 하기
make_plot()

#  단층 신경망을 이용한 이항 분류기 모델을 정의한다.
num_units = 2
mult = train_x.flatten().mean()
x = tf.placeholder(tf.float32, [None, 2])
w1 = tf.Variable(tf.truncated_normal([2, num_units]))
b1 = tf.Variable(tf.zeros([num_units]))
hidden1 = tf.nn.relu(tf.matmul(x, w1) + b1 * mult)  # 활성화 함수를 ReLU로 변경한다.
w0 = tf.Variable(tf.zeros([num_units, 1]))
b0 = tf.Variable(tf.zeros([1]))
p = tf.nn.sigmoid(tf.matmul(hidden1, w0) + b0 * mult)

# 오차 함수 loss, 트레이닝 알고리즘 train_step, 정답률 accuracy를 정의한다.
t = tf.placeholder(tf.float32, [None, 1])
loss = -tf.reduce_sum(t * tf.log(p) + (1 - t) * tf.log(1 - p))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.sign(p - 0.5), tf.sign(t - 0.5))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 세션을 준비하고 Variable을 초기화한다.
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())

# 파라미터 최적화를 1000회 반복한다.
i = 0
for _ in range(1000):
    i += 1
    sess.run(train_step, feed_dict={x: train_x, t: train_t})
    if i % 1000 == 0:
        loss_val, acc_val = sess.run(
            [loss, accuracy], feed_dict={x: train_x, t: train_t}
        )
        print("Step: {}, Loss: {}, Accuracy: {}".format(i, loss_val, acc_val))

# 시각화하기
make_plot()

def generate_datablock(n, mu, var, t):
    data = multivariate_normal(mu, np.eye(2) * var, n)
    df = DataFrame(data, columns=["x1", "x2"])
    df["t"] = t
    return df


df0 = generate_datablock(30, [-7, -7], 18, 1)
df1 = generate_datablock(30, [-7, 7], 18, 0)
df2 = generate_datablock(30, [7, -7], 18, 0)
df3 = generate_datablock(30, [7, 7], 18, 1)

df = pd.concat([df0, df1, df2, df3], ignore_index=True)
train_set = df.reindex(permutation(df.index)).reset_index(drop=True)

train_set1 = train_set[train_set["t"] == 1]
train_set2 = train_set[train_set["t"] == 0]

fig = plt.figure(figsize=(6, 6))
subplot = fig.add_subplot(1, 1, 1)
subplot.set_ylim([-15, 15])
subplot.set_xlim([-15, 15])
subplot.scatter(train_set1.x1, train_set1.x2, marker="x")
subplot.scatter(train_set2.x1, train_set2.x2, marker="o")

# (x1, x2)와 t를 각각 모은 것을 NumPy의 array 오브젝트로 추출해둔다.
train_x = train_set[["x1", "x2"]].as_matrix()
train_t = train_set["t"].as_matrix().reshape([len(train_set), 1])

# 2계층 신경망을 이용한 이항 분류기 모델을 정의한다.
num_units1 = 2
num_units2 = 2

x = tf.placeholder(tf.float32, [None, 2])
w1 = tf.Variable(tf.truncated_normal([2, num_units1]))
b1 = tf.Variable(tf.zeros([num_units1]))
hidden1 = tf.nn.tanh(tf.matmul(x, w1) + b1)
w2 = tf.Variable(tf.truncated_normal([num_units1, num_units2]))
b2 = tf.Variable(tf.zeros([num_units2]))
hidden2 = tf.nn.tanh(tf.matmul(hidden1, w2) + b2)
w0 = tf.Variable(tf.zeros([num_units2, 1]))
b0 = tf.Variable(tf.zeros([1]))
p = tf.nn.sigmoid(tf.matmul(hidden2, w0) + b0)

# 오차 함수 loss, 트레이닝 알고리즘 train_step, 정답률 accuracy를 정의한다.
t = tf.placeholder(tf.float32, [None, 1])
loss = -tf.reduce_sum(t * tf.log(p) + (1 - t) * tf.log(1 - p))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.sign(p - 0.5), tf.sign(t - 0.5))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 세션을 준비하고 Variable을 초기화한다.
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())

# 파라미터 최적화를 3000회 반복한다.
i = 0
for _ in range(5000):
    i += 1
    sess.run(train_step, feed_dict={x: train_x, t: train_t})
    if i % 1000 == 0:
        loss_val, acc_val = sess.run(
            [loss, accuracy], feed_dict={x: train_x, t: train_t}
        )
        print("Step: %d, Loss: %f, Accuracy: %f" % (i, loss_val, acc_val))

# 얻어진 확률을 색의 농담으로 그림에 표시한다.
train_set1 = train_set[train_set["t"] == 1]
train_set2 = train_set[train_set["t"] == 0]

fig = plt.figure(figsize=(6, 6))
subplot = fig.add_subplot(1, 1, 1)
subplot.set_ylim([-15, 15])
subplot.set_xlim([-15, 15])
subplot.scatter(train_set1.x1, train_set1.x2, marker="x")
subplot.scatter(train_set2.x1, train_set2.x2, marker="o")

locations = []
for x2 in np.linspace(-15, 15, 100):
    for x1 in np.linspace(-15, 15, 100):
        locations.append((x1, x2))
p_vals = sess.run(p, feed_dict={x: locations})
p_vals = p_vals.reshape((100, 100))
subplot.imshow(
    p_vals, origin="lower", extent=(-15, 15, -15, 15), cmap=plt.cm.gray_r, alpha=0.5
)

# 필요한 라이브러리를 불러오고 난수의 시드를 설정한다.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.examples.tutorials.mnist import input_data

np.random.seed(20180312)
tf.set_random_seed(20180312)

# MNIST 데이터 세트를 준비한다.

mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)

# 필터에 해당하는 Variable을 준비하고 입력 데이터에 필터와 풀링 계층을 적용하는 계산식을 정의한다.
num_filters = 16  # 사용할 필터의수 임의의 숫자
x = tf.placeholder(tf.float32, [None, 784])
x_image = tf.reshape(x, [-1, 28, 28, 1])
W_conv = tf.Variable(tf.truncated_normal([5, 5, 1, num_filters], stddev=0.1))
h_conv = tf.nn.conv2d(x_image, W_conv, strides=[1, 1, 1, 1], padding="SAME")
h_pool = tf.nn.max_pool(
    h_conv, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME"
)

# 풀링 계층의 출력을 전 결합층을 경유해서 소프트맥스 함수로 입력하는 계산식을 정의한다.
h_pool_flat = tf.reshape(h_pool, [-1, 14 * 14 * num_filters])
num_units1 = 14 * 14 * num_filters
num_units2 = 1024

w2 = tf.Variable(tf.truncated_normal([num_units1, num_units2]))
b2 = tf.Variable(tf.zeros([num_units2]))
hidden2 = tf.nn.relu(tf.matmul(h_pool_flat, w2) + b2)

w0 = tf.Variable(tf.zeros([num_units2, 10]))
b0 = tf.Variable(tf.zeros([10]))
p = tf.nn.softmax(tf.matmul(hidden2, w0) + b0)

# 오차 함수 loss, 트레이닝 알고리즘 train_step, 정답률 accuracy를 정의한다.
t = tf.placeholder(tf.float32, [None, 10])
loss = -tf.reduce_sum(t * tf.log(p))
train_step = tf.train.AdamOptimizer(0.0005).minimize(loss)
correct_prediction = tf.equal(tf.argmax(p, 1), tf.argmax(t, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 세션을 준비하고 Variable을 초기화한다.
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())

# 파라미터 최적화를 4000회 반복한다.
i = 0
for _ in range(4000):
    i += 1
    batch_xs, batch_ts = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, t: batch_ts})
    if i % 1000 == 0:
        loss_val, acc_val = sess.run(
            [loss, accuracy], feed_dict={x: mnist.test.images, t: mnist.test.labels}
        )
        print("Step: %d, Loss: %f, Accuracy: %f" % (i, loss_val, acc_val))

# 합성곱 필터의 값과 최초 9개의 이미지 데이터에 대해 합성곱 필터와 풀링 계층을 적용한 결과를 얻는다.
filter_vals, conv_vals, pool_vals = sess.run(
    [W_conv, h_conv, h_pool], feed_dict={x: mnist.test.images[:9]}
)

# 합성곱 필터와 풀링계층를 적용한 결과를 이미지로 출력한다.
# 합성곱 필터를 적용한 후에는 픽셀값이 음의 값을 갖는 경우도 있으므로 배경(픽셀값 0) 부분이 흰색이 되지 않는다는 점에 주의하기 바란다.

fig = plt.figure(figsize=(10, num_filters + 1))

for i in range(num_filters):
    subplot = fig.add_subplot(num_filters + 1, 10, 10 * (i + 1) + 1)
    subplot.set_xticks([])
    subplot.set_yticks([])
    subplot.imshow(filter_vals[:, :, 0, i], cmap=plt.cm.gray_r, interpolation="nearest")

for i in range(9):
    subplot = fig.add_subplot(num_filters + 1, 10, i + 2)
    subplot.set_xticks([])
    subplot.set_yticks([])
    subplot.set_title("%d" % np.argmax(mnist.test.labels[i]))
    subplot.imshow(
        mnist.test.images[i].reshape((28, 28)),
        vmin=0,
        vmax=1,
        cmap=plt.cm.gray_r,
        interpolation="nearest",
    )

    for f in range(num_filters):
        subplot = fig.add_subplot(num_filters + 1, 10, 10 * (f + 1) + i + 2)
        subplot.set_xticks([])
        subplot.set_yticks([])
        subplot.imshow(
            pool_vals[i, :, :, f], cmap=plt.cm.gray_r, interpolation="nearest"
        )

# 올바르게 분류할 수 없었던 몇몇 데이터에 대해 각각의 문자일 확률을 확인한다.

fig = plt.figure(figsize=(12, 10))
c = 0
for image, label in zip(mnist.test.images, mnist.test.labels):
    p_val = sess.run(p, feed_dict={x: [image]})
    pred = p_val[0]
    prediction, actual = np.argmax(pred), np.argmax(label)
    if prediction == actual:
        continue
    subplot = fig.add_subplot(5, 4, c * 2 + 1)
    subplot.set_xticks([])
    subplot.set_yticks([])
    subplot.set_title("%d / %d" % (prediction, actual))
    subplot.imshow(
        image.reshape((28, 28)),
        vmin=0,
        vmax=1,
        cmap=plt.cm.gray_r,
        interpolation="nearest",
    )
    subplot = fig.add_subplot(5, 4, c * 2 + 2)
    subplot.set_xticks(range(10))
    subplot.set_xlim(-0.5, 9.5)
    subplot.set_ylim(0, 1)
    subplot.bar(range(10), pred, align="center")
    c += 1
    if c == 10:
        break

# 데이터를 준비한다.
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True)

# 첫 번째 단계의 합성곱 필터와 풀링 계층을 정의한다.
num_filters1 = 32
x = tf.placeholder(tf.float32, [None, 784])
x_image = tf.reshape(x, [-1, 28, 28, 1])
W_conv1 = tf.Variable(tf.truncated_normal([5, 5, 1, num_filters1], stddev=0.1))
h_conv1 = tf.nn.conv2d(x_image, W_conv1, strides=[1, 1, 1, 1], padding="SAME")
b_conv1 = tf.Variable(tf.constant(0.1, shape=[num_filters1]))
h_conv1_cutoff = tf.nn.relu(h_conv1 + b_conv1)
h_pool1 = tf.nn.max_pool(
    h_conv1_cutoff, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME"
)

# 두 번째 단계의 합성곱 필터와 풀링 계층을 정의한다.
num_filters2 = 64
W_conv2 = tf.Variable(
    tf.truncated_normal([5, 5, num_filters1, num_filters2], stddev=0.1)
)
h_conv2 = tf.nn.conv2d(h_pool1, W_conv2, strides=[1, 1, 1, 1], padding="SAME")
b_conv2 = tf.Variable(tf.constant(0.1, shape=[num_filters2]))
h_conv2_cutoff = tf.nn.relu(h_conv2 + b_conv2)
h_pool2 = tf.nn.max_pool(
    h_conv2_cutoff, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="SAME"
)

# 전 결합층, 드롭아웃 계층, 소프트맥스 함수를 정의한다.
h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * num_filters2])
num_units1 = 7 * 7 * num_filters2
num_units2 = 1024
w2 = tf.Variable(tf.truncated_normal([num_units1, num_units2]))
b2 = tf.Variable(tf.constant(0.1, shape=[num_units2]))
hidden2 = tf.nn.relu(tf.matmul(h_pool2_flat, w2) + b2)
keep_prob = tf.placeholder(tf.float32)
hidden2_drop = tf.nn.dropout(hidden2, keep_prob)
w0 = tf.Variable(tf.zeros([num_units2, 10]))
b0 = tf.Variable(tf.zeros([10]))
p = tf.nn.softmax(tf.matmul(hidden2_drop, w0) + b0)

# 오차 함수 loss, 트레이닝 알고리즘 train_step, 정답률 accuracy을 정의한다.
t = tf.placeholder(tf.float32, [None, 10])
loss = -tf.reduce_sum(t * tf.log(p))
train_step = tf.train.AdamOptimizer(0.0001).minimize(loss)
correct_prediction = tf.equal(tf.argmax(p, 1), tf.argmax(t, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 세션을 준비하고 Variable을 초기화한다.
sess = tf.InteractiveSession()
sess.run(tf.global_variables_initializer())

# 파라미터 최적화를 4000회 반복한다.
i = 0
for _ in range(4000):
    i += 1
    batch_xs, batch_ts = mnist.train.next_batch(50)
    sess.run(train_step, feed_dict={x: batch_xs, t: batch_ts, keep_prob: 0.5})
    if i % 1000 == 0:
        loss_vals, acc_vals = [], []
        for c in range(4):
            start = len(mnist.test.labels) / 4 * c
            end = len(mnist.test.labels) / 4 * (c + 1)
            loss_val, acc_val = sess.run(
                [loss, accuracy],
                feed_dict={
                    x: mnist.test.images[int(start) : int(end)],  # numpy 변경사항
                    t: mnist.test.labels[int(start) : int(end)],
                    keep_prob: 1.0,
                },
            )
            loss_vals.append(loss_val)
            acc_vals.append(acc_val)
        loss_val = np.sum(loss_vals)
        acc_val = np.mean(acc_vals)
        print("Step: %d, Loss: %f, Accuracy: %f" % (i, loss_val, acc_val))