🚀 Day 5 of 30-Day MLOps Challenge: Feature Engineering and Feature Stores

🧠 Learn here

What is Feature Engineering?

Feature Engineering is the process of transforming raw data into meaningful input features that improve the performance of machine learning models.

Key Concepts:

• Features = input variables (columns) used by ML models to make predictions.

• Goal = Create features that highlight the signal (patterns) and reduce the noise.

It involves:

• Selecting relevant variables

• Transforming variables (scaling, encoding, etc.)

• Creating new features (e.g., time since last login, ratios, interactions)

• Handling missing values, outliers, and categorical variables

In Simple words:

Feature Engineering is turning raw data into the most useful inputs so a machine-learning model can learn better.

Example:

Why It's Crucial for ML Success

1. Garbage In, Garbage Out: No matter how powerful the algorithm, poor features = poor results.

2. Boosts Model Accuracy: Well-engineered features help models better understand patterns and relationships in data.

3. Reduces Complexity: Simplifies the learning task by focusing on relevant inputs.

4. Domain Knowledge Integration: Injects human intuition and business logic into the model.

5. Improves Generalization: Helps models perform better on unseen data by reducing overfitting.

---

Practical Example:

Dataset: house_prices.csv

A simple dataset to predict house prices based on features such as location, size, number of bedrooms, and year built.

id,location,size_sqft,bedrooms,built_year,price
1,Bangalore,1200,2,2005,70
2,Delhi,1800,3,2010,90
3,Mumbai,800,1,2000,50
4,Chennai,1500,3,2015,85

Objective

Prepare the dataset for machine learning by engineering meaningful features that improve model performance.

Feature Engineering Steps

Final Engineered Columns Example

id,house_age,size_per_room,location_Bangalore,location_Delhi,location_Mumbai,location_Chennai,price
1,19,600,1,0,0,0,70
2,14,600,0,1,0,0,90
3,24,800,0,0,1,0,50
4,9,500,0,0,0,1,85

Example Python Script for the same:

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, StandardScaler
import numpy as np

# Step 1: Load CSV
df = pd.read_csv('house_prices.csv')

# Step 2: Create house_age from built_year
current_year = 2025
df['house_age'] = current_year - df['built_year']

# Step 3: Create size_per_room feature
df['size_per_room'] = df['size_sqft'] / df['bedrooms']

# Step 4: One-hot encode 'location'
location_encoded = pd.get_dummies(df['location'], prefix='location')
df = pd.concat([df, location_encoded], axis=1)

# Step 5: Drop unused columns
df = df.drop(['location', 'built_year'], axis=1)

# Step 6: Normalize numerical features
scaler = StandardScaler()
df[['size_sqft', 'house_age', 'size_per_room']] = scaler.fit_transform(df[['size_sqft', 'house_age', 'size_per_room']])


# Save to CSV
output_path = "house_prices_engineered.csv"
df.to_csv(output_path, index=False)

# Final Output
print("\U0001F9FE Final Feature Engineered DataFrame:")
print(df)

Output

A cleaned and transformed dataset ready for feeding into machine learning models like Linear Regression, XGBoost, Random Forests, etc.

---

Types of Features commonly used in machine learning

Data Examples:

1. Tabular Data (Business / Transactions)

2. Date/Time Data

3. Web/App User Behavior

4. E-commerce Data

5. Text Data (NLP)

6. Healthcare / Time Series

7. Image Data

8. IoT / Sensor Data

9. Geospatial Data

---

Common Feature Engineering Transformations

---

Challenges in feature consistency across training & inference

Ensuring feature consistency between training and inference is a common challenge in MLOps and feature engineering pipelines. Inconsistencies can lead to degraded model performance, skewed predictions, or even outright failures in production.

⚠️ Key Challenges

---

What is a Feature Store?

A Feature Store is a centralized repository for storing, managing, and serving features used in machine learning models. It streamlines the entire ML workflow by enabling the reuse of features across different models, teams, and pipelines.

Why Feature Stores Matter?

• Consistency between training and inference

• Reusability of features across ML models

• Efficiency in data engineering and experimentation

• Governance and compliance for feature usage

• Documentation and lineage tracking for each feature

Core Components

1. Feature Registry: Catalog of all available features

2. Feature Ingestion: Pipelines to compute and store features

3. Online Store: Low-latency feature serving for real-time inference

4. Offline Store: Historical feature storage for training

5. Transformation Service: Converts raw data into features

How It Works?

1. Data engineers define feature pipelines.

2. Features are stored in offline/online stores.

3. ML engineers use the same features during training and inference.

4. Feature metadata and lineage are tracked centrally.

Popular Feature Stores

• Feast (open source)

• Tecton

• Databricks Feature Store

• SageMaker Feature Store

• Vertex AI Feature Store

Now, let's discuss about the MOST popular feature stores 👇

Feast (Feature Store)

From official Feast Repo

Feast (Feature Store) is an open-source feature store built for ML teams to manage and serve machine learning features:

