NAIAHD

구글이 keras  인수하면서 tensorflow 에 들어간다

keras 백그라운드에 tensorflow이지만 프로그램이 간단하게 개발된다.

scike-learn가 동일하다.

tensorflow2가 keras이다.

경사하강법 : 오차가 최소가 되도록 하는 것

가중치가 기울기이다. w

optimizer:  경사하강법 adam 확률적경사하강법

 

분류

sigmoid  - 2중 으로

softmax  -  다중 분류

 

확률이 가장 높은 것을 원핫 인코딩으로 한다.

내부적으로는 확률 형태로 되는데 확률은 가장 높은 것으로 한다.

one- hot encoding 확률이 잴 높은 것을 1로 하고 나머지는 0으로 한다.

 

MNIST ->이미지 손글씨를 모아논 데이터셋

 MNIST 데이터셋은 미국 국립표준기술원(NIST)이 고등학생과 인구조사국 직원 등이 쓴 손글씨를

이용해 만든 데이터로 구성되어 있다.

 60,000개의 글자 이미지에 각각 0부터 9까지 이름표를 붙인 데이터셋으로, 머신러닝을 배우는 사람

이라면 자신의 알고리즘과 다른 알고리즘의 성과를 비교해 보고자 한 번씩 도전해 보는 가장 유명한

데이터 중 하나이다.

 각 이미지는 28 * 28 픽셀 크기로 되어있다.

 

 Mnist 데이터셋에는 총 60,000개의 데이터가 있는데, 이 데이터는 크게 아래와 같이 세종류의 데이터

셋으로 나눠 진다.

 모델 학습을 위한 학습용 데이터인 mnist.train 그리고, 학습된 모델을 테스트하기 위한 테스트 데이터

셋은 minst.test, 그리고 모델을 확인하기 위한 mnist.validation 데이터셋으로 구별된다.

 각 데이터는 아래와 같이 학습용 데이터 55,000개, 테스트용 10,000개, 그리고, 모델 확인용 데이터

5000개로 구성되어 있다.

 

from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.pyplot as plt

# 숫자 이미지 파일을 MNIST_data 폴더에 다운로드 받는다.
#읽어올때 one-hot인코딩으로
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
batch_xs, batch_ys = mnist.train.next_batch(1) # 1개의 파일을 구해옴
# batch_xs 이미지를 가지고 오고
# batch_ys 이미지의 label을 가져온다.
# print(batch_xs.shape)
# print(batch_ys.shape)
# print(batch_xs.reshape(28,28))
# print(batch_xs)
print(batch_ys)
plt.imshow(batch_xs.reshape(28,28), cmap='Greys') # 1장의 이미지는 28 * 28 개의 픽셀로 되어있음
plt.show()

 

from tensorflow.examples.tutorials.mnist import input_data
import random
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import matplotlib.pyplot as plt

#시드 값을 설정하지 않으면 결과가 매번 달라진다.
tf.set_random_seed(777) # for reproducibility

# Check out https://www.tensorflow.org/get_started/mnist/beginners for
# more information about the mnist dataset
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) # 자동으로 이미지를 다운로드 받는다.
nb_classes = 10 # 클래스 갯수: 숫자 이미지 파일 갯수
# MNIST data image of shape 28 * 28 = 784
# 자료형을 설정한다.
X = tf.placeholder(tf.float32, [None, 784]) # 784행
# 0 - 9 digits recognition = 10 classes
Y = tf.placeholder(tf.float32, [None, nb_classes]) # 10열

W = tf.Variable(tf.random_normal([784, nb_classes]))
b = tf.Variable(tf.random_normal([nb_classes]))
# Hypothesis (using softmax)
# 다중 분류  softmax 결과는 확률 형태로 된다.
hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)
# Test model
# arg_max(): one-hot-encoding을 만들어 주는 함수(가장 확률이 높은것을 1로, 나머지는 0으로 만듬)
#학습을 한것에서 확률이 잴 높은 것을 하나 뽑아오라
# tf.arg_max(Y, 1)  실제 데이터
is_correct = tf.equal(tf.arg_max(hypothesis, 1), tf.arg_max(Y, 1)) # 10개의 예측값중에서 가장큰값을 구함
# Calculate accuracy
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32)) # float형으로 형변환 (정확도 구함)
# parameters
training_epochs = 15 # 학습 회수 15번 학습 했다 .
batch_size = 100 # batch_size : 큰 파일을 나눠서 읽어옴 (100개) - 메모리가 부족하기 때문에
# 55000 / 100 = 550
# epoch : 반복횟수(1번다 읽어온것)
print('데이터 갯수=', mnist.train.num_examples) # 55,000 개

