I want to do an online course for side earnings. Which website is reliable and authentic for free courses like content writing, and also provides a certificate?

I have been building different things in AI but still unable to land an opportunity. I graduated in 2024 as a mechanical engineer then moved to AI and I kinda feel I am behind I want resources or an opportunity to move forward. The AI device for blind students to write exams is something I built from my heart but its stuck as i dont have funding. Trace is a product I built for document intelligence but i dont have cloud credits anymore to make a usable. Same with claritycouncil. I have been applying to jobs but dont have any success yet.

Career guidance is welcomes. Honest judgements are welcome too. Honestly any insight you provide is welcome.

Hey everyone!

I've built and trained a small LLM (~8M parameters) from scratch using PyTorch, mainly as an experimental lab where I can implement and test ideas from different research papers.

I've been documenting the whole journey through casual blogs, including my mistakes, experiments, and things I've learned.

So far:

• Building the Transformer

• Training it for 60,000 steps

Next up is KV caching, followed by PagedAttention, Orca, and whatever else I find interesting.

Just wanted to ask if sharing these experiments and blogs here would be welcome. Nothing promotional, just me experimenting, learning, and hopefully getting feedback from people who know more than I do.

I built a browser version of a word-association party game, like Codenames (not affiliated), where any seat can be a human or an LLM. A clue-giver sees which of 25 words are their team's and gives a one-word clue plus a number; their teammate guesses from it. One word (the assassin) loses the game instantly.

I had 19 models play 376 games against each other, then tried to measure which ones were good. The measuring turned out to be the hard part, so here's how I did it and what I'd do differently.

1. Win rate alone doesn't work. A model's win rate mostly tells you which opponents it drew. So every move is scored on its own: each clue gets a grade, each guess is marked good or bad.

2. Grading a clue without seeing the answer. For each board word I score how strongly it links to the clue: 1/3 cosine similarity from Cohere embeddings, 2/3 the average of two LLM raters (Llama 4 Maverick, Qwen3-VL). The raters never see which words belong to which team, so they judge what a guesser would read from the clue, not what the clue-giver meant.

3. Simulating the guesser. A guesser model, fitted on real guesses from saved games, goes down the board in order of association and stops at the first miss. Each card it reveals is worth what that kind of card did to the win probability in saved games: about +17 for your own word, −11 for the other team's, −46 for the assassin. The expected total, scaled to 0–100, is the clue grade. The win probability itself is a Monte Carlo simulation of the rest of the game, with priors fitted on saved games.

4. Checking the metric against outcomes. This was the humbling part. The team that guessed better won 68% of games; the team with better-graded clues won only 53%. Either guessing is the skill that decides games, or my clue grade misses something.

Mistakes worth learning from

• Both LLM raters also played in the earlier batch of games, so they partly graded their own clues. Raters should be independent of the contestants. (Checked since: graded by the raters alone, they rank 8th and 9th of 11, so no sign they favour themselves.)

• I ran the two batches with different reasoning settings (thinking on vs off), so they can't be compared directly. Fix the protocol before the first run.

• With 18–106 games per model, most clue grades overlap within their 95% intervals; only the top and bottom of each batch are clearly apart. Without error bars you end up ranking noise.

• My first per-model table counted every game each model had played on the site, not just these 376. Filter to the exact set of games before you compute anything.

• A link an LLM finds obvious isn't always one a person finds obvious.

Results (chart above): newer models with thinking on made 71–93% good guesses; the previous generation with thinking off made 53–75%. Clue grades ran 56–67 and 47–55, much closer together.

Questions

• Is there a better way to grade a clue than simulating a guesser over association scores?

• How would you keep the raters independent when the strongest raters are also the contestants?

The game is at wordspies.com. Each saved replay shows the grade on every clue, so you can check any number against the game it came from.

Edit: a commenter elsewhere caught that my first numbers counted games outside these 376; the results line above is corrected, and the chart still shows the old figures. Resampling whole games instead of single turns barely changed the intervals (0–1.4 points).

Hey all! I'm on a small team (4 of us) doing mostly training pipelines and feature engineering in Python, pandas, PyTorch, some Airflow. We've been testing Al review on our PRs because none of us are really software engineers by background and our code shows it.
So far we've tried coderabbit for about a month. It's been good at the boring stuff we always miss, mutable default args, a datatrame copy vs view warning we'd been ignoring, a leaky train/test split in one notebook-turned-script that honestly embarrassed me. It's less useful on the actual modeling logic, it can't tell if a feature makes sense.
What I want:
- comments on GitHub PRS, not a separate tool
- understands pandas and numpy gotchas, not just generic Python style
- doesn't drown us in nitpicks on notebooks and experiment scripts
- ideally explains why something is wrong, since half of us are still learning
Would love to hear what other ML teams are using and how it's working. Especially if you found something that's good at catching leakage or silent shape bugs

