크레이지J의 탐구생활

# -*- coding: utf-8 -*-

'''

Created on Sat May 13 10:54:59 2017

@author: Junhee

'''

#

# complex algbra predict learning? is it possible???

# continous valued target bounded range (-1000,1000)

# not using polynomial modified input!. because I don't know

# what polynomial degree is correct. 

#

import numpy as np

import tensorflow as tf

import matplotlib.pyplot as plt

import time

bDrawFigure = True

# train yes or no

bTrain = 1

#learning_rate = 0.1

#learning_rate = 0.00001

learning_rate = 0.001

train_cnt = 4000

# unknown algbra function

def problem(x):

    y = np.sin(x/100)*500 + np.cos(x/27)*300 +x

    return y

# can u imagine? i dont know.

xrange = np.linspace(-500, 500, 1000)

y_correct = problem(xrange)

# draw graph?

if bDrawFigure:

    plt.figure()

    plt.plot(xrange, y_correct)

output_space = 2000     # tanh ; -1~1 X output_space ; output range! ; -2000~2000

                    # x domain ; -1000~1000

trainx = np.random.rand(train_cnt)*2000-1000   # training set must be shuffle!!!

trainx = trainx.reshape([-1,1])

trainy_cor = problem(trainx)

trainy_cor = trainy_cor.reshape([-1,1])

X = tf.placeholder(tf.float32, shape=[None,1])

Y = tf.placeholder(tf.float32, shape=[None,1])

# make network NN

W1 = tf.Variable(tf.random_normal([1,512]))

b1 = tf.Variable(tf.zeros([512]))

L1 = tf.nn.sigmoid(tf.matmul(X, W1)+b1)

#L1 = tf.nn.tanh(tf.matmul(X, W1)+b1) 

W2 = tf.Variable(tf.random_normal([512,1024]))

b2 = tf.Variable(tf.zeros([1024]))

L2 = tf.nn.sigmoid( tf.matmul(L1, W2)+b2) 

W3 = tf.Variable(tf.random_normal([1024,1024]))

b3 = tf.Variable(tf.zeros([1024]))

L3 = tf.nn.sigmoid( tf.matmul(L2, W3)+b3) 

W4 = tf.Variable(tf.random_normal([1024,1024]))

b4 = tf.Variable(tf.zeros([1024]))

L4 = tf.nn.sigmoid( tf.matmul(L3, W4)+b4) 

W5 = tf.Variable(tf.random_normal([1024,1]))

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

#Llast = tf.nn.tanh( tf.matmul(L4, W5)+b5) *output_space

#Llast = (tf.matmul(L4, W5)+b5) *output_space

Llast = (tf.matmul(L4, W5)+b5)

cost = tf.reduce_mean( tf.square(Llast-Y) )

train = tf.train.AdamOptimizer(learning_rate).minimize(cost)

sess = tf.Session()

sess.run( tf.global_variables_initializer())

param_list = {'W1':W1,'b1':b1,

              'W2':W2,'b2':b2,

              'W3':W3,'b3':b3,

              'W4':W4,'b4':b4,

              'W5':W5,'b5':b5,

              }

saver = tf.train.Saver(param_list)

#saver.restore(sess, './unknown_predict.ptl')    # continue train

print( "bTrain=", bTrain, " train_cnt=", train_cnt)

# train

oldtime = time.time()

if bTrain:

    for i in range(train_cnt) :

        _, _cost = sess.run( [train, cost], feed_dict={X:trainx, Y:trainy_cor})

        if i%100==(100-1):

            newtime = time.time()

            term = newtime-oldtime

            print( "train=",i," cost=",_cost, " remaintime=", ((train_cnt-i)/100+1)*term)

            oldtime=newtime

    saver.save(sess, './unknown_predict.ptl')

##########################################################

# test

saver.restore(sess, './unknown_predict.ptl')

test_cnt = 500

testx = np.random.rand(test_cnt)*1000-500  # training set must be shuffle!!!

testx = testx.reshape([-1,1])

testy_cor = problem(testx)

testy_cor = testy_cor.reshape([-1,1])

_llast = sess.run( Llast, feed_dict = { X:testx } )

testcost = np.mean( np.square(_llast-testy_cor))

print ( "cost=", testcost )

#for i in range(test_cnt):

#    print("input=", testx[i], " predict=", _llast[i], " correct=", testy_cor[i])

#draw compare

if bDrawFigure:

#    xrange = np.linspace(-1000, 1000, 2000)

    xrange = np.linspace(-500, 500, 1000)

    xrange = xrange.reshape(-1, 1)

    _llast2 = sess.run( Llast, feed_dict = { X:xrange } )

    xrange = xrange.reshape(-1)

    testyrange = _llast2.reshape(-1)

    plt.plot(xrange, testyrange, c='r')    

plt.show()

# -*- coding: utf-8 -*-

'''

Created on Sat May 13 10:54:59 2017

@author: Junhee

'''

#

# complex algbra predict learning? is it possible???

