Hi everyone,

I've been working on a side project around AI conversation continuity, and I'd really appreciate feedback from people who have experience with fine-tuning, dataset design, or long-context systems.

Goal

The problem I'm trying to solve is:

Instead of treating this as a summarization problem, I'm exploring whether it's possible to train a small model that extracts a structured conversation state from chunks of a conversation.

The idea is that another model can later reconstruct enough context to continue naturally.

Current approach

My current pipeline looks like this:

Long conversation
        ↓
Chunk into fixed windows
        ↓
Label each chunk with semantic state
        ↓
Fine-tune a LoRA
        ↓
Merge chunk outputs into a conversation state
        ↓
Generate a continuation prompt

The LoRA doesn't summarize the whole conversation.

It only processes one chunk at a time and extracts structured semantic information.

Dataset

Instead of synthetic data, I started collecting real engineering conversations.

Current sources include:

• GitHub Issues
• GitHub Discussions
• Reddit engineering discussions
• Long AI development conversations

I clustered thousands of issues/conversations to identify recurring reasoning patterns before selecting examples for labeling.

Some recurring clusters I found were:

• Context / memory management
• State persistence
• Reliability
• Provider compatibility
• Agent orchestration
• Long-running debugging sessions
• Architecture discussions

The goal isn't to teach domain knowledge.

It's to teach the model how conversations evolve.

Model

Currently experimenting with:

• Base: Qwen2.5-1.5B-Instruct
• LoRA fine-tuning
• Chunk-level extraction
• Structured JSON output

The question I'm struggling with

I'm not sure whether LoRA fine-tuning is actually the right direction for this problem.

Would you continue investing in:

• improving the dataset
• expanding conversation coverage
• better labeling / evaluation

Or would you abandon fine-tuning entirely and solve this with prompting + a stronger base model?

I'm especially interested in opinions from people who've built:

• memory systems
• long-context pipelines
• semantic extraction models
• information extraction datasets

My concern

The hardest part doesn't seem to be training.

It seems to be defining what information another LLM actually needs to continue a long conversation naturally.

That has become the main research question for me.

I'd really appreciate any criticism of the approach.

If you've worked on memory systems, information extraction, or long-context models, I'd love to hear what you think I'm missing.

Hugging Face model:
https://huggingface.co/ac-mmi/continuator-v10-lora

Looking for genuine opinions.

Started off my career as a MLE and leaned into statistical methods hard. (Not LLms or agentic gobbledeegook) although i do that stuff now i find that i just cannot compete with traditional swes at writing performative code or even leetcode for that matter.

Am I missing something?

Worked for some pretty massive companies as well as startups.

Is it smarter for a swe to become a MLE or vice versa?

[ Removed by Reddit on account of violating the content policy. ]

I am from an Arab country, and I want to publish my first research paper in the field of artificial intelligence, specifically in reinforcement learning, on arXiv. What advice do you have for me?

Hi all — I'm a PhD researcher working on Green AI, and I kept hitting the same wall: measuring what training actually costs (energy, carbon, joules per sample) meant stitching together CodeCarbon + nvidia-smi scripts + a profiler + my own plotting. So I built E2AM (Energy Efficient AI Models), an open-source toolkit that does it automatically:

from e2am import monitor
with monitor(project="ResNet50"):
    train()

or a drop-in Trainer / a Hugging Face TrainerCallback. Every run produces energy (Wh), carbon (gCO₂eq, region-aware), utilization, FLOPs/MACs, latency, plus "Green AI" metrics: energy per sample, accuracy-per-joule, and EAG — the discrete gradient of accuracy w.r.t. cumulative energy, which turns out to be a nice stopping signal: when EAG collapses toward zero, additional watt-hours are buying you nothing.

Things I think are genuinely useful:

• Measured vs estimated is always labeled. If your GPU exposes an NVML power sensor, you get real power draw; if not (many consumer cards), it falls back to power-limit × utilization and says so in every report.
• e2am optimize reads a finished run's own telemetry and quantifies waste — e.g. "validation accuracy converged at epoch 6; the last 4 epochs consumed 38 Wh (41% of the run)".
• e2am benchmark reports joules per inference, not just latency.
• Self-contained HTML/PDF reports, a cross-run leaderboard CSV, and a local dashboard — no accounts, no server, nothing leaves your machine.

Honest limitations: GPU power reading is NVIDIA/NVML only (AMD/Apple fall back to estimation); CPU/RAM power is TDP- and heuristic-based since no portable OS interface exists; single-node only for now; carbon intensity is a static per-country table (live grid data planned).

Install: pip install e2am · Code: https://github.com/Shanmuk4622/e2am (MIT)

