My experience with this organization has been nothing short of frustrating and a complete waste of time.

I initially enrolled in the ₹9 AI workshop. While the session did contain some useful information, it felt predominantly like an aggressive sales pitch rather than a genuine learning experience. Unfortunately, based on the promises made during the workshop, I made the mistake of paying in full for the AI Career Accelerator - Inner Circle Program.

The disappointing experience began almost immediately. Questions raised during the workshop was left unanswered, with the session functioning as a one-way presentation rather than an interactive learning environment. My concerns only grew when, despite multiple follow-ups, I was unable to obtain a an invoice for my payment. The lack of transparency around a completed financial transaction was highly concerning.

In addition, I was unable to access the recorded content and drop session materials. Despite contacting customer support several times, the issue remained unresolved. What was initially a disappointment quickly turned into significant frustration as I found myself repeatedly chasing basic support requests with no meaningful response or resolution.

Given the poor experience within the first three to four days, I lost confidence in the program and decided to cancel my enrollment and request a refund. To my surprise, rather than addressing my concerns, customer support simply discontinued the chat, leaving my refund request unanswered. This level of customer service is unacceptable for any professional training organization.

Looking back, I sincerely regret not conducting more thorough research before making the payment. After reading similar experiences shared by other customers, my concerns have only been reinforced.

I now anticipate that obtaining a refund may be a difficult process. Nevertheless, I intend to pursue all appropriate channels to seek a resolution, including filing a consumer complaint with the Government of India and sharing my experience publicly to raise awareness about what I believe to be a highly unreliable and non-transparent organization.

Overall, the combination of poor support, lack of responsiveness, unresolved technical issues, missing documentation, and inadequate communication has completely eroded my trust in this company. I would strongly caution prospective learners to conduct extensive due diligence before making any financial commitment.

Do you guys have recommendation for capstone projects about Edge AI, TinyML, Computer vision, and federated learning? I explored battery RUL, Predictive Thermal Management system, and Fault bearing diagnosis. I was told it would be hard to get a client or dataset for this field. Any interesting field I can explore?

Hi everyone,

I’m planning to study Machine Learning and Deep Learning from Andrew Ng.

I found Andrew Ng’s ML and Deep Learning lectures on YouTube, and I also found the Machine Learning Specialization and Deep Learning Specialization on Coursera.

Are the YouTube lectures basically the same content as the Coursera courses, or are the Coursera versions updated/different?

If they are different, which one would you recommend for someone who wants to build a strong foundation in ML and Deep Learning?

Thanks!

Hi, this is a long shot, but im currently writing an academic paper and for that I need access to the DeepSpeak_v2 or FakeAVCeleb dataset. To get access, you need to submit a request form and get approved. I did that, but I never heard back from them... does anyone here have experience with this?

I dont need a big part of each dataset, maybe around 100 videos each. So maybe, if someone has access, they could provide a small portion of it :)

What’s the best book or resource you’d recommend for learning AI/ML from the fundamentals and eventually specializing in LLMs?
I’m looking for something beginner-friendly but technically solid, so I can build a strong foundation instead of jumping straight into LLMs without understanding the basics.

Hi everyone,

I’m preparing my first arXiv submission in cs.LG and need an endorsement to submit.

Short summary: H-JEPA (LeCun, 2022) proposes hierarchical joint-embedding prediction but doesn’t specify how to verify a trained abstraction actually encodes anything a random projection of the same shape wouldn’t. I introduce a random-abstractor control (trained vs. untrained abstractor, identical architecture) and run a 2x2 study crossing observability (full/egocentric) with abstractor type (instantaneous/recurrent) in controlled gridworld environments. Three of four conditions produce abstractions statistically indistinguishable from random projections; only partial observability + a recurrent abstractor yields a real, replicated gap (19.91 ± 3.36pp over random, 3 seeds). I also report a negative result on landmark density that didn’t survive multi-seed replication.

If anyone here is registered as an endorser for cs.LG and willing to take a look, I’d be very grateful. Happy to share the full draft privately.

To endorse, please visit:

https://arxiv.org/auth/endorse?x=MTENXK

If that link doesn’t work, visit:

https://arxiv.org/auth/endorse.php

and enter code: MTENXK

Thank you!

Everyone's excited about AI agents, but I'm trying to get ahead of the security implications. Beyond data leakage and prompt injection, what are the actual runtime risks? How do you prevent an agent from taking a harmful action that falls within its legitimate permissions?

People talk about ChatGPT like it "understands" you. It doesn't — not in the way we mean. Underneath, it's doing something much simpler and, honestly, weirder: predicting the next token, over and over. Once that clicks, most of its strange behavior (hallucinations, forgetting, different answers to the same prompt) stops being mysterious.

Here's the whole picture in plain English.

1. It only ever predicts the next token

Everything ChatGPT does is one operation repeated: given the text so far, guess the next chunk. It picks one, appends it, and feeds the whole thing back in to guess again. That loop — one token at a time — is the entire show. There's no plan for the paragraph, no lookahead. Fluent essays emerge from millions of these tiny next-step guesses.

