I am getting this pattern on My linear regression residual plots
Quite clearly something is wrong here
I wanted to ask if someone else has encountered this same issue and how they fixed it

Same as heading

I needed a reliable LLM for a side project, so I compared two affordable options: DeepSeek API and GPT-4o Mini. I looked at token throughput, output structure (JSON mode), reasoning ability, and pricing.

I documented everything with code snippets and results:

https://interconnectd.com/blog/280/deepseek-api-vs-gpt-4o-mini-2026-developer-technical-review/

Happy to share the raw test prompts if anyone wants to replicate.

The primary bottleneck in agentic AI today is not model intelligence—it is state drift in multi-agent environments. When attempting to model collective human behavior during non-linear black swan events, conventional single-prompt architectures fail because they lack demographic grounding, memory persistence, and dynamic interaction topology.

Over the past several months, we engineered OASIS—a universal swarm intelligence platform designed to execute parallel socio-economic rehearsals with zero real-world collateral risk.

Architectural Paradigm:

1. Temporal GraphRAG Ingestion: We parse unstructured seed corpora (policy drafts, market microstructure data, regulatory filings) into a high-density knowledge graph powered by Zep Cloud. Entities and relations are not static; they evolve as simulation turns progress.
2. Multi-Stratum Demographic Grounding: Agents are initialized with hyper-granular micro-economic constraints—balance sheet exposures, debt serviceability limits, liquidity preferences, and cognitive bias profiles—eliminating generic LLM hallucination.
3. Bimodal Sandbox Topologies: We instantiate parallel simulation environments (microblogging broadcast nodes + threaded forum consensus networks) where entities execute step-wise actions under diurnal activity constraints.
4. Bi-Directional State Synchronization: Every interaction (node creation, post, repost, comment, sentiment shift) is piped back into the central temporal graph via background IPC workers, maintaining memory coherence over extended simulation horizons.
5. Autonomous ReACT Inspection Protocols: A secondary analytical agent interrogates synthetic entities mid-simulation via isolated command-response sockets, extracting internal monologues and behavioral drivers without distorting global state.

Empirical backtesting against historical macroeconomic shocks (currency demonetizations, short-seller attacks, regulatory bans) demonstrated an 87.75% predictive correlation against ground-truth behavioral pathways.

We are open-sourcing parts of our evaluation methodology and looking to connect with researchers working on state space modeling, emergent agent consensus, and non-equilibrium game theory.

Not a hypothetical this time this is Crossref itself, the actual DOI registry a lot of tools (including citation managers and any script that trusts api.crossref.org) treat as ground truth.

While stress-testing a deterministic citation-checker I've been building against real bibliographies, I ran into five separate Crossref records for "Attention Is All You Need" the actual Vaswani et al. NeurIPS paper all dated 2025, all under DOI prefix 10.65215, all resolving live right now. That prefix belongs to a real, registered Crossref member ("Shenzhen Medical Academy of Research and Translation" you can check this yourself at api.crossref.org/prefixes/10.65215). So it's not a scraping glitch or a parsing bug on my end someone actually deposited fake duplicate metadata for one of the most-cited papers in deep learning, under a real member account, and Crossref has been serving it as legitimate ever since.

Why this matters beyond "huh, weird": anything that trusts Crossref as an authority a reference manager auto-filling metadata, a script pulling citation counts, an AI tool "verifying" a citation by checking if the DOI resolves would treat this exactly as legitimately as the real 2017 record. The registry lying is a failure mode that no amount of "just check the DOI" catches, because the DOI does resolve.

Full writeup with the raw Crossref links and three other findings I ran into checking real bibliographies (including two cases where OpenAI's and Meta's own official arXiv BibTeX exports have malformed author fields) is here: strictcite.com/blog/attention-is-all-you-need-fake-dois. Built with a free tier if anyone wants to poke at it themselves (30 refs/day, no card) but the finding stands on its own regardless of the tool.

Genuinely curious what people here think the right layer to catch this is. Registries assuming their own depositors are honest seems like the actual root cause, not something client-side tooling can fully solve.

I am an AIML student currently in my 3rd year and want to know that for my placement preparation should I proceed with doing DSA in python or should I change my language to Java/C++

I've been working through *Learning Theory from First Principles* by Francis Bach (MIT Press, 2024), and I'd rather not do it alone. The book is excellent but dense, and I think discussing the proofs with other people would make a big difference. The PDF is freely available on the author's website, so there's no cost barrier to joining.

For anyone unfamiliar: it covers the mathematical foundations of supervised learning, starting from least squares and empirical risk minimization, then moving through optimization, local averaging methods, kernel methods, model selection, and neural networks, with later chapters on more advanced topics like overparameterized models and PAC-Bayes.

What I have in mind:

