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

descriptive names

Browse Source
This commit is contained in:
jbsch 2024-10-24 15:28:12 +05:30
parent dcf47d4821
commit 0ea341a18b
2 changed files with 44 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
machine_learning/ridge_regression/ridge_regression.py
View File

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

30
machine_learning/ridge_regression/test_ridge_regression.py
View File

@ -23,9 +23,9 @@ def test_feature_scaling():
Tests the feature_scaling function of RidgeRegression.
--------
>>> model = RidgeRegression()
>>> X = np.array([[1, 2], [2, 3], [3, 4]])
>>> X_scaled, mean, std = model.feature_scaling(X)
>>> np.round(X_scaled, 2)
>>> features = np.array([[1, 2], [2, 3], [3, 4]])
>>> features_scaled, mean, std = model.feature_scaling(features)
>>> np.round(features_scaled, 2)
array([[-1.22, -1.22],
[ 0. , 0. ],
[ 1.22, 1.22]])
@ -43,14 +43,14 @@ def test_fit():
>>> model = RidgeRegression(alpha=0.01,
... regularization_param=0.1,
... num_iterations=1000)
>>> X = np.array([[1], [2], [3]])
>>> y = np.array([2, 3, 4])
>>> features = np.array([[1], [2], [3]])
>>> target = np.array([2, 3, 4])
# Adding a bias term
>>> X = np.c_[np.ones(X.shape[0]), X]
>>> features = np.c_[np.ones(features.shape[0]), features]
# Fit the model
>>> model.fit(X, y)
>>> model.fit(features, target)
# Check if the weights have been updated
>>> np.round(model.theta, decimals=2)
@ -65,17 +65,17 @@ def test_predict():
>>> model = RidgeRegression(alpha=0.01,
... regularization_param=0.1,
... num_iterations=1000)
>>> X = np.array([[1], [2], [3]])
>>> y = np.array([2, 3, 4])
>>> features = np.array([[1], [2], [3]])
>>> target = np.array([2, 3, 4])
# Adding a bias term
>>> X = np.c_[np.ones(X.shape[0]), X]
>>> features = np.c_[np.ones(features.shape[0]), features]
# Fit the model
>>> model.fit(X, y)
>>> model.fit(features, target)
# Predict with the model
>>> predictions = model.predict(X)
>>> predictions = model.predict(features)
>>> np.round(predictions, decimals=2)
array([-0.97, 0. , 0.97])
"""
@ -86,9 +86,9 @@ def test_mean_absolute_error():
Tests the mean_absolute_error function of RidgeRegression
--------
>>> model = RidgeRegression()
>>> y_true = np.array([2, 3, 4])
>>> y_pred = np.array([2.1, 3.0, 3.9])
>>> mae = model.mean_absolute_error(y_true, y_pred)
>>> target = np.array([2, 3, 4])
>>> predictions = np.array([2.1, 3.0, 3.9])
>>> mae = model.mean_absolute_error(target, predictions)
>>> float(np.round(mae, 2))
0.07
"""