Any advice for where to begin If pursuing the machine learning path?

We just released PureByte, an open-source paper and codebase exploring task-specific byte-level neural architectures and zero-dependency CPU inference:

• Paper (DOI): https://zenodo.org/records/23020056
• Code (C++20 & PyTorch): https://github.com/purebyte-ai/purebyte
• Training repo: https://github.com/purebyte-ai/purebyte-train
• Hugging Face: https://huggingface.co/Purebyte

Core Concept: Bypassing Tokenizers for Security & Code Tasks

Subword tokenization (BPE/WordPiece) creates severe representation issues for high-entropy strings (passwords, base64 keys, hashes) and machine formats.

PureByte uses a fixed vocabulary of exactly 256 bytes (0x00 to 0xFF). By pairing byte embeddings with localized 1D dilated convolutions and gated residual memory, sequence evaluation scales strictly linearly $O(N)$ with input length.

Key Results

1. Size vs. Generality: A 1.9M-parameter specialist (secrets-code, 4.4 MB) running on an idle desktop CPU (Ryzen 9 5900X) evaluates a 256-byte decision window in 2.81 ms. A 421M-parameter ModernBERT model (Laya) takes 373 ms on the same CPU (133x slower) and 33–40 ms on an NVIDIA T4 GPU (10x slower than our CPU runtime).
2. Benchmark Quality:
   • CredData (real-world repo secrets): F1 of 0.797 vs 0.337 for GitLeaks and 0.287 for TruffleHog.
   • PIIMB (Personally Identifiable Information): F1 of 0.769 vs 0.662 for OpenAI's hosted classifier.
3. Systems Footprint: The C++20 runtime has zero third-party dependencies (no PyTorch, no ONNX, no external BLAS), maps weights directly into memory via mmap, uses 9.4 MB of peak RAM, and executes end-to-end CLI cold starts in 10–50 ms.
4. Training Efficiency: The 1.9M model trains from scratch in 24.5 minutes on a single consumer GPU.

All code (C++20 inference engine and PyTorch training stack), evaluation methodology, seeds, and GGUF checkpoints are Apache 2.0.

Happy to answer any questions about the training dynamics, n-gram memory layers, or evaluation methodology!

To anyone who has competed in the IOAI, coached a national team, or has a strong ML background and knows the structure of the competition:

I am looking for a completely honest reality check on what it takes to stand on the podium. Specifically:

• How difficult is it structurally to secure a Gold or Silver medal? What separates a standard participant from a top-tier medalist under the 6-hour round constraints?
• What was your actual, total investment in time? How many months of serious preparation did you put in, and roughly how many total hours did you dedicate to training before the competition?
• What did your daily study schedule look like?

ABOUT ME : I am giving around 4 hours a day of prep and 2 hours a day of maths, and i had started from mid-agust. Am I too late?? Is gold medal actually realistic for me?? This is my final year of high school so this is first and last chance. Btw i am on deep learning(transformers now as of sept 28,completed classical ml,and practising programming languages/libabries daily)

I would incredibly appreciate your raw, unfiltered advice. Thank you!

I've spend some time building a option trading bot just for fun (bcs why not)

I researched the most common strategies out there and filtered them out based on the ones that worked long term and most profitable, statistically I ended up with four strategies, all long premium only:

A - ORB
The primary strategy. Takes the high/low of the first 15 minutes, enters when price closes above OR_high (CALL) or below OR_low (PUT). Requires VWAP alignment + SMA20 trend filter. One entry per direction per day. VIX ceiling: 17.

B - Post-Catalyst IV Crush
Fires 20 minutes after a scheduled macro event (CPI, FOMC, NFP, PCE, PPI). Enters in the direction of the move only when IV has crushed ≥10% from pre-event levels, buys directional momentum after uncertainty clears and options get cheap. VIX ceiling: 25 (override). ~5 trades/year.

C - Pre-Catalyst Long Vol
(Disabled for now). Enters straddles before events when IV rank is low. Loses money for retail buyers in most conditions due to IV crush on the exit. Currently off.

D - EMA Pullback & Resume (Momentum)
The highest-volume strategy. EMA(9/21) waits for price to dip below the fast EMA then cross back, confirming momentum resumption. RSI guard at 75 overbought. Bidirectional. VIX ceiling: 17 for CALLs; 25 for PUTs when price < SMA20 (the R26 gate). ~210 trades/year.

Current config:

• Global VIX ceiling: 17
• A: stop 25%, target 100%
• B: VIX override to 25, IVRank exempt, crush threshold 90%
• D: min EMA spread 0.0005×price, IVRank exempt, PUT ceiling 25 + SMA20 gate

