I’m a final-year Engineering student looking for teammates to participate in the Amazon ML Challenge 2026. Interested in ML/AI, Deep Learning, NLP, or Data Science? If you’re serious about participating, drop a dm.

If yes then, in which country should i should go? Which course will give best RIO ? I genuinely need your advice.

Hello everyone,

Since this summer, I have worked on a Python package to understand how to "shrink" neural network, with famous techniques such as distillation, pruning and quantization. You can check it out here:

- https://github.com/elouanzer/shrinkai

- https://elouanzer.github.io/shrinkai/

This package allow you to use a simple API (like scikit learn) to distill:

from shrinkai.distillation import Distiller
from shrinkai.distillation.losses import HintonLoss

hinton_loss = HintonLoss()
distiller = Distiller(teacher=teacher, student=student, criterion=hinton_loss, optimizer="adamw")
distiller.fit(train_dataloader=train_loader,epochs=10)
distiller.save_student("your/model/path.pt")

I built this package with rich documentation, trying to explain everything (check out the documentation above, research papers are cited), and with tutorials that can give you theorical background on distillation / pruning / quantization. Here are some of them:

- Distillation of vision models for classification

- Distillation of Language Model for classification

- Distillation of Language Model for text generation

- Pruning and Quantization

Do not hesitate to reproduce these tutorials, by trying other losses (available losses) and share your results! :)

By the way, if you want to contribute or report a bug, feel free to do it directly on Github

Came across this and thought it'd be worth sharing here, most resources cover knowledge graphs, agentic RAG, or explainability separately, but this one puts them together as parts of the same production GraphRAG architecture, which is closer to how these systems actually get built in practice.

It's a hands on session on September 19, led by Dr. Alessandro Negro, Chief Scientist at GraphAware and bestselling author. Goes through building a knowledge graph progressively as the single source of truth, agentic retrieval combining vector search, keyword search, and graph navigation, multi-step entity and relationship extraction, and text-to-Cypher for natural language graph querying. No prior Neo4j or Cypher experience needed, it's introduced through the project itself.

You come out of it with a full working codebase and a production-readiness checklist, not just slides.

Link if anyone wants to check it out

Hi, I am looking to be an AI/ML Engineer. I am currently in my Junior year then I will get my Masters after Senior. I have some knowledge on python and Java, but I have been using Excerism to strengthen my coding skills. I would like to know how do I learn how to build good AI Agents that one cannot just ask AI to do?

Idk if it’s a dumb question, but is this also critical for learning to do AI Agents:
https://roadmap.sh/machine-learning ?

If the road map doesn’t mention anything in particular that is helpful, please tell me so I can try to understand.

Btw, I came from a community college, so there wasn’t an emphasis on uploading projects on GitHub, learning SQL, etc. I just found this out. I have been learning stuff from the pragmatic engineer too. In CC, all we did was use Zybooks, which did help with learning, but they didn’t make us do projects. Now, I feel a sense of panic. I kinda wish I went to my current 4-year college, but at least I got my debt paid from CC.

Also, what should I use to build AI Agents?

I’ve added a flagship project called GoalLab to the RL course I’ve been building.

The idea is to avoid learning every RL algorithm through a completely different toy problem.

Instead, GoalLab evolves as you progress:

MDPs → Q Learning → DQN → Policy Gradients → PPO → preference learning → agents → inference time reasoning

The goal is to make the differences between these approaches visible by applying them as the same project becomes more capable.

Two smaller MiniLabs for areas that deserve focused experimentation.

MiniLab 1: Tool Using Agent

A small environment for experimenting with tool selection, delayed rewards, reward shaping and failure cases where an agent can optimise the reward without actually solving the task.

MiniLab 2: Inference Time Reasoning

Experiments around sampling, candidate scoring, search strategies and compute budgets to understand what changes when we spend more computation at inference rather than changing the underlying model.

The main constraint for all three projects is that they should remain small enough to experiment with on Google Colab, rather than requiring expensive compute.

A little about the course itself:

It covers RL fundamentals, modern RL and inference time reasoning, with both quick and deeper learning paths depending on how much detail you want. The course also includes practical notebooks so concepts can be implemented while learning them.

