AllenAI Open Instruct Tulu 3 Post-Training with SFT, DPO, RLVR, GRPO, and Verifier-Based Evaluation

AllenAI's Open Instruct framework was used to build an end-to-end post-training pipeline for a compact instruction-tuned language model, integrating Supervised Fine-Tuning, Direct Preference Optimization, and Reinforcement Learning with Verifiable Rewards using GRPO, while adapting the original multi-GPU Tulu 3 stack to fit within a 16 GB runtime. The tutorial clones the Open Instruct repository, configures LoRA adapters, prepares GSM8K data, and uses deterministic verifiers to evaluate mathematical answers, replacing distributed components like vLLM and Ray with lightweight Hugging Face and PyTorch implementations for Colab.

In this tutorial, we build an end-to-end post-training pipeline for a compact instruction-tuned language model using AllenAI’s Open Instruct https://github.com/allenai/open-instruct framework. We move through three major training stages: Supervised Fine-Tuning, Direct Preference Optimization, and Reinforcement Learning with Verifiable Rewards using GRPO, while adapting the original multi-GPU Tulu 3 stack to fit within a 16 GB runtime. We clone the Open Instruct repository, selectively load its native loss and utility functions, configure LoRA adapters, prepare GSM8K data for each training stage, and use deterministic verifiers to evaluate generated mathematical answers. Throughout the workflow, we preserve the core optimization logic of Open Instruct while replacing distributed components such as vLLM, Ray actors, DeepSpeed, and asynchronous rollout queues with lightweight Hugging Face and PyTorch implementations suitable for Colab. python import os, sys, subprocess, textwrap, json, math, random, re, ast, types, dataclasses, gc, contextlib REPO URL = "https://github.com/allenai/open-instruct.git" REPO DIR = "/content/open-instruct" if os.path.isdir "/content" else "./open-instruct" PIP PKGS = "peft", "accelerate", "ray", "wandb", "beaker-py", "langdetect==1.0.9", "immutabledict==1.2.0", "nltk", "absl-py", "sympy", "antlr4-python3-runtime==4.11", "tiktoken", def sh args : print "$", " ".join args subprocess.run args, check=False def setup : sh sys.executable, "-m", "pip", "install", "-q", PIP PKGS if not os.path.isdir REPO DIR : sh "git", "clone", "--depth", "1", REPO URL, REPO DIR if REPO DIR not in sys.path: sys.path.insert 0, REPO DIR os.environ.setdefault "WANDB MODE", "disabled" os.environ.setdefault "TOKENIZERS PARALLELISM", "false" os.environ.setdefault "RAY DISABLE IMPORT WARNING", "1" setup import numpy as np import torch import torch.nn.functional as F from torch.utils.data import DataLoader from datasets import load dataset, Dataset from transformers import AutoModelForCausalLM, DataCollatorForSeq2Seq, get cosine schedule with warmup from peft import LoraConfig, get peft model DEV = "cuda" if torch.cuda.is available else "cpu" try: bf16 = DEV == "cuda" and torch.cuda.is bf16 supported including emulation=False except TypeError: bf16 = DEV == "cuda" and torch.cuda.get device properties 0 .major = 8 AMP DTYPE = torch.bfloat16 if bf16 else torch.float16 USE SCALER = AMP DTYPE is torch.float16 print f"device={DEV} autocast dtype={AMP DTYPE} gpu={torch.cuda.get device name 0 if DEV=='cuda' else '-'}" def oi load relpath, names, ns=None : src = open os.path.join REPO DIR, relpath .read tree = ast.parse src found = {n.name: n for n in tree.body if isinstance n, ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef and n.name in names} missing = set names - set found if missing: raise KeyError f"{relpath}: could not find {missing} upstream may have renamed them " ns = {} if ns is None else dict ns ns.update {"torch": torch, "F": F, "np": np, "enum": import "enum" , "dataclasses": dataclasses, "math": math, "os": os} future = ast.parse "from future import annotations" .body mod = ast.Module body=future + found n for n in names , type ignores= exec compile ast.fix missing locations mod , f"<open instruct:{relpath} ", "exec" , ns return {n: ns n for n in names} dpo = oi load "open instruct/dpo utils.py", "dpo loss", " get batch logps" pf = oi load "open instruct/padding free collator.py", "calculate per token logps" rl = oi load "open instruct/rl utils.py", "masked mean" mu = oi load "open instruct/model utils.py", "estimate kl" grpo = oi load "open instruct/grpo utils.py", "GRPOLossType", "compute grpo loss" , ns={"model utils": types.SimpleNamespace mu } dpo loss = dpo "dpo loss" get batch logps = dpo " get batch logps" per token logps fn = pf "calculate per token logps" masked mean = rl "masked mean" compute grpo loss = grpo "compute grpo loss" GRPOLossType = grpo "GRPOLossType" print "lifted from repo:", f. name for f in dpo loss, get batch logps, per token logps fn, masked mean, compute grpo loss from open instruct.dataset transformation import CHAT TEMPLATES, TokenizerConfig, sft tulu tokenize and truncate v1, sft tulu filter v1, preference tulu tokenize and truncate v1 2, rlvr tokenize v1, visualize token role, from open instruct.ground truth utils import GSM8KVerifier, MathVerifier, IFEvalVerifierOld We install the required lightweight dependencies, clone the Open Instruct repository, and configure the Colab environment for stable execution. We detect the available GPU precision mode and select either FP16 or BF16 autocasting based on the hardware capabilities. We also extract the original DPO, GRPO, masking, and log-probability functions directly from the repository without importing its full distributed training stack. @dataclasses.dataclass class CFG: model: str = "Qwen/Qwen2.5-0.5B-Instruct" max seq len: int = 640 seed: int = 42 n sft: int = 192 sft steps: int = 40 sft micro bs: int = 2 sft accum: int = 4 sft lr: float = 1e-4 n dpo: int = 96 dpo steps: int = 24 dpo micro bs: int = 1 dpo accum: int = 4 dpo lr: float = 5e-5 dpo beta: float = 0.1 dpo norm: bool = True grpo iters: int = 6 prompts per iter: int = 4 samples per prompt: int = 4 grpo micro bs: int = 1 grpo inner epochs: int = 2 grpo lr: float = 2e-5 grpo temperature: float = 1.0 grpo max new: int = 200 grpo kl beta: float = 0.02 clip lower: float = 0.2 clip higher: float = 0.272 kl estimator: int = 2 adv norm: str = "centered" n eval: int = 24 cfg = CFG random.seed cfg.seed ; np.random.seed cfg.seed ; torch.manual seed cfg.seed tc = TokenizerConfig tokenizer name or path=cfg.model, chat template name=None, use fast=True tok = tc.tokenizer print f"\navailable CHAT TEMPLATES: {list CHAT TEMPLATES :12 } ... {len CHAT TEMPLATES } total " print f"pad={tok.pad token r} {tok.pad token id} eos={tok.eos token r} {tok.eos token id} " demo = {"messages": {"role": "user", "content": "What is 12 3?"}, {"role": "assistant", "content": "12 3 = 36. The answer is 36."}, {"role": "user", "content": "And minus 6?"}, {"role": "assistant", "content": "36 - 6 = 30. The answer is 30."}, } enc = sft tulu tokenize and truncate v1 dict demo , tok, cfg.max seq len print "\n SFT label masking — colour 0 = masked out of the loss, colour 1 = trained on " visualize token role enc "input ids" .tolist , enc "labels" = -100 .long .tolist , tok print f"trainable tokens: { enc 'labels' = -100 .sum .item }/{ enc 'labels' .numel }" We define a centralized configuration class that controls the model, dataset sizes, learning rates, batch settings, and optimization parameters for every training stage. We initialize the Open Instruct tokenizer while preserving the model’s chat template and ensuring that padding and end-of-sequence tokens remain correctly separated. We then tokenize a sample conversation and visualize which assistant tokens contribute to the supervised training loss. gsm = load dataset "openai/gsm8k", "main" SYS = "You are a careful math assistant. Reason step by step, then finish with 'The answer is N.'" def gsm answer a : return a.split " " -1 .strip .replace ",", "" def gsm solution a : body = a.split " " 0 .strip body = re.sub r"<<. ? ", "", body return f"{body}\nThe answer is {gsm answer a }." def as messages row : return {"role": "system", "content": SYS}, {"role": "user", "content": row "question" }, {"role": "assistant", "content": gsm solution row "answer" } train rows = gsm "train" i for i in range cfg.n sft + cfg.n dpo eval rows = gsm "test" i for i in range cfg.n eval def to lists row : for k in "input ids", "labels", "attention mask" : row k = row k .tolist return row sft ds = Dataset.from list {"messages": as messages r } for r in train rows : cfg.n sft sft ds = sft ds.map lambda r: to lists sft tulu tokenize and truncate v1 r, tok, cfg.max seq len , remove columns= "messages" , desc="sft tokenize" sft ds = sft ds.filter sft tulu filter v1, fn kwargs={"tokenizer": tok}, desc="drop all-masked" def make pair r : gold = gsm answer r "answer" bad = str int float gold + random.choice -10, -3, -1, 1, 2, 7 if gold.replace '.', '', 1 .lstrip '-' .isdigit else gold + "0" prompt = {"role": "system", "content": SYS}, {"role": "user", "content": r "question" } good txt = gsm solution r "answer" bad txt = good txt.rsplit "The answer is", 1 0 + f"The answer is {bad}." return {"chosen": prompt + {"role": "assistant", "content": good txt} , "rejected": prompt + {"role": "assistant", "content": bad txt} } dpo ds = Dataset.from list make pair r for r in train rows cfg.n sft: dpo ds = dpo ds.map lambda r: {k: v.tolist if torch.is tensor v else v for k, v in preference tulu tokenize and truncate v1 2 r, tok, cfg.max seq len .items }, remove columns= "chosen", "rejected" , desc="dpo tokenize" rlvr rows = {"messages": as messages r :2 , "ground truth": gsm answer r "answer" , "dataset": "gsm8k"} for r in train rows : cfg.n sft rlvr ds = Dataset.from list rlvr rows .map lambda r: rlvr tokenize v1 r, tok , remove columns= "messages" , desc="rlvr tokenize" print f"\nsft={len sft ds } dpo={len dpo ds } rlvr={len rlvr ds }" VERIFIERS = {"gsm8k": GSM8KVerifier , "math": MathVerifier , "ifeval old": IFEvalVerifierOld } print "\n verifier smoke test " print " gsm8k :", VERIFIERS "gsm8k" , "9 + 3 = 12. The answer is 12.", "12" .score print " gsm8k :", VERIFIERS "gsm8k" , "The answer is 11.", "12" .score print " math :", VERIFIERS "math" , r"hence \boxed{0.5}", r"\frac{1}{2}" .score print " ifeval:", VERIFIERS "ifeval old" , "one two three four five six seven", json.dumps {"func name": "validate word constraint", "N": 6, "quantifier": "at least"} .score def verify batch responses, ground truths, sources, tokenized=None : out = for i, resp, gt, src in enumerate zip responses, ground truths, sources : v = VERIFIERS.get src, VERIFIERS "gsm8k" out.append v tokenized i if tokenized else , resp, gt .score v.weight return np.array out, dtype=np.float32 We load GSM8K and transform its questions and solutions into a consistent conversational format for SFT, DPO, and RLVR training. We create supervised examples, preference pairs with deliberately incorrect final answers, and verifier-ready prompts with structured ground-truth labels. We also initialize Open Instruct’s GSM8K, mathematical, and instruction-following verifiers and use them to score generated responses deterministically. model = AutoModelForCausalLM.from pretrained cfg.model, dtype=torch.float32 .to DEV model.config.use cache = False if len tok model.get input embeddings .weight.shape 0 : model.resize token embeddings len tok def patch peft torchao : import importlib for mod in "peft.import utils", "peft.tuners.lora.torchao", "peft.tuners.lora.model", "peft.tuners.lora.layer" : try: m = importlib.import module mod except Exception: continue if hasattr m, "is torchao available" : m.is torchao available = lambda: False patch peft torchao model = get peft model model, LoraConfig r=32, lora alpha=64, lora dropout=0.05, bias="none", task type="CAUSAL LM", model.print trainable parameters TRAINABLE = p for p in model.parameters if p.requires grad @contextlib.contextmanager def with cache : old = model.config.use cache model.config.use cache = True try: yield finally: model.config.use cache = old def amp : return torch.autocast device type="cuda", dtype=AMP DTYPE if DEV == "cuda" \ else torch.autocast device type="cpu", enabled=False def new opt lr, steps : opt = torch.optim.AdamW TRAINABLE, lr=lr, weight decay=0.0, betas= 0.9, 0.999 sched = get cosine schedule with warmup opt, int 0.05 steps + 1, steps scaler = torch.amp.GradScaler "cuda", enabled=USE SCALER return opt, sched, scaler def step opt opt, sched, scaler : scaler.unscale opt torch.nn.utils.clip grad norm TRAINABLE, 1.0 scaler.step opt ; scaler.update ; sched.step ; opt.zero grad set to none=True @torch.no grad def evaluate tag, rows, max new=256 : model.eval tok.padding side = "left" correct, bs = 0.0, 4 for i in range 0, len rows , bs : chunk = rows i:i + bs prompts = tok.apply chat template {"role": "system", "content": SYS}, {"role": "user", "content": r "question" } , add generation prompt=True, tokenize=False for r in chunk enc = tok prompts, return tensors="pt", padding=True, add special tokens=False .to DEV with amp , with cache : out = model.generate enc, max new tokens=max new, do sample=False, pad token id=tok.pad token id texts = tok.batch decode out :, enc "input ids" .shape 1 : , skip special tokens=True correct += verify batch texts, gsm answer r "answer" for r in chunk , "gsm8k" len chunk .sum acc = correct / len rows print f" eval:{tag} verifier accuracy = {acc:.3f} {int correct }/{len rows } " model.train ; tok.padding side = "right" return acc print "\n" + "=" 90 ; print "BASELINE" ; print "=" 90 base acc = evaluate "base", eval rows We load the Qwen instruction model, apply LoRA adapters to its attention and feed-forward projection layers, and restrict optimization to the trainable adapter parameters. We configure mixed-precision execution, gradient scaling, gradient clipping, learning-rate scheduling, and temporary KV-cache activation for generation. We then evaluate the untrained baseline on GSM8K using greedy decoding and verifier-based answer accuracy. print "\n" + "=" 90 ; print "STAGE 1 — SFT" ; print "=" 90 sft collate = DataCollatorForSeq2Seq tokenizer=tok, padding="longest", label pad token id=-100 sft dl = DataLoader sft ds, batch size=cfg.sft micro bs, shuffle=True, collate fn=sft collate, drop last=True opt, sched, scaler = new opt cfg.sft lr, cfg.sft steps model.train ; it, step, run = iter sft dl , 0, 0.0 while step < cfg.sft steps: for in range cfg.sft accum : try: batch = next it except StopIteration: it = iter sft dl ; batch = next it batch = {k: v.to DEV for k, v in batch.items } with amp : loss = model batch .loss / cfg.sft accum scaler.scale loss .backward run += loss.item step opt opt, sched, scaler ; step += 1 if step % 10 == 0 or step == 1: print f" sft step {step: 3}/{cfg.sft steps} loss {run:.4f} lr {sched.get last lr 0 :.2e}" run = 0.0 sft acc = evaluate "after-sft", eval rows We construct a padded SFT DataLoader and train the LoRA adapters on tokenized GSM8K conversations using gradient accumulation. We optimize the model with cross-entropy loss calculated only over the unmasked assistant response tokens. We track the training loss and learning rate throughout the stage and evaluate the updated model after supervised fine-tuning. print "\n" + "=" 90 ; print "STAGE 2 — DPO dpo norm " ; print "=" 90 def pad side seqs, pad, maxlen : return torch.tensor s + pad maxlen - len s for s in seqs , dtype=torch.long def dpo collate features : out = {} for pfx in "chosen", "rejected" : L = max len f f"{pfx} input ids" for f in features out f"{pfx} input ids" = pad side f f"{pfx} input ids" for f in features , tok.pad token id, L out f"{pfx} labels" = pad side f f"{pfx} labels" for f in features , -100, L out f"{pfx} attention mask" = pad side f f"{pfx} attention mask" for f in features , 0, L return out def seq logps input ids, attn, labels : with amp : logits = model input ids=input ids, attention mask=attn .logits ptl = per token logps fn logits, labels return get batch logps ptl, labels, average log prob=cfg.dpo norm dpo dl = DataLoader dpo ds, batch size=cfg.dpo micro bs, shuffle=True, collate fn=dpo collate, drop last=True opt, sched, scaler = new opt cfg.dpo lr, cfg.dpo steps it, step = iter dpo dl , 0 while step < cfg.dpo steps: agg = {"loss": 0.0, "acc": 0.0, "margin": 0.0} for in range cfg.dpo accum : try: b = next it except StopIteration: it = iter dpo dl ; b = next it b = {k: v.to DEV for k, v in b.items } with torch.no grad , model.disable adapter : ref c = seq logps b "chosen input ids" , b "chosen attention mask" , b "chosen labels" ref r = seq logps b "rejected input ids" , b "rejected attention mask" , b "rejected labels" pol c = seq logps b "chosen input ids" , b "chosen attention mask" , b "chosen labels" pol r = seq logps b "rejected input ids" , b "rejected attention mask" , b "rejected labels" losses, r c, r r = dpo loss pol c, pol r, ref c, ref r, beta=cfg.dpo beta, label smoothing=0.0 loss = losses.mean / cfg.dpo accum scaler.scale loss .backward agg "loss" += loss.item agg "acc" += r c r r .float .mean .item / cfg.dpo accum agg "margin" += r c - r r .mean .item / cfg.dpo accum step opt opt, sched, scaler ; step += 1 if step % 8 == 0 or step == 1: print f" dpo step {step: 3}/{cfg.dpo steps} loss {agg 'loss' :.4f} " f"reward acc {agg 'acc' :.2f} margin {agg 'margin' :+.3f}" dpo acc = evaluate "after-dpo", eval rows We batch the chosen and rejected responses separately and calculate their length-normalized sequence log probabilities with Open Instruct’s native utilities. We compare the active LoRA policy against the frozen base reference policy and optimize the model using the repository’s DPO loss. We monitor preference accuracy, reward margins, and training loss before measuring the model’s post-DPO verifier performance. print "\n" + "=" 90 ; print "STAGE 3 — RLVR / GRPO" ; print "=" 90 grpo cfg = types.SimpleNamespace loss fn=GRPOLossType.dapo, clip lower=cfg.clip lower, clip higher=cfg.clip higher, kl estimator=cfg.kl estimator gen eos = getattr getattr model, "generation config", None , "eos token id", None terms = {tok.eos token id, tok.pad token id} terms |= set gen eos if isinstance gen eos, list, tuple else { gen eos} TERMINATORS = torch.tensor sorted t for t in terms if t is not None , device=DEV def token logps seq, attn, temperature, grad=True : pos = attn.cumsum -1 - 1 .clamp min=0 ctx = torch.enable grad if grad else torch.no grad with ctx, amp : logits = model input ids=seq, attention mask=attn, position ids=pos .logits return per token logps fn logits / temperature, seq def rollout batch rows : G = cfg.samples per prompt ids = r "input ids prompt" for r in batch rows P = max len x for x in ids pin = torch.tensor tok.pad token id P - len x + x for x in ids , device=DEV pmask = torch.tensor 0 P - len x + 1 len x for x in ids , device=DEV model.eval with torch.no grad , amp , with cache : seq = model.generate input ids=pin, attention mask=pmask, do sample=True, temperature=cfg.grpo temperature, top p=1.0, top k=0, max new tokens=cfg.grpo max new, num return sequences=G, pad token id=tok.pad token id model.train resp = seq :, P: is term = torch.isin resp, TERMINATORS first = torch.where is term.any 1 , is term.float .argmax 1 , torch.full resp.shape 0 , , resp.shape 1 - 1, device=DEV idx = torch.arange resp.shape 1 , device=DEV .unsqueeze 0 resp mask = idx <= first.unsqueeze 1 .long full mask = torch.cat torch.zeros seq.shape 0 , P, dtype=torch.long, device=DEV , resp mask , 1 attn = torch.cat pmask.repeat interleave G, 0 , resp mask , 1 texts = tok.batch decode resp, skip special tokens=True gts = r "ground truth" for r in batch rows for in range G srcs = r "dataset" for r in batch rows for in range G scores = verify batch texts, gts, srcs per prompt = scores.reshape -1, G mean g = np.repeat per prompt.mean -1 , G, 0 if cfg.adv norm == "standard": adv = scores - mean g / np.repeat per prompt.std -1 , G, 0 + 1e-8 else: adv = scores - mean g adv t = torch.tensor adv, device=DEV, dtype=torch.float32 .unsqueeze 1 .expand as full mask.float return seq, attn, full mask, adv t, scores, texts opt, sched, scaler = new opt cfg.grpo lr, cfg.grpo iters cfg.grpo inner epochs order = list range len rlvr ds ; random.shuffle order for it i in range cfg.grpo iters : rows = rlvr ds order it i cfg.prompts per iter + j % len rlvr ds for j in range cfg.prompts per iter seq, attn, mask, adv, scores, texts = rollout rows with torch.no grad : old lp = torch.cat token logps seq i:i + cfg.grpo micro bs , attn i:i + cfg.grpo micro bs , cfg.grpo temperature, grad=False for i in range 0, seq.shape 0 , cfg.grpo micro bs with model.disable adapter : ref lp = torch.cat token logps seq i:i + cfg.grpo micro bs , attn i:i + cfg.grpo micro bs , cfg.grpo temperature, grad=False for i in range 0, seq.shape 0 , cfg.grpo micro bs n chunks = math.ceil seq.shape 0 / cfg.grpo micro bs for ep in range cfg.grpo inner epochs : stats = {"pg": 0.0, "kl": 0.0, "clip": 0.0} for i in range 0, seq.shape 0 , cfg.grpo micro bs : sl = slice i, i + cfg.grpo micro bs new lp = token logps seq sl , attn sl , cfg.grpo temperature, grad=True new lp , old lp , ref lp = new lp :, :-1 , old lp sl :, :-1 , ref lp sl :, :-1 m , a = mask sl :, 1: , adv sl :, 1: ratio = torch.exp new lp - old lp .clamp -20, 20 pg, clipfrac, kl = compute grpo loss new lp , ratio, a , ref lp , grpo cfg, torch.ones like ratio loss = masked mean pg + cfg.grpo kl beta kl, m / n chunks scaler.scale loss .backward with torch.no grad : stats "pg" += masked mean pg.detach , m .item / n chunks stats "kl" += masked mean kl.detach , m .item / n chunks stats "clip" += masked mean clipfrac.detach , m .item / n chunks del new lp, ratio, pg, kl step opt opt, sched, scaler if DEV == "cuda": torch.cuda.empty cache print f" grpo iter {it i+1}/{cfg.grpo iters} ep{ep+1} reward {scores.mean :.3f} " f" solved {int scores.sum }/{len scores } pg {stats 'pg' :+.4f} " f"kl {stats 'kl' :.4f} clipfrac {stats 'clip' :.3f}" print "\n sample rollout - ", textwrap.shorten texts 0 .replace "\n", " " , 220 rlvr acc = evaluate "after-rlvr", eval rows print "\n" + "=" 90 print f"{'stage':<14}{'verifier acc': 14}" for name, val in "base", f"{base acc:.3f}" , "sft", f"{sft acc:.3f}" , "dpo", f"{dpo acc:.3f}" , "rlvr", f"{rlvr acc:.3f}" : print f"{name:<14}{val: 14}" print "=" 90 OUT = "/content/tulu-mini" if os.path.isdir "/content" else "./tulu-mini" merged = model.merge and unload merged.save pretrained OUT ; tok.save pretrained OUT print f"merged checkpoint - {OUT} equivalent to python open instruct/merge lora.py " We generate multiple sampled responses for each prompt, score them with deterministic verifiers, and calculate group-relative advantages from their reward distributions. We optimize the policy with Open Instruct’s GRPO and DAPO-style clipping logic while applying response masks, importance ratios, and KL regularization against the reference model. We finally compare accuracy across the baseline, SFT, DPO, and RLVR stages before merging the LoRA adapters and saving the completed checkpoint. In conclusion, we implemented a practical miniature version of the Tulu 3 post-training stack and observed how each training stage changes model performance on verifier-scored mathematical reasoning tasks. We first established a baseline, improved instruction-following through supervised fine-tuning, refined response preferences through length-normalized DPO, and finally optimized verified task rewards using group-relative advantages and the repository’s GRPO loss implementation. We also used LoRA to maintain an accessible reference policy, apply response masking and KL regularization during reinforcement learning, compare accuracy across all training stages, and export a merged checkpoint for later inference or evaluation. Check out the FULL CODES here . Also, feel free to follow us on and don’t forget to join our Twitter https://x.com/intent/follow?screen name=marktechpost and Subscribe to 150k+ML SubReddit https://www.reddit.com/r/machinelearningnews/ . Wait are you on telegram? our Newsletter https://magic.beehiiv.com/v1/f5e63dd4-5653-4f09-83e2-321a8b1ba526?email={{email}} now you can join us on telegram as well. https://t.me/machinelearningresearchnews Need to partner with us for promoting your GitHub Repo OR Hugging Face Page OR Product Release OR Webinar etc.? Connect with us https://forms.gle/wbash1wF6efRj8G58 Sana Hassan, a consulting intern at Marktechpost and dual-degree student at IIT Madras, is passionate about applying technology and AI to address real-world challenges. With a keen interest in solving practical problems, he brings a fresh perspective to the intersection of AI and real-life solutions.