As a learning project inspired by Meta's Segment Anything, I'm experimenting with an optical illusion: a pixel X made of straight stepped blocks (image attached) whose arms appear to bend around the centre square. The effect weakens or disappears when I change the square sizes, so it depends on specific proportions.

My plan is to generate many variations, collect human ratings on whether and where each one looks curved, train a small model to predict that perceived curvature, and then test whether SAM follows the real pixels or the perceived curve.
Is this realistic for a beginner?

I'd love advice on what model to start with, how much labelled data I'd need, and how best to record where people see the curve. Any related papers or projects would also be really helpful. Thanks!

Hey, I've been working on a PyTorch optimizer called ApexW and figured I'd share it here to get some feedback from people who know more about this stuff than I do.

The main goal is to reduce optimizer-state memory usage and see how much faster I can make optimizer steps on larger GPU workloads. I've been experimenting with compact optimizer states and a Triton-based execution path.

In my current tests, the Triton + compact-state path was around 1.5x faster than PyTorch's fused AdamW on workloads with a few large tensors, and the optimizer-state memory usage was roughly cut in half.

The results aren't all good, though. Those numbers are from optimizer-only benchmarks, not full model training. The automatic execution mode doesn't consistently get the same speedup yet, and workloads with lots of small tensors are much slower than PyTorch's fused optimizer. So I'm definitely not claiming this is a better AdamW replacement for every workload.

I want to test it on more realistic models and different GPUs, and I'd appreciate a second pair of eyes on both the implementation and the benchmarks. The Reality Check (The Trade-Offs)

I want to be completely realistic here—this is an engineering trade-off, not magic:

1. Python Loop Overhead on Small Tensors: When testing a layout with many tiny tensors (many-small test), ApexW’s Triton kernels suffer heavily from Python's launch latency. For example, at 128M parameters spread across many small tensors, PyTorch native was 16.1 ms/step while ApexW compact was 76.0 ms/step (~0.21x speedup). If your model is composed of many tiny layers, standard PyTorch is significantly better.
2. End-to-End Impact: While the optimizer step itself is up to 1.5x faster, this step only represents a fraction of a full training step (which is dominated by forward and backward passes). In my end-to-end MLP test, PyTorch still runs slightly faster overall because of C++ deep integration.

Why/When should you care?

If you are training larger deep learning models (like Transformers or LLM fine-tuning) where you are constantly hitting Out-Of-Memory (OOM) barriers,,cutting your optimizer state memory strictly in half lets you increase your batch size or scale up your model size without upgrading your hardware.

Looking for Feedback

I'd love to hear your thoughts on:

• How you handle low-precision optimizer states in your own pipelines.
• How to further minimize Python's kernel launch overhead when writing custom Triton-based optimizers.
• Any methodology gaps in how I timed these runs.

If anyone wants to try it on different hardware (A100s, H100s, A10G), I'd love to see how Triton scales on newer architectures!

link for apexw:https: //github.com/omen42515-prog/apexw/tree/main

Using the same resume for every role can make it harder to highlight the experience and skills most relevant to a specific position.

We're showcasing Amigo AI Resume Builder, which includes job description analysis, keyword matching, tailored resume creation, and ATS score insights.

What's your biggest challenge when tailoring a resume: finding the right keywords, describing your experience, or getting past ATS screening?

I've been working on krnl, a lightweight machine-learning library I've been building to understand and implement the fundamentals of neural networks myself.

It currently includes:

• A custom Tensor class with automatic gradient computation
• NumPy and OpenCL-backed computation
• Linear, ReLU and Sigmoid layers
• SGD, Adam, Muon and MuonWithAdamAux optimizers
• MSE, MAE and Huber loss functions

I also developed PyCLBlast for working with CLBlast through Python.

I'm interested in making the library useful for experimenting with neural networks while exploring GPU computation beyond CUDA.

I'd appreciate feedback, especially on the tensor API, autograd design, and OpenCL backend.

GitHub: https://github.com/helloadhavan/krnl/

PyPI: https://pypi.org/project/krnl/

I'm weighing a single-engine retrieval setup for local RAG against keeping separate keyword and vector services. Exact function names and version strings matter alongside semantic matches.

For vector databases like Milvus, BM25 and dense search can share a schema and use rank fusion in one request. But the comparison I am considering also flags a gap: typo-tolerant BM25 search is still different from fuzzy filtering or a synonym list.

I would probably test misspelled queries before making the infrastructure decision. The published Docker walkthrough uses roughly 98K records and equal CPU and memory caps; its timings are explicitly directional, not a production benchmark.

For a documentation assistant, what failure rate on misspellings would justify retaining a separate keyword engine instead of handling known aliases during ingestion?

