TENSORFLOW Archives - 3 중 2 번째 페이지

[PYTHON/TENSORFLOW] 다층 퍼셉트론 신경망 만들기 (MNIST)

■ 다층 퍼셉트론 신경망을 만드는 방법을 보여준다. ▶ mlp.py


import input_data
import matplotlib.pyplot as pp
import tensorflow as tf

numberPixelDatasets = input_data.read_data_sets("MNIST_data/", one_hot = True)

learningRate       = 0.001
trainingEpochCount = 20
batchSize          = 100
displayStep        = 1

inputNodeCount   = 784 # 입력 노드 카운트 ; 28×28 픽셀 이미지
hiddenNodeCount1 = 256 # 은닉 노드 카운트 1
hiddenNodeCount2 = 256 # 은닉 노드 카운트 2
outputNodeCount  = 10  # 출력 노드 카운트 ; 슷자 0-9

inputValueTensor  = tf.placeholder("float", [None, inputNodeCount])
outputValueTensor = tf.placeholder("float", [None, outputNodeCount])

hiddenLayerWeightVariable1 = tf.Variable(tf.random_normal([inputNodeCount, hiddenNodeCount1]))
hiddenLayerBiasVariable1   = tf.Variable(tf.random_normal([hiddenNodeCount1]))
hiddenLayerTensor1         = tf.nn.sigmoid(tf.add(tf.matmul(inputValueTensor, hiddenLayerWeightVariable1), hiddenLayerBiasVariable1))

hiddenLayerWeightVariable2 = tf.Variable(tf.random_normal([hiddenNodeCount1, hiddenNodeCount2]))
hiddenLayerBiasVariable2   = tf.Variable(tf.random_normal([hiddenNodeCount2]))
hiddenLayerTensor2         = tf.nn.sigmoid(tf.add(tf.matmul(hiddenLayerTensor1, hiddenLayerWeightVariable2), hiddenLayerBiasVariable2))

outputLayerWeightVariable = tf.Variable(tf.random_normal([hiddenNodeCount2, outputNodeCount]))
outputLayerBiasVariable   = tf.Variable(tf.random_normal([outputNodeCount]))
outputLayerTensor         = tf.matmul(hiddenLayerTensor2, outputLayerWeightVariable) + outputLayerBiasVariable

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerTensor, labels = outputValueTensor))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

averageList = []
epochList   = []

initializerOperation = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(initializerOperation)
    for epoch in range(trainingEpochCount):
        averageCost = 0.
        totalBatch = int(numberPixelDatasets.train.num_examples / batchSize)
        for i in range(totalBatch):
            xBatchNDArray, yBatchNDArray = numberPixelDatasets.train.next_batch(batchSize)
            sess.run(optimizerOperation, feed_dict = {inputValueTensor : xBatchNDArray, outputValueTensor : yBatchNDArray})
            averageCost += sess.run(costTensor, feed_dict = {inputValueTensor : xBatchNDArray, outputValueTensor : yBatchNDArray}) / totalBatch
        if epoch % displayStep == 0:
            print("회차 :", '%04d' % (epoch + 1), "비용 =", "{:.9f}".format(averageCost))
        averageList.append(averageCost)
        epochList.append(epoch + 1)
    print("훈련 단계 완료")

    correctPredictionTensor = tf.equal(tf.argmax(outputLayerTensor, 1), tf.argmax(outputValueTensor, 1))
    accuracyTensor          = tf.reduce_mean(tf.cast(correctPredictionTensor, "float"))
    print("모델 정확도 :", accuracyTensor.eval({inputValueTensor : numberPixelDatasets.test.images, outputValueTensor : numberPixelDatasets.test.labels}))

    pp.plot(epochList, averageList, 'o', label = "MLP Training phase")
    pp.ylabel("cost")
    pp.xlabel("epoch")
    pp.legend()
    pp.show()

import input_data

import matplotlib.pyplot as pp

import tensorflow as tf

numberPixelDatasets = input_data.read_data_sets("MNIST_data/", one_hot = True)

learningRate = 0.001

trainingEpochCount = 20

batchSize = 100

displayStep = 1

inputNodeCount = 784 # 입력 노드 카운트 ; 28×28 픽셀 이미지

hiddenNodeCount1 = 256 # 은닉 노드 카운트 1

hiddenNodeCount2 = 256 # 은닉 노드 카운트 2

outputNodeCount = 10 # 출력 노드 카운트 ; 슷자 0-9

inputValueTensor = tf.placeholder("float", [None, inputNodeCount])

outputValueTensor = tf.placeholder("float", [None, outputNodeCount])

hiddenLayerWeightVariable1 = tf.Variable(tf.random_normal([inputNodeCount, hiddenNodeCount1]))

hiddenLayerBiasVariable1 = tf.Variable(tf.random_normal([hiddenNodeCount1]))

hiddenLayerTensor1 = tf.nn.sigmoid(tf.add(tf.matmul(inputValueTensor, hiddenLayerWeightVariable1), hiddenLayerBiasVariable1))

hiddenLayerWeightVariable2 = tf.Variable(tf.random_normal([hiddenNodeCount1, hiddenNodeCount2]))

hiddenLayerBiasVariable2 = tf.Variable(tf.random_normal([hiddenNodeCount2]))

hiddenLayerTensor2 = tf.nn.sigmoid(tf.add(tf.matmul(hiddenLayerTensor1, hiddenLayerWeightVariable2), hiddenLayerBiasVariable2))

outputLayerWeightVariable = tf.Variable(tf.random_normal([hiddenNodeCount2, outputNodeCount]))

outputLayerBiasVariable = tf.Variable(tf.random_normal([outputNodeCount]))

outputLayerTensor = tf.matmul(hiddenLayerTensor2, outputLayerWeightVariable) + outputLayerBiasVariable

costTensor = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = outputLayerTensor, labels = outputValueTensor))

optimizerOperation = tf.train.AdamOptimizer(learningRate).minimize(costTensor)

averageList = []

epochList = []

initializerOperation = tf.global_variables_initializer()

with tf.Session() as sess:

sess.run(initializerOperation)

for epoch in range(trainingEpochCount):

averageCost = 0.

totalBatch = int(numberPixelDatasets.train.num_examples / batchSize)

for i in range(totalBatch):

xBatchNDArray, yBatchNDArray = numberPixelDatasets.train.next_batch(batchSize)

sess.run(optimizerOperation, feed_dict = {inputValueTensor : xBatchNDArray, outputValueTensor : yBatchNDArray})

averageCost += sess.run(costTensor, feed_dict = {inputValueTensor : xBatchNDArray, outputValueTensor : yBatchNDArray}) / totalBatch

if epoch % displayStep == 0:

print("회차 :", '%04d' % (epoch + 1), "비용 =", "{:.9f}".format(averageCost))

averageList.append(averageCost)

epochList.append(epoch + 1)

print("훈련 단계 완료")

correctPredictionTensor = tf.equal(tf.argmax(outputLayerTensor, 1), tf.argmax(outputValueTensor, 1))

accuracyTensor = tf.reduce_mean(tf.cast(correctPredictionTensor, "float"))

print("모델 정확도 :", accuracyTensor.eval({inputValueTensor : numberPixelDatasets.test.images, outputValueTensor : numberPixelDatasets.test.labels}))

pp.plot(epochList, averageList, 'o', label = "MLP Training phase")

pp.ylabel("cost")

pp.xlabel("epoch")

pp.legend()

pp.show()

▶ 결과


회차 : 0001 비용 = 1.835462693
회차 : 0002 비용 = 0.543075322
회차 : 0003 비용 = 0.365367627
회차 : 0004 비용 = 0.269016541
회차 : 0005 비용 = 0.207292393
회차 : 0006 비용 = 0.162509755
회차 : 0007 비용 = 0.128678610
회차 : 0008 비용 = 0.102387188
회차 : 0009 비용 = 0.080819757
회차 : 0010 비용 = 0.064745211
회차 : 0011 비용 = 0.051405598
회차 : 0012 비용 = 0.040682739
회차 : 0013 비용 = 0.032230697
회차 : 0014 비용 = 0.025317747
회차 : 0015 비용 = 0.019939722
회차 : 0016 비용 = 0.015559807
회차 : 0017 비용 = 0.011993421
회차 : 0018 비용 = 0.009289965
회차 : 0019 비용 = 0.007239956
회차 : 0020 비용 = 0.005603419
훈련 단계 완료
모델 정확도 : 0.9465

