Logistic Regression in Python – Restructuring Data for Machine Learning | Data Preprocessing Guide

Logistic Regression in Python – Restructuring Data

Before training a Logistic Regression model, raw data must be transformed into a format that machine learning algorithms can understand. This process is called data restructuring or data preprocessing.

Real-world datasets are rarely clean or ready for modeling. They often contain categorical values, missing data, inconsistent formats, and unscaled numerical features. If we directly feed such data into a Logistic Regression model, the performance will be poor.

In this tutorial, you will learn how to restructure data step-by-step so that it becomes suitable for Logistic Regression in Python using Scikit-Learn.

---

Why Restructuring Data is Important

Machine learning models cannot understand raw human data directly.

Restructuring data helps to:

• Improve model accuracy
• Convert categorical values into numerical format
• Normalize feature ranges
• Remove inconsistencies
• Make data machine-readable
• Improve training stability

Without proper restructuring, Logistic Regression may produce incorrect or biased predictions.

---

Types of Data Problems

Before restructuring, it is important to understand common issues in datasets:

1. Categorical Data

Example:

Gender: Male, Female
Country: India, USA, UK

2. Missing Values

Example:

Age: 25, NaN, 40

3. Unscaled Features

Example:

Age: 20–60
Salary: 10,000–100,000

4. Text Data

Example:

Reviews: "Good product", "Bad experience"

---

Import Required Libraries

import pandas as pd
import numpy as np

from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import StandardScaler

---

Load Dataset

Example dataset:

data = pd.read_csv("data/customers.csv")

print(data.head())

Sample output:

   Age  Salary  Gender  Purchased
0   22   25000    Male          0
1   25   30000  Female          0
2   30   45000  Female          0

---

Handling Categorical Data

Machine learning models require numerical input. Therefore, categorical values must be converted.

---

1. Label Encoding

Label Encoding converts categories into numeric values.

le = LabelEncoder()

data['Gender'] = le.fit_transform(data['Gender'])

print(data.head())

Example transformation:

Male   → 1
Female → 0

Result:

Gender column becomes numeric

---

When to Use Label Encoding

• Binary categories
• Ordinal data
• Simple classification features

---

2. One-Hot Encoding

One-Hot Encoding creates separate columns for each category.

data = pd.get_dummies(data, columns=['Gender'])

Result:

Gender_Female | Gender_Male
      1       |      0
      0       |      1

---

When to Use One-Hot Encoding

• Non-ordinal categorical variables
• Multi-class categories
• Nominal data (no ranking)

---

Handling Missing Values

Missing data must be treated before training.

Check missing values:

print(data.isnull().sum())

---

Remove Missing Values

data = data.dropna()

---

Fill Missing Values

data.fillna(data.mean(), inplace=True)

---

Feature Scaling

Logistic Regression is sensitive to feature magnitude differences.

Example:

• Age: 20–60
• Salary: 10,000–100,000

Scaling is required.

---

Standardization

scaler = StandardScaler()

data[['Age', 'Salary']] = scaler.fit_transform(
    data[['Age', 'Salary']]
)

---

Why Scaling is Important

• Improves convergence speed
• Enhances model accuracy
• Prevents feature dominance
• Stabilizes gradient descent

---

Feature Selection

Select only relevant columns:

X = data[['Age', 'Salary', 'Gender_Male']]
y = data['Purchased']

Split features and target:

• X → Input variables
• y → Output label

---

Train-Test Split Preparation

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.25,
    random_state=42
)

---

Data Transformation Pipeline (Best Practice)

Instead of manual steps, use pipelines:

from sklearn.pipeline import Pipeline

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('model', LogisticRegression())
])

Benefits:

• Clean workflow
• Reusable steps
• Less error-prone
• Production-ready structure

---

Common Restructuring Workflow

A typical preprocessing pipeline:

1. Load Dataset
2. Handle Missing Values
3. Encode Categorical Data
4. Scale Features
5. Select Features
6. Split Data
7. Train Model

---

Example Complete Preprocessing Code

import pandas as pd
from sklearn.preprocessing import LabelEncoder, StandardScaler
from sklearn.model_selection import train_test_split

data = pd.read_csv("data/customers.csv")

# Encode categorical data
le = LabelEncoder()
data['Gender'] = le.fit_transform(data['Gender'])

# Features and target
X = data[['Age', 'Salary', 'Gender']]
y = data['Purchased']

# Feature scaling
scaler = StandardScaler()
X[['Age', 'Salary']] = scaler.fit_transform(X[['Age', 'Salary']])

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

print("Data ready for Logistic Regression")

---

Best Practices for Data Restructuring

• Always encode categorical variables
• Scale numerical features
• Avoid data leakage
• Use pipelines when possible
• Keep preprocessing consistent
• Save preprocessing objects (scaler, encoder)

---

Common Mistakes

Avoid:

• Training model before scaling
• Forgetting to encode categories
• Mixing train/test preprocessing
• Overcomplicating transformations
• Ignoring missing values

---

Real-World Importance

Restructuring data is critical in:

• Fraud detection systems
• Customer analytics
• Medical diagnosis models
• Marketing prediction systems
• Financial risk modeling

Even advanced models depend heavily on clean and structured data.

---

Conclusion

Restructuring data is a crucial step in building effective Logistic Regression models. Proper encoding, scaling, and feature selection ensure that the algorithm can learn meaningful patterns from the dataset.

By mastering data preprocessing techniques in Python, you improve model accuracy, stability, and performance. This step forms the foundation of every successful machine learning pipeline, especially in classification tasks using Logistic Regression.