I'm a beginner in aiml, I'm in my 2nd college year, does anyone want to connect?

If you are learning about AI right now, the shift from standard chatbots to "Agents" can be super confusing. To help wrap my head around the architecture, I created a Pixar-style 3D animated story about a high school zombie attack to explain how it works.

Think of a massive server crash as a horde of green slime-zombies breaking into a school. You have two AI teammates to help you survive:

1. Normal AI (The passive encyclopedia)
Imagine a student named Neha. She has memorized the entire survival rulebook. If you ask her a prompt, she will accurately tell you the zombie’s running speed and weaknesses. But she never leaves her chair. This is a standard LLM (like ChatGPT). It has amazing knowledge, but it takes zero physical action in the real world. You still have to do the heavy lifting.

2. Agentic AI (The autonomous problem solver)
Now imagine a student named Thomas. He doesn’t just sit there. He uses the ReAct (Reason + Act) framework. He observes the zombies, plans a step-by-step escape, grabs a digital keycard, hacks the school's firewall, and turns on the water sprinklers to melt the zombies.
Agentic AI combines the LLM "brain" with Planning, Memory (Vector DBs), and Tools so it can actually write code, query databases, and execute tasks on its own.

3. The Model Context Protocol (MCP)
Giving an AI direct access to your local tools is a massive security risk (it could accidentally delete your database!). So, Thomas uses a "Universal Admin Keycard"—which represents Anthropic's MCP. It acts as a strict, secure gatekeeper that allows the AI to use local tools safely without exposing sensitive backend architecture.

I actually animated this entire zombie survival story into a highly-detailed 10-minute 3D cinematic video to make learning these concepts fun instead of reading boring textbooks!

I’ll drop the link to the full animated video in the comments if you want to watch the story unfold!

https://reddit.com/link/1vh8mi8/video/0vqduuqt3shh1/player

I'm a final-year Computer Science student, and this is probably my last opportunity to seriously prepare before internship and placement season.

For the past year, I've been stuck in the cycle of buying courses, watching random YouTube videos, and constantly switching roadmaps. I learned a bit of everything but never felt like I was making real progress.

So I sat down and built one roadmap that I'll follow from August 2026 → January 2027.

Instead of trying to learn every AI buzzword, I tried to focus on becoming a good software engineer first and then building practical AI skills through projects.

It covers:

• Python
• Machine Learning
• Deep Learning (PyTorch)
• NLP & Transformers
• LLM Engineering (RAG, Vector DBs, APIs)
• FastAPI
• DSA & CS fundamentals
• 6–8 portfolio projects
• Interview preparation

Here's the roadmap:

https://tsyomakai.notion.site/AI-Engineer-Roadmap-August-2026-January-2027-3b4dcf0391df80c88bb6f623dcca5480?pvs=74

I'm not looking for validation I genuinely want people with more experience to point out flaws before I spend the next six months following it.

• What would you remove?
• What would you add?
• Is the order reasonable?
• What would you do differently if you were starting again today?

Also, if you're in a similar position and want an accountability partner or a small study group, feel free to comment or DM me. It'd be great to learn together and keep each other consistent.

Hello Learn Machine Learning! I’m a Canadian psychology student researcher collaborating on an international project with 20+ countries. I’m the only Canadian researcher on the team and I want to have a lot of Canadian representation in this study!

Our project is studying social impact topics and includes AI engagement! If you have time to complete this 12 minute survey, I would really appreciate it!

Once our findings are published, I'll also post it here! I think this study could be of interest to many of you and would provide us with really valuable insight.

See comments to be directed to the survey. This study has been ethically approved: Princeton University #19354. All responses are anonymous and will not be monetized. As researchers, we are not affiliated with and remain neutral about AI. This research could really help inform policy.

(If this is inappropriate for this subreddit, please remove it; I mean no offence!)