회차 : 0001 비용 = 1.835462693

회차 : 0002 비용 = 0.543075322

회차 : 0003 비용 = 0.365367627

회차 : 0004 비용 = 0.269016541

회차 : 0005 비용 = 0.207292393

회차 : 0006 비용 = 0.162509755

회차 : 0007 비용 = 0.128678610

회차 : 0008 비용 = 0.102387188

회차 : 0009 비용 = 0.080819757

회차 : 0010 비용 = 0.064745211

회차 : 0011 비용 = 0.051405598

회차 : 0012 비용 = 0.040682739

회차 : 0013 비용 = 0.032230697

회차 : 0014 비용 = 0.025317747

회차 : 0015 비용 = 0.019939722

회차 : 0016 비용 = 0.015559807

회차 : 0017 비용 = 0.011993421

회차 : 0018 비용 = 0.009289965

회차 : 0019 비용 = 0.007239956

회차 : 0020 비용 = 0.005603419

훈련 단계 완료

모델 정확도 : 0.9465

[PYTHON/TENSORFLOW] 단일 계층 퍼셉트론 신경망 만들기 (MNIST)

■ 단일 계층 퍼셉트론 신경망을 만드는 방법을 보여준다. ▶ input_data.py


from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import gzip
import os
import tempfile
import numpy
from six.moves import urllib
from six.moves import xrange
import tensorflow as tf
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import gzip

import os

import tempfile

import numpy

from six.moves import urllib

from six.moves import xrange

import tensorflow as tf

from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

▶ slp.py


import input_data
import matplotlib.pyplot as pp
import tensorflow as tf

numberPixelDatasets = input_data.read_data_sets("numberPixelDatasets_data/", one_hot = True)

learningRate       = 0.01
trainingEpochCount = 25
batchSize          = 100
displayStep        = 1

xTensor = tf.placeholder("float", [None, 784]) # 28×28 = 784
yTensor = tf.placeholder("float", [None, 10 ]) # 0-9 숫자 인식

weightVariable = tf.Variable(tf.zeros([784, 10]))
biasVariable   = tf.Variable(tf.zeros([10]))

activationTensor   = tf.nn.softmax(tf.matmul(xTensor, weightVariable) + biasVariable)
crossEntropyTensor = yTensor * tf.log(activationTensor)
costTensor         = tf.reduce_mean(-tf.reduce_sum(crossEntropyTensor, reduction_indices = 1))

optimizerOperation = tf.train.GradientDescentOptimizer(learningRate).minimize(costTensor)

averageList = []
epochList   = []

initializerOperation = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(initializerOperation)
    for epoch in range(trainingEpochCount):
        averageCost = 0.
        totalBatch = int(numberPixelDatasets.train.num_examples / batchSize)
        for i in range(totalBatch):
            xBatchNDArray, yBatchNDArray = numberPixelDatasets.train.next_batch(batchSize)
            sess.run(optimizerOperation, feed_dict = {xTensor : xBatchNDArray, yTensor : yBatchNDArray})
            averageCost += sess.run(costTensor, feed_dict = {xTensor : xBatchNDArray, yTensor : yBatchNDArray}) / totalBatch
        if epoch % displayStep == 0:
            print("회차 :", '%04d' % (epoch + 1), "비용 =", "{:.9f}".format(averageCost))
        averageList.append(averageCost)
        epochList.append(epoch + 1)
    print("트레이닝 단계 완료")

    correctPredictionTensor = tf.equal(tf.argmax(activationTensor, 1), tf.argmax(yTensor, 1))
    accuracyTebsor          = tf.reduce_mean(tf.cast(correctPredictionTensor, "float"))
    print("모델 정확도 :", accuracyTebsor.eval({xTensor : numberPixelDatasets.test.images, yTensor : numberPixelDatasets.test.labels}))

    pp.plot(epochList, averageList, "o", label = "Logistic Regression Training phase")
    pp.ylabel("cost")
    pp.xlabel("epoch")
    pp.legend()
    pp.show()

import input_data

import matplotlib.pyplot as pp

import tensorflow as tf

numberPixelDatasets = input_data.read_data_sets("numberPixelDatasets_data/", one_hot = True)

learningRate = 0.01

trainingEpochCount = 25

batchSize = 100

displayStep = 1

xTensor = tf.placeholder("float", [None, 784]) # 28×28 = 784

yTensor = tf.placeholder("float", [None, 10 ]) # 0-9 숫자 인식

weightVariable = tf.Variable(tf.zeros([784, 10]))

biasVariable = tf.Variable(tf.zeros([10]))

activationTensor = tf.nn.softmax(tf.matmul(xTensor, weightVariable) + biasVariable)

crossEntropyTensor = yTensor * tf.log(activationTensor)

costTensor = tf.reduce_mean(-tf.reduce_sum(crossEntropyTensor, reduction_indices = 1))

optimizerOperation = tf.train.GradientDescentOptimizer(learningRate).minimize(costTensor)

averageList = []

epochList = []

initializerOperation = tf.global_variables_initializer()

with tf.Session() as sess:

sess.run(initializerOperation)

for epoch in range(trainingEpochCount):

averageCost = 0.

totalBatch = int(numberPixelDatasets.train.num_examples / batchSize)

for i in range(totalBatch):

xBatchNDArray, yBatchNDArray = numberPixelDatasets.train.next_batch(batchSize)

sess.run(optimizerOperation, feed_dict = {xTensor : xBatchNDArray, yTensor : yBatchNDArray})

averageCost += sess.run(costTensor, feed_dict = {xTensor : xBatchNDArray, yTensor : yBatchNDArray}) / totalBatch

if epoch % displayStep == 0:

print("회차 :", '%04d' % (epoch + 1), "비용 =", "{:.9f}".format(averageCost))

averageList.append(averageCost)

epochList.append(epoch + 1)

print("트레이닝 단계 완료")

correctPredictionTensor = tf.equal(tf.argmax(activationTensor, 1), tf.argmax(yTensor, 1))

accuracyTebsor = tf.reduce_mean(tf.cast(correctPredictionTensor, "float"))

print("모델 정확도 :", accuracyTebsor.eval({xTensor : numberPixelDatasets.test.images, yTensor : numberPixelDatasets.test.labels}))

pp.plot(epochList, averageList, "o", label = "Logistic Regression Training phase")

pp.ylabel("cost")

pp.xlabel("epoch")

pp.legend()

pp.show()

▶ 결과


회차 : 0001 비용 = 1.176287905
회차 : 0002 비용 = 0.662353746
회차 : 0003 비용 = 0.550700741
회차 : 0004 비용 = 0.496796931
회차 : 0005 비용 = 0.463800235
회차 : 0006 비용 = 0.440929263
회차 : 0007 비용 = 0.423949052
회차 : 0008 비용 = 0.410716742
회차 : 0009 비용 = 0.399927922
회차 : 0010 비용 = 0.390965419
회차 : 0011 비용 = 0.383320482
회차 : 0012 비용 = 0.376762401
회차 : 0013 비용 = 0.371033744
회차 : 0014 비용 = 0.365946764
회차 : 0015 비용 = 0.361372409
회차 : 0016 비용 = 0.357258832
회차 : 0017 비용 = 0.353575538
회차 : 0018 비용 = 0.350136466
회차 : 0019 비용 = 0.347030454
회차 : 0020 비용 = 0.344138179
회차 : 0021 비용 = 0.341470252
회차 : 0022 비용 = 0.339007374
회차 : 0023 비용 = 0.336622848
회차 : 0024 비용 = 0.334463308
회차 : 0025 비용 = 0.332481194
트레이닝 단계 완료
모델 정확도 : 0.914

회차 : 0001 비용 = 1.176287905

회차 : 0002 비용 = 0.662353746

회차 : 0003 비용 = 0.550700741

회차 : 0004 비용 = 0.496796931

회차 : 0005 비용 = 0.463800235

회차 : 0006 비용 = 0.440929263

회차 : 0007 비용 = 0.423949052

회차 : 0008 비용 = 0.410716742

회차 : 0009 비용 = 0.399927922

회차 : 0010 비용 = 0.390965419

회차 : 0011 비용 = 0.383320482

회차 : 0012 비용 = 0.376762401

회차 : 0013 비용 = 0.371033744

