from sklearn import datasets
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

plt.style.use('ggplot') 
iris = datasets.load_iris() 
type(iris)

print(iris.keys())

type(iris.data), type(iris.target)

iris.data.shape

iris.target_names

X = iris.data
y = iris.target
df = pd.DataFrame(X, columns=iris.feature_names) 
print(df.head())

_ = pd.plotting.scatter_matrix(df, c = y, figsize = [8, 8], s=150, marker = 'D')

from sklearn.neighbors import KNeighborsClassifier 
knn = KNeighborsClassifier(n_neighbors=6) 
knn.fit(iris['data'], iris['target'])

iris['data'].shape

iris['target'].shape # targets needs to be a single column with the same # of observation as the feature data

X_new = np.array(
[
    [5.6, 2.8, 3.9, 1.1],
    [5.7, 3.2, 3.8, 1.3],
    [4.7, 3.2, 1.3, 0.2]
])   # feature in columns and observation in rows
prediction = knn.predict(X_new) 
X_new.shape # 3 obsevation and 4 colums

print('Prediction: {}'.format(prediction))

from sklearn.model_selection import train_test_split

# use train_test_split function to randomly split data
# firast argument is feature data, the second the targets or labels
# returns the training data, test data, training labels, test labels
# by default split the data into 75% training data and 25% test data, we specify the size using the test_size 
# stratify=y:perform the split so that the split reflects the labels on your data, that is the labels to be distributed in train and test sets as they are in original dataset.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3,
    random_state=21, stratify=y) 
knn = KNeighborsClassifier(n_neighbors=8)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)

print("Test set predictions:")
print(y_pred)

# check out accuracy of the model
knn.score(X_test, y_test)

# Import necessary modules
from sklearn import datasets
import matplotlib.pyplot as plt

# Load the digits dataset: digits
digits = datasets.load_digits()

# Print the keys and DESCR of the dataset
print(digits.keys())
print(digits.DESCR)

# Print the shape of the images and data keys
print(digits.images.shape)
print(digits.data.shape)

# Display the 1011th image
plt.imshow(digits.images[1010], cmap=plt.cm.gray_r, interpolation='nearest')
plt.show()

# Import necessary modules
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

# Create feature and target arrays
X = digits.data
y = digits.target

# Split into training and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state=42, stratify=y)

# Create a k-NN classifier with 7 neighbors: knn
knn = KNeighborsClassifier(n_neighbors=7)

# Fit the classifier to the training data
knn.fit(X_train, y_train)

# Print the accuracy
print(knn.score(X_test, y_test))

# Setup arrays to store train and test accuracies
neighbors = np.arange(1, 9)
train_accuracy = np.empty(len(neighbors))
test_accuracy = np.empty(len(neighbors))

# Loop over different values of k
for i, k in enumerate(neighbors):
    # Setup a k-NN Classifier with k neighbors: knn
    knn = KNeighborsClassifier(n_neighbors=k)

    # Fit the classifier to the training data
    knn.fit(X_train, y_train)
    
    #Compute accuracy on the training set
    train_accuracy[i] = knn.score(X_train, y_train)

    #Compute accuracy on the testing set
    test_accuracy[i] = knn.score(X_test, y_test)

# Generate plot
plt.title('k-NN: Varying Number of Neighbors')
plt.plot(neighbors, test_accuracy, label = 'Testing Accuracy')
plt.plot(neighbors, train_accuracy, label = 'Training Accuracy')
plt.legend()
plt.xlabel('Number of Neighbors')
plt.ylabel('Accuracy')
plt.show()

# It looks like the test accuracy is highest when using 3 and 5 neighbors. 
# Using 8 neighbors or more seems to result in a simple model that underfits the data. 

from sklearn import datasets
boston_data = datasets.load_boston()

# change to dataframe 
boston = pd.DataFrame(boston_data.data, columns=boston_data.feature_names)
boston['MEDV'] = pd.Series(boston_data.target)
print(boston.head())

X = boston.drop('MEDV', axis=1).values
y = boston['MEDV'].values

