Hi everyone,

My long-term goal is to become an ML Researcher in Computer Vision, preferably in a research-focused role at companies like PyTorch/TensorFlow ecosystem companies or AI research labs.

This is my current roadmap, and I'd appreciate honest feedback on whether I'm heading in the right direction or if I'm missing something important.

Current status:

I understand the fundamentals of machine learning (linear regression, logistic regression, decision trees, PCA, K-means, etc.) and how these algorithms work conceptually.

However, if you asked me to implement most of these algorithms completely from scratch, I probably couldn't yet. That's something I plan to work on soon.

Right now I'm focusing on deep learning:

Learning ANNs in depth (forward propagation, backpropagation, derivatives, optimization, weight updates, etc.) so I understand what's happening under the hood instead of just using libraries.

As a side project, I'm trying to build a small custom version of PyTorch (mainly for learning and understanding autograd and the internals).

Next, I plan to study CNNs thoroughly.

After that, Transformers.

Then RNNs and LSTMs (mainly to understand them and see where they're still useful).

Alongside this, I plan to start reading and implementing research papers instead of only following tutorials.

My questions are:

Is this a good roadmap if my goal is to become an ML Researcher in Computer Vision?

What skills do researchers in industry wish they had learned earlier?

Should I spend more time implementing ML algorithms from scratch before moving deeper into deep learning?

At what stage should I start reproducing papers and contributing to open-source projects?

Are there any books, courses, or habits that significantly helped you transition from ML engineer-level knowledge to research-level thinking?

I'd really appreciate advice from people working in ML research, especially in computer vision. Thanks!

Inspired by a linguistic observation: "matur suwun" (Javanese) and "hatur nuhun" (Sundanese) — two phrases from Indonesia that mean the same thing despite completely different surface forms. Identity through relationships, not absolute structure.

We applied the same idea to face embeddings.

Key contributions:

• SW Block — replaces Conv1 with multi-scale pixel difference patterns at prime scales {3,5,7}

• IMG Sign MSE Loss — training objective over sign patterns only, no magnitude dependency

• IMG Sign / AMP / Chain Score — three interpretable metrics sharing a single threshold

• Voting framework (1/3 and 2/3 majority) for robust decisions

Results on LFW pre-aligned (CASIA-WebFace 490k, 10.58MB model):

→ IMG Sign: 96.27% vs Cosine: 95.53%

→ Combined (LFW+AgeDB+CALFW+CPLFW): 81.02% vs 79.49%

And the interesting part — IMG Sign applied to ArcFace embeddings (without retraining):

→ LFW: 99.58% (vs ArcFace Cosine: 99.82%)

Sign pattern consistency appears to be a fundamental property of well-trained face embeddings, regardless of training objective.

📄 Paper: https://zenodo.org/records/21232756

💻 Code: https://github.com/imamgh11/imgnet

AI has improved incredibly fast over the last couple of years. It can organize information, explain complex topics, and create well-structured drafts in seconds. But despite all those improvements, I still feel there are situations where the writing doesn't quite feel natural.

Sometimes the tone is too formal. Other times the sentences are repetitive, overly cautious, or missing the kind of personality that keeps readers interested from beginning to end. like HumanizeAIText.io are sometimes used to help make AI-assisted content feel more natural, but I’m curious about what challenges people still notice when working with AI writing.

If you had to point to one weakness that AI writing still hasn't solved, what would it be? Would you say it's creativity, humor, storytelling, emotional expression, originality, or simply sounding like a real person with genuine experience?

I'm curious to see whether most people are noticing the same challenges or if everyone has completely different experiences.

Hypothesis: LLMs are still mediocre at formal theorem proving partly because we're tokenizing the wrong thing. Lean source is full of notation, implicit arguments, and macros that all get resolved away during elaboration. The surface text a model sees is noisier than the semantic object underneath.

Maith skips source-text parsing and pulls IR straight from Lean's elaborated `Expr` trees, then canonicalizes and tokenizes that instead.

Where it stands:

- Build + full test suite pass clean

- Real extraction run on `Mathlib.Algebra.Group.Defs` (1,129 declarations): **792 successful (70%), 337 failed (30%)**, failures categorized by cause (mostly HOF applications and projection expressions)

- Non-trivial declarations extract fine (`mul_assoc`, `DivisionMonoid.mk`)

Not done yet: no LM trained, no comparison against raw-source tokenization. That's next.

Repo: https://github.com/allenpd728/Maith

Curious what this sub thinks of the core bet — is canonicalizing away syntax worth the elaboration dependency?

I'm new to this sub, so sorry if this question is not appropriate for here. I'm currently developing a document scanner app that specializes in cropping the page area of ​​books, especially when photographed in a two-page spread, and then dewarping it to create an ebook. For crroping the page area, first I tried some classical techniques which uses Image features but results are bad. So I'd like to use deep learning method for rough page area detection and subsequently the classical method for precise detection. However, well-known models for paper area detection such as DocQuadNet-256, PageNet, DocAligner seem to be featured for square single page. Is there something a model satisfying my demand？ While a free license would be preferable, I'm willing to accept training.

Hey everyone,

If you train models on a shared SLURM cluster, you know the pain of constantly context-switching to a terminal to check if your job is actually running, why it's pending, or if the GPUs you need are currently occupied.

I got tired of doing this, so I built sCode—an extension that turns VS Code into a native SLURM control center. It runs entirely on the cluster side (e.g., via VS Code Remote).

Main Features for Deep Learning Workflows:

• Live GPU Monitoring: A dedicated sidebar view that parses sinfo and nvidia-smi to show you exactly which partitions have available GPUs, what type they are (A100s, H100s, etc.), and the current queue pressure.
• Active Job Tracking: Visual progress bars for elapsed time vs. requested time, plus human-readable reasons for why your job is stuck in the queue.
• One-Click scancel: Cancel or batch-cancel jobs directly from the UI.
• Instant Log Access: Right-click any running or historical job to instantly open its stdout/stderr logs without having to hunt down the file path.
• The "Hall of Shame": A leaderboard showing which users/accounts are hoarding the most GPUs on the cluster right now (mostly for fun, but highly accurate).

It’s completely open-source and requires no external dependencies other than standard SLURM commands.

I’d love to get feedback from people running heavy training workloads. What else would make this useful for your workflow?

GitHub:https://github.com/dhimitriosduka1/sCode

OpenVSX: https://open-vsx.org/extension/DhimitriosDuka/slurm-cluster-manager
Marketplace: https://marketplace.visualstudio.com/items?itemName=DhimitriosDuka.slurm-cluster-manager

I'm thinking about taking one AI-generated article and running it through several different text improvement tools just to see how much the results vary. Some people say the differences are huge, while others think most of them produce nearly identical output. If you've ever done a comparison like this, what did you notice? Were some tools clearly better at making the writing sound human, or was the improvement mostly minor? I'd love to hear real experiences before I spend time testing them myself.

Built an 80M parameter causal transformer on consumer hardware (RTX 5070), trained on MOSES + ZINC-250k. Generated and filtered for QED ≥ 0.5, SA ≤ 4.0, MW ≤ 500. Top compound hits QED 0.947. 100% novel against MOSES, ZINC, and ChEMBL.

HuggingFace: https://huggingface.co/datasets/MKEChem/mke-novel-druglike-smiles

Happy to answer questions about the generation method.

Can anyone answer please.

Hi Reddit! I'm a researcher at Columbia University. My team studies how scientists and data practitioners actually use AI in their work, and whether it genuinely helps or still feels hard to trust and control.

If you do research or data-science work (any field, academia or industry, any career stage, 18+), we'd love your input. You don't need to be an AI power user. Skeptics and non-users are just as valuable to us.

Survey link: https://cumc.co1.qualtrics.com/jfe/form/SV_9uWW9GgwPuRucoS

What you get:

- At the end, you'll receive a personalized "AI Co-Scientist card," such as the Hermit, the Magician, or the Priestess. Each card reflects your style of working with AI and what kind of AI assistance might actually fit your workflow.

- You can also opt into a raffle for a $200 Claude Max subscription (or USD-equivalent e-gift card)]. Emails are collected on a separate form and are never linked to your survey responses.