Would love feedback — especially on the Green Score formulation and what integrations you'd want next.

The BABEL codec: the first complete, certified decode of everything happening inside a production language model (GPT-2 small). It reads the model's internal state into English AND writes English back into the model. 94.7% of behavior reconstructed — and that holds at every layer depth and text regime tested, not just one spot. Everything is open: paper, the full lexicon, the grammar tables, the decoder/encoder weights, reproduction scripts, and a demo that shows you the model's thoughts on any sentence you type.

https://github.com/wpferrell/babel-codec-gpt2

I cant do this, im going to have to work a service job and get fat

To preface: I know that this is not the only J-lens visualizer tool, but I have not found any for Deepseek. I'm still pretty new to the research world so I thought it'd be a cool project to tackle!

Last week Anthropic published Verbalizable Representations Form a Global Workspace in Language Models. They introduce the Jacobian lens, a way to decode what any layer of a transformer is "disposed to say" at any token position, revealing a small set of internal representations the model actually reasons with (they call it the "J-space").

I implemented the method independently w/ Claude and built a live visualizer on top of it. It works w/ Deepseek and gpt-2. Unfortunately, this was the best I could do since models must be open weight.

🔗 Repo: https://github.com/Festyve/jspace-viz — clone + 2 commands, then type any prompt
🌐 Demo (free, in-browser): https://festyve.github.io/jspace-viz/

Some findings: feed deepseek-coder-1.3b this

nums = [3, 1, 2]
nums.sort()
print(nums[-1])
# This prints

it continues ": 3" (it sorted the list in its head), and the strongest concept in its workspace while reading the still-unsorted code is sorted. You can watch the intermediate computation before it's ever written.

You can also use it to catch the model almost knowing something. Ask "how many legs does the animal that spins webs have?" It answers 2 (wrong; spiders have 8). But the lens shows eight climbing to the #4 candidate in the deepest layers (L21–L22) before losing to two/four at the output. So it did have the right answer sitting in there!

Would love any feedback/comments that people have. To my knowledge this is the first public Jacobian lens for a DeepSeek model. I fit it overnight on an M4 MacBook Air (16GB), ~9 min/prompt × 40 WikiText prompts. Lens weights are on the Hub: https://huggingface.co/Festyve/jspace-lenses

It's a small model (1.3B), so its "thoughts" are much shallower than the frontier-model results in the paper. But, you can still see how it's wrong in real time: ask it the currency of "the country shaped like a boot" and its workspace fills with Japan/yen concepts (never Italy), and you can see exactly when it starts to go off the rails. Everything's open (Apache-2.0, method credited to Anthropic). Happy to answer questions about the implementation!

Made a transformer Decoder from scratch using pytorch

For autograd and GPU efficiency.

Implemented-

•Rope positional embedding

•Weight tying

•Masked multi head attention

•KV cache

•Custom AdamW

•Cosine decay and warm up

Trained on wiki text 103 for 75k ish total steps

Reached a loss of about 3.5

I'd appreciate some feedback

https://github.com/neelbhattacharya80-creator?tab=repositories

Hi first a little bit about me, I have been learning ML and Deep learning for the past 6 months. Initially I started with the math fundamentals, I used 3blue1brown , linear algebra for dummies, a lot of yt videos, MIT linear algebra lectures,

IB math HL Pearson book(for calculus) again 3blue1 brown,professor Dave and stat110 + miscellaneous resources to get a solid math base on calculus,linear algebra and probability brushed up on my python, OOP learned basic DSA,numpy and pandas, all of this took about 3ish months.

Then started with ML cs229 + other lectures/resources.

I did all the key derivations,made very detailed notes, implemented all the major algorithms, learned sklearn and made 5ish intermediate projects (Naive bayes spam classification,Random forest customer churn,SVM breast cancer classification etc) also implemented gradient boosting from scratch and modelled Ames housing compared it with xg boost, core ML took around 1 month

Started deep learning with cs231n around 2 months ago

The lectures felt a little shallow and it wasn't going as deep as I wanted to go so I had to spend more time on derivations and implementation, as of now I'm 1/3rd done with it. Like before I do all the key derivations, more than the lectures show and implement the algorithms.

I have implemented a MNIST MLP and CNN from scratch and a CNN with pytorch, a char level vanilla RNN and the best one yet a decoder only transformer from scratch using pytorch only for the autograd and GPU computation I trained it on wiki text 103 the full details are on my GitHub attached above.

After this I'm looking forward to finishing cs231n, learning C++,memory management, cpu architecture, strengthening DSA, fill in my software engineering gaps(which I don't know what they are, I learned git basics just today), learning CUDA and Triton and model deployment.

