{"id":"l-ml-1-3","courseId":"ml-crash-course","lang":"en","kind":"lesson","summary":"Use any scikit-learn model through the same three calls (fit, predict, score), read what a fitted model learned, and spot memorisation by comparing training and test scores.","html":"

scikit-learn ships dozens of models, from straight lines to forests of trees, and you use every one of them the same way. Learn three method calls and you can try any of them on the churn data in a few lines. That consistency is the main reason scikit-learn is the default library for classic machine learning.

\n

Three calls

\n

A model in scikit-learn is an estimator: a Python object you create with its settings, train with fit, and use with predict and score.

\n
Python
import pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.tree import DecisionTreeClassifier\n\nchurn = pd.read_csv(\"churn.csv\")\nfeatures = [\"tenure_days\", \"orders\", \"total_spent\", \"avg_order_value\",\n            \"days_since_last_order\", \"used_coupon\", \"support_tickets\", \"mobile_share\"]\nX, y = churn[features], churn[\"churned\"]\nX_train, X_test, y_train, y_test = train_test_split(\n    X, y, test_size=0.25, random_state=42, stratify=y)\n\nmodel = DecisionTreeClassifier(max_depth=3, random_state=42)  # 1. create\nmodel.fit(X_train, y_train)                                    # 2. learn\nprint(model.predict(X_test)[:10])                              # 3. use\nprint(\"train accuracy:\", round(model.score(X_train, y_train), 3))\nprint(\"test accuracy: \", round(model.score(X_test, y_test), 3))
\n

What each call does:

\n\n
\n An estimator is created with hyperparameters, fit on training data to learn parameters stored in attributes ending with an underscore, and then used to predict on new data or score against known answers.\n \n Model(max_depth=3)\n hyperparameters\n \n fit\n \n Fitted model\n classes_, tree_ …\n \n \n \n predict(X)\n \n score(X, y)\n
The life of an estimator
\n

What a fitted model knows

\n

Everything a model learns during fit is stored in attributes whose names end with an underscore. They don’t exist before fit; asking for one raises an AttributeError, and calling predict on an unfitted model raises NotFittedError.

\n
Python
import pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.tree import DecisionTreeClassifier\n\nchurn = pd.read_csv(\"churn.csv\")\nfeatures = [\"tenure_days\", \"orders\", \"total_spent\", \"avg_order_value\",\n            \"days_since_last_order\", \"used_coupon\", \"support_tickets\", \"mobile_share\"]\nX_train, X_test, y_train, y_test = train_test_split(\n    churn[features], churn[\"churned\"], test_size=0.25, random_state=42,\n    stratify=churn[\"churned\"])\nmodel = DecisionTreeClassifier(max_depth=3, random_state=42).fit(X_train, y_train)\n\nprint(model.classes_)            # the labels it saw: [0 1]\nprint(model.n_features_in_)      # 8\nprint(model.feature_names_in_[:3])\n\nnew_customer = pd.DataFrame([{\n    \"tenure_days\": 400, \"orders\": 2, \"total_spent\": 180.0, \"avg_order_value\": 90.0,\n    \"days_since_last_order\": 150, \"used_coupon\": 0, \"support_tickets\": 1,\n    \"mobile_share\": 0.5}])\nprint(model.predict(new_customer))        # [1]: likely to churn\nprint(model.predict_proba(new_customer))  # [[0.36 0.64]]
\n

predict_proba gives the model’s estimated probability for each class, in the order of classes_. This customer gets 64% for churn. You’ll lean on probabilities heavily in section 3, because they let you choose how cautious to be.

\n

The training score lies

\n

Now remove the depth limit and watch what happens. An unlimited tree keeps asking questions until every training customer sits in a leaf with only their own class.

\n
Python
import pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.neighbors import KNeighborsClassifier\n\nchurn = pd.read_csv(\"churn.csv\")\nfeatures = [\"tenure_days\", \"orders\", \"total_spent\", \"avg_order_value\",\n            \"days_since_last_order\", \"used_coupon\", \"support_tickets\", \"mobile_share\"]\nX_train, X_test, y_train, y_test = train_test_split(\n    churn[features], churn[\"churned\"], test_size=0.25, random_state=42,\n    stratify=churn[\"churned\"])\n\nfor model in [DecisionTreeClassifier(max_depth=3, random_state=42),\n              DecisionTreeClassifier(random_state=42),\n              KNeighborsClassifier(n_neighbors=5)]:\n    model.fit(X_train, y_train)\n    print(f\"{model!r:55} train {model.score(X_train, y_train):.2f}  test {model.score(X_test, y_test):.2f}\")
\n

The unlimited tree is perfect on the 298 customers it studied and worse than the shallow tree on the 100 it didn’t. It memorised quirks of individual customers. This gap between training and test performance is overfitting, and you’ll spend much of section 2 learning to control it.

\n

Notice also the third model. k-nearest neighbours works nothing like a tree (it predicts by looking at the five most similar training customers), yet the code is identical. Swapping models costs one line.

\n

Same contract, different assumptions

\n

The shared API hides very different ideas about the world. A tree assumes churn can be described by a handful of yes/no questions with sharp cut-offs. k-nearest neighbours assumes customers who look alike behave alike, where “look alike” means close together when every column is treated as a distance. Neither assumption is right; each is useful in some situations and wrong in others. That’s why you try several models on the same split rather than arguing about which one ought to win.

\n

Regression models keep the same contract. DecisionTreeRegressor or LinearRegression take a numeric y, predict returns numbers instead of classes, and score returns R² instead of accuracy. Everything you learn about one estimator carries over to the rest.

\n

Two details save confusion later. Calling fit a second time throws away what the model learned before and starts from scratch; it doesn’t add to the old knowledge. And the settings you passed to the constructor stay readable as plain attributes (model.max_depth), so you can always check what a fitted model was told to do.

\n\n

You now have a model at 73% test accuracy. Is that good? You can’t say yet, because you haven’t asked what a model with no intelligence at all would score. That’s the next lesson.

\n","toc":[{"id":"sec-1","text":"Three calls","level":2},{"id":"sec-2","text":"What a fitted model knows","level":2},{"id":"sec-3","text":"The training score lies","level":2},{"id":"sec-4","text":"Same contract, different assumptions","level":2}],"takeaways":["Every scikit-learn estimator is created with its settings, learns in fit(X, y), and is used with predict(X) and score(X, y).","Hyperparameters such as max_depth are set by you before training; parameters such as split thresholds are learned during fit.","Fitted attributes end with an underscore (classes_, feature_names_in_) and only exist after fit.","score returns accuracy for classifiers and R² for regressors.","A large gap between training and test scores means the model memorised its training rows."],"further":[{"title":"Getting started: fitting and predicting","url":"https://scikit-learn.org/stable/getting_started.html"},{"title":"DecisionTreeClassifier","url":"https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html"},{"title":"Glossary: estimator, fit, predict","url":"https://scikit-learn.org/stable/glossary.html"}],"quiz":[{"q":"

What does this print?

\n
Python
from sklearn.tree import DecisionTreeClassifier\nmodel = DecisionTreeClassifier(max_depth=3)\nprint(model.classes_)
\n","options":[{"text":"[0 1], the two churn classes.","why":"classes_ is learned from y during fit. This model has never seen any data."},{"text":"None, because no classes have been set yet.","why":"scikit-learn doesn’t create fitted attributes as None. They don’t exist until fit runs."},{"text":"An AttributeError, because classes_ only exists after fit.","why":"Correct. The trailing underscore marks an attribute that fit creates."}],"answer":2},{"q":"

A tree scores 1.00 on the training set and 0.72 on the test set. A depth-3 tree scores 0.78 and 0.73. Which is the better model for Cartwheel?

","options":[{"text":"The unlimited tree, because 1.00 shows it captured every pattern.","why":"A perfect training score on noisy data like churn means it memorised individual customers. Its test score is lower."},{"text":"The depth-3 tree, because it does at least as well on unseen customers and is far simpler.","why":"Correct. Judge on held-out data; when scores tie, prefer the model with fewer moving parts."},{"text":"They are equal, because their test scores differ by only 0.01.","why":"Test scores are close, but the depth-3 tree is easier to explain and less likely to swing on new data. That breaks the tie."}],"answer":1},{"q":"

Which value is a hyperparameter rather than a learned parameter?

","options":[{"text":"max_depth=3 passed to DecisionTreeClassifier","why":"Correct. You choose it before training, and it limits how complex the learned tree can be."},{"text":"The threshold days_since_last_order <= 236.5 at the root of a fitted tree","why":"That threshold is found by fit from the data. It is a learned parameter."},{"text":"coef_ of a fitted LinearRegression","why":"Coefficients are learned from the data, which is why they carry the trailing underscore."}],"answer":0},{"q":"

You fitted a model on a DataFrame with columns in one order, then call predict on a DataFrame with the same columns in a different order. What happens?

","options":[{"text":"scikit-learn reorders the columns for you and predicts correctly.","why":"scikit-learn checks names but does not reorder. It refuses instead of guessing."},{"text":"It raises a ValueError saying feature names must be in the same order as in fit.","why":"Correct. The check protects you from silently feeding orders into the slot the model learned as tenure_days."},{"text":"It predicts silently, using the columns by position.","why":"That is what happens with a NumPy array, which has no names. With a DataFrame, the name check catches the mismatch."}],"answer":1}],"exercise":{"kind":"python","files":["churn.csv"],"starter":"import pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.tree import DecisionTreeClassifier\n\nchurn = pd.read_csv(\"churn.csv\")\nfeatures = [\"tenure_days\", \"orders\", \"total_spent\", \"avg_order_value\",\n \"days_since_last_order\", \"used_coupon\", \"support_tickets\", \"mobile_share\"]\nX_train, X_test, y_train, y_test = train_test_split(\n churn[features], churn[\"churned\"], test_size=0.25, random_state=42,\n stratify=churn[\"churned\"])\n\nnew_customer = pd.DataFrame([{\n \"tenure_days\": 120, \"orders\": 6, \"total_spent\": 940.0, \"avg_order_value\": 156.7,\n \"days_since_last_order\": 12, \"used_coupon\": 1, \"support_tickets\": 0,\n \"mobile_share\": 0.8}])\n\n# 1. A tree limited to depth 3, and a tree with no depth limit (both random_state=42)\nshallow = DecisionTreeClassifier(max_depth=3, random_state=42)\ndeep = DecisionTreeClassifier(random_state=42)\n\n# 2. Fit both on the training data, then fill in the scores\nshallow_test = None\ndeep_train = None\ndeep_test = None\n\n# 3. The shallow tree's prediction (0 or 1) for new_customer\nnew_pred = None\n","solution":"import pandas as pd\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.tree import DecisionTreeClassifier\n\nchurn = pd.read_csv(\"churn.csv\")\nfeatures = [\"tenure_days\", \"orders\", \"total_spent\", \"avg_order_value\",\n \"days_since_last_order\", \"used_coupon\", \"support_tickets\", \"mobile_share\"]\nX_train, X_test, y_train, y_test = train_test_split(\n churn[features], churn[\"churned\"], test_size=0.25, random_state=42,\n stratify=churn[\"churned\"])\n\nnew_customer = pd.DataFrame([{\n \"tenure_days\": 120, \"orders\": 6, \"total_spent\": 940.0, \"avg_order_value\": 156.7,\n \"days_since_last_order\": 12, \"used_coupon\": 1, \"support_tickets\": 0,\n \"mobile_share\": 0.8}])\n\nshallow = DecisionTreeClassifier(max_depth=3, random_state=42).fit(X_train, y_train)\ndeep = DecisionTreeClassifier(random_state=42).fit(X_train, y_train)\n\nshallow_test = shallow.score(X_test, y_test)\ndeep_train = deep.score(X_train, y_train)\ndeep_test = deep.score(X_test, y_test)\n\nnew_pred = int(shallow.predict(new_customer)[0])\n\nprint(f\"shallow test {shallow_test:.2f} | deep train {deep_train:.2f}, test {deep_test:.2f}\")\n","checks":[{"id":"fitted","test":"hasattr(shallow, 'classes_') and hasattr(deep, 'classes_') and shallow.max_depth == 3 and deep.max_depth is None"},{"id":"shallow-test","test":"shallow_test is not None and abs(float(shallow_test) - 0.73) < 0.005"},{"id":"deep-scores","test":"deep_train is not None and float(deep_train) == 1.0 and abs(float(deep_test) - 0.72) < 0.005"},{"id":"prediction","test":"new_pred is not None and int(__import__('numpy').ravel(new_pred)[0]) == 0"}],"title":"Fit two trees and compare","prompt":"

Fit two decision trees on the churn training data and see memorisation in numbers.

\n
    \n
  1. Fit shallow (max_depth=3) and deep (no depth limit), both with random_state=42.
    2. \n
  2. Set shallow_test to the shallow tree’s test accuracy, and deep_train / deep_test to the deep tree’s training and test accuracy.
    3. \n
  3. Set new_pred to the shallow tree’s prediction (0 or 1) for new_customer.
    4. \n
\n","hints":["fit returns the model, so DecisionTreeClassifier(...).fit(X_train, y_train) works in one line.","model.score(X, y) returns accuracy for a classifier.","predict returns an array with one value per row; take element [0] for the single new customer."],"explanation":"

The deep tree scores 1.00 on the customers it trained on and 0.72 on new ones; the depth-3 tree scores 0.73 on new ones with a fraction of the rules. The training score of a flexible model tells you almost nothing. The new customer ordered 12 days ago and has six orders, so the shallow tree predicts 0 (stays).

\n","checkLabels":{"fitted":"Both trees are fitted with the right depth settings","shallow-test":"shallow_test is the shallow tree’s test accuracy","deep-scores":"deep_train and deep_test are the deep tree’s scores","prediction":"new_pred is the shallow tree’s prediction for new_customer"}},"words":688,"readMinutes":3}