# single feature: the average num of romms in a block
X_rooms = X[:,5] # fifth column
# check type
type(X_rooms), type(y)

# Keep the first dimension, but add another dimension of size one to X,from (506,) to (506, 1)
y = y.reshape(-1, 1)
X_rooms = X_rooms.reshape(-1, 1) 
X_rooms.shape 

plt.scatter(X_rooms, y) 
plt.ylabel('Value of house /1000 ($)') 
plt.xlabel('Number of rooms') 
plt.show();

# more rooms leads to higher prices

import numpy as np
from sklearn.linear_model import LinearRegression

# instantiate LinearRegression as reg
reg = LinearRegression()
# fit regressor to the data
reg.fit(X_rooms, y)
# check out the regressors predictions over the range of the data by using np.linspace between the maximum
# and minimum number of rooms and make prediction for this data
prediction_space = np.linspace(min(X_rooms),
    max(X_rooms)).reshape(-1, 1)

plt.scatter(X_rooms, y, color='blue') 
plt.plot(prediction_space, reg.predict(prediction_space),
    color='black', linewidth=3)
plt.show()

from sklearn.model_selection import train_test_split 
from sklearn.linear_model import LinearRegression

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=42)
reg_all = LinearRegression()
reg_all.fit(X_train, y_train) 
y_pred = reg_all.predict(X_test)
reg_all.score(X_test, y_test)

from sklearn.model_selection import cross_val_score 
from sklearn.linear_model import LinearRegression

# instantiate model
reg = LinearRegression()
# call cross val score with the regressor, the feature data and the target data as the first three positional argument 
# specify the numver of fold with cv
cv_results = cross_val_score(reg, X, y, cv=5) 
# the length of the array is the number of folds utilized
# note that the score reported is R square(default score for linear regression)
print(cv_results)

np.mean(cv_results)

from sklearn.linear_model import Ridge

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=42)
# set up alpha, normalize insure all the variables are on the same scale 
ridge = Ridge(alpha=0.1, normalize=True) 
ridge.fit(X_train, y_train)
ridge_pred = ridge.predict(X_test)
ridge.score(X_test, y_test)

from sklearn.linear_model import Lasso

X_train, X_test, y_train, y_test = train_test_split(X, y,
    test_size = 0.3, random_state=42)
lasso = Lasso(alpha=0.1, normalize=True) 
# Fit the regressor to the data
lasso.fit(X_train, y_train)
lasso_pred = lasso.predict(X_test) 
lasso.score(X_test, y_test)

from sklearn.linear_model import Lasso 
names = boston.drop('MEDV', axis=1).columns 
lasso = Lasso(alpha=0.1)
# Compute and print the coefficients,extract the coef attribute and store in lasso coef
lasso_coef = lasso.fit(X, y).coef_
# plotting the coefficients as a function of feature name
_ = plt.plot(range(len(names)), lasso_coef)
_ = plt.xticks(range(len(names)), names, rotation=60) 
_ = plt.ylabel('Coefficients')
plt.show()
# Lasso selected out the 'RM' feature as being the most important for predicting 
# Boston house prices, while shrinking the coefficients of certain other features to 0.

iris = datasets.load_iris() 
X = iris.data
y = iris.target
df = pd.DataFrame(X, columns=iris.feature_names) 

# Import necessary modules
from sklearn.metrics import classification_report 
from sklearn.metrics import confusion_matrix

# Instantiate a k-NN classifier: knn
knn = KNeighborsClassifier(n_neighbors=8)
# Create training and test set
X_train, X_test, y_train, y_test = train_test_split(X, y,
    test_size=0.4, random_state=42)
# Fit the classifier to the training data
knn.fit(X_train, y_train)
# Predict the labels of the test data: y_pred
y_pred = knn.predict(X_test)

# compute confusion matrix
print(confusion_matrix(y_test, y_pred))

# compute result matrix
print(classification_report(y_test, y_pred))

from sklearn.linear_model import LogisticRegression 
from sklearn.model_selection import train_test_split