# 한 epochs이 100개 사이즈로 나누어서 550 번 수행한다.
# 총 15 * 550 수행
with tf.Session() as sess:
    # Initialize TensorFlow variables
    sess.run(tf.global_variables_initializer())
    # Training cycle
    for epoch in range(training_epochs):
        avg_cost = 0
        total_batch = int(mnist.train.num_examples / batch_size)
        for i in range(total_batch): # 배치 사이즈를 100개로 나누어서 550 번씩 한다.
            batch_xs, batch_ys = mnist.train.next_batch(batch_size) #550개 씩 가져온다.
            c, _ = sess.run([cost, optimizer], feed_dict={X: batch_xs, Y: batch_ys})
            avg_cost += c / total_batch
    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost))
    print("Learning finished")

    # Test the model using test sets
    print("Accuracy: ", accuracy.eval(session=sess, feed_dict={X: mnist.test.images, Y: mnist.test.labels}))
    # Get one and predict
    r = random.randint(0, mnist.test.num_examples - 1)
    print("Label: ", sess.run(tf.argmax(mnist.test.labels[r:r + 1], 1)))
    print("Prediction: ", sess.run(tf.argmax(hypothesis, 1), feed_dict={X: mnist.test.images[r:r + 1]}))
    # don't know why this makes Travis Build error.
    plt.imshow(
        mnist.test.images[r:r + 1].reshape(28, 28),
        cmap='Greys',
        interpolation='nearest')
    plt.show()

 

TensorBoard를 이용한 그래프 시각화

머신러닝 알고리즘을 모니터링하고 문제를 해결하는 일은 버거운 작업이 될 수 있다. 특히 결과를 얻기

위해 긴 시간 학습이 완료되기를 기다려야 하는 상황이라면 더욱 힘들 수 있다. 이런 문제를 해결하기

위해 턴서플로에는 tensorboard 라는 계산 그래프 시각화 도구 가 있다. tensorboard를 이용해 학습이

진행되는 동안에도 중요한 값(비용, 정확도, 학습시간 등)을 시각화하고 그래프로 표현할 수 있다.

 

Tensorboard 가 잘 실행되지 않는 경우 해결법

 방법1. conda 명령어로 모든 모듈을 최신버전으로 update 한다

c:\> conda update --all

 방법2. tensorboard 버전을 1.10 버전으로 낮춰서 실행 해본다.

 

C:\pythonwork\python3\tensorflow\src\ch05\log_dir

mkdir C:\project\python3\tensorflow\src\log_dir

cd C:\project\python3\tensorflow\src

tensorboard --logdir=log_dir <-- tensorboard 실행

#--logdir=log_dir 주의에 공백 있으면 오류가 난다.

주위에 공백 있으면 안된다.

그리고 log_dri까지가 아니고 상위 폴더 까지 진행한다.

 

 

pycharm tensorboard

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

# 상수 선언
a = tf.constant(20, name="a")
b = tf.constant(30, name="b")
mul = a * b
# 세션 생성하기
sess = tf.Session()
# tensorboard 사용하기
# tensorboard 로그가 저장될 폴더(log_dir)가 생성된다.
tw = tf.summary.FileWriter("log_dir", graph=sess.graph)
# 세션 실행하기
print(sess.run(mul))

 

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

# 상수와 변수 선언하기
a = tf.constant(100, name="a")
b = tf.constant(200, name="b")
c = tf.constant(300, name="c")
v = tf.Variable(0, name="v")
# 곱셈을 수행하는 그래프 정의하기
calc = a + b * c
assign_op = tf.assign(v, calc) # calc에 저장된 값을 v변수에 할당
# 세션 생성하기
sess = tf.Session()
# TensorBoard 사용하기
# tensorboard 로그가 저장될 폴더(log_dir)가 생성된다.
tw = tf.summary.FileWriter("log_dir", graph=sess.graph)
# 세션 실행하기
print(sess.run(assign_op))
print(sess.run(v))

tensorboard --logdir=log_dir

 

import pandas as pd
import numpy as np
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

# 키, 몸무게, 레이블이 적힌 CSV 파일 읽어 들이기
csv = pd.read_csv("bmi.csv")
# 데이터 정규화
csv["height"] = csv["height"] / 200
csv["weight"] = csv["weight"] / 100
# 레이블을 배열로 변환하기
# - thin=(1,0,0) / normal=(0,1,0) / fat=(0,0,1)
bclass = {"thin": [1,0,0], "normal": [0,1,0], "fat": [0,0,1]}
csv["label_pat"] = csv["label"].apply(lambda x : np.array(bclass[x]))
# 테스트를 위한 데이터 분류
test_csv = csv[15000:20000]
test_pat = test_csv[["weight","height"]]
test_ans = list(test_csv["label_pat"])