회차 : 0014 비용 = 0.365946764

회차 : 0015 비용 = 0.361372409

회차 : 0016 비용 = 0.357258832

회차 : 0017 비용 = 0.353575538

회차 : 0018 비용 = 0.350136466

회차 : 0019 비용 = 0.347030454

회차 : 0020 비용 = 0.344138179

회차 : 0021 비용 = 0.341470252

회차 : 0022 비용 = 0.339007374

회차 : 0023 비용 = 0.336622848

회차 : 0024 비용 = 0.334463308

회차 : 0025 비용 = 0.332481194

트레이닝 단계 완료

모델 정확도 : 0.914

[PYTHON/TENSORFLOW] K-평균 군집화(K-Means Clustering) 알고리즘 사용하기

■ K-평균 군집화(K-Means Clustering) 알고리즘을 사용하는 방법을 보여준다. ▶ kmean.py


import matplotlib.pyplot as pp
import numpy as np
import pandas as pd
import tensorflow as tf

def DisplayPartition(xValueList, yValueList, assignmentValueNDArray):
    labelList = []
    colorList = ["red", "blue", "green", "yellow"]
    for i in range(len(assignmentValueNDArray)):
        labelList.append(colorList[(assignmentValueNDArray[i])])
    dataFrame = pd.DataFrame(dict(x = xValueList, y = yValueList, color = labelList))
    _, axexSubPlot = pp.subplots()
    axexSubPlot.scatter(dataFrame["x"], dataFrame["y"], c = dataFrame["color"])
    pp.show()

vectorCount           = 2000
clusterCount          = 4
sampleCountPerCluster = 500
stepCount             = 1000
xValueList            = []
yValueList            = []
vectorList            = []

# 랜덤 데이터를 생성한다.
for i in range(vectorCount):
    if np.random.random() > 0.5:
        xValueList.append(np.random.normal(0.4, 0.7))
        yValueList.append(np.random.normal(0.2, 0.8))
    else:
        xValueList.append(np.random.normal(0.6, 0.4))
        yValueList.append(np.random.normal(0.8, 0.5))

vectorList = list(zip(xValueList, yValueList))

vectorTensor = tf.constant(vectorList)

vectorListCount = tf.shape(vectorList)[0]

randomIndexTensor = tf.random_shuffle(tf.range(0, vectorListCount))

begin = [0,]

size    = [clusterCount,]
size[0] = clusterCount

centroidIndexTensor     = tf.slice(randomIndexTensor, begin, size)
centroidVariable        = tf.Variable(tf.gather(vectorList, centroidIndexTensor))
expandedVectorTensor    = tf.expand_dims(vectorTensor, 0)
expandedCentroidVector  = tf.expand_dims(centroidVariable, 1)
subtractedVectorTensor  = tf.subtract(expandedVectorTensor, expandedCentroidVector)
euclideanDistanceTensor = tf.reduce_sum(tf.square(subtractedVectorTensor), 2)
assignmentTensor        = tf.to_int32(tf.argmin(euclideanDistanceTensor, 0))

partitionList = tf.dynamic_partition(vectorTensor, assignmentTensor, clusterCount)

for partition in partitionList:
    updatedCentroidTensor = tf.concat(tf.expand_dims(tf.reduce_mean(partition, 0), 0), 0)

initializeOperation = tf.global_variables_initializer()

sess = tf.Session()

sess.run(initializeOperation)

for step in range(stepCount):
    _, centroidValueNDArray, assignmentValueNDArray = sess.run([updatedCentroidTensor, centroidVariable, assignmentTensor])

DisplayPartition(xValueList, yValueList, assignmentValueNDArray)

pp.plot(xValueList,yValueList, "o", label = "Input Data")
pp.legend()
pp.show()

import matplotlib.pyplot as pp

import numpy as np

import pandas as pd

import tensorflow as tf

def DisplayPartition(xValueList, yValueList, assignmentValueNDArray):

labelList = []

colorList = ["red", "blue", "green", "yellow"]

for i in range(len(assignmentValueNDArray)):

labelList.append(colorList[(assignmentValueNDArray[i])])

dataFrame = pd.DataFrame(dict(x = xValueList, y = yValueList, color = labelList))

_, axexSubPlot = pp.subplots()

axexSubPlot.scatter(dataFrame["x"], dataFrame["y"], c = dataFrame["color"])

pp.show()

vectorCount = 2000

clusterCount = 4

sampleCountPerCluster = 500

stepCount = 1000

xValueList = []

yValueList = []

vectorList = []

# 랜덤 데이터를 생성한다.

for i in range(vectorCount):

if np.random.random() > 0.5:

xValueList.append(np.random.normal(0.4, 0.7))

yValueList.append(np.random.normal(0.2, 0.8))

else:

xValueList.append(np.random.normal(0.6, 0.4))

yValueList.append(np.random.normal(0.8, 0.5))

vectorList = list(zip(xValueList, yValueList))

vectorTensor = tf.constant(vectorList)

vectorListCount = tf.shape(vectorList)[0]

randomIndexTensor = tf.random_shuffle(tf.range(0, vectorListCount))

begin = [0,]

size = [clusterCount,]

size[0] = clusterCount

centroidIndexTensor = tf.slice(randomIndexTensor, begin, size)

centroidVariable = tf.Variable(tf.gather(vectorList, centroidIndexTensor))

expandedVectorTensor = tf.expand_dims(vectorTensor, 0)

expandedCentroidVector = tf.expand_dims(centroidVariable, 1)

subtractedVectorTensor = tf.subtract(expandedVectorTensor, expandedCentroidVector)

euclideanDistanceTensor = tf.reduce_sum(tf.square(subtractedVectorTensor), 2)

assignmentTensor = tf.to_int32(tf.argmin(euclideanDistanceTensor, 0))

partitionList = tf.dynamic_partition(vectorTensor, assignmentTensor, clusterCount)

for partition in partitionList:

updatedCentroidTensor = tf.concat(tf.expand_dims(tf.reduce_mean(partition, 0), 0), 0)

initializeOperation = tf.global_variables_initializer()

sess = tf.Session()

sess.run(initializeOperation)

for step in range(stepCount):

_, centroidValueNDArray, assignmentValueNDArray = sess.run([updatedCentroidTensor, centroidVariable, assignmentTensor])

DisplayPartition(xValueList, yValueList, assignmentValueNDArray)

pp.plot(xValueList,yValueList, "o", label = "Input Data")

pp.legend()

pp.show()

[PYTHON/TENSORFLOW] K-최근접 이웃(KNN, K-Nearest Neighbors) 알고리즘 사용하기

■ K-최근접 이웃(KNN, K-Nearest Neighbors) 알고리즘을 사용하는 방법을 보여준다. ▶ input_data.py


from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import gzip
import os
import tempfile
import numpy
from six.moves import urllib
from six.moves import xrange
import tensorflow as tf
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import gzip

import os

import tempfile

import numpy

from six.moves import urllib

from six.moves import xrange

import tensorflow as tf

from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

▶ knn.py


import input_data
import numpy as np
import tensorflow as tf

# 학습/테스트 데이터를 로드한다.
numberPixelDatasets = input_data.read_data_sets("/tmp/data/", one_hot = True)

trainNumberPixelNDArray, trainNumberNDArray = numberPixelDatasets.train.next_batch(100)
testNumberPixelNDArray , testNumberNDArray  = numberPixelDatasets.test.next_batch(10)

# 비용 함수와 거리 최적화를 정의한다.
trainNumberPixelTensor = tf.placeholder("float", [None, 784])
testPixelTensor        = tf.placeholder("float", [784])

distance = tf.reduce_sum(tf.abs(tf.add(trainNumberPixelTensor, tf.negative(testPixelTensor))), reduction_indices = 1)

predictor = tf.argmin(distance, 0)

# 테스트 한다.
accuracy = 0.

initializer = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(initializer)
    for i in range(len(testNumberNDArray)):
        predictNumberIndex = sess.run(predictor, feed_dict = { trainNumberPixelTensor : trainNumberPixelNDArray, testPixelTensor : testNumberPixelNDArray[i, :] })
        print("회차 : {0}, 예측 숫자 : {1}, 실제 숫자 : {2}".format(i, np.argmax(trainNumberNDArray[predictNumberIndex]), np.argmax(testNumberNDArray[i])))
        if np.argmax(trainNumberNDArray[predictNumberIndex]) == np.argmax(testNumberNDArray[i]):
            accuracy += 1. / len(testNumberPixelNDArray)
    print("정확도 = {0}".format(accuracy))