• Open Source: Maintained by the community and used in many production-grade ML systems.

• Real-time & Batch: Supports both batch and real-time data sources.

• Pluggable Storage: Works with Redis, BigQuery, Snowflake, PostgreSQL, etc.

• Online & Offline Store: Guarantees feature consistency between training and serving.

• Integration: Works well with popular ML frameworks like TensorFlow, PyTorch, and Spark.

Use Cases:

• Real-time fraud detection

• Recommendation systems

• Click-through rate prediction

🔗 https://github.com/feast-dev/feast

🔧 Tecton

Tecton is a managed feature store that helps productionize ML features at scale:

• Enterprise-grade: Designed for large-scale deployments.

• Declarative Pipelines: Define features using Python or SQL.

• Feature Lineage & Monitoring: Built-in observability tools.

• Consistent Feature Delivery: Ensures consistency across training and serving environments.

• Streaming & Batch: Native support for both batch and real-time sources.

Strengths:

• Automated feature transformation pipelines

• Versioning and governance

• Scales with modern data infra (e.g., Snowflake, Spark, Kafka)

🔗 https://www.tecton.ai

AWS SageMaker Feature Store

Amazon SageMaker Feature Store is a fully-managed feature store service integrated with the AWS ecosystem:

• Fully Managed: Serverless, scales with usage.

• Integration with SageMaker: Seamless experience for AWS ML workflows.

• Online and Offline Store: Syncs features for both training and real-time inference.

• Data Security & Compliance: Built-in IAM, encryption, and logging.

• Data Catalog Integration: Supports Glue Data Catalog and Athena.

Ideal for:

• Teams already using AWS for ML

• Large-scale training and inference pipelines

• Data lineage and security-focused ML workflows

🔗 https://aws.amazon.com/sagemaker/feature-store/

---

📊 Feature Store Comparison Table

Example: Installing and Using Feast with CSV Data

1. Install Feast

pip install feast

2. Initialize Feast Project

feast init feast_project
cd feast_project

3. Add CSV File

Create a file named customer_engagement.csv with the following content:

customer_id,last_login_days,num_sessions,avg_session_duration,signup_date
1001,5,12,30.5,2021-01-01
1002,2,20,45.0,2021-02-15
1003,10,5,25.0,2021-03-20

Place it in the root of your Feast project.

4. Define Feature Repo (example_repo/feature_repo.py)

from datetime import timedelta
from feast import Entity, FeatureView, Field, FileSource
from feast.types import Int64, Float64

engagement_source = FileSource(
    path="customer_engagement.csv",
    timestamp_field="signup_date"
)

customer = Entity(name="customer_id", join_keys=["customer_id"])

engagement_fv = FeatureView(
    name="engagement_fv",
    entities=["customer_id"],
    ttl=timedelta(days=365),
    schema=[
        Field(name="last_login_days", dtype=Int64),
        Field(name="num_sessions", dtype=Int64),
        Field(name="avg_session_duration", dtype=Float64),
    ],
    source=engagement_source
)

5. Register Features

feast apply

6. Materialize Data

feast materialize-incremental $(date +%F)

7. Query Features

from feast import FeatureStore
import pandas as pd

store = FeatureStore(repo_path=".")

entity_df = pd.DataFrame.from_dict({
    "customer_id": [1001, 1003],
    "event_timestamp": ["2022-01-01", "2022-01-01"]
})

features = store.get_historical_features(
    entity_df=entity_df,
    features=[
        "engagement_fv:last_login_days",
        "engagement_fv:num_sessions",
        "engagement_fv:avg_session_duration"
    ]
).to_df()

print(features)

Expected Output

   customer_id      event_timestamp  last_login_days  num_sessions  avg_session_duration
0         1001  2022-01-01 00:00:00                5            12                 30.5
1         1003  2022-01-01 00:00:00               10             5                 25.0

💡Notes

• Feast defaults to using SQLite as the online store.

• You can configure Redis, PostgreSQL, or DynamoDB for production use.

• For production, define feature_store.yaml with appropriate store and provider settings.

---

📖 Learning Resources

• 📘 Feature Engineering | Applied Machine Learning

• 📘 Feature engineering - Machine Learning Lens

---

🔥 Challenges

💡 Perform basic feature engineering on a CSV dataset using Pandas

💡 Use scikit-learn pipelines to automate transformations

💡 Install Feast, initialize a repo, and define a feature view

💡 Simulate online/offline feature serving using Feast with a local SQLite store

💡 Write a blog post or GitHub README: "Intro to Feature Stores with Feast + Python"

💡 Try using Feast with Google Cloud BigQuery or Redis as the online store

---

🤷🏻 How to Participate?

✅ Complete the tasks and challenges.
✅ Document your progress and key takeaways on GitHub ReadMe, Medium, or Hashnode.
✅ Share the above in a LinkedIn post tagging me (Bittu Kumar), and use #30DaysOfMLOps to engage with the community!

Follow me on LinkedIn

Follow me on GitHub

Keep Learning……