# 플레이스홀더 선언하기
x = tf.placeholder(tf.float32, [None, 2]) # 키와 몸무게 데이터 넣기
y_ = tf.placeholder(tf.float32, [None, 3]) # 정답 레이블 넣기
# 변수 선언하기
W = tf.Variable(tf.zeros([2, 3])) # 가중치
b = tf.Variable(tf.zeros([3])) # 바이어스
# 소프트맥스 회귀 정의하기
y = tf.nn.softmax(tf.matmul(x, W) + b)
# 모델 훈련하기
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(cross_entropy)
# 정답률 구하기
predict = tf.equal(tf.argmax(y, 1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(predict, tf.float32))

# 세션 시작하기
sess = tf.Session()
# TensorBoard 사용하기 (추가)
# tensorboard 로그가 저장될 폴더(log_dir)가 생성된다.
tw = tf.summary.FileWriter("log_dir", graph=sess.graph)
# 변수 초기화하기
sess.run(tf.global_variables_initializer())
# 학습시키기
for step in range(3500):
    i = (step * 100) % 14000
    rows = csv[1 + i : 1 + i + 100]
    x_pat = rows[["weight","height"]]
    y_ans = list(rows["label_pat"])
    fd = {x: x_pat, y_: y_ans}
    sess.run(train, feed_dict=fd)
    if step % 500 == 0:
        cre = sess.run(cross_entropy, feed_dict=fd)
        acc = sess.run(accuracy, feed_dict={x: test_pat, y_: test_ans})
        print("step=", step, "cre=", cre, "acc=", acc)

# 최종적인 정답률 구하기
acc = sess.run(accuracy, feed_dict={x: test_pat, y_: test_ans})
print("정답률 =", acc)

 

AND와 OR 게이트는 직선을 그어 결과값이 1인 점을 구별할 수 있습니다.

그러나 XOR의 경우 선을 그어 구분할 수 없습니다.

 

 

다층 퍼셉트론(multilayer perceptron)

신경망을 이루는 가장 중요한 기본 단위는 퍼셉트론(perceptron) 입니다.

퍼셉트론은 입력 값과 활성화 함수(activation function: ex) sigmoid, ReLU)를 사용해 출력 값을 다음으로 넘기는 가장 작은 신경망 단위입니다.

활성화 함수라고 한다.

 

인공 신경망의 작동원리

인공 신경망은 입력값(x)에 가중치(w)를 곱하고 편향(b)을 더한 뒤 활성화 함수(Sigmoid, ReLU 등)를 거친 결과값 y를 만들어 내는 것이다.

그리고 원하는 y값을 만들어 내기 위해 w와 b의 값을 변경해 가면서 적절한 값을 찾아내는 최적화 과정을 학습(learning) 또는 훈련(training) 이라고 합니다.

y = sigmoid ( x * w + b )

출력 활성화함수 입력 가중치 편향

 

활성화 함수(activation function)

뇌 신경망에는 시냅스가 있는데, 인공 신경망에서는 이런 방식을 모방한 활성화 함수를 이용 한다.

 

overfitting처리해야할 방법중의 하나가 드롭아웃으로 하나 써서 OVERFITTING 으로 사용한다.

 

다층과 단층에 따라 정확도가 달라질 수 있다.

 

노드/ UNIT

DROPOUT 쓰면 정확도가 높아진다. ->다층 시 주로 사용해서 OVERFITTING 줄인다. 보통 30% 사용

 

LOSS가 작으면 학습이 잘 된것이다.

 

오차가 최소가 되는 예측/ 분류를 할려고 한다.

 

분류(classification) 모델

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as np
# 학습에 사용할 데이터 정의
# 털과 날개가 있느냐를 담은 특징 데이터를 구성한다.(있으면1, 없으면 0)
# [털, 날개]
x_data = np.array(
[[0, 0], [1, 0], [1, 1], [0, 0], [0, 0], [0, 1]])

# 1) 각 개체가 실제 어떤 종류인지를 나타내는 레이블(분류값) 데이터를 구성합니다.
# 2)위에서 정의한 특징 데이터의 각 개체가 포유류인지 조류인지, 아니면 제3의 종류인지를
# 기록한 실제 결과값이다.
# 3)다음과 같은 형식을 one-hot 형식의 데이터라고 합니다.
# 4)원-핫 인코딩(one-hot encoding)이란 데이터가 가질 수 있는 값들을 일렬로 나열한 배열을
# 만들고, 그중 표현하려는 값을 뜻하는 인덱스의 원소만 1로 표기하고 나머지 원소는 모두 0으로
# 채우는 표기법입니다.
# 5)예를 들어, 우리가 판별하고자 하는 개체의 종류는 기타, 포유류, 조류 이렇게 세 가지 이고,
# 이를 배열에 넣으면 [기타, 포유류, 조류]처럼 될 것이다.
# 6)각 종류의 인덱스는 기타=0, 포유류=1, 조류=2가 되겠죠. 이를 원-핫-인코딩 형식으로 만들면
# 다음처럼 된다.
# [기타, 포유류, 조류]
y_data = np.array([
[1, 0, 0], # 기타
[0, 1, 0], # 포유류
[0, 0, 1], # 조류
[1, 0, 0], # 기타
[1, 0, 0], # 기타
[0, 0, 1] # 조류
])


####################
# 신경망 모델 구성
####################
# 특징 X와 레이블 Y와의 관계를 알아내는 모델입니다.
# 플레이스홀더 X, Y 설정
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# 신경망은 2차원으로
# 가중치 변수 W는 [입력층(특징 수), 출력층(레이블 수)] -> [2, 3] 으로 설정
W = tf.Variable(tf.random_uniform([2, 3], -1., 1.)) # 균등 분포니깐 범위가 필요하다 -1 ~ 1 까지
# 편향을 각각 각 레이어의 아웃풋 갯수로 설정합니다.
# 편향은 아웃풋의 갯수, 즉 최종 결과값의 분류 갯수인 3으로 설정합니다.
# 편향 변수 b는 레이블 수인 3개의 요소를 가진 변수로 설정
b = tf.Variable(tf.zeros([3]))