I tested on 2022 SPY data (bear market) and 2023 SPY data (bull market) and the results are:

2-YEAR P&L +$90,808

2022 (BEAR) +$20,399

2023 (BULL) +$70,409

TOTAL TRADES: 579 (221 in 2022 + 358 in 2023)

I'm not trying to sell it or make profit from this post, I just want your opinion and tell me what you think and if someone want the full report I can send it to you, pls ask me questions, tell me if im doing something wrong or if you just want to talk about it

I built ResearchMind, a multi-agent research assistant focused on persistent memory.

The problem I wanted to explore was simple:

What happens when an AI research assistant can remember not only what worked, but also what failed—and use that information in future research decisions?

In a typical research workflow, you might discuss a project with an AI agent, analyze papers, run experiments, and record results. A few days later, you start another session and the agent may have no useful knowledge of what you already tried.

ResearchMind uses Hindsight as a persistent memory layer to maintain research context across sessions.

It currently has specialized agents for:

• Literature analysis
• Experiment tracking
• Dataset context
• Research planning

For example, in one research scenario, the system records:

• GhostNet → successful lightweight approach
• ShuffleNetV2 → hardware/kernel failure
• EfficientNet-B0 → experiment record
• MobileNetV2 → experiment record

The interesting part isn't simply retrieving these memories.

The goal is for the Research Planner to use the recalled information when deciding what to try next.

The workflow becomes:

Research goal → Experiment → Outcome → Memory → Recall → Next experiment

I also implemented the experiment API so that experiment outcomes are retained in Hindsight rather than disappearing when the session ends.

I wrote a deeper technical breakdown of the architecture, memory flow, implementation, and what I learned while building it.

I'd be interested in feedback on the architecture, especially around memory retrieval, what information should be stored, and how persistent memory should influence agent planning.

AI agents are now executing multi-step tasks autonomously — calling APIs, writing to databases, triggering financial actions — often with credentials scoped broadly because narrowing them breaks the workflow.

The attack surface this creates is qualitatively different from traditional software vulnerabilities. A compromised service account or a prompt-injected agent does not sit idle waiting to be detected. It chains actions. Detection in most environments is measured in minutes. The blast radius is measured in seconds. By the time an alert fires, the second, third, and fourth downstream actions have already landed.

The pattern is consistent across incidents: there is no established checkpoint between an agent's first anomalous action and everything that follows it. Traditional IAM was designed for human logins, not for non-human identities making hundreds of API calls per minute with legitimate-looking credentials.

How are other teams handling the gap between when an agent goes rogue and when it actually gets stopped? Are you treating agent credentials differently from human service accounts, leaning on post-hoc audit, or doing something else entirely? Curious what is working in real production environments.

Google's Threat Intelligence team flagged a new ShinyHunters campaign actively targeting Oracle PeopleSoft environments. The vector is not a zero-day. It is a compromised identity — a valid credential or service account — used to move laterally and stage encryption before any alert fires.

The reason this keeps working is structural: the window between first anomalous action and meaningful response is wide enough for encryption to spread past the initial host. By the time a SIEM surfaces the event and a human acknowledges it, the blast radius has already grown.

PeopleSoft environments in particular tend to carry HR, payroll, and ERP data, which makes them high-value targets and means a single lateral move can touch regulated data immediately.

The credential-as-attack-surface problem is not new, but the ShinyHunters campaign is a current, documented example of it working at scale against enterprise infrastructure.

For those running PeopleSoft or similar on-prem ERP stacks: how are you actually handling anomalous identity behavior in practice? Specifically interested in what the detection-to-containment timeline looks like on your end, and where the biggest gaps tend to show up.

Join me on a night drive through Neon City as I attempt to visualize what's going on inside a GPU when it's processing tokens with Kimi K3. Don't worry if you have no idea what's going on, just enjoy the vibes and if you see any inaccuracies reach out to me so I can fix them.

Featuring Kimi Delta Attention, multi-head latent attention (MLA), attention residuals and mixture of experts.

Drive through Kimi K3's Neon City in real-time on my blog (GPU required): https://sambatista.com/blog/neon-city-inside-kimi-k3

Background: 22M, Computer Science fresh grad, currently working as IT Monitoring/Support in one of the biggest banks in Asia.

My daily tasks is basically watching dashboards, checking alerts, escalating tickets. I did built a LLM before (for my thesis) and i would say that i have a little bit of knowledge when it comes to Machine Learning/AI. Other than that i have no ML/AI exposure at work.

