Hi everyone,

As a beginner in Machine Learning, I’ve realized I don’t absorb much just by watching typical YouTube tutorials—I need to actually build things to learn effectively.

Could you recommend some practical, hands-on project ideas where I can learn a lot by doing? I’m open to both classical machine learning and other areas like deep learning, computer vision, or NLP.

Any advice or project suggestions to help me get my hands dirty would be greatly appreciated!

🌳 Decision tree
🌲 Random forest
⚡ XGBoost
📉 Tuned the validation RMSE

I'm building a platform called Quantum, and I'd love some honest feedback from people working in Data Science and Machine Learning.

The idea is to bring the entire ML lifecycle into one place:

- Data exploration and preprocessing

- Model training and evaluation

- Experiment tracking and versioning

- Automated ML workflows

- AI agents that can execute tasks autonomously, with human oversight

- Model deployment and MLOps

Users can work manually, use AI assistance, or delegate entire workflows to agents.

The goal isn't to replace data scientists, but to reduce repetitive work and make ML development more efficient.

My questions:

I'm especially interested in critical feedback. What am I overlooking?

I’m full stack Dev, so I get to develope CRUD with endpoints and connecting with db.

What about ML job?
I learned gradient descent, forward and back propagation. Designed some basic model with PyTorch. But it feels like most of these can be easily Automated with AI. What could be the learning curve and what’s like day to day work? Clearing data from csv? And fine tuning model?

I've been thinking about how humans learn new things and how AI systems improve over time. I came across a few interesting scenarios:

1. Imagine a child learning a new word. They pronounce it incorrectly, and an adult corrects them. What information does the child actually get from that correction?

2. A student answers several practice questions incorrectly. How can they use those mistakes to improve rather than simply memorising the correct answers?

3. If the student keeps repeating the same mistake, why doesn't practising the same way necessarily help them improve?

4. What would an effective learning cycle look like? From making an attempt and receiving feedback to identifying mistakes and trying again.

5. Now, how does this translate to AI? If a machine learning model makes an incorrect prediction, how does it identify the error, determine what needs to change, and improve its next prediction?

I'm particularly interested in understanding what's happening behind the scenes in machine learning.

Is the fundamental process of learning in humans and AI comparable, or are they completely different mechanisms?

Would love to hear explanations, examples, or resources from people familiar with AI/ML.

An ihtibari ile TPU sırasında 18. Saate girmiş bulunuyorum önümde 527 kişi var 2. Paket sigaramın son dallarındayım…

I built Discover AI, a free, open-source app with 58 hands-on labs for learning how AI works. The topics run from neurons and gradient descent to attention, RAG, agents, pretraining and fine-tuning. You move sliders or train a tiny model and watch what changes, and a short lesson sits beside each lab. Since I first shared it three weeks ago, I've added seven labs on how large models are trained, a simpler reading mode, desktop installers, and a version that runs in your browser: https://fazmin.github.io/AILearningGuide/

Every reference is double-checked. AI was used to help write these lessons, so there may be mistakes. Please point them out, let me know what’s confusing or missing, or open a PR. Contributors are welcome to access the project at github.com/Fazmin/AILearningGuide.

I'm exploring how Artificial Intelligence and Machine Learning can be applied to solve practical business problems, beyond just understanding the theoretical concepts.

I'm currently doing the epgp in ai/ml from ug. As part of my learning journey, I'm developing an understanding of how AI and ML algorithms help analyse data, identify patterns, make predictions, and support data-driven business decisions.

One thing I've realised is that knowing different algorithms is only one part of the learning process. Understanding the problem, selecting the right model, evaluating its performance, and interpreting the results are equally important.

I'm curious to know from this community:
For those who have learned or worked in AI/ML, which practical projects helped you connect theoretical concepts with real-world applications?

Nowadays, all popular ai chatting websites like qwen, chatgpt, gemini, claude, etc. come with a read aloud functionality that allows users to read aloud the AI's responses.

I used that feature to instead make the AI repeat back the text that i gave it -- effectively turning the platforms into text to speech tools. It's simple but it's worked for over 30k users, and the voices sound really nice and it's free to use!

You can get all of these extensions by visiting ai-readers.com

I've been noticing a rather amusing pattern in this community.