# 신경망에 가중치 W과 편향 b을 적용합니다
L = tf.add(tf.matmul(X, W), b) # 히든 LAYER를 추가한다.
# 가중치와 편향을 이용해 계산한 결과 값에
# 텐서플로우에서 기본적으로 제공하는 활성화 함수인 ReLU 함수를 적용합니다.
L = tf.nn.relu(L) # 일정이상의 자격의 강도  값이 와야만 다음 층으로 전달한다.
#히든 LAVYER를 추가하는 순간 딥런닝이다.
# 마지막으로 softmax 함수를 이용하여 출력값을 사용하기 쉽게 만듭니다
# softmax 함수는 다음처럼 결과값을 전체합이 1인 확률로 만들어주는 함수입니다.
# 예) [8.04, 2.76, -6.52] -> [0.53 0.24 0.23]
model = tf.nn.softmax(L)

# 신경망을 최적화하기 위한 비용 함수를 작성합니다.
# 각 개별 결과에 대한 합을 구한 뒤 평균을 내는 방식을 사용합니다.
# 전체 합이 아닌, 개별 결과를 구한 뒤 평균을 내는 방식을 사용하기 위해 axis 옵션을 사용합니다.
# axis 옵션이 없으면 -1.09 처럼 총합인 스칼라값으로 출력됩니다.
# Y model Y * tf.log(model) reduce_sum(axis=1)
# 예) [[1 0 0] [[0.1 0.7 0.2] -> [[-1.0 0 0] -> [-1.0, -0.09]
# [0 1 0]] [0.2 0.8 0.0]] [ 0 -0.09 0]]
# 즉, 이것은 예측값과 실제값 사이의 확률 분포의 차이를 비용으로 계산한 것이며,
# 이것을 교차 엔트로피(Cross-Entropy) 라고 합니다.
#교차 엔트로피(Cross-Entropy) 다중 분류 할 경우 주로 사용한다.
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(model), axis=1))
# 경사하강법으로 비용을 최적화합니다.
# 성능을 높이기 위해서는 ADAM으로 사용할 수 도 있다.
#optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01)
optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
# AdamOptimizer성능을 향상시키는 겟
train_op = optimizer.minimize(cost)

####################
# 신경망 모델 학습
####################
# 텐서플로의 세션을 초기화
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# 위에서 구성한 특징과 레이블 데이터를 이용해 100번 학습을 진행
# 100 번 학습을 시킨다.
# 적은 값이 나왔을 때 학습을 크게 한다.
# 학습률이 보통 영향을 많이 준다ㅏ.
for step in range(100):
    # x_data날게 유무
    # y_data 실제 데이터 전달 3가지로 분류된다.
    sess.run(train_op, feed_dict={X: x_data, Y: y_data})
    # 학습 도중에 10번에 한번씩 손실값을 출력함
    if (step + 1) % 10 == 0:
        print(step + 1, sess.run(cost, feed_dict={X: x_data, Y: y_data}))

##############################
# 결과 확인
# 0: 기타 1: 포유류, 2: 조류
#############################
# 학습된 결과를 확인해보는 코드 작성
# 1)예측값인 model을 바로 출력하면 [0.2, 0.7, 0.1]과 같이 확률로 나오기 때문에, 요소 중
# 2)가장 큰 값의 인덱스를 찾아주는 argmax 함수를 사용하여 레이블 값을 출력
# 3)tf.argmax: 예측값과 실제값의 행렬에서 tf.argmax 를 이용해 가장 큰 값을 가져옵니다.
# 4)원-핫 인코딩을 거꾸로 한 결과를 만들어준다.
# 예) [[0 1 0] [1 0 0]] -> [1 0]
# [[0.2 0.7 0.1] [0.9 0.1 0.]] -> [1 0]
#높은 확률을 가진것을 뽑아온다.
prediction = tf.argmax(model, 1) # 예측값
target = tf.argmax(Y, 1) # 실제값
print('예측값:', sess.run(prediction, feed_dict={X: x_data}))
print('실제값:', sess.run(target, feed_dict={Y: y_data}))

# 정확도 출력
# 1)전체 학습 데이터에 대한 예측값과 실측값을 tf.equal()함수로 비교한 뒤,
# true, false 값으로 나온 결과를 다시 tf.cast()함수를 이용해 0과 1로 바꾸어
# 평균을 내면 간단히 정확도를 구할 수 있다.
# 2)프로그램을 실행해서 학습을 시키면, 손실값이 점점 줄어드는 것을 확인할 수 있다.
# 하지만, 실망스럽게도 아무리 학습횟수를 늘려도 정확도가 크게 높아지지 않는다.
# 그 이유는 신경망이 한 층밖에 안 되기 때문인데, 하나의 층(hidden layer)을 더 늘리면
# 정확도가 높아진다.
is_correct = tf.equal(prediction, target)
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
print('정확도: %.2f' % sess.run(accuracy * 100, feed_dict={X: x_data, Y: y_data}))

 

 