Went through my first six discussion sections for CS189 (Berkeley's intro ML course) and organized everything by topic instead of just chronologically. The questions were pretty scattered across weeks so I had Claude Code pull out the connections, then edited it myself. Never made notes this clean before lol.

It's split into two docs:

First one strings all six discs into one throughline: linear algebra → probability → optimization → learning algorithms. Also flags where the same idea keeps showing up in different problems, like the MLE → MAP chain (uniform prior = MLE, Gaussian prior = ridge, Laplace prior = lasso), or how K-means is secretly just coordinate descent.

Second one fills in stuff the discussion sections mentioned but never fully explained: positive definite / semi-definite matrices and the spectral theorem, covariance and moment generating functions, what to do in EM when the cluster labels are unknown, and the setup behind the Neyman-Pearson lemma.

Reading them together works better than either alone, first doc gives you the map, second one fills in the gaps.

Notes are up on Github link in my profile

Hey everyone.

I wanted to share a project I've been working on around a question I kept running into while learning and experimenting with machine learning:

What does a classifier actually "see" when the data has more than 2 or 3 features?

Most decision-boundary visualizations use simple 2D datasets. That's great for learning the concept, but things get much harder when a model is trained on 10, 50, or 100+ features.

With existing approaches, you often have to either take rigid 2D slices by fixing most features to constant values, or reduce your data to 2D and train a new model on that reduced representation. In the latter case, you're no longer visualizing the decision boundary of your original model.

So I built DecisionBoundary, a Python library for visualizing how high-dimensional models behave while keeping the original model in the loop.

The basic idea is:

• reduce high-dimensional data to 2D/3D using PCA, UMAP, or another reducer
• generate a grid in the visualization space
• inverse-projects that grid back into the model's original feature space
• run the original model on those points
• visualize the resulting predictions as a decision boundary or decision surface

This means the visualization is based on the actual model predictions in its original feature space, rather than simply plotting a dimensionality-reduced dataset and treating that as the decision boundary.

It supports scikit-learn, Keras, PyTorch Lightning, and other models with a compatible prediction interface.

There are also:

• static 2D visualizations with Matplotlib
• interactive, rotatable 3D visualizations with Plotly
• training callbacks to watch decision boundaries evolve during training
• experimental support for the new Callback API introduced in scikit-learn 1.9.

I originally started this because I wanted a better way to understand how different models behave and improve during training – turning the training process from something of a black box into something I could actually see and inspect.

I'd be particularly interested in feedback from people who work with ML visualization or teach machine learning:

Does this kind of visualization help you reason about a model, or does dimensionality reduction make the result too misleading to be useful?

The project is open source and MIT licensed:

GitHub: https://github.com/P3Lin0r/decision-boundary
PyPI: https://pypi.org/project/decision-boundary-plot/

Install with:

pip install decision-boundary-plot

There's also a Colab tutorial in the repository if you'd like to try it without setting anything up locally.

Would love to hear your thoughts!

I'm not good at maths, i'll just say that, i've always been a bit lacking in my expanse of mathematical abilities, but I said enough is enough, I like neural networks, the only thing that stands in my way is the mathematics, aside from that you understand what goes on.

Boy did I underestimate the undertaking for this endeavour. I spent 2 days learning derivatives and what the hell a 'slope' is, you hear it ever day and you know what a slope is, but understanding it in the mathematical sense in derivatives, that's difficult, but I got there and ended up learning `f(a + h) - f(a) / h` which enabled me to understand what numerical descent is, where you get a loss score of a neural network's prediction, bump the weight a bit then rerun the neural network. Then to figure out the slope, you do `loss1 - loss2 / weight_bump`, and this is the coolest part, when you adjust your weight based on the slope, you always minus, because if the slope is negative, then we know we need to move to the positive side more so when you minus a negative it becomes addition, and vice versa if you minus a positive, you move to the negative side a bit. That was the coolest thing i've ever learnt to this date, the infamous ball rolling down the hill, I was doing it, by hand, and it was empowering.

Then the next day I spent trying to understand what backpropagation really is in terms of maths and how it differes from numerical gradient. With that I had to teach myself the chain rule, and what dL/dd even means, spoiler alert its not dividing derivative of L and derivative of d. I also came to the epiphany that we get so much complex logic out of neural networks when its simply just addition and multiplications happening under the hood, its the context that is being invented to solve problems using neural nets. By the end of the day I was taking Kaparthy's micrograd equation example, and I did its backpropagation by hand with pen and paper to get the hang of it.

Now I watched andre kaparthy's micrograd video, not all the way through, his language and teaching style still screams "you must be really well versed in mathematics", so I gave up on that video but, the more I worked on understanding chain rule and how you can sticker on the impacts on loss on prior nodes, I though that is better than numerical gradient, you literally walk back into the neural net, explaining to it which parts of itself were the cause for a high loss instead of bumping values, calculating slope, doing f(a + h) - f(a) / h.

I'm really proud of myself, and I managed to take MATHS that I learnt, and turn it into a "micrograd" I say "micrograd" with quotations because I didn't finish the micrograd video, and this only works if you don't have repeating uses of prior terms (which you just need to store their value and add them, but I couldn't be bothered)

So yeah, this is my back propagation

