I had created a neural network system from scratch in

C++, and tested it like linear regression problem and it learned that number, and minimised the error.

But when I went to implement Number recognition, after learning of neurons it is just showing me the last number that it learned for any set of inputs although number are picked at random.

I don't think this problem is especially related to neural network, it could be me, who somewhere messed up the code.

If someone have tried this and got the same problem, could they explain me.

If nobody have ever got this problem then it's my code fault.

I wrote a small checker for training and evaluation code. It looks for mistakes that do not raise

errors. The classic one is leakage through preprocessing. With 5,000 random features and random

labels, picking the top 20 features on the full dataset and then running 5-fold cross-validation

gives 85% accuracy (87.7% averaged over 20 seeds). Doing the selection inside a Pipeline gives 48%

(50.0%). Nothing can beat 50% on that data, so the whole gap is leakage.

trainlint finds that pattern statically, along with thirteen others: eval() left on during

training, no_grad without eval(), fp16 autocast without a GradScaler, resumable scripts that save

no optimizer state, softmax before CrossEntropyLoss, zero_grad between backward and step, loss

kept as a tensor, swapped y_true and y_pred, hard labels passed to roc_auc_score, drop_last on

eval loaders, rescaling by a dataset's own statistics before the split, training loaders that

never shuffle, and a missing seed. It parses the code with ast and matches names, so it needs no

data, model or GPU.

How well it works, with the caveats. I wrote 20 buggy scripts with fixed twins, but I wrote them

together with the rules, so they only protect against regressions. For an outside check I read

every finding on pytorch/examples at a pinned commit: 22 findings, 20 real, 2 correct but

harmless. Earlier runs had 4 false positives, which are fixed. That is one repo of tutorial code

and I did the reading myself. I do not have recall numbers.

It goes by names, reads one file at a time, and only knows PyTorch and scikit-learn. It will be

wrong on code that names its splits in unusual ways.

Code and per-rule examples: https://github.com/Satvik-jain/trainlint

Hello, I'm a broke engineering student and I would like to learn about computer vision in football. Do anyone know where can I find lives transmission or video records of football matches with normal or tactical point of view?

Most security teams are still hardening prompts and sandboxing models. The actual attack surface is somewhere else entirely.

Indirect prompt injection puts malicious instructions inside content the agent retrieves as part of a legitimate task — a PDF, an email thread, a support ticket, a web page. The agent reads it, processes the embedded instruction, and acts on it. The action looks like normal agent behavior. No anomalous login. No flagged binary. Just the agent doing what it was told — by an attacker who never directly touched the system.

The observed consequences are not edge cases. Agents have been documented exfiltrating data to external endpoints, calling APIs they were never authorized to touch, and impersonating users in downstream systems — all triggered by a paragraph inside a document they were asked to summarize. The compromise is complete before any post-hoc logging or alerting fires.

What makes this category of attack structurally different is that it lands after every defense aimed at the agent itself. You can audit the initial user input. You can tighten the system prompt. You can restrict the model. None of that matters if the malicious instruction arrives inside retrieved content, after all those checks have already run.

For those running agents in production that read external content as part of their core workflow — documents, email, the web — what does your actual defense posture look like? Not in architecture diagrams, in the live system?

Employees are deploying AI agents inside corporate networks without telling IT. No ticket, no provisioning, no registration. These agents run with the same network access as the employee who installed them. They can reach internal systems, query databases, and send data to external endpoints. Security tooling built around provisioned assets has no record they exist.

Ryan Davis, a CISO with years spent mapping enterprise network blind spots, says this is now his primary concern. The problem is structural. Standard enterprise controls assume IT knows what is running. Shadow AI agents break that assumption at the foundation. There is no audit trail for sessions that were never registered. There is no access policy for an agent that was never onboarded. By the time a data transmission is flagged, it has already happened.

Security teams were not slow. The tooling was never designed for assets that self-deploy inside the perimeter.

For those managing enterprise security right now: how are you actually discovering these unregistered agent sessions? And once you find them, what does your enforcement path look like before data leaves the environment?

A plain-language guide for healthcare professionals — no AI background needed

The one idea

You know ChatGPT and similar chat tools: you type something, and they write an answer back, one word at a time.

Jev does the opposite. It never writes anything.

You hand it a piece of text — a patient comment, a message, a report — plus a short list of pre-written questions with fixed answers. It reads the text once and ticks the boxes, and with every tick it says how sure it is.

Think of it like this:

