DEV Community: Jeremy Sayo

[Boost]

Jeremy Sayo — Thu, 17 Apr 2025 10:02:26 +0000

Jeremy Sayo

Apr 17 '25

Machine Learning Demystified: A Practical Introduction Through a Simple Project

#machinelearning #python #programming #datascience

Comments

4 min read

Machine Learning Demystified: A Practical Introduction Through a Simple Project

Jeremy Sayo — Thu, 17 Apr 2025 10:01:08 +0000

Ever hear the term "Machine Learning" and feel a little wave of intimidation? The term "Machine Learning" often surfaces in discussions about technology, and it can sometimes seem daunting. For the longest time, "ML" felt like this exclusive club I wasn't qualified for, something reserved for data science wizards.

I was curious, definitely, but also convinced it was way beyond my reach as someone still learning the ropes of programming.

But what if I told you that you can build and run a simple machine learning model in less than 20 lines of actual learning code? I just did it, and it completely changed how I see machine learning. Stick with me, and I'll show you exactly how.

So, What Is Machine Learning, Really?

Let's ditch the jargon for a second. At its core, machine learning is surprisingly simple to understand:

Machine learning is just teaching a computer how to find patterns in data and make predictions based on those patterns — without explicitly programming every single rule.
_

Think about how you learn. If you see enough pictures of cats, you start recognizing features (pointy ears, whiskers, fur) and can identify a cat you've never seen before. You weren't given a giant rulebook; you learned from examples. Machine learning models do something similar, but with data.

From Simple Models to Large Language Models

You might be wondering — "Okay, predicting scores is cool... but what does this have to do with ChatGPT or other AI tools?"

The answer? Everything.

At its core, machine learning is about learning patterns from data. Whether it’s a small model learning how hours studied relates to scores, or a massive model like ChatGPT learning how words relate in a sentence, the principle is the same.

A large language model like ChatGPT learns how words relate to each other by analyzing billions of sentences.An LLM uses complex deep learning techniques (like transformers) to understand language and generate responses.

My Mini Project: Predicting Student Scores

To dip my toes into the ML waters, I decided on a simple, relatable goal: Predicting a student's final exam score based on their study habits. Specifically, I wanted to see if we could guess the score based on:

How many hours they studied (Hours_Studied)
How many practice tests they completed (Practice_Tests)

I started with a small, imaginary dataset. Imagine we collected this info from 10 students:

Walking Through the Code :

Okay, here's the code I used. I'll break down what each part does in plain English.

1. Imports

I imported pandas to handle our data easily (like a super-powered spreadsheet), and scikit-learn (often called sklearn) which is like a magic toolbox full of ready-made machine learning algorithms (LinearRegression) and helpers (train_test_split).

2. Sample Data

I then created a sample dataset

3. Selecting features and targets

The lines of code above tell the computer: "Look at Hours_Studied and Practice_Tests (the features, X) to figure out the pattern that leads to the Final_Score (the target, y)."

4. Splitting the data into training and testing

This is crucial! I hide some data (20% in this case, the X_test, y_test) from the model while it's learning. Then, I use this hidden data to check if the model actually learned the pattern or just memorized the training answers. Think of it like studying with one set of practice questions (training) and then taking a mock exam with different questions (testing).

5. Training the model

I chose a simple model called Linear Regression. The model.fit(X_train, y_train) line is where the computer looks at the training data and figures out that relationship. This is the core "learning" step!

6. Predicting

The predict function asks the trained model: "Based on what you learned, what score would you predict for someone who studied 3.5 hours and took 2 practice tests?"

Visualizing the Pattern

Sometimes, a picture is worth a thousand lines of code. We can plot how study hours relate to the final score, and even draw the line our LinearRegression model figured out:

This plot shows each student as a dot. The orange line is the trend our machine learning model found – generally, as study hours increase, the final score tends to increase too. The model learned this relationship from the data!

The "Aha!" Moment

When I ran this code and saw it predict a score, I had a moment of realization: _

"Wait... this is machine learning? That's it?"
_

Okay, obviously, ML can get vastly more complex than this. But the fundamental process – feeding data to an algorithm, letting it find patterns, and using it to make predictions – was right there in just a few lines of code.

You Can Do This Too! Go Demystify ML For Yourself.

If you've been curious about machine learning but felt it was too complex, I hope this little walkthrough helps. It really is possible to get started with simple projects.

Why not try it yourself?

