Design Community: Anuj Bolewar

Building a 75,000-Product Image Feature Dataset for the Amazon ML Challenge 2025

Anuj Bolewar — Fri, 17 Oct 2025 08:07:38 +0000

Hey everyone! Hope you’re all doing great today.

So I’ve got something pretty exciting to share with you all — I just created a massive image features dataset for the Amazon ML Challenge 2025!

Processing 75,000 product images and extracting deep learning features was absolutely wild. I never thought I’d be building ML-ready datasets at this scale — but here we are!

How It All Started

While reading through the Amazon ML Challenge problem statement about predicting product prices, I noticed something interesting.

The challenge provides product images, but most participants would probably struggle with efficient image processing.

That’s when it hit me —

“Wait, I could create a ready-to-use feature dataset that makes everyone’s life easier!”

Why make everyone extract image features from scratch when it can be done once and shared with the whole community?

The Challenge That Sparked This Idea

The competition focuses on predicting product prices using both text and images.

The connection between visuals and pricing is fascinating — a clean, professional product photo often correlates with higher perceived value.

But there’s a catch — working with raw images is:

Time-consuming
GPU-intensive
Technically complex for beginners
Repetitive work everyone must do

So I thought —

“What if I create a dataset that eliminates all these pain points?”

The Creative Process Was Actually Fun

Coming Up With The Architecture

I’ve always loved transfer learning, so I chose ResNet50, pretrained on ImageNet, to extract image embeddings.

The pipeline:

Extract 2048-dimensional features using ResNet50
Apply PCA compression to reduce them to 100 dimensions
Save it all in a clean, ML-ready CSV file

The Technical Challenge

Processing 75,000 product images isn’t just “run a script and chill”.

I had to make sure the extracted features were:

Meaningful: capturing rich visual details
Efficiently processed: I hit 502 images/sec on GPU
Handled missing data: about 2% of products had missing images
Easy to use: simple CSV ready for pandas or sklearn

I also worked on:

Optimizing the batch pipeline
Fine-tuning PCA (retaining 83% variance)
Normalizing features
Writing documentation and examples

What I Learned About Feature Engineering

Before this project, I understood deep learning theory — but building a real-world feature pipeline taught me so much more.

We’re talking about compressing thousands of pixels into just 100 numerical features — yet those vectors can:

Identify similar products
Enable price prediction
Drive recommendation engines

That’s the power of representation learning.

The Technical Breakdown

Image Processing Pipeline

ResNet50 → 2048 features → PCA → 100 features

Quality Checks

98% image coverage (73,485 / 75,000)
Feature distributions validated
Visual similarity tested

Optimization

GPU accelerated → 502 images/sec
Parallel processing
Memory-efficient pipeline

Documentation

Detailed README
Example notebooks
Ready-to-run scripts

The Challenges I Faced

The hardest decision? Choosing PCA dimensions.

After several experiments:

100 dimensions retained 83% variance
Balanced accuracy + efficiency
Great for visualization and clustering

Handling missing images was another challenge — I used zero vectors with a missing flag to maintain data consistency.

💭 What This Experience Taught Me

Data Infrastructure Matters — great models need great data.
Usability Is Everything — make it easy for others to use.
Optimization Pays Off — from 50 → 502 images/sec!
Community Value — sharing saves others’ time and energy.

The Numbers That Made Me Proud

Metric	Value
Total Products	75,000
Valid Images	73,485 (98%)
Speed	502 images/sec
Compression	2048 → 100 dims
Variance Retained	83%
File Size	79 MB

Use Cases I’m Excited About

Visual Product Search – find similar-looking items
Clustering – group visually related products
Price Prediction – combine with text features
Recommendations – suggest look-alike products
Research – benchmark multimodal ML pipelines

Future Plans

Extract features from other layers
Try EfficientNet or Vision Transformers (ViT)
Create multimodal datasets (image + text)
Build a real-time API for on-the-fly feature extraction

My Honest Take on Feature Engineering

Sure, raw images are great for end-to-end learning,

but pre-extracted features democratize access — no GPU required, and instant modeling possible.

It’s about practicality — get to the ML part faster

Check Out the Dataset

Dataset: Kaggle – Product Image Features

Includes:

Feature extraction code
Usage tutorials
Analysis scripts
Documentation for quick start

Perfect for the Amazon ML Challenge or any e-commerce ML project.

Final Thoughts

Creating this dataset was both challenging and deeply rewarding.

It taught me how to think about scalability, optimization, and sharing ML resources with the community.

There’s something magical about seeing those progress bars fly at 502 images/sec —

knowing your work might save others days of processing time.

Technical Specifications