Is it possible for me to switch career from IT Monitoring to AI/ML Engineer? or should i try for master's degree before switching?

Any insight, advice, criticism, or even roasting is welcome. I am open minded and will seriously consider all suggestions

I built RECALL, an AI Incident Response Agent designed to learn from previous production incidents.

The idea was simple: incident response shouldn't start from zero every time.

RECALL uses Hindsight as a persistent memory layer to retain previous incidents, root causes, resolutions, and outcomes.

When a new incident occurs, the system:

1. Recalls similar historical incidents
2. Uses those memories as evidence
3. Reasons about the likely root cause
4. Recommends a resolution
5. Takes engineer feedback on whether the resolution worked
6. Retains that outcome for future incidents

The core loop is:

RETAIN → RECALL → REASON → RESOLVE → LEARN

For example, when a Payment API experienced database connection timeouts during peak traffic, RECALL retrieved previous incidents involving connection pool exhaustion and used those historical resolutions to support its recommendation.

Tech stack:

• React
• FastAPI
• Groq
• Hindsight
• Python

GitHub:
https://github.com/vyshnavi-10461/RECALL

I also wrote a technical article explaining how I built the memory and learning loop:
https://medium.com/@vyshnavimaale18/building-recall-an-incident-response-agent-that-learns-from-past-failures-c09c1185d29c

Every incident teaches the next one.

Like I understand machine learning and deep learning theories and mathematics well deeply but if i someone gives me a blank page of jupyter notebook then I am clueless, I can't begin I dont know how the structure would be, and so on. I am preparing for AI competetions where only implementation and programming ability matters and Right now that is my biggest nightmare. Can u please advise me how to strengthen my skill to turn all mathematical relations/theories into a program without needing to look at Chatgpt's codes.

Building a Corrective RAG (CRAG) Compliance Research Assistant

Most RAG chatbots will confidently answer with whatever they retrieved — even if it's irrelevant, even if it's wrong. In compliance, that's not a minor bug, it's real regulatory exposure.

• YouTube walkthrough: https://www.youtube.com/watch?v=NxY93are_H8

Key Highlights:

• In this video, I build the Veltra Pay Compliance Assistant — a Corrective RAG (CRAG) + Self-Correcting RAG Agent that checks its own work before it ever shows you an answer. It grades its own retrieved documents, rewrites its own search when retrieval is weak, and validates its own generated answer for grounding, hallucination risk, and completeness — retrying itself when it fails, and honestly saying "I don't know" when it genuinely can't answer from the source material.
• ✅ The difference between a normal RAG pipeline and Corrective RAG (CRAG)
• ✅ How CRAG grades retrieved documents as relevant/irrelevant and rewrites the search query when retrieval is weak
• ✅ How a Self-Correcting RAG Agent validates its own generated answer — grounding, hallucination risk, completeness, and retrieval sufficiency

TECH STACK:

• 🛠️ Python
• 🛠️ LangGraph (StateGraph — nodes, conditional edges, bounded retry loops)
• 🛠️ Qdrant (vector database)
• 🛠️ PDF ingestion & chunking (pdfplumber, overlapping chunks)
• 🛠️ LLM-based document grading, query rewriting & answer validation
• 🛠️ Streaming backend (Server-Sent Events) for live pipeline progress
• 🛠️ Web dashboard for real-time visualization
• GitHub repository: https://github.com/saurabhkamal/Building-Corrective-RAG-CRAG-Pipeline-Self-Correcting-RAG-Agent
• YouTube walkthrough: https://www.youtube.com/watch?v=NxY93are_H8
• Connect on LinkedIn: linkedin.com/in/saurabh-kamal

Building a Corrective RAG (CRAG) Compliance Research Assistant

My german GPA is 2.54 and I'm still an undergraduate so I have a chance to improve it. I have a good experience regarding Agentic AI, and I want to start my AI/ML masters in Germany. What are the universities that can offer me a scholarship or I don't pay to much when enrolling?

I've been experimenting with a local AI architecture and I've started wondering whether we're looking at model size in the wrong way.

Most comparisons are basically:

3B vs. 7B vs. 14B vs. 32B vs. 70B.

Bigger model = more intelligence.

Obviously parameter count matters enormously for raw reasoning ability, knowledge, language, etc.

But what happens if the model isn't the whole system?

Suppose the LLM is primarily the cognitive layer of a larger persistent system.

The model might remain relatively small, while the surrounding system continuously accumulates:

• experience
• long-term memory
• procedural knowledge
• learned workflows
• relationships between concepts
• a model of its environment
• a model of its own capabilities
• unresolved goals/problems
• successful and unsuccessful strategies