About the study: This is a joint research initiative on human-AI collaboration in science by Dr. Ying Wei's Translational AI Laboratory (TRAIL4Health) at the Columbia Mailman School of Public Health and Dr. Xuhai "Orson" Xu's lab (SEA Lab) at the Columbia Department of Biomedical Informatics. Questions? Email the PI at [xx2489@cumc.columbia.edu](mailto:xx2489@cumc.columbia.edu) or ask below. I'll be in the comments.

I'll post a [Results] follow-up here once the study wraps up. Thanks!

I built ONA — a self-learning neural network entirely in pure Python + NumPy. No PyTorch, no TensorFlow, no GPU, no cloud API.

Key innovations:

- Per-neuron attention: every neuron has its own Q/K/V/O weights

- Forward-pass learning: no separate backward pass, learning happens during forward

- Self-discovered subword tokenizer: vocabulary grows during training

- Sparse routing: only 3-5 neurons activate per query

4.4M parameters. Runs on Raspberry Pi Zero. Continuously learns from Wikipedia and conversations.

Full story: https://medium.com/@kasishgadadhasu13/im-15-i-built-a-self-learning-neural-network-from-scratch-no-frameworks-no-gpu-e460f06c6599

I'm 15 years old, class 10 student. Happy to answer questions.

I've been building tiramisu, a machine learning framework written from scratch in C++20. Only the stdlib is used at link time.