심층 신경망 구현

# 털과 날개가 있는지 없는지에 따라, 포유류인지 조류인지 분류하는 신경망 모델을 만들어봅니다.
# 신경망의 레이어를 여러개로 구성하여 말로만 듣던 딥러닝을 구성해 봅시다!
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import numpy as np
# 학습에 사용할 데이터 정의
# [털, 날개]
x_data = np.array(
[[0, 0], [1, 0], [1, 1], [0, 0], [0, 0], [0, 1]])
#있으면 1 없으면 0

# 원-핫 인코딩(one-hot encoding)이란 데이터가 가질 수 있는 값들을 일렬로 나열한 배열을
# 만들고, 그중 표현하려는 값을 뜻하는 인덱스의 원소만 1로 표기하고 나머지 원소는 모두 0으로
# 채우는 표기법입니다.
# [기타, 포유류, 조류] - ONE- HOT ENCODING
y_data = np.array([
[1, 0, 0], # 기타
[0, 1, 0], # 포유류
[0, 0, 1], # 조류
[1, 0, 0], # 기타
[1, 0, 0], # 기타
[0, 0, 1] # 조류
])


#####################
# 신경망 모델 구성
#####################
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# 다층 신경망을 만드는 것은, 앞에서 만든 단층 신경망 모델에 가중치와 편향을 추가해서 만든다.
# 가중치
# W1 = [2, 10] -> [특징, 은닉층의 뉴런수]
# W2 = [10, 3] -> [은닉층의 뉴런수, 분류 수]
# 편향
# b1 = [10] -> 은닉층의 뉴런 수
# b2 = [3] -> 분류 수
# 입력층과 출력층은 각각 특징과 분류 갯수로 맞추고, 중간의 연결 부분은 맞닿은 층의 뉴런 수와
# 같도록 맞추면 된다.
# 중간의 연결 부분을 은닉층(hidden layer)이라 하며, 은닉층의 뉴런 수는 하이퍼파라미터이므로 실험을
# 통해 가장 적절한 수를 정하면 된다.

# 첫번째 가중치의 차원은 [특징, 히든 레이어의 뉴런갯수] -> [2, 10] 으로 정합니다.
W1 = tf.Variable(tf.random_uniform([2, 10], -1., 1.))
# 두번째 가중치의 차원을 [첫번째 히든 레이어의 뉴런 갯수, 분류 갯수] -> [10, 3] 으로 정합니다.
# w2가 가중치 출력층을 포함하고 있따.
# 3 3가지로 분류되서
W2 = tf.Variable(tf.random_uniform([10, 3], -1., 1.))
# 편향을 각각 각 레이어의 아웃풋 갯수로 설정합니다.
# b1 은 히든 레이어의 뉴런 갯수로, b2 는 최종 결과값 즉, 분류 갯수인 3으로 설정합니다.
# 초기값은 0으로 만들어진다.
b1 = tf.Variable(tf.zeros([10])) # 은닉층의 뉴런 수
b2 = tf.Variable(tf.zeros([3])) # 분류 수
# 신경망의 히든 레이어에 가중치 W1과 편향 b1을 적용합니다
# 특징 입력값에 첫번째 가중치와 편향, 그리고 활성화 함수를 적용합니다.
L1 = tf.add(tf.matmul(X, W1), b1) # 입력층에서
L1 = tf.nn.relu(L1)   # 입력층에 relu를 하게 되면
# 출력층을 만들기 위해 두번째 가중치와 편향을 적용하여 최종 모델을 만듭니다.
# 최종적인 아웃풋을 계산합니다.
# 히든레이어에 두번째 가중치 W2[10,3]와 편향 b2[3]를 적용하여 최종적으로 3개의 출력값을 만들어냅니다.
model = tf.add(tf.matmul(L1, W2), b2)
# 마지막으로 손실함수를 작성합니다.
# 텐서플로우에서 기본적으로 제공되는 크로스 엔트로피 함수를 이용해 복잡한 수식을 사용하지
# 않고도 최적화를 위한 비용 함수를 다음처럼 간단하게 적용할 수 있습니다.
cost = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=model))
# 최적화 함수로 AdamOptimizer를 사용한다.
# 사용하는 최적화 함수에 따라 정확도나 학습 속도가 많이 달라질 수 있으며, AdamOptimizer는
# 앞에서 사용한 GrdadientDescentOptimizer보다 보편적으로 성능이 좋다고 알려져 있습니다.
optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
train_op = optimizer.minimize(cost)

#####################
# 신경망 모델 학습
#####################
# 텐서플로의 세션을 초기화
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# 위에서 구성한 특징과 레이블 데이터를 이용해 100번 학습을 진행
for step in range(100):
    sess.run(train_op, feed_dict={X: x_data, Y: y_data})
    # 학습 도중에 10번에 한번씩 손실값을 출력함
    if (step + 1) % 10 == 0:
        print(step + 1, sess.run(cost, feed_dict={X: x_data, Y: y_data}))


