DEV Community: Temiloluwa Valentine

# ⚡ EcoScan— See Which Device is Drinking Your Money

Temiloluwa Valentine — Sun, 19 Apr 2026 17:42:27 +0000

_This is a submission for Weekend Challenge: Earth Day Edition

What I Built

Last month, my dad got our electricity bill and just stared at it.

He couldn't understand why it was so high. Was it the iron my mum uses every morning? The old fridge that runs all night? The TV nobody ever turns off? He had no idea. So he just paid it. Like he always does.

That moment stayed with me.

Millions of families across Nigeria, India, Ghana, Kenya and across the entire world pay electricity bills they don't understand. Not because they're careless. But because nobody ever made it simple enough to see where the money is actually going.

So I built EcoScan for Earth Day.

EcoScan is an AI-powered energy auditor that works with just a gesture.

Point your camera at any electrical appliance in your home, your iron, your fridge, your phone charger, your TV. Pinch your thumb and index finger together. In seconds, you see exactly what that device costs you per month in your local currency, how much CO₂ it produces, and what you can do about it.

No typing. No forms. No complicated settings. Just point and pinch.

Demo

In the demo you can see:

Real-time hand tracking detecting the pinch gesture
Gemini identifying a clothing iron, phone charger and smartphone
The live dashboard updating instantly with monthly costs in local currency
CO₂ impact, efficiency scores and energy-saving tips for each device

Code

Valentinetemi / EcoScan

⚡ EcoScan— See Which Device is Drinking Your Money

Point your camera at any appliance. Pinch your fingers. Know instantly what it costs you and the planet.

🌍 The Story Behind This

Last month, my dad got our electricity bill and just stared at it.

He couldn't understand why it was so high. He had no idea which device was the problem. Was it the iron my mum uses every morning? The old fridge that runs all night? The TV nobody turns off?

He just paid it. Like he always does. Because there was no easy way to find out.

That moment stayed with me.

Millions of families across Nigeria, India, Ghana, Kenya, across the entire world pay electricity bills they don't understand. Not because they're careless. But because nobody ever made it simple enough to see where the money is actually going.

So I built EcoScan for Earth Day.

…

View on GitHub

How I Built It

The Gesture Engine — MediaPipe in the Browser

The pinch detection runs entirely in the browser using MediaPipe HandLandmarker via WebAssembly. No backend needed for hand tracking.

Every frame, it calculates the Euclidean distance between Landmark 4 (thumb tip) and Landmark 8 (index finger tip). When the distance drops below 0.055 in normalized space, that's a pinch. It triggers once, captures the frame, and sends it to Gemini.

const dx = points[4].x - points[8].x;
const dy = points[4].y - points[8].y;
const dz = points[4].z - points[8].z;
const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
const pinching = dist < 0.055;

A cooldown ref prevents double-triggering during the async Gemini call.

The AI Brain - Gemini 2.0 Flash Latest

When a pinch is detected, the current video frame is captured as a base64 JPEG and sent to a Next.js API route, which calls Gemini 2.0 Flash Latest.

The prompt instructs Gemini to return structured JSON:

{
  "appliance": "Electric Iron",
  "category": "laundry",
  "wattageMin": 1000,
  "wattageMax": 2400,
  "dailyHours": 2,
  "efficiencyScore": 4,
  "co2PerYear": 47,
  "costPerYear": 12,
  "habitChange": "Iron clothes in batches instead of one item at a time",
  "alternative": "Steam generator iron with auto shut-off",
  "funFact": "An iron left on for 1 hour uses the same energy as charging your phone 50 times"
}

The API key never touches the browser, all Gemini calls go through Next.js API routes server-side.

Local Electricity Pricing - 20 Countries

The biggest insight: annual cost numbers mean nothing to most people. Monthly cost does.

EcoScan supports 20 countries with real electricity rates, from Nigeria to Germany. Users select their country from a dropdown and all costs recalculate instantly in their local currency.

The Live Dashboard

As devices are scanned, a live dashboard builds up using Recharts wattage by device, CO₂ impact, monthly cost, eco grade, trees needed to offset, and equivalent flights per year. Everything is stored in localStorage so it persists between sessions.

Tech Stack

