model_building.py

#%%
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

df = pd.read_csv("data_eda.csv")
# choose the relevant columns

#%%
df.columns

#%%
df_model = df[[
    "avg_salary",
    "Rating",
    "Size",
    "Type of ownership",
    "Industry",
    "Sector",
    "Revenue",
    "num_comp",
    "hourly",
    "employer_provided",
    "job_state",
    "same_state",
    "age",
    "python_yn",
    "spark",
    "aws",
    "excel",
    "job_simp",
    "seniority",
    "desc_len",
]]

#%%
# get dummy data
df_dum = pd.get_dummies(df_model)
df_dum

#%%

# train test split

from sklearn.model_selection import train_test_split

X = df_dum.drop("avg_salary", axis=1)
y = df_dum.avg_salary.values

X_train, X_test, y_train, y_test = train_test_split(X,
                                                    y,
                                                    test_size=0.2,
                                                    random_state=42)

# multiple linear regression
#%%
import statsmodels.api as sm

X_sm = X = sm.add_constant(X)
model = sm.OLS(y, X_sm)

#%%
model.fit().summary()

#%%
from sklearn.linear_model import LinearRegression, Lasso
from sklearn.model_selection import cross_val_score

lm = LinearRegression()
lm.fit(X_train, y_train)

#%%
# np.mean(
#     cross_val_score(lm,
#                     X_train,
#                     y_train,
#                     scoring="neg_mean_absolute_error",
#                     cv=3))

cross_val_score(lm, X_train, y_train, scoring="neg_mean_absolute_error", cv=3)

# lasso regression
#%%
# THIS IS THE CODE THAT WAS USED ON TRIAL BASIS FOR THE LASSO REGRESSION MODEL

# lm_1 = Lasso(alpha=0.13)
# lm_1 = Lasso(alpha=0.13)
# lm_1.fit(X_train, y_test)
# np.mean(
#     cross_val_score(lm_1,
#                     X_train,
#                     y_train,
#                     scoring="neg_mean_absolute_error",
#                     cv=3))
# alpha = []
# error = []

# for i in range(1, 100):
#     alpha.append(i / 100)
#     lm_1 = Lasso(alpha=(i / 100))
#     error.append(
#         np.mean(
#             cross_val_score(lm_1,
#                             X_train,
#                             y_train,
#                             scoring="neg_mean_absolute_error",
#                             cv=3)))

# plt.plot(alpha, error)

# LASSO REGRESSION USED:

lm_l = Lasso(alpha=0.13)
lm_l.fit(X_train, y_train)
np.mean(
    cross_val_score(lm_l,
                    X_train,
                    y_train,
                    scoring="neg_mean_absolute_error",
                    cv=3))

alpha = []
error = []

for i in range(1, 100):
    alpha.append(i / 100)
    lml = Lasso(alpha=(i / 100))
    error.append(
        np.mean(
            cross_val_score(lml,
                            X_train,
                            y_train,
                            scoring="neg_mean_absolute_error",
                            cv=3)))

plt.plot(alpha, error)

#%%
err = tuple(zip(alpha, error))
df_err = pd.DataFrame(err, columns=["alpha", "error"])
df_err[df_err.error == max(df_err.error)]

#%%
# random forest
from sklearn.ensemble import RandomForestRegressor

rf = RandomForestRegressor()

np.mean(
    cross_val_score(rf,
                    X_train,
                    y_train,
                    scoring="neg_mean_absolute_error",
                    cv=3))

# tune models GridSearchCV
# this is the tuning part, using grid search as mentioned above
#%%
from sklearn.model_selection import GridSearchCV

parameters = {
    "n_estimators": range(10, 300, 10),
    "criterion": (
        "mse",
        "mae",
    ),
    "max_features": ("auto", "sqrt", "log2"),
}

#%%
gs = GridSearchCV(rf, parameters, scoring="neg_mean_absolute_error", cv=3)
gs.fit(X_train, y_train)

#%%
gs.best_score_
#%%
gs.best_estimator_

# test end samples
# %%
# tpred_lm = lm.predict(X_train, y_train)
# tpred_lm_1 = lm_1.predict(X_train, y_train)

tpred_lm = lm.predict(X_test)
tpred_lml = lm_l.predict(X_test)
tpred_rf = gs.best_estimator_.predict(X_test)

# %%
from sklearn.metrics import mean_absolute_error

mean_absolute_error(y_test, tpred_lm)

#%%
mean_absolute_error(y_test, tpred_lml)

#%%
mean_absolute_error(y_test, tpred_rf)

#%%

mean_absolute_error(y_test, (tpred_lm + tpred_rf) / 2)

# %%
((tpred_lm + tpred_rf) / 2)

#%%
# pickling the model
import pickle

pickl = {"model": gs.best_estimator_}
pickle.dump(pickl, open("model_file" + ".p", "wb"))

# %%
file_name = "model_file.p"
with open(file_name, "rb") as pickled:
    data = pickle.load(pickled)
    model = data["model"]

#%%
model.predict(X_test.iloc[1, :].values.reshape(1, -1))

#%%
# X_test.iloc[1, :].values
# %%