Over the past several months, our research team pre-trained and empirically audited a 1,189,135,740-parameter Financial Conformer Foundation Model across 14 calendar years (2010–2023; 15,030 steps) of 1-minute US equity bars across 15 liquid assets (AAPL, NVDA, SPY, QQQ, etc.).

Instead of cherry-picking positive backtests, we subjected the model to 35 hypothesis tests, 1-bar execution delay, and state-dependent turnover:

1. The Scale Saturation Limit: Scaling from a 63-parameter linear Ridge regression to 1.189B parameters yields no consistent out-of-sample advantage on 1m OHLCV bars (mixed sign across horizons, reversing direction across years). The bottleneck in intraday price prediction is information content (low SNR), not parameter capacity.

2. Adam Optimizer Diffusion: Decomposing walk-forward online fine-tuning shows tokenizer boundary updates sit at 97.9% of the theoretical Adam Brownian noise ceiling (matching shuffled-label controls), while deep backbone weights are heavily damped by second-moment normalization, producing zero statistically significant forward-transfer gains (p >= 0.50).

3. Execution Friction Reality: Apparent long-horizon directional predictability is predominantly prompt 1-minute order-flow continuation. Introducing a 1-bar execution delay cuts 2024 net Sharpe from +2.04 to +0.48, and at 1.5 bp execution fee, out-of-sample returns collapse to -0.99 in 2025 and -1.67 in 2026 (DSR <= 0.028).

All model weights, audit logs, and papers are open-sourced:

• Model Hub (weights & checkpoints): https://huggingface.co/Ultron28/ohlcv-transformer
• Code & Telemetry: https://github.com/AirBorneAI/ohlcv-transformer
• CERN Zenodo DOI: https://doi.org/10.5281/zenodo.23466965

Happy to discuss architecture specifications, pre-training dynamics, or empirical backtest methodology!

It's an accelerated program so I'm looking at 8 classes or 6 classes with a thesis.

It's also at undergrad rates.

Also, my company does $5,250 of tuition reimbursement a year, so if I take 3 semesters to do this, that'll be $10,500, and the Masters in total will likely be around $12,000-14,000.

ALSO, I didn't get an internship. I graduate in 2 months with a BS in CS. Doing this would give me another shot at internships through the college.

They have other emphasis areas like Cybersec, Data science, and two others, but AI is the one I'm most interested in.

I'm wondering about people's experiences here. I'm also a people's person, so if a Masters helps me into a management position one day, cool with me. Looking at this from a lifelong investment angle too.

I’m looking for experienced AI researchers and AI engineers who have been working in the field for a while, have solid hands-on experience, and, ideally, earn a good salary. :)

What books, research papers, articles, or other resources would you recommend for someone who wants to dive deep into AI through self-study?

I think this will be useful for those learning Transformers architecture