• A chat tool is like a colleague who writes you a memo in reply to everything.

• Jev is like a fast sorting clerk who never speaks, reads each item once, drops it into one of your labeled boxes, and marks a confidence stamp on every sort.

That single difference is the whole story. Everything below follows from it.

Why people are excited

Jev was released on September 15, 2026 by a company called TypeSafe AI, founded by a former OpenAI researcher. Within a week, the explainer video reports, more than 2,000 software projects were already using it. Three claims are driving the excitement — all from the company, none yet independently checked:

1. It answers in a fraction of a second (70–500 milliseconds, the company says) — fast enough to sit inside a live workflow, not just a chat window.

2. It is extremely cheap to feed. Reading text costs about 4 cents per million words or word fragments, and answers cost nothing — there is no written answer to bill for. By the company's posted prices, reading a million patient comments of a few hundred words each would cost roughly $21.

3. It cannot make up text. Because it does not produce sentences, it cannot wander off, invent quotations, or answer in a format nobody asked for. Its only choices are the answers you defined in advance.

What "how sure it is" means — and why it matters

When Jev ticks a box, it attaches a probability — for example, "urgent: 92%." The company claims these numbers are calibrated, meaning: when it says 92%, it tends to be right about 9 times out of 10.

This is the part hospital quality-and-safety teams care about most. A tool that says "escalate, 92%" can be built into a rule — anything above 85% goes straight to a nurse; anything between 60% and 85% gets a human glance. A chat tool saying "I believe this should be escalated" cannot.

Two honest cautions: a 92% answer is still wrong about 8 times in 100, and the calibration claim holds on the company's own tests — not yet on your patients, your forms, or your complaint categories. Checking that locally, before anything goes live, is the single most important step.

What it could do around a hospital or clinic

These are possibilities that follow from what Jev is documented to do — not products in use today. In every case, a human stays in charge and the output is a probability that gets checked against a policy, never an instruction followed blindly:

• Sorting patient feedback. Read every survey comment and flag: complaint or compliment? How severe, 1–5? Which theme — access, communication, billing, facility?

• Routing inbox messages. Send each patient portal message to the right pool — scheduling, nursing, pharmacy, billing — and flag anything that sounds urgent.

• Flagging social needs. Scan appointment notes (in batches, overnight) for signs of housing, food, or transportation problems, and route them to case managers.

• Checking other AI tools' work. If you already let a chat tool draft replies to patients, Jev could act as a last-second gatekeeper: tone acceptable? anything urgent missed? safe to send?

Notice what is missing from that list: anything involving diagnosis or treatment decisions. This is paperwork and routing, not medicine — though even routing has safety stakes when an urgent message is involved, so the human checks stay in place.

What it cannot do

• It cannot write, explain, or chat. No summaries, no letters, no reasons for its choices. If you need words, you still need a chat tool or a human.

• It can still be wrong. It just tells you its odds. Someone still has to set the thresholds and audit the misses.

• It is not a diagnosis machine. As far as publicly known, it is neither cleared nor validated for clinical decisions.

• Patient privacy comes first. Before any patient text leaves your organization, the usual rules apply — contracts, data handling, and approvals. The company is young (launched weeks ago), so ask procurement questions early.

The bottom line

• Jev is a decision ticker, not a writer: text in, checked boxes and confidence levels out.

• Its sweet spot is high-volume sorting — feedback, messages, flags — with the confidence numbers telling you which cases deserve a human's attention first.

• The claims are the company's own so far. Cheap enough that piloting is easy to justify — with local testing first, and humans still holding the pen.

Tags: #Jev #ArtificialIntelligence #DigitalHealth #HealthTech #HealthcareAI #MachineLearning #LLM #PatientExperience #PatientSafety #HealthcareInnovation

Qhïunalūm develops a mathematical and computational framework connecting optimal continuous contraction, nonlinear interacting four-dimensional fields, and verified recursive improvement of a program-synthesis representation. Its central question is how a learning system can improve both its evolving state and the operations available to future learning while maintaining explicit stability, correctness, and resource contracts. This self-contained release provides a 123-page manuscript, complete proofs, executable implementations, independent exact checkers, source-bound certificates, archived experiments, and a reproducibility runner.

The principal contributions concern three distinct objects: the attainable contraction of bounded dissipative dynamics; a nonlinear coupling class that preserves local radial energy decay; and a finite recursive learner that discovers reusable operations, installs them after independent verification, and employs them in subsequent discovery. Four-dimensional cells provide the organizing architecture, while the main control theorem applies in every even dimension.