Find a simple dataset online (like house sizes and prices, or daily temperature and ice cream sales) and try to build a predictor for it.
Think about simple patterns in your own life: Could you predict workout calories burned based on duration? Crop yield based on rainfall?

Machine learning is a powerful field, but it doesn't have to be scary. It starts with understanding the basics, and sometimes the best way to do that is to just build something, however small.

Go ahead, take that first step! You might be surprised at what you can do.

Bonus: Here is my link to the full code.
Let me know any challanges you faced in the comments below

Why I Use Flask. And Maybe You Should Too...

Jeremy Sayo — Thu, 03 Apr 2025 13:58:19 +0000

Choosing a web framework can feel like picking a side. Do you go for the all-inclusive toolkit with batteries included, or something leaner that lets you chart your own course? For me, after diving deep into building non-trivial applications – like the school exam system I'm currently working on – the choice became clear: Flask. Flask is one of the two main web frameworks for Python, the other being Django.

Flask calls itself a "microframework," but don't let the "micro" fool you. It doesn't mean "small capabilities"; it means a small, solid core that doesn't impose decisions on you. This philosophy is precisely why it's become my go-to. Here are five reasons why:

Unparalleled Flexibility (The "Choose Your Own Adventure" Framework)

This is Flask's superpower. Unlike heavier frameworks that often dictate your database layer (ORM), form handling, or authentication system, Flask steps back. Need a database? Great. For my exam system, integrating SQLAlchemy felt natural and powerful, giving me fine-grained control over my database models (Students, Exams, ExamResult) and relationships. Need robust forms? Flask-WTF integrates seamlessly, allowing for validation and easy rendering, just like we implemented for adding students or handling exam uploads. Flask doesn't bundle these; it makes integrating the best tool for your specific job incredibly easy.

Advantage: You build a tailored stack using best-in-class libraries you know and trust, avoiding framework bloat or fighting against pre-made components that don't quite fit.

Simplicity and Speed (From Zero to App, Fast)

Flask's core API is small and intuitive. Defining routes (@app.route('/view_results')), handling requests, and rendering templates (thanks, Jinja2!) is straightforward. This low barrier to entry means you can get a basic application running remarkably quickly. More importantly, its simplicity makes the codebase easier to understand and debug. There's less "magic" happening behind the scenes, making development feel more direct and controllable.

Advantage: Faster prototyping, easier learning curve, and quicker iterations as you add features incrementally (like moving from basic student CRUD to complex result processing).

Perfect for Custom Applications

Flask shines when you're building something that doesn't fit a standard mold like a generic blog or CMS. Our exam system has specific logic: handling CSV uploads, mapping names to IDs, calculating totals and rankings, and displaying results in a very particular format. Flask doesn't get in the way. Its minimalist nature means the framework's structure doesn't conflict with your application's unique requirements. You spend more time writing your application logic, less time wrestling with the framework.

Advantage: Ideal for bespoke web apps, internal tools, or systems with unique business logic where framework overhead is undesirable.

API Development Made Easy

While our current project involves HTML rendering, Flask is exceptionally well-suited for building APIs. Its simple routing and request/response handling make defining API endpoints clean and logical. Whether you're building a backend for a JavaScript frontend (SPA), a mobile application, or interconnected microservices, Flask provides just enough structure without unnecessary overhead.

Advantage: Excellent choice for building lightweight, focused APIs and microservices.

A Rich Ecosystem of Extensions

"Micro" doesn't mean isolated. Flask has a vibrant ecosystem of well-maintained extensions for almost any functionality you might need – databases (Flask-SQLAlchemy), forms (Flask-WTF), user authentication (Flask-Login, Flask-Security-Too), migrations (Flask-Migrate), and much more. These extensions follow Flask's philosophy: integrate smoothly, provide specific functionality, but stay out of your way otherwise.

Advantage: You can start simple and easily add powerful, complex features as your application grows, without sacrificing the core simplicity.

Should You Use Flask?

If you value control, flexibility, and understanding your stack from the ground up, Flask is a fantastic choice. It empowers you to make the architectural decisions and select the tools that best suit your project. It might require you to explicitly add components that other frameworks include by default, but this deliberate approach leads to cleaner, more understandable, and often more efficient applications.

For the freedom it offers and the focused development experience it enables, Flask has earned its place in my toolkit. Give it a try on your next project – you might just find it's the perfect fit you've been looking for.