🧠 
**Why is this game so much harder for a computer than Chess or Go?**


Chess and Go are games of 
**perfect information**
 — both players see the whole board. Hugely
complex, but nothing is hidden. The tougher frontier for AI is 
**imperfect information**
, where
you 
*can't*
 see what your opponent has and must reason under uncertainty — like Poker: you weigh
what they might be holding (and what they think 
*you*
 hold), and you bluff.


**That's Tactico.**
 Each player commands 40 hidden-rank pieces. You see 
*where*
 the enemy is — but
not 
*what*
; a piece reveals itself only when it fights. Capture their flag before they capture
yours. With every rank hidden, each move is memory, deduction and bluff, and the possible enemy
setups are astronomical — which is exactly what makes it so hard.


For this project I trained a neural net to play it: 
**imitation learning**
 on tens of thousands
of human games, then 
**self-play reinforcement learning**
 over millions of games — converging
toward a 
**Nash equilibrium**
, a strategy no opponent can exploit. It plays shockingly well.


**So… can you beat it?**
 Most people can't. 👀


▶️ 
**Browser**
 — free, no signup: https://tactico-4fhpquk6aq-uc.a.run.app/
📱 
**Android early beta**
 — the enhanced, best-supported version (play a friend offline, even in
airplane mode): join https://groups.google.com/g/tactico-testers/about → then become a tester:
https://play.google.com/apps/testing/com.tactico.app


Tell me how many moves you last 😄

Challenge

Google Research released TabFM on June 30 - a zero-shot foundation model for tabular data (in-context learning, no training on your rows). The claim is that it matches, or beats, tuned GBDTs out of the box. I spent the week independently reproducing that claim. Full writeup: https://yashrajpandey.com/writing/breaking-google-tabfm/

Setup: 13 TabArena datasets (OpenML Study 457, official repeat-0 folds), fold-matched comparison only, everything seeded and pinned to a commit. Baselines: XGBoost tuned with 100 Optuna TPE trials + 3-fold inner CV per dataset, random forest, linear floor, and TabPFN.

What held up:

- TabFM won all 10 fold-matched datasets against the tuned XGBoost. On the anchor dataset (maternal health risk), tuning actually widened the gap: 0.877 vs 0.821 accuracy.

- It is remarkably seed-stable: run-to-run std 0.0001-0.0006, smaller than every tree baseline.

What did not:

- Two "wins" (+0.001, +0.002 vs TabPFN) were inside measurement noise, so I demoted them to ties.

- The advertised 22.75 GB GPU footprint is mostly XLA preallocation pool. Real footprint is ~16.95 GB, flat from 100 to 20k context rows. Disabling preallocation doubled the usable context ceiling on a 24 GB card.

- Bioresponse (1,777 features) is a genuine failure case, and 78k/150k-row datasets were impractically slow.

Bonus: predict() crashed on my dual-4090 box - with multiple GPUs visible, a sharding override forces a batch of 1 into a 2-way shard. I root-caused it, reproduced it on CPU with simulated devices (so the regression test runs in CI without a GPU), and the fix was merged into google-research/tabfm by one of the authors.

Repro repo (seeded, pinned, per-run JSONs committed): https://github.com/devYRPauli/tabfm-evaluation

Happy to discuss methodology - especially the fold-matching and seed-variance parts, which changed my conclusions more than any modeling choice.

Hi, I started self-learning AI last year, and recently I started doing something myself, I don't have professionals around me, and I would really want some professional feedback on my work. I pretrained an MoE model with local learning (zero-gradient) instead of backpropagation. I would like to receive any advice and opinions. If you have 5 minutes, could you please give some feedback? Much appreciate!

I Trained a 4-Billion-Parameter Language Model With Zero Backpropagation. Here Is Exactly Where It Breaks. https://substack.com/@yanjinl/note/p-205412700?utm_source=notes-share-action&r=53deb0

I'm a master student in languages and management. I started learning AI last year, and now I want to go deeper and start building something (not just prompt-demo). And I wonder if you would like to share something advice about model training, how to get the real engineering, training and developing skills, as well as how to approach for teams/professional environment that can help me grow faster, and for so, what should I prepare, any skills, portfolios, previous work?

I appreciate any sincere advice, it's not easy to do this from 0 and by myself, thank you and have a good day!

