import pandas as pd
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
import seaborn as sns

from sklearn.linear_model import RidgeCV, LassoCV, ElasticNetCV
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.preprocessing import PolynomialFeatures, StandardScaler

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import r2_score

%config InlineBackend.figure_format = 'retina'
%matplotlib inline

test = pd.read_csv('test.csv')
train = pd.read_csv('train.csv')

test.shape

train.shape

train.head()

test.head()

# This use of the DataFrame.replace() method uses a regular expression
# to replace cells which only contain whitespace with np.NaN.
# Credit for this implementation goes to Stack Overflow user Temak 
# on this thread: https://stackoverflow.com/questions/13445241/replacing-blank-values-white-space-with-nan-in-pandas 

train.replace(r'^\s+$', np.nan, regex=True, inplace=True)
test.replace(r'^\s+$', np.nan, regex=True, inplace=True)

train.columns = [col.strip().replace(' ', '_') for col in train.columns]
test.columns =  [col.strip().replace(' ', '_') for col in test.columns]

sns.distplot(train.SalePrice);

train.SalePrice.describe()

# This graph was inspired by Lee Clemmer's blog post here: https://www.kaggle.com/leeclemmer/exploratory-data-analysis-of-housing-in-ames-iowa/code
train.groupby(['Yr_Sold','Mo_Sold']).Id.count().plot(kind='bar',fontsize=14,figsize=(15,5),color='b')
plt.title("Amount of Sales Per Month")
plt.xlabel('Year, Month')
plt.show()

train.groupby(['Yr_Sold','Mo_Sold'])['SalePrice'].mean().plot(kind=
                                                              'bar',color='b',
                                                              figsize=(15,5));

# Log-transform SalePrice, the target.
train.SalePrice = np.log(train.SalePrice)

# Make dummy variables for all variables of type object, plus MS SubClass
# which, while not currently encoded as an object, still represents a categorical variable.
# Credit for this function goes to Joe Dorfman from my DSI cohort
def get_dummied(train, test):
    list = ['MS_SubClass']
    for i in train.columns:
        if train[i].dtype == object:
            list.append(i)
            
    full_data = pd.concat([train, test], axis = 0)
    full_data = pd.get_dummies(full_data, columns=list, drop_first = True)
    
    X_dummied = full_data[:len(train)]
    test_dummied = full_data[len(train):]
    
    return X_dummied, test_dummied

train, test = get_dummied(train, test)

# review the columns to check that get_dummied really made the dummies
train.head()
test.head()

# Assess which variables are most correlated with sale price:
corr = train.corrwith(train.SalePrice)
print(corr.sort_values(ascending=False).head(11))

# Make a list of the columns to be passed to PolynomialFeatures()
cols = ['Overall_Qual','Gr_Liv_Area','Garage_Cars','Garage_Area',
        'Year_Built','Total_Bsmt_SF','Year_Remod/Add', '1st_Flr_SF', 
        'Garage_Yr_Blt','Full_Bath']

# Instantiate PolynomialFeatures with intercept = False
poly = PolynomialFeatures(include_bias=False)

# Make 2nd degree polynomials from the variables in cols
# Filling all NaNs with 0s because you can't multiply times a NaN
# And turn them back into dataframes
train_poly = pd.DataFrame(poly.fit_transform(train[cols].fillna(0)))
test_poly = pd.DataFrame(poly.fit_transform(test[cols].fillna(0)))

# I don't care about the column names because I'm not trying to make an
# inferential model, just a predictive one

# check that the features of both dataframes line up
test_poly.head()
train_poly.head()

# concatonate the new polynomial features with the existing X features
X_test = pd.concat([test, test_poly], axis=1)
X_train = pd.concat([train, test_poly], axis=1)

# check the result of the concatonation
X_train.head()
X_test.head()

X_train = train[[col for col in train.columns if col!="SalePrice"]].fillna(0)
y_train = train['SalePrice'].fillna(0)

X_pred = test[[col for col in test.columns if col!="SalePrice"]].fillna(0)
y_pred = test['SalePrice'].fillna(0)

X_train, X_test, y_train, y_test = train_test_split(X_train,y_train)

# Instantiate StandardScaler object
ss = StandardScaler()

# The 1st pipeline uses RidgeCV
ridge = RidgeCV()

pipe_ridge = Pipeline([
    ('ss', ss),
    ('ridge', ridge)
])

# Fit ridge model on training data with target that is not log-transformed
pipe_ridge.fit(X_train,np.exp(y_train))

# Score ridge model on training data with atarget that is not log-transformed
pipe_ridge.score(X_train,np.exp(y_train))

# Score ridge model on testing data without log-transforming the target
pipe_ridge.score(X_test,np.exp(y_test))

# Make predictions for the prediction set's SalePrice and format them 
# For submission to the kaggle contest
# this code snippet was inspired by Jamie Quella in my DSI Cohort
ridge_prediction = pd.DataFrame(pipe_ridge.predict(X_pred), 
                                columns=['SalePrice'],
                                index=X_pred['Id']).sort_index()

# Output my RidgeCV predictions to a CSV
ridge_prediction.to_csv('./ridge_submission.csv')

# y_train was log transformed in the preprocessing stage
pipe_ridge.fit(X_train, y_train)

# Score model on training data
yhat = pipe_ridge.predict(X_train)
yhat = np.exp(yhat)
r2_score( np.exp(y_train), yhat)

# y_train was log transformed in the preprocessing stage
pipe_ridge.fit(X_test, y_test)

# Score model on training data
yhat = pipe_ridge.predict(X_test)
yhat = np.exp(yhat)
r2_score(np.exp(y_test), yhat)

# Make predictions for the prediction set's SalePrice 
yhat = pipe_ridge.predict(X_pred)
yhat = np.exp(yhat)

# Format predictions for submission to the kaggle contest
# this code snippet was inspired by Jamie Quella in my DSI Cohort
ridge_prediction_log_y = pd.DataFrame(yhat, 
                                columns=['SalePrice'],
                                index=X_pred['Id']).sort_index()

# Output the predictions of my RidgeCV model with a log-transformed target to a CSV
ridge_prediction_log_y.to_csv('./ridge_submission_log_y.csv')

# The 2nd pipeline uses LassoCV
lasso = LassoCV()

pipe_lasso = Pipeline([
    ('ss', ss),
    ('lasso', lasso)
])

# Fit lasso model on training data with a target that is not log-transformed
pipe_lasso.fit(X_train,np.exp(y_train))

# Score lasso model on training data with a target that is not log-transformed
pipe_lasso.score(X_train,np.exp(y_train))

# Score lasso model on testing data without log-transforming the target
pipe_lasso.score(X_test,np.exp(y_test))

# Make predictions for the prediction set's SalePrice and format them 
# For submission to the kaggle contest
# this code snippet was inspired by Jamie Quella in my DSI Cohort
lasso_prediction = pd.DataFrame(pipe_lasso.predict(X_pred), 
                                columns=['SalePrice'],
                                index=X_pred['Id']).sort_index()

# Output my LassoCV predictions to a CSV
lasso_prediction.to_csv('./lasso_submission.csv')

#### The 3rd pipeline uses ElasticNetCV
enet = ElasticNetCV()

pipe_enet = Pipeline([
    ('ss', ss),
    ('enet', enet)
])

# Fit enet model on training data with a y that is not log-transformed
pipe_enet.fit(X_train,np.exp(y_train))

# Score enet model on training data with a target that is not log-transformed
pipe_enet.score(X_train,np.exp(y_train))