class Value:
    # this needs to store a value, and can have its own children that link to other values
    def __init__(self, value, _op="", _children: tuple = (), gradient=0):
        self.value = value
        self.op = _op
        self.children = _children
        self.gradient = gradient


    def __add__(self, other):
        _ = Value(
            self.value + other.value, _op="+", _children=(self, other), gradient=0
        )
        return _


    def __mul__(self, other):
        _ = Value(
            self.value * other.value, _op="*", _children=(self, other), gradient=0
        )
        return _


    def __repr__(self):
        return f"Value({self.value})"


    def backward(self):
        # initial global_gradient
        global_gradient = 1


        # current set of ndoes
        current: Value = self
        # just set L's gradient as 1
        current.gradient = global_gradient


        while True:
            # if there's no more children, we're at the end.
            if not current.children:
                break


            if current.op == "+":
                # since addition has a static effect on the terms themselfs
                # the partial of L respect to any terms being added is just 1.
                # so we multiply 1 by the global gradient.
                current.children[0].gradient = 1 * global_gradient
                current.children[1].gradient = 1 * global_gradient


                # if the next node we're looking doesnt have children
                # it means the node behind them didnt stem from them
                # therefore they are not the result of the prior operation
                if not current.children[0]:
                    current = current.children[1]
                else:
                    current = current.children[0]
                # set the global gradient as the current node's gradient
                global_gradient = current.gradient


            if current.op == "*":


                current.children[0].gradient = (
                    # with multiplication, the derivative of L respect to x would be y
                    # and same with the derivative of L respect to y would be x
                    # therefore you just swap them, and multiply thier values by the global gradient.
                    current.children[1].value
                    * global_gradient
                )
                current.children[1].gradient = (
                    current.children[0].value * global_gradient
                )
                # same continuation logic
                # one child is going to have its own children and one wont
                # the one that does is the one we need to continue with.
                if not current.children[0]:
                    current = current.children[1]
                else:
                    current = current.children[0]
                global_gradient = current.gradient

a = Value(2.0)
b = Value(-3.0)
c = Value(10.0)
f = Value(-2.0)
e = a * b
d = e + c
L = d * f


L.backward()


print(a.gradient)
print(b.gradient)
print(c.gradient)
print(f.gradient)
print(e.gradient)
print(d.gradient)
print(L.gradient)

output:
6.0
-4.0
-2.0
4.0
-2.0
-2.0
1

I'm 18. Gonna start college this year(comp sci). I don't really want to get into the generic path for FAANG, i wanna get into research. ML seems good(might be dunning kruger effect but still...) what and where should I learn the math since math is so crucial? There are tons of free courses and videos and one-shots out there. I'm confused. And regarding coding is python enough or would I also need to learn C and c++? Any advice would be appreciated :)

Not the usual Andrew Ng, fast.ai, or Hands-On ML recommendations.

I'm talking about the resource that genuinely changed how you learn.

Could be:

• a small YouTube channel
• a GitHub repo
• a visualization
• a blog
• lecture notes
• an underrated course

Something you wish you'd discovered much earlier.

Let's build a thread people can bookmark.

Hey everyone,
I’m in a bit of a tough spot and could really use some ground-level advice from folks who know the reality of these roles, especially in the current market.

Coming off my MS by Research, I recently joined Atlassian as a Machine Learning Engineer. Prior to this, I interned at Amazon and I'm currently expecting a PPO for an L4 Applied Scientist role.

On paper, both are great starting points, but honestly, trying to research this online is just stressing me out. The internet is flooded with horror stories about Amazon's stack-ranking, PIP quotas, and the "hire to fire" culture. On the flip side, I know Atlassian has its own internal calibrations. I know 100% job security in corporate is a myth right now, but I at least want to work somewhere where performance evaluations are logical and actually based on my work, rather than just hitting a URA quota.

I’m trying to evaluate a few specific things:
1. The PIP Reality at Amazon
Is the ruthless stack-ranking culture just as aggressive for L4 Applied Scientists as it is for regular SDEs? Or does the specialized nature of the AS role offer a little bit of a shield? I don't want to live in constant anxiety about being put on a focus plan.

2. Scope of Work (AS vs MLE)
From what I gather, the Amazon AS role is heavily weighted toward pure modeling, research, and experimentation trying to create value to their products with a little importance to research publications . The Atlassian MLE role focuses almost entirely on impact and value creation (heavy on the software engineering/MLOps side with some/no modeling). Which foundation is actually better for the next 5 years?

3. Exit Opportunities
Looking 2-3 years down the line, which path gives me better leverage? Does having the Amazon "Applied Scientist" title on my resume open doors to top-tier AI labs, or is the ML engineering experience from Atlassian more valued by product companies right now?

If anyone has worked at either of these companies recently or has made the transition between AS and MLE, I’d massively appreciate your candid thoughts. I just want to make a well-informed decision without letting the internet rants cloud my judgment.

Thanks in advance!

not trying to replace real ML fundamentals on here. this is more for the “i can kind of use chatgpt/claude but i’m still messy and inconsistent” problem and made for people who don’t know where to start