Technology	Purpose
Next.js 14	Framework + server-side API routes
Google Gemini 2.0 Flash Latest	Vision AI — appliance identification
MediaPipe HandLandmarker	Pinch gesture detection (WebAssembly)
Framer Motion	Animations
Recharts	Live dashboard charts

Prize Categories

Best use of Google Gemini

Gemini 2.0 Flash Latest is the entire brain of EcoScan. Without it, the app is just a camera. With it, a single pinch gesture turns any appliance into a complete energy audit wattage, CO₂, cost, efficiency score, habit tips and eco alternatives, all adapted to the user's country and local electricity rate.

The prompt is carefully engineered to always return clean structured JSON so the UI can render results instantly. Gemini makes something that would normally require a database of thousands of appliances work with zero setup, it just knows.

My dad still doesn't know which appliance was draining our electricity bill.
Now he can find out in seconds.
That's why I built EcoScan. 🌍

By @temiloluwavalentine_

Predict House Prices with Python: A Beginner’s Machine Learning Guide

Temiloluwa Valentine — Wed, 04 Mar 2026 01:34:30 +0000

In the last article, “Getting Started with AI,” we covered the fundamentals—what machine learning is, the types of problems it solves, and the tools you need.

Theory is important. But it only matters when you build something real.

So let’s build.

In this article, you’ll learn how to predict house prices using machine learning.

Not a toy example. A real regression problem that real estate companies, investors, and data scientists solve every day.

You’ll understand:

How to structure data for a model
How to train a machine learning system
How to test if it actually works
How to make predictions on new data

By the end, you’ll have built your first machine learning model. And more importantly, you’ll understand the process, because this same process works for predicting stock prices, weather, customer churn, or anything else.

Let’s go.

Step 1: Get Your Data

Machine learning starts with data. You need examples to learn from.

For this project, we’re using the Housing Prices dataset from Kaggle, which is a free dataset with real house data: size, number of bedrooms, bathrooms, parking, e.t.c and most importantly, the price.

This is your training material. The model will learn the relationship between house features (size, bedrooms) and price.

How to get the data:

Go to Kaggle