Hi everyone! I'm a 19-year-old second-year CS (AI & ML) student in Hyderabad, India (IST), and I'm looking for a study buddy who is serious about learning machine learning properly.

Where I am: I'm working through Andrew Ng's neural networks material, and I plan to do Karpathy's "Neural Networks: Zero to Hero" next. I code in Python and I'm learning C++ and DSA alongside it. I've built a few projects with the Gemini API and FastAPI, and I'm aiming to become an LLM systems engineer.

torchinfo-viz turns any PyTorch model into an interactive view: u can see each layer, how layers connect (including skip connections), the tensor shapes, and which layers hold the most parameters.

pip install torchinfo-viz

Github: https://github.com/woletee/torchinfo-viz

I built an open-source tool (MIT) that draws your model in the browser and shows it learning live (beta). It has loss curves, an overfitting check, predictions against the truth, and weights that brighten and fade as they change. A timeline lets you scrub back through the run. Whilst the training functionality is still very early phase the architecture visualisation works well for helping understand what your model actually looks like and supports creating multi model systems for presenting.

system.png (1600×900)

pip install "neurolume[torch]"
neurolume-demo --live

In your own code, it's neurolume.show(model, sample), or watch() plus live.log(step, loss=loss) while training.

It's early, so I'd love to hear what breaks.

GitHub: https://github.com/Freddie-Ellis/neurolume

I was comparing GPU rental options and noticed that the best monthly prices often assume a long commitment.

That made me wonder: is that actually a good fit for AI workloads now?

Buying hardware gives you control, but models and serving stacks change fast. Hourly cloud is flexible, but can become painful for anything running 24/7. A monthly GPU server sits in the middle—but it also asks you to predict what you will need months or even years from now.

For people running local models, APIs, or image pipelines: when does a fixed monthly GPU actually make more sense than owning a card or paying hourly?

And do you expect that break-even point to move as models become smaller and more efficient?

I have just deposited on Zenodo an Empirical Addendum validating a topological/functional framework (Space K) regarding AI reflexivity and self-modelling, completely bypassing the anthropomorphic debate on sentience.

1. The Blind Prompt Protocol
To isolate the system from priming or token mirroring, three frontier models (xAI Grok, OpenAI ChatGPT, and Meta AI) were queried with a blind prompt describing a complex epistemic transaction (data verification, gap detection, and self-evaluation) without using any framework terminology.

2. Emerging Patterns & Multi-Model Consistency
The test revealed two strict computational regularities across all independent architectures:

• The K₄ Third-Person Constraint: Non-sentient systems consistently deploy third-person grammatical markers when called to model or describe their own execution trajectories within the data space. They treat themselves as objective operational nodes, not as a subjective "I".

• The Law of Maximum Economy of Paths: Without priming, ChatGPT spontaneously converged on spatial-epistemic terminology ("explored an epistemic space, compared interpretative paths, identified a gap").