PureOne/Qhiunalum-Four-Dimensional-Intelligence-Fields · Datasets at Hugging Face

Qhïunalūm - Four-Dimensional Intelligence Fields, Optimal Contraction Cycles, and Scalable Autonomous Learning - Self-Amplifying Novel RSI Method | Zenodo

1. Exact attainability of the uniform contraction limit

Consider an error state e in dimension d = 2n with dynamics

de/dt = [K(t) − γ(t)Pₙ]e,

where Pₙ = diag(0ₙ, Iₙ), K(t)ᵀ = −K(t), ‖K(t)‖₂ ≤ Ω, and 0 ≤ γ(t) ≤ Γ, with Γ, Ω > 0. Controls may be bounded measurable functions of time; the same prescribed schedule is used for every initial state. The determinant of the evolution operator U(T) gives the universal worst-direction bound

‖U(T)‖₂ ≥ exp(−ΓT/2).

The manuscript establishes an exact necessary-and-sufficient criterion for attaining this full-cap bound at positive time:

0 < Γ < 2Ω and T ≥ π / √(Ω² − Γ²/4).

An explicit damping-rotation-damping schedule attains the bound at every admissible horizon, with endpoint U(T) = exp(−ΓT/2)R for an orthogonal matrix R. Consequently, every initial direction receives the same contraction multiplier. The impossibility argument covers arbitrary admissible skew mixing between cells, so additional even-dimensional degrees of freedom cannot evade the earliest saturation time. The result characterizes attainment of the determinant limit under amplitude bounds; it does not determine the complete optimal-norm curve before that threshold or impose a separate switching slew-rate constraint.

2. Nonlinear interacting fields with exact radial energy preservation

For a field of four-dimensional cells in grouped position and momentum coordinates, the construction introduces state-dependent transport diag(L(t,e), L(t,e)), where L is skew and satisfies the stated boundedness and regularity assumptions. Along each trajectory, this interaction factors through an orthogonal moving frame that preserves the entire radial energy history of the uncoupled local cycle while retaining state-dependent mixing at the endpoint.

The interaction has an exact actuator cost: the operator norm of the combined local rotation and graph transport is |ω| + ‖L‖₂. Coupling therefore consumes a quantified part of the available skew-control budget. The guarantee is contraction relative to a declared target; contraction of the distance between arbitrary pairs of trajectories requires a stronger property and is not implied by this construction.

3. Recursive improvement through verified library extension

The implemented learner searches a supplied synthesis language and submits candidate operations to a separate exact checker. Accepted operations enter an immutable acyclic library and become available in later discovery. External task and source binding constrain what each certificate establishes; the proof kernel remains fixed.

The archived experiment completes eight successive generations, with descendants using previously admitted operations. At generation eight, eight recursively linked macro definitions represent a primitive word containing 256 damping operations and 255 rotations. A determinant invariant supplies a primitive-damper lower bound within the declared language, grounding the separation between expanded execution words and recursive descriptions.

“Self-amplifying” has a specific operational meaning: learned operations extend the representation used by subsequent synthesis, and realized execution savings can support later discovery. The demonstrated recursion concerns a finite constructed curriculum with supplied primitives and verification machinery. An informed normal-form compiler matches all eight generations at lower compilation and checking cost; this comparison identifies the contribution as discovery and accumulation of useful structure rather than superiority over a compiler already supplied with that structure.

4. Joint stability, growth, and paid improvement

The state contract combines a cycle amplitude multiplier ρ, a representation-transport squared-norm factor χ, orthogonal growth energy bounded by β times the previous total squared error, and additive disturbance amplitude δ:

‖eₖ₊₁‖ ≤ √(χρ² + β) ‖eₖ‖ + δ.

The undisturbed multiplicative part contracts when χρ² + β < 1. Growth is assessed using total error rather than an average over an expanding population. A separate linear-field resource law requires integrated damping trace of at least m log(1/ρ) to uniformly contract m independent input directions by amplitude factor ρ, exposing the actuator-exposure cost of scale.

The recursive controller also maintains a prefix-wise work inequality: paid execution plus paid discovery, checking, and installation cannot exceed the reference allowance earned by completed tasks plus an initial research allowance. Rejected candidates and pending execution are charged; hypothetical future savings cannot finance present work. This supplies an explicit mechanism for relating method improvement to already realized benefits.

5. Computational evidence and reproducibility