# continous valued target bounded range (-1000,1000)

# not using polynomial modified input!. because I don't know

# what polynomial degree is correct. 

#

import numpy as np

import tensorflow as tf

import matplotlib.pyplot as plt

import time

bDrawFigure = True

# train yes or no

bTrain = 1

#learning_rate = 0.1

#learning_rate = 0.0001

learning_rate = 0.00001

#learning_rate = 0.1

trainset_cnt = 200

epoch_cnt = 4000

#epoch_cnt = 40000

# unknown algbra function

def problem(x):

#    y = x**2

    y = x**2-30*x

    return y

# can u imagine? i dont know.

xrange = np.linspace(0, 100, 200)

y_correct = problem(xrange)

# draw graph?

if bDrawFigure:

    plt.figure()

    plt.plot(xrange, y_correct)

output_space = 40000     # tanh ; -1~1 X output_space ; output range! ; -2000~2000

                    # x domain ; -1000~1000

trainx = np.random.rand(trainset_cnt)*100-0   # training set must be shuffle!!!

trainx = trainx.reshape([-1,1])

trainy_cor = problem(trainx)

trainy_cor = trainy_cor.reshape([-1,1])

X = tf.placeholder(tf.float32, shape=[None,1])

Y = tf.placeholder(tf.float32, shape=[None,1])

# make network NN

W1 = tf.Variable(tf.random_normal([1,512]))

b1 = tf.Variable(tf.zeros([512]))

L1 = tf.nn.sigmoid(tf.matmul(X, W1)+b1)

#L1 = tf.nn.tanh(tf.matmul(X, W1)+b1) 

W2 = tf.Variable(tf.random_normal([512,1024]))

b2 = tf.Variable(tf.zeros([1024]))

L2 = tf.nn.sigmoid( tf.matmul(L1, W2)+b2) 

W3 = tf.Variable(tf.random_normal([1024,1024]))

b3 = tf.Variable(tf.zeros([1024]))

L3 = tf.nn.sigmoid( tf.matmul(L2, W3)+b3) 

W4 = tf.Variable(tf.random_normal([1024,1024]))

b4 = tf.Variable(tf.zeros([1024]))

L4 = tf.nn.sigmoid( tf.matmul(L3, W4)+b4) 

W5 = tf.Variable(tf.random_normal([1024,1]))

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

#Llast = tf.nn.tanh( tf.matmul(L4, W5)+b5) *output_space

#good

Llast = (tf.nn.sigmoid( tf.matmul(L4, W5)+b5)) *output_space - 500

#Llast = (tf.matmul(L4, W5)+b5) *output_space

# bad... 

#Llast = (tf.matmul(L4, W5)+b5)

cost = tf.reduce_mean( tf.square(Llast-Y) )

train = tf.train.AdamOptimizer(learning_rate).minimize(cost)

sess = tf.Session()

sess.run( tf.global_variables_initializer())

param_list = {'W1':W1,'b1':b1,

              'W2':W2,'b2':b2,

              'W3':W3,'b3':b3,

              'W4':W4,'b4':b4,              

              'W5':W5,'b5':b5,

              }

saver = tf.train.Saver(param_list)

#saver.restore(sess, './unknown_predict_poly.ptl')    # continue train

print( "bTrain=", bTrain, " trainset_cnt=", trainset_cnt, " epoch=cnt", epoch_cnt)

# train

oldtime = time.time()

if bTrain:

    for i in range(epoch_cnt) :

        _, _cost = sess.run( [train, cost], feed_dict={X:trainx, Y:trainy_cor})

        if i%100==(100-1):

            newtime = time.time()

            term = newtime-oldtime

            print( "train=",i," cost=",_cost, " remaintime=", ((epoch_cnt-i)/100+1)*term)

            oldtime=newtime

    saver.save(sess, './unknown_predict_poly.ptl')

##########################################################

# test

saver.restore(sess, './unknown_predict_poly.ptl')

#draw compare

if bDrawFigure:

#    xrange = np.linspace(-1000, 1000, 2000)

    xrange = np.linspace(1, 200, 200)

    xrange = xrange.reshape(-1, 1)

    _llast2 = sess.run( Llast, feed_dict = { X:xrange } )

    xrange = xrange.reshape(-1)

    testyrange = _llast2.reshape(-1)

    plt.plot(xrange, testyrange, c='r')    

plt.show()

bTrain= 1  trainset_cnt= 200  epoch=cnt 4000

train= 99  cost= 4.10605e+07  remaintime= 408.33133206844326

train= 199  cost= 6.47534e+06  remaintime= 374.9750850892067

train= 299  cost= 3.22122e+06  remaintime= 390.8726796555519

...

train= 3399  cost= 12447.5  remaintime= 73.77905233621597

train= 3499  cost= 12130.0  remaintime= 62.91447646141052

train= 3599  cost= 11828.8  remaintime= 51.30402812004089

train= 3699  cost= 11539.5  remaintime= 43.085111978054044

