Supervised Learning Algorithms

Machine learning is much easier to learn when you have a real dataset to experiment with. Scikit-learn ships with several datasets that are ready to use, and the breast cancer dataset is one of them. This article loads it, runs a few lines of code, and examines what comes back. Each step starts with code you can trace, so you can check your understanding against what Python actually prints.

The article then turns to a harder question that appears once the data is no longer labeled. Imagine you run a clustering algorithm on a large collection of photographs and it returns several groups of pictures. Your first question is simple: did it work? In many machine learning settings that question has a straightforward answer, because you can compare the output against a known correct result. In unsupervised learning that comparison is usually impossible. Keep this scenario in mind, because the rest of the article returns to it.

The data is loaded with the load_breast_cancer function from scikit-learn. The function is imported from the sklearn.datasets module, called once, and its result is stored in a variable named cancer. The program below loads the dataset and prints the keys that the loaded object provides.

Datasets that come with scikit-learn are usually stored as Bunch objects. A Bunch object holds some information about the dataset together with the actual data. The source describes what you need to know about it in one sentence: a Bunch behaves like a dictionary, with the added benefit that you can access values using a dot. So bunch.key is an alternative to bunch['key'].

Because the Bunch behaves like a dictionary, the dot form and the bracket form refer to the same stored value. Writing cancer.data and cancer['data'] both reach the array of measurements. The dot form is simply shorter and easier to read in a line of code. The stored values are the same either way.

The breast cancer dataset consists of 569 data points, with 30 features each. The shape attribute of the data array reports this directly. Printing cancer.data.shape shows the number of rows and the number of columns, in that order. In this layout each row is one data point, which the source calls a sample, and each column is one feature measured on that sample.

The source also gives the per-class sample counts. The dataset is labeled as 212 malignant and 357 benign. These two counts add up to the 569 samples, so every row belongs to exactly one of the two classes. The 30 in the shape is a different kind of number: it counts features, not classes. Keeping the samples dimension and the features dimension separate is the key to reading the shape correctly.

To find out what each column in the data represents, look at the feature_names attribute. It gives the semantic meaning of each feature as a name. Printing it produces a list of 30 names. The names are not arbitrary. They follow a repeated pattern built from a small set of base measurements.

The mean, error, and worst pattern across ten base measurements accounts for all 30 features: three versions of ten measurements gives 30. When you read the list, you can locate any feature by its group and its base measurement. This structure matters because it tells you what each column means before you ever run an algorithm on it. A column's position in the array is meaningless until you match it to a name from feature_names.

The cancer dataset carries labels, which is what makes it useful for checking a supervised model. Unsupervised learning algorithms are usually applied to data with no label information, so the correct output is not known. This absence is the root of the evaluation problem. If nobody has written down what the right answer should be, there is nothing to measure the algorithm's output against.

The result can look orderly and still fail to be the division you cared about. Because of this, the source states plainly that it is very hard to say whether a model did well. A clean-looking output is not evidence of a correct output.

It helps to follow the path that data takes through an unsupervised workflow. The input is a collection of unlabeled items. The algorithm organizes them into groups. Those groups are then the only evidence you have, and whether they are good has to be judged by a person looking at them. The diagram below shows this path. Notice that the final step does not come from the algorithm at all.

The important point is that the algorithm cannot be told which division is wanted. There is no instruction you can give it that says group by the feature I care about. This is why evaluation in unsupervised learning often shifts from comparing against an answer key to asking whether the groups make sense for the purpose at hand. The judgment depends on the person doing the inspection, which is why manual inspection is often the only practical way to evaluate the result.