Search “Housing Prices Dataset” or just click this link (https://www.kaggle.com/datasets/yasserh/housing-prices-dataset)
Download the CSV file
Upload to Google Colab

Load the data:

import pandas as pd

Load the dataset

df = pd.read_csv(f"{path}/Housing.csv ")
print(df)

Look at the first few rows

print(df.head())

You now have your data loaded. Next step: prepare it for the model.

Step 2: Prepare Your Data

Raw data isn’t ready for machine learning. You need to organize it.

Your dataset has features (inputs) and a target (output). Features are what you know: size, bedrooms, bathrooms, e.t.c. Target is what you want to predict: price.

The model learns the relationship between features and target. So you need to separate them.

Separate features and target:

Target (what we want to predict)

y = df['price']

Features (drop price column)

X = df.drop('price', axis=1)

Convert yes/no columns to 1/0
This is to convert the text to numbers because machine learning only understands numbers, not text, so we convert the "yes" to 1 and the "no" to 0.

binary_columns = [
‘mainroad’, ‘guestroom’, ‘basement’,
‘hotwaterheating’, ‘airconditioning’, ‘prefarea’
]
for col in binary_columns:
X[col] = X[col].map({'yes': 1, 'no': 0})
We will handle furnishingstatus because some are furnished, semi-furnished, and unfurnished

X = pd.get_dummies(X, columns=[‘furnishingstatus’], drop_first=True)

Split into training and testing:

Here’s the critical part: you can’t test on the same data you trained on. The model will memorize the answers instead of learning.

So split your data:

80% for training (the model learns)
20% for testing (we check if it actually works)

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
What random_state means:
Scikit-learn randomly selects:
80% of the data for training

20% for testing

If you don’t set random_state, the split will be different every time you run the code.

That means:

Your training data changes

Your test data changes

Your accuracy changes

That’s not good for debugging or comparing models.

Why this matters:

Training data teaches the model. Test data proves it works on new data it’s never seen.

Without this split, you’ll think your model is perfect. But it will fail when it meets real, unseen data.

Now your data is ready. Time to train.

Step 3: Train the Model

Now comes the magic. You’re going to teach a machine to predict house prices.

Create the model:

from sklearn.linear_model import LinearRegression
model = LinearRegression()
That’s it. You’ve created an empty machine learning model. It knows nothing yet.

Train it:

Train on your data

model.fit(X_train, y_train)
This is where learning happens. The model analyzes your training data to identify the mathematical relationship between features (size, bedrooms, e.t.c) and price.

It’s asking, "What pattern connects these house features to their prices?”

What’s happening behind the scenes:

The model is drawing a line (or curve) through your data. It’s trying to find the best line that fits all the houses, where features predict price most accurately.

This process is called “fitting” or “training.”

In a few seconds, your model learned from hundreds of house examples. That’s machine learning.

Step 4: Test the Model

Your model is trained. But does it work?

Time to test it on data it’s never seen before.

Make predictions:

Predict on test data

predictions = model.predict(X_test)
print(predictions[:5])
The model now looks at houses in the test set and predicts their prices. It’s guessing based on what it learned.

Comparison
We compare the actual price with the predicted price

comparison = pd.DataFrame({
“Actual Price”: y_test.values[:5],
“Predicted Price”: predictions[:5]
})
print(comparison)
Check how accurate it is:

from sklearn.metrics import mean_squared_error, r2_score

Calculate error

print("R²:", r2_score(y_test, predictions))
print("MAE:", mean_absolute_error(y_test, predictions))

After training and testing our linear regression model, we can see how well it predicts house prices:

R² Score: 0.65

Mean Absolute Error (MAE): ₦970,000

What this means:

R² Score (0–1): Measures how much of the variation in house prices the model can explain.

0.65 means our model explains about 65% of the differences in house prices.

The closer to 1, the better the model is at capturing patterns.

Mean Absolute Error (MAE): Shows the average amount our predictions are off.

₦970,000 means, on average, the predicted price is roughly ₦970k higher or lower than the actual price.

Lower is better, but for a first beginner model, this is acceptable.

Even though the model isn’t perfect, it successfully learns patterns from the data. This is exactly what beginners need to understand: how to go from raw data to predictions using machine learning.

With this foundation, you can now experiment with more features, larger datasets, or advanced models in the future.

Conclusion: You’re Now a Machine Learning Engineer

You just built a real machine learning system.

Not in theory. In practice. With code. With data. With real predictions.

What you learned:

Data is everything—garbage in, garbage out
Splitting data prevents lying to yourself
Training finds patterns automatically
Testing proves it actually works
Predictions are just applying what you learned

Why this matters:

This exact process solves real problems:

Predicting stock prices
Detecting diseases in medical images
Recommending products
Forecasting demand
Detecting fraud

Every machine learning project follows this same pipeline. Master it, and you can build anything.

What’s next:

Now that you understand the process, you can:

Try different algorithms (Random Forest, SVM, Neural Networks)
Use bigger datasets
Add more features
Build on real problems in your own life

The tools are free. The knowledge is available. The only limit is how much you’re willing to build.

Keep building.

Use this process on a problem you care about.

That’s where real learning happens.

Temiloluwa Valentine

AI #MachineLearning #BuildingInPublic

Getting Started with AI: A Practical Guide for Everyone

Temiloluwa Valentine — Fri, 27 Feb 2026 12:58:25 +0000

You've heard the word AI everywhere. ChatGPT, image generators, and recommendation systems on Netflix.

But here's what you're probably thinking: "AI is complicated. I'm not smart enough for this. I need a PhD in mathematics."

That's not true.

AI sounds mysterious because people make it sound mysterious. But underneath all the hype, it's just:

Data (examples)
Math (finding patterns)
Code (making it work)

If you can learn to code, you can learn AI.

This guide breaks down what AI actually is, how it works, and how you can start building it, whether you're a CS student, a curious developer, or someone completely new to programming.

No PhD required. Just curiosity and willingness to learn.

Let's go.

What Is AI, Actually?

You hear three words thrown around: AI, Machine Learning, Deep Learning.

People use them interchangeably. But they're not the same thing.

AI (Artificial Intelligence) = The big umbrella.
Any system that can perform tasks that normally require human intelligence.
Example: A chess program, a chatbot, a recommendation system.

Machine Learning = a subset of AI.
Instead of you telling the computer exactly what to do, you show it examples and let it figure out the pattern.
Example: Show the system 1000 photos of cats and dogs. It learns to tell them apart without you writing specific rules.

Deep Learning = A subset of Machine Learning.
Uses neural networks (inspired by how brains work) to find complex patterns.
Example: ChatGPT, image generators, self-driving cars.

Think of it like this:

AI is the whole pizza
Machine Learning is a slice
Deep Learning is a bit of that slice

Why does this matter?

Because you don't need deep learning to start. Most real-world problems are solved with machine learning.

You can predict house prices, classify emails as spam, and recommend products, all with machine learning, not deep learning.

Start simple. Go deep only when you need to.

The Types of Machine Learning

Machine learning breaks down into three main types. Understanding the difference is crucial because it changes how you approach problems.

1. Supervised Learning

You have data with answers.

The computer learns from examples where you've already labeled the correct answer. It's like learning with a teacher who shows you the right answer after each question.

Examples:

Email spam detection: "This email is spam" (labeled)
House price prediction: "This house costs ₦50 million" (labeled)
Image recognition: "This is a cat" (labeled)

How it works:

You give the system labeled examples
It finds patterns between the input and the label
When new data comes, it predicts the label

Most real-world problems use supervised learning.

2. Unsupervised Learning

You have data with no answers.

The computer finds patterns on its own. No teacher. No labels. Just raw data.

Examples:

Customer segmentation: Group customers by behavior (they don't know the groups beforehand)
Recommendation systems: Find users with similar tastes
Clustering documents: Group similar articles together

How it works:

You give the system unlabeled data
It finds hidden patterns
You discover insights you didn't know existed

3. Reinforcement Learning

The computer learns by doing and getting feedback.

Like training a dog: good behavior = reward. Bad behavior = no reward.

Examples:

Self-driving cars learning to navigate
Game AI learning to win
Robots learning to walk

How it works:

The agent (AI) takes an action
It gets feedback (reward or penalty)
It learns to maximize rewards

Which one do you need?

Start with supervised learning. 90% of real problems can be solved this way.

Most beginners should focus here.

Your Tools: Languages and Libraries

Okay, so you understand the theory. Now what do you actually use to build AI?

The Language: Python

Python dominates AI for one reason: it's simple.

You can focus on AI concepts, not syntax. Other languages (Java, C++) require more boilerplate code.

If you don't know Python yet, learn it first. It's easy and widely used in the AI community.

The Libraries: What You Need

Think of libraries as toolkits. Each one solves different problems.

Scikit-learn

Best for: Beginners, traditional machine learning
What it does: Classification, regression, clustering
When to use: Predicting prices, spam detection, customer segmentation
Difficulty: Easiest

TensorFlow

Best for: Deep learning, production systems
What it does: Neural networks, large-scale models
When to use: Image recognition, NLP, complex problems
Difficulty: Medium-Hard

PyTorch

Best for: Research, rapid prototyping
What it does: Neural networks, flexible design
When to use: Building custom models, research projects
Difficulty: Medium

The Honest Truth:

Start with scikit-learn. It's simple, powerful, and teaches you ML fundamentals without the complexity.

Once you understand how machine learning actually works, move to TensorFlow or PyTorch.

Don't jump to deep learning frameworks as a beginner. You'll get lost in the complexity and miss the fundamentals.

Where to Code:

Google Colab (free): Write Python in your browser, no installation needed
Jupyter Notebooks (free): Write code locally with explanations
VS Code (free): Full IDE if you want to get serious

Start with Google Colab. Seriously. No setup, just write code.

Your First Steps:

Learn Python basics (loops, functions, data structures)
Learn pandas (data manipulation)
Learn scikit-learn (machine learning)
Build a project

That's it. Don't skip steps.

You Now Know:

What AI, Machine Learning, and Deep Learning are
The three types of machine learning
The tools you need to get started
Where to write your first code

Next step? Build something.

In the next article, we'll walk through a real project - predicting house prices - and you'll see how all this theory actually works in practice.

See you there.

— Temiloluwa Valentine