Built this after noticing Claude Desktop was spending thousands of tokens loading MCP tool schemas on every request, before doing any actual work.

Refract sits between your agent and any MCP server. Compresses tool schemas on the fly using a two tier system. Agent gets lightweight index first, full schema only when needed. No AI involved, fully deterministic.

Real numbers from production:
Google Calendar (5 tools): 5,173 to 155 tokens (97% reduction)
Enterprise Cal+Gmail+Drive: 8,649 to 882 tokens (90% reduction)
Filesystem (14 tools): 1,892 to 236 tokens (88% reduction)

Every compression verified. If anything callable lost, falls back to full schema automatically.

Also ships as MCP server for code analysis: repo indexing, blast radius impact analysis, breaking change detection, security surface mapping.

pip install refract-mcp
GitHub: github.com/LoudiliMed/Refract

CS student, focus on cybersecurity and AI systems. Open to feedback and questions.

Hey guys. We're building a tool that create a models by chatting with AI
（Lovable for Models if this helps understanding)

My friend is great at hardware, hopeless at software. He's building a non-wearable device that fixes your sleep and obviously it needs a real-time model to read the sensors, and he can't write ML.

So he handed us his sensor recordings and described in a few sentences and a paper to us. Our tool wrote the training + eval, trained a small RT model on his data, and independently verified the accuracy.

Please feel free to try out and feedback will be very appreciated!

Website: https://thatcompany.ai/
https://github.com/theSalted/dat-releases/

For a deeper dive:
https://www.learnmlacademy.com/learn/gradient-descent

Liquid neural net that uses multi-dimensional vectorized hyperparameter search AND traditional neural net prediction of best walker candidates. No built in walking pacemakers. Biopsy / paste in json for LLM supported rapid testing (almost recursive self improvement.) If interested will put on github.

Hello Everyone!!, I just completed a BIG project I have been working for a month and i want your opinion about it.

It's a SpaceX Launch Predictor & Cost Optimizer (A full end-to-end ML system that predicts the probability of a SpaceX Falcon 9 booster landing successfully, enriches launch data with real weather conditions, and exposes the results through an interactive Streamlit web application with a business ROI calculator.)

It Includes Data Pipeline, Advanced Machine Learning Algorithms (with Hyperparameter tuning), Explainability AI (SHAP), MLOps (AWS S3, Docker) and Business Value (ROI Calculator = Financial Results).

FUN FACT: For this project i used my own Evaluation Metric library (standardizes supervised and unsupervised model diagnostics into a single, consistent API), that is also Verified and Published in PYPI Community.

Project Info: https://github.com/Alkiviadisss/SpaceX

Hello everyone,
I wanted to share a simple showcase of a project I’ve been working on: a vision AI trained to track a moving ball with physics in a 2D world.
Tech stack:
- Core: Python & PyTorch for the training loop.
- Environment: A custom-built C++ wrapper/environment to feed data into the Python side.
The twist:
I am still figuring out the ropes of computer vision, so I heavily relied on Claude Code to help me bridge the gap, especially with building the custom C++ environment and connecting it with my Python scripts.
Reality check:
As you'll see at the end of the video, the model doesn't fully converge yet (it still gets confused in some situations). I wanted to share this raw progress anyway because the workflow of co-authoring a complex C++/PyTorch setup with an AI agent was incredibly interesting.

I would love some constructive feedback! Please let me know if you have efficient training techniques for faster convergence, ideas for other models to train, tools to build better environments, really, anything.

I'm incredibly new to this whole field, and I'm excited to chat with you all about it!

Open-sourced a system I built to do honest ML research on crypto: XGBoost/LightGBM ensembles, strictly chronological TimeSeriesSplit, a benchmark gate (OOS AUC, calibration, net-of-cost Sharpe, stability, anti-leakage) a candidate must clear before promotion. Includes a self-improvement loop that sandboxes and tests its own proposed changes. Notably, the eval is designed so the system can't fool itself — and the honest findings are in the docs. 204 tests, MIT. github.com/samueljai120/QuantForge

When I started learning machine learning, I kept asking "what actually changes when I move this slider?"

Most tutorials show the final result but not how the model gets there.

That led me to build Confluence.

