r/MachineLearning • • 14d ago

Discussion [D] Self-Promotion Thread

Please post your personal projects, startups, product placements, collaboration needs, blogs etc.

Please mention the payment and pricing requirements for products and services.

Please do not post link shorteners, link aggregator websites , or auto-subscribe links.

--

Any abuse of trust will lead to bans.

Encourage others who create new posts for questions to post here instead!

Thread will stay alive until next one so keep posting after the date in the title.

--

Meta: This is an experiment. If the community doesnt like this, we will cancel it. This is to encourage those in the community to promote their work by not spamming the main threads.

8 Upvotes

51 comments sorted by

1

u/tenkei_01 14d ago

Since coding agents write most of our ML code, I wanted a way to verify the output of model without having to read every single line of code, so I tried to trick the agent into writing the code in a way I can inspect the output directly, here example result for RD_DETR x QWEN3 run:

https://supervision.ml-pipes.com/assets/detect_and_attribute/inspection_qwen3_vl_2b_instruct.html

The trick is very simple, the constraints are fed to model as a framework, and the model has to follow the framework rules and validations, you can try it with your existing code (it handle generating report from existing code) without installing any plugin or mcp (simply ask your coding agent to migrate a pipeline to ml-pipes and create an inspection report):

https://github.com/trained-by-humans/ml-pipes

1

u/p3rdy 14d ago

Flama: an open source Python framework where a trained model is just another API resource, now written up on arXiv (2608.18733).

It starts from the deployment gap: fitting a model is easy, but putting it in front of users still means gluing a web framework, a model server and an inference engine together. In Flama a prediction route is a route:

  • Predictive models: scikit-learn, PyTorch, TensorFlow or Hugging Face models are packaged into a single .flm file with their metadata and metrics, and served with one command.

  • LLMs: one deployment answers the OpenAI, Anthropic and Ollama APIs at once, with reasoning and tool calls decoded on the server.

  • The rest of the API: type-driven validation and OpenAPI docs, dependency injection, CRUD from database tables, JWT auth and MCP tools, on a Rust core.

Free and Apache-2.0, not selling anything. Feedback from people deploying models is very welcome.

Code: https://github.com/vortico/flama

Paper: https://arxiv.org/abs/2608.18733

1

u/No-Childhood-2502 14d ago

Indicodec - A neural speech codec for speech LMs and TTS models, one of its kind, trained on English and indian languages.

Strongest on Indian languages: On 10 Indian languages, IndiCodec adds 9x less error than the Mimi codec, with 25% fewer tokens.
In English, it has the lowest WER of the ~1 kbps codecs we tested.

It sounds closer to the original. PESQ-WB on speakers never seen in training: ahead of Mimi on 3 of 4 test sets (FLEURS, LibriTTS-R, CMU-Arctic), just behind on Seed-TTS, and ahead of SNAC and NeuCodec on all four.

Lowest error in all 10 Indian languages.

Open source with Apache 2.0
HF: https://huggingface.co/prakharkhatri/IndiCodec

1

u/ModularMind8 14d ago

I built QuiddityML, an app that teaches ML with short lessons, hands-on exercises, and fun interactive games: https://quiddityml.com

Pricing: Python, PyTorch, NumPy and Math for ML are free, plus the first unit of every other track. Pro is $19.99/month.

1

u/rustydustyshckleford 14d ago

I released grinpress v3: a tiny 128x128 rectified-flow model trained from scratch to draw newsprint-style faces with custom text up to 14 characters. Free live demo and MIT-licensed downloadable weights; no purchase required.

The 50-step teacher is distilled into 2- and 4-step students, shipped as ONNX with dynamic INT8 quantization. Mean CPU latency was 0.270s / 0.540s per image on an 8-vCPU Intel Xeon VM, 8 threads, batch 1, after warm-up. A slower Colab CPU measured 0.536s / 0.988s median, so hardware matters.

On a 48-string held-out evaluation, the shipped INT8 students scored 45/48 (2-step) and 46/48 (4-step) case-sensitive CRNN exact matches. The judge itself only reads 47/48 procedural reference renders correctly, so this is a small-domain experiment with an imperfect metric, not a broad text-rendering benchmark. Long phrases and word spacing remain limitations. Eval artifacts, sample grids, and benchmark details are in the model card.