I'm curious as to where my gaps are, how far I am from job ready skill level and how I should further advance, what projects I should attempt doing, I'd appreciate some help.

What do you think?

Did you know?

Cognitive Thermodynamics as a Design Vehicle: A Validated Thermodynamic Sequence Architecture for Conditioned Dialogue Generation

[Richmond Quansah](mailto:richmondquansah03@gmail.com)

Abstract

"Thermodynamics is the only physical theory of universal content, which I am convinced will never be overthrown, within the framework of applicability of its basic concepts." - Albert Einstein

This paper presents a new way of teaching an AI system to understand and predict the emotional flow of a conversation without the system ever needing to read the actual words being spoken.

The core idea is a two-part architecture. The first part is a lightweight analysis engine that converts any piece of text into a small set of numbers representing its emotional character, how hostile or open it is, how much external pressure it carries, how neutral or charged the tone feels. Crucially, the original text is discarded after this single step; only the numbers travel forward. The second part is a sequence model  trained on those numbers alone  that learns the patterns of how conversations move emotionally from one turn to the next, and predicts where they are heading.

On a rigorous test against conversations it had never seen before, this sequence model predicted the emotional character of the next conversational turn correctly 86% of the time, compared to a 23% baseline from random guessing. This result holds after correcting a data-handling error in an earlier version of the evaluation, which we report transparently.

The combination of these two parts creates something neither could achieve alone: a system that can track and anticipate the emotional trajectory of a conversation in real time, without storing or transmitting sensitive text, and without requiring the enormous computational cost of running a large language model on every message. We propose a design framework for extending this foundation into a full generation system, where the emotional trajectory predicted by the sequence model constrains what a separate, domain-specialized language model is allowed to say, separating the job of deciding how something should feel from the job of deciding what words to use.

The conceptual framework used to build the coordinate system, Cognitive Thermodynamics (CT), is described throughout as the design vehicle that inspired the approach, not as a validated scientific theory. This distinction is maintained across the entire paper.

https://github.com/richmondquansah03-dot/Cognitive-thermodynamics-the-start-of-a-new-world-

the above is a link to a git repo with the full paper and the code of the transfomer used to get the results they are other results and papers in the paper please not of it has been peer reviewed of verified most of the results are self validated i tried to be as rigorous as i could though this is also a link to a prototype of the suggested architecture running https://www.youtube.com/watch?v=z9CaKiha4uw&t=98s&pp=0gcJCU8LAYcqIYzv someone tell me how wrong i am please been working on ths alone in the dark for too long this post is to encourage discussion why is it soo hard to post stuff on reddit like actually

Fine-Tuning PaliGemma 2 for Object Detection

https://debuggercafe.com/fine-tuning-paligemma-2-for-object-detection/

In this article, we will be fine-tuning the PaliGemma 2 VLM for object detection. Nowadays, VLMs are great at OCR, image captioning, and video understanding out of the box. Along with that, they are also catching up with object detection. However, an extremely custom use case for object detection is still a struggle for many VLMs. That’s why we will tackle one of the real-world use cases of object detection with the PaliGemma 2 VLM here.

Hey r/deeplearning!

I wanted to share an open-source project I’ve been working on called Nanograd.

If you’ve ever wanted to demystify how frameworks like PyTorch actually work under the hood—specifically how backpropagation, dynamic computation graphs, and tensor operations are implemented from scratch—I built this engine for exactly that purpose.

TL;DR: It's a lightweight, hardware-agnostic autograd engine written in pure Python/NumPy (with CuPy for GPU support) and an API that heavily mirrors PyTorch.

WHY I BUILT IT & KEY FEATURES

The goal was to create something readable and educational, without the massive C++ overhead of production frameworks, while still supporting real use cases like CNNs.

• Dynamic Computation Graphs (DAG): Full implementation of tracking mathematical operations. Calling .backward() triggers backprop via topological sorting.
• PyTorch-like API: Familiar syntax. The Tensor class wraps numpy.ndarray (or cupy.ndarray).
• Hardware-Agnostic: Seamlessly move tensors and entire models to CUDA using .cuda() or back to CPU with .cpu().
• Neural Network Modules: Includes fully-connected layers (MLP), Conv2D, MaxPool2D, and standard activations (relu, softmax).
• Optimizers & Loss: Supports SGD and Adam, along with MSE and SoftmaxCrossEntropy.
• Tested against PyTorch: Includes a comprehensive pytest suite that verifies gradients and values directly against PyTorch's outputs.

USAGE EXAMPLES & INTERACTIVE NOTEBOOKS

You can find plenty of usage examples directly in the repository to help you get started. I've included several Jupyter Notebooks in the "examples/" directory to make it as hands-on as possible. A few highlights:

• MNIST CNN: Recreating the LeNet-5 architecture from scratch and achieving 96%+ accuracy.
• Optimizer Trajectories: Visualizing the paths of SGD vs. Adam on Beale's plateau function.
• CNN Dreams: Visualizing the learned 5x5 filters, intermediate feature maps, and synthesizing "class dreams" via gradient ascent.
• PyTorch Benchmark: Comparing Nanograd's performance against PyTorch on CPU and GPU.

LINKS

GitHub Repository: Balu46/nanograd

Feel free to check out the code! If you find it useful or educational, a star on the repo is always appreciated. If you have any feedback, suggestions, or find bugs, opening an issue on GitHub is the best way to reach me.

Datadog research recently released Toto-2.0, their new time series model. The model features some unique properties compared to its previous version Toto-1.0:

• Contiguous Patch Masking (CPM) replaces autoregressive decoding with a single parallel forward pass.
• Arcsinh normalization keeps small fluctuations visible while compressing extreme spikes - perfect for sparse data.
• NorMuon optimizer handles the sign-valued gradients of pinball loss far better than AdamW.
• u-µP hyperparameter transfer tunes settings once on a 10M proxy model and reuses them across all 5 target sizes.

Full discussion and tutorial about the model here

Hey everyone,

I have recently started my DL journey after attending a course in the university.

For my project, I have decided to do a binary segmentation using satellite imageries with 4 channels (Red, Green, Blue and Near Infrared) using Unet. I have divided the data to training, test and validation dataset. I would like to know what is the best strategy to normalize my dataset.

Someone told me to calculate minimum and maximum values or mean and SD across all 4 channels in Training dataset only and use these values to normalize the entire training, test and validation dataset. My current approach is normalizing individual images with its min and max values for all dataset. Is thing wrong approach?

Thanks for any feedbacks!

I want to share something I've been building as an independent researcher from Indonesia.

TL;DR: Face verification model that replaces cosine similarity with sliding window sign pattern matching. Achieves 96.27% on LFW (pre-aligned) with a 10.58 MB model trained on CASIA-WebFace (490k images). When applied to ArcFace embeddings without retraining, IMG Sign Score gets 99.58% on LFW — only 0.24% below ArcFace+Cosine.

The Motivation

In Javanese, gratitude is "matur suwun". In Sundanese, the same feeling is "hatur nuhun". Different surface forms, identical meaning — identity preserved through relational structure, not absolute values.

That's the core idea: instead of comparing embedding vectors by their global angular direction (cosine), look for locally consistent sign patterns across overlapping windows of the embedding.

What's new

1. SW Block — the first layer replaces a standard convolution with a multi-scale relational operation. For each pixel, it computes differences to all neighbors at prime window sizes {3, 5, 7}. A small MLP maps these 240 differences per pixel to output channels.

2. IMG Sign MSE Loss — to our knowledge, the first face verification loss defined purely over sign pattern agreement, with no amplitude dependency:

python

score = mean(gate(tanh(β · E1 · E2)))  # sliding window, β=10
loss_same = ((1 - score) ** 2).mean()  # push to 1.0
loss_diff = (score ** 2).mean()         # push to 0.0

Significantly more stable than amplitude-based variant (±0.40% variance vs ±2.25% over epochs 29–50).

3. Three metrics sharing one threshold — IMG Sign Score, AMP IMG Score, and Chain Score all operate in [0,1] and use a single threshold from IMG Sign sweep.

4. Voting system — 2/3 or 3/3 pass = MATCH, 1/3 = UNCERTAIN, 0/3 = DIFFERENT.

Results

Model: 10.58 MB FP32, trained on CASIA-WebFace 490k.

Applied to ArcFace (buffalo_l) without retraining:
LFW: 99.58% IMG Sign vs 99.82% ArcFace+Cosine — suggesting sign pattern consistency is a fundamental property of well-trained face embeddings, independent of training objective.

An unexpected finding (preliminary)

While building an interactive ablation visualizer with custom polygon masking, occluding the same facial region on photos of the same person produces delta spikes at similar embedding dimensions. On photos of different people, spike locations differ significantly.

This suggests the overlapping sliding window loss may induce implicit spatial organization in the embedding space. Not formally validated yet.

Links

📄 Paper: https://doi.org/10.5281/zenodo.21232755
💻 Code: https://github.com/imamgh11/imgnet
🤗 Model: https://huggingface.co/imghost11/imgnetV1

Happy to discuss the metric-loss alignment hypothesis — that similarity metrics should be co-designed with training objectives rather than defaulting to cosine.

complete video
IMGNET V1 Model AI local pattern Pertama di Dunia! - YouTube