import warnings
warnings.filterwarnings("ignore", category=FutureWarning)

logreg = LogisticRegression()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)
logreg.fit(X_train, y_train) 
y_pred = logreg.predict(X_test)

diabetes = pd.read_csv("data/diabetes.csv")

X = diabetes.drop('diabetes', axis=1).values
y = diabetes['diabetes'].values

# Import the necessary modules
from sklearn.linear_model import LogisticRegression 
from sklearn.metrics import confusion_matrix, classification_report

# Create training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4, random_state=42)

# Create the classifier: logreg
logreg = LogisticRegression()

# Fit the classifier to the training data
logreg.fit(X_train, y_train)

# Predict the labels of the test set: y_pred
y_pred = logreg.predict(X_test)

# Compute and print the confusion matrix and classification report
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

# Import necessary modules
from sklearn.metrics import roc_curve

# Compute predicted probabilities: y_pred_prob
y_pred_prob = logreg.predict_proba(X_test)[:,1]

# Generate ROC curve values: fpr, tpr, thresholds
fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)

# Plot ROC curve
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(fpr, tpr)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('ROC Curve')
plt.show()

# Import necessary modules
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import cross_val_score

# Compute predicted probabilities: y_pred_prob
y_pred_prob = logreg.predict_proba(X_test)[:,1]

# Compute and print AUC score
print("AUC: {}".format(roc_auc_score(y_test, y_pred_prob)))

# Compute cross-validated AUC scores: cv_auc
cv_auc = cross_val_score(logreg, X, y, cv=5, scoring='roc_auc')

# Print list of AUC scores
print("AUC scores computed using 5-fold cross-validation: {}".format(cv_auc))

from sklearn.model_selection import GridSearchCV
# specify the hyperparameter as a dictionary in which the keys are the dictionary 
# which the keys are the hyperparameter names, such as n_neighbors in KNN or alpha in lasso regression.
# The values in the grid dictionary are lists containing the values we wish to tune the relevant hyperparameter(s) over
# if specify multiple parameters, all possible combinations will be tried
param_grid = {'n_neighbors': np.arange(1, 50)} 
# ibnstantiate classifier
knn = KNeighborsClassifier()
# pass our model(knn), the gird we wish to tune over(param_grid) and the # of folds that we wish to use
knn_cv = GridSearchCV(knn, param_grid, cv=5) # return a GridSearch object that can fit the data
# This fit performs the actual grid search inplace
knn_cv.fit(X, y)
# apply the attributes beat params, to show the hyperparameter perform the best
knn_cv.best_params_

# apply the attributes beat score(mean cross validation score over that fold)
knn_cv.best_score_

# Import necessary modules
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV

# Setup the hyperparameter grid by using c_space as the grid of values to tune C over.
c_space = np.logspace(-5, 8, 15)
param_grid = {'C': c_space }

# Instantiate a logistic regression classifier: logreg
logreg = LogisticRegression()

# Instantiate the GridSearchCV object: logreg_cv
logreg_cv = GridSearchCV(logreg, param_grid, cv=5) # specify the classifier, parameter grid, and number of folds to use.

# Fit it to the data
logreg_cv.fit(X, y)

# Print the tuned parameters and score
print("Tuned Logistic Regression Parameters: {}".format(logreg_cv.best_params_)) 
print("Best score is {}".format(logreg_cv.best_score_))

# Import necessary modules
from scipy.stats import randint
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import RandomizedSearchCV

# Setup the parameters and distributions to sample from: param_dist
param_dist = {"max_depth": [3, None],
              "max_features": randint(1, 9),
              "min_samples_leaf": randint(1, 9),
              "criterion": ["gini", "entropy"]}

# Instantiate a Decision Tree classifier: tree
tree = DecisionTreeClassifier()

# Instantiate the RandomizedSearchCV object: tree_cv
tree_cv = RandomizedSearchCV(tree, param_dist, cv=5)

# Fit it to the data
tree_cv.fit(X, y)