train= 3799  cost= 11257.4  remaintime= 33.96168860197067

train= 3899  cost= 10978.7  remaintime= 21.201974751949308

train= 3999  cost= 10699.7  remaintime= 11.279016330242158

INFO:tensorflow:Restoring parameters from ./unknown_predict_poly.ptl

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

"""

Created on Tue May 23 14:56:53 2017

@author: crazyj

"""

import numpy as np

import tensorflow as tf

# trainint set

X_train = np.array( [[0,0], [0,1], [1,0], [1,1]])

T_train = np.array( [[0], [1], [1], [0]] )

# placeholder

X = tf.placeholder(tf.float32, [None, 2])

T = tf.placeholder(tf.float32, [None, 1])

# variable

W1 = tf.Variable(tf.truncated_normal([2,4]))

b1 = tf.Variable(tf.zeros([4]))

W2 = tf.Variable(tf.truncated_normal([4,1]))

b2 = tf.Variable(tf.zeros([1]), dtype=tf.float32)

# model

A1 = tf.matmul(X, W1)+b1

Z1 = tf.sigmoid(A1)

A2 = tf.matmul(Z1, W2)+b2

Z2 = tf.sigmoid(A2)

learn_rate = 0.1

Cost = tf.reduce_mean(tf.reduce_sum(tf.square(Z2-T), 1))

train = tf.train.GradientDescentOptimizer(learn_rate).minimize(Cost)

predict = Z2

sess = tf.Session()

sess.run(tf.global_variables_initializer())

for i in range(5000):

    _train, _Cost = sess.run([train, Cost], feed_dict={X:X_train, T:T_train})

    print( "cost=", _Cost)

_predict = sess.run([predict], feed_dict={X:X_train})

print("predict=", _predict)

print("result=", np.array(np.array(_predict)>=0.5, np.int))

cost= 0.021748

cost= 0.0217359

cost= 0.0217239

predict= [array([[ 0.10571096],

       [ 0.86153752],

       [ 0.84178925],

       [ 0.17739831]], dtype=float32)]

result= [[[0]

  [1]

  [1]

  [0]]]

#!/usr/bin/env python3

# -*- coding: utf-8 -*-

"""

Created on Tue May 23 14:10:10 2017

@author: crazyj

"""

import numpy as np

import os

# xor simple network.

#   X(2) - 2 - Y(1)

# sigmoid activation function use.

# manual gradient

#

# if fail?, try again!

#   local minima problem exists... 

#   make deep and wide network.

#

X = np.array( [[0,0], [0,1], [1,0], [1,1]])

T = np.array( [[0], [1], [1], [0]] )

np.random.seed(int(os.times()[4]))

W1 = np.random.randn(2,2)

b1 = np.zeros([2])

W2 = np.random.randn(2,1)

b2 = np.zeros([1])

def Sigmoid(X):

    return 1/(1+np.exp(-X))

def Predict(X,  W1, b1, W2, b2):

    Z1 = np.dot(X, W1)+b1

    A1 = Sigmoid(Z1)

    Z2 = np.dot(A1, W2)+b2

    A2 = Sigmoid(Z2)

    Y = A2

    return Y

def Cost(X, W1, b1, W2, b2, T):

    epsil = 1e-5

    Z1 = np.dot(X, W1)+b1

    A1 = Sigmoid(Z1)

    Z2 = np.dot(A1, W2)+b2

    A2 = Sigmoid(Z2)

    Y = A2

    return np.mean(-T*np.log(Y+epsil)-(1-T)*np.log(1-Y+epsil))

def Gradient(learning_rate, X, W1, b1, W2, b2, T):

    Z1 = np.dot(X, W1)+b1

    A1 = Sigmoid(Z1)

    Z2 = np.dot(A1, W2)+b2

    A2 = Sigmoid(Z2)

    deltaY = A2-T

    deltaA1 = np.dot(deltaY, W2.T) * (A1*(1-A1))

    m = len(X)

    gradW2 = np.dot(A1.T, deltaY)

    gradW1 = np.dot(X.T, deltaA1)

    W2 = W2-(learning_rate/m)*gradW2

    b2 = b2-(learning_rate/m)*np.sum(deltaY)

    W1 = W1-(learning_rate/m)*gradW1

    b1 = b1-(learning_rate/m)*np.sum(deltaA1)

    return (W1, b1, W2, b2)

for i in range(3000):

    J= Cost(X,W1,b1,W2,b2,T)

    W1,b1,W2,b2 = Gradient(1.0, X, W1, b1, W2, b2, T)

    print ("Cost=",J)

Y = Predict(X, W1, b1, W2, b2)

print("predict=", Y)

Cost= 0.351125685078

predict= [[ 0.50057071]

 [ 0.49643107]

 [ 0.99648031]

 [ 0.00640712]]

Cost= 0.00403719259697

predict= [[ 0.00475473]

 [ 0.99634993]

 [ 0.99634975]

 [ 0.00409427]]