##############################
# 결과 확인
# 0: 기타 1: 포유류, 2: 조류
##############################
# 예측값과 실제값 출력
prediction = tf.argmax(model, 1)
target = tf.argmax(Y, 1)
print('예측값:', sess.run(prediction, feed_dict={X: x_data}))
print('실제값:', sess.run(target, feed_dict={Y: y_data}))
# 정확도 출력
is_correct = tf.equal(prediction, target)
accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
print('정확도: %.2f' % sess.run(accuracy * 100, feed_dict={X: x_data, Y: y_data}))

#오차가 쭐어든다는 것은 예측 분류 능력이 좋아진다.
# 손실함수 적게 하는 것
# optimizer -adam
# 학습률
# 학습 회수
# hidder layer만 추가했다.

 

 

Google’s playground : 구글 놀이터

구글은 뉴럴 네트워크를 학습하는 모습을 마치 손에 잡힐 듯이 느낄 수 있는 웹 사이트를 제공 하고 있다

http://playground.tensorflow.org

학습률(learning rate), 활성화함수(Activation Function), 정규화(Regularization) 유무, Problem Type

(Classification, Regression) 등을 선택하고, 은닉층(Hidden Layers)의 갯수와 뉴런(Neurous)의 갯수를

바꾸어 가면서 학습을 시킬 수 있고, 출력 결과를 바로 확인 할 수 있다.

 

neurons , node, unit

 

합성곱 신경망 (CNN : Convolutional Neural Network)

합성공 신경망(CNN : Convolutional Neural Network)은 1998년 얀 레쿤(Yann LeCun)교수가 소개한 이래로 널리 사용되고 있는 신경망 이론으로, 특히 이미지 인식 분야에서 강력한 성능을 발휘하고 있다.

이미지, 음성 등 다양한 것 사용할 수 있다.

신경망의 단점은 신경망의 층(Layer)이 늘어나면 제대로 학습하지 못한다는 문제가 있지만, CNN에서는 이 문제를 입력층과 출력층 사이에 합성곱층(Convolutional Layer)과 풀링층 (Pooling Layer)을 넣어서 보완하고 있다.

 

이미지를 배열로 만들어서  특징을 추출하기 위해 필터를 이용해서 matrix 곱하기 연산한다.

컨볼루션 신경망(CNN)

컨볼루션 신경망은 입력된 이미지의 특징을 추출하기 위해 마스크(필터, 윈도 또는 커널)를 적용하는 기법이다. ( 입력 이미지에 3 * 3 필터 적용 )

이미지를 뽑아내는 것이 합성곱이다. 필터를 사용한다.

 

 

맥스 풀링(max pooling) -> 가장 큰값을 가져오는 것

컨볼루션층을 통해서 이미지의 특징을 도출하고, 풀링층으로 넘어온다.

 

 

tensorflw는 복잡하다.

keras로 하면 간단하다.

 

이미지를 받으면 배열로 된다.

딥런닝에서 과적합을 막아주는 잴 자주 사용하는 방법은 드룹아웃 기법이다.

 

keras는 묘듈을 만드는 방법이 2가지가 있다. Sequential , Function

2.0 대에는 3가지가 있다. Sequential , Function , Subclassing

 

tensorflow는 javascript

 

텐서플로우 코어(Tensorflow core) -> 우리가 주로 하는 것

Tensorflow.js -> 브라우즈 기반으로 하는것

텐서플로우 라이트(Tensorflow Lite) ->스마트폰 안드로이등 등 임베디드 시스템에서 사용한 것

 

텐서플로우 익스텐디드(TensorFlow Extended, TFX) ->플랫폼

 

<!doctype html>
<html>
<head>
<title>TF.js Test</title>
<script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@0.6.1"></script>
<script type="text/javascript">
// 선형회귀 모델 생성
const model = tf.sequential();
model.add(tf.layers.dense({units: 1, inputShape: [1]}));
// 학습을 위핚 준비 : 손실 함수와 최적화 함수를 설정
model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});
// 학습 데이터 생성
const xs = tf.tensor2d([1, 2, 3, 4], [4, 1]);
const ys = tf.tensor2d([1, 3, 5, 7], [4, 1]);
// 데이터를 사용해서 학습
model.fit(xs, ys).then(() => {
// 학습된 모델을 가지고 추론
model.predict(tf.tensor2d([5], [1, 1])).print();
});
</script>
</head>
<body>
콘솔을 확인하세요.
</body>
</html>

 

 

 

 

!pip install tensorflow = 2.0

 

주피터 노트복

1. 가상홖경 만들기 : tensorflow2 라는 이름을 가진 python 3.6홖경(env) 생성

c:\> conda create -n tensorflow2 python=3.6

2. 가상홖경 홗성화

c:\> activate tensorflow2

3. Tensorflow 설치 : CPU 모드 설치

(tensorflow2) c:\> conda install tensorflow==2.0

