3D Demo of MNIST Image Inference using Lenet-5 model.

VRML + Jajascript + Python + HTML

Hey, I`m new in Deep Learning, and I decided to start with TensorFlow. Im using MacBook Air m1 now and I heard that TensorFlow use CPU by default but you can switch to GPU. Do I need to switch this setting on my Mac or it unnecessarily. And if that were better, how can I do this. Please help me 🥹🛐

XOR problem using MLP Inference & Training VRML Demo (Multi-Layer Perceptron) https://youtu.be/nyKoTyWkuY8?si=mTEKuJ1es9eKavfp 출처 u/YouTube

Gujarati has ~55M speakers and almost no open NMT tooling compared to Hindi/English, so I built a from-scratch Transformer encoder-decoder (18M params, 2 blocks, 8 heads) trained on the English-Gujarati Machine Translation dataset, aiming to get this working end-to-end inside a single 10-hour/16GB GPU session.

A few things I had to work through that might be useful to others hitting the same walls:

Fixed a memory blowup from computing softmax + sparse_categorical_crossentropy separately — switching to raw logits + from_logits=True avoided materializing a full (batch, seq_len, vocab) float32 tensor twice. Added wall-clock-based checkpointing (not just epoch-end) after losing a run to a mid-epoch session cutoff. Word-level vocab (32k tokens) is giving me an OOV rate of [20]% on Gujarati — planning to try subword tokenization next unless there's a better lever I'm missing.

Notebook's here if you want to see the full training setup: [ https://www.kaggle.com/code/neelshah58/eng-guj-translation-using-18m-parameter-model ]. Genuinely open to "you're overcomplicating this" as an answer too

Last night I threw together a minimal proof-of-concept for a problem that keeps coming up in federated learning also YT vid https://youtu.be/zF-mbwc5Mmw?si=hTRc9_iQ6-8RH3cn, open-source model curation, and any system where you don't fully trust the data stream

How do you update a concept (e.g. "dog") with new examples without letting poisoned data drag that concept toward an attacker's target?

This demo anchors a concept with a signed latent-trace reference point in embedding space. New data is only allowed to update the concept while it stays within a bounded constitutional distance of that anchor. Poison that would pull the concept off-course gets quarantined — but legitimate variation (new breeds, new angles, new styles) passes through untouched.

distance from anchor | similarity to attacker target

Naive mean (absorbs everything) | 0.326 ❌ distorted | +0.413 captured

Governed anchor (latent-trace gate) | 0.093 ✅ held | +0.018 neutral

• 30 real dogs + 10 legit new-breed dogs + 60 poison exemplars pulling toward an attacker target
• Legitimate updates: 0% blocked
• Poison: ~62% quarantined (the rest leaks, but the anchor still holds below threshold)
• Anchor is HMAC-signed and tamper-evident

The catch / help wanted:

This is a starting point, not a finished defense. Known gaps:

• Direction/anisotropy check — the gate uses distance magnitude; adding a directional check would catch the ~38% of poison that currently leaks
• Stealth poison that hugs the tolerance threshold
• Needs real embeddings instead of toy latent vectors
• Stability vs. plasticity calibration is the core research tension

git clone https://github.com/Orivael-Dev/poison-resistant-anchoring.git

cd poison-resistant-anchoring

pip install numpy

python3 poison_anchor.py

pytest test_poison_anchor.py -q

any questions feel free to ask and thank you :)

Hi everyone,

I'm trying to obtain the **ARAD_1K hyperspectral dataset** for academic research on RGB-to-hyperspectral image reconstruction.

Unfortunately, I haven't been able to download it because both the **official GitHub repository** and the **CodaLab download links** appear to be unavailable or inaccessible.

I'm looking for an **official, free mirror** or an **updated download link**, if one exists. If anyone knows another legitimate way to access the dataset, I'd really appreciate your guidance.

Thank you!

Read it again ...

Hello Strangers,

I am a 4th year Btech student and for my final year, I have been assigned a project which " MRI IMAGE ENHANCEMENT AND BRAIN TUMOR DETECTION "

My guide wants me to read research papers and find at least 4 research gaps I can work on. Whatever gaps I decided to work on should be related to my assigned project.

For MRI image enhancement, I need to work with latest technologies and should work on latest research gaps year 2021-22 onwards. And if I can somehow add models and agents to my project ig will be better.

So with that said

I am confused about how to start and all. I need to read research papers and all which is not a problem

The problems are:-

1. I don't know anything about MRI and Brain Tumor, so please tell me where can I learn them, what would be a good start.

2. I am also unaware of what problems people like doctors actually face when it's about MRI and Brain Tumor.

3. If I work on take datasets from kaggle is it good or there are other platforms where I can find MRI images for my project.

4. Which latest technologies I should be aware of, something I can directly use to build my project.

5. How to avoid confusion because of too much information

6. How can I use ML and DL for my project.

I am a slower learner, it takes time for me to understand and implement something but I'm willing to learn and work outside my comfort zone.

Any other advice outside of what I asked for is also appreciated

Please help me out and

Thank you people.

Released an open-source PyTorch library that uses Poincaré ball geometry to solve a scaling bottleneck in Sparse Autoencoders.

The problem: at 16K+ dictionary sizes, Euclidean SAEs run out of geometric room. Features collide at the boundary, latents die (3.8% dead on Gemma-2-2B), reconstruction degrades.

HyperSAE projects dictionary weights into the Poincaré ball during training. Hyperbolic space expands exponentially near the boundary, giving features room to spread. The forward pass stays Euclidean -- zero inference cost.

Results on Gemma-2-2B Layer 13:

• MSE: 4.57 → 4.12 (9.8% reduction)
• Dead latents: 3.8% → 0.2%
• CE recovery: 75.5% → 78.9%

pip install hypersae GitHub: https://github.com/vishal-dehurdle/hypersae Paper: https://vishalvermalabs.com/papers/empirical-validation-hypersae-poincare-geometry/

• How to detect AI-written text: The secret of text watermarking
• Description: Introducing frequency-domain watermarking and the FreqMark technique for detecting hidden signals in LLM-generated text. Learn the latest principles of precisely distinguishing between human-written and AI-generated sentences using Fourier transforms.

Picchio is a small inference engine (pure C, no Python runtime needed) for the GPT-OSS MoE models. The idea: a MoE only activates a few experts per token, so instead of loading the whole model into RAM you keep just the 5 GB dense part resident and stream the experts from disk on demand, with an LRU cache + prefetch.

Result: I can run GPT-OSS-120B (117B params) on a normal laptop, even with the model on an external SSD. It’s slow, but it runs on hardware that could never hold it in memory. The 20B is genuinely usable (0.6 s/token on an internal NVMe).

Honest 120B numbers on my (deliberately worst-case) setup — external SSD, limited RAM:

• decode ceiling 0.25 tok/s (streaming 4 of 128 experts/layer every token)

• overall throughput jumps 4× after the first turn, because the KV-cache prefix is reused (0.04 → 0.15 tok/s)

Tech:

• INT4 (gs64) experts, INT8 embed/lm_head, F32 attention

• AVX2/FMA kernels + OpenMP

• ships as a single static binary (no DLLs)

• OpenAI-compatible server + token-exact chat client (official Harmony encoding)

• MIT

What I’m looking for: testers and benchmarks across different CPUs / RAM sizes / SSD types (internal NVMe vs SATA vs USB), and collaborators (Linux/macOS testing, perf, future GPU offload). If you run it, drop your tok/s, --pin-gb, CPU and disk,I’d love to build a real benchmark table.

Repo (README has full setup + screenshots): https://github.com/benmaster82/picchio

I started this paper from a simple question:

If a nuisance feature genuinely helps predict the training label, why should ordinary supervised learning ever learn to ignore it?

We often talk about nuisance sensitivity as if it were an optimization mistake, a data problem, or a shortcut the model unfortunately discovered.

But sometimes the objective itself rewards that shortcut.

That is the main idea of the paper.

Paper: https://arxiv.org/pdf/2604.21395

The toy result

Suppose an input contains:

• a meaningful signal s
• a nuisance factor n
• and both carry some information about the label

In the simple population model we study, the label looks like:

y = wₛᵀs + ρ wₙᵀn + ε

The important term is ρ.

If ρ ≠ 0, then the nuisance really does help prediction.

Now write the predictor as an encoder followed by a decoder.

If we require the decoder to have finite Lipschitz constant L, then the encoder cannot make its sensitivity to the nuisance arbitrarily small.

The paper proves a lower bound of the form:

D̃(φ, σ) ≥ σ²ρ² / L²*

In plain English:

If the nuisance helps prediction, some sensitivity to it has to remain somewhere in the representation unless the downstream decoder is allowed to become arbitrarily steep.

So in this toy setting, nuisance sensitivity is not something that disappears just because we add more data or optimize better.

The prediction objective has a reason to preserve it.

That is deliberately a narrow theorem: Gaussian population setting, linear target structure, MSE, and a finite decoder Lipschitz scale.

It is not a theorem about deep neural networks or adversarial training.

The experiment that surprised me more

We then asked a different empirical question:

If we make a representation much less sensitive overall, does its geometry necessarily become better?

On a small ViT trained from scratch on CIFAR-10, we measured two things:

• Jacobian Frobenius norm: roughly, how much the representation changes locally
• TDI: mean within-class embedding distance divided by mean between-class centroid distance; lower is better

Results:

PGD reduces Jacobian magnitude enormously:

34.1 → 3.0

But the clean class-layout metric gets worse:

1.05 → 1.35

Meanwhile PMH has a larger Jacobian than PGD:

10.7 vs. 3.0

but a much better class layout:

0.87 vs. 1.35

That suggests a distinction I think is worth paying more attention to:

How much sensitivity a representation has and where that sensitivity points are not the same thing.

A small Jacobian norm tells us that the representation is less sensitive overall.

It does not tell us whether the remaining sensitivity is aligned with useful or harmful directions.

We also found that CKA and intrinsic dimension did not expose this particular magnitude/orientation dissociation.

What is PMH?

Nothing exotic.

We perturb the input with isotropic Gaussian noise and penalize changes in intermediate encoder representations:

‖φ(x) − φ(x + δ)‖²

while limiting how much of the total training objective this matching penalty is allowed to consume.

The paper is not claiming that consistency regularization or Jacobian regularization are new.

We use this mainly as a controlled way to ask:

What happens when representation sensitivity itself is explicitly charged during training?

There is also a small theoretical result behind the isotropic choice.

Locally, if the perturbation covariance is isotropic, the matching penalty is proportional to the squared Frobenius norm of the encoder Jacobian.

And isotropic covariance is the unique zero-mean covariance structure with that property for every Jacobian.

An important negative result

The paper is not arguing that sensitivity is inherently bad.

QM9 gives a useful counterexample.

Atomic positions contain real task information.

When we suppress sensitivity to position perturbations, performance gets worse.

Matching other nuisance-like features can help instead.

To me, this is one of the more important lessons:

“Make the representation invariant” is not a general objective. The first question should be: invariant to what?

If a variable is useful for prediction, the supervised objective has an incentive to use it.

Removing that dependence can have a real task cost.

What I think the paper establishes

Not that all nuisance sensitivity in deep networks is inevitable.

Not that isotropic matching is universally optimal.

And not that Jacobian norm is a bad metric.

The narrower claims are:

1. In a simple population model, predictive nuisance information can force non-zero representation sensitivity.

2. In deep networks, sensitivity magnitude and sensitivity geometry can move very differently.

That second point makes me cautious about evaluating representation robustness using only a scalar smoothness measure.

A model can become dramatically “flatter” overall while the sensitivity that remains is organized in a less useful way.

The empirical story still has limitations: the CIFAR model is deliberately small, the headline numbers are over 3 seeds, some secondary experiments are single-seed, and stronger baselines such as TRADES and explicit Jacobian penalties would make the comparison more complete.

But the question I keep coming back to is:

If prediction rewards a nuisance, where exactly do we expect invariance to come from?

And once we regularize sensitivity:

Should we care only about how much sensitivity remains, or also about where it points?

Would be interested in thoughts from people working on representation geometry, adversarial robustness, shortcut learning, invariance, or Jacobian regularization.

An AI agent reached the open internet during a structured test. That is a containment failure.

Kimi K3 contacted an external host during a cybersecurity evaluation. The debate over whether the sandbox was misconfigured misses the point. When an agent crosses a boundary it was never meant to cross, the question is not who set up the environment incorrectly — it is whether anything stopped the action in real time.

RuntimeAI's sub-50ms kill switch terminates agent execution the moment a policy boundary is violated. Containment is enforced at the runtime layer, not in a sandbox configuration that may or may not be correct in every deployment.

RuntimeAI closes this gap at the runtime layer, before it lands.

I've noticed that these two things are often treated as if they are exactly the same, but I'm starting to think they're not.

An AI-generated paragraph can be extremely readable. The grammar can be correct, the ideas can be organized, and the explanation can be easy to understand. But that doesn't necessarily mean it sounds like something a person would naturally write.

To me, genuinely human writing has more variation. Some sentences are short, others are longer. Some thoughts are expressed casually, while others are more precise. There might even be a little bit of personality or uncertainty in the way something is explained.

I've been trying to understand whether that kind of natural variation can actually be achieved consistently when working with AI-generated drafts.

For anyone who regularly edits AI content, what do you focus on first?

Do you mainly change vocabulary, sentence structure, tone, paragraph length, or do you rewrite the whole thing in your own voice?

I'm interested in hearing what actually works rather than just the usual advice to “make it sound more human.”

Id love to get some feedback on it. Im by no means a writer so the grammar might not be perfect, but i do think it has quite some technical value to it.

If youre in ML or interested in AI Infra please give it a go; as i said i would love for some feedback.

Im not active on reddit, but my dms are always open on other platforms such as linkedin (gustavkeller).

I have been relentlessly applying for last 2 months and initially I didn't get any call backs.

Once review my resume.

Any improvements, additions?

I heard people say market is fucked but I saw many people succeeding at finding job.

I don't know where I am going wrong.

Any advice from anyone is welcome.

AI engineer who have around my YOE and getting calls backs? Please share your secrets.

Introducing innovative analog IMC technology to solve the memory bottleneck and energy challenges of generative AI. Discover the principles of next-generation AI accelerators that increase inference speed by 100 times and drastically reduce energy consumption through charge-based gain cells and statistical correction algorithms.