import input_data

import numpy as np

import tensorflow as tf

# 학습/테스트 데이터를 로드한다.

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

trainNumberPixelNDArray, trainNumberNDArray = numberPixelDatasets.train.next_batch(100)

testNumberPixelNDArray , testNumberNDArray = numberPixelDatasets.test.next_batch(10)

# 비용 함수와 거리 최적화를 정의한다.

trainNumberPixelTensor = tf.placeholder("float", [None, 784])

testPixelTensor = tf.placeholder("float", [784])

distance = tf.reduce_sum(tf.abs(tf.add(trainNumberPixelTensor, tf.negative(testPixelTensor))), reduction_indices = 1)

predictor = tf.argmin(distance, 0)

# 테스트 한다.

accuracy = 0.

initializer = tf.global_variables_initializer()

with tf.Session() as sess:

sess.run(initializer)

for i in range(len(testNumberNDArray)):

predictNumberIndex = sess.run(predictor, feed_dict = { trainNumberPixelTensor : trainNumberPixelNDArray, testPixelTensor : testNumberPixelNDArray[i, :] })

print("회차 : {0}, 예측 숫자 : {1}, 실제 숫자 : {2}".format(i, np.argmax(trainNumberNDArray[predictNumberIndex]), np.argmax(testNumberNDArray[i])))

if np.argmax(trainNumberNDArray[predictNumberIndex]) == np.argmax(testNumberNDArray[i]):

accuracy += 1. / len(testNumberPixelNDArray)

print("정확도 = {0}".format(accuracy))

▶ 결과


회차 : 0, 예측 숫자 : 2, 실제 숫자 : 2
회차 : 1, 예측 숫자 : 1, 실제 숫자 : 1
회차 : 2, 예측 숫자 : 6, 실제 숫자 : 5
회차 : 3, 예측 숫자 : 2, 실제 숫자 : 2
회차 : 4, 예측 숫자 : 8, 실제 숫자 : 8
회차 : 5, 예측 숫자 : 1, 실제 숫자 : 1
회차 : 6, 예측 숫자 : 0, 실제 숫자 : 0
회차 : 7, 예측 숫자 : 8, 실제 숫자 : 5
회차 : 8, 예측 숫자 : 8, 실제 숫자 : 8
회차 : 9, 예측 숫자 : 6, 실제 숫자 : 6
정확도 = 0.7999999999999999

회차 : 0, 예측 숫자 : 2, 실제 숫자 : 2

회차 : 1, 예측 숫자 : 1, 실제 숫자 : 1

회차 : 2, 예측 숫자 : 6, 실제 숫자 : 5

회차 : 3, 예측 숫자 : 2, 실제 숫자 : 2

회차 : 4, 예측 숫자 : 8, 실제 숫자 : 8

회차 : 5, 예측 숫자 : 1, 실제 숫자 : 1

회차 : 6, 예측 숫자 : 0, 실제 숫자 : 0

회차 : 7, 예측 숫자 : 8, 실제 숫자 : 5

회차 : 8, 예측 숫자 : 8, 실제 숫자 : 8

회차 : 9, 예측 숫자 : 6, 실제 숫자 : 6

정확도 = 0.7999999999999999

[PYTHON/TENSORFLOW] MNIST 데이터 로드하기

■ MNIST 데이터를 로드하는 방법을 보여준다. ▶ input_data.py


from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import gzip
import os
import tempfile
import numpy
from six.moves import urllib
from six.moves import xrange
import tensorflow as tf
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import gzip

import os

import tempfile

import numpy

from six.moves import urllib

from six.moves import xrange

import tensorflow as tf

from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

▶ mnist.py


import input_data
import matplotlib.pyplot as pp
import numpy as np

numberPixelDatasets = input_data.read_data_sets("MNIST_data/", one_hot = False)

# numberPixelNDArray : 숫자별 784개의 픽셀 값을 갖는 2차원 배열이다.
# numberNDArray      : 숫자 값을 갖는 1차원 배열이다.
numberPixelNDArray, numberNDArray = numberPixelDatasets.train.next_batch(10)

print("로드한 숫자 : {0}".format(numberNDArray))

# 출력할 숫자 인덱스
plotNumberIndex = 5

print("출력할 숫자 : " + str(numberNDArray[plotNumberIndex]))

# 출력할 숫자에 대한 1차원 배열을 구한다.
pixelNDArray = numberPixelNDArray[plotNumberIndex,:]
# 1차원 배열을 2차원 배열로 변환한다.
pixelNDArray = np.reshape(pixelNDArray, [28, 28])

pp.imshow(pixelNDArray)
pp.show()

import input_data

import matplotlib.pyplot as pp

import numpy as np

numberPixelDatasets = input_data.read_data_sets("MNIST_data/", one_hot = False)

# numberPixelNDArray : 숫자별 784개의 픽셀 값을 갖는 2차원 배열이다.

# numberNDArray : 숫자 값을 갖는 1차원 배열이다.

numberPixelNDArray, numberNDArray = numberPixelDatasets.train.next_batch(10)

print("로드한 숫자 : {0}".format(numberNDArray))

# 출력할 숫자 인덱스

plotNumberIndex = 5

print("출력할 숫자 : " + str(numberNDArray[plotNumberIndex]))

# 출력할 숫자에 대한 1차원 배열을 구한다.

pixelNDArray = numberPixelNDArray[plotNumberIndex,:]

# 1차원 배열을 2차원 배열로 변환한다.

pixelNDArray = np.reshape(pixelNDArray, [28, 28])

pp.imshow(pixelNDArray)

pp.show()

▶ 결과


로드한 숫자 : [6 2 0 5 9 6 0 1 1 1]
출력할 숫자 : 6

로드한 숫자 : [6 2 0 5 9 6 0 1 1 1]

출력할 숫자 : 6

[PYTHON/TENSORFLOW] 선형 회귀 알고리즘 사용하기

■ 선형 회귀 알고리즘을 사용하는 방법을 보여준다. ▶ linear_regression.py


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

pointCount = 200

xList = []
yList = []

a = 0.22
b = 0.78

for i in range(pointCount):
    x = np.random.normal(0.0, 0.5)
    y = a * x + b + np.random.normal(0.0, 0.1)
    xList.append(x)
    yList.append(y)

pp.plot(xList, yList, "o", label = "Input Data")
pp.legend()
pp.show()

aVariable = tf.Variable(tf.random_uniform([1], -1.0, 1.0))
bVariable = tf.Variable(tf.zeros([1]))

yTensor              = aVariable * xList + bVariable
costTensor           = tf.reduce_mean(tf.square(yTensor - yList))
optimizer            = tf.train.GradientDescentOptimizer(0.5)
trainOperation       = optimizer.minimize(costTensor)
initializerOperation = tf.global_variables_initializer()

with tf.Session() as session:
    session.run(initializerOperation)
    for step in range(0, 21):
        session.run(trainOperation)
        if (step % 5) == 0:
            pp.plot(xList, yList, "o", label = "step = {0}".format(step))
            pp.plot(xList, session.run(aVariable) * xList + session.run(bVariable))
            pp.legend()
            pp.show()

import matplotlib.pyplot as pp

import numpy as np

import tensorflow as tf

pointCount = 200

xList = []

yList = []

a = 0.22

b = 0.78

for i in range(pointCount):

x = np.random.normal(0.0, 0.5)

y = a * x + b + np.random.normal(0.0, 0.1)

xList.append(x)

yList.append(y)

pp.plot(xList, yList, "o", label = "Input Data")

pp.legend()

pp.show()

aVariable = tf.Variable(tf.random_uniform([1], -1.0, 1.0))

bVariable = tf.Variable(tf.zeros([1]))

yTensor = aVariable * xList + bVariable

costTensor = tf.reduce_mean(tf.square(yTensor - yList))

optimizer = tf.train.GradientDescentOptimizer(0.5)

trainOperation = optimizer.minimize(costTensor)

initializerOperation = tf.global_variables_initializer()

with tf.Session() as session:

session.run(initializerOperation)

for step in range(0, 21):

session.run(trainOperation)

if (step % 5) == 0:

pp.plot(xList, yList, "o", label = "step = {0}".format(step))

