Upload 5 files

src/model.py

@@ -0,0 +1,99 @@
+import sys
+sys.path.append('..')
+
+import pandas as pd
+import os
+import random
+import joblib
+from time import perf_counter
+
+from src.preprocessing import outlier_detection,box_cox_transformation
+from sklearn.linear_model import LinearRegression
+from sklearn.svm import LinearSVR
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.ensemble import GradientBoostingRegressor
+
+
+from sklearn.metrics import r2_score,mean_squared_error
+from sklearn.model_selection import train_test_split,KFold,cross_val_score
+from sklearn.preprocessing import StandardScaler
+
+current_script_dir = os.path.dirname(__file__)
+csv_path = os.path.join(current_script_dir,"../data/cal_housing.csv")
+
+df = pd.read_csv(csv_path)
+columns = [column for column in df.columns]
+
+new_df,lambda_values = box_cox_transformation(df,df["longitude"],columns=columns)
+df_tuned = outlier_detection(new_df,columns)
+
+# print(new_df.head())
+def main():
+
+    X = df_tuned.drop("medianHouseValue",axis=1).values
+    y = df_tuned["medianHouseValue"].values
+
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=0.2, random_state=44)
+
+
+
+    scaler = StandardScaler()
+    scaler.fit(X_train)
+    X_train_scaled = scaler.transform(X_train)
+    X_test_scaled = scaler.transform(X_test)
+
+    LinReg = LinearRegression()
+    svm = LinearSVR(max_iter=10000,C=11,random_state=42)
+    ranfor = RandomForestRegressor(n_estimators=102, random_state=42)
+    gradboost = GradientBoostingRegressor(n_estimators=90, learning_rate=0.2, max_depth=3, random_state=42)
+
+    models = [LinReg,svm,ranfor,gradboost]
+
+    for model in models:
+
+        model.fit(X_train_scaled,y_train)
+        y_pred = model.predict(X_test_scaled)
+
+        mse = mean_squared_error(y_test, y_pred)
+        r2 = r2_score(y_test, y_pred)
+        print(f"Performance of {model} :- ")
+        print(f"Mean Squared Error: {mse}")
+        print(f"R-squared: {r2}\n")
+
+
+    # scalers = StandardScaler()
+    # X_scaled = scalers.fit_transform(X)
+
+    # ran = RandomForestRegressor(n_estimators=102, random_state=42)
+
+    # kf = KFold(n_splits=5, shuffle=True, random_state=42)
+
+    # # Performing k-fold cross-validation
+    # mse_scores = cross_val_score(ran, X_scaled, y, cv=kf, scoring='neg_mean_squared_error')
+    # r2_scores = cross_val_score(ran, X_scaled, y, cv=kf, scoring='r2')
+
+    # mse_scores = -mse_scores
+
+    # for fold, (mse, r2) in enumerate(zip(mse_scores, r2_scores), 1):
+    #     print(f"Fold {fold}:-")
+    #     print(f"Mean Squared Error: {mse}")
+    #     print(f"R-squared: {r2}\n")
+
+    # print("Average Performance Across Folds:")
+    # print(f"Mean Squared Error: {mse_scores.mean()}")
+    # print(f"R-squared: {r2_scores.mean()}")
+
+    model_filename = "ranfor_model.joblib"
+    scaler_filename = "scaler.joblib"
+
+    # saving the model and the scaler object
+    joblib.dump(ranfor,model_filename)
+    joblib.dump(scaler,scaler_filename)
+
+    print(f"Random forest model saved to {model_filename}")
+    print(f"Scaler saved to {scaler_filename}")
+
+if __name__ == "__main__":
+    main()

src/predict.py

@@ -0,0 +1,72 @@
+import os
+import sys
+sys.path.append('..')
+
+import joblib
+from sklearn.preprocessing import StandardScaler
+import pandas as pd
+import numpy as np
+from scipy.special import inv_boxcox
+
+from models.model import lambda_values
+from src.preprocessing import boxcox
+
+current_scirpt_dir = os.path.dirname(__file__)
+
+model_path = os.path.join(current_scirpt_dir,"ranfor_model.joblib")
+scaler_path = os.path.join(current_scirpt_dir,"scaler.joblib")
+
+def load_model():
+    model = joblib.load(model_path)
+    return model
+
+def load_std_scaler():
+    scaler = joblib.load(scaler_path)
+    return scaler
+
+
+constant = 1e-5
+min_value_longitude = -124.35
+
+columns = ["longitude","latitude","housingMedianAge","totalRooms","totalBedrooms","population","households","medianIncome"]
+
+lamda_values = [value for value in lambda_values.values()]
+
+
+def make_input(input_data:list,lamda_values:list,scaler) -> list:
+
+    input_data[0] += abs(min_value_longitude) + constant
+    transformed_data = []
+
+    #since input_data has 8 elements, the element of lamda_values(for medianHouseValue)
+    #will be ignored in for loop due to the zip function 
+
+    for data,lamda_value in zip(input_data,lamda_values):
+        transformed_data.append(boxcox(data,lmbda=lamda_value))
+
+    transformed_data = np.array(transformed_data).reshape(1,-1)
+    transformed_data_scaled = scaler.transform(transformed_data)
+
+    return transformed_data_scaled
+
+def make_prediction(input_data:list,model) -> list:
+    
+    pred_value_transformed = model.predict(input_data)
+    pred_value = inv_boxcox(pred_value_transformed,lamda_values[-1])
+    return pred_value
+
+
+
+if __name__ =="__main__":
+    actual_output = 52900
+    new_data = [-1.1906e+02,  3.6150e+01,  2.5000e+01,  2.4020e+03,  4.7800e+02,
+         1.5270e+03,  4.6100e+02,  2.3194e+00]
+    scaler = load_std_scaler()
+
+    tranformed_data = make_input(new_data,lamda_values=lamda_values,scaler=scaler)
+
+    model = load_model()
+
+    pred_value = make_prediction(tranformed_data,model=model)
+    print(pred_value)
+    print(actual_output)

