import tensorflow as tf
import numpy as np
print(tf.__version__)

test1 = [i for i in range(0,10) if i>2]
test1

test1 = list(range(0,10))
test2 = list(range(10,20))
print(test1)
print(test2)

test3 = []
for i,v in zip(test1,test2):
    test3.append([i,v])
test3

x1 = [x[0] for x in test3]
x2 = [x[1] for x in test3]
y = [i for i in range(100,110)]

print(x1)
print(x2)
print(y)

#x변수가 2개이기 때문에 W도 2개 설정
tf.random.set_seed(0)
W1 = tf.Variable(tf.random.uniform((1,),1., 10.0 ))
W2 = tf.Variable(tf.random.uniform((1,),1., 10.0 ))
b = tf.Variable(tf.random.uniform((1,),1., 10.0 ))

learning_rate = tf.Variable(0.001)
for i in range(1001):
    with tf.GradientTape() as tape:
        hypothesis = W1 * x1 + W2* x2 + b
        cost = tf.reduce_mean(tf.square(hypothesis - y))
    W1_grad, W2_grad, b_grad = tape.gradient(cost, [W1,W2,b])
    W1.assign_sub(learning_rate * W1_grad)
    W2.assign_sub(learning_rate * W2_grad)
    b.assign_sub(learning_rate * b_grad)
    
    if i % 50 ==0:
        print("{:5} | {:10.6f} | {:10.4f} | {:10.4f} | {:10.6f}".format(
        i, cost.numpy(), W1.numpy()[0], W2.numpy()[0], b.numpy()[0]))

x1 = [x for x in range(0,10)]
x2 = [x for x in range(10,20)]
x3 = [x for x in range(30,40)]
y = [x for x in range(100,110)]

print(x1)
print(x2)
print(x3)
print(y)

#변수를 한 메트릭스로 만들기
data =np.array([[i,v,z,h] for i,v,z,h in zip(x1,x2,x3,y)],dtype =np.float32)
data

#X, Y 로 데이터 나눠주기
X = data[:,:-1]
Y = data[:,[-1]]
print(X)
print(Y)

print(X.shape)
print(X.shape[1])

#W, b 설정해주기
W = tf.Variable(tf.random.normal((X.shape[1],1)))
b = tf.Variable(tf.random.normal((1,)))

# 예측 모델 및 경사하강법 적용
def predict(X):
    return tf.matmul(X,W) + b

learning_rate = 0.00001


for i in range(1001):
    with tf.GradientTape() as tape:
        cost =tf.reduce_mean((tf.square(predict(X) - y)))
        
    W_grad, b_grad = tape.gradient(cost, [W,b])
    
    W.assign_sub(learning_rate * W_grad)
    b.assign_sub(learning_rate * b_grad)
    
    if i % 500 ==0:
        print("{:5} | {:10.6f} | {:10.4f} | {:10.4f} | {:10.6f}".format(
            i, cost.numpy(), W.numpy()[0][0], W.numpy()[1][0], b.numpy()[0]))

#W값 확인
print(W)

#X값으로 해 도출
predict(X)

#임의의 값으로 해 도출
predict([[ 1.,  1.,  4.],[ 145.,  50.,  50.]]).numpy()

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

tf.random.set_seed(0)
print(tf.__version__)

#x1, x2를 각각 x_train의 2차원배열로 정의해줍니다.
x_train = [[1., 6.],
          [2., 5.],
          [3., 4.],
          [4., 3.],
          [5., 2.],
          [6., 1.]]

#각 배열의 도출 값을 선언합니다.
#1,6 -> 0
#6,1 -> 1

y_train = [[0.],
          [0.],
          [0.],
          [1.],
          [1.],
          [1.]]

#데이터 확인
print(x_train, y_train)

#test할 데이터를 세팅해 줍니다.
#2,6이 1인지 확인하기 위합니다.
x_test = [[2.,6.]]
y_test = [[0.]]

x_test,y_test

x1 = [x[0] for x in x_train]
x1

x1=[]
for x in range(len(x_train)):
    x1.append(x_train[x][0])
x1

x2 = [x[1] for x in x_train]
x2

x2=[]
for x in range(len(x_train)):
    x2.append(x_train[x][1])
x2

colors = []
for y in range(len(y_train)):
    colors.append(int(y_train[y][0]))
colors

colors = [int(y[0]) for y in y_train]
colors

#0은 보라색, 1은 노란색으로 표시가 됩니다.
colors = [int(y[0]) for y in y_train]

#x1, x2에 해당되는 값들은 삼각형으로 표시
plt.scatter(x1,x2, c= colors, marker='^')

#제가 찾고자 했던 x_test값 (2,6)은 빨간색으로 표시했습니다.
plt.scatter(x_test[0][0], x_test[0][1], c='red')