Parameter	Value
Model	ResNet50 (ImageNet pretrained)
Original Features	2048
Compressed Features	100 via PCA
Variance Retained	83%
Processing Speed	502 images/sec (GPU)
File Format	CSV (pandas-ready)

💬 What Do You Think?

What’s your take on feature engineering for ML competitions?

Have you ever built your own dataset like this?

Share your thoughts below — let’s talk data, optimization, and creativity!

Until next time —

Keep Building. Keep Learning.

My First NFT Creation Journey - From Zero to Digital Artist!

Anuj Bolewar — Thu, 25 Sep 2025 03:44:07 +0000

Hey everyone! Hope you're all doing great today.

So I've got something pretty exciting to share with you all - I just created my very first NFT! And let me tell you, this whole experience has been absolutely wild. I never thought I'd be diving into the world of digital art and blockchain, but here we are!

How It All Started

Picture this: I'm just casually browsing through social media (you know how it is), when suddenly this amazing artwork catches my eye. It was this super cool leopard character wearing headphones and a hoodie, sitting at a computer with all these glowing blue tech elements around it. Something about it just screamed "modern digital world" to me.

That's when it hit me - "Wait, I could totally create something like this!" I mean, why not give it a shot, right?

The Creative Process Was Actually Fun

Coming Up With The Concept
First things first, I had to decide what my NFT would be about. I've always been fascinated by the contrast between nature and technology. Like, how crazy is it that we live in a world where animals and digital tech can coexist in art?

So I went with this idea of a snow leopard - these beautiful, mysterious creatures - but placed in a completely digital environment. Kind of like asking "What if animals were part of our tech world?"

The Design Challenge
Now here's where things got interesting. I wanted to create something that looked professional but still had that personal touch. The leopard needed to feel alive, not just like some random cartoon.

I spent hours working on:

Getting those piercing blue eyes just right
Making sure the headphones looked realistic
Creating that glowing keyboard effect
Adding all those floating UI elements in the background

What I Learned About NFTs

Before starting this project, I honestly didn't know much about NFTs beyond "expensive digital pictures." But diving deeper, I discovered it's actually about ownership and authenticity in the digital space.

Think about it - we share millions of images online every day, but NFTs give creators a way to say "Hey, this specific piece is mine, and here's the proof."

The Technical Side
Creating the actual NFT was easier than I expected. Once you have your artwork ready, you just need to:

Choose a marketplace (I went with OpenSea)
Upload your image
Add a description and properties
Pay the minting fee
And boom - you're officially a digital artist!

The Challenges I Faced

Not gonna lie, it wasn't all smooth sailing. The hardest part was probably getting the lighting effects right. You know how in movies, everything glows perfectly? Yeah, that's harder to recreate than you'd think.

Also, choosing the right colors was tricky. I wanted that cyberpunk vibe without making it look too overwhelming. Blue seemed perfect because it's both tech-y and cool.

What This Experience Taught Me

This whole NFT creation process opened my eyes to so many things:

Creativity Has No Limits: When you're working digitally, you can literally create worlds that don't exist. Want a leopard using a computer? Done. Want floating UI elements? Easy.

Art Meets Technology: NFTs are this fascinating intersection of creativity and blockchain technology. It's like the perfect blend of left brain and right brain thinking.

Community Matters: The NFT community is actually pretty supportive. People genuinely appreciate good art and creativity.

Future Plans

Now that I've gotten my feet wet, I'm already thinking about what's next. Maybe a whole collection of tech-savvy animals? Or perhaps exploring different artistic styles?

I'm also curious about adding utility to NFTs - like maybe creating characters that could be used in games or interactive experiences.

My Honest Take On NFTs

Look, I get that NFTs can be controversial. Some people see them as just overpriced JPEGs, while others see them as the future of digital ownership.

From my experience, I think they're really about giving digital creators new ways to monetize their work and connect with audiences. Whether that's revolutionary or not, I'll leave up to you to decide.

Check Out My NFT!

Want to see the final result? You can check out my snow leopard NFT right here on OpenSea:
View My NFT Collection

I'd love to know what you think! Does it capture that tech-meets-nature vibe I was going for?

Wrapping Up

Creating my first NFT has been one of those experiences that's equal parts challenging and rewarding. It pushed me to learn new skills, think creatively, and step into a space I never imagined I'd be part of.

Whether you're thinking about creating your own NFT or just curious about the process, I'd say go for it! The worst thing that can happen is you learn something new and create some cool art in the process.

What do you think about NFTs? Are you planning to create any? I'd love to hear your thoughts in the comments!

Until next time, keep creating!

My Python KeyLogger Project: More Than Just Keystroke Capture!

Anuj Bolewar — Mon, 22 Sep 2025 18:41:40 +0000