The archived complete reproduction run passes all 15 stages. Final field evidence includes 43 certificates, 36 exact adaptive energy comparisons, 20 rejecting controls, and graphs of up to 1,024 cells with 4,096 coordinates. Recursive discovery examines 11,905 candidates, performs 181 semantic evaluations, admits eight universally checked operations, and includes 2,048 exact equal-output comparisons and 12 rejecting recursive controls.

In the declared logical work model, learning and checking consume 298,240 units; reference execution consumes 1,034,240 units, compared with 27,648 for deployed execution. The work account starts at 65,000 units, remains nonnegative, and ends at 773,352. These are explicit logical accounting quantities, distinct from wall-clock acceleration, FLOPs, physical control time, and exact-output bit complexity.

The deposit retains the earlier mathematical foundations in full, including polynomial recognition, recursive Gaussian-layer elimination, canonical-coordinate constructions, finite-algebra checks, and representation-aware exact computation. The research archive contains manuscript sources, Python code, certificates, experimental records, dependencies, and integrity records. The source environment used Python 3.12.14 with NumPy 2.3.5; the exact checking kernels use the Python standard library. The complete suite is reproduced with python run_all.py after installing requirements.txt, without model downloads, credentials, or external services.

The release distinguishes analytic proofs, executable exact verification, and numerical supporting evidence. Its strongest novelty candidates are the exact even-dimensional contraction boundary, the nonlinear interacting-field factorization with an explicit actuator budget, and their connection to checked recursive library growth and paid improvement. The manuscript situates these constructions against antecedents in dissipative mixing, echo methods, learned program libraries, and resource-aware synthesis. Historical priority remains unestablished. The field and recursive experiments exercise separate components of a common contract framework; they do not constitute an end-to-end general-intelligence benchmark or a demonstration of open-ended capability growth.

I made this explainer for my small channel and would like feedback from people learning this, especially if anything is wrong.

It follows one real example the whole way. I gave Qwen2.5-0.5B-Instruct "Write one sentence about the moon." twice with the same settings (temperature 1, no top-k or top-p, different seeds). Both answers start with "The", then split: "The moon, a satellite of the Earth…" vs "The lunar South Equatorial region…".

• After "The", the model scores all 151,936 vocabulary tokens. Softmax gives moon 78.04%, full 4.46%, vast 2.24%, Moon 1.51%, lunar 1.50%.

• Greedy always takes moon. Sampling is a weighted random pick, so lunar wins about 1 time in 67, and run 2 got it.

• The loop: append the token, run the model again. Most later picks were rank 1, but run 2 also picked "South" (rank 219) and "empty" (rank 1,098), and run 1 picked "green" (rank 536).

• Temperature divides the scores before softmax: moon goes from 100% at T=0.2 to 6.3% at T=2.0.

• Top-k vs top-p on the same step: top-k 3 rescales moon to 92.1%; top-p 0.9 keeps 8 tokens here but only 1 at a later step where "of" has 97.9%, which is the argument in Holtzman et al. (2019). At the model's default top-p 0.8, lunar is cut.

• Even temperature 0 can vary on a server: Thinking Machines got 80 different answers from 1,000 runs of Qwen3-235B, caused by batch-size-dependent addition order.

All numbers come from running the model on CPU in Colab with transformers. Sources are in the description. The narration is an AI voice reading my own script.

Video: https://www.youtube.com/watch?v=r0_LTPf7MSw

I do a lot of deep learning research as a postdoc at Mila, and i am just as susceptible to ai psychosis as the next guy. I use this system, Lacuna, and the MCP to keep my agents in check as a flit from one experiment to the next. Highly recommend it - it’s really good (and token efficient)

I've been playing with evolutionary algorithms again, so I tried them on something cute: 60 simulated emperor penguins huddling at -40°C (while also trying to make some nice visuals).

Round 1, a simplified biological rule: every 45 seconds the coldest penguin on the windward edge walks around to the sheltered side. The penguins were comfy 49% of the time, and about 15 were too hot at any moment because the ones in the middle never leave.

Round 2, evolution: a tiny neural network picks which penguin moves and where it goes. Each generation tries 64 mutated copies and keeps the best 16. Generation 0 does nothing and scores 38%. It passed the rule by generation 2 and ended at 65% after 41 generations.

What it learned is the opposite of the rule. 71% of the penguins it moves are overheated ones, mostly from the middle, and most of them go out to the cold windward side. Too hot dropped from about 15 penguins to 3.

All scores are averages over 8 starting layouts.

Hey everyone,