plt.xlabel("x1")
plt.ylabel("x2")
plt.show()

#dataset 만들기
#학습시킬 값을 dataset에 담아준다.
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset

#리스트 컴프리헨션
elem = [i for i in dataset]
print(elem)
print(len(elem))

#append로 확인하기
elem2= []
for i in dataset:
    elem2.append(i)
print(elem2)
len(elem2)

#초기값을 tf.random.normal로 설정해주기
W = tf.Variable(tf.random.normal((2, 1)))
b = tf.Variable(tf.random.normal((1,)))
print(W.numpy(),b.numpy())

#초기값을 tf.zeros로 설정해 주기
W = tf.Variable(tf.zeros([2,1]), name= 'weight')
b = tf.Variable(tf.zeros([1]), name='bias')
print(W.numpy(),b.numpy())

def logistic_regression(features):
    hypothesis = tf.divide(1., 1. + tf.exp(tf.matmul(features, W) + b))
    return hypothesis
    

def loss_fn(hypothesis, features, labels):
    cost = -tf.reduce_mean(labels * tf.math.log(logistic_regression(features)) + (1-labels) * tf.math.log(1-hypothesis))
    return cost
optimizer = tf.keras.optimizers.SGD(learning_rate =0.01)

test1 = 0.3
test2 = tf.cast(test1 > 0.5,dtype = tf.float32)
test2.numpy()

test1 = 0.6
test2 = tf.cast(test1 > 0.5,dtype = tf.float32)
test2.numpy()

test1 = 0.6
test2 = 0.6
test3 = tf.equal(test1,test2)
test3.numpy()

test4 = 0.5
test5 = 0.6
test6 = tf.equal(test4,test5)
test6.numpy()

test7 = tf.cast(tf.equal(test1,test2),dtype = tf.float32)
test7.numpy()

test8 = tf.cast(tf.equal(test4,test5),dtype = tf.float32)
test8.numpy()

def accuracy_fn(hypothesis, labels):
    predicted = tf.cast(hypothesis > 0.5, dtype =tf.float32)
    accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, labels),dtype =tf.int32))
    return accuracy

def grad(features, labels):
    with tf.GradientTape() as tape:
        loss_value = loss_fn(logistic_regression(features),features,labels)
        return tape.gradient(loss_value, [W,b])
    

#반복 횟수 선언
EPOCHS = 1001

for step in range(EPOCHS):
    #dataset을 몇 묶음씩 학습 시킬 것인지 정해준다
    #batch size를 선언해줄 수 있다.
    for features, labels in iter(dataset.batch(len(x_train))):
        #print(features)
        #print(labels)
        hypothesis = logistic_regression(features)
        grads = grad(features, labels)
        optimizer.apply_gradients(grads_and_vars =zip(grads,[W,b]))
        if step % 100 ==0:
            print("Iter : {}, Loss: {:.4f}".format(step, loss_fn(logistic_regression(features),features,labels)))
test_acc = accuracy_fn(logistic_regression(x_test),y_test)
print("Testset Accuracy: {:4f}".format(test_acc))

x_test2 = [[2.,6.]]
y_test2 = [[1.]]

#반복 횟수 선언
EPOCHS = 1001

for step in range(EPOCHS):
    #dataset을 몇 묶음씩 학습 시킬 것인지 정해준다
    #batch size를 선언해줄 수 있다.
    for features, labels in iter(dataset.batch(len(x_train))):
        #print(features)
        #print(labels)
        hypothesis = logistic_regression(features)
        grads = grad(features, labels)
        optimizer.apply_gradients(grads_and_vars =zip(grads,[W,b]))
        if step % 100 ==0:
            print("Iter : {}, Loss: {:.4f}".format(step, loss_fn(logistic_regression(features),features,labels)))
test_acc = accuracy_fn(logistic_regression(x_test2),y_test2)
print("Testset Accuracy: {:4f}".format(test_acc))

#반복 횟수 선언
EPOCHS = 1001

for step in range(EPOCHS):
    #dataset을 몇 묶음씩 학습 시킬 것인지 정해준다
    #batch size를 선언해줄 수 있다.
    for features, labels in iter(dataset.batch(2)):
        #print(features)
        #print(labels)
        hypothesis = logistic_regression(features)
        grads = grad(features, labels)
        optimizer.apply_gradients(grads_and_vars =zip(grads,[W,b]))
        if step % 100 ==0:
            print("Iter : {}, Loss: {:.4f}".format(step, loss_fn(logistic_regression(features),features,labels)))
test_acc = accuracy_fn(logistic_regression(x_test2),y_test2)
print("Testset Accuracy: {:4f}".format(test_acc))

