mathdatech/Python
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Python.git synced 2024-12-18 01:00:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

resolved errors

Browse Source
This commit is contained in:
jbsch 2024-10-23 20:51:58 +05:30
parent b1353dddd4
commit 1713cbe7c2
2 changed files with 29 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
machine_learning/ridge_regression/__init__.py Normal file
View File

51
machine_learning/ridge_regression/model.py
View File

@ -3,52 +3,55 @@ import pandas as pd
class RidgeRegression: class RidgeRegression:
def __init__(self, alpha:float=0.001, regularization_param:float=0.1, num_iterations:int=1000) -> None: def __init__(self,
alpha:float=0.001,
regularization_param:float=0.1,
num_iterations:int=1000) -> None:
self.alpha:float = alpha self.alpha:float = alpha
self.regularization_param:float = regularization_param self.regularization_param:float = regularization_param
self.num_iterations:int = num_iterations self.num_iterations:int = num_iterations
self.theta:np.ndarray = None self.theta:np.ndarray = None
def feature_scaling(self, X:np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]: def feature_scaling(self, x:np.ndarray)-> tuple[np.ndarray, np.ndarray, np.ndarray]:
mean = np.mean(X, axis=0) mean = np.mean(x, axis=0)
std = np.std(X, axis=0) std = np.std(x, axis=0)
# avoid division by zero for constant features (std = 0) # avoid division by zero for constant features (std = 0)
std[std == 0] = 1 # set std=1 for constant features to avoid NaN std[std == 0] = 1 # set std=1 for constant features to avoid NaN
X_scaled = (X - mean) / std x_scaled = (x - mean) / std
return X_scaled, mean, std return x_scaled, mean, std
def fit(self, X:np.ndarray, y:np.ndarray) -> None: def fit(self, x:np.ndarray, y:np.ndarray) -> None:
X_scaled, mean, std = self.feature_scaling(X) x_scaled, mean, std = self.feature_scaling(x)
m, n = X_scaled.shape m, n = x_scaled.shape
self.theta = np.zeros(n) # initializing weights to zeros self.theta = np.zeros(n) # initializing weights to zeros
for i in range(self.num_iterations): for i in range(self.num_iterations):
predictions = X_scaled.dot(self.theta) predictions = x_scaled.dot(self.theta)
error = predictions - y error = predictions - y
# computing gradient with L2 regularization # computing gradient with L2 regularization
gradient = ( gradient = (
X_scaled.T.dot(error) + self.regularization_param * self.theta x_scaled.T.dot(error) + self.regularization_param * self.theta
) / m ) / m
self.theta -= self.alpha * gradient # updating weights self.theta -= self.alpha * gradient # updating weights
def predict(self, X:np.ndarray) -> np.ndarray: def predict(self, x:np.ndarray) -> np.ndarray:
X_scaled, _, _ = self.feature_scaling(X) x_scaled, _, _ = self.feature_scaling(x)
return X_scaled.dot(self.theta) return x_scaled.dot(self.theta)
def compute_cost(self, X:np.ndarray, y:np.ndarray) -> float: def compute_cost(self, x:np.ndarray, y:np.ndarray) -> float:
X_scaled, _, _ = self.feature_scaling(X) x_scaled, _, _ = self.feature_scaling(x)
m = len(y) m = len(y)
predictions = X_scaled.dot(self.theta) predictions = x_scaled.dot(self.theta)
cost = (1 / (2 * m)) * np.sum((predictions - y) ** 2) + ( cost = (
1 / (2 * m)) * np.sum((predictions - y) ** 2) + (
self.regularization_param / (2 * m) self.regularization_param / (2 * m)
) * np.sum(self.theta**2) ) * np.sum(self.theta**2)
return cost return cost
@ -61,21 +64,21 @@ class RidgeRegression:
# Example usage # Example usage
if __name__ == "__main__": if __name__ == "__main__":
df = pd.read_csv("ADRvsRating.csv") df = pd.read_csv("ADRvsRating.csv")
X = df[["Rating"]].values x = df[["Rating"]].values
y = df["ADR"].values y = df["ADR"].values
y = (y - np.mean(y)) / np.std(y) y = (y - np.mean(y)) / np.std(y)
# added bias term to the feature matrix # added bias term to the feature matrix
X = np.c_[np.ones(X.shape[0]), X] x = np.c_[np.ones(x.shape[0]), x]
# initialize and train the ridge regression model # initialize and train the ridge regression model
model = RidgeRegression(alpha=0.01, regularization_param=0.1, num_iterations=1000) model = RidgeRegression(alpha=0.01, regularization_param=0.1, num_iterations=1000)
model.fit(X, y) model.fit(x, y)
# predictions # predictions
predictions = model.predict(X) predictions = model.predict(x)
# results # results
print("Optimized Weights:", model.theta) print("Optimized Weights:", model.theta)
print("Cost:", model.compute_cost(X, y)) print("Cost:", model.compute_cost(x, y))
print("Mean Absolute Error:", model.mean_absolute_error(y, predictions)) print("Mean Absolute Error:", model.mean_absolute_error(y, predictions))