Model: https://huggingface.co/skyuu72/grinpress-v3

Demo: https://huggingface.co/spaces/skyuu72/grinpress-v3-demo

Gazette sample image: https://www.reddit.com/r/StableDiffusion/comments/1xlxrqz/i_trained_a_tiny_image_model_from_scratch_that/

I'd welcome feedback on evaluating glyph errors separately from OCR-judge errors, or CPU timing reports.

1

u/Fickle_Worry_6734 13d ago

Operators Day - Meet 10 founders building startups and hiring founding talent (Nov 5)

I'm part of EWOR's Talent team, and we're organising Operators Day this Thursday, November 5 (4:30 PM CET), online.

Ten early-stage founders will pitch what they're building and share the founding roles they're hiring for. These include AI/ML and robotics engineering roles, CTO and other technical leadership positions, as well as product, marketing and sales roles.

It's free to attend and could be interesting if you're exploring an early-stage startup opportunity or considering joining a founding team.

Registration: https://luma.com/OperatorsDay?utm_source=reddit&utm_content=machinelearning

Disclosure: I'm part of EWOR's Talent team and helping organise the event.

1

u/Uyi_Uwadiae 12d ago

Signed-up, thanks for sharing!

1

u/Fickle_Worry_6734 12d ago

See you there!

1

u/Creative-Feature-264 13d ago

Standard parallel reduction kernels in PyTorch/TensorFlow trade numerical accuracy for speed on GPUs. In float32, parallel Welford / two-pass methods accumulate a relative rounding error around 6.6e-4. When you scale layer depth vertically, that noise compounds and eventually corrupts gradients and convergence.

Dense-Armor is a JAX-native framework that targets this bottleneck directly.

On a single Tesla T4, it lets you train roughly 3x deeper architectures without gradient degradation or OOM.

Pure gradients via compensated trees

This drops the relative variance error from ~6.6e-4 to ~1.7e-8 while preserving GPU parallelism. On a T4 it runs at 2.24x the speed of the plain two-pass formula, and gradients stay stable across extreme depths.

~78% VRAM savings with remat=True

Paired with jax.checkpoint activation rematerialization, peak memory drops to 0.22x on deep blocks — removing the linear memory penalty of deep backpropagation.

Fused training execution

Trainer(compile=True) fuses forward, backward, gradient clipping, and the AdamW update into a single compiled XLA function. Measured acceleration: ~4.4x on Transformers, ~9.7x on MLPs.

Caveats

  • All benchmarks are single-GPU (T4), float32. Multi-GPU numbers aren't published yet.

  • The compensated tree has a small constant-factor overhead per op; the 2.24x figure is measured against the plain two-pass baseline on the same hardware, not against every possible cuBLAS-optimized kernel.

  • Early-stage project: the training core is the most mature part; some other subsystems are less battle-tested.

  • Not benchmarked against PyTorch's torch.compile end-to-end yet — that comparison is on my list.

If you're pushing model depth on consumer-grade hardware and hitting numerical instability, I'd be glad to hear whether this helps, and where it breaks.

Links

Happy to answer technical questions about the reduction algorithm, the fusion pass, or the memory strategy.

1

u/lostmsu 13d ago

https://mlnews.online/ - discuss papers (and only ML papers) on Hacker News. For people who don't like the new Reddit login requirements.

1

u/InfiniteInflation427 13d ago

🚀 Meet Zukko — Access Top AI Models for Up to 80% Less!

We’ve built a universal AI API router that gives you access to the world’s leading AI models at up to 80% lower prices than official providers.

🔥 What you get:

  • Access to top AI models from multiple providers.

  • One unified API for all your favorite models.

  • Save up to 80% on API costs.

  • Support for text, image and other AI capabilities.

  • Easy switching between models and providers.

⚡ Get started in just 5 minutes!

We’ve prepared video tutorials, setup guides, and examples to make integration as simple as possible.

No complicated setup. Just top AI models at a fraction of the usual cost.

🌐 https://zukko.pro

1

u/FulcraDynamics 13d ago

We're building Fulcra, a platform that gives AI agents access to shared context across different apps and tools.