import tensorflow as tf
import numpy as np

#x는 1,2,3,4,5 로 1씩 증가 되는 값을 세팅
x_data = [1,2,3,4,5]
#y는 2,4,6,8,10 으로 2씩 증가되는, 즉 x에 2를 곱한 값들로 세팅
y_data = [2,4,6,8,10]

import matplotlib.pyplot as plt

plt.plot(x_data, y_data, 'o')
plt.ylim(0,13)
plt.show()

#W,b는 랜덤값으로로 설정이 가능함
W = tf.Variable(5.0)
b = tf.Variable(0.5)

#y=Wx + b
hypothesis = W * x_data+b

#초기 값에 따른 가설값은 5.5, 10.5, 15.5, 20.5, 25.5 로 확인된다.
# 5.5 = 5.0 * 1 + 0.5 등등
hypothesis = W * x_data+b
hypothesis

#numpy를 활용해 확인가능
hypothesis.numpy()

#초기값으로 주어진 W, b값도 다시한번 확인
W , b

#마찬가지로 numpy로 확인가능
W.numpy(), b.numpy()

#그래프로 확인하기
#빨간선(선형)에 표시된 값은 이번에 구한 가설(y = hypothesis)이다.
#저 선형그래프를 초기 초기 데이터에 가장 근사하게 그려질 수있도록 만들어 줄 것이다.
plt.plot(x_data, hypothesis.numpy(), 'r-+')
plt.plot(x_data, y_data, 'go')
plt.ylim(0, 30)
plt.show()

#reduce_mean예시
v = [1.,2.,3.,4.]
tf.reduce_mean(v).numpy()

#square예시
tf.square(5).numpy()

#초기 cost도출
#cost는 에러, 오차, 이기 때문에 최대한 0에 수렴한 값이 되는것을 목표로 해야한다.
cost = tf.reduce_mean(tf.square(hypothesis - y_data))
cost.numpy()

#텐서플로우에서 경사하강법은 
#tf.GradientTape()을 with 와 함께사용한다.


#참고 : https://www.tensorflow.org/tutorials/customization/autodiff?hl=ko
#with구문안에 있는 모든 연산을 tape에 저장함
with tf.GradientTape() as tape:
    hypothesis = W * x_data + b
    cost = tf.reduce_mean(tf.square(hypothesis - y_data))
    
#gradient cost를 W,b로 각각 미분한 값을 W_grad와 b_grade에 입력해준다.
W_grad, b_grade = tape.gradient(cost, [W,b])
W_grad.numpy(), b_grade.numpy()

#learning_rate란 미분한 값을 얼마만큼의 비중을두고 반영할 것인가 정하는 것이다
#0.01, 0.001, 0.0001로 흔히 정한다고함.
#작으면 작을수록 정확한 값을 찾는데 유리함, 그만큼 많은 수를 반복 해야하긴함
learning_rate = 0.01
#assign_sub란 -= 와 같은 기능이다.
W.assign_sub(learning_rate * W_grad)#5(W초기값) - 0.69 = 4.31
b.assign_sub(learning_rate * b_grad)#0.5(b초기값) - 0.19 = 0.49
W.numpy(), b.numpy()

#확인하기 위하여 한번더 선언해줌
hypothesis = W * x_data + b
plt.plot(x_data, hypothesis.numpy(), 'r-+')
plt.plot(x_data, y_data, 'go')
plt.ylim(0, 30)
plt.show()
print(hypothesis)

#점선은 기본 데이터,
#빨간 선형그래프는 반영된 W,b와 데이터의 계산으로 표시된 것이다.
#즉 
#초기값설정에서 5.5 = 5 x 1 + 0.1
#경사하강법1회 4.8 = 4.31 x 1 + 0.49
#로 변화 되었다. 이것을 반복을 통하여 최적의 값을 찾아야한다.

import tensorflow as tf
import numpy as np

x_data = [1., 2., 3., 4., 5.]
y_data = [2., 4., 6., 8., 10.]

W = tf.Variable(4.0)
b = tf.Variable(0.5)
learning_rate = 0.0001


for i in range(10000):
    with tf.GradientTape() as tape:
        hypothesis = W * x_data + b
        cost = tf.reduce_mean(tf.square(hypothesis - y_data))
    W_grad, b_grad = tape.gradient(cost, [W, b])
    W.assign_sub(learning_rate * W_grad)
    b.assign_sub(learning_rate * b_grad)
    if i % 1000 == 0:
      print("{:5}|{:10.4f}|{:10.4f}|{:10.6f}".format(i, W.numpy(), b.numpy(), cost))
    
plt.plot(x_data, y_data, 'o')
plt.plot(x_data, hypothesis.numpy(), 'r-')
plt.ylim(0, 30)