4. Tensorflow 설치 버전 확인

c:\> python

>>> import tensorflow as tf

>>> print (tf.__version__)

5. Jupyter notebook 설치

c:\> activate tensorflow2

(tensorflow2)c:\> conda install jupyter notebook

(tensorflow2)c:\> jupyter notebook # jupyter notebook 실행

 

 

 

 

1. 아나콘다 프롬프트에 config 생성 코드를 입력핚다. 생성이 제대로 되었다면, 생성 위치가 출력된다.

 

2. config 파일을 메모장으로 연 뒤, 266라인에 있는 c.NotebookApp.notebook_dir = 'c:\users\계정디렉토리„

설정핚 후에 주피터 노트북을 다시 시작하면 새로 바뀐 화면을 볼 수 있다.

 

 

jupyter notebook에서는 tensorflow2를 따로 사용해야 한다.

가상 환경을 만들어서 jupyter note book사용하면 저장된 위치가 달라지고 속도가 늦어진다.

그래서 데이터 저장해야 할 위치를 정해야 한다.

간단하게 만들 떄는 virtualenv environment

체크 박스를 만들지 말고 해야 한다.

아니면 기존에 만든것을 불러온다.

 

conda -> python버전을 다르게 할 떄  버전 이나 파일 위치 설정한다.

체크 하지 말고  그럼 콘솔창에서 conda사용할 수 있다.

conda env list -> 현재 만들어진 가상환경의 목록이 만들어진다.

tensorflow2.0데가 설치되면 keras도 같이 설치된다.

 

colab 1.5 대

텐스플로 2.0은 keras

 

#import tensorflow.compat.v1 as tf
#tf.disable_v2_behavior()
import tensorflow as tf

tf.disable_v2_behavior()
# 상수 선언
hello = tf.constant('Hello, Tensorflow')
# 세션 시작
sess = tf.Session()
# 세션 실행
print(sess.run(hello))

 

session는 1점대로 사용한다. 2점 대는 즉시 생성해서 되지 않는다.

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
#import tensorflow as tf

tf.disable_v2_behavior()
# 상수 선언
hello = tf.constant('Hello, Tensorflow')
# 세션 시작
sess = tf.Session()
# 세션 실행
print(sess.run(hello))

 

import tensorflow as tf

print(tf.__version__)


# 상수 선언
hello = tf.constant('Hello, TensorFlow!')
print(hello) #데이터 타입이 출력되고
# tf.Tensor(b'Hello, TensorFlow!', shape=(), dtype=string)
# numpy() 메소드를 사용하여 텐서의 값을 numpy데이터 타입으로 변홖하여 출력
print(hello.numpy()) # 데이터 값이 출력
# b'Hello, TensorFlow!'
# decode('utf-8')메소드로 bytes 클래스를 str 클래스로 변홖
# 문자열 앞에 보이던 b가 사라짐
print(hello.numpy().decode('utf-8'))

#영문은 numpy()로 되지만 한글은 encoding decoding 문제가 있다.
# 상수 선언 : 핚글
hi = tf.constant('안녕')

print(hi) #tf.Tensor(b'\xec\x95\x88\xeb\x85\x95', shape=(), dtype=string)
print(hi.numpy()) #b'\xec\x95\x88\xeb\x85\x95'

# decode('utf-8')메소드로 bytes 클래스를 str 클래스로 변홖
print(hi.numpy().decode('utf-8')) #decode로 해야 한다. 
# 안녕

import tensorflow as tf
# 상수 정의
a = tf.constant(2)
b = tf.constant(3)
c = a+b
# 연산 결과 출력
print(a.numpy()) #a의 상수값을 출력 
print(b.numpy())
print(c.numpy())
print(a.numpy()+b.numpy())

#상수
import tensorflow as tf

#상수 선언
a = tf.constant(2)
b = tf.constant(3)
c = tf.constant(4)

# 연산 정의
cal1 = a + b * c
cal2 = (a + b) * c
# 연산 결과 출력
print(cal1.numpy())
print(cal2.numpy())

 

import tensorflow as tf
node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0)
# 연산
node3 = tf.add(node1, node2)
node4 = tf.multiply(node1, node2)
# 연산 결과 출력
print(node1.numpy())
print(node2.numpy())
print(node3.numpy())
print(node4.numpy())

import tensorflow as tf
# 상수 선언
x1 = tf.constant([1, 2, 3, 4])
x2 = tf.constant([5, 6, 7, 8])
# 연산
cal1 = tf.add(x1, x2) # 더하기
cal2 = tf.subtract(x1, x2) # 빼기
cal3 = tf.multiply(x1, x2) # 곱하기
cal4 = tf.divide(x1, x2) # 나누기
# 연산 결과 출력
print(cal1.numpy())
print(cal2.numpy())
print(cal3.numpy())
print(cal4.numpy())

import tensorflow as tf
# 변수 선언
v1 = tf.Variable(50) # v1 변수의 초기값 50
# 변수 출력
print('v1=', v1) # v1= <tf.Variable 'Variable:0' shape=() dtype=int32, numpy=50>
print('v1=', v1.numpy()) # v1= 50

