please see attachment

{
“cells”: [
{
“cell_type”: “code”,
“execution_count”: 1,
“metadata”: {
“colab”: {},
“colab_type”: “code”,
“id”: “_mH0rAuvUju8”
},
“outputs”: [],
“source”: [
“# Import libraries:\n”,
“import numpy as np\n”,
“import pandas as pd\n”,
“import seaborn as sns # optional, but recommended\n”,
“import matplotlib.pyplot as plt \n”,
“from sklearn import datasets”
]
},
{
“cell_type”: “code”,
“execution_count”: 2,
“metadata”: {},
“outputs”: [],
“source”: [
“cancer = datasets.load_breast_cancer()”
]
},
{
“cell_type”: “code”,
“execution_count”: 0,
“metadata”: {
“colab”: {},
“colab_type”: “code”,
“id”: “fxzWh2YoU8Un”
},
“outputs”: [],
“source”: [
“# enter your code here”
]
}
],
“metadata”: {
“colab”: {
“name”: “hw0_template.ipynb”,
“provenance”: [],
“version”: “0.3.2”
},
“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.7.3”
}
},
“nbformat”: 4,
“nbformat_minor”: 1
}

CS Machine Learning

Homework 0 – Programming

Keywords: Jupyter, scikit-

learn

We will use Jupyter Notebook with Python 3 in this course. Install Python 3.7, jupyter, scikit-
learn, pandas, and matplotlib. We also recommend installing seaborn, a data visualization library.
You may find it convenient to use Anaconda to manage your Python setup.

Load the Wisconsin breast cancer data set, which is available as part of the sklearn datasets.
You can read more about this dataset here.

from sklearn import datasets

cancer = datasets.load_breast_cancer()

The object cancer is a dictionary, you can check the keys using

cancer.keys()

and check the details by calling the keys, like by using

cancer.feature_names

to see the feature names. You can also view a more detailed description of the dataset:

print(cancer.DESCR)

Please read the description! On your own, explore the other functions related to the keys. You
will also want to load the data (from cancer.data) into a pandas DataFrame.

df = pd.DataFrame(cancer.data, columns=cancer.feature_names)

You can select the column(s) of the DataFrame by indexing on the column name(s). E.g., to
see the ‘mean radius’ column of df, simply type

df[‘mean radius’]

Notice that invoking the above command returns a Series, a fundamental Pandas data-structure.
You can read more about this online.

You can select the row(s) of the DataFrame in multiple ways. One way is by slicing. For
example, if you want to see the top

1

00 rows of df, simply type

df[:100]

Or if you want to see the 100th, simply type

1

https://scikit-learn.org/stable/datasets/toy_dataset.html#breast-cancer-dataset

df[99:100]

Another way would be

df.ix[99]

You can read more about the ix method online.
The questions below involve exploring the data by plotting some figures, and you will find

libraries like numpy, matplotlib and seaborn very useful. You may want to read up on built in
functions like where from numpy for finding indices (or index from pandas) and show, savefig
from matplotlib to show and save your plots.

(a) How many rows and columns are there in this data set? What do the rows and columns
represent?

(b) How many malignant cases are there in total?

(c) Make a scatterplot of ‘mean compactness’ and ‘mean perimeter’. Try to color the points by
their label (i.e. malignant or benign). You may find scatter (from matplotlib) or jointplot
(from seaborn) useful for this.

(d) Make pairwise scatterplots of ‘mean texture’, ‘mean perimeter’, ‘mean compactness’, and ‘mean
radius’. You may find scatter matrix (from matplotlib) or pairplot (from seaborn) useful
for this. Do you notice that two of these features seem to be particularly correlated? Why
might this be?

2

CS Machine Learning

Homework

1

– Programming

Keywords: decision trees

1. Read the online documentation on decision trees and random forests in scikit-learn to find
out how to use decision trees and random forests. Notice that training a classifier is done
using the fit method, and that for decision trees this is done using a more sophisticated
evolution (known as CART) of the ID3 algorithm covered in class.

(a) Use the breast cancer data set from Homework 0 to create a training set. Recall that the
label is 0 if the patient’s data indicates a malignant cancer and 1 otherwise. Compute
the base rate of malignant cancer occurrence over the entire data set.

(b) The goal is to build a decision tree that, based on the other features in the set, predicts
whether or not a patient has malignant cancer. So this is a classification problem. Using
tree.DecisionTreeClassifier and other functions in the scikit-learn library, one can
build a decision tree and calculate both its training accuracy when fitted to the entire
data set as well as its accuracy using 10-fold cross validation (which gives a better idea
of true accuracy).

Vary the depth of your decision tree (use max depth = 1,2,. . . ,10 ) and plot both training
accuracy and cross-validated accuracy (as a function of the depth, on the x-axis). Plot
both curves on the same plot and use a legend to label them.

(c) Now try the random forest classifier of the scikit-learn library and use the best depth
you get from (b) as max depth. Vary the number of trees in the forest via the param-
eter n estimators and plot its 10-fold cross-validated accuracy (use n estimators =
1, 2, . . . , 20). Do you see an improvement using random forests versus using a single tree?
(Note: use the n estimators=1 result as the result for a single tree.)

(d) Using the method for building a decision tree you used in part (b), build a tree but
randomly hold out a .2, .4, .6, and .8 fraction of the data set (so you will need to build
4 different trees for each depth value). For each fraction held out, plot a curve of the
test accuracy (the accuracy on the held-out set) against depth. You should have four
curves. Plot them all on the same plot and use a legend to label them.

1

https://scikit-learn.org/stable/modules/tree.html

https://scikit-learn.org/stable/modules/ensemble.html#forests-of-randomized-trees