pp.plot(xList, session.run(aVariable) * xList + session.run(bVariable))

pp.legend()

pp.show()

[PYTHON/TENSORFLOW] 편미분 방정식을 사용해 빗방울 시뮬레이션 하기

■ 편미분 방정식을 사용해 빗방울을 시뮬레이션하는 방법을 보여준다. ▶ 예제 코드 (PY)


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

# 컨볼루션 커널을 구한다.
# sourceList : 이중 리스트
def GetConvolutionKernel(sourceList):
    ndarray = np.asarray(sourceList)
    ndarray = ndarray.reshape(list(ndarray.shape) + [1, 1])
    return tf.constant(ndarray, dtype = 1)

# 단순 2D 컨볼루션 연산을 구한다.
def GetSimplified2DConvolutionOperation(xVariable, kTensor):
    xTensor = tf.expand_dims(tf.expand_dims(xVariable, 0), -1)
    yTensor = tf.nn.depthwise_conv2d(xTensor, kTensor, [1, 1, 1, 1], padding = "SAME")
    return yTensor[0, :, :, 0]

# 라플라스 변환을 계산한다.
def ComputeLaplaceConversion(x):
    kTensor = GetConvolutionKernel([[0.5, 1.0, 0.5],
                                    [1.0, -6., 1.0],
                                    [0.5, 1.0, 0.5]])
    return GetSimplified2DConvolutionOperation(x, kTensor)

sess = tf.InteractiveSession()

size = 500

# 초기 조건 -- 빗방울이 연못에 떨어진다.

# 모두 0으로 설정한다.
ndarray1 = np.zeros([size, size], dtype = np.float32)
ndarray2 = np.zeros([size, size], dtype = np.float32)

# 빗방울이 연못의 임의 지점에 떨어진다.
for n in range(100):
    y, x = np.random.randint(0, size, 2)
    ndarray1[y, x] = np.random.uniform()

pp.imshow(ndarray1)
pp.show()

# 매개 변수 :
# eps     -- 시간 해상도
# damping -- 물결 감쇠
eps     = tf.placeholder(tf.float32, shape = ())
damping = tf.placeholder(tf.float32, shape = ())

# 시뮬레이션 상태를 위한 변수를 생성한다.
variable1 = tf.Variable(ndarray1)
variable2 = tf.Variable(ndarray2)

# 이산화 편미분 방정식 업데이트 규칙을 설정한다.
tensor1 = variable1 + eps * variable2
tensor2 = variable2 + eps * (ComputeLaplaceConversion(variable1) - damping * variable2)

# 상태를 업데이트 하기 위한 연산을 설정한다.
stepOperation = tf.group(variable1.assign(tensor1), variable2.assign(tensor2))

# 초기 조건에 대한 상태를 초기화 한다.
tf.global_variables_initializer().run()

# 편미분 방정식을 1000 단계 실행한다.
for i in range(1000):
    stepOperation.run({ eps : 0.03, damping : 0.04 })
    if i % 500 == 0:
        pp.imshow(variable1.eval())
        pp.show()

import matplotlib.pyplot as pp

import numpy as np

import tensorflow as tf

# 컨볼루션 커널을 구한다.

# sourceList : 이중 리스트

def GetConvolutionKernel(sourceList):

ndarray = np.asarray(sourceList)

ndarray = ndarray.reshape(list(ndarray.shape) + [1, 1])

return tf.constant(ndarray, dtype = 1)

# 단순 2D 컨볼루션 연산을 구한다.

def GetSimplified2DConvolutionOperation(xVariable, kTensor):

xTensor = tf.expand_dims(tf.expand_dims(xVariable, 0), -1)

yTensor = tf.nn.depthwise_conv2d(xTensor, kTensor, [1, 1, 1, 1], padding = "SAME")

return yTensor[0, :, :, 0]

# 라플라스 변환을 계산한다.

def ComputeLaplaceConversion(x):

kTensor = GetConvolutionKernel([[0.5, 1.0, 0.5],

[1.0, -6., 1.0],

[0.5, 1.0, 0.5]])

return GetSimplified2DConvolutionOperation(x, kTensor)

sess = tf.InteractiveSession()

size = 500

# 초기 조건 -- 빗방울이 연못에 떨어진다.

# 모두 0으로 설정한다.

ndarray1 = np.zeros([size, size], dtype = np.float32)

ndarray2 = np.zeros([size, size], dtype = np.float32)

# 빗방울이 연못의 임의 지점에 떨어진다.

for n in range(100):

y, x = np.random.randint(0, size, 2)

ndarray1[y, x] = np.random.uniform()

pp.imshow(ndarray1)

pp.show()

# 매개 변수 :

# eps -- 시간 해상도

# damping -- 물결 감쇠

eps = tf.placeholder(tf.float32, shape = ())

damping = tf.placeholder(tf.float32, shape = ())

# 시뮬레이션 상태를 위한 변수를 생성한다.

variable1 = tf.Variable(ndarray1)

variable2 = tf.Variable(ndarray2)

# 이산화 편미분 방정식 업데이트 규칙을 설정한다.

tensor1 = variable1 + eps * variable2

tensor2 = variable2 + eps * (ComputeLaplaceConversion(variable1) - damping * variable2)

# 상태를 업데이트 하기 위한 연산을 설정한다.

stepOperation = tf.group(variable1.assign(tensor1), variable2.assign(tensor2))

# 초기 조건에 대한 상태를 초기화 한다.

tf.global_variables_initializer().run()

# 편미분 방정식을 1000 단계 실행한다.

for i in range(1000):

stepOperation.run({ eps : 0.03, damping : 0.04 })

if i % 500 == 0:

pp.imshow(variable1.eval())

pp.show()

[PYTHON/TENSORFLOW] 몬테카를로 기법을 사용해 원주율 구하기

■ 몬테카를로 기법을 사용해 원주율을 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import matplotlib.pyplot as pp
import tensorflow as tf

trialCount = 100
hitCount = 0

x = tf.random_uniform([1], minval = -1, maxval = 1, dtype = tf.float32)
y = tf.random_uniform([1], minval = -1, maxval = 1, dtype = tf.float32)

piList = []

with tf.Session() as sess:
    for i in range(1, trialCount):
        for j in range(1, trialCount):
            if x.eval() ** 2 + y.eval() ** 2 < 1:
                hitCount = hitCount + 1
                piList.append((4 * float(hitCount) / i) / trialCount)

pp.plot(piList)
pp.show()

import matplotlib.pyplot as pp

import tensorflow as tf

trialCount = 100

hitCount = 0

x = tf.random_uniform([1], minval = -1, maxval = 1, dtype = tf.float32)

y = tf.random_uniform([1], minval = -1, maxval = 1, dtype = tf.float32)

piList = []

with tf.Session() as sess:

for i in range(1, trialCount):

for j in range(1, trialCount):

if x.eval() ** 2 + y.eval() ** 2 < 1:

hitCount = hitCount + 1

piList.append((4 * float(hitCount) / i) / trialCount)

pp.plot(piList)

pp.show()

[PYTHON/TENSORFLOW] random_uniform 함수 : seed를 사용해 난수 생성하기

■ random_uniform 함수에서 seed를 사용해 난수를 생성하는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf

tensor1 = tf.random_uniform([1], seed = 1)
tensor2 = tf.random_uniform([1])

print("첫번째 실행")

with tf.Session() as session1:
    print("균일 분포 (시드 = 1)    : {0}".format(session1.run(tensor1)))
    print("균일 분포 (시드 = 1)    : {0}".format(session1.run(tensor1)))
    print("균일 분포 (시드 미사용) : {0}".format(session1.run(tensor2)))
    print("균일 분포 (시드 미사요) : {0}".format(session1.run(tensor2)))

print("두번째 실행")

with tf.Session() as session2:
    print("균일 분포 (시드 = 1)    : {0}".format(session2.run(tensor1)))
    print("균일 분포 (시드 = 1)    : {0}".format(session2.run(tensor1)))
    print("균일 분포 (시드 미사용) : {0}".format(session2.run(tensor2)))
    print("균일 분포 (시드 미사용) : {0}".format(session2.run(tensor2)))

[결과]

