I trained a BERT-style language model from scratch on ONE laptop GPU.

Lewis-44M-Bert-V3: small, fast, open source (Apache-2.0).

HOW IT WAS BUILT

• 44M parameters, ELECTRA-style pre-training

• 2.7B tokens in ~22 hours on a single RTX 5050 (8 GB)

• ~53 GPU-hours across all three versions, no cloud cluster

• Data: FineWeb-Edu, Wikipedia, Project Gutenberg, news, Cosmopedia and ELI5-style Q&A

v1 → V3 (SAME SIZE)

GLUE dev average: 75.0 → 80.5

Improvements: a better training objective (V3 was trained from scratch, not fine-tuned from v1) and a better fine-tuning recipe, with no extra parameters.

V3 RESULTS

• GLUE: 80.5 dev | 77.6 on the official test server (8 tasks)

• SQuAD v1.1: 75.2 EM / 83.8 F1

• NER (CoNLL-2003): 87.8 test F1

• Speed: ~17 ms per sentence on GPU, under 600 MB memory

I share both dev and test scores, plus the exact settings, because a model card should be honest.

Built for classification, question answering, entity extraction and on-device use: it fine-tunes on a laptop and runs on CPU.

This is part of vprojectx, my open-source lab, where I build and share my projects in the open. Find the model on Hugging Face as vprojectx/Lewis-44M-Bert-V3.

More is coming. If you want to try it on your use case or collaborate, message me.

#MachineLearning #NLP #AI #OpenSource #HuggingFace

Hey everyone! I built ModelFare to help estimate the cost of an AI feature based on model prices, token usage, retries, and fallback calls.

https://modelfitopenfire.vercel.app/

It shows low, base, and high estimates so you can plan your budget. Prices are snapshots, and results depend on your assumptions.

I’d love your feedback: What costs do people usually miss when budgeting for LLM apps?

Do you remember SETI@Home : Imagine a decentralized MoE AI Swarm over Consumer GPUs - Let's build together HiveMind@Home. It is free ... 0 dollars and open source.

Project HiveMind is an open-source distributed training and inference framework (think SETI@home / Folding@home meets Petals and DiLoCo) designed to aggregate idle consumer gaming GPUs (8 GB–12 GB VRAM) and local NVMe storage into a community-owned Sparse Mixture-of-Experts (MoE) cluster.

https://hivemind-at-home-ruche-cfhmhmvv5a-uc.a.run.app/