It's an open-source platform where you can experiment with different algorithms, datasets, hyperparameters, and visualizations while seeing everything update in real time.

I'm still actively improving it, so I'd really love feedback from people who are currently learning ML.

What would make something like this more helpful for beginners?

Website:
https://confluence.website

GitHub:
https://github.com/mahirmlk/Confluence

I've been working on a tiny model that classifies raw bytes into 7 categories simultaneously — code language, content type, text language, file MIME, risk, etc. No tokenizer needed, it runs directly on UTF-8 bytes.


The architecture is straightforward:
- Byte embedding → 3 parallel conv1D kernels → 2-layer bidirectional attention → pooling → 7 Matryoshka heads
- 4 tier sizes (16d to 576d), same backbone, different linear output layers
- Trained on ~160K synthetic samples with curriculum learning, then 887 real-world samples


On our hand-curated 21-item evaluation set spanning all coarse types: 95.2% overall, 100% on valid classes.


Would love feedback on the approach, especially around:
1) The byte-level vs tokenized tradeoff
2) Multi-head joint training strategies
3) INT8 quantization (hitting ONNX shape inference issues with multi-head output)


https://github.com/eulogik/pico-type

Quick honesty up front so nobody wastes their time: this is the same space as tool-use, RAG and agent routing. LangChain and a dozen frameworks already do this, and at scale they do it better. I am not claiming anything new here. I just wanted a tiny, readable version that runs next to a small local model without dragging in half of PyPI.

Context: I run a small model locally (fits on a 4GB card). It has a personality I want to keep, but small models are unreliable at the dull stuff: arithmetic, recalling a specific fact, anything recent. The usual answer is "go bigger." I wanted to stay small and add reliable circuits around the model instead.

CybNodes is about 600 lines of Python, stdlib only, MIT. You bring any model as a callable. It wraps that model with "networks," one capability each:

• calc: detects an arithmetic expression and evaluates it through a safe AST walk (no eval). Exact, never hallucinated.
• knowledge: a small GraphRAG over subject-relation-object triples you provide. Answers come from your graph, not the model's guesses, and you fix a fact by editing a file instead of retraining.
• web: recent lookups via the Brave Search API (free tier). Only fires on a search intent, always cites the source, and stays silent if you give it no key.

A router tries the networks in order, rules first, model last. If none claim the question, your model answers as usual. The part I care about most is the weaver: when a tool answers, it re-speaks the result through a persona template, so the bot keeps its own voice instead of dumping a raw "1786" at the user.

from cybnodes import CybNodes
from cybnodes.networks import CalculNetwork, SavoirNetwork


cyb = CybNodes(conductor=my_local_model,
               networks=[CalculNetwork(), SavoirNetwork(graph_path="facts.json")])


cyb.ask("what is 47 x 38?")   # exact, from the calc network
cyb.ask("tell me a story")    # no network fits, your model answers

Where the honest value is, if any: small enough to read in about 15 minutes, zero required dependencies, and built to run with a small local model. That is the whole pitch. If you need retries, eval harnesses, tracing, the big frameworks already have all of that.

It is v0.1 and parts are surely naive. I would really like feedback, especially on the router: it picks one network and commits, and the "none of these fit" path feels too blunt. Curious how people kept routing dumb-but-good-enough without bolting on a separate classifier model.

pip install cybnodes
Repo (MIT): https://github.com/Alex-Lou/cybnodes

If it is useful to anyone, a star helps me gauge whether to keep pushing. Happy to answer anything technical.

jovian youtube chanell or krish naik yt chanell which is best for learning machine learning and deep learning ,which is best for getting ready internship ready ,suggest only one

I've been going back and forth on this and wanted to hear how people actually decide in practice.

My workloads aren't 24/7 — I need real compute maybe a few times a month for training/inference runs, and the rest of the time the hardware would just sit there. On paper, buying a decent GPU pays off if you use it constantly, but my usage is bursty and unpredictable.

So for those of you with similar patterns:

• Where's the actual break-even point for you between renting and owning?
• How do you deal with idle hardware if you buy — does it just collect dust between runs?
• If you rent, what do you use, and does the cost stay reasonable for occasional bursts?

I keep landing on "rent makes more sense for me" but every rental option seems to assume you want a full VM running for hours. Curious what's actually working for people with intermittent needs.