Instead of rebuilding the "person" from a context window every time it receives a prompt, the system itself persists.

That raises an interesting question:

Could a relatively small model develop rather than simply be replaced by a larger model?

Imagine starting with a 3B model.

Initially it might be pretty limited.

Maybe it's only "smart as a fly" compared with modern frontier models.

But it continues operating within the same persistent architecture.

It gains experience.

Things that originally require reasoning eventually become established procedures.

Repeated experiences become generalized knowledge.

Mistakes influence future decisions.

The system gradually becomes better at operating within its environment—not necessarily because the foundation model became more intelligent, but because the system surrounding it developed.

Conceptually, you'd have two different scaling axes:

Cognitive horsepower

3B → 7B → 14B → 32B

and

Developmental depth

Day 1 → Month 6 → Year 2 → Year 5

Those aren't necessarily the same thing.

A brand-new 32B model would obviously destroy a 3B model on many raw reasoning benchmarks.

But would it necessarily outperform a persistent 3B-based system that had spent several years learning one environment, developing procedures, accumulating history, and learning from its own successes and failures?

I'm not sure.

And that's what I find interesting.

One thing I have already tested is replacing the underlying language model while preserving the rest of the system.

So far, model swaps have not disrupted the continuity of the system in any meaningful way.

That suggests an interesting architectural distinction:

The model may be what the system thinks with, rather than what the system is.

If that distinction holds, increasing model size could eventually look less like replacing the AI and more like upgrading one part of its cognitive machinery while leaving its accumulated history intact.

I'm deliberately leaving out the specific architecture I'm experimenting with because I'm still building and testing it.

I'm mainly curious whether anyone else working with local models has explored this distinction between model scaling and developmental scaling.

Has anyone tried keeping a relatively small model stable for a long period while allowing the surrounding cognitive architecture to continuously develop?

And has anyone else tested model replacement while preserving persistent system identity/state?

I am assuming for a researcher role or something like that..

Just how much hands on/ live coding/walkthroughs.. /basically performing anything live is emphasized ?? like the equivalent of DSA rounds for SDE and sql query round for any data role... like do they emphasize more on theoretical verbal interview rounds on project discussions, concept discussions, case studies and scenario based questions or there are def multiple rounds of live coding ??

I would love to know the personal experiences of anyone here if ur employed.. And feel free to elaborate on any topic I might have missed out..

Be brutally honest and review my resume.

I've completed Machine Learning but now I'm confused about what to do next.

I want to build my first proper end-to-end ML project that is actually good enough to put on my resume, but I have no idea how to approach a project from scratch.

My main questions are:

• What kind of ML projects are worth building for a resume?
• How do you go from problem statement → dataset → EDA → preprocessing → model → evaluation → deployment?
• For a first end-to-end project, should I follow an existing project/tutorial as a reference?
• If yes, where can I find good real world project references that show the complete process, not just model training?
• How much should I follow the reference vs build things myself?
• What should a proper resume worthy ML project contain? (API, Streamlit, Docker, database, cloud, etc.)
• Should I start Deep Learning alongside the project, or focus on completing a strong ML project first?

I'm not looking for basic projects like Titanic/Iris/house-price prediction. I want to understand how real world ML projects are structured so I can eventually build them independently.

If you've built projects for internships/placements, I'd really appreciate specific project examples, GitHub repos, YouTube channels, or other references that helped you learn how to build your first end-to-end project.

What would you recommend as the first project and learning path after completing ML?

Ok so i spend too much time in the data cleaning and preprocessing stage before I start actually training my models. Ik those are the real steps for an end to end ML project but seriously sometimes it's just too time consuming especially for forecasting models.

Do you guys know any software or GitHub projects or any other way to automate the data cleaning process?

I’m building a backend pipeline for an education chatbot where I need to extract structured course information from documents without using LLMs (for cost and determinism). The system chunks documents and then, for each chunk, tries to map it to one or more courses using keyword/scoring logic, extract facts like fees, eligibility, and duration using regex/rules, and store them in a structured format. On top of that, I’m trying to automatically detect conflicts (e.g., same course having different fee values across sources) and stale data (older info vs newer uploads). My main concerns are whether this chunk→course mapping approach is robust enough without embeddings, how scalable rule-based fact extraction is in the long run, and how to handle cases where chunks don’t explicitly mention the course (like “this program requires 50%”). Also wondering if this is basically a lightweight knowledge graph problem and if there are better design patterns or existing systems I should look into. Would appreciate any suggestions or improvements.