src/preprocessing.py

@@ -0,0 +1,95 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.stats import boxcox,zscore
+from scipy.special import inv_boxcox
+import os
+
+#checking for null values
+# df.isna().sum()
+
+# df.info()
+
+def histogram(df:pd.DataFrame,nrows:int,ncols:int,figsize:tuple,columns:list):
+  fig,axes = plt.subplots(nrows=nrows,ncols=ncols,figsize=figsize)
+  axes = axes.flatten()
+  for i,ax in enumerate(axes):
+    ax.hist(df[columns[i]],bins="auto")
+    ax.set_xlabel(f"{columns[i]}")
+
+  plt.subplots_adjust(hspace=0.2, wspace=0.6)
+
+  return plt.show()
+
+def boxplot(df:pd.DataFrame,nrows:int,ncols:int,figsize:tuple,columns:list):
+  fig,axes = plt.subplots(nrows=nrows,ncols=ncols,figsize=figsize)
+  axes = axes.flatten()
+  for i,ax in enumerate(axes):
+    ax.boxplot(df[columns[i]])
+    ax.set_xlabel(f'{columns[i]}')
+  
+  plt.subplots_adjust(hspace=0.2, wspace=0.6)
+  return plt.show()
+
+
+
+def box_cox_transformation(df: pd.DataFrame,negative_or_zero_column,columns:list) -> pd.DataFrame:
+  min_value = negative_or_zero_column.min()
+  constant = 1e-5
+  # print(1+constant)
+  negative_or_zero_column = pd.Series(negative_or_zero_column + abs(min_value) + constant)
+
+  box_cox_data = {}
+  lambda_values = {}
+
+  box_cox_data["longitude"],lambda_values["longitude"] = \
+   boxcox(negative_or_zero_column)
+
+  for column in columns:
+    if column =="longitude":
+      continue
+    box_cox_data[column],lambda_values[column] = boxcox(df[column])
+
+  transformed_df = pd.DataFrame(box_cox_data)
+  return (transformed_df,lambda_values)
+
+
+
+def inverse_box_cox(transformed_data,lambda_value):
+  
+  return inv_boxcox(transformed_data,lambda_value)
+
+
+def single_value_boxcox(datas:list,lambda_values:list) -> list:
+  transformed_values = list()
+  for data,lambda_value in zip(datas,lambda_values):
+    transformed_values.append(boxcox(data,lmbda=lambda_value))
+  return transformed_values
+
+      
+
+
+
+# z_scores = zscore(new_df["totalRooms"])
+# outliers = (z_scores > 3) | (z_scores < -3)
+# print(f"Total outliers for totalRooms : {outliers.sum()}")
+
+# outlier_indices = outliers[outliers==True].index.values
+
+def outlier_detection(df:pd.DataFrame,columns:list) -> pd.DataFrame:
+  outliers_dict = {}
+  for column in columns:
+    z_scores = zscore(df[column])
+    outliers = (z_scores > 3) | (z_scores < -3)
+    #print(f"Total outliers for {column} : {outliers.sum()}")
+    if not outliers.sum():
+      continue
+    outliers_dict[column] = list(outliers[outliers==True].index.values)
+  indices = np.array([value for sublist in outliers_dict.values() for value in sublist])
+  unique_elements, counts = np.unique(indices,return_counts=True)
+  new_df = df.drop(unique_elements)
+  return new_df
+  # print(df1["medianHouseValue"].mean(),df1["medianHouseValue"].std())
+  # print(df1.shape)
+  # df1.head()
+# df1.to_csv("cal_housing_tuned.csv",index=False)

src/ranfor_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fea821fcbcc1a15ca676ec3f687e389a09537f87b5d0d2890d63caab2170c965
+size 144670081

src/scaler.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bde7795e728ea3533e4db5e803a3b2c212f0f66b00814dfd1d901a8b4e81474f
+size 807