hypothesis = tf.sigmoid(tf.matmul(X, W) + b)

cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1-hypothesis))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)

import tensorflow as tf

# Logistic(=Sigmoid)

x_data = [[1, 2], [2, 3], [3, 1], [4, 3], [5, 3], [6, 2]]
y_data = [[0], [0], [0], [1], [1], [1]]

X = tf.placeholder(tf.float32, shape=[None, 2]) # shape[n개, 들어오는 개수]
Y = tf.placeholder(tf.float32, shape=[None, 1]) # shape[n개, 나가는 개수]

# tf.random_normal() 정규분포로부터의 난수값을 반환
W = tf.Variable(tf.random_normal([2, 1]), name='weight') # random_normal([X의 개수, Y의 개수]) = random_normal([들어오는 개수, 나가는 개수])
b = tf.Variable(tf.random_normal([1], name='bias')) # random_normal([Y의 개수]) = random_normal([나가는 개수])

hypothesis = tf.sigmoid(tf.matmul(X, W) + b)

# Cost/Loss Function, 모델에 맞춰서 이부분만 외워주면 됨
cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))

# Optimize
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)

predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32) # tf.cast() : dtype으로 바꿔줌, 0.5이상이면 1(=true), 아니면 0(=false)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32)) # tf.cast -> True = 1, False = 0

with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())
  
  for step in range(10001):
    cost_val, _ = sess.run([cost, optimizer], feed_dict={X: x_data, Y:y_data})
    
    if step % 200 == 0:
      print(step, cost_val)
  
  h, c, a  = sess.run([hypothesis, predicted, accuracy], feed_dict={X: x_data, Y: y_data})
  print("\nHypothesis: ", h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)

# X : 입력값 / Y : 결과값 (내가 가지고 있는 데이터)
# W : Weight / b : bias (hypothesis를 통해 두 변수의 최적의 값을 찾는게 목적)

logits = tf.matmul(X, W) + b
hypothesis = tf.nn.softmax(logits)

# X : 입력값 / Y : 결과값 (내가 가지고 있는 데이터)
# W : Weight / b : bias (hypothesis를 통해 두 변수의 최적의 값을 찾는게 목적)

cost = tf.reduce_mean(-tf.reduce_sum(Y*tf.log(hypothesis), axis=1))
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)

import tensorflow as tf

x_data = [[1, 2, 1, 1], [2, 1, 3, 2], [3, 1, 3, 4], [4, 1, 5, 5], [1, 7, 5, 5], [1, 2, 5, 6], [1, 6, 6, 6], [1, 7, 7, 7]]
y_data = [[0, 0, 1], [0, 0, 1], [0, 0, 1], [0, 1, 0], [0, 1, 0], [0, 1, 0], [1, 0, 0], [1, 0, 0]]

X = tf.placeholder(tf.float32, [None, 4]) # 위의 x_data가 4개라서
Y = tf.placeholder(tf.float32, [None, 3]) # 위의 y_data가 3개라서
nb_classes = 3

W = tf.Variable(tf.random_normal([4, nb_classes]), name='weight') # Weight는 [입력값, 출력값]을 차원으로 가진다
b = tf.Variable(tf.random_normal([nb_classes]), name='bias') # bias는 y의 출력값을 차원으로 가진다

# hypothesis
hypothesis = tf.nn.softmax(tf.matmul(X, W) + b)

cost = tf.reduce_mean(-tf.reduce_sum(Y*tf.log(hypothesis), axis=1)) # axis = 축
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)

# Training
with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())
  
  for step in range(2001):
    sess.run(optimizer, feed_dict={X: x_data, Y: y_data})
    
    if step % 200 == 0:
      print(step, sess.run(cost, feed_dict={X: x_data, Y: y_data}))
  
  
  # Test
  ## 입력이 1개일때 : 위에서 트레이닝을 통해 생성된 hypothesis에 [1, 11, 7, 9]를 대입했을때 어떻게 나오는지
  a = sess.run(hypothesis, feed_dict={X:[[1, 11, 7, 9]]})
  print(a, sess.run(tf.arg_max(a,1))) # tf.arg_max는 가장 큰 값을 골라서 주는것
  
  ## 입력이 1개일때 : 위에서 트레이닝을 통해 생성된 hypothesis에 [1, 11, 7, 9]를 대입했을때 어떻게 나오는지
  all = sess.run(hypothesis, feed_dict={X: [ [1, 11, 7, 9],
                                             [1, 3, 4, 3],
                                             [1, 1, 0, 1]]})
  print (all, sess.run(tf.arg_max(all,1)))