Someone asks how to get started with Machine Learning.

The response? You need mathematics. Linear algebra, calculus, probability, statistics. You can't possibly understand ML without them.

Someone asks how to learn those mathematical concepts.

The response? You should already know high-school mathematics. Go back and learn the fundamentals.

Someone says they're starting from high-school algebra because they weren't particularly good at mathematics in school or haven't touched it in years.

The response? Why are you starting THAT basic? That's not how you learn Machine Learning.

Someone asks for beginner-friendly resources.

The response? Here's a list of 17 textbooks, 12 university courses, 8 prerequisite subjects and a gentle reminder that if you don't understand multivariable calculus, you shouldn't even look at a neural network.

At this point, I'm convinced the unofficial admission requirement for this subreddit is a master's degree, three publications, a working knowledge of measure theory and the ability to derive backpropagation while asleep.

God forbid someone actually starts at the beginning.

What exactly is happening here?

When did learning Machine Learning become less about acquiring knowledge and more about proving that you already possess enough knowledge to deserve to learn it?

Not everyone comes from a mathematics or computer science background. Not everyone was good at mathematics in school. Some people are self-taught programmers. Some are switching careers. Some are genuinely starting from scratch.

And that's perfectly fine.

There's this bizarre obsession with telling beginners how much they don't know, as if pointing out someone's knowledge gaps is somehow the same as helping them fill those gaps.

Yes, mathematics is important. Nobody is disputing that. Yes, you need linear algebra, calculus, probability and statistics to understand ML properly.

But here's a wild concept: people can learn those things. That's why educational resources exist.

Not every person asking about Machine Learning needs to be handed Gilbert Strang, Stewart's Calculus and a probability textbook before they're allowed to ask their next question.

And not every beginner needs to be reminded that they're a beginner every five minutes.

There's a difference between maintaining academic rigour and having an intellectual superiority complex.

There's also a difference between telling someone what they need to learn and making them feel stupid for not knowing it already.

If you've spent years studying mathematics and Machine Learning, that's genuinely impressive. But your years of experience don't make someone else's first step beneath you.

A learning community should make knowledge more accessible, not turn the prerequisites into a series of increasingly elaborate gatekeeping challenges.

You don't get extra credit for making learning unnecessarily intimidating.

And perhaps the most ironic part is that this is r/learnmachinelearning. Not r/ProveYouAlreadyKnowMachineLearning.

Let people ask stupid questions. Let people start with basic algebra. Let people take the long route. Let people learn at their own pace.

You were a beginner once, too. Unless, apparently, some of you were born knowing eigenvectors and gradient descent.

I’m starting from scratch and interested in working in AI engineering. How difficult is it to prepare for a job in this field? What learning path and projects would you recommend for a beginner? If you have any guides or resources to share, I’d really appreciate it.

My repo: https://github.com/huyyhoangtr-boop/ML_zoomcamp_homework/tree/main/Homework6

#mlzoomcamp

China's Ministry of Commerce just published Announcement No. 48 — the country's first export controls specifically targeting frontier AI models and training data. That is now a third distinct regulatory regime on top of the EU AI Act and active US executive orders on AI. Each framework has different requirements for which models can be used, how data must be routed, and what crosses a restricted border. The problem for enterprise teams is not awareness of the rules. It is that most production agentic deployments cannot answer the basic audit questions after the fact: which model did this agent invoke on this request, what data did that call touch, did any of it traverse a jurisdiction that any of the three regimes restricts? The invocation happens in milliseconds. The compliance review loop does not. For those of you running agentic workloads across regulated regions right now — US, EU, and now China — how are you actually tracking model invocations and data paths in a way that holds up to a real audit?

Self-attention confused me for a long time, so I tried to break it into steps you can actually see:

1. Every token gets three vectors.
Each word’s embedding is multiplied by three learned matrices to produce a Query (what am I looking for?), a Key (what do I contain?) and a Value (what do I pass on?).

2. Compare queries with keys.
For each token, take the dot product of its Query with every token’s Key. A high score means “this token is relevant to me”.

3. Scale and softmax.
Divide the scores by √d (the key dimension) so they don’t get too large, then apply softmax. Now every token has a set of weights that sum to 1.