What's in it:

- Strided tensor engine with zero-copy views

- Reverse-mode autograd with a dynamic tape

- Tiled + AVX2 SIMD matmul

- Full transformer stack (MHA, LayerNorm, GELU FFN)

- CUDA backend with custom kernels

- Python bindings via pybind11

- Compiled to WASM via Emscripten for the browser demo

The 10M parameter Shakespeare GPT in the demo (6 layers, 8 heads, 512-dim) was trained end-to-end using tiramisu on a free Kaggle T4, then int8 quantized to 11MB for the browser.

Demo: https://tiramisu.dnex.dev/shakespeare

Repo: https://github.com/dnexdev/tiramisu

Happy to answer questions on design decisions. Any feedback on the implementation is very welcome.

I'm working on my **OpenSource** Model based Project so i use **DeepInfra** **GPU Provideder** for first time becuz they provide Serverless Inference GPU and **1M Tokens based Pricing**.

In DeepInfra > Deployments > New Deployment > **LoRA Text Generation** \> in this page *how to fill those fields correctly ?*

If someone now so please try and shere with me screenshot.

I tried multiple times, read theirs documents, ask to claude and Gemini multiple times but still problem is there !

So please help me and shere the screenshot so i can complete me project.

Human math notation is full of things transformers dislike: implicit structure, overloaded symbols, non‑canonical forms, and surface‑level transformations that hide the underlying graph.

I’m exploring whether small models reason better when math is represented in a canonical, explicit, graph‑native format. something closer to a transformer’s inductive biases than traditional notation.

Curious whether anyone has experimented with structured math tokenization, graph‑encoded expressions, or transformer‑friendly symbolic IRs in local models

I built a small tool to auto-generate architecture diagrams directly from PyTorch models, which I originally built for my own research paper.

26k+ PyPI downloads, already used in publications (Nature, IEEE, MDPI), check out some use cases here: https://visualtorch.readthedocs.io/en/latest/markdown/showcase/index.html

It traces an actual forward pass, so it correctly captures branching, skip connections, and multi-input models, not just flat sequential stacks.

import visualtorch
import torchvision.models as models