import tensorflow as tf
import numpy as np

xy = np.loadtxt('data-03-diabetes.csv', delimiter=',', dtype=np.float32) # 8개가 피처, 마지막 1개가 결과(1=당뇨병 / 0=!당뇨병)
x_data = xy[:, 0:-1]
y_data = xy[:, [-1]]

X = tf.placeholder(tf.float32, shape=[None, 8]) # X의 데이터가 8개, Feature개수
Y = tf.placeholder(tf.float32, shape=[None, 1]) # Y의 데이터는 1개

W = tf.Variable(tf.random_normal([8, 1]), name='weight')
b = tf.Variable(tf.random_normal([1]), name='bias')

hypothesis = tf.sigmoid(tf.matmul(X, W) + b)

cost = -tf.reduce_mean(Y * tf.log(hypothesis) + (1 - Y) * tf.log(1 - hypothesis))
train = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(cost)

predicted = tf.cast(hypothesis > 0.5, dtype=tf.float32)
accuracy = tf.reduce_mean(tf.cast(tf.equal(predicted, Y), dtype=tf.float32))

with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())
  
  feed = {X: x_data, Y: y_data}
  for step in range(10001):
    sess.run(train, feed_dict=feed)
    
    if step % 2000 == 0:
      print(step, sess.run(cost, feed_dict=feed))
    
  h, c, a = sess.run([hypothesis, predicted, accuracy], feed_dict=feed)
  print("\nHypothesis: ", h, "\nCorrect (Y): ", c, "\nAccuracy: ", a)

logits = tf.matmul(X, W) + b # score라고도 부름
hypothesis = tf.nn.softmax(logits)
cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))

logits = tf.matmul(X, W) + b # score라고도 부름
cost_i = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y_one_hot)
cost = tf.reduce_mean(cost_i)

import tensorflow as tf
import numpy as np

xy = np.loadtxt('data-04-zoo.csv', delimiter=',', dtype=np.float32)
x_data = xy[:, 0:-1] # 0~n-1
y_data = xy[:, [-1]] # n

nb_classes = 7 # 0~6개의 숫자라 7개

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

# 중요 One Hot이 아닌 값을 One Hot으로 reshape 하기
Y = tf.placeholder(tf.int32, [None, 1]) # 0 ~ 6의 숫자를 하나에 담아 주기 위함 shape=(n, 1)
Y_one_hot = tf.one_hot(Y, nb_classes) # one_hot()를 쓰면 한 차원이 증가하게 된다 shape=(n, 1, 7)
Y_one_hot = tf.reshape(Y_one_hot, [-1, nb_classes]) # 위에서 한 차원이 증가해서 다시 reshape 함 shape=(n, 7)

W = tf.Variable(tf.random_normal([16, nb_classes]), name='weight')
b = tf.Variable(tf.random_normal([nb_classes]), name='bias')

logits = tf.matmul(X, W) + b
hypothesis = tf.nn.softmax(logits)

cost_i = tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=Y_one_hot)

cost = tf.reduce_mean(cost_i)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.1).minimize(cost)

prediction = tf.argmax(hypothesis, 1) # Probability 0 ~ 6중 1나를 만들겠다는 의미
correct_prediction = tf.equal(prediction, tf.argmax(Y_one_hot, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) # tf.cast() : Tensor를 dtype으로 변환

with tf.Session() as sess:
  sess.run(tf.global_variables_initializer())
  
  for step in range(2000):
    sess.run(optimizer, feed_dict={X: x_data, Y: y_data})
    
    if step % 100 == 0:
      loss, acc = sess.run([cost, accuracy], feed_dict={X: x_data, Y: y_data})
      print("Step: {:5}\tLoss: {:.3f}\tAcc: {:.2%}".format(step, loss, acc))
      
  pred = sess.run(prediction, feed_dict={X: x_data})
  
  for p, y, in zip(pred, y_data.flatten()): # flatten : [[1], [0]] -> [1, 0]
                  print("[{}] Prediction: {} True Y: {}".format(p == int(y), p, int(y)))