def sigmoid(z):
	g = 1 / (1 + np.exp(-z))
	return g

def compute_cost(X, y, w, b, lambda_= 1):
	"""
    Computes the cost over all examples
    Args:
      X : (ndarray Shape (m,n)) data, m examples by n features
      y : (array_like Shape (m,)) target value 
      w : (array_like Shape (n,)) Values of parameters of the model      
      b : scalar Values of bias parameter of the model
      lambda_: unused placeholder
    Returns:
      total_cost: (scalar)         cost 
    """

	m, n = X.shape
	total_cost = 0
	for i in range(m):
		f_wb_i = sigmoid(np.dot(X[i], w) + b)
		loss = -y[i] * np.log(f_wb_i) - (1 - y[i]) * np.log(1 - f_wb_i)
		total_cost += loss

	total_cost = total_cost / m
	return total_cost

def compute_gradient(X, y, w, b, lambda_=None): 
    """
    Computes the gradient for logistic regression 
 
    Args:
      X : (ndarray Shape (m,n)) variable such as house size 
      y : (array_like Shape (m,1)) actual value 
      w : (array_like Shape (n,1)) values of parameters of the model      
      b : (scalar)                 value of parameter of the model 
      lambda_: unused placeholder.
    Returns
      dj_dw: (array_like Shape (n,1)) The gradient of the cost w.r.t. the parameters w. 
      dj_db: (scalar)                The gradient of the cost w.r.t. the parameter b. 
    """
    m, n = X.shape
    dj_dw = np.zeros(n)
    dj_db = 0.

    for i in range(m):
        f_wb_i = sigmoid(np.dot(X[i], w) + b)
        diff = f_wb_i - y[i]
        dj_db += diff
        for j in range(n):
            dj_dw[j] = dj_dw[j] + diff * X[i][j]
    
    dj_db = dj_db / m
    dj_dw = dj_dw / m
        
    return dj_db, dj_dw

def gradient_descent(X, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters, lambda_): 
    """
    Performs batch gradient descent to learn theta. Updates theta by taking 
    num_iters gradient steps with learning rate alpha
    
    Args:
      X :    (array_like Shape (m, n)
      y :    (array_like Shape (m,))
      w_in : (array_like Shape (n,))  Initial values of parameters of the model
      b_in : (scalar)                 Initial value of parameter of the model
      cost_function:                  function to compute cost
      alpha : (float)                 Learning rate
      num_iters : (int)               number of iterations to run gradient descent
      lambda_ (scalar, float)         regularization constant
      
    Returns:
      w : (array_like Shape (n,)) Updated values of parameters of the model after
          running gradient descent
      b : (scalar)                Updated value of parameter of the model after
          running gradient descent
    """
    
    # number of training examples
    m = len(X)
    
    # An array to store cost J and w's at each iteration primarily for graphing later
    J_history = []
    w_history = []

    w = copy.deepcopy(w_in)
    b = b_in
    
    for i in range(num_iters):
        dj_db, dj_dw = gradient_function(X, y, w, b, lambda_)
        w = w - alpha * dj_dw
        b = b - alpha * dj_db
        cost = cost_function(X, y, w, b, lambda_)
        J_history.append(cost)
        w_history.append(w)
        if i % math.ceil(num_iters / 10) == 0:
            print(f"{i:4d} cost: {cost:6f}, w: {w}, b: {b}")
        
    return w, b, J_history, w_history #return w and J,w history for graphing


def predict(X, w, b): 
    m, n = X.shape   
    p = np.zeros(m)
    for i in range(m):
        f_wb = sigmoid(np.dot(X[i], w) + b)
        p[i] = f_wb >= 0.5 
    return p

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
# 支持顯示中文
font_path = '/System/Library/Fonts/STHeiti Light.ttc'
custom_font = fm.FontProperties(fname=font_path)
plt.rcParams["font.family"] = custom_font.get_name()

# 載入訓練集
X_train, y_train = load_data("data/ex2data1.txt")
# 訓練模型
np.random.seed(1)
intial_w = 0.01 * (np.random.rand(2).reshape(-1,1) - 0.5)
initial_b = -8
iterations = 10000
alpha = 0.001
w_out, b_out, J_history,_ = gradient_descent(X_train ,y_train, initial_w, initial_b, compute_cost, compute_gradient, alpha, iterations, 0)

# 根據訓練結果（w_out和b_out）計算決策邊界
#f = w0*x0 + w1*x1 + b
# x1 = -1 * (w0*x0 + b) / w1
plot_x = np.array([min(X_train[:, 0]), max(X_train[:, 0])])
plot_y = (-1. / w_out[1]) * (w_out[0] * plot_x + b_out)
# 將訓練數據分類
x0s_pos = []
x1s_pos = []
x0s_neg = []
x1s_neg = []
for i in range(len(X_train)):
    x = X_train[i]
    # print(x)
    y_i = y_train[i]
    if y_i == 1:
        x0s_pos.append(x[0])
        x1s_pos.append(x[1])
    else:
        x0s_neg.append(x[0])
        x1s_neg.append(x[1])

# 繪圖
plt.figure(figsize=(8, 6))
plt.scatter(x0s_pos, x1s_pos, marker='o', c='green', label="Admitted")
plt.scatter(x0s_neg, x1s_neg, marker='x', c='red', label="Not admitted")
plt.plot(plot_x, plot_y, lw=1, label="決策邊界")
plt.xlabel('Exam 1 score', fontsize=12)
plt.ylabel('Exam 2 score', fontsize=12)
plt.title('在二維平面上可視化分類模型的決策邊界', fontsize=14)
plt.legend(fontsize=12, loc='upper center')
plt.grid(True)
plt.show()


# 使用訓練集計算預測準確率
p = predict(X_train, w_out, b_out)
print('Train Accuracy: %f'%(np.mean(p == y_train) * 100)) 
# Train Accuracy: 92.000000