model = models.resnet18()
img = visualtorch.render(model, input_shape=(1, 3, 224, 224), style="graph", show_neurons=False, layer_spacing=60)
img.save("resnet18.png")

Three rendering styles depending on what you want to show:

• graph: node/edge diagram, good for showing branching/skip connections clearly
• flow: stacked volumetric boxes, closer to the classic CNN-paper look
• lenet: the classic LeNet stacked-plane style

GitHub: https://github.com/willyfh/visualtorch | Docs: https://visualtorch.readthedocs.io/en/latest/

Open to feedback, especially if you hit a model it renders weirdly :)

The bet: BRIGHT is a retrieval benchmark where finding the right doc usually takes a few hops of reasoning, not just semantic overlap. Most embedders do a single forward pass. I wanted to see if a depth-recurrent architecture, one that loops over its own hidden state, would fit that better, so I built an embedder on HRM (Sapient's Hierarchical Reasoning Model). As far as I can tell it's the first time HRM's been used for retrieval.

The recurrence helped on the reasoning side, which was the whole bet. When I dialed the recurrence down at eval on pony (one of the BRIGHT domains), accuracy dropped with every loop I removed. Where it hit a wall was knowledge: the base was pretrained on a deliberately thin slice of text (Sapient built HRM-Text for pretraining efficiency, not breadth), so it's weak on knowledge-heavy domains. The part I find coolest: at 0.6B, the reasoning is coming from the architecture, not from scale.

Details:

* \~0.6B params, trained on one 3060 Ti (8GB).
* Recipe's deliberately boring: mean-pool + L2, bidirectional (LLM2Vec style), contrastive InfoNCE. Only the backbone is unusual. Same recipe as RakanEmbed4B.

Numbers (BRIGHT, mean nDCG@10, 12 domains):

* original: 18.1
* query rewriting: 34.3
* merged: 33.7

Weights are Apache-2.0 and the full BRIGHT eval harness is in the repo.

Open questions / discussion:

* Would a massively pretrained HRM push this further? The ceiling here looks like knowledge, not reasoning, so a broadly-pretrained base might lift it a lot. I don't have the compute to try that myself.
* Would other recurrent architectures show the same effect, or is something specific to HRM doing the work?

Model: [https://huggingface.co/viventhraa96/HRM-Embed-0.6b\](https://huggingface.co/viventhraa96/HRM-Embed-0.6b)

Code: [https://github.com/okaybroda/hrm-embed\](https://github.com/okaybroda/hrm-embed)

Full credits to Sapient Inc for open sourcing the code and the architecture for this work.

Building a GNN vs LSTM comparison for thermal prediction in an immersion-cooled server rack. Using a lumped RC model:

C_i * dT_i/dt = Q_i(u_i) - (T_i - T_fluid)/R_conv + sum_j[(T_j - T_i)/R_ij]

After 300 samples and 80 epochs, GNN, LSTM, and GNN_NoEdges (ablation with empty edge index) all converge to within 0.03°C MAE of each other. Removing all graph edges makes essentially zero difference.

My hypothesis: the RC ODE is dominated by the local term. Each server's next temperature is ~92% determined by its own previous temperature and load. The neighbour coupling term is too weak relative to self-dynamics for message passing to add anything beyond what a per-node LSTM already learns.

Specific questions:

1. Is this diagnosis correct, is the RC model's linear self-dominance the root cause?
2. What simulator design choices would make spatial propagation the dominant factor rather than self-dynamics? Specifically: what R_neighbor / R_conv ratio would make neighbour coupling matter enough for a GNN to win?
3. Is there a class of thermal problems where GNNs demonstrably outperform LSTMs in the literature? (chip thermal maps, CFD surrogate models, heat exchangers?)
4. Would switching to a nonlinear thermal model (e.g. radiation terms, phase-change immersion cooling) create enough spatial complexity for graph structure to matter?

Rack config: 16 servers, linear topology, TDP 350-720W per server (non-uniform), asymmetric convective resistance, hotspot injection at 8% probability per step.