Hey everyone!
I'm Anuj, and I'm super excited to share my latest project that I've been working on - a comprehensive KeyLogger system with reverse shell capabilities.
When I first started this project, I thought I'd just build a simple keylogger to learn about cybersecurity. But, it turned into something way cooler than I expected! Let me walk you through what I built and what I learned along the way.

The Spark Behind This Project .
So it all started when I was watching some cybersecurity videos and got curious about how penetration testing tools actually work. I'd always heard about keyloggers and reverse shells, but I wanted to understand them from the ground up.
You know that feeling when you see something cool and think "I bet I can build that"? That was me. I wanted to dive deep into Python networking, understand how background processes work, and get my hands dirty with some real cybersecurity concepts.

What I Actually Built
This isn't your typical "hello world" keylogger. I ended up building a complete 4-module system:

The Main Components:
keylogger.py - The brain that captures keystrokes intelligently
reverse_shell.py- A powerful client with tons of features
server.py - Command and control server
test_client.py- Testing framework to make sure everything works

Cool Features:
Works on Windows, Linux, and macOS (cross-platform was tricky!)
Complete reverse shell access
Remote screenshot capture
Smart keylogger that filters out sensitive stuff
Runs completely silently in the background

The Technical Stuff (Don't Worry, I'll Keep It Simple):
Let me show you some of the cool code I wrote. The keylogger part was actually pretty elegant:

python def on_press(key): global log try: log = log + str(key.char) # Regular characters except AttributeError: # Handle special keys like space, enter, etc. if key == key.space: log = log + " " else: log = log + " " + str(key) + " "

The reverse shell communication was where I really learned about networking:

pythondef reliable_send(data): jsondata = json.dumps(data) s.send(jsondata.encode())

def reliable_recv(): data = "" while True: try: data = data + s.recv(1024).decode().rstrip() return json.loads(data) except ValueError: continue

What I love about this is how clean the JSON communication makes everything. No more dealing with messy raw socket data!

The Learning Curve :
Building this taught me so much more than I expected:
Socket Programming: I'd never done network programming before. Learning how clients and servers communicate, handling connections, dealing with timeouts - it was like unlocking a whole new world.
Threading: Getting the keylogger to run in the background while maintaining the reverse shell connection was my first real experience with concurrent programming.
Cross-Platform Development: Making this work on Windows, Linux, and macOS was honestly the hardest part. Different file paths, different permissions, different behaviors - but so satisfying when it all came together.
File Handling: Implementing secure file transfer with Base64 encoding taught me a lot about data serialization.

Challenges I Faced :
Not gonna lie, there were some frustrating moments:

Windows Defender: It kept flagging my reverse shell (which is actually expected behavior for this type of tool). Had to add exceptions for testing.

Path Management: Getting file paths to work correctly across different operating systems was more complex than I thought.

Connection Reliability: Network connections can be flaky. I had to implement retry logic and proper error handling.

Testing: Making sure everything worked across different platforms required setting up multiple test environments.

The Features That Make Me Proud

Smart Keystroke Capture: It doesn't just dump everything - it intelligently handles special keys and formats the output properly.

**Remote File Operations: **You can upload and download files, even grab files directly from URLs.

Screenshot Capability: Using the mss library, it can capture screenshots remotely across different platforms.

Stealth Mode: Runs completely silently with no visible windows or indicators.

**Robust Communication: **JSON-based protocol with proper error handling and retry mechanisms.

Tech Stack:
Python 3.8+ (obviously!)
Libraries: pynput, mss, requests, python-dotenv
Built-in modules: socket, threading, subprocess, json, base64

Architecture:
Client-server model with JSON communication
Multi-threaded for concurrent operations
Environment-based configuration
Cross-platform file system handling

The whole thing is about 500+ lines of code spread across multiple modules, but it's clean and well-organized.

I built this to learn about cybersecurity concepts, understand how these tools work, and improve my Python skills. Always use tools like this responsibly, in controlled environments, and only with proper authorization.
If you're interested in cybersecurity, use this knowledge to build better defenses, not to cause harm.

What's Next?
Adding AES encryption to the communication
Building a web-based control interface
Implementing database storage for logs
Maybe exploring mobile platforms
Adding steganography features

Final Thoughts
This project pushed me way out of my comfort zone and taught me so much about networking, security, and system programming. There's something incredibly satisfying about seeing your reverse shell connect for the first time, or watching your keylogger silently capture data exactly as intended.

The best part? Everything is open source on my GitHub. If you're curious about cybersecurity or want to learn about socket programming, feel free to check it out, star it if you find it interesting, and don't hesitate to ask questions!

GitHub Repository: https://github.com/anujbolewar/KeyLogger

What do you think? Have you worked on any cybersecurity projects? I'd love to hear about your experiences in the comments!