import tensorflow as tf
# 변수 선언
v1 = tf.Variable(50) # v1 변수의 초기값 50
v2 = tf.Variable([1,2,3]) # rank: 1, shape: (3)
v3 = tf.Variable([[1],[2]]) # rank: 2, shape: (2,1)
# 변수 출력
print('v1=', v1.numpy()) # v1= 50
print('v2=', v2.numpy()) # v2= [1 2 3]
print('v3=', v3.numpy()) # v3= [[1][2]]

import tensorflow as tf
# 변수 선언
x = tf.Variable([[2, 2, 2],[2, 2, 2]]) # rank: 2, shape(2,3) 2행 3열
y = tf.Variable([[3, 3, 3],[3, 3, 3]]) # rank: 2, shape(2,3) 2행 3열
# 연산
z1 = tf.add(x, y) # 덧셈
z2 = tf.subtract(x, y) # 뺄셈
z3 = tf.multiply(x, y) # 곱셈
z4 = tf.matmul(x, tf.transpose(y)) # matrix 곱셈 (tf.transpose() : 젂치행렬)
z5 = tf.pow(x, 3) # 3제곱
# shape 구하기
print(x.get_shape()) # (2, 3)
print(y.get_shape()) # (2, 3)
# 연산 결과 출력
print(z1.numpy())
print(z2.numpy())
print(z3.numpy())
print(z4.numpy())
print(z5.numpy())

import tensorflow as tf
x = tf.Variable([[3., 3.]]) # shape: (1, 2) 1행 2열
y = tf.Variable([[2.],[2.]]) # shape: (2, 1) 2행 1열
mat = tf.matmul(x, y) # matrix 곱셈
# shape 구하기
print(x.get_shape()) # shape: (1, 2) 1행 2열
print(y.get_shape()) # shape: (2, 1) 2행 1열
# 연산 결과 출력
print(x.numpy())
print(y.numpy())
print(mat.numpy())

import tensorflow as tf
# 변수 선언
v1 = tf.Variable(tf.zeros([2,3])) # [[ 0. 0. 0.] [ 0. 0. 0.]]
v2 = tf.Variable(tf.ones([2,3], tf.int32)) # [[1 1 1] [1 1 1]]
v3 = tf.Variable(tf.zeros_like(tf.ones([2,3]))) # [[ 0. 0. 0.] [ 0. 0. 0.]]
v4 = tf.Variable(tf.fill([2,3], 2)) # [[2 2 2] [2 2 2]]
v5 = tf.Variable(tf.fill([2,3], 2.0)) # [[ 2. 2. 2.] [ 2. 2. 2.]]
# 변수 출력
print(v1.numpy())
print(v2.numpy())
print(v3.numpy())
print(v4.numpy())
print(v5.numpy())

 

난수 : 균등분포 정규분포  초기값 등 사용할 떄

uniform 균등분포 난수 를 생성할 떄 개수를 의미한다 .

 

import tensorflow as tf
# 난수 생성
a = tf.random.uniform([1], 0, 1) # 0 ~ 1 사이의 난수 1개 발생
b = tf.random.uniform([1], 0, 10) # 0 ~ 10 사이의 난수 1개 발생
print(a.numpy())
print(b.numpy())
""" 난수 생성 """
# 정규분포 난수 : 평균: -1, 표준편차: 4
norm = tf.random.normal([2, 3], mean=-1, stddev=4)
print(norm.numpy())
# 주어진 값들을 shuffle()함수로 무작위로 섞음
c = tf.constant([[1, 2], [3, 4], [5, 6]])
shuff = tf.random.shuffle(c)
print(shuff.numpy())
# 균등분포 난수 : 0 ~ 3 값 사이의 2행 3열 난수 발생
unif = tf.random.uniform([2,3], minval=0, maxval=3)
print(unif.numpy())

 Rank: 텐서의 차원은 rank로 나타낸다. 괄호 하나면 1차원 두개면 2차원 3개면 3차원

 Shape: 텐서의 행과 열이 몇 개인지를 나타낸다. -> 이미지 학습 할 떄 중요하다.

 Type: 텐서의 데이터가 어떤 형식인지를 나타낸다.

 

keras

tensorflow가 keras인수해서 기능을 많이 사용할 수 있다.

 

keras 환경구축

Windows 운영체제 홖경에서 python-3.x 또는 Anaconda3-5.x 가 설치된 다음에 tensorflow 를

설치하고, keras 를 설치핚다.

 CPU모드 설치

c:\> conda install keras

 GPU모드 설치

c:\> conda install keras-gpu

 keras 설치 확인

c:\> python

>>> import keras

Using Tensorflow backend

 

keras 환경구축 : PyCharm에서 keras 설치법

tensorflow2.0 이 설치되면 keras도 같이 설치 된다.

from keras.models import Sequential

from keras.layers import Dense

 Tensorflow2.0 에서 import 하는 방법

from tensorflow.keras.models import Sequential

from tensorflow.keras.layers import Dense