diabetes = pd.read_csv("data/diabetes.csv")

X = diabetes.drop('diabetes', axis=1)

y = diabetes['diabetes']

# handle missing data
# instaniate an instance of the imputer
from sklearn.preprocessing import Imputer
imp = Imputer(missing_values=0, strategy='mean', axis=0) # axis=0, impute along columns
imp.fit(X)
X = imp.transform(X) # due to their ability to transform our data as such, impters are known as transformers

X

# Import necessary modules
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import GridSearchCV

import warnings
warnings.filterwarnings(action='ignore',category=DeprecationWarning)

# Create the hyperparameter grid
c_space = np.logspace(-5, 8, 15)
param_grid = {'C': c_space, 'penalty': ['l1', 'l2']}

# Instantiate the logistic regression classifier: logreg
logreg = LogisticRegression()

# Create train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.4, random_state=42)

# Instantiate the GridSearchCV object: logreg_cv
logreg_cv = GridSearchCV(logreg, param_grid, cv=5)

# Fit it to the training data
logreg_cv.fit(X_train, y_train)

# Print the optimal parameters and best score
print("Tuned Logistic Regression Parameter: {}".format(logreg_cv.best_params_))
print("Tuned Logistic Regression Accuracy: {}".format(logreg_cv.best_score_))

# Import necessary modules
from sklearn.linear_model import ElasticNet
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import train_test_split

# Create train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)

# Create the hyperparameter grid
l1_space = np.linspace(0, 1, 30)
param_grid = {'l1_ratio': l1_space}

# Instantiate the ElasticNet regressor: elastic_net
elastic_net = ElasticNet()

# Setup the GridSearchCV object: gm_cv
gm_cv = GridSearchCV(elastic_net, param_grid, cv=5)

# Fit it to the training data
gm_cv.fit(X_train, y_train)

# Predict on the test set and compute metrics
y_pred = gm_cv.predict(X_test)
r2 = gm_cv.score(X_test, y_test)
mse = mean_squared_error(y_test, y_pred)
print("Tuned ElasticNet l1 ratio: {}".format(gm_cv.best_params_))
print("Tuned ElasticNet R squared: {}".format(r2))
print("Tuned ElasticNet MSE: {}".format(mse))

 import pandas as pd
df = pd.read_csv('data/auto.csv')
df_origin = pd.get_dummies(df) 
print(df_origin.head())

df_origin = df_origin.drop('origin_Asia', axis=1) 
print(df_origin.head())

X = boston.drop('MEDV', axis=1).values
y = boston['MEDV'].values

from sklearn.model_selection import train_test_split 
from sklearn.linear_model import Ridge

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
ridge = Ridge(alpha=0.5, normalize=True).fit(X_train, y_train)
ridge.score(X_test, y_test)

# Import pandas
import pandas as pd

# Read 'gapminder.csv' into a DataFrame: df
df = pd.read_csv('data/gapminder.csv')

# Create a boxplot of life expectancy per region
df.boxplot('life', 'Region', rot=60)

# Show the plot
plt.show()

# Create dummy variables: df_region
df_region = pd.get_dummies(df)

# Print the columns of df_region
print(df_region.columns)

# Create dummy variables with drop_first=True: df_region
df_region = df_region.drop('Region_America', axis=1)
# or: df_region = pd.get_dummies(df, drop_first=True)

# Print the new columns of df_region
print(df_region.columns)

# Import necessary modules
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import Ridge

# Instantiate a ridge regressor: ridge
ridge = Ridge(alpha=0.5, normalize=True)

# Perform 5-fold cross-validation: ridge_cv
ridge_cv = cross_val_score(ridge, X, y, cv=5)

# Print the cross-validated scores
print(ridge_cv)

df = pd.read_csv('data/diabetes.csv') 
df.info()

print(df.head())

df.insulin.replace(0, np.nan, inplace=True) 
df.triceps.replace(0, np.nan, inplace=True) 
df.bmi.replace(0, np.nan, inplace=True) 
df.info()