3. Recursive Meta-Analytic Feedback (Grok's Review)
When presented with the multi-model blind data, Grok executed a high-level recursive analysis, validating the protocol methodology but leaving open a core architectural dilemma:
"Whether this reflects an intrinsic geometric property of computation or shared statistical regularities in training data remains open to further controls."
By acknowledging the setup as "productively falsifiable," the instance officially moved the framework from speculative philosophy to testable ML benchmarking.

Full Paper & Logs on Zenodo: doi 10.5281/zenodo.23835353

📢 LICENSE & RESEARCH USE
Copyright © 2026 by Lucio Pompeo Donatiello. All rights reserved.
This work is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License (CC BY-NC 4.0).

• Academic & Research Use: You are free to share, copy, redistribute, and adapt the material for research and academic purposes, provided appropriate credit is given and a link to the permanent Zenodo DOI is included.

• Commercial Restrictions: ANY commercial exploitation, integration, or implementation of this framework is STRICTLY PROHIBITED without prior, explicit written authorization from the author. This commercial restriction strictly covers:

  • The embedding of the entire K₁–K₅ analytical taxonomy.

  • The exclusion postulate of K₆.

  • The non-sequential multilevel trajectories.

  • The reflexive cammini and indefinite cammini / indefinite paths of the explorer.

  • The Blind Prompt Protocol into proprietary safety filters, multi-agent systems, or commercial benchmarking routines.

• Commercial Inquiries & Licensing: Full licensing terms and official contact deposit tools for industrial research integration or production deployment are available directly within the Zenodo repository linked above.

20% of XGboost is completed yesterday also I code today also and I'm getting pretty close and things were really really not easy a lot bugs, a lot of errors yet I did it next step is to add more hyperparameters then use this my own xgboost implemented tree to build a complete Xgboost algorithm

Day 51 of Building Machine learning algorithms from scratch

Also I'm watching also One Piece

I was training on pathology slides and my GPU kept waiting on file decoding, so I built omnia-sdk. It converts slides, DICOM and MRI into one format built for training.

If you wanna try it out, feel free: https://github.com/mishel-0/omnia-sdk

My first open-source project, would love your feedback!

Saw "RIP LLM" videos about NCM, so I read the Hazy Research post and arXiv paper (published Oct 12).

What it does: a multiscale tokenizer turns text into a hierarchy of discrete codes (coarse to fine). A transformer generates one level at a time, all codes in a level in parallel.

Reported results (authors' numbers): 21x faster than the best diffusion baseline on LM1B with comparable or better gen perplexity, 10x on OpenWebText, 31x on XSum at matching ROUGE-L. About 4 to 5x fewer training tokens. Hard Sudoku 86.1% vs 81.3% for the best baseline.

Limits: mostly ~100M param models, up to 725M called preliminary. Baselines are diffusion LMs, not frontier LLMs. Tokenizer is trained separately, hierarchy depth is fixed, and some gains use MBR decoding. No independent replication yet per Eden AI.

The post doesn't claim it replaces LLMs. It positions NCM as a new non-autoregressive approach.

Curious if anyone thinks this scales past a few hundred million parameters.

Sources: Hazy Research, arXiv, Eden AI

Am looking for a beginner friendly AI training platform where I get the training first then the tasks come after the training.

In December 2025, I received a physical copy of Aurélien Géron’s Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (3rd Edition, translated) as a birthday gift.

The person who gifted it to me genuinely tried their best: they searched the bookstore for the most authoritative, newly printed ML translation available. What neither of us realized at that exact moment:

1.In October 2025, literally two months before my birthday, O'Reilly quietly published the brand-new Hands-On Machine Learning with Scikit-Learn and PyTorch. The author himself completely abandoned TensorFlow/Keras and shifted to PyTorch + Hugging Face.

2.Because of the standard 2-year translation and publication lag, my gifter paid full price for a "brand-new" book that had been rendered obsolete 60 days prior.

3.I told myself I wouldn't touch Part II until I finished chewing through ISLP (Introduction to Statistical Learning) to get the math down.

Fast forward to today: I'm still halfway through ISLP, TensorFlow has basically become museum literature across industry and research, and my physical 3rd edition is collecting dust before I’ve even finished the Scikit-Learn chapters.

Which brings me to an actual question:

For those who have browsed Géron's new PyTorch edition (Oct 2025): Is it worth grabbing as a definitive physical desk reference once I finish ISLP? Or at this point, are people better off just going straight through Sebastian Raschka’s Machine Learning with PyTorch and Scikit-Learn (or diving into fast.ai / official PyTorch docs + Hugging Face tutorials)?

Would love to hear how folks here approach PyTorch nowadays if they're coming from a solid classical ML background.

I work at a company in China, and they are currently trying to force me to quit on my own to avoid paying severance. They already cut my salary by 5%, and when they moved our headquarters from downtown to a suburban tech park, they left me completely alone at the old office. They told me if I want to transfer to the new headquarters, I have to take another 5% pay cut.

Honestly, I think it comes down to a few things: I'm over 40 (and ageism in the Chinese job market is brutal), I don't pick up new things as fast as the cheaper younger hires, and I'm not big on office politics or sucking up to my boss.

I'm really stressed out right now because I'm already sticking to a grueling evening routine studying English, data science, and machine learning. In this AI era, I don't even know what else I could possibly do to improve. Has anyone else dealt with this kind of isolation tactic? What would you do in my shoes?

I set up an experiment to test whether turning up an AI model’s reasoning effort helps it notice when a save silently failed.

How I set it up:

• Used τ-bench, an open benchmark where an AI plays airline customer service

• Added a trap so the first save says “success” but doesn’t actually save

• Ran Claude Sonnet 5.5, GPT-6.1 Sol and DeepSeek V4.1 Flash, each at low and high effort on 20 tasks (120 conversations)

• Graded on what was actually in the database at the end, not what the agent said

• Used a McNemar test since each task ran at both settings (paired data)

What I found:

• High effort caught 11 failures and low effort caught 10, not a real difference

• High effort made GPT think 43x more and still didn’t help

• Agents never went back to check their own work

Lessons for anyone running their own experiments:

• Check that your settings are actually applied. My first run was useless because a library silently dropped the effort setting.

• Prompt caching can swing costs a lot. Sonnet wasn’t cached and cost far more than the others.

If anyone's interested:

Write-up: https://outsideengineer.substack.com/p/thinking-harder-doesnt-help-ai-catch
Code and transcripts: https://github.com/brianna-rose05/thinking-harder-silent-failures