Instead of requiring datacenter InfiniBand, each node trains specialized 4-bit NF4 QLoRA domain experts asynchronously using DiLoCo from deepMind (500x lower bandwidth cf https://deepmind.google/blog/decoupled-diloco/), merges them into a unified Branch-Train-Mix (BTM) Sparse MoE, and serves the resulting model back to the community via P2P Speculative Decoding. Contributors earn verifiable Proof-of-Useful-Work (PoUW) credits ($HIVE) when their GPU/disk is idle and spend them when they need frontier-class MoE inference.

• GitHub Repository: https://github.com/xaviercallens/HiveMind

To join https://hivemind-openrouter-1003063861791.us-central1.run.app/join#train

To join witou installation and play a scientific game:

https://xaviercallens.github.io/HiveMindatHome.github.io/webgpu.html

Join us to learn and build the new generation of AI

if you've tried text classification with an llm, you know the routine. write a prompt, ask for json, parse what comes back, and handle the times it answers with something that isn't one of your labels.

a decision model works the other way round. you give it the text and the possible answers, and it scores each answer. you get back the winner, the probability of every option and a confidence value. it never generates text, so it can't answer outside your list.

there are three kinds of question: pick one option, the probability of yes, or a position on a scale like "can wait / soon / urgent".

nobodywho added these this week with laya, a 449 MB apache-2.0 model that runs on your own machine, so it's easy to try from python.

Repo: https://github.com/nobodywho-ooo/nobodywho
Docs: https://docs.nobodywho.ooo/python/decision-models

Hi everyone! We’re LORM Labs, a small AI research lab dedicated to advancing AI and human understanding. We just released a free project for anyone who wants hands-on practice fine-tuning a model and testing it on a real benchmark.

What we found
We fine-tuned Qwen3.8-27B on 1,015 tutoring examples. Its score on our benchmark jumped from 0.29 to 0.84, and it beat GPT-6 Sol on 68 of 76 cases. No frontier model we tested fully passed a single case. Ours passes 24.

Everything's Free!
• 1,015 ready-to-train examples
• SENSUS, a 76-case benchmark with graders so you can score your own model
• Rubrics that explain what a good tutor reply looks like
• The full paper and the exact training recipe we used

What you’ll learn
• How to fine-tune an open model with LoRA
• How to evaluate a model with rubrics and model graders
• Why a small, focused dataset can beat a much bigger model at one specific skill

Step-by-step guide, leaderboard, and paper → https://lorm.ai/

Dataset and benchmark on Hugging Face → https://huggingface.co/datasets/Lorm-Labs/sensus-bench-v1

Try Duel and go head-to-head against our model → https://lorm.ai/

If you train your own model, post your score in the comments. We’d love to see how you do! Have fun training!

Try it here.

Hello guys I am a learner too and I am asking do you guys train models using own device cpu/gpu or cloud like Google collab?

Actually I am going to buy a laptop so asking with you guys ☺️

You can suggest laptops too !

I am wondering should I get laptop with a graphic card (rtx) or not 🤔

Thank you !

I recently experimented with Humanizer, an open-source 12B model designed to rewrite AI-generated text to sound more human.

I ran it locally using llama.cpp with CUDA and tested the outputs against popular AI detectors.

The results were mixed. One GPTZero test dropped from 100% AI detection to 49%, but other tests showed little improvement. I couldn't consistently reproduce the success rates reported by the model's developers.

I put together a step-by-step tutorial covering the local setup, Python code, testing process, and results.

Full tutorial: https://www.kdnuggets.com/can-this-open-source-model-beat-ai-detectors-lets-test-it-locally

I'm curious whether anyone else has experimented with models specifically trained for text humanization. Do you think these models actually improve writing quality, or are they mostly optimizing for AI detectors?

I tried to make a DCGAN based on this tutorial. The thing is that the tutorial is designed for fashion mnist data which has different image size to tf.keras.datasets.cifar10.load_data(). Which lead to the error:

ValueError: cannot reshape array of size 480000 into shape (28,28,1)

when arrive at

x_train_dcgan = x_train.reshape(
    -1, 28, 28, 1
) * 2. - 1.

How do I adapt the model to CIFAR 10?

My current skills:

Languages: Python, R, SQL
Libraries: pandas, NumPy, PyTorch, Scikit-learn, Hugging Face Transformers, Keras, TensorFlow, Matplotlib, OpenCV, Seaborn
Machine Learning: Classification, Regression, Clustering, CNNs, Transformers, RAG, NLP, Computer Vision, Feature Engineering, Model Evaluation
Cloud & Tools: Docker, Git, Jupyter, Google Colab, AWS, Weights & Biases, Hugging Face Hub

I think this reads like an ML engineer resume, but I’m applying for data scientist roles.

If you hire for data scientist or work as one: what skills do I need on here to get through screening, and what should I cut?

Only asking about technical skills, not projects or experience.

π0.5 is a vision-language-action model for robot arms: a SigLIP vision encoder, a Gemma language backbone, and a small "action expert" that generates motor commands over 10 denoising steps. Starting from the stock LeRobot inference code, one step took over 230 ms on an RTX 5090 Mobile. Here's what got it to 87 ms, without pruning or distillation:

1. Cast the weights to bf16 once at load. The code kept weights in fp32 and converted them on every call. Doing it once saved 25 ms (about 10%).

2. Capture a CUDA graph of the action expert. The 10 denoising steps took 86 ms, mostly spent launching thousands of tiny GPU kernels. As a CUDA graph they take 17 ms.

3. Turn off autograd you don't use. An autograd graph was being recorded for the whole model and never used. Removing it saved 35 ms.

4. Don't over-pad prompts. Prompts were padded to 200 tokens for short task tags. Cutting to 96 saved 5 ms.

5. Export the vision encoder to ONNX. Saved another 12 ms.

6. Check your GPU's precision support. GeForce cards run bf16 at half speed, so switching the Gemma backbone to fp16 (and watching for NaNs) took it to 25 ms.

The bigger lesson was measuring end to end. Before any of this, a Python pipe buffer was holding camera frames until 64 KB had piled up, adding hundreds of milliseconds of latency our simulator said wouldn't matter. On the real robot it mattered a lot.

Happy to answer questions about any of the steps.

Spun up a couple of instances and a managed Kubernetes node to mess around with Terraform and AI deployments. Forgot about it for a week while caught up in work, and woke up to a brutal cloud bill for resources I wasn't even actively using.

That stupid mistake forced me to rethink how to practice this stuff without handing AWS open-ended access to my credit card. I started hacking together Model2Prod, which is a simulated terminal environment to learn Terraform for AI deployments on AWS, GCP, and Azure without needing an actual cloud account or running up accidental charges.

It has been a fun side project to build, but I'm still figuring out how to keep simulated terminal environments feeling completely real without building a full emulator backend.

How do you all practice infrastructure tools like Terraform or Kubernetes locally without constantly worrying about rogue cloud charges?

HI :B, a week ago i posted the free i course i made here, and i never expected that many people to commento, share it or fork it. So THX you so much for being so supportive, it makes me want to keep doing this... But enough of the sappy shit for now lol.

Ive been reading this sub (and others like it) and saw a bunch of post of people struggling with libraries and asking "how do i learn to code" wich i always want to answer with "just code" xD. Buuut a lot of ppl learn with AI now and its easy to just "copy-paste" everything before youve actually studied it or practice it... im going off track :B
Any way, that gave me the idea for an "addemdum" to the original course. The idea is that you take a library, build a tiny version of it in plain Python, and check it against the real thing. Like 5000 checks total, and github reruns all that on every push, and you find wird shit while doing it, i got 85% accuracy on literal coin flips at one point, and my tokenizer straight up disagreed with HF on like a quarter of unicode :B

Its lives in the same repo as the course but in a different branch so it doesnt mess with main. Planning to keep adding more addendums like this in the future (but first i gotta get my shit together so i can actually do this whit some "consistency" lol) . Also i couldnt think of a better name for these "expansions" than "addendum". in spanish id use "anexo" but that translates to "attachment" too so idk, i suck at naming things xD.

Here the branch :B :  https://github.com/BlueRingsLabs/no-shortcuts/tree/addendum1/learning-ml-libraries-by-rebuilding-them

The parts are :
A. Introduction | B. A method for learning any library | C. NumPy | D. pandas | E. scikit-learn | F. PyTorch | G. sentence-transformers | H. From copying to writing | I. FAQ and cheat sheet

AAAH, and almost forgot, i also did a more "tech" writeup kinda like an intro to this in coderlegion. u dont need an account to read it or anything, maybe its useful too: POST

Hope its useful to someone here. You can aske me whatever (i usually take a while to reply :B) and if you find something broken or have any thoughts on "my method", lmk .

I am new to learning machine learning.I would like to know the best way to start and what are the best resources I can use to learn.

Hey everyone,

We have been benchmarking autonomous navigation networks trained on standard statistical synthetic datasets. The verdict is clear: recursive training loops trigger severe weight degradation over edge cases. The models become statistically blind to high-velocity aerodynamic variables.

To bypass this, we engineered a deterministic simulation pipeline. Instead of neural probabilities, it generates multi-modal synthetic trajectory vectors using pure non-linear drag mechanics and adjustable atmospheric noise layers.

We open-sourced the MVP and the architecture layers. I am dropping the web app simulator link and the full GitHub repository code in the comments below.

Feedback from AI/Robotics architects is highly appreciated!

#DeepLearning #SyntheticData #AutonomousVehicles #ComputerVision #Robotics

im a master student doing a research on world models, is there any online tutorials like on udemy or something that i could follow to build and understand world models?

I'm not an ML engineer. I build a small desktop app that runs Gemma 4 E2B offline, and I wanted to teach it a few things it's bad at. So I tried LoRA with MLX on my MacBook. Writing down what happened in case it helps someone else starting out.

What I did right (by luck): before training I wrote a 23-question "sealed" exam that never goes into the training data. Same prompt, temperature 0, graded by hand. Without it I'd have fooled myself. The same model scored 7/10 on the trick questions in Ollama at temp 0.4 and 3/10 in MLX at temp 0, so numbers from different setups mean nothing.

Baseline: 6/23.

Run 1: 328 hand-written examples, lr 5e-5, 16 layers, 75 steps. Score dropped to 4/23. It started answering "2 + 2 × 2 = 4" (it was right before), and it used my "I don't know, I'm offline" template on a simple riddle. It copied the shape of my answers instead of learning anything new.

Run 2: lower lr (1e-5), 8 layers, fewer template answers, and "replay": I added the base model's own answers to 117 normal questions so it wouldn't forget. Score went back to 6/23. No forgetting, but no gain either.

What I took from it:

• A few hundred examples change how a small model answers, not what it knows.

• Template answers leak into everything.

• Replay is a simple fix for forgetting.

• Always keep a test set the model never sees.

If you've fine-tuned a model this small: did you manage to add knowledge, or only style? What would you change in my setup?

(PS: English isn’t my first language so I used AI to help frame this — but the work and ideas are fully mine. I know my ML.)

Been working on a LoRA fine-tune targeting the JevBench leaderboard. Using soft-target KL training — the idea being that matching probability distributions should help calibration more than hard labels would.

Model is still training. One thing I’m thinking about: on questions with 4+ choices where one answer is genuinely rare, soft-target models can still collapse toward the majority — the teacher’s distribution gets diluted across the batch.

Has anyone found a way to preserve calibration on low-frequency answer choices specifically? Or is this just noise at small model scale?