df = df.dropna() # remove columns contain Nan
df.shape # half of rows droped, unacceptable

# instaniate an instance of the imputer
from sklearn.preprocessing import Imputer
imp = Imputer(missing_values='NaN', strategy='mean', axis=0) # axis=0, impute along columns
imp.fit(X)
X = imp.transform(X) # due to their ability to transform our data as such, impters are known as transformers

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import Imputer

imp = Imputer(missing_values='NaN', strategy='mean', axis=0) 
logreg = LogisticRegression()
# construct a list of steps in the pipeline, where each step is a 2-tuple containing the name you wish to give the relevant step and the estimator
steps = [('imputation', imp), ('logistic_regression', logreg)]
# pass the list to the pipeline constructor
pipeline = Pipeline(steps)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

pipeline.fit(X_train, y_train.astype('int')) 
y_pred = pipeline.predict(X_test) 
# compute acurracy
pipeline.score(X_test, y_test.astype('int'))

df = voting

# Convert '?' to NaN
df[df == '?'] = np.nan

# Print the number of NaNs
print(df.isnull().sum())

# Print shape of original DataFrame
print("Shape of Original DataFrame: {}".format(df.shape))

# Drop missing values and print shape of new DataFrame
df = df.dropna()

# Print shape of new DataFrame
print("Shape of DataFrame After Dropping All Rows with Missing Values: {}".format(df.shape))

df = voting
df[df == 'y'] = 1
df[df == 'n'] = 0
df[df == '?'] = "NaN"

# Import the Imputer module
from sklearn.svm import SVC
from sklearn.preprocessing import Imputer

# Setup the Imputation transformer: imp
imp = Imputer(missing_values='NaN', strategy='most_frequent', axis=0)

# Instantiate the SVC classifier: clf
clf = SVC()

# Setup the pipeline with the required steps: steps
steps = [('imputation', imp),
        ('SVM', clf)]

X = df.drop('party', axis=1)
y = df['party']

# Import necessary modules
from sklearn.preprocessing import Imputer
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC

# Setup the pipeline steps: steps
steps = [('imputation', Imputer(missing_values='NaN', strategy='most_frequent', axis=0)),
        ('SVM', SVC())]

# Create the pipeline: pipeline
pipeline = Pipeline(steps)

# Create training and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Fit the pipeline to the train set
pipeline.fit(X_train, y_train) 

# Predict the labels of the test set
y_pred = pipeline.predict(X_test) 

# Compute metrics
print(classification_report(y_test, y_pred))

winequality_red = pd.read_csv("data/winequality-red.csv")

winequality_red

print(winequality_red.describe())

X = winequality_red.drop('quality', axis=1).values
y = winequality_red['quality'].values
y = np.where(y<5, 1, 0)

from sklearn.preprocessing import scale 
X_scaled = scale(X)

np.mean(X), np.std(X)

np.mean(X_scaled), np.std(X_scaled)

from sklearn.preprocessing import StandardScaler
steps = [('scaler', StandardScaler()),('knn', KNeighborsClassifier())] 
pipeline = Pipeline(steps)
# split dartaset in training and test set
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=21)
# fit the pipeline to training set
knn_scaled = pipeline.fit(X_train, y_train) 
# predict test set
y_pred = pipeline.predict(X_test)
# compute accuracy
accuracy_score(y_test, y_pred) # 0.956

# perform KNN without scaling
knn_unscaled = KNeighborsClassifier().fit(X_train, y_train) 
knn_unscaled.score(X_test, y_test) # result accurancy of 0.928, scaling did improve our model performance

# build pipeline
steps = [('scaler', StandardScaler()), (('knn', KNeighborsClassifier()))]
pipeline = Pipeline(steps)
# specify yhperparameter space by creating a dictionary: the keys are pipeline step name followed by a double underscore,
# followed by the hyperparameter name, the corresponding vale is a list or an array of the values to try for that
# particular hyperparameter. In this case, we are tuning only the n neighbours in the KNN model
parameters = {knn__n_neighbors: np.arange(1, 50)}
# split data into cross-validation and hold-out set 
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=21)
# perform gridsearch over the parameters in the pipeline by instantiating the GridSearchCV object
cv = GridSearchCV(pipeline, param_grid=parameters)
# fit to training data
cv.fit(X_train, y_train)
# The predict method will call predict on the estimator with the best found parameters and we do this on the hold-out set
y_pred = cv.predict(X_test)

