CISC683

import numpy as np import matplotlib.pyplot as plt

def ols(X, y): ''' input: X: n, m+1 y: n, 1 output: beta_hat: m+1, 1 ''' return np.dot(np.linalg.inv(np.dot(X.T, X)), X.T).dot(y)

def pred(X, beta_hat): ''' input: X: (k, m+1) output: y_hat: (k, 1) ''' return np.dot(X, beta_hat)

x_data = [55, 53, 99, 74, 66] y_data = [60, 68, 95, 72, 69] X = np.array(x_data).reshape(len(x_data), -1) X = np.concatenate((np.ones((len(x_data), 1)), X), axis=1) y = np.array(y_data).reshape(len(y_data), -1) beta_hat = ols(X, y) print(beta_hat)

x_data_new = [64] X_new = np.array(x_data_new).reshape(len(x_data_new), -1) X_new = np.concatenate((np.ones((len(x_data_new), 1)), X_new), axis=1) y_hat = pred(X_new, beta_hat) print(y_hat)

X_data = [[59, 20, 22], [55, 22, 20], [62, 20, 16], [55, 18, 32], [52, 30, 27], [60, 24, 28], [59, 16, 24], [54, 22, 24], [83, 18, 14], [50, 21, 29], [73, 22, 21], [61, 25, 35], [42, 34, 21], [46, 25, 7], [54, 20, 30]] y_data = [195, 203, 214, 183, 130, 200, 212, 164, 108, 285, 207, 336, 280, 207, 264] assert len(X_data) == len(y_data) X = np.array(X_data) X = np.concatenate((np.ones((len(X_data), 1)), X), axis=1) y = np.array(y_data).reshape(len(y_data), -1)

beta_hat = ols(X, y) print(beta_hat)

x_data_new = [53, 20, 25] X_new = np.matrix(x_data_new) X_new = np.concatenate( ( np.ones(X_new.shape[0]).reshape(X_new.shape[0],1), X_new), axis=1) y_hat = pred(X_new, beta_hat) print(y_hat)

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

def initialize_params(m): w = np.zeros((m, 1)) b = 0 return w, b

def train_logistic(w, b, X, Y): ''' 此函数使用行向量形式; forward+back 整合 input: w -- weights (m, 1) b -- bias, scalar X: (m, n) Y: true labels (1, n) return: cost: cross-entropy loss dw: gradient over w (dim same as w) db: .. ''' n = X.shape[1] # forward A = sigmoid(np.dot(w.T, X) + b) cost = (-1/n) * np.sum( Y*np.log(A) + (1-Y)*np.log(1-A) ) # back dw = (1/n) * np.dot(X, (A-Y).T) db = (1/n) * np.sum(A-Y) assert(dw.shape == w.shape) assert(db.dtype == float) cost = np.squeeze(cost) grads = {"dw":dw, "db":db} return grads, cost

def optimizer(w, b, X, Y, num_iterations, learning_rate, print_cost = False): ''' inputs: same as above returns: params: w and b grads costs ''' costs = [] # training for i in range(num_iterations): # cost and gradient grads, cost = train_logistic(w, b, X, Y) # retrieve dw = grads["dw"] db = grads["db"] # update params w -= learning_rate*dw b -= learning_rate*db # record costs if i % 100 == 0: costs.append(cost) # print cost every 100 iter if print_cost and i%1000 == 0: print("cost after iter %i: %f"%(i, cost)) # record params = {"w": w, "b": b} grads = {"dw": dw, "db": db} return params, grads, costs

def predict(w, b, X): ''' X: new data ; (m, n) ''' n = X.shape[1] Y_prediction = np.zeros((1, n)) # initialze w = w.reshape(X.shape[0], 1) # prediction A = sigmoid(np.dot(w.T, X) + b) Y_prediction = np.where(A <= 0.5, 0 ,1) assert(Y_prediction.shape == (1, n)) return A

X_possible = [26.8, 27.3, 28.5, 30.3, 30.7] y_possible = [[1, 10], [2, 9], [8, 5], [9, 2], [10, 1]] y = [] X = [] for i, x in enumerate(X_possible): for j, n_y in enumerate(y_possible[i]): y1 = [j]*n_y X1 = [x]*n_y X += X1 y += y1 assert(len(X) == len(y))

m = 1 # X (m, n); y (1, n) X_train = np.array(X).reshape(m, -1) Y = np.array(y).reshape(1, -1) Y_train = np.where(Y==1, 0, 1) # male = 1; female = 0

w, b = initialize_params(m)

parameters, grads, costs = optimizer(w, b, X_train, Y_train, 200000, 0.015, True)

print ("w = " + str(parameters["w"])) print ("b = " + str(parameters["b"]))

X = np.arange(25.5, 31.1, 0.5).reshape(m,-1) X.shape

w = parameters["w"] b = parameters["b"]

Y_predict = predict(w, b, X) print(Y_predict)

sig_x = np.linspace(20, 36, 100).reshape(m, -1) sig_y = sigmoid(np.dot(w.T, sig_x) + b) fig = plt.figure() ax = fig.add_subplot(1, 1, 1) plt.scatter(X, Y_predict) plt.plot(sig_x.reshape(-1,), sig_y.reshape(-1,) , 'r', label="logistic") plt.legend(loc='upper left') plt.xlabel("tempreture") plt.ylabel("prob to be male") plt.show()

X = np.array([28]).reshape(m,-1) Y_predict = predict(w, b, X) print(Y_predict)

X = np.array([29]).reshape(m,-1) Y_predict = predict(w, b, X) print(Y_predict)

# x: (n,m+1) x_data = [[630, 35, 1.6], [550, 50, 2.4]] X = np.array(x_data).reshape(len(x_data), -1) X = np.concatenate( (X, np.ones((len(x_data), 1))), axis=1) m = X.shape[1]

# w: (m+1, n_class) 注意顺序⚠️; intercept 在最后面 W = [[ -0.03, 9.4847, -62.9414,54.4545], [ 0.2075, 12.3057,-27.9694, -244.1814] , [ 0.1824, 12.3408, -29.7338, -226.1336]] W = np.array(W).T assert(W.shape[0]==m)

# x (n,m+1) w (m+1 , 1) # row: for a instance; column: n_class f1, f2..fk f = np.dot(X, W) f

P = {} P_k = 1/ (1+ np.sum(np.exp(f), axis=1) ) P["Pk"] = P_k.reshape(2,1) for i in range(1, f.shape[1]+1): P["P"+str(i)] = P["Pk"] * np.exp(f[:,i-1].reshape(2,1))

P