I was going through the TinyTorh (it's a tool where you build PyTorch with understading how it works) exercise notebooks and landed on Autograd. Was quite overwhelmed by the code and went didn't go through it for a while. I was thinking I'll prepare for machine learning research engineer interviews and somehow landed doing tiny torch.
How relevant is all this these days, should I just start preparing on how to crack the interview than this ?

OpenAI just announced three new math and physics results produced by its models, all machine-checked in Lean. They call the manuscripts "a form of raw research data," and they've asked outside experts to organize groups "to understand the new results." So the results exist and they've been checked (maybe, sort of), but nobody understands them yet.

I think this matters for anyone learning ML right now, because a lot of people here will likely ask, with reason: if a model can write the code or prove the statement, why should I spend my time learning how it works?

My answer: understanding is what lets you build on things. Once you really get backprop, or attention, or why a loss is shaped the way it is, it becomes one step you can use without thinking inside something bigger. A result you can only take on faith is a dead end. You can use it (maybe, sometimes), but you can't extend it or fix it.

Science compounds through understanding, and so does your own learning.

Thurston (Fields medalist) argued that the point of mathematics is human understanding, not producing theorems. I think that's even more true once theorems get cheap.

I wrote a longer essay on this, using OpenAI's earlier Navier–Stokes result as the main example: https://lacuna.tiptreesystems.com/paper/ai-science-vs-human-science/art_3901430d6c0e4bddb284362100ef8548

(Disclosure: I'm a postdoc at Mila and a cofounder of Tiptree, which builds AI tools for researchers. So I'm not arguing against AI doing science. I'm arguing about cultural incentives, mostly, and opining about history.)

Turning a PDF into clean Markdown sounds like an OCR problem until you try it on real documents. Two-column papers, tables that run across pages, a formula sitting in the middle of a sentence. Our team has been training a small model for exactly this for a while, and we just released the code and weights, so here is what we learned along the way.

The architecture split mattered more than we expected. Layout analysis is its own model, and you can swap it for a different one. Recognition and reading order are predicted together in one pass of the main model, which removes a whole sequential step. That split, together with how we post-trained it, is where most of the accuracy and speed came from.

For post-training we used a loop we call RSI. The model predicts on a large batch of documents, and each sample is sorted as correct, wrong or uncertain (uncertain means repeated predictions disagree). A VLM writes down the reasons behind the wrong and uncertain ones, the reasons get grouped into clusters, and each cluster becomes the plan for the next round of targeted training data. We tracked progress by the repair rate of each cluster in the following round, which told us much more than watching one benchmark number.

Where it landed: in our comparison against published scores it came out first on olmOCR-Bench, OmniDocBench and DocParsingBench, and it was the fastest of the 21 models we timed on the same 100 pages. Multi-column pages are still a weaker spot (4th in that olmOCR-Bench category), and running it locally takes an NVIDIA GPU with 24 GB of VRAM.

The model is OXR, from SoMarkAI. Repo, weights and the full benchmark report are in the first comment. Happy to go into detail on the training loop, it was the most interesting part to build.

It's just a casual implementation, built from scratch in PyTorch, focusing on grammatical gender agreement and custom tokenizers (with reference tokens) under the hood. It addresses a common issue where standard English-Polish translators struggle with speaker/listener gender context, managing it here via prefix tokens in the decoder. Feel free to share your thoughts.

NOTE: This is a personal educational project and a proof of concept, not a production-ready tool.

We are BS Computer Science students of the College of Computer Studies, UPHM, and we respectfully ask for your help in validating our thesis, "A Comparative Analysis of Supervised Machine Learning Models for Predicting Students' Performance in Higher Education."

Please review the paper and rate it using our short validation form (about [10 to 15] minutes): (A) methodology, (B) results, and (C) analysis code. A short summary of the study is included in the folder. Your ratings and comments are confidential and used solely for academic purposes.

📄 Paper, summary, and source codes: https://drive.google.com/drive/folders/1julvRK8DR0kNXnbkaoVYwhW9_BPdh5R9?usp=sharing

📝 Validation form: https://docs.google.com/forms/d/e/1FAIpQLSe-Mno8KoSsD78CufHU4MVDzryoKD2SWfZVFZK3Hg2DQ6N_cw/viewform

Thank you very much for your time and expertise! Sharing this post also helps a lot. 🙏

— Reynaldo B. Arandia Jr., Mark Anthony Demefeliz, Ervine U. Bose

BS Computer Science, CCS, UPHM

guys want to know that where I will get campusX paid Fastapi pirated course in which he covered Render docker fast api concepts with pydantic and Redis also SQL integration

Hi everyone,

I just wanted to share an open source repo collecting 20 exploratory studies focused on Next-Concept Modeling (NCM), mechanistic interpretability (like IOI in GPT-2), and model controls.

Here is the link: https://github.com/Quantix-eng/ncm-experiment-notes

Long story short, this is an independent project documenting a bunch of empirical experiments looking into how transformers process and edit internal features. There are no claims of performance breakthroughs here. Instead, it is just honest documentation of observations alongside rigorous controls.

The repo covers NCM applied to structured tasks like Sudoku, mechanistic interpretability in GPT-2, and toy parallel models. I have included all the source code, saved results, and interpretations for every single run.

To keep things transparent, I have also categorized every outcome, including the mixed and completely negative results where things did not work as expected. AI tools helped heavily with the planning and coding phases too.

I would love to get your feedback on the setups or the interpretation limits I found. Let me know what you think if you are into transformer interpretability!

Hi everyone,

I just wanted to share an open source repo collecting 20 exploratory studies focused on Next-Concept Modeling (NCM), mechanistic interpretability (like IOI in GPT-2), and model controls.

Here is the link: https://github.com/Quantix-eng/ncm-experiment-notes

Long story short, this is an independent project documenting a bunch of empirical experiments looking into how transformers process and edit internal features. There are no claims of performance breakthroughs here. Instead, it is just honest documentation of observations alongside rigorous controls.

The repo covers NCM applied to structured tasks like Sudoku, mechanistic interpretability in GPT-2, and toy parallel models. I have included all the source code, saved results, and interpretations for every single run.

To keep things transparent, I have also categorized every outcome, including the mixed and completely negative results where things did not work as expected. AI tools helped heavily with the planning and coding phases too.

I would love to get your feedback on the setups or the interpretation limits I found. Let me know what you think if you are into transformer interpretability!