첫번째 실행
균일 분포 (시드 = 1)    : [0.2390374]
균일 분포 (시드 = 1)    : [0.22267115]
균일 분포 (시드 미사용) : [0.16077161]
균일 분포 (시드 미사요) : [0.62763023]
두번째 실행
균일 분포 (시드 = 1)    : [0.2390374]
균일 분포 (시드 = 1)    : [0.22267115]
균일 분포 (시드 미사용) : [0.74607146]
균일 분포 (시드 미사용) : [0.6121973]

import tensorflow as tf

tensor1 = tf.random_uniform([1], seed = 1)

tensor2 = tf.random_uniform([1])

print("첫번째 실행")

with tf.Session() as session1:

print("균일 분포 (시드 = 1) : {0}".format(session1.run(tensor1)))

print("균일 분포 (시드 미사용) : {0}".format(session1.run(tensor2)))

print("균일 분포 (시드 미사요) : {0}".format(session1.run(tensor2)))

print("두번째 실행")

with tf.Session() as session2:

print("균일 분포 (시드 = 1) : {0}".format(session2.run(tensor1)))

print("균일 분포 (시드 미사용) : {0}".format(session2.run(tensor2)))

[결과]

첫번째 실행

균일 분포 (시드 = 1) : [0.2390374]

균일 분포 (시드 = 1) : [0.22267115]

균일 분포 (시드 미사용) : [0.16077161]

균일 분포 (시드 미사요) : [0.62763023]

두번째 실행

균일 분포 (시드 = 1) : [0.2390374]

균일 분포 (시드 = 1) : [0.22267115]

균일 분포 (시드 미사용) : [0.74607146]

균일 분포 (시드 미사용) : [0.6121973]

[PYTHON/TENSORFLOW] random_normal 함수 : 정규 분포 구하기

■ random_normal 함수를 사용해 정규 분포를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import matplotlib.pyplot as pp
import tensorflow as tf

tensor = tf.random_normal([100], mean = 0, stddev = 2, dtype = tf.float32)

with tf.Session() as session:
    print(tensor.eval())
    pp.hist(tensor.eval(), density = True)
    pp.show()

[결과]

[-3.440956    2.9528139  -2.1874828   1.1655606   1.9633586   2.534135
  2.2539172   4.1552515   0.6079847  -1.2589507  -2.3669343   2.4858336
 -2.7820125  -0.35739782  1.0026959  -3.414314   -4.110763   -3.772042
 -0.86982745 -3.5725734  -4.133035   -0.6590802   1.6426448  -2.18655
  1.7955924   0.6521051  -1.4494358  -1.393985    1.1428603  -3.6488476
 -0.5809621   1.120533    0.7422741  -1.8246961   2.0381367  -0.5463194
 -3.0208485  -1.3748398   4.41915    -1.430362    0.74772584 -0.41407225
  2.5688095   1.7374964  -0.21328539  0.24921085  0.8804999   0.07990843
 -1.261807    0.953815   -2.9196105  -2.6247299   0.21441022  1.5979617
 -1.3157839   1.2904466   0.2824374   2.3852978  -2.2696433   2.0548098
  0.52727544 -3.3213265   2.102399    4.7985563   1.384564   -2.1308424
 -0.13864219 -2.6747816   3.0806332  -2.369708   -1.4581449  -0.15420328
  1.621943    0.12209347 -2.8875623   1.6283735   1.9554224  -1.6151962
  2.5842354   2.6196551  -1.6083497  -0.73591906 -3.3242385   1.4458559
 -0.16545773  0.06856316  2.8434432  -0.9933967   0.73452926 -1.2012529
 -3.075046   -0.9778303   2.856141    1.1595836  -1.6699845   3.2019432
  1.0307454   2.7444181  -1.1426736  -0.41676688]

import matplotlib.pyplot as pp

import tensorflow as tf

tensor = tf.random_normal([100], mean = 0, stddev = 2, dtype = tf.float32)

with tf.Session() as session:

print(tensor.eval())

pp.hist(tensor.eval(), density = True)

pp.show()

[결과]

[-3.440956 2.9528139 -2.1874828 1.1655606 1.9633586 2.534135

2.2539172 4.1552515 0.6079847 -1.2589507 -2.3669343 2.4858336

-2.7820125 -0.35739782 1.0026959 -3.414314 -4.110763 -3.772042

-0.86982745 -3.5725734 -4.133035 -0.6590802 1.6426448 -2.18655

1.7955924 0.6521051 -1.4494358 -1.393985 1.1428603 -3.6488476

-0.5809621 1.120533 0.7422741 -1.8246961 2.0381367 -0.5463194

-3.0208485 -1.3748398 4.41915 -1.430362 0.74772584 -0.41407225

2.5688095 1.7374964 -0.21328539 0.24921085 0.8804999 0.07990843

-1.261807 0.953815 -2.9196105 -2.6247299 0.21441022 1.5979617

-1.3157839 1.2904466 0.2824374 2.3852978 -2.2696433 2.0548098

0.52727544 -3.3213265 2.102399 4.7985563 1.384564 -2.1308424

-0.13864219 -2.6747816 3.0806332 -2.369708 -1.4581449 -0.15420328

1.621943 0.12209347 -2.8875623 1.6283735 1.9554224 -1.6151962

2.5842354 2.6196551 -1.6083497 -0.73591906 -3.3242385 1.4458559

-0.16545773 0.06856316 2.8434432 -0.9933967 0.73452926 -1.2012529

-3.075046 -0.9778303 2.856141 1.1595836 -1.6699845 3.2019432

1.0307454 2.7444181 -1.1426736 -0.41676688]

[PYTHON/TENSORFLOW] random_uniform 함수 : 균일 분포 구하기

■ random_uniform 함수를 사용해 균일 분포를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import matplotlib.pyplot as pp
import tensorflow as tf

tensor = tf.random_uniform([100], minval = 0, maxval = 1, dtype = tf.float32)

with tf.Session() as sess:
    print(tensor.eval())
    pp.hist(tensor.eval(), density = True)
    pp.show()

[결과]

[0.59834206 0.51181686 0.050102   0.73071086 0.43281043 0.403
 0.84472597 0.86903036 0.9982685  0.37471735 0.29925036 0.7509545
 0.80886376 0.13208961 0.8736682  0.7498324  0.05850744 0.7352829
 0.01046085 0.86014843 0.52570355 0.67701745 0.8295574  0.3465761
 0.59797275 0.65029776 0.5552492  0.09862709 0.7465478  0.5077661
 0.6939571  0.33908582 0.8289263  0.73877156 0.735968   0.7166053
 0.6315912  0.31752253 0.9069333  0.6777247  0.14038134 0.7489219
 0.90146756 0.24346983 0.10258448 0.20915556 0.3328128  0.8555565
 0.5762454  0.8039553  0.46993172 0.11023343 0.1745404  0.9341748
 0.850304   0.09276247 0.7760397  0.88917756 0.49657965 0.51570284
 0.07565284 0.08290625 0.47053838 0.65277123 0.9000623  0.5739497
 0.8410399  0.8034811  0.43779492 0.7869625  0.8152808  0.18398738
 0.57458556 0.36849105 0.14195943 0.5163764  0.5915874  0.79982495
 0.87443864 0.6804317  0.31145406 0.5538204  0.1555816  0.70909894
 0.15273666 0.09382796 0.0074687  0.7780589  0.7109288  0.17873096
 0.7720157  0.9246503  0.6532688  0.16645253 0.38929904 0.38421035
 0.8735094  0.47028458 0.30578423 0.4232496 ]

import matplotlib.pyplot as pp

import tensorflow as tf

tensor = tf.random_uniform([100], minval = 0, maxval = 1, dtype = tf.float32)

with tf.Session() as sess:

print(tensor.eval())

pp.hist(tensor.eval(), density = True)

pp.show()

[결과]