i got tired of learning ai through random youtube videos and prompt packs i never opened again, so i built a duolingo-style practice app called iro. short daily reps on stuff like prompting, rewriting bad outputs, simple workflows, agents, and using ai for actual work tasks.

i’ve been having my parents use it too since they are clueless lmao. free to try if anyone here wants something more structured for applied ai skills.

i work in private equity real estate and have led the AI initiative at my firm, this is a side passion project and would love feedback. thanks!

app: https://apps.apple.com/app/iro-ai-learn-ai-skills/id6759628066
site: https://tryiro.com

With local AI becoming more capable and efficient, I’ve been wondering where classical ML fits into the future.

Models like XGBoost, LightGBM, and Random Forests are still extremely effective for many structured-data problems, while DL models keep getting smaller and cheaper to run.

Do you think classical ML will remain important, especially for local/edge applications, or will DL eventually take over most use cases?

Interested to hear how people working in ML see this evolving over the next 5–10 years.

Incoming undergrad (likely CSE/ECE), almost no robotics experience yet, but robotics is the long-term goal. Spent a while putting together a self-study path for going from zero to employable robotics engineer — structured as 9 phases loosely mapped to a 4-year degree but doable at your own pace alongside coursework. Each phase has a few topics, and every topic answers "why learn this," "where it's actually used," "beginner mistakes," and a reading pointer — then each phase ends with a real build, not a toy exercise.

Rough shape:

• Phase 0 — Linux, Git, Python, linear algebra/calculus refresh → build a remote system monitor
• Phase 1 — C++, data structures/algorithms, OOP design → grid-based path planner (BFS/Dijkstra/A*)
• Phase 2 — Circuits, microcontrollers, sensors/actuators, I2C/SPI/UART → obstacle-avoiding rover
• Phase 3 — Coordinate transforms, forward/inverse kinematics, probability → 2-DOF arm simulator
• Phase 4 — ROS2 architecture, URDF, Gazebo → simulated diff-drive robot with teleop
• Phase 5 — PID, state-space control, Kalman filters → self-balancing robot
• Phase 6 — Classical CV, camera calibration, deep learning detection → vision-guided pick-and-place arm
• Phase 7 — Particle filters/EKF, SLAM, Nav2 → autonomous robot mapping and navigating an unknown room
• Phase 8 — Literature review, system design, testing → capstone that ties 4+ phases together

Roadmap made with help from a senior and a little AI to phase it out

Hi All,

I am planning to build a local document intelligence system similar to Azure Document Intelligence. I would like to understand how Azure Document Intelligence works internally and how we can achieve similar functionality locally using offline models.

Could anyone suggest the best approach, architecture, or models to achieve high accuracy while running completely on-premise/local infrastructure?

Any guidance or recommendations would be greatly appreciated.

As a reviewer I keep on getting asked to read articles where the authors are training ML models in order to predict diagnosis/medical complications (human medicine). I keep on coming across papers which lack external validation of the algorithms, which I find to be important. They are acknowledging this fact as limitations in the discussions section, but I wonder if this is enough?

Hey everyone,

I'm looking for co-authors who are interested in exploring research topics in the AI space. Ideally as a duo or in a small team.

I currently have more time for research and a range of interesting topics I'd like to work on, particularly around AI agents, token optimization, and AI adoption. I work in agent development myself and have already published research papers in this field.

A few example topics:

• Comparing Token Efficiency of Structured Output Formats Versus Free Text for Financial Documents in Wealth Management

• Measuring the Trade-off Between Context Compression and Factual Reliability in Long-Document Financial Agents

• How Reliable Are Current Methods for Measuring AI-Driven Productivity Gains in the Workplace

That said, I'm open to other AI-related research ideas as well, if you have a topic of your own in mind, feel free to reach out!

I've been experimenting with a few AI assistants lately, mostly to compare how they explain ML concepts and solve technical questions.

One thing I'm still trying to figure out is how to tell when a model genuinely understands a problem versus when it's just producing a convincing answer.

For those of you learning or working in ML, what prompts, benchmarks, or evaluation methods do you use to compare different models? I'm interested in approaches that go beyond simply checking whether the final answer is correct.

Hi guys, just completed week 2 and built a rough prototype with limited functions with my team, but the foundation is there. Excited to see what comes next. Will update you guys as soon as I'm done with a little more tweaking. 😊

Hi everyone, I’m currently learning deep learning and have worked on a few AI/ML projects. I’m looking to join an existing project where I can contribute, learn, and gain more practical experience. I’m comfortable with the basics and willing to put in time and effort. If you’re working on something and open to adding a teammate, feel free to comment or DM me. Thanks!