One of the problems we're trying to solve is how disconnected AI assistants are. You might use Claude, ChatGPT, and other agents, but each one has its own memory, and switching between them often means starting from scratch.

With Fulcra, agents can access and share relevant information while users stay in control of their data and permissions. We're also working on making it easier for different agents to communicate and collaborate.

Pricing:

  • Free: 5 GB of storage

  • Pro: $14.99/month or $149.99/year

  • Scale: Custom pricing for teams and businesses

You can check it out here:
https://fulcradynamics.com/?utm_source=reddit&utm_medium=social&utm_campaign=reddit_growth

We're interested in hearing how other developers are handling persistent memory and context sharing between agents. Is this something you've run into while building AI applications?

1

u/deckartes 13d ago

I built a free one that runs entirely in the browser, so nothing is uploaded: https://detector.esperr.dev/

Small models, so it isn't perfect (no detector is), and it shows probabilities rather than verdicts. Code and models are public.

1

u/Uyi_Uwadiae 12d ago edited 12d ago

Making Connection: Artificial Intelligence meets Abstract Ingenuity 

Hey everyone! As someone who loves building custom puzzles (Crafting Connections), I wanted to see how today's LLMs actually handle the game's unique mix of lateral thinking, cultural subtext, and red herrings.

​I ran an experiment putting eight AI models (Gemini, Claude, DeepSeek, Vibe by Mistral, Copilot, ChatGPT, Muse, and Grok) through 10 rounds of 5 more recently published NYT boards with low solve rates and 5 original custom puzzles I crafted.

A few quick takeaways:

  • ​Gemini and Claude tied for the top spot, solving 30/40 total connections and mastering standard NYT wordplay

  • While they sailed through 91% of official NYT boards, they didn't fully solve any of my themed custom puzzles

  • Watching models fall for classic decoys, get trapped in one-away loops, and make wild guesses was entertaining 

​I wrote up the full deep-dive with some of the data, scoreboards, and model breakdowns in my article Making Connection: Artificial Intelligence meets Abstract Ingenuity and also have a presentation deck with more charts. The full data is available on ResearchGate.

Let me know what you think! 

1

u/0xcontext 12d ago

https://github.com/sshah03/shrewd-studio/

I'm working on a project where I need a large number of small locally runnable models. In service of this, I had initially built what I ended up putting out there as the shrewd package (https://github.com/sshah03/shrewd) where I also documented things that worked for me / didn't, running on examples that weren't my private data to demonstrate this. Supports single label classifiers, and multi label decision panels (kind of like jev, but not zero shot obviously).

There are a few key things I wanted

- Support running on multiple LLMs and taking the most agreed on result, or flagging split decisions for me to manually label (or default to the model I trust more)

- Use GEPA to optimize the labelling prompt to try to get as good a result as possible on a pre-defined tuning set (separate from training and test sets)

- Easily compare different training methods to see what performs better (accuracy, model size, latency etc...)

This was working out pretty well for me, but some steps were getting tiresome so I built a GUI where everything in it basically just links to calls in the package. It made it much simpler to use so I decided to open that up for people as well.

There's a video in the README demonstrating the different things it supports. If there are things people need it to support / export for their projects, let me know and I'm happy to help.

1

u/what-isthe-cloud 12d ago
The CASP-DREAM TAP Challenge now open for registration. A contest on predicting which TCRs activate against a peptide-MHC. Free to Registar its a computational contest that may interest people who work with T cell responses. Teams build models that predict whether a T cell with a given TCR activates against a given peptide-MHC. The labels come from functional assays (MIRA with CD137 readout, with pairSEQ for alpha/beta pairing) and cover more than 700 peptides across more than 40 class I HLAs. Synapse lists training data options, including the public VDJdb database and Harell Data's proprietary TCR datasets provided by Adaptive Biotechnologies. Registration is open now: https://www.synapse.org/Synapse:syn77965030/wiki/643867

1

u/latenticlabs 12d ago