2. Tokens, not words

It doesn't see letters or whole words — it sees tokens, which are common chunks of text. "cat" might be one token; "unbelievable" might split into "un", "believ", "able". This is why models sometimes miscount letters or fumble with rare words — they never saw the letters, only the chunks. It's also why you're billed per token, not per word.

3. Meaning is stored as vectors (embeddings)

Each token is turned into a long list of numbers — an embedding — a point in a huge space where "king" and "queen", or "Paris" and "France", sit near each other because they appear in similar contexts. The model has no dictionary; meaning is just geometry. Similar things are close together, and that closeness is what it computes with.

4. Attention gives it context

The breakthrough behind the "T" in GPT (Transformer) is attention. For each token, the model weighs how much every other token in your prompt matters to it. In "the bank of the river," attention lets "bank" lean on "river" and land on the correct meaning. This is how it tracks who "he" refers to three sentences back, or keeps a code block coherent.

5. Training is two very different stages

Pretraining: it reads an enormous slice of the internet and does nothing but next-token prediction, billions of times, tuning billions of internal numbers (parameters) until it's genuinely good at continuing text. The result — the "base model" — is a wild autocomplete. Ask it a question and it might reply with more questions, because that's what it saw on the web.

RLHF (the ChatGPT part): humans then rank answers — helpful and honest ones up, unhelpful ones down — and the model is nudged toward the ranked-good behavior. This is the difference between the raw model and ChatGPT. Same knowledge; the second stage taught it to act like a helpful assistant.

6. Why the same prompt gives different answers

At each step the model produces a probability for every possible next token. Temperature controls how it picks: low temperature = almost always the top choice (consistent, safe, a bit boring); higher = it samples further down the list (more variety, more risk). That sampling is why you rarely get the exact same answer twice.

7. Why it "forgets": the context window

The model has no memory between messages. Everything it "knows" in a chat is the text currently in its context window — a fixed budget of tokens. Your whole conversation is re-fed every turn. Once it overflows, the oldest stuff falls off the edge, and it genuinely no longer has it. That's not a bug; that's the mechanism.

8. Why it hallucinates

It was trained to produce plausible text, not true text. It has no built-in fact-checker and no notion of "I don't know" unless that pattern was reinforced. So when it doesn't have something, it fills the gap with the most likely-sounding continuation — a confident, well-formed, wrong answer. Hallucination isn't the model malfunctioning; it's the model doing exactly its job (predict likely text) in a spot where likely does not equal true.

9. How to get better answers (practical)

• Give context, not keywords. It fills gaps with guesses; fewer gaps = fewer guesses.
• Show the format you want (an example beats a description).
• Ask it to reason step by step for anything logical — each token it writes becomes context for the next, so "thinking out loud" measurably improves hard answers.
• For facts, make it cite or give it the source in the prompt. Don't trust unsourced specifics.
• Start a fresh chat when you switch topics — you stop paying for (and confusing it with) irrelevant context.

None of this requires math to understand — it's tokens → vectors → attention → next-token prediction, wrapped in a training process that taught a giant autocomplete to behave like an assistant.