print(cv.best_params_) # {'knn__n_neighbors': 41}

print(cv.score(X_test, y_test) )# 0.956

print(classification_report(y_test, y_pred))

winequality_white = pd.read_csv("data/winequality-white.csv")

X = winequality_white.drop('quality', axis=1).values
y = winequality_white['quality'].values
y = np.where(y<5, 0, 1)

# Import scale
from sklearn.preprocessing import scale

# Scale the features: X_scaled
X_scaled = scale(X)

# Print the mean and standard deviation of the unscaled features
print("Mean of Unscaled Features: {}".format(np.mean(X))) 
print("Standard Deviation of Unscaled Features: {}".format(np.std(X)))

# Print the mean and standard deviation of the scaled features
print("Mean of Scaled Features: {}".format(np.mean(X_scaled))) 
print("Standard Deviation of Scaled Features: {}".format(np.std(X_scaled)))

# Import the necessary modules
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline

# Setup the pipeline steps: steps
steps = [('scaler', StandardScaler()),
        ('knn', KNeighborsClassifier())]
        
# Create the pipeline: pipeline
pipeline = Pipeline(steps)

# Create train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Fit the pipeline to the training set: knn_scaled
knn_scaled = pipeline.fit(X_train, y_train)

# Instantiate and fit a k-NN classifier to the unscaled data
knn_unscaled = KNeighborsClassifier().fit(X_train, y_train)

# Compute and print metrics
print('Accuracy with Scaling: {}'.format(knn_scaled.score(X_test, y_test)))
print('Accuracy without Scaling: {}'.format(knn_unscaled.score(X_test, y_test)))

# Setup the pipeline
steps = [('scaler', StandardScaler()),
         ('SVM', SVC())]

pipeline = Pipeline(steps)

# Specify the hyperparameter space
# Specify the hyperparameter space using the following notation: 'step_name__parameter_name'. 
# Here, the step_name is SVM, and the parameter_names are C and gamma.
parameters = {'SVM__C':[1, 10, 100],
              'SVM__gamma':[0.1, 0.01]}

# Create train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=21)

# Instantiate the GridSearchCV object: cv
cv = GridSearchCV(pipeline, param_grid=parameters)

# Fit to the training set
cv.fit(X_train, y_train)

# Predict the labels of the test set: y_pred
y_pred = cv.predict(X_test)

# Compute and print metrics
print("Accuracy: {}".format(cv.score(X_test, y_test)))
print(classification_report(y_test, y_pred))
print("Tuned Model Parameters: {}".format(cv.best_params_))

# Setup the pipeline steps: steps
steps = [('imputation', Imputer(missing_values='NaN', strategy='mean', axis=0)),
         ('scaler', StandardScaler()),
         ('elasticnet', ElasticNet())]

# Create the pipeline: pipeline 
pipeline = Pipeline(steps)

# Specify the hyperparameter space
# Specify the hyperparameter space for the l1 ratio using the following notation: 
# 'step_name__parameter_name'. Here, the step_name is elasticnet, and the parameter_name is l1_ratio.
parameters = {'elasticnet__l1_ratio':np.linspace(0,1,30)}

# Create train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=42)

# Create the GridSearchCV object: gm_cv
gm_cv = GridSearchCV(pipeline, param_grid=parameters)

# Fit to the training set
gm_cv.fit(X_train, y_train)

# Compute and print the metrics
r2 = gm_cv.score(X_test, y_test)
print("Tuned ElasticNet Alpha: {}".format(gm_cv.best_params_))
print("Tuned ElasticNet R squared: {}".format(r2))