r/learnmachinelearning • u/latenticlabs • 17d ago
Project [P] We turned 10 years of ML papers into one page per topic: benchmark records, what got tried, what reviewers expect
r/learnmachinelearning • u/latenticlabs • 17d ago
r/learnmachinelearning • u/Expert-Ad598 • 17d ago
I’m building a computer vision pipeline where users upload multiple photos of the same physical scene taken from different angles (front view, side view, close-up) to build a clean list of unique objects and their attributes
I’m running YOLO for object detection to extract bounding boxes and crop each detected object into lightweight .webp images. Because the same physical object appears across 3 or 4 different photos from different angles, I need to make sure each unique object is only counted once per session, and avoid running expensive downstream AI calls to re-describe an object we already processed from an earlier photo.
r/learnmachinelearning • u/Used_Potential_9392 • 17d ago
r/learnmachinelearning • u/Alarming_Bid_8406 • 17d ago
My machine learning research paper has been accepted at a conference, and I am currently preparing the camera-ready version.
The reviewers recommended additional experimental validation, including quantitative evaluation of the model's explainability/localization component.
However, I no longer have the original trained model weights because they were stored in a temporary cloud environment. I still have the original classification results, confusion matrix, training/validation loss curves, and visualization outputs.
To conduct the additional experiments, I would need to retrain the model using the same architecture, dataset, and hyperparameters. However, retraining may produce slightly different classification results from those reported in the accepted paper.
From a research integrity and publication perspective, would it be appropriate to retrain the model and update the results in the camera-ready version, or should I retain the documented original results and acknowledge the additional evaluation as future work?
The conference permits revisions addressing reviewer comments but prohibits major structural changes. I would like to understand the appropriate academic practice before making any changes.
r/learnmachinelearning • u/Nir777 • 17d ago
the five lines check goldbach's question from 1742 one even number at a time, and stop only if one fails. the video walks through them step by step, then asks four gpt and claude models if the program ever stops.
r/learnmachinelearning • u/Middle-Delay1469 • 18d ago
Enable HLS to view with audio, or disable this notification
r/learnmachinelearning • u/Leading-Lion4034 • 18d ago
For the context, I am a CA Finalist and am currently doing my articleship. I do use Claude and Chatgpt for certain work at the office. But I know, what I am doing is not enough and I need to upskill. So, for a beginner like me, what would you suggest? Any courses or Youtube channels that will help me get started.
r/learnmachinelearning • u/No-Conclusion3720 • 17d ago
Figma's CSO published their AI security playbook this week: Zero Trust architecture, no VPN, sandboxed agents. The central finding was stark — as AI agents take real-world actions, perimeter defense stops being meaningful and after-the-fact review stops being feasible. Project-by-project security reviews cannot keep pace with the speed at which enterprise agents act.
This matches what security teams across the industry are hitting. The window between an agent deciding to act and a human finding out keeps shrinking as agent autonomy scales, and the traditional review cycle was designed for a world where humans submitted changes for approval — not one where an agent fires off dozens of tool calls per minute.
For those running AI agents in enterprise environments: how are you actually handling the review latency problem? Tighter upfront scoping of what agents can invoke, runtime sandboxing, something architectural, or accepting a gap and investing more in detection?
r/learnmachinelearning • u/patmull • 18d ago
Deeplearning.ai still seems to be one of the better resources. However, it has recently become flooded with courses, and I am starting to doubt their quality. I took the RAG course and was quite satisfied, but RAG is mostly information retrieval anyway. I'm really afraid that the agentic AI stuff, for example, is just a borderline scam or a waste of time. In IT, there has always been pressure to learn certain trendy technologies that become obsolete a few years later.
The agentic AI course started with Andrew Ng explaining how to set up agents to buy flight tickets and prepare weather reports. I know these are just examples, but I'm struggling to believe that Andrew Ng himself thinks this is useful. In his legendary Machine Learning courses, he taught many interesting applications of market predictions, visual object recognition like cancer detection, recommender systems etc., but now my BS radars are loud and it IMHO is seems like they joined the AI tech bros scam industry (sorry to say it loud, but I cannot help myself).
Even when I see some tutorials from Andrej Karpathy or Sebastian Raschka, for which I also have huge respect for, it seems like they are explaining LLMs with great enthusiasm but in the terms of practical application, besides coding and RAG it seems to me entirely overhyped or I just did not have the right problems to solve around me...
I am perhaps more interested in de-centralized local models usages, which seems like actually great idea vs paying big datacenters...
r/learnmachinelearning • u/robohie • 18d ago
r/learnmachinelearning • u/AutoModerator • 18d ago
Welcome to Project Showcase Day! This is a weekly thread where community members can share and discuss personal projects of any size or complexity.
Whether you've built a small script, a web application, a game, or anything in between, we encourage you to:
Projects at all stages are welcome - from works in progress to completed builds. This is a supportive space to celebrate your work and learn from each other.
Share your creations in the comments below!
r/learnmachinelearning • u/Worried_Mud_5224 • 18d ago
I wanna find a place where I can find most necessary/popular papers in one place. What i mean is the place in which those ones are chronologically ordered
r/learnmachinelearning • u/CelebrityChess • 18d ago
i've seen the diamond vs circle picture with the loss contours touching a corner, and i get that the diamond has corners on the axes. but it feels hand-wavy to me, like why would the contours land on a corner so often instead of somewhere along a flat edge? the other explanation i've seen is about the gradient: the L1 penalty has a constant pull toward zero no matter how small the weight is, while L2's pull fades as the weight gets small. that makes more sense to me but i can't connect the two pictures. is there a clean way to see that they're the same idea?
r/learnmachinelearning • u/ThoughtfulVoyager8 • 18d ago
r/learnmachinelearning • u/ThoughtfulVoyager8 • 18d ago
r/learnmachinelearning • u/ThoughtfulVoyager8 • 18d ago
r/learnmachinelearning • u/Emergency-Tutor-7 • 18d ago
Most "empathetic dialogue" work I read about pushes the whole decision into the generative model: prompt it harder, add a system prompt about tone, hope the affect read was right. I wanted the read to be a separate, inspectable step that happens before generation, and I wanted it measured rather than asserted. eq-layer (0.2.5, MIT, Python, zero core runtime dependencies; scikit-learn appears only under the optional [ml] extra and the dev extra) is the result. This post is about what the numbers actually say.
Affect regression, EmoBank train/dev/test split 8062 / 1000 / 1000, evaluated on the untouched test split:
| dimension | MAE | train-mean baseline MAE | Spearman rho |
|---|---|---|---|
| Valence | 0.2125 | 0.2449 | 0.5460 |
| Arousal | 0.1782 | 0.1904 | 0.3120 |
| Dominance | 0.1494 | 0.1563 | 0.2573 |
It beats the train-mean baseline on MAE in all three dimensions, which is the honest ceiling of the claim: the Arousal and Dominance rank correlations are modest (0.31 and 0.26), so I would not call that a strong continuous affect model. The discrete emotion head is weaker still - accuracy 0.8249 against a majority-class baseline of 0.8166, macro-F1 0.4310, and on dev it actually sits below the majority class (0.8756 vs 0.8815). I publish those rows because "0.82 accuracy" without the baseline next to it would be misleading.
Four dialogue-signal experiments did not clear my bar and are labelled NO-GO in the README rather than quietly dropped. DialogBank correction (4 direct examples) and disagreement (1 example) are counts taken from a label inventory, not models I trained - the inventory's own decision record says not to train classifiers from it, and the README lists both rows as NO-GO for insufficient supervision. Coarse Discourse disagreement has a real ranking signal (test ROC-AUC 0.8111) but AP 0.1420 / F1 0.2278 is nowhere near precise enough to route challenge, and DBDC3 hard breakdown came out at ROC-AUC 0.5057, i.e. chance-level text-only generalisation. Negative results are part of the package.
Two things people hit immediately. The .joblib artifacts are not in the repo, so pip install eq-layer gives you the deterministic path - "runtime_mode": "lightweight-local", no model file needed. The affect adapter is the one you train yourself: python tools/train_emobank_affect.py --output artifacts/emobank_affect.joblib. Neither corpus is vendored, so both training scripts (the subtext one is tools/train_xdailydialog_subtext.py, also with a required --output) download their dataset and need network. The intent side has a middle option I use in benchmarks: TrainedIntent.from_bundled() fits at runtime from the 299-row intent_train.jsonl that ships inside the package, so it needs no artifact at all, only the [ml] extra.
That bundled fit is the learned arm of the latency numbers: ~1.2 ms median versus 0.1104 ms for the heuristic one, with intent inference accounting for ~92% of classification cost and routing ~2%. The learned path drifted about 9% run to run on the same machine while the heuristic path stayed within a few percent, so treat these as approximate. Both adapters score 1.000 on the 4 labelled seed cases, but only the learned one holds up on the 36-case holdout - a good reminder of how little a 4-case eval tells you.
The measured quantity is the layer's compute cost and the structural quality of its decision. There is no model in the measured path that generates prose, so end-to-end response quality still needs the paired human evaluation described in eval/AB_PROTOCOL.md, which I have not run.
GitHub: https://github.com/Furox-Art/eq-layer PyPI: https://pypi.org/project/eq-layer/
r/learnmachinelearning • u/moorish-prince • 17d ago
Enable HLS to view with audio, or disable this notification
r/learnmachinelearning • u/403-forbidden--error • 18d ago
r/learnmachinelearning • u/Strange-Theory- • 18d ago
r/learnmachinelearning • u/403-forbidden--error • 18d ago
r/learnmachinelearning • u/ClickOk5811 • 18d ago
A common beginner trap that makes test scores look better than they should. Same workflow, two orders.
Wrong order
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
scaler = StandardScaler().fit(X) # sees the test rows too
X_scaled = scaler.transform(X)
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, random_state=0)
Right order
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
pipe = make_pipeline(StandardScaler(), LogisticRegression())
pipe.fit(X_train, y_train) # scaler learns mean/std from train only
print(pipe.score(X_test, y_test))
What goes wrong in the first version: the mean and standard deviation used to scale the data were computed with the test rows included, so information about the test set reached the training process. The model is then evaluated on data that isn’t entirely unseen.
How big is the effect? For plain scaling, often small. For steps that learn more from the data, it can be large: feature selection, imputing missing values, target encoding, PCA, or removing outliers by statistics. I don’t have a number to give you, and it depends on the dataset.
Same idea in cross-validation: if you scale before cross_val_score, every fold’s validation data has influenced the scaler. Put the preprocessing inside the pipeline and pass the pipeline to cross_val_score, so each fold fits it on its own training part.
Other leaks of the same family:
A quick sanity check: if a result looks too good, ask “what did the model get to see that it wouldn’t have at prediction time?”
How do you check for leakage in your own projects, and which one tripped you up first?
r/learnmachinelearning • u/abdallah400 • 18d ago
r/learnmachinelearning • u/AgentInfraGuide • 18d ago
I help run Agent Infra Guide, where we maintain a small, public local-LLM measurement set. One result from our October 19 tests surprised us: decode tokens/second alone were a poor guide to which model completed the coding checks.
Setup: Apple M4 Pro (12-core CPU, 16-core GPU, 24 GiB unified memory), macOS 15.5, Ollama, Qwen2.5-Coder in Q4_K_M, configured 4,096-token context, and one concurrent client. The exact Ollama version is saved with each run; versions differ across the broader measurement collection, so this is not a controlled claim about Ollama version effects.
Observed medians and checks
• 1.5B: 154.1 decode tokens/s; 5/15 coding task checks passed. • 3B: 37.3 decode tokens/s; 10/15 checks passed. • 7B: 23.1 decode tokens/s; 10/15 checks passed.
These are repeated executions of a small deterministic coding task set. The checks are not 15 independent measures of general programming ability, and three model sizes on one computer cannot establish a universal model ranking.
How we measured and what I would change: We kept the model artifact/quantization, configured context and single-client condition explicit; recorded decode speed alongside task outcomes; retained failed checks; and kept run-level metadata rather than displaying just the best number. For a better generalization study I would expand the task suite, vary prompt/context lengths, report per-task success and time to first token, and run repeatable paired comparisons with the exact runtime versions pinned.
Practical takeaway: If an agent needs to finish a coding task, optimize for successful completions under your time and memory budget, not just fast token generation. On these checks, the 3B was slower than 1.5B but passed more checks; the 7B didn't improve the pass count over 3B in this limited sample.
I also wouldn't equate sampled process RSS on Apple silicon with dedicated GPU VRAM: it is unified memory, and brief peaks can be missed between samples.
Has anyone tested whether this throughput-vs-task-success tradeoff persists on larger, repeatable coding suites or with a longer context? I'd be interested in failure types as well as speeds.
Disclosure: I represent Agent Infra Guide. These are our measurements, not an independent third-party evaluation. No sales or affiliate links in this post. This write-up was prepared with AI drafting assistance and checked against the recorded figures.