def fit(self, x_train, y_train):
"""
Fit the model according to the given training data.
Args:
x_train: a 1d or 2d numpy ndarray for the samples
y_train: a scalar or a numpy ndarray for the correct labels
Returns:
self : object
None on any error.
Raises:
This method should not raise any Exception.
"""
# self.model.fit(x_train, y_train)
# self.thetas = np.hstack((self.model.intercept_[:,None], self.model.coef_)).reshape(-1,1)
# return self.thetas
# Your code here
thetas = np.zeros((x_train.shape[1] + 1,1))
np.insert(x_train, 0, 1,axis=1)
m = x_train.shape[0]
for i in range(5):
# print("cost: {}".format(vec_log_loss_(y_train,y_pred,m)),end='\r')
y_pred = sigmoid_(x_train.dot(thetas))
grad = vec_log_gradient_(x_train,y_train,y_pred)
thetas = thetas - self.alpha * 0.5 * (1./m) * grad
if i % 150 == 0 and self.verbose == True:
print("epoch {} : loss {}".format(i,vec_log_loss_(y_train,y_pred,m)))4
self.thetas = thetas
return self.thetas
def logistic_predict(x, theta): """Computes the vector of prediction y_hat from two non-empty numpy.ndarray. Args: x: has to be an numpy.ndarray, a vector of dimension m * n. theta: has to be an numpy.ndarray, a vector of dimension (n + 1) * 1. Returns: y_hat as a numpy.ndarray, a vector of dimension m * 1. None if x or theta are empty numpy.ndarray. None if x or theta dimensions are not appropriate. Raises: This function should not raise any Exception. """ if len(x) < 1 or len(theta) < 1 or x is None or theta is None: return None return sigmoid_(np.matmul(add_intercept(x), theta))
def predict(self, x_train): """ Predict class labels for samples in x_train. Arg: x_train: a 1d or 2d numpy ndarray for the samples Returns: y_pred, the predicted class label per sample. None on any error. Raises: This method should not raise any Exception. """ # Your code here #without intercept column x_train = np.insert(x_train, 0, 1,axis=1) return sigmoid_((x_train.dot(self.thetas)))
def vec_reg_logistic_grad(y, x, theta, lambda_):
"""Computes the regularized linear gradient of three non-empty numpy.ndarray, without any for-loop. The three arrays must have compatible dimensions."""
if isinstance(x, np.ndarray) == 1 and isinstance(
y, np.ndarray) == 1 and isinstance(theta, np.ndarray) == 1:
if isinstance(lambda_, (int, float)) == 1:
if len(y) == len(x) and len(x[0]) == len(theta):
y_pred = sigmoid_(np.dot(x, theta))
temp = np.dot(x.T, (y_pred - y)) / len(x)
res = np.dot(x.T, (y_pred - y)) / len(x) + np.dot(
lambda_ / len(x), theta)
res[0] = temp[0]
return (res)
else:
print("vec_reg_log_gradient: error in size of x, y or theta")
else:
print("vec_reg_log_gradient: lamda is not a scalar")
else:
print("vec_reg_log_gradient: error in type of x, y or theta")
def logistic_predict(x, theta):
"""Computes the vector of prediction y_hat from two non-empty numpy.ndarray.
Args:
x: has to be an numpy.ndarray, a vector of dimension m * n.
theta: has to be an numpy.ndarray, a vector of dimension (n + 1) * 1.
Returns:
y_hat as a numpy.ndarray, a vector of dimension m * 1.
None if x or theta are empty numpy.ndarray.
None if x or theta dimensions are not appropriate.
Raises:
This function should not raise any Exception.
"""
if x.ndim == 1:
x = x.reshape(len(x), 1)
print(x.shape, theta.shape)
intercept = np.ones((x.shape[0], 1))
x = np.append(intercept, x, axis=1)
return sigmoid_(x.dot(theta))
def reg_logistic_grad(y, x, theta, lambda_):
"""Computes the regularized linear gradient of three non-empty numpy.ndarray, with two for-loop. The three arrays must have compatible dimensions."""
if isinstance(y, np.ndarray) == 1 and isinstance(x, np.ndarray) == 1 and isinstance(theta, np.ndarray) == 1:
if isinstance(lambda_, (int, float)) == 1:
if len(x) == len(y):
if len(x[0]) == len(theta):
y_pred = sigmoid_(np.dot(x, theta))
res = np.zeros(len(x[0]))
res[0] = sum((y_pred - y) * (x[:,0])) / len(x)
for j in range(1,len(theta)):
res[j] = sum((y_pred - y) * (x[:,j]) + lambda_ * theta[j]) / len(x)
return(res)
else:
print("reg_log_grad: x's columns is not equel to theta's lines")
else:
print("reg_log_grad: lamda not a float / int")
else:
print("reg_log_grad: x and y do not have the same number of lines")
else:
print("reg_log_grad: At least one argument is not a np.ndaray")
if y_true.size > 1:
x = np.transpose(x)
for i, row in enumerate(x):
sigma.append(np.sum((y_pred - y_true).dot(x[i])))
return sigma
for i, row in enumerate(x):
sigma.append(np.sum((y_pred - y_true) * x[i]))
return np.array(sigma)
if __name__ == "__main__":
x = [1, 4.2] # 1 represent the intercept
y_true = 1
theta = [0.5, -0.5]
x_dot_theta = sum([a * b for a, b in zip(x, theta)])
y_pred = sigmoid_(x_dot_theta)
print(log_gradient_(x, y_pred, y_true))
x = [1, -0.5, 2.3, -1.5, 3.2]
y_true = 0
theta = [0.5, -0.5, 1.2, -1.2, 2.3]
x_dot_theta = sum([a * b for a, b in zip(x, theta)])
y_pred = sigmoid_(x_dot_theta)
print(log_gradient_(x, y_true, y_pred))
x_new = [[1, 2, 3, 4, 5], [1, 6, 7, 8, 9], [1, 10, 11, 12, 13]]
# first column of x_new are intercept values initialized to 1
y_true = [1, 0, 1]
theta = [0.5, -0.5, 1.2, -1.2, 2.3]
x_new_dot_theta = []
for i in range(len(x_new)):
my_sum = 0
for j in range(len(x_new[i])):
import numpy as np from sigmoid import sigmoid_ from vec_log_loss import vec_log_loss_ # x = 4 # y_true = 1 # theta = 0.5 # y_pred = sigmoid_(x * theta) # m = 1 # # length of y_true is 1 # print(vec_log_loss_(y_true, y_pred, m)) # 0.1269280110429715 x = np.array([1, 2, 3, 4]) y_true = 0 theta = np.array([-1.5, 2.3, 1.4, 0.7]) y_pred = sigmoid_(np.dot(x, theta)) m = 1 print(vec_log_loss_(y_true, y_pred, m)) # x_new = np.arange(1, 13).reshape((3, 4)) # y_true = np.array([1, 0, 1]) # theta = np.array([-1.5, 2.3, 1.4, 0.7]) # y_pred = sigmoid_(np.dot(x_new, theta)) # m = len(y_true) # print(vec_log_loss_(y_true, y_pred, m))
This function should not raise any Exception.
"""
if m > 1:
if y_true.size != m or y_pred.size != y_true.size:
return (None)
return (-1 / m * (np.dot(y_true, np.log(y_pred)) + np.dot(
(1 - y_true), np.log(1 - y_pred))))
return (y_true * np.log(y_pred + eps) + (1 - y_true) * np.log(1 - y_pred))
if __name__ == "__main__":
# Test n.1
x = 4
y_true = 1
theta = 0.5
y_pred = sigmoid_(x * theta)
m = 1 # length of y_true is 1
print(vec_log_loss_(y_true, y_pred, m))
# 0.12692801104297152
# Test n.2
x = np.array([1, 2, 3, 4])
y_true = 0
theta = np.array([-1.5, 2.3, 1.4, 0.7])
y_pred = sigmoid_(np.dot(x, theta))
m = 1
print(vec_log_loss_(y_true, y_pred, m))
# 10.100041078687479
# Test n.3
x_new = np.arange(1, 13).reshape((3, 4))
def vec_log_gradient(x, y, theta):
x_pr = add_intercept(x)
m = y.shape[0]
sig = sigmoid_(np.dot(x_pr, theta))
return (1 / m) * (np.dot(x_pr.T, (sig - y)))
import numpy as np from sigmoid import sigmoid_ # Example 1: x = np.array([-4]) print(sigmoid_(x)) # Output: array([0.01798620996209156]) # Example 2: x = np.array([2]) print(sigmoid_(x)) # Output: array([0.8807970779778823]) # Example 3: x = np.array([[-4], [2], [0]]) print(sigmoid_(x)) # Output: # array([[0.01798620996209156], [0.8807970779778823], [0.5]])
# theta = 0.5
# y_pred = sigmoid_(x * theta)
# m = 1
# length of y_true is 1
# print(log_loss_(y_true, y_pred, m))
# 0.12692801104297152
# # Test n.2
# x = [1, 2, 3, 4]
# y_true = 0
# theta = [-1.5, 2.3, 1.4, 0.7]
# x_dot_theta = sum([a*b for a, b in zip(x, theta)])
# y_pred = sigmoid_(x_dot_theta)
# m = 1
# print(log_loss_(y_true, y_pred, m))
# # 10.100041078687479
# # # Test n.3
x_new = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
y_true = [1, 0, 1]
theta = [-1.5, 2.3, 1.4, 0.7]
x_dot_theta = []
for i in range(len(x_new)):
my_sum = 0
# for j in range(len(x_new[i])):
# my_sum += x_new[i][j] * theta[j]
my_sum = sum([a * b for a, b in zip(x_new[i], theta)])
x_dot_theta.append(my_sum)
y_pred = sigmoid_(x_dot_theta)
m = len(y_true)
print(log_loss_(y_true, y_pred, m))
# # 7.233346147374828
import numpy as np from sigmoid import sigmoid_ from vec_log_loss import vec_log_loss_ # Test n.1 x = 4 y_true = 1 theta = 0.5 y_pred = sigmoid_(x * theta) m = 1 # length of y_true is 1 print(vec_log_loss_(y_true, y_pred, m)) # 0.12692801104297152 # Test n.2 x = np.array([1, 2, 3, 4]) y_true = 0 theta = np.array([-1.5, 2.3, 1.4, 0.7]) y_pred = sigmoid_(np.dot(x, theta)) m = 1 print(vec_log_loss_(y_true, y_pred, m)) # 10.100041078687479 # Test n.3 x_new = np.arange(1, 13).reshape((3, 4)) y_true = np.array([1, 0, 1]) theta = np.array([-1.5, 2.3, 1.4, 0.7]) y_pred = sigmoid_(np.dot(x_new, theta)) # convert en list forcement ! m = len(y_true) print(vec_log_loss_(y_true, y_pred, m)) # 7.233346147374828
somme += (y_true[i] * math.log(y_pred[i] + eps) + (1 - y_true[i]) * math.log(1 - y_pred[i] + eps))
J = - (1 / m) * somme
return (J)
else:
print("log_loss: y_true and y_red are not the same size")
elif isinstance (y_true, (int, float)) == 1 and isinstance(y_pred, (int, float)) == 1:
J = - (1 / m) * (y_true * math.log(y_pred + eps) + (1 - y_true) * math.log(1 - y_pred + eps))
return (J)
else:
print("log_loss: error with var type")
# Test n.1
x = 4
y_true = 1
theta = 0.5
y_pred = sigmoid_(x * theta)
m = 1 # length of y_true is 1
print(log_loss_(y_true, y_pred, m))
# Test n.2
x = [1, 2, 3, 4]
y_true = 0
theta = [-1.5, 2.3, 1.4, 0.7]
x_dot_theta = sum([a*b for a, b in zip(x, theta)])
y_pred = sigmoid_(x_dot_theta)
m = 1
print(log_loss_(y_true, y_pred, m))
# Test n.3
x_new = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
y_true = [1, 0, 1]
lambda_: a float for the regularization parameter
eps: epsilon (default=1e-15)
Returns:
The logistic loss value as a float.
None on any error.
Raises:
This function should not raise any Exception.
"""
y = y_true
h = y_pred
j = (1 / m) * np.sum((-y.T) @ np.log(h + eps) -
(1 - y).T @ (1 - np.log(h + eps)) +
(np.dot(lambda_, theta) * theta))
return j
if __name__ == "__main__":
x_new = np.arange(1, 13).reshape((3, 4))
y_true = np.array([1, 0, 1])
theta = np.array([-1.5, 2.3, 1.4, 0.7])
h = x_new.dot(theta)
y_pred = sigmoid_(h)
m = len(y_true)
print(reg_log_loss_(y_true, y_pred, m, theta, 0.0))
x_new = np.arange(1, 13).reshape((3, 4))
y_true = np.array([1, 0, 1])
theta = np.array([-1.5, 2.3, 1.4, 0.7])
y_pred = sigmoid_(np.dot(x_new, theta))
m = len(y_true)
print(reg_log_loss_(y_true, y_pred, m, theta, 0.5))
