diff --git a/labs/2019/lab3_lr_svm_eval_sol.ipynb b/labs/2019/lab3_lr_svm_eval_sol.ipynb new file mode 100644 index 0000000..5aa85fd --- /dev/null +++ b/labs/2019/lab3_lr_svm_eval_sol.ipynb @@ -0,0 +1,1525 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Lab 3: Logistic Regression, Support Vector Machines, and Evaluation\n", + "\n", + "\n", + "In this lab we'll get some hands on experience with two more classifiers we've seen in class\n", + "- Logitic Regression\n", + "- Support Vector Machines\n", + "\n", + "We will also explore evaluation metrics that we covered in class and understand how to calculate them." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Goals for this lab\n", + "\n", + "- Understand the practical implications for changing the parameters used in Logistic Regression and Support Vector Machines\n", + " \n", + "- Learn more about the evaluation metrics covered in class and learn how to calculate them (at different thresholds)\n", + " - accuracy\n", + " - precision\n", + " - recall\n", + " - AUC" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "### import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import sklearn.tree as tree\n", + "from sklearn.linear_model import LogisticRegression\n", + "from sklearn.svm import LinearSVC\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import accuracy_score as accuracy\n", + "import graphviz # If you don't have this, install via pip/conda\n", + "from sklearn.metrics import confusion_matrix\n", + "from sklearn.metrics import precision_recall_curve\n", + "%matplotlib inline\n", + "\n", + "# exercise: what additional modules should you import?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data\n", + "We'll continue to use the same data as in the previous lab.\n", + "\n", + "It is a subset of the data set from https://www.kaggle.com/new-york-state/nys-patient-characteristics-survey-pcs-2015\n", + "\n", + "The data has been downloaded, modified, and is in the github repo for the lab\n", + "\n", + "You should also try this with other data sets you have been provided for the homeworks." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Change this to wherever you're storing your data\n", + "datafile = '../data/nysmedicaldata.csv'\n", + "df = pd.read_csv(datafile)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Region ServedAge GroupSexTransgenderSexual OrientationHispanic EthnicityRaceLiving SituationHousehold CompositionPreferred Language...No InsuranceUnknown Insurance CoverageMedicaid InsuranceMedicaid Managed InsuranceMedicare InsurancePrivate InsuranceChild Health Plus InsuranceOther InsuranceCriminal Justice StatusThree Digit Residence Zip Code
0HUDSON RIVER REGIONADULTMALENO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALYESOTHEROTHER LIVING SITUATIONNOT APPLICABLEENGLISH...NONOYESNONONONONOYES113
1NEW YORK CITY REGIONADULTMALENO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALNO, NOT HISPANIC/LATINOWHITE ONLYINSTITUTIONAL SETTINGNOT APPLICABLEENGLISH...NONOYESNOUNKNOWNNONOUNKNOWNYES113
2HUDSON RIVER REGIONADULTMALENO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALNO, NOT HISPANIC/LATINOWHITE ONLYPRIVATE RESIDENCECOHABITATES WITH OTHERSENGLISH...NONOYESNONONONONOYES107
3NEW YORK CITY REGIONADULTFEMALENO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALNO, NOT HISPANIC/LATINOOTHEROTHER LIVING SITUATIONNOT APPLICABLEASIAN AND PACIFIC ISLAND...YESNONONOT APPLICABLENONONONOYES888
4LONG ISLAND REGIONADULTMALENO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALNO, NOT HISPANIC/LATINOBLACK ONLYOTHER LIVING SITUATIONNOT APPLICABLEENGLISH...NONOYESUNKNOWNYESNONONONO117
\n", + "

5 rows × 65 columns

\n", + "
" + ], + "text/plain": [ + " Region Served Age Group Sex Transgender \\\n", + "0 HUDSON RIVER REGION ADULT MALE NO, NOT TRANSGENDER \n", + "1 NEW YORK CITY REGION ADULT MALE NO, NOT TRANSGENDER \n", + "2 HUDSON RIVER REGION ADULT MALE NO, NOT TRANSGENDER \n", + "3 NEW YORK CITY REGION ADULT FEMALE NO, NOT TRANSGENDER \n", + "4 LONG ISLAND REGION ADULT MALE NO, NOT TRANSGENDER \n", + "\n", + " Sexual Orientation Hispanic Ethnicity Race \\\n", + "0 STRAIGHT OR HETEROSEXUAL YES OTHER \n", + "1 STRAIGHT OR HETEROSEXUAL NO, NOT HISPANIC/LATINO WHITE ONLY \n", + "2 STRAIGHT OR HETEROSEXUAL NO, NOT HISPANIC/LATINO WHITE ONLY \n", + "3 STRAIGHT OR HETEROSEXUAL NO, NOT HISPANIC/LATINO OTHER \n", + "4 STRAIGHT OR HETEROSEXUAL NO, NOT HISPANIC/LATINO BLACK ONLY \n", + "\n", + " Living Situation Household Composition Preferred Language \\\n", + "0 OTHER LIVING SITUATION NOT APPLICABLE ENGLISH \n", + "1 INSTITUTIONAL SETTING NOT APPLICABLE ENGLISH \n", + "2 PRIVATE RESIDENCE COHABITATES WITH OTHERS ENGLISH \n", + "3 OTHER LIVING SITUATION NOT APPLICABLE ASIAN AND PACIFIC ISLAND \n", + "4 OTHER LIVING SITUATION NOT APPLICABLE ENGLISH \n", + "\n", + " ... No Insurance Unknown Insurance Coverage Medicaid Insurance \\\n", + "0 ... NO NO YES \n", + "1 ... NO NO YES \n", + "2 ... NO NO YES \n", + "3 ... YES NO NO \n", + "4 ... NO NO YES \n", + "\n", + " Medicaid Managed Insurance Medicare Insurance Private Insurance \\\n", + "0 NO NO NO \n", + "1 NO UNKNOWN NO \n", + "2 NO NO NO \n", + "3 NOT APPLICABLE NO NO \n", + "4 UNKNOWN YES NO \n", + "\n", + " Child Health Plus Insurance Other Insurance Criminal Justice Status \\\n", + "0 NO NO YES \n", + "1 NO UNKNOWN YES \n", + "2 NO NO YES \n", + "3 NO NO YES \n", + "4 NO NO NO \n", + "\n", + " Three Digit Residence Zip Code \n", + "0 113 \n", + "1 113 \n", + "2 107 \n", + "3 888 \n", + "4 117 \n", + "\n", + "[5 rows x 65 columns]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "df.dtypes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Some Quick Data Exploration\n", + "Before running any sort of model on your dataset, it's always a good idea to do some quick data exploration to get a sense of how your data looks like. Try to answer the following questions with some sort of plot/histogram/etc:\n", + "\n", + "1) What do the distributions of each feature look like?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Ex\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Using scikitlearn for classification\n", + "\n", + "sklearn is a very useful python packager for building machiune learning models. To build a model in sklearn, you need to have a matrix (or dataframe) with X and y columns. X is your set of features/predictors. y is a single column that is your label. We'll take the foll;owing steps:\n", + "\n", + "1. Select/create column as label/outcome (y)\n", + "2. Select/create columns as features (X)\n", + "3. Create Training Set\n", + "4. Create Validation Set\n", + "5. Build model on Training Set\n", + "6. Predict risk scores for the Validation Set\n", + "7. Calculate performance metric(s)\n", + "\n", + "## Some useful things to know in sklearn\n", + "\n", + "fit = train an algorithm\n", + "\n", + "predict_proba = predict a \"risk\" score for all possible classes for a given record (classification only)\n", + "\n", + "\n", + "## Important- never use .predict\n", + "There is also a function called \"predict\" which first runs predict_probs and then predicts a 1 if the score > 0.5 and 0 otherwise. *Never* use that function since 0.5 is a completely arbitrary threshold to call a prediction 1 vs 0.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Create label/outcome\n", + "One thing we can do with this dataset is to try to use the various feature columns to classify whether a person has High Blood Pressure. Let's create a column that is 1 if a person has High Blood Pressure and 0 otherwise" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# code\n", + "df['HBP'] = np.where(df['High Blood Pressure']==\"YES\", 1, 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Question: what percentage of people have High Blood Pressure?" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.21600738092492217" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# code\n", + "df['HBP'].mean()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. create or select existing predictors/features\n", + "\n", + "For now, let's take a handful of existing columns to use.\n", + "\n", + "sklearn needs features to be numeric and not categorical so we'll have to turn our selected features to be binary (also known as dummy variables)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Region ServedAge GroupTransgenderSexual OrientationHispanic EthnicityLiving SituationHousehold CompositionPreferred LanguageVeteran StatusEmployment Status...Drug Substance Disorder_YESDrug Substance Disorder_nanCriminal Justice Status_NOCriminal Justice Status_UNKNOWNCriminal Justice Status_YESCriminal Justice Status_nanPrivate Insurance_NOPrivate Insurance_UNKNOWNPrivate Insurance_YESPrivate Insurance_nan
0HUDSON RIVER REGIONADULTNO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALYESOTHER LIVING SITUATIONNOT APPLICABLEENGLISHNONOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ......1000101000
1NEW YORK CITY REGIONADULTNO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALNO, NOT HISPANIC/LATINOINSTITUTIONAL SETTINGNOT APPLICABLEENGLISHNONOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ......1000101000
2HUDSON RIVER REGIONADULTNO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALNO, NOT HISPANIC/LATINOPRIVATE RESIDENCECOHABITATES WITH OTHERSENGLISHNONOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ......0000101000
3NEW YORK CITY REGIONADULTNO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALNO, NOT HISPANIC/LATINOOTHER LIVING SITUATIONNOT APPLICABLEASIAN AND PACIFIC ISLANDNONOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ......0000101000
4LONG ISLAND REGIONADULTNO, NOT TRANSGENDERSTRAIGHT OR HETEROSEXUALNO, NOT HISPANIC/LATINOOTHER LIVING SITUATIONNOT APPLICABLEENGLISHNONOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ......0010001000
\n", + "

5 rows × 91 columns