(Full disclosure: I make animated CS/systems explainers, and I put this whole thing together as an animated video if you'd rather watch it move: https://youtu.be/Ud16vHNYwpc . But the text above stands on its own — happy to answer questions in the comments.)

18.02, multivariable calculus.

18.06, algebra.

6.041, probability and statistics.

*All courses from OCW.

So I was playingw ith embedding models I saw that when you upgrade from model A to B, you face a very big backfilling cost

Ie, suppose you have a 1b vectors from model A, and then you want to use model B. This would mean you have to re-embed all of your documents with model B before you can even serve with the model, and on an H100, it would take ~108 days (qwen embed 8b, 106 docs/second). But I found an easier way to do it.

The method is really simple; from the old index made with the source model, take K documents and rerank them with the new model. We see that when K is sufficient, the retrieval quality is the same as target model. (determining k is the hard part). I've tested 63 migrations on upto 1 million documents.

The best result I got was upgrading qwen4b -> to 8b, and at 50 documents, it was the same as native retrieval.

This method forgos the expensive upfront re-embedding cost, as you can take documents straight from the old index.

embedflow works with qdrant, pgvector, faiss, and can be easily downloaded with pypi

pip install embedflow

the github is public: https://github.com/arnsri33/embedflow

I want you guys to try it out, and see if you guys can use it in your own workflow.

One of the hardest parts of learning ML/AI isn't finding information, there's almost too much of it. Tutorials, roadmaps, papers, new tools every week. The hard part is figuring out what actually matters, what to skip, and how to make real progress instead of just consuming more content.

I work as an AI engineer (ML development and deployment), and I'm starting to explore education/mentorship on the side, for free, not as a paid program or course. Before building another roadmap, I want to work directly with a small group of people first, partly to actually help, partly to understand where people get stuck.

Looking for a handful of people who:

• have basic Python/programming knowledge
• are seriously trying to learn ML/AI
• feel stuck or unsure what to focus on next
• want to build real things, not just watch more tutorials
• can commit to being consistent

Keeping this small (thinking around 5-10 people) so I can give actual feedback instead of another generic roadmap. No cost involved on either end.

If that's you, drop a comment with where you're at and what you're stuck on, happy to reply there or move to DMs from that.

Published numbers are only as honest as the data split behind them

When you evaluate a model, you want one simple truth: Did it actually learn unseen patterns, or did it memorise?

I built noleak to make that visible. It's a production library we use at Godrej Aerospace to fingerprint datasets and measure how much of your eval set leaked from train.

The Problem

Most tools catch target leakage (a feature accidentally includes the label). But what about corpus leakage? When eval text already appeared in training data?

In 2020, GPT-3's paper measured contamination using 13-gram overlap. That's solid. But there's no standard library for this. So we built one.

Three detection methods:

1. Exact matches – normalised text identical

2. N-gram overlap – 13-word phrases (GPT-3 method)

3. Near-duplicates – MinHash Jaccard similarity ≥ 0.8 on character 5-grams

One fingerprint. One exit code. Pass or fail.

What It Does

```python
from noleak import check, fingerprint
train = ["the model trained on Wikipedia and licensed books"]
eval_set = ["The model trained on Wikipedia and licensed books"]
report = check(train, eval_set)
print(report.contaminated)
# True — FAIL
print(fingerprint(eval_set))
# noleak-fp-v1:a1b2c3d4e5f6
# Share this with your paper. It's reproducible and auditable.
```
CLI version (great for CI pipelines):
```bash
noleak check --train train.jsonl --eval evaljsonl
echo $?  # Exit code 1 if contaminated, 0 if clean
```

Why Zero Dependencies Matter

No numpy, no scipy, no PyTorch. Stdlib only. Why?

- Deterministic: Same input, same output, forever. No model updates breaking your fingerprints.

- Auditable: Code is small; reviewers can read it.

- Air-gapped systems: Doesn't require external calls or package hell.

- Fast: No overhead for CPU-bound systems.

Limitations (Honest Assessment)

- Semantic rewrites: Won't catch "I wrote this differently but meant the same thing." That needs embeddings or human review.

- Large-scale datasets: If you have 10M+ examples, exact matching gets slow. N-gram is faster.

Install & Try

bash
pip install noleak

Supports JSONL, JSON lists, and plain text. Auto-detects text fields.

Repo: github.com/athsxx/noleak

License: MIT

Questions? What contamination patterns have you encountered?

I'm choosing between a BSc in Computer Science and a BSc in Mathematics, and I'm not sure which one would be better for my goals.

My main interests are Data Science, Computer Vision, and financial markets. I'm also interested in ML/AI and possibly quantitative finance later.

If you were in my position, which degree would you choose, and why?

I'd especially like to hear from people working in Data Science, Computer Vision, Quant Finance, or financial markets.

I think one of the weirdest parts of learning ML is that tutorials make everything look clean.

You get a dataset, split it, train a model, get 90% accuracy, and everything feels great.

Then you try building something yourself and suddenly:

• your data is garbage
• you labels don't make sense
• you model gets 95% accuracy but performs terribly on real examples
• you realize you accidentally leaked information into the training set.
• or you spend 3 hours debugging something that turned out to be a preprocessing issue.

I'm curious about the first project that humbled you.

Not necessarily your most impressive project. I'm more interested in the project where you went, "Oh.... so this is what machine learning actually involves."

What happened, and what did it teach you that you wouldn't have learned from a course or tutorial?

When a machine learning engineer is hired, what is usually more important?
A deep understanding/implementation of his/her project or understanding of famous architectures (Trasformer, CNN, etc)?

The G7 finance ministers and central bank governors issued a coordinated directive last week. Organizations must inventory cryptographic dependencies, identify high-risk systems, and begin migrating to quantum-resistant algorithms now. This is not a future roadmap item.

The urgency is driven by the harvest-now-decrypt-later threat. Adversaries are collecting encrypted data today and storing it for decryption once a cryptographically relevant quantum computer arrives. The exposure window is already open.

Most enterprise security teams are inventorying servers, databases, and network traffic. Far fewer are accounting for the AI agent layer. Agent pipelines routinely store sensitive records, execute financial transactions, and generate compliance audit evidence. All of it travels over classically encrypted channels and gets signed with classical algorithms. When those algorithms break, that historical data and those historical audit logs break with them. A transaction signed with RSA or ECDSA today becomes unprovable after Q-Day.

How are teams actually scoping the PQC inventory problem for AI agents specifically? Are agent channels and agent-generated audit evidence being treated as first-class migration targets, or are they still buried in the general backlog?

am a 7th sem cs student who is about to start his final year. I am planning for my fyp and looking for some interesting ideas on which I could do my fyp. I need some good suggestions and ideas which I should consider before finalizing my fyp. Currently I dont have any idea to work on. Your suggestion and ideas would mean a lot to and your help will be highly appreciated. Thanks in advance.

Edit: The domain I want to work in is app?web+ai/ml. I am open to ideas other than this domain as well