here’s what I usually do first when starting a new machine learning demo—especially when working in Jupyter Notebook or similar environments. I make a duplicate of the existing notebook and rename it. That just keeps things organized. In this case, I renamed it to MLDemo2. Once that’s done, I close the old tab. No need to have it open anymore.
Next step: I restart the kernel and clear all previous outputs. Fresh start helps avoid confusion. Then, I begin importing the libraries I’ll need. Not too many—just the essentials.
We bring in NumPy (as np), which, if you’re new to this, is used for numerical operations. Super useful for arrays and math stuff. Then, from scikit-learn’s model selection module, we pull in train_test_split. It splits the data—one part for training the model, another part to test it.
We also import StandardScaler from the preprocessing module. That one’s for scaling features. It ensures everything has the same range—mean of 0, standard deviation of 1. And finally, we grab accuracy_score from sklearn’s metrics module to evaluate how well the model performs.
Let’s talk about why these matter.
Why Standardization Matters
Imagine you’re predicting house prices. You’ve got two features: square footage and number of bedrooms. Square footage ranges between 1,000 and 5,000, while bedroom count might just be between 1 and 6. Naturally, square footage has bigger numbers. If you don’t standardize, the model might treat square footage as more important, just because the values are larger—not because it actually matters more.
Standardizing both helps bring them to the same playing field. It’s like saying: hey, treat all features equally and don’t let large numbers bully the small ones.
Train-Test Split
This one’s pretty straightforward. train_test_split divides your dataset. You train your model on one half and test it on the other. That way, you can check how well your model performs on data it hasn’t seen before.
And then there’s the random_state parameter. That’s like a seed value. If you set it (say to 42), the split will be the same every time you run the code. Helps when you want reproducibility.
Validation and Accuracy
After training, how do we know the model works well? That’s where accuracy_score comes in. It compares the model’s predictions with actual values from the test set. The higher the score, the better the model—simple as that.
Let’s say you built a spam classifier. You train it on labeled email data. Then you test it with some fresh emails. If the model correctly classifies 95 out of 100 emails, that’s 95% accuracy. But it’s also important that the model isn’t just memorizing. That’s called overfitting—where the model performs great on training data but fails with new, unseen data.
Let’s Get Our Hands Dirty
Alright. Now, we load the dataset. Typically, this will be something like the Iris dataset. We display a few rows just to get familiar with it. Then we split the data into features (X) and labels (y).
Once split, we do another round of splitting: this time into training and testing sets — X_train, X_test, y_train, y_test.
Next, we scale the data using the StandardScaler. We create an instance of the scaler and use it to standardize the training and test features. Scaling is always done after the split to avoid data leakage.
Model Training: Logistic Regression
We create an instance of LogisticRegression. Then, we train the model using the standardized training data.
At this point, the model tries to understand the patterns between the features and the labels. That’s learning, basically. Once it’s trained, we test it on unseen data—X_test_scaled. The model predicts the output, and we compare it with the actual labels using accuracy_score.
In our case, the model gave an accuracy of 1. That’s 100%. Which honestly is rare in real-world scenarios, but possible in clean datasets like Iris.
Trying Out New Predictions
To make this demo more complete, we create some new sample data points—think of them as attributes of unknown Iris flowers. We standardize this new data, just like we did for the training and testing data.
Now comes the interesting part—we ask the trained model to predict the species based on these new attributes. It does that, and then we print out the predicted classes.
Let’s say:
- The first sample is predicted as Iris Setosa
- The second one as Iris Virginica
- And the third one again as Iris Setosa
These predictions are based purely on the features we provided—sepal length, sepal width, petal length, petal width. This kind of prediction is what makes machine learning so useful.
Wrapping Up
So, in this extended demo, we went beyond just training a model. We:
- Imported essential libraries
- Split and standardized data
- Trained a logistic regression model
- Evaluated its performance
- And finally, made predictions on new data
It’s not just about getting to the result, but understanding each part along the way. The accuracy, the scaling, the reproducibility—all of it adds up to help build a more reliable model.
This is just one workflow, and there’s more out there to explore. But even just knowing this gives you a solid starting point.