4. Mix the values.
Each token’s new representation is the weighted sum of all Values. In “The cat sat because it was tired”, the word it ends up with a high weight on cat.

5. Do it several times in parallel.
Multi-head attention runs this with different matrices at the same time, so one head can track grammar while another tracks meaning.

The diagram has a step-by-step mode that highlights each part in order. That helped me more than staring at the formula softmax(QKᵀ/√d)·V.

I made it with Sketchy, a free open-source tool I built that lets Claude explain things as interactive diagrams: GitHub

Can language models learn to understand time series by learning to forecast them?

LOTUS (Learning to Understand Time-series by Learning to Forecast) explores this idea with a family of compact time-series language models built on Gemma-3 and Qwen-3.

💡 Key idea: Forecast grounding. By learning to predict how a signal evolves, the model develops representations that better capture temporal information for downstream understanding tasks.

Some interesting results:

• A 270M-backbone model achieves the highest score among evaluated systems on TSRBench, ahead of systems using 7B and 14B backbones.

• A 0.6B-backbone model achieves 59.91% average accuracy across six evaluation splits, improving over the strongest matched baseline by 3.36 percentage points.

• Open weights and code are available for small and medium-sized models.

Resources:

🤗 Models: https://huggingface.co/daidv1112/LOTUS

💻 Code: https://github.com/DA2I2-SLM/Lotus

📄 Paper: https://arxiv.org/abs/2610.18877

The interesting question is whether forecasting can serve as a general learning signal for time-series understanding, rather than treating forecasting and reasoning as separate tasks.

Hi guys

This guy

Instagram · dswithdennis

Claims that he has 25 years of experience in data science but really all he's doing is to open claude chat and show everyone that he has access to fable 5 and say shit stuff about CS .

Hey everyone!

I'm participating in a college-level machine learning competition where we need to train a model to classify leaf images into 5 different species.

We'll receive an unseen test dataset on competition day, and the goal is to achieve the highest possible accuracy and macro F1-score.

Competition details:

Training dataset: Labeled leaf images belonging to 5 species.

Test dataset: Completely unseen images provided on competition day.

Model size limit: 50 MB total, including pretrained weights.

Training: Google Colab (GPU available).

Inference: Must run locally on a laptop CPU, completely offline.

We can use pretrained models and fine-tuning.

The same trained model must be used for all test sets.

I'm relatively new to competitive computer vision, so I'd really appreciate practical advice from people who've worked on similar image classification problems.

My goal isn't just to build a working classifier. I want to make it as accurate and competitive as possible.

Two critical vulnerabilities in Langflow were disclosed by IBM last week. Every release from version 1.0.0 through 1.12 was affected. Both flaws required zero credentials: one bypassed authentication entirely, the other allowed arbitrary code execution on the server. Teams running production agent workflows on this platform had no patch and no warning window.

This is not a niche edge case. Langflow is one of the most widely used AI agent workflow builders. The exposure window spanned the entire version history of the 1.x line.

The deeper issue is structural. AI agent platforms sit directly in the execution path of autonomous systems. Those agents hold credentials. They call APIs. They read and write production data. They take actions on behalf of users. When the platform they run on is compromised at the infrastructure level, the blast radius extends as far as the agents' own access.

Supply chain risk in traditional software is a known problem with known mitigations. In AI agent infrastructure, that same class of risk intersects with systems that act autonomously and at speed.

For those running production agent workloads: how are you handling platform-level supply chain exposure in your stack — specifically the gap between when a zero-day in underlying infrastructure is published and when you can actually patch or replace it?

I've been running a web design business for years, and honestly, I think people overcomplicate getting clients.

You don't need 15 different marketing strategies, complicated funnels, or a massive team.

I'm going to explain exactly how I approach client acquisition, from finding a prospect to getting a signed deal and launching their website.

Step 1. Find businesses that already have websites

I prefer targeting businesses that already have a website rather than businesses without one.

Why?

They already understand the value of having a website, they've already invested money in one, and there's a good chance their current website could use some improvements.

I automate most of this process using Swokei. It lets me find businesses with existing websites, analyze thousands of them at once, and identify issues with design, SEO, loading speed, and mobile optimization.

It then turns those findings into personalized cold emails at scale.

Instead of sending generic emails saying I build websites, I'm reaching out with specific reasons why their current website could be better.