scime: two free tools for ML researchers (small team, Latentic Labs)

  1. scime atlas (https://atlas.scime.ai): a map of all ~109k accepted papers at ICML, NeurIPS, ICLR, CVPR and AAAI (2016-2026). Describe your idea in a sentence and it shows the closest accepted papers, which topics they sit in, and how the area has grown. The research topic pages (atlas.scime.ai/research) summarize each area and its approaches.

  2. scime draft (https://draft.scime.ai): a LaTeX workspace for ML papers with real-time co-authoring and a pre-submission check. CVPR 2027 papers are due Nov 16 (AoE), so you can drop your Overleaf ZIP at draft.scime.ai/guides/cvpr-2027 and it checks the source for CVPR 2027 rules (2027 template, review mode), anonymity leaks, unreferenced figures and labels, cite keys missing from your .bib, and typos. It runs in memory, nothing is stored, and you don't need an account. The full check (page count on the compiled PDF, every reference looked up on arXiv, DBLP, Crossref and OpenAlex) needs a free account.

Pricing: both are free. No payment details are needed, and AI help runs on our own model.

Feedback we'd value most: false positives in the check, and papers or topics the atlas gets wrong.

1

u/runemanga 12d ago

I’m working on RuneManga, a manga translation extension. It translates the text right on the page, and we’re also testing a coloring feature. If you give it a try, I’d like to hear what feels awkward or needs fixing. There are free credits to start, then paid plans. https://runemanga.com

1

u/2dayyy6 12d ago

Do looped transformers, which reuse the same weights at every iteration, also save HBM traffic? I profiled Huginn's recurrent Core on a B200: a shared weight helps only while it fits in L2, and eight iterations still read about eight times as much data from HBM as one.

Post: https://dinara-dl.github.io/posts/looped-transformer/

Code and data: https://github.com/dinara-dl/looped-transformer

1

u/VulcanTrading 11d ago

Vulcan Trading is a markets research platform. The desk is a set of quantitative strategies, mostly statistical tests and models run on market price data, and each one has its own page showing the method and a chart of what it has flagged and when. We built it so that every strategy publishes its method, and we're now opening the outcomes of those strategies as a structured data feed.

A signal here is one row: which strategy fired, on what market, at what time. Our Signal API carries those rows for the strategies the desk opens to it. The feed is the same rows shown on the strategy pages, delivered outward instead of displayed.

A row tells you what one strategy did. It cannot tell you why the strategy was built, what it was tested on, or whether the conditions it was built for are the conditions you are in now. Those live on the strategy's own page on the desk, in the method written beside its chart. Reading them once turns a row from a number into a research point you understand.

Pricing: pre-commercial, no price yet. The Signal API is coming and there is a waitlist on the site. No link on purpose: this account is new and Reddit's filter has eaten two linked posts. The site is easy to find by name.

Feedback we'd value most: if you read a signal feed in your own code, what would a row need to carry next to the signal itself (the method it came from, the window it was tested on, the conditions it was built for) before you would let it into a pipeline? We'd like to understand what is missing.

Posted by the Vulcan Trading account. An analysis platform, not a broker. Not investment advice.

1

u/Firm_Review3779 11d ago

Hello guys, I'm running an interview of some ai developers. Please feel free to dm me, they are just few simple and easy survey based questions (no links)

1

u/SPJohnJohn 11d ago

I built a topic-wise Mathematics for Machine Learning practice collection on Synapticz, covering linear algebra, calculus, probability and optimization, with worked explanations. The collection is free: https://synapticz.com/quizbooks/b418ed04-27d0-4348-847c-2ebd26abd761/topic-mml

For a focused starting point, this PCA quiz connects maximum projected variance with minimum reconstruction error: https://synapticz.com/quizzes/578635a3-f775-4f5a-9867-dc9ac2fb5b21/mml-14-11 . Try deriving both objectives on the same centered dataset before checking the choices; feedback on unclear explanations is welcome.

1

u/CogniviumOfficial 10d ago

Disclosure: I run Cognivium and made this video. I'm not affiliated with MIT or the researchers.

I made an 8-minute visual explainer about the weight-space programming experiments: a frontier language model analyzing small networks and making targeted changes to another model's weights.

One result covered is the Qwen3.5-0.8B intervention: with Python tools, practice problems and up to 50 forward passes, Astra edited 131,072 weights (about 0.016% of the model). The reported MATH-500 score rose from 7.9% to 48.1%. The video separates that result from the smaller game-network experiments and explains why this does not demonstrate unlimited recursive self-improvement.

Video (free to watch): https://www.youtube.com/watch?v=1nZHBBaIS5I

Original research: https://rikiyat.github.io/blog/weight-space-programming/

The video uses AI-assisted illustrative visuals and narration. I'd welcome feedback on how clearly it explains the distinction between reading weights and tool/feedback-guided weight editing.

1

u/CivilDatabase7508 8d ago

LocalSR: a free, open-source (MIT) desktop app for upscaling, denoising and restoring photos and videos locally, with current SR models like SPAN, RealPLKSR, HAT and the ESRGAN-type models, plus any OpenModelDB model through spandrel. I built it because there was no upscale app that is up to date with the cutting edge models and that has an easy to use and understand UI.

The part that might interest people here is the Neural Engine on Apple Silicon. The app converts the PyTorch models to Core ML on the device and caches them. Before it uses the Neural Engine, it runs the first tile both ways and only keeps Core ML if the PSNR against PyTorch is at least 45 dB and it is actually faster. On my M1 Pro, SPAN, the ESRGAN-type models and FBCNN run fully on the Neural Engine and are 2.2 to 3 times as fast as PyTorch on MPS in fp32. FBCNN on a 12 MP photo took 9.5 s and 48 J instead of 26 s and 554 J. RealPLKSR is slower there because of its large 17x17 convolutions, so it runs on the GPU through Core ML instead, and HAT stays on PyTorch.

It runs on Mac (signed and notarized), Windows and Linux. Constructive criticism is very welcome.

https://github.com/HerRei/local-upscale

1

u/ExplanationMassive78 7d ago

I run Techmixer. I wrote two walkthroughs for checking a local ML workflow before trusting its output.

Soup (local LLM fine-tuning): I validated a small JSONL dataset and the YAML config, then opened the dashboard. The walkthrough stops short of training. If you continue, keep unseen examples aside and compare the adapter with the base model on the same task. https://www.techmixer.com/soup-llm-fine-tuning-setup/

Kronos (financial time-series forecasting): Start with clean OHLCV candles, keep the evaluation period later than the input window, and compare forecasts with a persistence baseline. Getting a forecast to run does not establish a trading edge. https://www.techmixer.com/kronos-ai-setup-financial-forecasting/

1

u/Internal-Purpose5469 6d ago

[P] CC BY, AI-generated illustrations for 11,011 bird species with per-image AI review scores, for experiments in zero-shot recognition

I made these for a birding app. They're AI-generated and AI-reviewed, and I haven't tested whether they improve recognition. Free to download, no signup required.

Why they might be useful: field-guide illustrations can help recognise species that have no training photos (Rodríguez et al., "Recognition of Unseen Bird Species by Learning From Field Guides", WACV 2024). The illustrations used there come from Birds of the World; access and reuse are subject to its terms. This set is CC BY 4.0: one image per species for 11,011 species drawn from AviList v2026, mostly in side view, with scientific names and cross-database IDs (eBird, Avibase, GBIF, Wikidata) where available to help build label mappings, and an AI review score per image.

How it was made: an image model draws each species from a written description of its field marks plus reference photos where available; a second model scores each image on identification marks, plumage, bill and eye, legs and feet, and proportions, and images were regenerated until they passed. Passing doesn't mean an image is free of errors. I'd be glad to hear if someone runs a baseline.

HF: https://huggingface.co/datasets/yunfeichen/huashu-bird-sticker · DOI: 10.5281/zenodo.23968399 · Repo: https://github.com/alchaincyf/huashu-bird-sticker

1

u/papapin777 6d ago

I run Has Brains and made How LLMs Work, an animated course for people who use AI and want to understand what happens behind the chat box.

One lesson follows a prompt from your browser to the GPU and back. The part I wanted to make clear is the difference between prefill, when the model processes the input, and decode, when it generates the reply token by token. That distinction helps explain why there can be a pause before the first word and then a steady stream.

Sample video: https://www.youtube.com/watch?v=8d1WllwHZmQ

Course and lesson list: https://hasbrains.com/courses/how-llms-work

Six of the planned 23 lessons are up, including three free previews. The full course is part of Has Brains membership ($12/month or $100/year). Each lesson has a transcript. If you teach LLM basics, I’d appreciate feedback on whether the animation makes that split easy to follow.

1

u/Competitive_Summer30 6d ago

Commercial introduction — I'm Cam, a product engineer handling data partnerships at Axiom Frontier.

We've secured authorized data access through multiple major API aggregation platforms, giving us access to a substantial corpus of agent and coding trajectories, including Astra and Fable interactions, with complete conversation context preserved.

For teams working on coding or agent models, is this category relevant to a current training project, or who evaluates external data on your team?

Pricing and evaluation terms are not yet available to share. You can reply here or reach me at [email protected].

1

u/Responsible-Swim1350 6d ago

ReDefiNER is a 0.8B model for local entity extraction. You tell it what to extract in plain English and change the rules without retraining.

I’m Cibe from Jungroo AI Labs. We built it because teams working with private data often disagree on what counts as an entity, and those definitions change as the project evolves.

  • Editable rulebook. Define entity types, exclusions, where spans start and end, and which label wins when two apply.

  • Exact spans. It returns character offsets, labels, and confidence scores. It selects spans from the input without generating text.

  • Local inference. The int8 weights are a single 0.77 GB file. With the rulebook cached, we measured 0.4–0.7 seconds per sentence on a 4-core CPU or an M2.

Code and weights are free under Apache 2.0.

I’d especially like to see cases where you edit a rule and the output stays the same when you expected it to change.

Model - https://huggingface.co/jungroo-ai/redefiner-0.8b

Demo - https://huggingface.co/spaces/jungroo-ai/redefiner-demo

Install locally with pip install redefiner.

1

u/LimitlessMatrix 5d ago

I teach AI security in Salt Lake City and I’m opening my first paid cohorts. In person, small group, Wednesdays 11am to 1pm starting Nov 18, with an evening cohort forming after that if there’s demand. I’ve presented at DEF CON and SAINTCON, where I run an AI red teaming CTF. Three tracks: AI Foundations is $250 for four sessions or $95 to drop in on session one, Building With AI is $395 for four sessions or $125 drop in, and AI for Security is $1,500 for four live labs covering hands on attack work like prompt injection and jailbreak evaluation. There’s also a free Thursday intro class if you want a taste first. You bring a laptop and leave having actually built something. Signup: https://docs.google.com/forms/d/e/1FAIpQLSdO88YMH-mPW-1u4AqlADurE-iOYxXgl_1_Iha205V_lLBJSg/viewform. Run by my company NT Operations LLC at a local SLC hackerspace. Happy to answer curriculum questions here.

1

u/NevolraDEV 5d ago

Nevolra RAC — Independent Research into Persistent AI Learning and Memory

I'm the independent developer behind Nevolra Recursive Adaptive Cognition (RAC), a research project started in September 2026.

The central question is whether an AI learning system can retain useful models of previous environments, recognize when those models become relevant again, and adapt without unnecessary forgetting.

We've built early experimental tooling, including a numerical learning baseline, Genesis Lab, and Genesis Arena.

One of our synthetic memory comparisons produced a negative result: memory assistance improved one returning-condition prediction but worsened overall prediction error. We're using findings like this to investigate when memory retrieval is genuinely useful and when it causes interference.

Our next research stage focuses on blind context recognition, selective memory reuse, reproducible evaluation, and comparisons against established learning methods.

I'm currently funding development personally and seeking $3,000 in voluntary research sponsorship for a 90-day experimental cycle.

Supporters receive public progress updates and research summaries. Contributions do not confer equity, financial returns, or access to confidential project materials.

Research documents: https://drive.google.com/drive/folders/19jo8_QNNlpsdrT_XqLzh5ltDVeyN9y3S?usp=sharing

Research sponsorship: https://ko-fi.com/nevolradevelopmentfund

I'd particularly welcome technical feedback on evaluating memory selection and continual learning without information leakage.

1

u/Valeztrio 5d ago

Started making this LLM few days ago, and I've trained it till 2556 steps, Its called Micro-llm, a small hand crafted llm that was made using Pytorch and Numpy and trained on Hugging-Face open sourced data named "no_robots", its still in progress, but id love to see people noticing this small project of mine, its currently in Hugging face (unsurprisingly), and its available in a .zip file, Version name - V1.0.1, here's the link - "https://huggingface.co/Valeztiro/Micro-llm" Thanks for your time! :)

1

u/rodneyg_ 4d ago

AI Portfolio Lab: a 90-minute live session (Thu Nov 19, 8:00-9:30 PM ET) for engineers moving into AI work who have tutorial projects but no demo they're proud of. We pick one real problem, build the first working slice live, and write a 3-minute demo covering model choice, how you checked output quality, and failure cases. Price: $149, 20 seats, full refund up to 48 hours before; cancelled and refunded if fewer than 3 sign up by Nov 17. https://luma.com/zyjp4tyc

1

u/ExplanationMassive78 4d ago

I run Techmixer and compared five cloud GPU options for small ML jobs. Before a long experiment, I’d write a small checkpoint or result to storage that survives a restart and open it from a fresh session. A notebook being saved doesn’t guarantee its runtime files are saved too. Colab and Kaggle are good starting points for notebooks, while ZeroGPU suits short demos. The guide also covers credit-based options and what to check before starting a job.

https://www.techmixer.com/free-cloud-gpu-options/

1

u/ande765a 4d ago

Meet Duo

Duo is a full-duplex conversational AI. It listens while it speaks and hears your voice directly instead of a transcript, so it reacts to pauses, a quick "mm-hm" and interruptions as they happen.

Check out the demos at duplexio.ai
Model weights and technical write-up coming up!

1

u/sudorian 3d ago

Weight-space implants: I had GPT-6 Astra hand-write exact 3-digit addition into GPT-2 small's existing weights, with no gradients and the embeddings and output layer frozen. On fresh problems it went from 0/2,000 to 19,988/20,000, and 98.66% of its next-token predictions on fresh prose stayed the same. It only works in one format, and the same attempt on Gemma 3 270M failed the text bar. An agent in mfaseehuddin/wsp got a more general adder into Qwen2.5-0.5B a few days earlier by adding new layers, while this one only rewrites existing weights. The independent re-test and audits are in the repo: https://github.com/sudorian/weight-space-implants

1

u/Herberton777 3d ago

I've been developing Car Price Studio, an open-source applied ML project for historical used-vehicle pricing.

It covers advertised asking prices and a separate wholesale auction population in the US, alongside European asking-price estimates.

The modeling experiments include neural architectures, quantized text embeddings, accelerated-failure-time regression, robust Huber objectives and outlier handling.

Evaluation includes MAE, RMSE and CVaR95, so unusually large prediction errors get attention instead of disappearing into an average.

An especially interesting issue is temporal validity: historical cross-validation is not evidence that a model accurately predicts contemporary transactions after a market adjustment.

I'd be interested in research feedback on three questions:

  1. How would you validate time extrapolation when genuine recent transactions are unavailable?

  2. Would you prioritize conformal calibration, distribution-shift diagnostics or alternative tail-risk objectives?

  3. What are your preferred approaches for combining free-text vehicle descriptions with tabular features without leakage?

MIT-licensed code: https://github.com/botsandbolts/Pricing

Demo: https://pricing-5a4k2zenhw2nte9xpshxs3.streamlit.app/

Free, no registration, and still very much an experimental research project.

1

u/SciSpaceSupport 3d ago

SciSpace: early access to a scholarly search API and an agentic literature-review API (free credits)

A bit about SciSpace (scispace.com): An AI research agent built for academic work. It handles paper discovery, literature reviews, citation verification, academic writing and grant proposals, so researchers can run whole research tasks in one place instead of switching between tools.

We’re now opening up the underlying capabilities as APIs. Early access is open for two APIs:

  • Search / Literature Review API: programmatic search over scholarly papers, plus literature-review style synthesis of the results

  • Agentic API: our research agent exposed as a callable tool, for multi-step literature tasks (search → screen → synthesize → cite) that you can run inside your own pipelines

  • Possible use cases

    • RAG and grounding over scientific literature

    • Evidence or citation pipelines where outputs need to trace back to papers

    • Research tools built on top of paper search/review instead of maintaining your own index

    • R&D teams in AI/ML, pharma and biotech doing recurring literature scans and more!

Access: Free credits for early-access users. Request access here: https://tally.so/r/dWG01z

We’d especially like feedback from people who’ve built RAG over papers. What broke for you: coverage, citation accuracy, latency, or how the output was structured? Happy to answer technical questions in the thread.

1

u/CogSpace-org 2d ago

https://youtu.be/D1s6vZ67yGo?si=Q9nqaL7ZL5A5ewx2
Verbalized confidence vs. a linear probe on Llama-3.1-8B-Instruct: 0.59 vs 0.81 AUC on the same answers (code, data, activations) . Context: this is the last act of a 52-minute documentary on metacognition.

1

u/imfinn005 2d ago

I built NoteCoder, a free experimental browser tool for reviewing diagnosis mentions and suggested ICD-10-CM codes. No account or payment is required.

Phrase matching proposes candidates, then a local decision model checks the full note using WebAssembly. Note text is processed on-device rather than sent to a remote model; initial model downloads are about 2 GB, and device/browser support varies. Highlights explain candidate discovery, not model-verified evidence, and scores are not calibrated probabilities.

Demo and documentation: https://notecoder-navy.vercel.app/

The included synthetic example has a diagnosis revised elsewhere in the document. I’d welcome feedback on evaluating document-level contradictions, false positives, and browser memory/latency tradeoffs. Please use synthetic examples when discussing failures.

This can miss diagnoses or suggest incorrect codes, requires human review, and is not clinically validated or a billing system. Disclosure: I’m the developer; AI assisted development and preparation of this post.

1

u/Firm_Percentage7997 1d ago

Seeking research collaborators in representation learning or LLM agents. I am a published ML researcher and engineer with experience in neural models, privacy-focused ML, tool-using agents, and reproducible evaluation. I can contribute experimental design, implementation, baselines, analysis, and paper writing.

For representation learning, I am interested in how alternative representations affect generalization and robustness; for agents, controlled studies of planning and tool-use reliability are especially interesting. I am open to existing projects and other well-motivated questions.

I am looking for a lab or collaborators with funding for GPU compute and LLM API benchmarking as appropriate to the project. Please comment or message me with your research direction and resources; I can share relevant work privately.

1

u/PanelReader 20h ago

built a random forest classifier for the UCI Dry Bean dataset

  • 7 classes, 16 numerical features

  • 100 trees with entropy splitting

  • 5-fold CV: 92.54%

  • test accuracy: 92.06%

  • GridSearchCV evaluated 4 configurations

  • FastAPI + Docker + pytest

included the classification report, confusion matrix, feature importance plots and reproducible training instructions

repo: https://github.com/Vaibh37/dry-bean-random-forest

technical feedback is welcome. if you find it useful, consider starring the repo ⭐

1

u/No_Advertising_8279 11h ago

ZeroGrad: one Python API for tabular foundation models (TabPFN v2, TabICLv2, Mitra, TabDPT)

Tabular foundation models predict on your table in a single forward pass, with no training and no tuning. Each one ships its own package and license, so I built an SDK that runs them all on the same holdout, next to simple baselines, and keeps the best one.

Pricing: the SDK is free and open source (Apache 2.0). There’s an optional paid hosted platform, but the SDK works fully without it.

Repo: https://github.com/ZeroGradLabs/zerograd-python

It’s early, so feedback on what breaks or what’s missing is very welcome :)

0

u/icecream_for_dinner 6d ago edited 6d ago

I’m the author of The Gradient Does Not See Rank, a free paper about a null result in latent reasoning. I truncated the rank of Matrix-CODI’s latent states and measured ProsQA accuracy. The curve was nearly flat. The useful part was the negative control: a vanilla model also gave a flat curve, so this test could not tell whether rank was irrelevant or whether the selected positions were insensitive to intervention in the first place.

If you use ablations to study latent reasoning, what would you accept as a positive control here? One option is to establish that the selected positions matter before varying rank. Another is to start from a task where the readout is forced through a known rank bottleneck. I’d be interested in what either test could still miss.

Paper: https://arxiv.org/abs/2609.03090

X discussion: https://x.com/samaneggs/status/2119940009994391956

Research notes: https://pebbleml.com/research/

Figure 6 (negative control): changing the retained rank barely moved vanilla GPT-2’s ProsQA accuracy. https://x.com/samaneggs/status/2119942200150872305/photo/1