[0.59834206 0.51181686 0.050102 0.73071086 0.43281043 0.403

0.84472597 0.86903036 0.9982685 0.37471735 0.29925036 0.7509545

0.80886376 0.13208961 0.8736682 0.7498324 0.05850744 0.7352829

0.01046085 0.86014843 0.52570355 0.67701745 0.8295574 0.3465761

0.59797275 0.65029776 0.5552492 0.09862709 0.7465478 0.5077661

0.6939571 0.33908582 0.8289263 0.73877156 0.735968 0.7166053

0.6315912 0.31752253 0.9069333 0.6777247 0.14038134 0.7489219

0.90146756 0.24346983 0.10258448 0.20915556 0.3328128 0.8555565

0.5762454 0.8039553 0.46993172 0.11023343 0.1745404 0.9341748

0.850304 0.09276247 0.7760397 0.88917756 0.49657965 0.51570284

0.07565284 0.08290625 0.47053838 0.65277123 0.9000623 0.5739497

0.8410399 0.8034811 0.43779492 0.7869625 0.8152808 0.18398738

0.57458556 0.36849105 0.14195943 0.5163764 0.5915874 0.79982495

0.87443864 0.6804317 0.31145406 0.5538204 0.1555816 0.70909894

0.15273666 0.09382796 0.0074687 0.7780589 0.7109288 0.17873096

0.7720157 0.9246503 0.6532688 0.16645253 0.38929904 0.38421035

0.8735094 0.47028458 0.30578423 0.4232496 ]

[PYTHON/TENSORFLOW] 미분 계수 구하기

■ 미분 계수를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf

xTensor = tf.placeholder(tf.float32)
yTensor = 2 * xTensor * xTensor

differentialCoefficientList = tf.gradients(yTensor, xTensor)

with tf.Session() as session:
    differentialCoefficient = session.run(differentialCoefficientList, feed_dict = { xTensor : 1 })
    print(differentialCoefficient)

[결과]

[4.0]

import tensorflow as tf

xTensor = tf.placeholder(tf.float32)

yTensor = 2 * xTensor * xTensor

differentialCoefficientList = tf.gradients(yTensor, xTensor)

with tf.Session() as session:

differentialCoefficient = session.run(differentialCoefficientList, feed_dict = { xTensor : 1 })

print(differentialCoefficient)

[결과]

[4.0]

[PYTHON/TENSORFLOW] 쥘리아 집합 출력하기

■ 쥘리아 집합을 출력하는 방법을 보여준다. ▶ 예제 코드 (PY)


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

yNDArray, xNDArray = np.mgrid[-2:2:0.005, -2:2:0.005]

zNDArray = xNDArray + 1j * yNDArray

zTensor = tf.constant(zNDArray.astype("complex64"))

zsVariable = tf.Variable(zTensor)
nsVariable = tf.Variable(tf.zeros_like(zTensor, "float32"))

tf.InteractiveSession()

tf.global_variables_initializer().run()

cComplex = complex(0.0, 0.75)

zsTensor = zsVariable * zsVariable - cComplex

notDivergedTensor = tf.abs(zsTensor) < 4

stepOperation = tf.group(zsVariable.assign(zsTensor), nsVariable.assign_add(tf.cast(notDivergedTensor, "float32")))

for i in range(200):
    stepOperation.run()

pp.imshow(nsVariable.eval())
pp.show()

import matplotlib.pyplot as pp

import numpy as np

import tensorflow as tf

yNDArray, xNDArray = np.mgrid[-2:2:0.005, -2:2:0.005]

zNDArray = xNDArray + 1j * yNDArray

zTensor = tf.constant(zNDArray.astype("complex64"))

zsVariable = tf.Variable(zTensor)

nsVariable = tf.Variable(tf.zeros_like(zTensor, "float32"))

tf.InteractiveSession()

tf.global_variables_initializer().run()

cComplex = complex(0.0, 0.75)

zsTensor = zsVariable * zsVariable - cComplex

notDivergedTensor = tf.abs(zsTensor) < 4

stepOperation = tf.group(zsVariable.assign(zsTensor), nsVariable.assign_add(tf.cast(notDivergedTensor, "float32")))

for i in range(200):

stepOperation.run()

pp.imshow(nsVariable.eval())

pp.show()

[PYTHON/TENSORFLOW] 망델브로 집합 출력하기

■ 망델브로 집합을 출력하는 방법을 보여준다. ▶ 예제 코드 (PY)


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

yNDArray, xNDArray = np.mgrid[-1.3:1.3:0.005, -2:1:0.005]

zNDArray = xNDArray + 1j * yNDArray

cTensor = tf.constant(zNDArray.astype(np.complex64))

zsVariable = tf.Variable(cTensor)
nsVariable = tf.Variable(tf.zeros_like(cTensor, tf.float32))

session = tf.InteractiveSession()

tf.global_variables_initializer().run()

zsTensor = zsVariable * zsVariable + cTensor

notDivergedTensor = tf.abs(zsTensor) < 4

stepOperation = tf.group(zsVariable.assign(zsTensor), nsVariable.assign_add(tf.cast(notDivergedTensor, tf.float32)))

for i in range(200):
    stepOperation.run()

pp.imshow(nsVariable.eval())
pp.show()

import matplotlib.pyplot as pp

import numpy as np

import tensorflow as tf

yNDArray, xNDArray = np.mgrid[-1.3:1.3:0.005, -2:1:0.005]

zNDArray = xNDArray + 1j * yNDArray

cTensor = tf.constant(zNDArray.astype(np.complex64))

zsVariable = tf.Variable(cTensor)

nsVariable = tf.Variable(tf.zeros_like(cTensor, tf.float32))

session = tf.InteractiveSession()

tf.global_variables_initializer().run()

zsTensor = zsVariable * zsVariable + cTensor

notDivergedTensor = tf.abs(zsTensor) < 4

stepOperation = tf.group(zsVariable.assign(zsTensor), nsVariable.assign_add(tf.cast(notDivergedTensor, tf.float32)))

for i in range(200):

stepOperation.run()

pp.imshow(nsVariable.eval())

pp.show()

[PYTHON/TENSORFLOW] transpose 함수 : 이미지 회전하기

■ transpose 함수를 사용해 이미지를 회전하는 방법을 보여준다. ▶ 예제 코드 (PY)


import matplotlib.image as img
import matplotlib.pyplot as pp
import tensorflow as tf

fileName = "d:\\sample.png"

ndarray = img.imread(fileName)
variable = tf.Variable(ndarray, name = 'x')
model = tf.global_variables_initializer()

with tf.Session() as sess:
    variable = tf.transpose(variable, perm = [1, 0, 2])
    sess.run(model)
    transposeNDArray = sess.run(variable)
    pp.imshow(transposeNDArray)
    pp.show()

import matplotlib.image as img

import matplotlib.pyplot as pp

import tensorflow as tf

fileName = "d:\\sample.png"

ndarray = img.imread(fileName)

variable = tf.Variable(ndarray, name = 'x')

model = tf.global_variables_initializer()

with tf.Session() as sess:

variable = tf.transpose(variable, perm = [1, 0, 2])

sess.run(model)

transposeNDArray = sess.run(variable)

pp.imshow(transposeNDArray)

pp.show()

[PYTHON/TENSORFLOW] slice 함수 : 이미지 자르기

■ slice 함수를 사용해 이미지를 자르는 방법을 보여준다. ▶ 예제 코드 (PY)


import matplotlib.image as img
import matplotlib.pyplot as pp
import tensorflow as tf

fileName = "c:\\sample.png"

ndarray = img.imread(fileName)
tensor = tf.placeholder("float32", [None, None, 3])
sliceTensor = tf.slice(tensor, [200, 0, 0], [500, -1, -1])

with tf.Session() as sess:
    slitceNDArray = sess.run(sliceTensor, feed_dict = { tensor : ndarray })
    pp.imshow(slitceNDArray)
    pp.show()

import matplotlib.image as img

import matplotlib.pyplot as pp

import tensorflow as tf

fileName = "c:\\sample.png"

ndarray = img.imread(fileName)

tensor = tf.placeholder("float32", [None, None, 3])

sliceTensor = tf.slice(tensor, [200, 0, 0], [500, -1, -1])

with tf.Session() as sess:

slitceNDArray = sess.run(sliceTensor, feed_dict = { tensor : ndarray })

pp.imshow(slitceNDArray)

pp.show()

[PYTHON/TENSORFLOW] matrix_determinant 함수 : 행렬식 값 구하기

■ matrix_determinant 함수를 사용해 행렬식 값을 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import numpy as np
import tensorflow as tf

ndarray = np.array([(2, 7, 2), (1, 4, 2), (9, 0, 2)], dtype = 'float32')

tensor = tf.matrix_determinant(ndarray)

with tf.Session() as sess:
    print(sess.run(tensor))

[결과]

55.999992

import numpy as np

import tensorflow as tf

ndarray = np.array([(2, 7, 2), (1, 4, 2), (9, 0, 2)], dtype = 'float32')