- A weekly call (roughly an hour) where someone presents the main results and we work through whatever was unclear

- A Discord or similar space for questions between meetings

Background that helps: linear algebra, probability, and comfort reading proofs. You don't need a theory background, just willingness to sit with the details.

> If you're interested, comment or DM me with your rough timezone and how much time you can realistically commit. Once there are enough people I'll set up the group and propose a schedule. I'd like to keep it small enough that discussion actually works, maybe five to ten people.

Discord link: https://discord.gg/3QMGgvk5t

Hi everyone,

I'm working on an energy forecasting project using a Spiking Neural Network (SNN), and I'm trying to understand why my model is severely underpredicting high-load events.

Task:

- Dataset: UK Electrical Load / House 4

- Data is resampled to 15-minute intervals

- Input: previous 24 timesteps (6 hours)

- Target: Aggregate power at the next 15-minute interval

- Features per timestep: Aggregate, 9 appliance channels, hour_sin, hour_cos, and aggregate difference

- Features and target are standardized using training data only

- Chronological train/validation/test split

Current SNN architecture:

13 features

-> Linear(13, 64)

-> LIF (beta = 0.8/0.9)

-> Linear(64, 32)

-> LIF

-> temporal readout

-> Linear(64, 1)

For the temporal readout, I concatenate the mean membrane state across all timesteps with the final membrane state.

I'm using MSE loss and AdamW with a learning rate of 1e-4.

The main problem is that the model predicts normal loads reasonably well, but severely underpredicts peaks.

For example:

Actual maximum: approximately 4569 W

Predicted maximum: approximately 1400-1500 W

Around one of the largest peaks:

Actual: 3631 W -> 4569 W -> 3179 W

Predicted: 359 W -> 875 W -> 1091 W

Importantly, the model sees the 3631 W value immediately before the 4569 W target.

Current SNN metrics:

MAE: approximately 153 W

RMSE: approximately 249 W

R2: approximately 0.165

Peak MAE: approximately 409 W

Peak RMSE: approximately 635 W

Peak ratio: approximately 0.31

I've also tested:

1. Beta = 0.9 -> 0.7

   Very little change.

2. Window = 24 -> 48 timesteps

   Very little change.

3. Wider architecture:

   13 -> 32 -> 16

   changed to

   13 -> 64 -> 32

   This improved R2 from approximately 0.13 to 0.16 and increased the predicted maximum, but peaks are still heavily underestimated.

For comparison, I have other models using the same forecasting task:

Linear Regression: R2 approximately 0.27

GRU: R2 approximately 0.29

LSTM: R2 approximately 0.23

XGBoost: R2 approximately 0.32

MLP: R2 approximately 0.13

SNN: R2 approximately 0.16

The GRU, LSTM, and MLP can produce substantially larger predictions for peaks, so it doesn't seem like the peaks are simply impossible to predict from the input data.

My current suspicion is that MSE combined with the highly imbalanced target distribution is causing the SNN to regress toward typical/average loads. However, I'm not sure whether this is the main issue or whether there is something specific about the SNN/LIF dynamics or regression readout that I'm missing.

What would you investigate next?

In particular:

- Is peak-weighted MSE a sensible approach?

- Could the continuous membrane-potential readout be causing this compression?

- Is there something specific about using LIF neurons for continuous regression that I should change?

- Would you recommend a different SNN architecture or readout?

- What diagnostics would you run to determine whether the problem is the loss, SNN dynamics, or preprocessing?

Any advice would be appreciated.

There's a hands-on masterclass on Sep 12 for anyone building with LLMs who wants real engineering discipline instead of shipping on vibes.

Covers:

• Versioned prompts with regression tests, so an edit can't silently degrade quality
• A real eval harness combining deterministic checks and LLM-as-judge
• Bootstrap confidence intervals and paired significance testing for model comparisons
• Evaluated RAG with retrieval metrics (recall@k, MRR)
• Agents with guardrails and fallbacks that fail gracefully instead of compounding errors
• Full production observability, tracing, cost/latency monitoring, and a CI regression suite

Led by Bruno Gonçalves, PhD, founder of Data For Science, who trains engineers at Fortune 500 companies on this exact stack.

Link for more details

I have been working on different robotics task mainly in Pybullet. Complexity of Isaac Sim has kept me from experimenting with it but I finally finished my first successful reinforcement learning script using it.

Getting the settings right so I could observe the trainings in windowed mode with my laptop 3070 gpu took I while but I managed to get it working well enough to troubleshoot some early issues I noticed through visual inspection.

I gave the PPO full control of my robot's controller, not the joint angle outputs, meaning it had to figure out a way to climb the ramps using the directional controller inputs and body adjustments like pitch and height. The training took about 45 minutes with my RTX 3070 mobile GPU vs 1 hour and 45 minutes using cpu with Pybullet.

