Logistic Regression in Python – Testing
After training a Logistic Regression model in Python, the most important step is testing and evaluation. This stage helps you understand how well your model performs on unseen data and whether it is reliable enough for real-world use.
A machine learning model is not considered complete until it has been properly tested and evaluated using real metrics.
In this guide, you will learn how to test a Logistic Regression model in Python using Scikit-Learn, interpret results correctly, and follow best practices used in real machine learning projects.
Why Testing a Machine Learning Model is Important
Testing is a critical step in the machine learning pipeline because it helps you understand how your model behaves on new data.
Key benefits of testing:
- Measures model accuracy on unseen data
- Detects overfitting or underfitting
- Evaluates real-world performance
- Helps compare different models
- Improves decision-making in deployment
Without proper testing, a model may look good during training but fail in real-world applications.
Machine Learning Testing Workflow
The testing process for a Logistic Regression model typically follows these steps:
1. Load trained model
2. Prepare test dataset
3. Apply preprocessing (scaling, encoding)
4. Make predictions
5. Compare predictions with actual values
6. Evaluate performance metrics
7. Interpret results
Each step ensures that the evaluation is accurate and meaningful.
Step 1: Load the Trained Model
In real projects, models are saved after training using joblib or pickle.
import joblib
model = joblib.load("models/logistic_model.pkl")
Loading a saved model ensures consistency and avoids retraining.
Step 2: Load and Prepare Test Data
Test data must be separate from training data to ensure fair evaluation.
import pandas as pd
data = pd.read_csv("data/customers_test.csv")
X_test = data[['Age', 'Salary']]
y_test = data['Purchased']
The test dataset simulates real-world unseen data.
Step 3: Apply Feature Scaling (Important Step)
Feature scaling must be consistent with training data preprocessing.
⚠️ Important: In real applications, you should load the saved scaler instead of refitting it.
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_test = scaler.fit_transform(X_test)
Why scaling is important:
- Ensures features are on the same scale
- Prevents bias toward large numerical values
- Improves model stability
Step 4: Make Predictions
Now we use the trained model to predict outcomes.
y_pred = model.predict(X_test)
print(y_pred)
Example Output:
[0 1 1 0 0 1]
Each value represents a predicted class.
Step 5: Compare Actual vs Predicted Values
Comparing results helps you visually understand model performance.
comparison = pd.DataFrame({
"Actual": y_test,
"Predicted": y_pred
})
print(comparison.head())
This helps identify mismatches and errors.
Step 6: Calculate Model Accuracy
Accuracy shows the percentage of correct predictions.
from sklearn.metrics import accuracy_score
accuracy = accuracy_score(y_test, y_pred)
print("Model Accuracy:", accuracy)
Example Output:
Model Accuracy: 0.88
However, accuracy alone is not always enough.
Step 7: Confusion Matrix (Detailed Evaluation)
The confusion matrix provides a deeper understanding of model performance.
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(y_test, y_pred)
print(cm)
Example Output:
[[52 4]
[ 6 38]]
Interpretation:
- True Negatives (TN): 52
- False Positives (FP): 4
- False Negatives (FN): 6
- True Positives (TP): 38
This helps identify where the model is making mistakes.
Step 8: Classification Report
The classification report gives a complete evaluation summary.
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))
It includes:
- Precision (how many predictions were correct)
- Recall (how many actual positives were found)
- F1-score (balance between precision and recall)
- Support (number of samples)
This is one of the most important evaluation tools in machine learning.
Step 9: Predict Probabilities
Logistic Regression also provides probability values instead of only class labels.
y_prob = model.predict_proba(X_test)
print(y_prob[:5])
Example Output:
[[0.78 0.22]
[0.40 0.60]
[0.10 0.90]]
These values show confidence levels for each prediction.
Understanding Model Performance
✅ Good Model Indicators:
- High accuracy (generally 80%+)
- Balanced precision and recall
- Low false positive and false negative rates
- Consistent performance across metrics
❌ Poor Model Indicators:
- Low accuracy
- Overfitting or underfitting
- High error rate
- Poor recall for minority class
Visualizing Test Results
Visualization helps better understand predictions.
import matplotlib.pyplot as plt
plt.scatter(range(len(y_test)), y_test, label="Actual")
plt.scatter(range(len(y_pred)), y_pred, label="Predicted")
plt.title("Actual vs Predicted Values")
plt.legend()
plt.show()
This graph helps compare prediction accuracy visually.
Complete Testing Code (Final Version)
import pandas as pd
import joblib
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
# Load model
model = joblib.load("models/logistic_model.pkl")
# Load test data
data = pd.read_csv("data/customers_test.csv")
X_test = data[['Age', 'Salary']]
y_test = data['Purchased']
# Predict
y_pred = model.predict(X_test)
# Evaluation
print("Accuracy:", accuracy_score(y_test, y_pred))
print("Confusion Matrix:\n", confusion_matrix(y_test, y_pred))
print("Classification Report:\n", classification_report(y_test, y_pred))
Best Practices for Model Testing
To ensure reliable results:
- Always use unseen test data
- Never test on training data
- Save and reuse preprocessing steps
- Evaluate multiple metrics, not just accuracy
- Avoid data leakage between training and testing
Common Mistakes to Avoid
Many beginners make these mistakes:
- Using training data for testing
- Refitting scaler on test data
- Relying only on accuracy
- Ignoring precision and recall
- Forgetting to save preprocessing steps
Avoiding these improves model reliability.
Real-World Applications of Model Testing
Testing Logistic Regression models is essential in:
- Fraud detection systems
- Medical diagnosis models
- Credit scoring systems
- Customer behavior prediction
- Marketing analytics
Conclusion
Testing is one of the most important stages in the machine learning workflow. It ensures that your Logistic Regression model performs correctly on unseen data and can be trusted in real-world applications.
By using evaluation metrics such as accuracy, confusion matrix, and classification report, you gain a complete understanding of model performance.
Proper testing helps you build more accurate, reliable, and production-ready machine learning systems in Python using Scikit-Learn.
0 Comments