tensor = tf.matrix_determinant(ndarray)

with tf.Session() as sess:

print(sess.run(tensor))

[결과]

55.999992

[PYTHON/TENSORFLOW] add 함수 : 행렬 더하기

■ add 함수를 사용해 행렬을 더하는 방법을 보여준다. ▶ 예제 코드 (PY)


import numpy as np
import tensorflow as tf

ndarray1 = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)], dtype = 'int32')
ndarray2 = np.array([(1, 0, 0), (0, 1, 0), (0, 0, 1)], dtype = 'int32')

tensor1 = tf.constant(ndarray1)
tensor2 = tf.constant(ndarray2)

tensor3 = tf.add(tensor1, tensor2)

with tf.Session() as sess:
    print(sess.run(tensor1))
    print(sess.run(tensor2))
    print(sess.run(tensor3))

[결과]

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[1 0 0]
 [0 1 0]
 [0 0 1]]
[[ 2  2  3]
 [ 4  6  6]
 [ 7  8 10]]

import numpy as np

import tensorflow as tf

ndarray1 = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)], dtype = 'int32')

ndarray2 = np.array([(1, 0, 0), (0, 1, 0), (0, 0, 1)], dtype = 'int32')

tensor1 = tf.constant(ndarray1)

tensor2 = tf.constant(ndarray2)

tensor3 = tf.add(tensor1, tensor2)

with tf.Session() as sess:

print(sess.run(tensor1))

print(sess.run(tensor2))

print(sess.run(tensor3))

[결과]

[[1 2 3]

[4 5 6]

[7 8 9]]

[[1 0 0]

[0 1 0]

[0 0 1]]

[[ 2 2 3]

[ 4 6 6]

[ 7 8 10]]

[PYTHON/TENSORFLOW] matmul 함수 : 행렬 곱셈하기

■ matmul 함수를 사용해 행렬을 곱셈하는 방법을 보여준다. ▶ 예제 코드 (PY)


import numpy as np
import tensorflow as tf

ndarray1 = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)], dtype = 'int32')
ndarray2 = np.array([(1, 0, 0), (0, 1, 0), (0, 0, 1)], dtype = 'int32')

tensor1 = tf.constant(ndarray1)
tensor2 = tf.constant(ndarray2)

tensor3 = tf.matmul(tensor1, tensor2)

with tf.Session() as sess:
    print(sess.run(tensor1))
    print(sess.run(tensor2))
    print(sess.run(tensor3))

[결과]

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[1 0 0]
 [0 1 0]
 [0 0 1]]
[[1 2 3]
 [4 5 6]
 [7 8 9]]

import numpy as np

import tensorflow as tf

ndarray1 = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)], dtype = 'int32')

ndarray2 = np.array([(1, 0, 0), (0, 1, 0), (0, 0, 1)], dtype = 'int32')

tensor1 = tf.constant(ndarray1)

tensor2 = tf.constant(ndarray2)

tensor3 = tf.matmul(tensor1, tensor2)

with tf.Session() as sess:

print(sess.run(tensor1))

print(sess.run(tensor2))

print(sess.run(tensor3))

[결과]

[[1 2 3]

[4 5 6]

[7 8 9]]

[[1 0 0]

[0 1 0]

[0 0 1]]

[[1 2 3]

[4 5 6]

[7 8 9]]

[PYTHON/TENSORFLOW] convert_to_tensor 함수 : 2차원 텐서 구하기

■ convert_to_tensor 함수를 사용해 2차원 텐서를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import numpy as np
import tensorflow as tf

sourceArray = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)], dtype = 'int32')

tensor = tf.convert_to_tensor(sourceArray, dtype = tf.int32)

with tf.Session() as sess:
    print(sess.run(tensor))
    print(sess.run(tensor[0]))
    print(sess.run(tensor[0][1]))

[결과]

[[1 2 3]
 [4 5 6]
 [7 8 9]]
[1 2 3]
2

import numpy as np

import tensorflow as tf

sourceArray = np.array([(1, 2, 3), (4, 5, 6), (7, 8, 9)], dtype = 'int32')

tensor = tf.convert_to_tensor(sourceArray, dtype = tf.int32)

with tf.Session() as sess:

print(sess.run(tensor))

print(sess.run(tensor[0]))

print(sess.run(tensor[0][1]))

[결과]

[[1 2 3]

[4 5 6]

[7 8 9]]

[1 2 3]

[PYTHON/TENSORFLOW] convert_to_tensor 함수 : 1차원 텐서 구하기

■ convert_to_tensor 함수를 사용해 1차원 텐서를 구하는 방법을 보여준다. ▶ 예제 코드 (PY)


import numpy as np
import tensorflow as tf

sourceArray = np.array([1.3, 1, 4.0, 23.99], dtype = 'float64')

tensor = tf.convert_to_tensor(sourceArray, dtype = tf.float64)

with tf.Session() as session:
    print(session.run(tensor))
    print(session.run(tensor[0]))
    print(session.run(tensor[1]))

[결과]

[  1.3    1.     4.    23.99]
1.3
1.0

import numpy as np

import tensorflow as tf

sourceArray = np.array([1.3, 1, 4.0, 23.99], dtype = 'float64')

tensor = tf.convert_to_tensor(sourceArray, dtype = tf.float64)

with tf.Session() as session:

print(session.run(tensor))

print(session.run(tensor[0]))

print(session.run(tensor[1]))

[결과]

[ 1.3 1. 4. 23.99]

1.3

1.0

[PYTHON/TENSORFLOW] 텐서보드 사용하기

■ 텐서보드를 사용하는 방법을 보여준다. 1. 아래 코드를 실행한다. ▶ 예제 코드 (PY)


import tensorflow as tf

a = tf.constant(10, name = "a")
b = tf.constant(90, name = "b")

y = tf.Variable(a + b * 2, name = "y")

model = tf.global_variables_initializer()

with tf.Session() as session:

    merged = tf.summary.merge_all()

    writer = tf.summary.FileWriter("/tmp/tensorflowlogs", session.graph)

    session.run(model)

    print(session.run(y))

import tensorflow as tf

a = tf.constant(10, name = "a")

b = tf.constant(90, name = "b")

y = tf.Variable(a + b * 2, name = "y")

model = tf.global_variables_initializer()

with tf.Session() as session:

merged = tf.summary.merge_all()

writer = tf.summary.FileWriter("/tmp/tensorflowlogs", session.graph)

session.run(model)

print(session.run(y))

2. Anaconda Prompt를 실행하고 아래 명령을 실행한다. ▶

[PYTHON/TENSORFLOW] placeholder 함수 : 변수 만들기

■ placeholder 함수를 사용해 변수를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf

a = tf.placeholder("int32")
b = tf.placeholder("int32")

y = tf.multiply(a, b)

with tf.Session() as sess:
    result = sess.run(y, feed_dict = { a : 2, b : 5 })
    print(result)

[결과]

10

import tensorflow as tf

a = tf.placeholder("int32")

b = tf.placeholder("int32")

y = tf.multiply(a, b)

with tf.Session() as sess:

result = sess.run(y, feed_dict = { a : 2, b : 5 })

print(result)

[결과]

[PYTHON/TENSORFLOW] constant 함수 : 상수 만들기

■ constant 함수를 사용해 상수를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf

hello = tf.constant("Hello TensorFlow!")

with tf.Session() as sess:
    result = sess.run(hello)
    print(result)

[결과]

b'Hello TensorFlow!'

import tensorflow as tf

hello = tf.constant("Hello TensorFlow!")

with tf.Session() as sess:

result = sess.run(hello)

print(result)

[결과]

b'Hello TensorFlow!'

[PYTHON/TENSORFLOW] Variable 클래스 : 변수 만들기

■ Variable 클래스를 사용해 변수를 만드는 방법을 보여준다. ▶ 예제 코드 (PY)


import tensorflow as tf

x = tf.constant(1, name = "x")
y = tf.Variable(x + 9, name = "y")

model = tf.global_variables_initializer()

with tf.Session() as sess:
    sess.run(model)
    result = sess.run(y)
    print(result)

[결과]

10

import tensorflow as tf

x = tf.constant(1, name = "x")

y = tf.Variable(x + 9, name = "y")

model = tf.global_variables_initializer()

with tf.Session() as sess:

sess.run(model)

result = sess.run(y)

print(result)

[결과]