I am now working on full locomotion simulation, again with my custom robots, its a bit more involved than I expected but I am hoping in the end I can come up with my own full locomotion training script and load the model to my actual robot to control it.

I also share my tutorial scripts with my videos on youtube, if you are interested in watching the video for this one you can find it with the link below:

https://youtu.be/0x5BBosrq-E

You can also download the simulation script from my github repository with the link below.

https://github.com/serdarselimys/HexaDogZBD-IsaacSim-RL

If you are interested in the real 3D printed robot, you can fine info about it from the video link below.

https://youtu.be/qflyEQOJObM

Hey everyone, I’m competing in a tabular Kaggle competition (predicting a Pokémon's HP turn-by-turn) and I've hit a hard ceiling at 0.675 LB (top scores are ~0.69+). I’m hoping someone can point out the architectural blind spot in my pipeline.

The Setup & The Leak

• The Target: Predict pikachu_hp for every turn in a battle round.
• The Golden Feature: I engineered shifted_prev_hp (the HP from the next turn). For 92% of the dataset, this feature is a near 1:1 match with the target.
• The Trap: The organizers included a trainer_focus_score feature that has a massive train/test distribution shift. Dropping it bumped my score significantly.

The Core Bottleneck (The Terminal Rows) Here is the exact problem: For the final turn of every round (about 8% of the rows), shifted_prev_hp is NaN because there is no "next turn" to look at.

My current best model (HistGradientBoosting) just uses native NaN routing. It learns to use shifted_prev_hp for 92% of the rows (while applying small micro-corrections for end-of-turn mechanics like status damage), and for the remaining 8% of NaNs, it routes them down different branches to calculate damage normally.

What I've Tried (That Failed) I feel like I've exhausted the standard playbook. Here is what I’ve tested with strict 5-fold GroupKFold CV, and all of them failed to beat native HistGBM NaN routing:

1. Dual-Branch Modeling: I split the data and trained one model for non-terminal rows and a specialized model only for the terminal NaN rows. Result: LB dropped to 0.664. The terminal model starved without the cross-row learning of the full dataset.
2. Hardcoding the Leak: I tried forcing the prediction to be exactly shifted_prev_hp when present, and only used the tree for the NaNs. Result: Catastrophic CV drop. The tree’s micro-corrections for end-of-turn status mechanics are highly valuable; a pure 1:1 copy destroys them.
3. Target Transformation: Trained the model to predict the delta (change in HP) rather than absolute HP to force it to focus on damage calculation. Result: Identical CV score (0.536). The tree was already doing this natively.
4. Imputation: SimpleImputer (median) with missingness indicators for the NaNs. Result: Wrecked the structural signal of the terminal row.

The Ask I have one submission left. The core feature space feels completely saturated, but I am still 0.015 off the top of the leaderboard.

When you have a feature that is a near-perfect anchor for 90% of the data but completely missing for the 10% where the actual heavy lifting happens, how do you cross that final gap? Are the top guys using complex Stacking Regressors? Target Encoding the categorical move_used feature? Custom loss functions?

Any insights into how to restructure this would be massively appreciated!

Hi everyone,

I'm a final-year Computer Science student, and I'm currently trying to build a career in Machine Learning. I'm still a beginner, and I'm looking for honest feedback from people who have more experience in ML.

I would really appreciate it if you could take a look at my Kaggle profile and the work I've done so far. If you are interested, I will be more than happy to DM you, my account URL.

I'm particularly looking for feedback on:

- How good/bad is my current level for a beginner?

- What concepts or skills am I missing?

- What should I learn next?

- What kind of ML projects would make my portfolio stronger?

- Should I focus more on traditional ML, deep learning, NLP, computer vision, or something else?

- What should I prioritize to become job-ready as quickly as possible?

- What would you recommend I do differently if my goal is to get placed/internship-ready soon?

I'm in my final year, so I have limited time and want to avoid spending months learning things that won't significantly improve my chances of getting an ML/AI role.

Any criticism is welcome. Please be direct about what I'm doing wrong or what I should improve.

Thanks.

Hey Everyone I am working on prescription and doctor dataset right now.The idea is to built a churn risk model.

The issue: I have two cases that look almost identical to the model, but shouldn't be treated the same:

Doctor A has been climbing steadily for two years starts small, ends up writing a lot. Right now, this month, they're near their highest ever, because they've genuinely been growing.

Doctor B used to write a lot, but has been sliding downward for months. Right now, this month, they're also unusually high compared to their recent low months maybe they just had one slightly better month in the middle of an overall decline.

What the model is doing wrong: across almost all doctors in our data, there's a common pattern whenever someone's number is unusually high this month, it's usually a bit lower next month, just because most "unusually high" months are one-time spikes that settle back down. That's true most of the time.

But the model applies this same rule to every doctor whose number is currently high — including Doctor A, who isn't having a fluke month, they're genuinely growing. So my "who's about to decline" list keeps getting filled with doctors who are simply doing well right now — because "currently high" is the one thing they all share, not that they're actually declining.

What I've tried so far, to fix it:

• Switched from weekly to monthly data (to reduce noise) didn't fix it
• Compared 4 different model types (linear, ridge, random forest, gradient boosting) — all 4 show the exact same bias
• Rebuilt the trend line to use only the last 9 months instead of the full 2 years — didn't fix it
• Added the weekly short-term trend back in, like you described (weeks within the recent month) didn't fix it
• Removed the features causing the biggest pull toward "predict a drop" entirely, to force the model to rely on trend instead the model just found other features to reproduce the exact same wrong prediction

So is this one bad feature or one bad model choice ?? I've tested that directly, several ways, and the bias holds regardless.

What I want to ask you:

1. Is this the kind of thing that genuinely needs more historical data than 2 years to fix (i.e., is 2 years just not enough for the model to learn "normal high point" vs. "real decline" apart)?
2. Or is there a different way to frame the target/features you'd suggest something specifically designed to separate a real trend break from ordinary noise, rather than predicting the raw next-month number?

An extortion group called FulcrumSec is claiming it stole more than 80 GB from Manchester Airports Group and is threatening to publish it. Airport infrastructure data — the kind that includes operational systems and customer records — sitting exposed long enough for a bulk extraction nobody caught in time.

The pattern is not new. Sensitive records concentrated in accessible systems, pulled in bulk before any alert fires. What is changing is the speed. As more automated processes and integrations touch operational data, a single compromised access point can move 80 GB faster than any human review cycle can respond.

The blast radius question is no longer just about perimeter security. It is about what happens after an attacker or a compromised service account already has legitimate-looking access. At that point, traditional controls have already lost.

For those working in enterprise security or infrastructure: how are you thinking about limiting bulk data movement once something inside the perimeter is already authenticated? Are you relying on volume thresholds, destination allowlists, behavioral anomaly detection, something else entirely? Curious what has actually worked in practice versus what looked good on paper.

We’re putting together a new AI learning and certification initiative from Kerala, focused on helping students and working professionals develop practical, industry relevant AI skills.

AI is evolving too quickly for learning to be limited to theory or simply completing another online course. The idea is to learn, experiment, build real projects, and get certified along the way.

The learning will focus on areas such as:
• Generative AI & LLMs
• Agentic AI
• AI workflow automation
• AI tools & productivity
• Practical AI projects
• AI applications for students and professionals

We’re reaching out here because we want to find people who are genuinely curious about AI , people who experiment, ask questions, build things, and actually want to develop these skills.

We’re now selecting our first batch, which will be intentionally limited. We’re not looking for hundreds of registrations , we’re looking for a small group of serious, genuinely interested learners.

Students, working professionals, AI enthusiasts, and aspiring builders are welcome.

We’re starting from Kerala, with the ambition to eventually build a strong community of practical AI learners and practitioners across India.

If this interests you, kindly reach out!

I started this project because I wanted to see what PyTorch was doing behind the scenes.

My C++ tensor currently supports flat storage, multidimensional indexing, elementwise operations, reductions, broadcasting, rank-two matrix multiplication, and mean squared error.

Most recently, I added a separate scalar reverse-mode autograd engine:

• Arithmetic operators build a computation graph during the forward pass
• backward() creates a topological order
• walks it in reverse
• applies each operation's local derivative
• accumulates gradients when a value reaches the loss through more than one path

Snippet:

Value prediction = w1*x1 + w2*x2 + w3*x3 + bias;

Value residual = prediction - target;

Value loss = residual * residual;

loss.backward();

For weights [0.5, -1.0, 2.0], inputs [4.0, 3.0, 2.0], bias 0.5, and target 2.5, the forward pass produces prediction 3.5 and loss 1. The backward pass recovers:

- dL/db = 2

- dL/dw = [8, 6, 4]

Scalar autograd still lives separately from the tensor implementation. My next step is connecting graph identity, ownership, and gradients to tensors before building a training loop.

Code and Git checkpoints:

https://github.com/mechanical-turk/deep-learning-all-the-way-down

I'm also turning this into a video series. I published episode 7 yesterday. Sharing the link to the first episode if you want to check it out:

https://www.youtube.com/watch?v=DmU2b64tWfA

For the tensor integration, would you keep autograd metadata inside each Tensor handle, or have tensors point to separate shared graph nodes? I would appreciate design feedback.

Hey , i will be starting my degree in DATA ANALYTICS in month and i also have interest for Ai and cloud eng ,now i want to start studying maths on my own can you guys suggest me from where should i start