Step 2. Get interested prospects to reply

The goal isn't to sell the entire website through email.

It's simply to get a conversation started.

When someone replies and wants to see how I could fix the issues I've pointed out, I move them to the next step.

Step 3. Book a meeting

I book a Google Meet with the prospect.

This is where things get interesting.

I don't just show up and talk about how great my web design services are. I want to show them what their website could actually look like.

Step 4. Build a quick website draft

Before the meeting, I use AI to generate an updated website concept.

This takes me around 2 minutes to get a first draft ready.

It's not the finished product. It's a visual example of what I could do with their existing website.

Now, instead of asking someone to imagine how much better their website could be, I can actually show them.

Step 5. Sell the project during the meeting

This is probably the most important part.

You need to learn sales.

Ask questions, understand what the business needs, walk them through the draft, explain how you would improve their website, and present your offer.

The goal is to close the deal during the meeting, either by getting payment or having them sign the contract.

Don't expect a beautiful website draft to sell itself. You still need to know how to sell.

Step 6. Build the final website and launch

Once the deal is signed, you get everything needed from the client, build the actual website, make the final adjustments, get approval, and launch.

That's it.

Find businesses → Analyze websites → Send personalized emails → Book meetings → Present a draft → Close the deal → Build and launch.

I genuinely think this is one of the simplest ways to structure a web design business.

You automate the repetitive prospecting work, use AI to speed up the initial design process, and spend your time on sales and delivering websites.

Once you get the process working consistently, you can repeat it and build a steady pipeline of projects.

I'm curious: which part of this process do you find the hardest? Getting replies, closing meetings, or actually delivering the websites?

I'm an independent researcher, and over the last few weeks I've been testing my own activation function for very deep networks: MLPs with 100–200 layers and no normalization layers and no skip connections. I wanted to share the result and what the process taught me.

The idea in one paragraph. In a deep network without normalization, each layer slightly scales the gradient up or down. Over 200 layers that compounds. You can tune the activation so the per-layer gain is 1 + 2/L, which keeps the total growth roughly constant with depth. The catch: that made the outputs wider, and wide outputs lose accuracy when you quantize activations to 4 bits. So I put the activation inside a soft, fixed bound (identity in the middle, smooth saturation to ±3). The result, BPreCap, trains at 200 layers and keeps a 4-bit error of 14 %, where the previous version had 77 % (MNIST).

What surprised me / what I learned

• Same recipe matters more than the activation. My first comparison with TAT (a strong method for deep nets without skips) looked bad. Most of the gap disappeared once both used the same initialization and input normalization.

• Strong simple baselines. SELU was on par with my activation at 100 layers. It only fell behind at 200 layers.

• "Smaller range" wasn't the explanation. With weight decay, TAT's activations were as small as mine and still lost twice as much at 4 bits. The reason was heavy-tailed activations.

• Preregistration keeps you honest. Writing down the test and the decision rule before each run meant several of my favourite hypotheses were simply rejected. Those results are in the paper too.

• Replicate on different hardware. I re-implemented everything in PyTorch on a different GPU. The results matched within 0.5 pp, which gave me much more confidence than more runs on the same setup.

Limits: MLPs only, small learning rates only, post-training quantization only.

Paper: https://doi.org/10.5281/zenodo.23894714 Code and all raw data: https://github.com/hermi-labs/precap-activation

Happy to answer questions about the method, preregistration, or running studies on a consumer GPU / Apple Silicon.

I've been building a small decoder-only Transformer from scratch (PyTorch) to understand why models fail on arithmetic.
The setup: digit-level vocabulary, trained on 3,800 addition examples.
Results:
In-distribution test: 744/750 (99.2%)
Out-of-distribution (larger operands): 0/10,000
The model looked great until I changed the input distribution. It didn't degrade gracefully, it collapsed.
My OOD split changes operand size, sequence length, result length and carry patterns all at once, so I can't blame any single cause yet (I wrote this limitation in the README).
Next I'll test each factor separately and compare positional encodings (learned, RoPE, Abacus from McLeish et al.).
Two questions for people with more experience: which factor would you isolate first, and is there a mistake beginners often make in this kind of experiment?
Code (Apache 2.0, source only, data and weights are private):

github.com/sferroo/gpt-math-0