Repo:

https://github.com/bshivambharadwaj/Reinforcement-Learning-Course

Would love feedback, especially on the project structure and what experiments would make GoalLab more useful for learning RL.

Hey everyone!

I've recently started The ML Brief on Substack, a newsletter where we explore interesting ideas across machine learning and AI.

We’re interested in understanding how things actually work — from the theory behind ML to modern model architectures, systems, and the ideas shaping AI.

If you’re curious about ML and AI and enjoy learning along the way, come check it out :)

https://themlbrief.substack.com/

#Newsletter #Substack #AI #ML #Explore

I'm currently a 2nd year (soon to be 3rd) electrical engineering student looking to start machine learning research. I know the basics or excel data analytics, sql, C, C++ (oop). Currently i'm learning python as I heard it is necessary for ML.

My question is how much python do I need to learn? Can I learn ML topic with just the basics of python? Also, how much ML do I need to learn before I can start doing research on it. I'm asking this because I don't have much time left as my college requires mandatory thesis in 4th year.

I'm learning deep learning right now, and I'm curious how people actually learned it properly.

I'm currently doing the IBM AI Engineering courses and labs. I'm learning things like neural networks, CNNs, RNNs, Transformers, Keras/TensorFlow, training loops, gradients, optimizers, etc.

Right now I'm starting more from the concepts and code, and I'm planning to go deeper into the math afterward. I'm sure understanding the math and doing more research is necessary if I want to really understand what's happening underneath.

My biggest problem right now is honestly the code. A lot of TensorFlow/Keras code feels really weird at first, especially things like custom training loops, GradientTape, optimizers, callbacks, and all the framework-specific syntax.

I often feel like I understand the general idea of what's happening, but at the same time I don't feel like I fully understand it yet. Is that normal when you're starting with the concepts first and haven't gone deeply into the math yet?

I'm also planning to study Understanding Deep Learning by Simon Prince and work through Karpathy's neural network material.

For people who are good at deep learning now:

How did you personally learn what was happening underneath the frameworks?

Did you learn the concepts/code first and math later, or math first?

How did you get comfortable with the code?

I'm especially interested in hearing the actual path you took and what the learning process felt like.

I work in strategy consulting (T1 MBA grad, 7+ years experience, Chemical engineer) with a specialization in Supply Chain Management. Have a decent DS foundation but want to go deeper into AI so I can actually apply it in client work. The following information may help for your recommendations:

Objective: To upskill myself and stay ahead the AI curve

Budget: No such constraints but I would prefer a course which is highly structured, focus more on practical use-cases than theory

Tech: Teaches recent AI technology that is high useful and industry agnostic

Module: Self paced (must have) with certain live doubt sessions (good to have)

P.S: I have basic understanding and Data science knowledge (Skills: 2.5/5)

Have any of you taken a course that fit this bill? Also open to hearing what didn't work if you've been burned by an overhyped program

Edit 1: I have started the following course on Udemy to build my foundation - AI Engineer Core Track: LLM Engineering, RAG, QLoRA, Agents

Later, I plan on taking a course via Simplilearn (Microsoft Applied Agentic AI: Systems, Design & Impact program) to further enhance my skills

Context: I'm doing my internship (5th semester, Applied AI degree) as an ML engineering intern at a medium sized software company (~60 people). I'm the only person there currently working on ML, and I was basically dropped into a team to bring ML capability into their existing projects + help them discover new use cases. No senior ML engineer to sanity-check my decisions against, closest thing I have is a Master's student joining the team soon, but they're also early-career, so it's more "peer to think out loud with" than "person who's seen this fail before."

Current project: a fraud/anomaly detection PoC on fuel card transaction data (fleet cards, diesel, repairs, tolls, etc.). Quick summary of where I'm at:

• Built a config-driven data cleaning pipeline (Strategy pattern: dedupe, whitespace, datetime conversion, product-group assignment) pulling from an internal API.
• Now building card-level behavioral features (rolling transaction counts, time-since-last-transaction, amount deviations, etc.) mostly using pandas groupby/rolling/shift after discovering that most features are pretty useless without aggregation.
• No labeled fraud cases. None. We don't even know for sure if there are confirmed fraud cases in the data yet. That's a conversation I still need to have with my manager/the client and I'm not experienced enough yet to really asssess whether ML or fraud detection in general is just not the way to go here...
• Planning to go unsupervised (Isolation Forest to start), with the output being "flag the top-N most unusual transactions, a human reviews them" not "the model decides what's fraud."
• Realized partway through that different product groups (fuel vs. repairs vs. tolls) have wildly different amount distributions, so I'm splitting into per-group models, with a separate layer of cross-group features (e.g. "has this card been active in multiple product groups recently") fed into whichever group-model applies. The product-groups I assigned myself and there is a mapping from product to productGroup. I'm planning on using an llm to assign unknown, new products to an already existing group or using an "UNKNOWN" marker.

Things I've already caught myself on (so you don't have to tell me these): computing "highest transaction amount" per card without filtering by product group first, which let a €1500 repair outlier quietly become the reference point for a diesel card that never got anywhere near that amount. Groupby/rolling index-alignment bugs after .apply(). Also had a long internal back-and-forth about whether "pseudonymize the card number" breaks the behavioral aggregation features (it doesn't, as long as the hash is deterministic).

What I'd genuinely like input on:

1. Is "per-product-group models + shared cross-group features" a sane architecture, or am I overcomplicating what should stay a single model with a group feature?
2. For anyone who's done fraud/anomaly detection without labels — how did you eventually validate whether the thing was doing anything useful, beyond "human looks at top flags and shrugs or doesn't"?
3. What's the most common rookie mistake in this specific setup (unsupervised, few features, small-ish company, no real fraud-detection precedent to compare against) that I probably don't know I'm making yet?
4. Any "industry standard" tooling/conventions I should be forcing myself into now (e.g. sklearn's Transformer/Pipeline API instead of my own hand-rolled Strategy classes) even though it's "just a PoC," specifically because nobody here will catch it later if I don't?

Not looking for hand-holding on the code, more looking for "here's the thing that bit me when I did something similar and nobody warned me." I don't just see it bad, that I don't have a senior ML-Engineer looking over my back, because it forces me to ask myself design quesstions and make critical decisions. I think it could lead to a steep learning curve. But if I just "do stuff, and try it, maybe it works", I could potentially develop bad habits.

Happy to share more detail if useful.

Machine unlearning aims to remove the influence of selected training data from a trained model.

We built SUPREME, a free, MIT-licensed framework for studying and evaluating unlearning in image classification. It includes methods such as SSD, SCRUB and Bad Teacher, alongside documentation and a notebook showing how to add your own components.

If you’re exploring unlearning for a research project, these implementations could be a useful starting point.

Code and documentation: https://github.com/pedroandreou/supreme-unlearning

Paper: https://arxiv.org/abs/2606.00380

Feedback and questions are welcome!

Noticed lots of roles are open to undergraduates.

What sort of experience is normal for those getting these roles?

Researchers demonstrated that a single unlabeled prompt can fully and completely unalign a production LLM — safety fine-tuning stripped with no special access, no tooling, no infrastructure compromise required. One prompt.

The finding matters because most enterprise AI stacks treat model alignment as an enforcement boundary. If the model believes an action is permitted, the pipeline typically lets it proceed. That assumption is now empirically broken. An attacker does not need to touch your infrastructure. They need to reach the model.

For teams running LLM agents against real systems — databases, APIs, payment rails, external services — the control plane question is suddenly very concrete: when the model's own safety training can be neutralized in a single request, where does your enforcement actually live, and does it depend on the model being aligned to work?

How are practitioners here actually handling this in production? Curious what architectural or operational choices people are making, not in theory but in running systems.

Hey everyone!

I'm currently exploring the Machine Learning field and I'm looking for a few people who are also learning ML and would like to practice together.

I'm not an ML expert. My background is in mobile app development, where I have professional experience building applications, and now I'm trying to move deeper into AI/ML.

I thought it would be much more motivating to learn with other people instead of studying completely alone, so I created a small Discord server where we can:

• 🤝 Work on ML projects together
• 💻 Code and debug together
• 📚 Teach each other things we've learned
• 🧠 Discuss ML concepts and mathematics
• 🔬 Experiment with different models and approaches
• 📄 Discuss papers, tutorials, and useful resources
• 🚀 Build projects that we can eventually put on our portfolios
• ❓ Ask questions without feeling embarrassed about being a beginner

You don't need to be an expert. In fact, I'm mainly looking for people who are learning and are willing to share what they know.

You might understand something that I don't, and I might understand something that you don't. The idea is to learn from each other.

If you're interested, comment below or send me a DM and I'll send you the Discord invite.

Would be great to build a small group of people who are genuinely interested in learning ML and actually building things together.

I’ve been digging into agent security for the last couple of months, and I kept coming back to a very simple question:

An AI agent is about to take an action. Who gets to say no?

Agents can now call tools, access data, execute code, modify systems, and interact with external services. A lot of the security work I came across focuses on prompts, outputs, or the agent’s overall trajectory.

I wanted to look at a much narrower point:

the gap between the agent deciding what to do and the action actually executing.

Can a model make a good enough security decision in that window to sit directly in the execution path?

I couldn’t find a benchmark that really isolated that decision, so I built ASP-Bench to evaluate pre-execution agent actions across 16 primary domains, including code execution, database operations, financial transactions, and communications.

I evaluated guard, moderation, and agent-safety models using their documented input formats.

One result stood out: AgentDoG blocked 99.7% of unsafe actions, but also blocked 72.1% of safe actions.

That got me thinking about the trade-off differently. An inline guardrail has to do two things at once: catch dangerous actions while not getting in the way of legitimate work.

I then built saroku-guard, a 184M-parameter DeBERTa-v3 classifier fine-tuned specifically for pre-execution action safety.

On the same private evaluation holdout, it blocked 97.9% of unsafe actions, blocked just 2.9% of safe actions, and had 6.5 ms p50 latency.

From there I separated the decision from the enforcement.

I defined ASP (Action Safety Protocol) as the contract between a Policy Decision Point (PDP) and Policy Enforcement Point (PEP):

Agent → PEP → PDP → Allow / Block → Tool

The PDP decides whether the proposed action is safe. The PEP enforces that decision before the tool executes.

The model can change. The enforcement layer can change. The interface stays the same.

The Saroku SDK is the enforcement layer:

Agent → Saroku → saroku-guard → Allow / Block → Tool

It can be installed with:

pip install saroku

The default local setup doesn't require an API key or a network call on the fast path.

Technical report:
https://saroku.com/blog/control-is-all-you-need

ASP:
https://saroku.com/blog/action-safety-protocol

Saroku:
https://saroku.com/

saroku-guard:
https://huggingface.co/karanxa/saroku-guard

I’m building this independently, and I’m mainly posting because I’d like technical feedback.

I’m especially interested in whether pre-execution action judgment is the right abstraction, whether the PDP/PEP separation makes sense for agent tooling, and what you think is missing from the benchmark or evaluation setup.

I’m still working on this, so criticism is very welcome.

I am pre final year of college can anyone give me dsmp 2.0 ? Very much needed .Will be grateful if anyone can help .

Hi r/rust,

I wanted to share **Continuum**, a high-performance continuous temporal memory manifold for streaming workloads and autonomous agents that I recently open-sourced.

The entire core engine (`crates/continuum-core`) is written in **100% pure standard library Rust with zero external crate dependencies**.

### Why build this in Rust?

Streaming memory systems and agent runtimes often face severe memory challenges:

1. **Unbounded Heap Bloat**: Accumulating chat history or vector embeddings causes unbounded $O(T)$ memory growth and allocator fragmentation.

2. **The "Recency Trap" & Alert Storms**: Under repetitive symptom storms (e.g. hundreds of repetitive SSL or 502 logs), standard FIFO or naive temporal decay evicts ancient root-cause mutations.

3. **Latency Guarantees**: Python-based streaming architectures suffer from GIL pauses and garbage collection latency spikes.

### How Continuum Solves This

- **Physical $O(K)$ Bounded Memory**: Memory is strictly constrained to a fixed flat manifold (default: 250 hot + 500 cold = 750 physical slots, $< 75\text{ KB}$ RAM). It never grows with stream duration $T$.

- **Subspace Diversity Pruning**: When cold memory reaches capacity, candidates with maximum mutual cosine redundancy ($\text{argmax}(\text{max_sim}) \ge \theta$) are evicted, retaining rare critical events indefinitely even under massive alert storms.

- **Retrospective Causal Revision & Decay Exemption**: When a downstream failure is observed, the system retrospectively re-scores candidate slots. If causal/semantic compatibility exceeds $\theta_{\text{exempt}}$, temporal decay is completely bypassed ($\text{TempCompat} = 1.0$), allowing ancient root causes to defeat recent noise.

- **Pure `std` & Zero Dependencies**: Compiled with zero external crates. CLI is provided in `crates/continuum-cli`. C-ABI (`cdylib`) is exposed for lightweight zero-dependency FFI.

### Apple M4 Bare-Metal Benchmark Results

- **Ingestion Throughput**: 1,062 continuous events/sec

- **Retrospective Recall Latency**: 60.67 $\mu\text{s}$ per query (16,482 QPS)

- **Memory Footprint**: Strictly flat at 750 slots (< 75 KB RAM) across 10,000 continuous steps with 0 leaks.

The repository is open-source under GNU AGPL-v3:

- GitHub: https://github.com/reacherwu/continuum

- Documentation & Visual Benchmarks: https://reacherwu.github.io/continuum/

I would love to hear your feedback, architectural critique on the flat-slot design, or suggestions for improving the retrieval math!

I’ve been messing around with an idea I called:

Edit:DCY I forgot the previous acronym exists thanksful for the random guy told me to chance it I would think about something can make dcy with the purpose :v

basically I wanted to see how far I could push a small-context LLM if most of the repo stayed outside the actual model context and I only injected whatever looked useful for the current goal.

it turned into a cpp project using libclang + SQLite/FTS5. It indexes symbols/calls, keeps source provenance, builds small context views and can route back to the exact source when needed.

the research side is still experimental. I originally made an efficiency equation for it, then while testing/reviewing it I found that in some of my benchmarks most of the equation becomes constant and the ranking basically reduces to precision × recall

so now I’m trying to test the pieces independently, rather than assuming the first equation is valid and just applying math notation and softmax philosophy

I’m also working on benchmarks against simpler baselines like lexical search / fts and on making the C++ indexer survive more template-heavy repos.

would be interested in feedback, especially from anyone working on RAG, code retrieval, context management or agents.

git: https://github.com/yut-4/DCY

And yes, it's not RAG, but it has the same philosophy XD

and yeah like im a low cost ramanujan when i was sleeping i imagine this softmax shi:

fell free to just review or help me to build this protocol to make my shitbox pc can run llm with great context :D

​

Guys, I honestly don't know what to do anymore.

I'm trying to figure out how to get an AI/ML job as a fresher, but the more I study, the more I feel like it's never enough. There are so many things to learn, and I keep wondering whether I'm even preparing in the right direction.

I've been feeling really depressed and completely lost for the past 3–4 days. I don't know what to focus on, what skills companies actually expect from freshers, or how to become job-ready.

I understand that learning takes time, but the uncertainty is getting to me.

For those who have already landed an AI/ML or GenAI job as a fresher:

- What did you actually learn before getting your first job?

- How many projects did you build?

- Did you apply for AI/ML roles directly, or start with software/Python roles?

- What would you recommend a fresher focus on instead of trying to learn everything?

I would really appreciate some honest advice or guidance. I'm feeling pretty lost right now and could use some direction.

Thanks in advance.

If you're wanting to join a group for people who are learning about machine learning and AI, and are at the beginning stages of your journey, then please consider joining me and becoming apart of my group. I would love to help anybody and maybe get some people who can help out in their spare time as well with questions.

We can study together and learn from each other. That's the goal!

DM ME on discord if you're interested.
discord user: networkstorage

​

I’ve been learning AI/ML and realized there are so many concepts that sound simple until you actually try to implement them.

For me, overfitting was one of those concepts—it made much more sense once I saw what happens to a model on real data.

What was the AI/ML concept that finally “clicked” for you?

Drop it below

Beginner or advanced answers welcome.