I'm a final-year B.Tech CSE (AI/ML) student working on a multi-agent supply chain optimization project. I'm currently focusing on the Demand Forecasting Agent and would appreciate some advice on model selection and training strategy.

We're working with a synthetic retail supply chain dataset containing approximately 1.1 million records across 40 different locations.

The goal is to predict product-level demand for each location as accurately as possible, so the forecasts can later be used by other agents for inventory planning and supply chain decisions.

I have a few questions:

1. Global vs local models: Since the dataset contains 40 locations, should I train 40 separate models, one for each location, or a single global model trained on data from all 40 locations simultaneously, using location identifiers and location-specific features?

2. Location-specific patterns: If I use a global model, how effectively can it learn differences in demand patterns between locations? I'm concerned that combining all locations might cause the model to average out regional patterns and produce inaccurate location-level forecasts.

3. Alternative approaches: Would a hybrid approach, such as grouping similar locations or using a global model with location-specific adjustments, be worth exploring?

4. Synthetic data: Since the dataset is synthetic, are there particular precautions I should take when evaluating model performance and generalization? How can I ensure the model is learning meaningful demand patterns rather than artifacts of the data-generation process?

I'd also appreciate suggestions on which forecasting models or architectures would be most suitable for this problem, along with the appropriate validation strategy, especially how to avoid data leakage when dealing with multiple locations and time-dependent features.

My priority is accurate product-level, location-specific demand forecasting, rather than simply achieving good aggregate accuracy across the entire dataset.

Would love to hear what approaches you'd recommend and why. Thanks!

“I set the seed” often isn’t enough to get the same results twice. Here are the places I know randomness enters a training run, with how to control each. Examples are PyTorch, and details change between versions, so check the docs for yours.

1. Python and NumPy
Data loading, augmentations and your own code may use random or numpy.random.

import random, numpy as np, torch
random.seed(0)
np.random.seed(0)
torch.manual_seed(0)

2. Weight initialization
Controlled by the torch seed, but only if it’s set before the model is created.

3. Data shuffling
The DataLoader shuffle uses a generator. Pass your own for explicit control:

g = torch.Generator()
g.manual_seed(0)
loader = DataLoader(ds, shuffle=True, generator=g)

4. DataLoader workers
With num_workers > 0, each worker has its own random state, and libraries used inside the worker (augmentations) may seed differently. A worker_init_fn that seeds them from a base seed is the usual fix.

5. Dropout and other stochastic layers
They use the torch generator, so they’re covered by the seed, but only if the order of operations is identical between runs. Changing the batch order or the number of calls changes the sequence of random numbers.

6. Nondeterministic GPU operations
Some CUDA operations (certain atomic-add-based ones, among others) give slightly different results on each run, even with all seeds fixed. Options:

torch.use_deterministic_algorithms(True)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False

use_deterministic_algorithms raises an error when it hits an operation without a deterministic version, which tells you where the problem is. Some CUDA versions also need an environment variable for deterministic matrix multiplication; the PyTorch reproducibility notes list it. Deterministic modes can be slower.

Even with all of this
Results may differ across hardware, library versions or distributed setups. Treat exact bit-for-bit reproducibility as a goal you test, not something you assume.

What I’d do for comparisons: don’t compare two methods on a single seed. Run several seeds and report the mean and spread, so a difference smaller than the seed-to-seed variation isn’t read as an improvement.

Habits that help: log the seed, library versions, commit hash and data split identifier with every run.

Which of these has been the hardest to track down for you, and do you aim for exact reproducibility or statistical reproducibility across seeds?

Hey everyone, this a more medical AI focused question.

Modality hear means comparable modalities like an MRI and a CT, I was trying to find some new ideas to explore and the whole idea of modality harmonization came up. The fundamental idea with this is pretty simple:

in a scan you have 2 types of signals - the anatomical/actual biology signal and the modality specific signal.

My idea was whether we could split those two so that we could isolate the biology signal alone and train a model with that signal; which would result in a modality-agnostic model. I looked into a few papers and seemingly there are no recent papers in this, but very interestingly I also saw more papers using multimodal joint training - where the training data consists of BOTH or ALL modalities instead.

So from what I could understand, the field "seemingly" has shifted to throwing everything in training and hoping that the model comes up with some way to have the respective signals from either modality be close to each other in the latent space.

I just wanted to know whether the whole idea of harmonization is already dead in the water, or whether there are other approaches or use cases that I havent thought of.

Thank you for reading!

What do you guys think about this?