\n", + "
" + ], + "text/plain": [ + " Region Served Age Group Transgender \\\n", + "0 HUDSON RIVER REGION ADULT NO, NOT TRANSGENDER \n", + "1 NEW YORK CITY REGION ADULT NO, NOT TRANSGENDER \n", + "2 HUDSON RIVER REGION ADULT NO, NOT TRANSGENDER \n", + "3 NEW YORK CITY REGION ADULT NO, NOT TRANSGENDER \n", + "4 LONG ISLAND REGION ADULT NO, NOT TRANSGENDER \n", + "\n", + " Sexual Orientation Hispanic Ethnicity Living Situation \\\n", + "0 STRAIGHT OR HETEROSEXUAL YES OTHER LIVING SITUATION \n", + "1 STRAIGHT OR HETEROSEXUAL NO, NOT HISPANIC/LATINO INSTITUTIONAL SETTING \n", + "2 STRAIGHT OR HETEROSEXUAL NO, NOT HISPANIC/LATINO PRIVATE RESIDENCE \n", + "3 STRAIGHT OR HETEROSEXUAL NO, NOT HISPANIC/LATINO OTHER LIVING SITUATION \n", + "4 STRAIGHT OR HETEROSEXUAL NO, NOT HISPANIC/LATINO OTHER LIVING SITUATION \n", + "\n", + " Household Composition Preferred Language Veteran Status \\\n", + "0 NOT APPLICABLE ENGLISH NO \n", + "1 NOT APPLICABLE ENGLISH NO \n", + "2 COHABITATES WITH OTHERS ENGLISH NO \n", + "3 NOT APPLICABLE ASIAN AND PACIFIC ISLAND NO \n", + "4 NOT APPLICABLE ENGLISH NO \n", + "\n", + " Employment Status ... \\\n", + "0 NOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ... ... \n", + "1 NOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ... ... \n", + "2 NOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ... ... \n", + "3 NOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ... ... \n", + "4 NOT IN LABOR FORCE:UNEMPLOYED AND NOT LOOKING ... ... \n", + "\n", + " Drug Substance Disorder_YES Drug Substance Disorder_nan \\\n", + "0 1 0 \n", + "1 1 0 \n", + "2 0 0 \n", + "3 0 0 \n", + "4 0 0 \n", + "\n", + " Criminal Justice Status_NO Criminal Justice Status_UNKNOWN \\\n", + "0 0 0 \n", + "1 0 0 \n", + "2 0 0 \n", + "3 0 0 \n", + "4 1 0 \n", + "\n", + " Criminal Justice Status_YES Criminal Justice Status_nan \\\n", + "0 1 0 \n", + "1 1 0 \n", + "2 1 0 \n", + "3 1 0 \n", + "4 0 0 \n", + "\n", + " Private Insurance_NO Private Insurance_UNKNOWN Private Insurance_YES \\\n", + "0 1 0 0 \n", + "1 1 0 0 \n", + "2 1 0 0 \n", + "3 1 0 0 \n", + "4 1 0 0 \n", + "\n", + " Private Insurance_nan \n", + "0 0 \n", + "1 0 \n", + "2 0 \n", + "3 0 \n", + "4 0 \n", + "\n", + "[5 rows x 91 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# code\n", + "cols_to_transform = [ 'Sex', 'Race', 'Obesity', 'Smokes', 'Alcohol Related Disorder','Drug Substance Disorder',\n", + " 'Criminal Justice Status','Private Insurance']\n", + "df = pd.get_dummies( df, dummy_na=True, columns = cols_to_transform )\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's define a vector of column names with only those dummy variables." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# code\n", + "selected_features = ['Sex_FEMALE','Sex_MALE','Sex_UNKNOWN','Race_BLACK ONLY','Race_MULTI-RACIAL','Race_OTHER',\n", + " 'Race_UNKNOWN RACE','Race_WHITE ONLY', 'Obesity_YES', 'Obesity_NO', 'Obesity_nan', \n", + " 'Smokes_YES', 'Smokes_NO','Alcohol Related Disorder_NO','Alcohol Related Disorder_YES',\n", + " 'Alcohol Related Disorder_UNKNOWN','Criminal Justice Status_YES','Criminal Justice Status_NO',\n", + " 'Criminal Justice Status_UNKNOWN','Private Insurance_NO','Private Insurance_YES','Private Insurance_UNKNOWN']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train/Test Splits\n", + "\n", + "Create a train/test set split using sklearn's [train_test_split](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html) function. We'll use these train/test splits for evaluating all our classification models." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# code\n", + "x = df[selected_features]\n", + "y = df['HBP']\n", + "test_size = 0.3 # you can adjust this\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=test_size)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Logistic Regression\n", + "See the sklearn documentation on Logistic Regression to see its parameters. The one's we'll mostly be interested in are:\n", + "- penalty\n", + "- C" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Remember that when training a model, **you should only use the training data!** The test set is reserved exclusively for evaluating your model. Now let's use the classifier:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# code\n", + "lr = LogisticRegression(random_state=0, solver='liblinear')\n", + "lr.fit(x_train, y_train)\n", + "pred_scores = lr.predict_proba(x_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.75929133 0.24070867]\n", + " [0.64513388 0.35486612]\n", + " [0.75818005 0.24181995]\n", + " ...\n", + " [0.64228939 0.35771061]\n", + " [0.82387763 0.17612237]\n", + " [0.75929133 0.24070867]]\n" + ] + } + ], + "source": [ + "print(pred_scores)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Logistic Regression Tasks:\n", + "\n", + "The goal here is to explore different penalty parameters and different C values. You can also try modofyinfg other parameters to see their impact. How does accuracy change, using different thresholds, as you vary penalty and C values? You can write a nested for loop that loops over all the parameters and values and store the results in a data frame (similar to last lab)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "Ref: http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html\n", + "\n", + "You'll notice that LogisticRegression takes a ton of parameters. We'll play around with the \"penalty\" and \"C\" parameters.\n", + "If we set the penalty parameter to ['l2'](http://mathworld.wolfram.com/L2-Norm.html), sklearn's LogisticRegression model solves the following minimization problem:\n", + "\n", + "$$ \\min_{\\beta} ||\\beta||_2 + C \\sum_{i} \\log ( -y_i (X_i^T \\beta) +1)$$\n", + "\n", + "Similarly, if we set the penalty parameter to ['l1'](http://mathworld.wolfram.com/L2-Norm.html), LogisticRegression will solve the following minimization problem:\n", + "\n", + "$$\\min_{\\beta} ||\\beta||_1 + C \\sum_{i} \\log ( -y_i (X_i^T \\beta) +1)$$\n", + "\n", + "where $$||\\beta||_2 = \\sqrt { \\sum_{i} \\beta_i^2 }$$ and $$||\\beta||_1 = \\sum_{i} | \\beta_i | $$ \n", + "\n", + "Try running logistic regression with both L1 and L2 penalties and a mix of C values. Something like $10^{-2}, 10^{-1}, 1, 10, 10^2)$ is reasonable." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The true number of HBP is 541/2602 from the data, with percentage 20.79%\n", + "\n", + "(Threshold: 0.1), the total number of predicted HBP is 2539, the accuracy is 0.23\n", + "(Threshold: 0.2), the total number of predicted HBP is 1604, the accuracy is 0.48\n", + "(Threshold: 0.25), the total number of predicted HBP is 578, the accuracy is 0.70\n", + "(Threshold: 0.3), the total number of predicted HBP is 377, the accuracy is 0.74\n", + "(Threshold: 0.35), the total number of predicted HBP is 291, the accuracy is 0.76\n", + "(Threshold: 0.4), the total number of predicted HBP is 113, the accuracy is 0.78\n", + "(Threshold: 0.5), the total number of predicted HBP is 0, the accuracy is 0.79\n", + "(Threshold: 0.6), the total number of predicted HBP is 0, the accuracy is 0.79\n", + "(Threshold: 0.7), the total number of predicted HBP is 0, the accuracy is 0.79\n" + ] + } + ], + "source": [ + "# we first choose a threshold to determine the pridiction \n", + "print(\"The true number of HBP is {}/{} from the data, with percentage {:.2f}%\\n\".format(\n", + " sum(y_test), len(y_test), 100.*sum(y_test)/len(y_test)))\n", + "for threshold in [0.1, 0.2, 0.25, 0.3, 0.35, 0.4, 0.5, 0.6, 0.7]:\n", + " pred_label = [1 if x[1]>threshold else 0 for x in pred_scores]\n", + " print(\"(Threshold: {}), the total number of predicted HBP is {}, the accuracy is {:.2f}\".format(\n", + " threshold, sum(pred_label), accuracy(pred_label,y_test)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It seems like 0.3 is a reasonable value. Then we fix the threshold and adjust penalty and the C value" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(reg: l1, C: 0.01), the total number of predicted HBP is 504, the accuracy is 0.72\n", + "(reg: l1, C: 0.1), the total number of predicted HBP is 394, the accuracy is 0.74\n", + "(reg: l1, C: 1), the total number of predicted HBP is 376, the accuracy is 0.75\n", + "(reg: l1, C: 10), the total number of predicted HBP is 372, the accuracy is 0.75\n", + "(reg: l1, C: 100), the total number of predicted HBP is 377, the accuracy is 0.74\n", + "\n", + "(reg: l2, C: 0.01), the total number of predicted HBP is 397, the accuracy is 0.74\n", + "(reg: l2, C: 0.1), the total number of predicted HBP is 378, the accuracy is 0.75\n", + "(reg: l2, C: 1), the total number of predicted HBP is 372, the accuracy is 0.75\n", + "(reg: l2, C: 10), the total number of predicted HBP is 377, the accuracy is 0.74\n", + "(reg: l2, C: 100), the total number of predicted HBP is 377, the accuracy is 0.74\n", + "\n" + ] + } + ], + "source": [ + "# code\n", + "threshold = 0.3\n", + "penalties = ['l1', 'l2']\n", + "c_values = [10**-2, 10**-1, 1 , 10, 10**2]\n", + "for norm in penalties:\n", + " for reg_strength in c_values:\n", + " lrf = LogisticRegression(random_state=0, solver='liblinear', penalty=norm, C=reg_strength).fit(x_train, y_train)\n", + " pred_scores = lrf.predict_proba(x_test)\n", + " pred_label = [1 if x[1]>threshold else 0 for x in pred_scores]\n", + " print(\"(reg: {}, C: {}), the total number of predicted HBP is {}, the accuracy is {:.2f}\".format(\n", + " norm, reg_strength, sum(pred_label), accuracy(pred_label,y_test)))\n", + " print" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Understanding what's going on inside Logistic Regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To really see the difference between L1 and L2 regularization, we need to take a closer look at the models they produced. Plot a histogram of the weight values of LogisticRegression models for each C value. You can access these weight coefficients via the coef\\_ attribute in LogisticRegression. Do you notice anything interesting happening as the C value varies?" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# code\n", + "coefs = []\n", + "\n", + "for norm in penalties:\n", + " coef = []\n", + " for reg_strength in c_values:\n", + " lrf = LogisticRegression(random_state=0, solver='liblinear', penalty=norm, C=c_value).fit(x_train, y_train)\n", + " pred_scores = lrf.predict_proba(x_test)\n", + " pred_label = [1 if x[1]>threshold else 0 for x in pred_scores]\n", + " coef.append(lrf.coef_)\n", + " coefs.append(coef)" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAHq1JREFUeJzt3Xu8FXW9//HXG9CwUDAhTSDRJBUzy9BSUynN0ErrVAYnSzpejpWdbr/KbkZUp4snLU92iszjpfKeRUfKMi9dvIEaEqKJlwKvoCaSF0Q+vz++3z0Oi7X2mg179tob38/HYz32XL7rO5+ZtfZ8Zr4z6zuKCMzMzAAGdToAMzPrP5wUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4K/YSk90j6zTq+d4GkSb0cUr8n6VeSjuivy5d0hqSvVKxrnKSQNKT3IqzXQIzZ2nNSWAeS7pZ0QG/WGRE/iYgDKyx7rR1NROwcEVf2ZHmlf+gV+XW3pON7GHZHRcRBEXFmf1i+pGmS/thbdUs6TNLVkh6XdGVv1VsnSVdKOqoX69tM0rcl/T1/R+/I4yN7axl5OTMl3SZptaRpbco+T9LpkpZLul/Sxxvm7y/p1vy5XSFpm96MtS84KdiIiBgGvBP4gqQ39vYCfCS5Th4Gvg18vdOBdIKkjYHfATsDk4HNgD2Bh4A9enlx84APAjdWKDsdGA9sA7we+JSkyTnmkcDPgC8ALwTmAuf1cqz1iwi/evgC7gYOaDHvaGAR6Z96FrB1ad6BwG3Ao8D3gKuAo/K8acAf87CAk4EHgeXAfODlwDHA08BKYAXwy8Z4gMHAZ4E7gMeAG4CxTeIcBwQwpDTteuCTpfGtgYuApcBdwH+U5m0CnAk8AiwEPgUsadhGnwZuBp4ChrSpbw/SP9Fy4AHgpDx9KPBj0s7gH8AcYMs878rS9hsEfB74W95uZwHDG9b1CODvwDLgcy0+v23zcgbl8R8CD5bmnw18tLx8YCfgSeCZ/Ln8I88/AzgVuCR/FtcBL22x3LU+jzz9KODKNt/HScCS/Lkvy9v+PaX5zwP+K6/7A8D3gU0a3vuJvN3uA95feu+bgZvy57IYmN4sZuCref2fzNvgu3ndv9UQ6yzgYxX+x47KsQ7rw//rPwLT2pS5FziwNP5l4Nw8fAxwdWneC4AngB37ah164+UzhV4k6Q3A14DDgBeTdlDn5nkjgQuBzwBbkJLDXi2qOhDYF3gZMDzX91BEzAR+AnwzIoZFxFubvPfjwFTgYNLR1b8Bj1eI/bWkxLMojw8Cfkk6ihoN7A98VNKb8lu+SNopbAe8ETi8SbVTSTuVEcDqNvV9B/hORGwGvBQ4P08/Im+DsaTtdizpH63RtPx6fY5pGGnHVPY6YIe87BMk7dRYSUTcRdoBvipP2hdYUSq7HymZl9+zMMd1Tf5cRpRmTwG+BGxO2rZfbRJ7b9gKGEnatkcAMyXtkOd9nfRdeiWwfS5zQsN7h+fpRwKnSto8z/sn8D7SZ/hm4AOS3ta48Ij4HPAH4Li8DY4jHTRMzd+lrv+BA4CfVlifA4BfR8SKaqsPkm6W9I8Wr+9Vraeb+jcn/V/PK02eRzqbIf8t5kXEP0kHZzszgDgp9K73AKdHxI0R8RQpAewpaRxpJ70gIn4WEauAU4D7W9TzNLApsCOgiFgYEfdVjOEo4PMRcVsk8yLioW7KL5P0BHAN6ezl53n67sCoiJgRESsj4k7SUfOUPP8w4D8j4pGIWJLXp9EpEbE4Ip6oUN/TwPaSRkbEioi4tjR9C2D7iHgmIm6IiOVNlvUe0tnFnXlH8hlgSkPT1Zci4omImEf65921xTa5CthP0lZ5/MI8vi0p0c5r8b5mLo6I6/Nn/hPSjrkuX4iIpyLiKtLZyWGSRDqC/VhEPBwRjwH/ybPbHdI2nhERT0fEbNKR/g4AEXFlRMyPiNURcTNwDikxthUR15POivfPk6aQznoeqPD2LUhnLZVFxCsiYkSL1wd7UlcLw/LfR0vTHiX9r3bNf5Q1lecPCE4KvWtr0tkBAHnn9BDpCGxr0ul317wgnbavJSIu59nT7wfzhbDNKsYwlnR0UtVI0pf5E6SmhI3y9G2ArctHW6TmiS3z/DXWp2G42bR29R1JOpq9VdIcSW/J088GLgXOlXSvpG9K2oi1rbHt8/CQUv2wZhJ+nGf/yRtdRdoW+wK/JzUT7Zdff4iI1S3e10zVZa6vR/KRaZe/kbbJKOD5wA2l7f7rPL3LQzlprRWnpNfkC6ZLJT1KOiPqyYXeM3n2LPJw0udZxUOko/L+pOuspfy/uBmpabBrfuP/aXn+gOCk0LvuJe38AJD0AtIRzz2ko54xpXkqjzeKiFMi4tXABNLO8pNds9rEsJjU/FJZPgI/idQe3HVEtRi4q+Foa9OIODjPX2N9SMloraob4mpZX0TcHhFTgRcB3wAulPSCfPT6pYiYQGpuewupOaPRGtseeAmwitQu3VNXAfuQEsNVpLbmvWnSdNRiXTth8/x96/IS0jZZRmpu27m03YdHurmgip+SrgOMjYjhpOsRalG22Tb4MXCopF1J115+3qRMM5cBb2pYp27lW7NXtHh9v2o9rUTEI6TvffkMc1dgQR5eUJ6XY39paf6A4KSw7jaSNLT0GkI6tX6/pFdKeh7pNP26iLibdDq/i6S35bIfIrXlrkXS7vkIbSNSm+6TpDZ5SDu57bqJ6zTgy5LGK3mFpC0qrtPXSXdTDCVddH5M0qclbSJpsKSXS9o9lz0f+IykzSWNBo5rU3e39Uk6XNKofBT+j/ye1ZJeL2kXSYNJbf1Pl7ZF2TnAxyRtK2kYaduf13AEXElE3E7akR4OXJWbqx4A3kHrpPAAMCbfNbPe8vYZSjrbGZS/Y83OkMq+JGljSfuQkucFeXv+EDhZ0oty3aNL13La2RR4OCKelLQH8K/dlF3ru5mbFueQzhAuyk2JXet4hqQzWtR1NulA4iJJO0oaJGkLSZ+VdHCzN0S6NXtYi9exrYLO22woKdl1/V+32jeeBXw+f+93JN1Y0rUOFwMvl/SOXN8JwM0RcWurZfdHTgrrbjZpx9H1mh4Rl5FuR7uIdETxUnLbbUQsA94FfJN0ajyBdLfNU03q3oz0j/wIqRngIeDEPO9HwITcFNDsqOsk0g77N6Sd6I9IdwpVcUle5tER8Qxpx/JK0p1Cy0gJZ3guO4PU/HUX6ajuwhbrAqSzkTb1TQYWSFpBuug8Je9Atsp1Lyfd5XQVzZsgTs/Tf5/rfxL4cMX1buYqUrPK4tK4aH3b4uWkI8L7JS1bj+V2eS/pe/U/pLOWJ0jfiVbuJ31295KuXRxb2hl9mnSR+1pJy0mf1w5Na1nbB4EZkh4j7eTO76bsd4B3SnpEUvka05nALqz9uY0F/tSsonxN7gDgVuC3pM//elLT1XUVY6/qN6TtuxcwMw/vC8WPSstH+l8kNc/+jfSdODEifp1jXko6cPgq6bN4DWteuxkQlJq2ra/lI5ElpFsHr+h0POtL0gdIO/JKFyGt9yj9mv3HEdGyObKTJO1LakbaJl9L6/odwjzgFRHxdCfjszX5TKEPSXqTpBG5aemzpCPPa9u8rV+S9GJJe+fT+h1IF6ov7nRc1r/kJq+PAKdF6Qg034G2kxNC/+Ok0Lf2JJ16LgPeCryt3MY6wGwM/IB0Z8XlwC9It7SaAaD0245/kO4i+naHw7GK3HxkZmYFnymYmVlhwHVUNnLkyBg3blynwzAzG1BuuOGGZRExql25AZcUxo0bx9y5czsdhpnZgCLpb+1LufnIzMxKnBTMzKzgpGBmZgUnBTMzKzgpmJlZwUnBzMwKtSUFSadLelDSX1rMl6RTJC1SeozebnXFYmZm1dR5pnAGqTvkVg4CxufXMaQugs3MrINqSwoR8Xvg4W6KHAqclZ8jfC0wQlJ/e/yemdlzSievKYxmzWf4LsnT1iLpGElzJc1dunRprwey5Pg/9HqdVU2fPr2mioe3L9MD446/ZI3xU4+9vMfvqcPCHXfiW+9+S8v5tW1fqm2Djurl74DVb5czd+l0CAPjQnNEzIyIiRExcdSotl13mJnZOupkUriHNR/2PiZPMzOzDulkUpgFvC/fhfRa4NGIuK+D8ZiZPefV1kuqpHOAScBISUtID7zeCCAivk968P3BpAeKPw68v65YzMysmtqSQkRMbTM/gA/VtXwzM+u5AXGh2czM+oaTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZgUnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWqDUpSJos6TZJiyQd32T+SyRdIekmSTdLOrjOeMzMrHu1JQVJg4FTgYOACcBUSRMain0eOD8iXgVMAb5XVzxmZtZenWcKewCLIuLOiFgJnAsc2lAmgM3y8HDg3hrjMTOzNupMCqOBxaXxJXla2XTgcElLgNnAh5tVJOkYSXMlzV26dGkdsZqZGZ2/0DwVOCMixgAHA2dLWiumiJgZERMjYuKoUaP6PEgzs+eKOpPCPcDY0viYPK3sSOB8gIi4BhgKjKwxJjMz60adSWEOMF7StpI2Jl1IntVQ5u/A/gCSdiIlBbcPmZl1SG1JISJWAccBlwILSXcZLZA0Q9IhudgngKMlzQPOAaZFRNQVk5mZdW9InZVHxGzSBeTytBNKw7cAe9cZg5mZVdfpC81mZtaPOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZgUnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzAqVkoKkXeoOxMzMOq/qmcL3JF0v6YOShtcakZmZdUylpBAR+wDvAcYCN0j6qaQ31hqZmZn1ucrXFCLiduDzwKeB/YBTJN0q6V/qCs7MzPpW1WsKr5B0MrAQeAPw1ojYKQ+fXGN8ZmbWh6qeKfw3cCOwa0R8KCJuBIiIe0lnD01JmizpNkmLJB3fosxhkm6RtEDST3u6AmZm1nuGVCz3ZuCJiHgGQNIgYGhEPB4RZzd7g6TBwKnAG4ElwBxJsyLillKZ8cBngL0j4hFJL1qPdTEzs/VU9UzhMmCT0vjz87Tu7AEsiog7I2IlcC5waEOZo4FTI+IRgIh4sGI8ZmZWg6pJYWhErOgaycPPb/Oe0cDi0viSPK3sZcDLJP1J0rWSJleMx8zMalA1KfxT0m5dI5JeDTzRC8sfAowHJgFTgR9KGtFYSNIxkuZKmrt06dJeWKyZmTVT9ZrCR4ELJN0LCNgKeHeb99xD+l1DlzF5WtkS4LqIeBq4S9JfSUliTrlQRMwEZgJMnDgxKsZsZmY9VCkpRMQcSTsCO+RJt+UdeXfmAOMlbUtKBlOAf20o83PSGcL/ShpJak66s2rwZmbWu6qeKQDsDozL79lNEhFxVqvCEbFK0nHApcBg4PSIWCBpBjA3ImbleQdKugV4BvhkRDy0jutiZmbrqVJSkHQ28FLgz6SdN0AALZMCQETMBmY3TDuhNBzAx/PLzMw6rOqZwkRgQt6Jm5nZBqrq3Ud/IV1cNjOzDVjVM4WRwC2Srgee6poYEYfUEpWZmXVE1aQwvc4gzMysf6h6S+pVkrYBxkfEZZKeT7qjyMzMNiBVu84+GrgQ+EGeNJr0GwMzM9uAVL3Q/CFgb2A5FA/ccY+mZmYbmKpJ4anc0ykAkoaQfqdgZmYbkKpJ4SpJnwU2yc9mvgD4ZX1hmZlZJ1RNCscDS4H5wL+TfqXc8olrZmY2MFW9+2g18MP8MjOzDVTVvo/uosk1hIjYrtcjMjOzjulJ30ddhgLvAl7Y++GYmVknVbqmEBEPlV73RMS3gTfXHJuZmfWxqs1Hu5VGB5HOHHryLAYzMxsAqu7Yv1UaXgXcDRzW69GYmVlHVb376PV1B2JmZp1Xtfmo2yejRcRJvROOmZl1Uk/uPtodmJXH3wpcD9xeR1BmZtYZVZPCGGC3iHgMQNJ04JKIOLyuwMzMrO9V7eZiS2BlaXxlnmZmZhuQqmcKZwHXS7o4j78NOLOekMzMrFOq3n30VUm/AvbJk94fETfVF5aZmXVC1eYjgOcDyyPiO8ASSdvWFJOZmXVI1cdxfhH4NPCZPGkj4Md1BWVmZp1R9Uzh7cAhwD8BIuJeYNO6gjIzs86omhRWRkSQu8+W9IL6QjIzs06pmhTOl/QDYISko4HL8AN3zMw2OFXvPvqv/Gzm5cAOwAkR8dtaIzMzsz7XNilIGgxcljvFcyIwM9uAtW0+iohngNWShvdBPGZm1kFVf9G8Apgv6bfkO5AAIuI/aonKzMw6ompS+Fl+mZnZBqzbpCDpJRHx94hYp36OJE0GvgMMBk6LiK+3KPcO4EJg94iYuy7LMjOz9dfumsLPuwYkXdSTivMF6lOBg4AJwFRJE5qU2xT4CHBdT+o3M7Pe1y4pqDS8XQ/r3gNYFBF3RsRK4Fzg0Cblvgx8A3iyh/WbmVkva5cUosVwFaOBxaXxJXlaQdJuwNiIuKS7iiQdI2mupLlLly7tYRhmZlZVuwvNu0paTjpj2CQPk8cjIjZb1wVLGgScBExrVzYiZgIzASZOnNjT5GRmZhV1mxQiYvB61H0PMLY0PiZP67Ip8HLgSkkAWwGzJB3ii81mZp3Rk+cp9NQcYLykbSVtDEwBZnXNjIhHI2JkRIyLiHHAtYATgplZB9WWFCJiFXAccCmwEDg/IhZImiHpkLqWa2Zm667qj9fWSUTMBmY3TDuhRdlJdcZiZmbt1dl8ZGZmA4yTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZgUnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWqDUpSJos6TZJiyQd32T+xyXdIulmSb+TtE2d8ZiZWfdqSwqSBgOnAgcBE4CpkiY0FLsJmBgRrwAuBL5ZVzxmZtZenWcKewCLIuLOiFgJnAscWi4QEVdExON59FpgTI3xmJlZG3UmhdHA4tL4kjytlSOBXzWbIekYSXMlzV26dGkvhmhmZmX94kKzpMOBicCJzeZHxMyImBgRE0eNGtW3wZmZPYcMqbHue4CxpfExedoaJB0AfA7YLyKeqjEeMzNro84zhTnAeEnbStoYmALMKheQ9CrgB8AhEfFgjbGYmVkFtSWFiFgFHAdcCiwEzo+IBZJmSDokFzsRGAZcIOnPkma1qM7MzPpAnc1HRMRsYHbDtBNKwwfUuXwzM+uZfnGh2czM+gcnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZgUnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmaFWpOCpMmSbpO0SNLxTeY/T9J5ef51ksbVGY+ZmXWvtqQgaTBwKnAQMAGYKmlCQ7EjgUciYnvgZOAbdcVjZmbt1XmmsAewKCLujIiVwLnAoQ1lDgXOzMMXAvtLUo0xmZlZNxQR9VQsvROYHBFH5fH3Aq+JiONKZf6SyyzJ43fkMssa6joGOCaP7gDc1mKxI4FlLeb1ZwM1bhi4sTvuvuW4+1azuLeJiFHt3jiknnh6V0TMBGa2KydpbkRM7IOQetVAjRsGbuyOu2857r61PnHX2Xx0DzC2ND4mT2taRtIQYDjwUI0xmZlZN+pMCnOA8ZK2lbQxMAWY1VBmFnBEHn4ncHnU1Z5lZmZt1dZ8FBGrJB0HXAoMBk6PiAWSZgBzI2IW8CPgbEmLgIdJiWN9tG1i6qcGatwwcGN33H3LcfetdY67tgvNZmY28PgXzWZmVnBSMDOzwoBOCpLeJWmBpNWSWt5+JeluSfMl/VnS3L6MsUU8VePutpuQTpD0Qkm/lXR7/rt5i3LP5O39Z0mNNxj0iYHazUqFuKdJWlravkd1Is5Gkk6X9GD+/VGz+ZJ0Sl6vmyXt1tcxNlMh7kmSHi1t7xP6OsZmJI2VdIWkW/L+5CNNyvR8m0fEgH0BO5F+zHYlMLGbcncDIzsdb0/iJl2cvwPYDtgYmAdM6AexfxM4Pg8fD3yjRbkVHY6z7fYDPgh8Pw9PAc7rB9u3StzTgO92OtYmse8L7Ab8pcX8g4FfAQJeC1zX6Zgrxj0J+L9Ox9kkrhcDu+XhTYG/Nvmu9HibD+gzhYhYGBGtft3cb1WMu0o3IZ1Q7prkTOBtHYylOwO1m5X++rm3FRG/J91F2MqhwFmRXAuMkPTivomutQpx90sRcV9E3JiHHwMWAqMbivV4mw/opNADAfxG0g25y4yBYDSwuDS+hLU/8E7YMiLuy8P3A1u2KDdU0lxJ10rqROKosv2KMhGxCngU2KJPomut6uf+jtwccKGksU3m90f99TtdxZ6S5kn6laSdOx1Mo9z0+SrguoZZPd7m/b6bC0mXAVs1mfW5iPhFxWpeFxH3SHoR8FtJt+ajg9r0Utwd0V3s5ZGICEmt7mneJm/z7YDLJc2PiDt6O9bnqF8C50TEU5L+nXS284YOx7Qhu5H0fV4h6WDg58D4DsdUkDQMuAj4aEQsX9/6+n1SiIgDeqGOe/LfByVdTDpFrzUp9ELcVboJqUV3sUt6QNKLI+K+fBr6YIs6urb5nZKuJB3F9GVS6Ek3K0v6UTcrbeOOiHKMp5Gu8wwEHftOr4/yjjYiZkv6nqSR0dBxZydI2oiUEH4SET9rUqTH23yDbz6S9AJJm3YNAwcCTe8y6GeqdBPSCeWuSY4A1jrrkbS5pOfl4ZHA3sAtfRZhMlC7WWkbd0Ob8CGktuSBYBbwvnxHzGuBR0tNkf2WpK26rjVJ2oO03+z0wQM5ph8BCyPipBbFer7NO30FfT2vvr+d1Eb2FPAAcGmevjUwOw9vR7qDYx6wgNR80+/jjmfvHPgr6Qi743HnmLYAfgfcDlwGvDBPnwiclof3AubnbT4fOLJDsa61/YAZwCF5eChwAbAIuB7YrtPbt2LcX8vf5XnAFcCOnY45x3UOcB/wdP5+HwkcCxyb54v04K078vei5R2D/Szu40rb+1pgr07HnON6Hel66c3An/Pr4PXd5u7mwszMCht885GZmVXnpGBmZgUnBTMzKzgpmJlZwUnBzMwKTgo2oEk6WdJHS+OXSjqtNP4tSR9vU8fVFZZzd/7NReP0SZL26mncLZYxTdJ3e6Mus3XlpGAD3Z9Iv4tA0iBgJFDum2YvoNudfkSsz059UtfyzTYETgo20F0N7JmHdyb9Wv2x0q+qdyL1XYOkT0qakzuS+1JXBZJW5L+DchcGtyo9K2K2pHeWlvVhSTcqPZtjx9wJ2bHAx3I/+/uU6hyUzy5GlKbdLmlLSW9Ven7DTZIuk7RWp4KSzigvuyvGVuuRf7l/Se607S+S3r3OW9Se05wUbECLiHuBVZJeQjpiv4bUU+SepF9Zz4+IlZIOJHVitgfwSuDVkvZtqO5fgHHABOC9PJtsuiyLiN2A/wH+X0TcDXwfODkiXhkRfyjFtZrUBcjbASS9BvhbRDwA/BF4bUS8itQ19qeqrm836zEZuDcido2IlwO/rlqnWZmTgm0IriYlhK6kcE1p/E+5zIH5dRPpzGFH1u7p8nXABRGxOiLuJ3UhUdbV4dgNpOTRznlA1xH7lDwOqVOySyXNBz7Jms1d7bRaj/nAGyV9Q9I+EfFoD+o0K/T7XlLNKui6rrALqfloMfAJYDnwv7mMgK9FxA/WYzlP5b/PUO1/5xpge0mjSA8j+kqe/t/ASRExS9IkYHqT964iH7TlayUb5+kt10PpUYsHA1+R9LuImFFlpczKfKZgG4KrgbcAD0fEMxHxMDCC1PzTdZH5UuDfct/zSBqdn69R9ifSw2sG5Xb+SRWW/RjpUYhridSx2MXASaSeLLt61hzOs90XH9HsvaRHyL46Dx8CbNTdekjaGng8In4MnEh6vKRZj/lMwTYE80l3Hf20YdqwyH3eR8RvJO0EXJN7QV4BHM6az4O4CNif1M33YlLzTLtmmF8CF0o6FPhw+bpCdh6pO+xppWnTgQskPQJcDmzbpN4fAr+QNI90feCfbdZje+BESatJvX1+oE3cZk25l1SzEknDIj1hawtSd9p75+sLZs8JPlMwW9P/5dtINwa+7IRgzzU+UzAzs4IvNJuZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRX+P9Z7xc4nSkJyAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAHvhJREFUeJzt3Xm8HFWZ//HPNwkYFEiQRJYkEpAIBBHFgAKCURADKuiomAwocVgGFcftp+IyGOMuIygjjkZkWFR20ThEUQTiwpYAhhgCEjYT1gSQEFkC5Pn9cc4tKp3u23WTW7fvDd/369WvW8vpU09V962n6lT1KUUEZmZmAIM6HYCZmfUfTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJ4UOknSYpN+u5XsXSJrYyyH1e5J+LemI/rp8SWdI+krFusZKCklDei/Ceg3EmK1nnBQqknSXpP17s86I+GlEHFBh2WvsaCJi54i4sifLK/1Dr8ivuyQd38OwOyoiDoyIM/vD8iVNlfSn3qpb0qGSrpL0uKQre6veOkm6UtJRvVjfppK+I+nv+Tt6ex4f0VvLyMuZIelWSaskTW0y/+OS7pe0XNLpkl7QTV37Sbolf25XSNqmNO8F+f3Lc32f6M31qIOTwvPT8IjYGHg38J+S3tzbC/CR5Fp5GPgO8I1OB9IJkjYEfg/sDEwCNgX2BB4C9ujlxc0DPgTc0CSOtwDHA/sB2wDbAV9qEfMI4OfAfwIvBuYC55WKTAPG5XreCHxa0qTeWolaRIRfFV7AXcD+LeYdDSwi/VPPBLYuzTsAuBV4FPg+MBs4Ks+bCvwpDws4GXgQWA7MB14BHAM8DawEVgC/aowHGAx8DrgdeAy4HhjTJM6xQABDStOuAz5VGt8auAhYCtwJ/Edp3kbAmcAjwELg08CShm30GeAm4ClgSJv69iD9Ey0HHgBOytOHAj8h7Qz+AcwBtsjzrixtv0HAF4C783Y7CxjWsK5HAH8HlgGfb/H5bZuXMyiP/wh4sDT/bOBj5eUDOwFPAs/mz+Ufef4ZwKnAJfmzuBZ4WYvlrvF55OlHAVe2+T5OBJbkz31Z3vaHlea/APivvO4PAD8ANmp47yfzdrsP+EDpvW8Fbsyfy2JgWrOYga/m9X8yb4Pv5XX/dkOsM4GPV/gfOyrHunEf/l//CZjaMO1nwNdK4/sB97d4/zHAVaXxFwFPADvm8XuBA0rzvwyc21frtzYvnymsI0lvAr4OHApsRdpBnZvnjQAuBD4LbE5KDnu1qOoAYF/g5cCwXN9DETED+CnwrYjYOCLe3uS9nwCmAAeRjq7+DXi8QuyvIyWeRXl8EPAr0lHUKNI/w8fykRPAF0k7he2ANwOHN6l2CmmnMhxY1aa+7wLfjYhNgZcB5+fpR+RtMIa03Y4l/aM1mppfb8wxbUzaMZW9HtghL/sESTs1VhIRd5J2gK/Ok/YFVpTKvoGUzMvvWZjjujp/LsNLsyeTjiw3I23brzaJvTdsCYwgbdsjgBmSdsjzvkH6Lr0K2D6XOaHhvcPy9COBUyVtluf9E3g/6TN8K/BBSe9oXHhEfB74I3Bc3gbHkQ4apuTvUtf/wP6kHW07+wO/iYgV1VYfJN0k6R8tXt+vWk+DnUnf2S7zgC0kbd6ubET8k3RwtnPenls1qWvntYyrTzgprLvDgNMj4oaIeIqUAPaUNJa0k14QET+PiGeAU4D7W9TzNLAJsCOgiFgYEfdVjOEo4AsRcWsk8yLioW7KL5P0BHA16ezlF3n67sDIiJgeESsj4g7SUfPkPP9Q0hHUIxGxJK9Po1MiYnFEPFGhvqeB7SWNiIgVEXFNafrmwPYR8WxEXB8Ry5ss6zDS2cUdeUfyWWByQ9PVlyLiiYiYR/qH3LXFNpkNvEHSlnn8wjy+LSnRzmvxvmYujojr8mf+U9KOuS7/GRFPRcRs0tnJoZJEOoL9eEQ8HBGPAV/jue0OaRtPj4inI2IW6Uh/B4CIuDIi5kfEqoi4CTiHlBjbiojrSGfF++VJk0lnPQ9UePvmpLOWyiLilRExvMXrQz2pq2Rj0jp06RrepELZrvKb5HmwZl3N6uk3nBTW3dakswMA8s7pIdIR2Nak0++ueUE6bV9DRFzOc6ffD+YLYZtWjGEM6eikqhGkL+wnSU0JG+Tp2wBbl4+2SM0TW+T5q61Pw3Czae3qO5J0NHuLpDmS3pannw1cCpwr6V5J35K0AWtabdvn4SGl+mH1JPw4z/2jNppN2hb7An8gNRO9Ib/+GBGrWryvmarLXFeP5CPTLneTtslI4IXA9aXt/ps8vctDOWmtEaek1+YLpkslPUo6I+rJhd4zee4s8nDS51nFQ6Qj605bQToQ6NI1/FiFsl3lH8vzYM26mtXTbzgprLt7STs/ACS9iHTEcw/pqGd0aZ7K440i4pSIeA0wnrSz/FTXrDYxLCY1v1SWj8BPIrUHdx1RLQbubDja2iQiDsrzV1sfUjJao+qGuFrWFxG3RcQU4CXAN4ELJb0oH71+KSLGk5rb3kZqzmi02rYHXgo8Q2qX7qnZwD6kxDCb1Na8N02ajlqsaydslr9vXV5K2ibLSM1tO5e2+7BINxdU8TPSdYAxETGMdD1CLco22wY/AQ6RtCvp2ssvmpRp5jLgLQ3r1K18a/aKFq8fVK2nwQJWP6PcFXigxdn3amVz7C8jtRA8QvqfaaxrwVrG1SecFHpmA0lDS68hpFPrD0h6Vb5t7WvAtRFxF+l0fhdJ78hlP0xqy12DpN3zEdoGpDbdJ0lt8pB2ctt1E9dpwJcljVPyyhbtn818g3RHxFDSRefHJH1G0kaSBkt6haTdc9nzgc9K2kzSKOC4NnV3W5+kwyWNzEfh/8jvWSXpjZJ2kTSY1Nb/dGlblJ0DfFzStpI2Jm378xqOgCuJiNtIO9LDgdm5ueoB4F20TgoPAKPzXTPrLG+foaSznUH5O9bsDKnsS5I2lLQPKXlekLfnj4CTJb0k1z2qdC2nnU2AhyPiSUl7AP/aTdk1vpu5aXEO6QzhotyU2LWOZ0g6o0VdZ5MOJC6StKOkQZI2l/Q5SQc1e0OkW7M3bvE6tlXQeZsNJSW7rv/rrv3hWcCRksZLGk66maFVzBcDr5D0rlzfCcBNEXFLqa4v5P+ZHUk3pbSqq19wUuiZWaQdR9drWkRcRrod7SLSUcHLyG23EbEMeA/wLdKp8XjS3TZPNal7U9I/8iOkZoCHgBPzvB8D43NTQLOjrpNIO+zfknaiPybdKVTFJXmZR0fEs6Qdy6tIdwotIyWcYbnsdFLz152ko7oLW6wLkM5G2tQ3CVggaQXpovPkvAPZMte9nHSX02yaN0Gcnqf/Idf/JPCRiuvdzGxSs8ri0rhocttidjnpqO9+ScvWYbld3kf6Xv0P6azlCdJ3opX7SZ/dvaRrF8eWdkafIV3kvkbSctLntUPTWtb0IWC6pMdIO7nzuyn7XeDdkh6RVL7GdCawC2t+bmOAPzerKF+T2x+4Bfgd6fO/jtR0dW3F2Kv6LWn77gXMyMP75jh+Q/qfvYJ099bdpJssgOLs5LBcdinpwOGrpM/itax+7eaLpKbdu0nfpxNz/f2WUjO39YV8JLKEdOvgFZ2OZ11J+iBpR17pIqT1HqVfs/8kIlo2R3aSpH1JzUjb5GtpXb9DmAe8MiKe7mR81prPFGom6S2Shuempc+RjjyvafO2fknSVpL2zqf1O5AuVF/c6bisf8lNXh8FTovSUWe+A20nJ4T+zUmhfnuSTh+XAW8H3lFuYx1gNgR+SLp74nLgl6RbWs0AUPptxz9IdxF9p8Ph2Fpw85GZmRV8pmBmZoUB12nZiBEjYuzYsZ0Ow8xsQLn++uuXRcTIduUGXFIYO3Ysc+fO7XQYZmYDiqS725dy85GZmZU4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRVqSwqSTpf0oKS/tpgvSadIWqT0SL3d6orFzMyqqfNM4QxS18itHAiMy69jSN0Fm5lZB9WWFCLiD8DD3RQ5BDgrP1P4GmC4pP7wKD4zs+etTl5TGMXqz/NdkqetQdIxkuZKmrt06dJeD2TJ8X/s9TqrmjZtWk0VD2tfpgfGHn/JauOnHnt5j99Th4U77sS33/u2lvNr275U2wYd1cvfAavfLmfu0ukQBsaF5oiYERETImLCyJFtu+4wM7O11MmkcA+rP/h9dJ5mZmYd0smkMBN4f74L6XXAoxFxXwfjMTN73qutl1RJ5wATgRGSlpAeYL0BQET8AJgFHER6uPjjwAfqisXMzKqpLSlExJQ28wP4cF3LNzOznhsQF5rNzKxvOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZgUnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZoVak4KkSZJulbRI0vFN5r9U0hWSbpR0k6SD6ozHzMy6V1tSkDQYOBU4EBgPTJE0vqHYF4DzI+LVwGTg+3XFY2Zm7dV5prAHsCgi7oiIlcC5wCENZQLYNA8PA+6tMR4zM2ujzqQwClhcGl+Sp5VNAw6XtASYBXykWUWSjpE0V9LcpUuX1hGrmZnR+QvNU4AzImI0cBBwtqQ1YoqIGRExISImjBw5ss+DNDN7vqgzKdwDjCmNj87Tyo4EzgeIiKuBocCIGmMyM7Nu1JkU5gDjJG0raUPSheSZDWX+DuwHIGknUlJw+5CZWYfUlhQi4hngOOBSYCHpLqMFkqZLOjgX+yRwtKR5wDnA1IiIumIyM7PuDamz8oiYRbqAXJ52Qmn4ZmDvOmMwM7PqOn2h2czM+hEnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZgUnBTMzKzgpmJlZoVJSkLRL3YGYmVnnVT1T+L6k6yR9SNKwWiMyM7OOqZQUImIf4DBgDHC9pJ9JenOtkZmZWZ+rfE0hIm4DvgB8BngDcIqkWyT9S13BmZlZ36p6TeGVkk4GFgJvAt4eETvl4ZNrjM/MzPpQ1TOF/wZuAHaNiA9HxA0AEXEv6eyhKUmTJN0qaZGk41uUOVTSzZIWSPpZT1fAzMx6z5CK5d4KPBERzwJIGgQMjYjHI+LsZm+QNBg4FXgzsASYI2lmRNxcKjMO+Cywd0Q8Iukl67AuZma2jqqeKVwGbFQaf2Ge1p09gEURcUdErATOBQ5pKHM0cGpEPAIQEQ9WjMfMzGpQNSkMjYgVXSN5+IVt3jMKWFwaX5Knlb0ceLmkP0u6RtKkivGYmVkNqiaFf0rarWtE0muAJ3ph+UOAccBEYArwI0nDGwtJOkbSXElzly5d2guLNTOzZqpeU/gYcIGkewEBWwLvbfOee0i/a+gyOk8rWwJcGxFPA3dK+hspScwpF4qIGcAMgAkTJkTFmM3MrIcqJYWImCNpR2CHPOnWvCPvzhxgnKRtSclgMvCvDWV+QTpD+F9JI0jNSXdUDd7MzHpX1TMFgN2Bsfk9u0kiIs5qVTginpF0HHApMBg4PSIWSJoOzI2ImXneAZJuBp4FPhURD63lupiZ2TqqlBQknQ28DPgLaecNEEDLpAAQEbOAWQ3TTigNB/CJ/DIzsw6reqYwARifd+JmZraeqnr30V9JF5fNzGw9VvVMYQRws6TrgKe6JkbEwbVEZWZmHVE1KUyrMwgzM+sfqt6SOlvSNsC4iLhM0gtJdxSZmdl6pGrX2UcDFwI/zJNGkX5jYGZm65GqF5o/DOwNLIfigTvu0dTMbD1TNSk8lXs6BUDSENLvFMzMbD1SNSnMlvQ5YKP8bOYLgF/VF5aZmXVC1aRwPLAUmA/8O+lXyi2fuGZmZgNT1buPVgE/yi8zM1tPVe376E6aXEOIiO16PSIzM+uYnvR91GUo8B7gxb0fjpmZdVKlawoR8VDpdU9EfAd4a82xmZlZH6vafLRbaXQQ6cyhJ89iMDOzAaDqjv3bpeFngLuAQ3s9GjMz66iqdx+9se5AzMys86o2H3X7ZLSIOKl3wjEzs07qyd1HuwMz8/jbgeuA2+oIyszMOqNqUhgN7BYRjwFImgZcEhGH1xWYmZn1vardXGwBrCyNr8zTzMxsPVL1TOEs4DpJF+fxdwBn1hOSmZl1StW7j74q6dfAPnnSByLixvrCMjOzTqjafATwQmB5RHwXWCJp25piMjOzDqn6OM4vAp8BPpsnbQD8pK6gzMysM6qeKbwTOBj4J0BE3AtsUldQZmbWGVWTwsqICHL32ZJeVF9IZmbWKVWTwvmSfggMl3Q0cBl+4I6Z2Xqn6t1H/5Wfzbwc2AE4ISJ+V2tkZmbW59omBUmDgctyp3hOBGZm67G2zUcR8SywStKwPojHzMw6qOovmlcA8yX9jnwHEkBE/EctUZmZWUdUTQo/zy8zM1uPdZsUJL00Iv4eEWvVz5GkScB3gcHAaRHxjRbl3gVcCOweEXPXZllmZrbu2l1T+EXXgKSLelJxvkB9KnAgMB6YIml8k3KbAB8Fru1J/WZm1vvaJQWVhrfrYd17AIsi4o6IWAmcCxzSpNyXgW8CT/awfjMz62XtkkK0GK5iFLC4NL4kTytI2g0YExGXdFeRpGMkzZU0d+nSpT0Mw8zMqmp3oXlXSctJZwwb5WHyeETEpmu7YEmDgJOAqe3KRsQMYAbAhAkTepqczMysom6TQkQMXoe67wHGlMZH52ldNgFeAVwpCWBLYKakg32x2cysM3ryPIWemgOMk7StpA2BycDMrpkR8WhEjIiIsRExFrgGcEIwM+ug2pJCRDwDHAdcCiwEzo+IBZKmSzq4ruWamdnaq/rjtbUSEbOAWQ3TTmhRdmKdsZiZWXt1Nh+ZmdkA46RgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZgUnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRVqTQqSJkm6VdIiScc3mf8JSTdLuknS7yVtU2c8ZmbWvdqSgqTBwKnAgcB4YIqk8Q3FbgQmRMQrgQuBb9UVj5mZtVfnmcIewKKIuCMiVgLnAoeUC0TEFRHxeB69BhhdYzxmZtZGnUlhFLC4NL4kT2vlSODXzWZIOkbSXElzly5d2oshmplZWb+40CzpcGACcGKz+RExIyImRMSEkSNH9m1wZmbPI0NqrPseYExpfHSethpJ+wOfB94QEU/VGI+ZmbVR55nCHGCcpG0lbQhMBmaWC0h6NfBD4OCIeLDGWMzMrILakkJEPAMcB1wKLATOj4gFkqZLOjgXOxHYGLhA0l8kzWxRnZmZ9YE6m4+IiFnArIZpJ5SG969z+WZm1jP94kKzmZn1D04KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzApOCmZmVnBSMDOzgpOCmZkVnBTMzKzgpGBmZgUnBTMzKzgpmJlZwUnBzMwKTgpmZlZwUjAzs4KTgpmZFZwUzMys4KRgZmYFJwUzMys4KZiZWcFJwczMCk4KZmZWcFIwM7OCk4KZmRWcFMzMrOCkYGZmBScFMzMrOCmYmVnBScHMzAq1JgVJkyTdKmmRpOObzH+BpPPy/Gslja0zHjMz615tSUHSYOBU4EBgPDBF0viGYkcCj0TE9sDJwDfrisfMzNqr80xhD2BRRNwRESuBc4FDGsocApyZhy8E9pOkGmMyM7NuKCLqqVh6NzApIo7K4+8DXhsRx5XK/DWXWZLHb89lljXUdQxwTB7dAbi1xWJHAMtazOvPBmrcMHBjd9x9y3H3rWZxbxMRI9u9cUg98fSuiJgBzGhXTtLciJjQByH1qoEaNwzc2B1333LcfWtd4q6z+egeYExpfHSe1rSMpCHAMOChGmMyM7Nu1JkU5gDjJG0raUNgMjCzocxM4Ig8/G7g8qirPcvMzNqqrfkoIp6RdBxwKTAYOD0iFkiaDsyNiJnAj4GzJS0CHiYljnXRtompnxqoccPAjd1x9y3H3bfWOu7aLjSbmdnA4180m5lZwUnBzMwKAzopSHqPpAWSVklqefuVpLskzZf0F0lz+zLGFvFUjbvbbkI6QdKLJf1O0m3572Ytyj2bt/dfJDXeYNAnBmo3KxXinippaWn7HtWJOBtJOl3Sg/n3R83mS9Ipeb1ukrRbX8fYTIW4J0p6tLS9T+jrGJuRNEbSFZJuzvuTjzYp0/NtHhED9gXsRPox25XAhG7K3QWM6HS8PYmbdHH+dmA7YENgHjC+H8T+LeD4PHw88M0W5VZ0OM622w/4EPCDPDwZOK8fbN8qcU8FvtfpWJvEvi+wG/DXFvMPAn4NCHgdcG2nY64Y90Tg/zodZ5O4tgJ2y8ObAH9r8l3p8TYf0GcKEbEwIlr9urnfqhh3lW5COqHcNcmZwDs6GEt3Bmo3K/31c28rIv5AuouwlUOAsyK5Bhguaau+ia61CnH3SxFxX0TckIcfAxYCoxqK9XibD+ik0AMB/FbS9bnLjIFgFLC4NL6ENT/wTtgiIu7Lw/cDW7QoN1TSXEnXSOpE4qiy/YoyEfEM8CiweZ9E11rVz/1duTngQkljmszvj/rrd7qKPSXNk/RrSTt3OphGuenz1cC1DbN6vM37fTcXki4Dtmwy6/MR8cuK1bw+Iu6R9BLgd5JuyUcHtemluDuiu9jLIxERklrd07xN3ubbAZdLmh8Rt/d2rM9TvwLOiYinJP076WznTR2OaX12A+n7vELSQcAvgHEdjqkgaWPgIuBjEbF8Xevr90khIvbvhTruyX8flHQx6RS91qTQC3FX6SakFt3FLukBSVtFxH35NPTBFnV0bfM7JF1JOorpy6TQk25WlvSjblbaxh0R5RhPI13nGQg69p1eF+UdbUTMkvR9SSOioePOTpC0ASkh/DQift6kSI+3+XrffCTpRZI26RoGDgCa3mXQz1TpJqQTyl2THAGscdYjaTNJL8jDI4C9gZv7LMJkoHaz0jbuhjbhg0ltyQPBTOD9+Y6Y1wGPlpoi+y1JW3Zda5K0B2m/2emDB3JMPwYWRsRJLYr1fJt3+gr6Ol59fyepjewp4AHg0jx9a2BWHt6OdAfHPGABqfmm38cdz9058DfSEXbH484xbQ78HrgNuAx4cZ4+ATgtD+8FzM/bfD5wZIdiXWP7AdOBg/PwUOACYBFwHbBdp7dvxbi/nr/L84ArgB07HXOO6xzgPuDp/P0+EjgWODbPF+nBW7fn70XLOwb7WdzHlbb3NcBenY45x/V60vXSm4C/5NdB67rN3c2FmZkV1vvmIzMzq85JwczMCk4KZmZWcFIwM7OCk4KZmRWcFGxAk3SypI+Vxi+VdFpp/NuSPtGmjqsqLOeu/JuLxukTJe3V07hbLGOqpO/1Rl1ma8tJwQa6P5N+F4GkQcAIoNw3zV5Atzv9iFiXnfrEruWbrQ+cFGyguwrYMw/vTPq1+mOlX1XvROq7BkmfkjQndyT3pa4KJK3IfwflLgxuUXpWxCxJ7y4t6yOSblB6NseOuROyY4GP53729ynVOSifXQwvTbtN0haS3q70/IYbJV0maY1OBSWdUV52V4yt1iP/cv+S3GnbXyW9d623qD2vOSnYgBYR9wLPSHop6Yj9alJPkXuSfmU9PyJWSjqA1InZHsCrgNdI2rehun8BxgLjgffxXLLpsiwidgP+B/h/EXEX8APg5Ih4VUT8sRTXKlIXIO8EkPRa4O6IeAD4E/C6iHg1qWvsT1dd327WYxJwb0TsGhGvAH5TtU6zMicFWx9cRUoIXUnh6tL4n3OZA/LrRtKZw46s2dPl64ELImJVRNxP6kKirKvDsetJyaOd84CuI/bJeRxSp2SXSpoPfIrVm7vaabUe84E3S/qmpH0i4tEe1GlW6Pe9pJpV0HVdYRdS89Fi4JPAcuB/cxkBX4+IH67Dcp7Kf5+l2v/O1cD2kkaSHkb0lTz9v4GTImKmpInAtCbvfYZ80JavlWyYp7dcD6VHLR4EfEXS7yNiepWVMivzmYKtD64C3gY8HBHPRsTDwHBS80/XReZLgX/Lfc8jaVR+vkbZn0kPrxmU2/knVlj2Y6RHIa4hUsdiFwMnkXqy7OpZcxjPdV98RLP3kh4h+5o8fDCwQXfrIWlr4PGI+AlwIunxkmY95jMFWx/MJ9119LOGaRtH7vM+In4raSfg6twL8grgcFZ/HsRFwH6kbr4Xk5pn2jXD/Aq4UNIhwEfK1xWy80jdYU8tTZsGXCDpEeByYNsm9f4I+KWkeaTrA/9ssx7bAydKWkXq7fODbeI2a8q9pJqVSNo40hO2Nid1p713vr5g9rzgMwWz1f1fvo10Q+DLTgj2fOMzBTMzK/hCs5mZFZwUzMys4KRgZmYFJwUzMys4KZiZWeH/Ax3L1pYI4EiwAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi40LCBodHRwOi8vbWF0cGxvdGxpYi5vcmcv7US4rQAAHYJJREFUeJzt3Xm4HGWd9vHvnYRNdklkSSIBjEDYFAIqvEhUxIAa3AdGFBwgMorj9qK4MSHuoiA4oAZkWFR20fASRdnCiCwJIISwDBGBhDUBJESWEPi9fzzPqVQ63afrJKdO55zcn+vq69TWVb+u7q676qk61YoIzMzMAAZ1ugAzM1t1OBTMzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzgUFhFSPqopD+u4HNnSxrXyyWt8iT9XtKhq+ryJZ0l6VsV5zVKUkga0nsV1qs/1mztORRWgKQHJO3bm/OMiF9FxH4Vlr3chiYidoiIa3uyvNIXelF+PCDp2B6W3VERsX9EnL0qLF/SYZL+3FvzlvRDSfdJelbSPZI+3lvzroukayUd0Yvz20DSjyU9lD+jf8v9Q3trGXk5UyTdK+kVSYe1mXYtSWdKWijpMUlfaBj/jvx+PSfpGklb9matfcGhYBtFxHrAh4BvSHpnby/Ae5Ir5J/Ae4ENgUOBkyXt2dmS+o6kNYGrgB2A8cAGwFuAJ4E9enlxtwOfAm6tMO0kYDSwJfA24EuSxueahwK/Ab4BvBqYCVzQy7XWLyL86OEDeADYt8W4I4E5wFPAVGCL0rj9gHuBZ4DTgOnAEXncYcCfc7eAk4AngIXALGBHYCLwErAYWARc1lgPMBj4KvA34FngFmBkkzpHAQEMKQ27GTim1L8FcAkwH/g78B+lcesAZwNPA3cDXwLmNayjLwN3AC8CQ9rMbw/Sl2gh8DhwYh6+NvBL0sbgH8AMYNM87trS+hsEfB14MK+3c4ANG17rocBDwALgay3ev63ycgbl/tOBJ0rjzwU+V14+sD3wAvByfl/+kcefBZwKXJ7fi5uAbVosd7n3o2H8VOCLLcaNA+bl931BXvcfLY1fC/hhfu2PAz8D1ml47hfzensU+ETpue8Gbsvvy1xgUrOagW/n1/9CXgf/lV/7j5q8js9X+I4dkWtdrw+/138GDmszzSPAfqX+bwLn5+6JwF9K49YFnge266vX0CvrodMF9McHLUIBeHv+Uu6av4g/Aa7L44bmL9YH8pfos6QNfLNQeBdpY74RKSC2BzbP484CvtWqHuAYUohsm5+7C7BJk1qX2QgBbwaeA96f+wflGo4D1gS2Bu4H3pXHf48UahsDI0gb/8ZQ+CswkhQg7eZ3A/Cx3L0e8Obc/UngMuBVpMDbDdggj7u2tP7+jRTGW+fn/wY4t+G1np5r2YUUVNu3eH8fAnbL3ffmOrcvjXtjk+UX719pPmexdM92CPAr8gak3fvRMG4d0sZ6fIvnjgOWACeSPnf7kI40ts3jTyJtjF8NrJ/X53cbnjsZWAM4IH8ONi6N3ym/fzuTNtTva/EZKtZH7t+DtBHtCtihed6bVviOnQ+c3cPv5R2kQG/2OK3C87sNBdJnPcr1k46wZ+Xuk4GfNjznTuCDfb2NWpmHm49610eBMyPi1oh4EfgK8BZJo0hfttkR8ZuIWAKcAjzWYj4vkb682wGKiLsj4tGKNRwBfD0i7o3k9oh4spvpF0h6nrRRPg34bR6+OzAsIiZHxOKIuJ+0UT0oj/8I8J2IeDoi5uXX0+iUiJgbEc9XmN9LwOskDY2IRRFxY2n4JsDrIuLliLglIhY2WdZHSUcX90fEItK6P6ih6er4iHg+Im4nNRns0mKdTAf2kbRZ7r84929Fasa4vcXzmrk0Im7O7/mvgDf04LldfpaXeUWb6b4RES9GxHTS0clHJIm0B/v5iHgqIp4FvsPS9Q5pHU+OiJciYhppT39bgIi4NiJmRcQrEXEHcB4pdNqKiJtJR8XvyIMOAq6NiMcrPH0TUhBWFhE7R8RGLR6f6sm8Wlgv/32mNOwZ0ne1a/wzLKs8vl9wKPSuLUjNFwDkjdOTwPA8bm5pXJAO25cTEVez9PD7iXwibIOKNYwkNR1VNZT0Yf4iaa9wjTx8S2ALSf/oepCaJzbN45d5PQ3dzYa1m9/hwOuBeyTNkPSePPxc0sbwfEmPSPqBpDVY3jLrPncPKc0flg3h51j6JW80nbQu3gpcR9oD3ic//iciXmnxvGaqLrMpSSeQmg4/kj8zrTwdEf8s9T9IWifDSEdZt5TW+x/y8C5P5tBark5Jb8onTOdLegY4ivSZqeps4JDcfQjp/aziSWDzHiynLyzKf8vfxQ1ITYNd4xu/p+Xx/YJDoXc9Qtr4ASBpXdIez8OkvZ4RpXEq9zeKiFMiYjdgDGljeUzXqDY1zAW26UnReQ/8RFJ7cNce1Vzg7w17W+tHxAF5/DKvhxRGy826oa6W84uI+yLiYOA1wPeBiyWtm/dej4+IMcCewHuAZlfiLLPugdeSmkWq7JU2mg7sTQqG6aRmhb1IoTC9xXN6/XbDko4H9ie1YTc7OirbOH/euryWtE4WkNq1dyit9w0jXVxQxa9JTU8jI2JD0lGLWkzbbB38EjhQ0i6kZtDfNpmmmSuBdzW8pm7lS7MXtXj8rOp8WomIp0mf+/IR5i7A7Nw9uzwu175NaXy/4FBYcWtIWrv0GEI6tP6EpDdIWot0mH5TRDxAOpzfSdL78rSfBjZrNmNJu+c9tDVIbcMvAF17p4+T2s1bOQP4pqTRSnaWtEnF1/Q90tUUa5NOOj8r6cuS1pE0WNKOknbP014IfEXSxpKGA0e3mXe385N0iKRheS/8H/k5r0h6m6SdJA0mnZN5qbQuys4DPi9pK0nrkdb9BQ17wJVExH2kDekhwPS8QX4c+CCtQ+FxYES+amalSfoK8K+kc0XdNf+VHS9pTUl7k8Lzorw+TwdOkvSaPO/hkt5VcZ7rA09FxAuS9sg1tbLcZzM3Lc4gHSFckpsSyXWcJemsFvM6l7QjcYmk7SQNkrSJpK9KOqDZEyJdmr1ei8dRrYrO62xtUth1fa9bbRvPAb6eP/fbkS4s6XoNlwI7Svpgnt9xwB0RcU+rZa+KHAorbhppw9H1mBQRV5IuR7uEtEexDbntNiIWAB8GfkA6NB5DutrmxSbz3oD0RX6a1AzwJHBCHvcLYExuCmi213UiaYP9R9JG9BekE5VVXJ6XeWREvEzasLyBdKXQAlLgbJinnUxq/vo7aa/u4havBUhHI23mNx6YLWkR6YTdQXkDslme90LSVU7Tad4EcWYefl2e/wvAZyq+7mamk5pV5pb6RevLFq8m7RE+JmnBSiy3y3dIe/tzSnu7X+1m+sdI790jpHMXR5U2Rl8mnYS/UdJC0vu1bcU6PgVMlvQsaSN3YTfTngx8SNLTksrnmM4mnaxufN9GAtc3m1E+J7cvcA/wJ9L7fzOp6eqmirVX9UfSd3hPYErufisU/1Ra3tP/T1Lz7IOkz8QJEfGHXPN80o7Dt0nvxZtY9txNv6DumymtLnlPZB7p0sFrOl3PypL076QNeaWTkNZ7lP6b/ZcR0bI5spMkvZXUjLRl13mRfER1O7BzRLzUyfpsWT5S6EOS3iVpo9y09FXSnueNbZ62SpK0uaS98mH9tqQT1Zd2ui5bteQm0M8CZ5RPlOcr0LZ3IKx6HAp96y2kQ88FpP9WfV+5jbWfWRP4OenKiquB35EuaTUDQNL2pPNDmwM/7nA5VpGbj8zMrOAjBTMzK/S7G5UNHTo0Ro0a1ekyzMz6lVtuuWVBRAxrN12/C4VRo0Yxc+bMTpdhZtavSHqw/VRuPjIzsxKHgpmZFRwKZmZWcCiYmVnBoWBmZgWHgpmZFWoLBUlnSnpC0p0txkvSKZLmSLpD0q511WJmZtXUeaRwFul2yK3sD4zOj4nAT2usxczMKqgtFCLiOuCpbiY5EDgnkhuBjSStaj+/Z2a2WunkOYXhLPsbvvPysOVImihppqSZ8+fPX+EFjjr28hV+bidsds1fO11CS6cedXWnS1ghkyZNWul5XHV1j37tdLW009k7dbqEfmlVWG/94kRzREyJiLERMXbYsLa37jAzsxXUyVB4mGV/7H1EHmZmZh3SyVCYCnw8X4X0ZuCZiHi0g/WYma32artLqqTzgHHAUEnzSD94vQZARPyM9MP3B5B+UPw54BN11WJmZtXUFgoRcXCb8QF8uq7lm5lZz/WLE81mZtY3HApmZlZwKJiZWcGhYGZmBYeCmZkVHApmZlZwKJiZWcGhYGZmBYeCmZkVHApmZlZwKJiZWcGhYGZmBYeCmZkVHApmZlZwKJiZWcGhYGZmBYeCmZkVHApmZlZwKJiZWcGhYGZmBYeCmZkVHApmZlZwKJiZWcGhYGZmBYeCmZkVHApmZlZwKJiZWcGhYGZmBYeCmZkVHApmZlZwKJiZWcGhYGZmhVpDQdJ4SfdKmiPp2CbjXyvpGkm3SbpD0gF11mNmZt2rLRQkDQZOBfYHxgAHSxrTMNnXgQsj4o3AQcBpddVjZmbt1XmksAcwJyLuj4jFwPnAgQ3TBLBB7t4QeKTGeszMrI06Q2E4MLfUPy8PK5sEHCJpHjAN+EyzGUmaKGmmpJnz58+vo1YzM6PzJ5oPBs6KiBHAAcC5kparKSKmRMTYiBg7bNiwPi/SzGx1UWcoPAyMLPWPyMPKDgcuBIiIG4C1gaE11mRmZt2oMxRmAKMlbSVpTdKJ5KkN0zwEvANA0vakUHD7kJlZh9QWChGxBDgauAK4m3SV0WxJkyVNyJN9EThS0u3AecBhERF11WRmZt0bUufMI2Ia6QRyedhxpe67gL3qrMHMzKrr9IlmMzNbhTgUzMys4FAwM7OCQ8HMzAoOBTMzKzgUzMys4FAwM7OCQ8HMzAoOBTMzKzgUzMys4FAwM7OCQ8HMzAoOBTMzKzgUzMys4FAwM7OCQ8HMzAoOBTMzKzgUzMys4FAwM7OCQ8HMzAoOBTMzKzgUzMys4FAwM7OCQ8HMzAoOBTMzKzgUzMys4FAwM7NCpVCQtFPdhZiZWedVPVI4TdLNkj4lacNaKzIzs46pFAoRsTfwUWAkcIukX0t6Z62VmZlZn6t8TiEi7gO+DnwZ2Ac4RdI9kj5QV3FmZta3qp5T2FnSScDdwNuB90bE9rn7pBrrMzOzPlT1SOEnwK3ALhHx6Yi4FSAiHiEdPTQlabykeyXNkXRsi2k+IukuSbMl/bqnL8DMzHrPkIrTvRt4PiJeBpA0CFg7Ip6LiHObPUHSYOBU4J3APGCGpKkRcVdpmtHAV4C9IuJpSa9ZiddiZmYrqeqRwpXAOqX+V+Vh3dkDmBMR90fEYuB84MCGaY4ETo2IpwEi4omK9ZiZWQ2qhsLaEbGoqyd3v6rNc4YDc0v98/KwstcDr5d0vaQbJY2vWI+ZmdWgaij8U9KuXT2SdgOe74XlDwFGA+OAg4HTJW3UOJGkiZJmSpo5f/78XlismZk1U/WcwueAiyQ9AgjYDPiXNs95mPR/DV1G5GFl84CbIuIl4O+S/pcUEjPKE0XEFGAKwNixY6NizWZm1kOVQiEiZkjaDtg2D7o3b8i7MwMYLWkrUhgcBPxrwzS/JR0h/LekoaTmpPurFm9mZr2r6pECwO7AqPycXSUREee0mjgilkg6GrgCGAycGRGzJU0GZkbE1DxuP0l3AS8Dx0TEkyv4WszMbCVVCgVJ5wLbAH8lbbwBAmgZCgARMQ2Y1jDsuFJ3AF/IDzMz67CqRwpjgTF5I25mZgNU1auP7iSdXDYzswGs6pHCUOAuSTcDL3YNjIgJtVRlZmYdUTUUJtVZhJmZrRqqXpI6XdKWwOiIuFLSq0hXFJmZ2QBS9dbZRwIXAz/Pg4aT/sfAzMwGkKonmj8N7AUshOIHd3xHUzOzAaZqKLyY73QKgKQhpP9TMDOzAaRqKEyX9FVgnfzbzBcBl9VXlpmZdULVUDgWmA/MAj5J+i/llr+4ZmZm/VPVq49eAU7PDzMzG6Cq3vvo7zQ5hxARW/d6RWZm1jE9ufdRl7WBDwOv7v1yzMyskyqdU4iIJ0uPhyPix8C7a67NzMz6WNXmo11LvYNIRw49+S0GMzPrB6pu2H9U6l4CPAB8pNerMTOzjqp69dHb6i7EzMw6r2rzUbe/jBYRJ/ZOOWZm1kk9ufpod2Bq7n8vcDNwXx1FmZlZZ1QNhRHArhHxLICkScDlEXFIXYWZmVnfq3qbi02BxaX+xXmYmZkNIFWPFM4BbpZ0ae5/H3B2PSWZmVmnVL366NuSfg/snQd9IiJuq68sMzPrhKrNRwCvAhZGxMnAPElb1VSTmZl1SNWf4/xP4MvAV/KgNYBf1lWUmZl1RtUjhfcDE4B/AkTEI8D6dRVlZmadUTUUFkdEkG+fLWnd+koyM7NOqRoKF0r6ObCRpCOBK/EP7piZDThVrz76Yf5t5oXAtsBxEfGnWiszM7M+1zYUJA0Grsw3xXMQmJkNYG2bjyLiZeAVSRv2QT1mZtZBVf+jeREwS9KfyFcgAUTEf9RSlZmZdUTVUPhNfpiZ2QDWbShIem1EPBQRK3SfI0njgZOBwcAZEfG9FtN9ELgY2D0iZq7IsszMbOW1O6fw264OSZf0ZMb5BPWpwP7AGOBgSWOaTLc+8Fngpp7M38zMel+7UFCpe+seznsPYE5E3B8Ri4HzgQObTPdN4PvACz2cv5mZ9bJ2oRAtuqsYDswt9c/LwwqSdgVGRsTl3c1I0kRJMyXNnD9/fg/LMDOzqtqdaN5F0kLSEcM6uZvcHxGxwYouWNIg4ETgsHbTRsQUYArA2LFjexpOZmZWUbehEBGDV2LeDwMjS/0j8rAu6wM7AtdKAtgMmCppgk82m5l1Rk9+T6GnZgCjJW0laU3gIGBq18iIeCYihkbEqIgYBdwIOBDMzDqotlCIiCXA0cAVwN3AhRExW9JkSRPqWq6Zma24qv+8tkIiYhowrWHYcS2mHVdnLWZm1l6dzUdmZtbPOBTMzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzgUDAzs4JDwczMCrWGgqTxku6VNEfSsU3Gf0HSXZLukHSVpC3rrMfMzLpXWyhIGgycCuwPjAEOljSmYbLbgLERsTNwMfCDuuoxM7P26jxS2AOYExH3R8Ri4HzgwPIEEXFNRDyXe28ERtRYj5mZtVFnKAwH5pb65+VhrRwO/L7ZCEkTJc2UNHP+/Pm9WKKZmZWtEieaJR0CjAVOaDY+IqZExNiIGDts2LC+Lc7MbDUypMZ5PwyMLPWPyMOWIWlf4GvAPhHxYo31mJlZG3UeKcwARkvaStKawEHA1PIEkt4I/ByYEBFP1FiLmZlVUFsoRMQS4GjgCuBu4MKImC1psqQJebITgPWAiyT9VdLUFrMzM7M+UGfzERExDZjWMOy4Uve+dS7fzMx6ZpU40WxmZqsGh4KZmRUcCmZmVnAomJlZwaFgZmYFh4KZmRUcCmZmVnAomJlZwaFgZmYFh4KZmRUcCmZmVnAomJlZwaFgZmYFh4KZmRUcCmZmVnAomJlZwaFgZmYFh4KZmRUcCmZmVnAomJlZwaFgZmYFh4KZmRUcCmZmVnAomJlZwaFgZmYFh4KZmRUcCmZmVnAomJlZwaFgZmYFh4KZmRUcCmZmVnAomJlZwaFgZmaFWkNB0nhJ90qaI+nYJuPXknRBHn+TpFF11mNmZt2rLRQkDQZOBfYHxgAHSxrTMNnhwNMR8TrgJOD7ddVjZmbt1XmksAcwJyLuj4jFwPnAgQ3THAicnbsvBt4hSTXWZGZm3VBE1DNj6UPA+Ig4Ivd/DHhTRBxdmubOPM283P+3PM2ChnlNBCbm3m2Be3tQylBgQdupVg9eF0t5XSzL62OpgboutoyIYe0mGtIXlaysiJgCTFmR50qaGRFje7mkfsnrYimvi2V5fSy1uq+LOpuPHgZGlvpH5GFNp5E0BNgQeLLGmszMrBt1hsIMYLSkrSStCRwETG2YZipwaO7+EHB11NWeZWZmbdXWfBQRSyQdDVwBDAbOjIjZkiYDMyNiKvAL4FxJc4CnSMHR21ao2WmA8rpYyutiWV4fS63W66K2E81mZtb/+D+azcys4FAwM7PCgAsFSR+WNFvSK5JaXlbW7hYcA4GkV0v6k6T78t+NW0z3sqS/5kfjxQD9mm+1slSFdXGYpPmlz8IRnaizL0g6U9IT+X+lmo2XpFPyurpD0q59XWOnDLhQAO4EPgBc12qCirfgGAiOBa6KiNHAVbm/mecj4g35MaHvyquXb7WyVA8+8xeUPgtn9GmRfessYHw34/cHRufHROCnfVDTKmHAhUJE3B0R7f7jucotOAaC8m1Ezgbe18FaOsG3WllqdfnMVxIR15GueGzlQOCcSG4ENpK0ed9U11kDLhQqGg7MLfXPy8MGmk0j4tHc/RiwaYvp1pY0U9KNkgZScFR5n4tpImIJ8AywSZ9U17eqfuY/mJtLLpY0ssn41cXqso1YTr+4zUUjSVcCmzUZ9bWI+F1f19NJ3a2Lck9EhKRW1x9vGREPS9oauFrSrIj4W2/Xaqu8y4DzIuJFSZ8kHUG9vcM1WR/rl6EQEfuu5Cyq3IKjX+huXUh6XNLmEfFoPvR9osU8Hs5/75d0LfBGYCCEQk9utTJvgN9qpe26iIjy6z4D+EEf1LWqGjDbiJ5aXZuPqtyCYyAo30bkUGC5oyhJG0taK3cPBfYC7uqzCuvlW60s1XZdNLSZTwDu7sP6VjVTgY/nq5DeDDxTaood2CJiQD2A95Pa/14EHgeuyMO3AKaVpjsA+F/SHvHXOl13TetiE9JVR/cBVwKvzsPHAmfk7j2BWcDt+e/hna67l9fBcu8zMBmYkLvXBi4C5gA3A1t3uuYOrovvArPzZ+EaYLtO11zjujgPeBR4KW8vDgeOAo7K40W6Wutv+XsxttM199XDt7kwM7PC6tp8ZGZmTTgUzMys4FAwM7OCQ8HMzAoOBTMzKzgUrF+TdJKkz5X6r5B0Rqn/R5K+0GYef6mwnAfy/3E0Dh8nac+e1t1iGYdJ+q/emJfZinIoWH93Pel/LZA0CBgK7FAavyfQ7UY/IlZmoz6ua/lmA4FDwfq7vwBvyd07kG6d/mzpP7W3B24FkHSMpBn5hm/Hd81A0qL8d5Ck0yTdk39/YpqkD5WW9RlJt0qaJWm7/NsLRwGfz78/sHdpnoPy0cVGpWH3SdpU0nvzbzfcJulKScvdqFDSWeVld9XY6nVIWlfS5ZJul3SnpH9Z4TVqqzWHgvVrEfEIsETSa0l77DcAN5GCYiwwKyIWS9qPdG/8PYA3ALtJemvD7D4AjCL93sDHWBo2XRZExK6ke+v/34h4APgZcFKk3x/4n1Jdr5BuK/J+AElvAh6MiMeBPwNvjog3km5h/aWqr7eb1zEeeCQidomIHYE/VJ2nWZlDwQaCv5ACoSsUbij1X5+n2S8/biMdOWxH2riW/R/gooh4JSIeI93qoew3+e8tpPBo5wKga4/9oNwP6eZqV0iaBRzDss1d7bR6HbOAd0r6vqS9I+KZHszTrNAv75Jq1qDrvMJOpOajucAXgYXAf+dpBHw3In6+Est5Mf99mWrfnRuA10kaRvqBo2/l4T8BToyIqZLGAZOaPHcJeactnytZMw9v+TryT0YeAHxL0lURMbnKizIr85GCDQR/Ad4DPBURL0fEU8BGpOafrpPMVwD/Jmk9AEnDJb2mYT7Xk35kZlBu5x9XYdnPAus3GxHpxmKXAicCd8fSW1NvyNLbMB/a7LnAA8BuuXsCsEZ3r0PSFsBzEfFL4ARgtflNYetdPlKwgWAW6aqjXzcMWy8iFgBExB8lbQ/ckH9tcxFwCMv+xsQlwDtItw6fS2qeadcMcxlwsaQDgc+UzytkF5BuW31Yadgk4CJJTwNXA1s1me/pwO8k3U46P/DPNq/jdcAJkl4h3fnz39vUbdaU75JqViJpvYhYJGkT0q2098rnF8xWCz5SMFvW/8uXka4JfNOBYKsbHymYmVnBJ5rNzKzgUDAzs4JDwczMCg4FMzMrOBTMzKzw/wEYBVDxnauedAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "num_C = 5\n", + "num_penalty = 2\n", + "index = 1\n", + "for p_i in range(num_penalty):\n", + " for c_i in range(num_C):\n", + " plt.hist(coefs[p_i][c_i], bins=30)\n", + " plt.title('Logistic Regression with %s penalty, C = %.2f' %(penalties[p_i], c_values[c_i]))\n", + " plt.xlabel('Weight values')\n", + " plt.ylabel('Frequency')\n", + " index += 1\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "you can think of the \"C\" parameter as a way of specifying the tradeoff between the L1/L2 penalty and the negative log likelihood of the model. \n", + "\n", + "A small value of \"C\" means that we are assigning greater weight to the L1/L2 penalty(equivalently downweighting the negative log likelihood).\n", + "\n", + "L1 regularization induces sparse models - this can be a very useful if you suspect your classification target variable can be explained by few features.\n", + "\n", + "* Sparsity refers to that only very few entries in a matrix (or vector) is non-zero. L1-norm has the property of producing many coefficients with zero values or very small values with few large coefficients." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Support Vector Machines" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ref: https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html#sklearn.svm.LinearSVC\n", + "The SVM Classifier also takes quite a few parameters. For now we will use Linear SVMs. The model is called LinearSVC in sklearn.\n", + "\n", + "We will be playing with following parameters:\n", + "* C: same as above\n", + "\n", + "SVM tries to find the hyperplane that maximizes the \"margin\" between the two classes of points. The \"C\" parameter in [SVC](http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC) has the same role as the \"C\" parameter in LogisticRegression: it tells you how much to penalize the \"size\" of the weight vector. Note that SVC only allows for L2 regularization.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Let's fit an SVM" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.51611687 -0.29820437 -0.51272115 -0.51611687 -0.35975434 -0.58490291\n", + " -0.74248609 -0.58490291 -0.51611687 -0.57761275]\n", + "the average of the confidence score is: -0.56\n" + ] + } + ], + "source": [ + "svm = LinearSVC(random_state=0, tol=1e-5)\n", + "svm.fit(x_train, y_train)\n", + "confidence_score = svm.decision_function(x_test)\n", + "print(confidence_score[:10])\n", + "print(\"the average of the confidence score is: %.2f\" % confidence_score.mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now predict scores on the test set and plot the distribution of scores\n", + "You might notice that the function you've been using to predict so far does not work. Is another function you need to use? Which one? Why?" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "The confidence score for a sample is the signed distance of that sample to the hyperplane.\n", + "\n", + "return:\n", + "array, shape=(n_samples,) if n_classes == 2 else (n_samples, n_classes)\n", + "\n", + "Confidence scores per (sample, class) combination. In the binary case, confidence score for self.classes_[1] where >0 means this class would be predicted." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### now we can select a threshold and calculate accuracy" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The true number of HBP is 541/2602 from the data, with percentage 20.79%\n", + "\n", + "(Threshold: -1), the total number of predicted HBP is 2598, the accuracy is 0.21\n", + "(Threshold: -0.9), the total number of predicted HBP is 2581, the accuracy is 0.22\n", + "(Threshold: -0.8), the total number of predicted HBP is 2460, the accuracy is 0.25\n", + "(Threshold: -0.7), the total number of predicted HBP is 2130, the accuracy is 0.34\n", + "(Threshold: -0.6), the total number of predicted HBP is 1638, the accuracy is 0.47\n", + "(Threshold: -0.5), the total number of predicted HBP is 631, the accuracy is 0.69\n", + "(Threshold: -0.4), the total number of predicted HBP is 393, the accuracy is 0.74\n", + "(Threshold: -0.3), the total number of predicted HBP is 291, the accuracy is 0.76\n", + "(Threshold: -0.2), the total number of predicted HBP is 26, the accuracy is 0.79\n", + "(Threshold: -0.1), the total number of predicted HBP is 0, the accuracy is 0.79\n", + "(Threshold: 0), the total number of predicted HBP is 0, the accuracy is 0.79\n" + ] + } + ], + "source": [ + "# code\n", + "print(\"The true number of HBP is {}/{} from the data, with percentage {:.2f}%\\n\".format(\n", + " sum(y_test), len(y_test), 100.*sum(y_test)/len(y_test)))\n", + "for threshold in [-1, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0] : # , -0.6, ]:\n", + " pred_label = [1 if x >threshold else 0 for x in confidence_score]\n", + " print(\"(Threshold: {}), the total number of predicted HBP is {}, the accuracy is {:.2f}\".format(\n", + " threshold, sum(pred_label), accuracy(pred_label,y_test)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "-0.4 is an ideal threshold." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Let's now vary values of C and see the results." + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(C: 0.01), the total number of predicted HBP is 113, the accuracy is 0.78\n", + "(C: 0.1), the total number of predicted HBP is 113, the accuracy is 0.78\n", + "(C: 1), the total number of predicted HBP is 113, the accuracy is 0.78\n", + "(C: 10), the total number of predicted HBP is 113, the accuracy is 0.78\n", + "(C: 100), the total number of predicted HBP is 113, the accuracy is 0.78\n" + ] + } + ], + "source": [ + "# code\n", + "threshold = -0.4\n", + "c_values = [10**-2, 10**-1, 1 , 10, 10**2]\n", + "for c_value in c_values:\n", + " svm = LinearSVC(random_state=0, tol=1e-5, C=c_value).fit(x_train, y_train)\n", + " confidence_score = lrf.decision_function(x_test)\n", + " pred_label = [1 if x > threshold else 0 for x in confidence_score]\n", + " print(\"(C: {}), the total number of predicted HBP is {}, the accuracy is {:.2f}\".format(\n", + " c_value, sum(pred_label), accuracy(pred_label, y_test)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Varing the value of C doesn't have much effect on accuracy for this dataset under the current setting of the model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluation Metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We covered several evaluation metrics in class:\n", + " - accuracy\n", + " - precision\n", + " - recall\n", + " - area under curve\n", + " - ROC curves\n", + " \n", + "Although sklearn has built-in functions to calculate these metrics,\n", + "in this lab we want to give you an understanding of these metrics \n", + "by writing functions to calculate them yourself.\n", + "\n", + "Remember that accuracy, precision, and recall are calculated at a specific threshold for turning scores into 0 and 1.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set Threshold\n" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "threshold = -0.4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### We will first create a confusion matrix based on this threshold" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "svm = LinearSVC(random_state=0, tol=1e-5).fit(x_train, y_train)\n", + "confidence_score = lrf.decision_function(x_test)\n", + "pred_label = [1 if x > threshold else 0 for x in confidence_score]\n", + "c = confusion_matrix(y_test, pred_label)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I create a confusion matrix for our SVM classifier." + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1987, 74, 502, 39)" + ] + }, + "execution_count": 141, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "true_negatives, false_positive, false_negatives, true_positives = c.ravel()\n", + "(true_negatives, false_positive, false_negatives, true_positives)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Let's now write functions that can calculate each metric" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def calculate_accuracy_at_threshold(predicted_scores, true_labels, threshold):\n", + " pred_label = [1 if x > threshold else 0 for x in predicted_scores]\n", + " true_negatives, false_positive, false_negatives, true_positives = confusion_matrix(y_test, pred_label).ravel()\n", + " return 1.0 * (true_positives + true_negatives) / (true_negatives + false_positive + false_negatives + true_positives)\n", + "\n", + "def calculate_precision_at_threshold(predicted_scores, true_labels, threshold):\n", + " pred_label = [1 if x > threshold else 0 for x in predicted_scores]\n", + " _, false_positive, _, true_positives = confusion_matrix(y_test, pred_label).ravel()\n", + " return 1.0 * true_positives / (false_positive + true_positives)\n", + "\n", + "def calculate_recall_at_threshold(predicted_scores, true_labels, threshold):\n", + " pred_label = [1 if x > threshold else 0 for x in predicted_scores]\n", + " _, _, false_negatives, true_positives = confusion_matrix(y_test, pred_label).ravel()\n", + " return 1.0 * true_positives / (false_negatives + true_positives)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Accuracy = TP+TN/TP+FP+FN+TN\n", + "\n", + "Precision = TP/TP+FP\n", + "\n", + "Recall = TP/TP+FN" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now let's calculate all of these for a logistic regression model you built above" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The accuracy is 0.75\n", + "The precision is 0.34\n", + "The recall is 0.23\n" + ] + } + ], + "source": [ + "threshold = 0.3\n", + "lrf = LogisticRegression(random_state=0, solver='liblinear').fit(x_train, y_train)\n", + "predicted_scores = lrf.predict_proba(x_test)\n", + "# print(predicted_scores)\n", + "# print(predicted_scores[:,1])\n", + "\n", + "print(\"The accuracy is %.2f\" % calculate_accuracy_at_threshold(predicted_scores[:,1], y_test, threshold))\n", + "print(\"The precision is %.2f\" % calculate_precision_at_threshold(predicted_scores[:,1], y_test, threshold))\n", + "print(\"The recall is %.2f\" % calculate_recall_at_threshold(predicted_scores[:,1], y_test, threshold))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now let's write a function that generates the precision, recall, k (% of population) graph that we covered in class\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def plot_precision_recall_k(predicted_scores, true_labels):\n", + " precision, recall, thresholds = precision_recall_curve(true_labels, predicted_scores)\n", + " plt.plot(recall, precision, marker='.')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### let's plot it for the same logistic regression model" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_precision_recall_k(predicted_scores[:,1], y_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Now we build the same graph for an svm model and compare the two. Which one is better?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "svm = LinearSVC(random_state=0, tol=1e-5).fit(x_train, y_train)\n", + "confidence_score = lrf.decision_function(x_test)\n", + "plot_precision_recall_k(predicted_scores[:,1], y_test)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}