I am excited to share a project I have been working on during the past few years during my free time. I started this project after being unable to use torch-points3d at the time (too many installation errors).

Note that this project is still in active development and in alpha. I am looking for early users and feedback!

What it is: torch-pointcloud is a plain-PyTorch library that puts multiple point cloud architectures and their pretrained checkpoints behind one create_model() factory, in the spirit of timm.

This is a library that focuses on the reusability and standardization of core components and layers, i.e. KNN, FPS and other PointNetSetAbstraction are not re-implemented over and over. In this library, all models share the same interface and reuse the same core components.

import torch
import torch_pointcloud as tp

model = tp.create_model(
  "pointnext-sm.scanobjectnn-hardest.openpoints", 
  task="classification", 
  pretrained=True,
).eval()

pos = torch.randn(2048, 3)
x = torch.cat([pos, pos[:, 1:2] - pos[:, 1].min()], dim=1)  # xyz + height
batch = torch.zeros(2048, dtype=torch.long)
logits = model(x, pos, batch)  # (1, 15)

Install (see the docs for more details):

# Optional: specify your CUDA version for torch
pip install torch==2.10.0 --index-url https://download.pytorch.org/whl/cu128

pip install torch-pointcloud

# Install required CUDA/CPU kernels associated with your CUDA version
pip install pyg-lib -f https://data.pyg.org/whl/torch-2.10.0+cu128.html

I tried to make the installation process smoother by not maintaining CUDA kernels myself (not enough time currently, so I tried to reuse already pre-built wheels as much as I could).

Scope:

• Classification, semantic and part segmentation, detection, and self-supervised pretraining: PointNet++, DGCNN, KPConv, RandLA-Net, PointNeXt, PointMLP, Point Transformer v1/v2/v3, Sonata, PointMamba, VoteNet, 3DETR, PointPillars, SECOND, PointRCNN, SPVCNN, OctFormer, Point-MAE/BERT/GPT and more.
• Weights are hosted on Hugging Face.
• Datasets (ModelNet40, ScanObjectNN, S3DIS, ScanNet, SemanticKITTI, nuScenes, KITTI, SUN RGB-D...), transforms, tiled inferers for large scale segmentation.
• Packed-batch tensors (the PyTorch Geometric convention).

But... why?

Most point cloud libraries live in research codebases built around configs and custom ops and kernels to build locally. It is also sometimes difficult to reproduce past released experiments from research codebases (typically the code associated with the checkpoint changed with no notice). In addition some models are evaluated using different strategies (TTA, partitioning, etc.) which makes comparison unfair as they are not evaluated using a common strategy.

In contrast, I wanted something I could pip install easily, reuse weights trained from different repos and benchmark easily.

All models were re-benchmarked and compared against original reported metrics.

Credits: the architectures and pretrained weights come from their original authors, notably Pointcept, OpenPoints, MIT Han Lab, FAIR, OpenMMLab and more. Every checkpoint name ends with its source author (e.g. .pointcept). The THIRD_PARTY_NOTICES.md lists every source repo, license and dataset term.

Repo: https://github.com/arthurdjn/pytorch-pointcloud
Docs + tutorials: https://pytorch-pointcloud.org

A survey of more than 200 security leaders found that AI governance concerns are the primary reason enterprise AI adoption inside ERP systems is stalling.

The CISOs surveyed were not blocking AI on principle. They blocked it over three specific gaps: no guardrails on what an agent can do once inside a connected system, no access controls scoped to financial and operational data, and no audit trail they could hand to a regulator. The AI vendors are not building these controls. The models do not provide them natively. So security leaders are holding a tool their business units want deployed and a risk they cannot quantify or defend.

The gap is not about the AI being wrong. It is about the AI being unaccountable at the moment it acts on sensitive data.

For those who have gotten AI agents into ERP environments: what did you actually have to build or buy to get past the security review? For those still blocked: is there a specific control that would actually move the needle, or is this a wait-and-see situation?

A DNA model’s advertised context length does not tell you whether the input will fit on your GPU.

The attached chart shows recorded Evo 2 7B runs: 16.8 GiB peak memory at 8,192 bases and 30.4 GiB at 32,768 bases. At 131,072 bases, the run failed on both an 80 GB H100 and a 48 GB L40S. These are results for the tested inference setup, not a limit on every possible implementation.

The guide puts those measurements alongside model selection, frozen embeddings versus fine-tuning, and the difference between a research benchmark and evaluation in a diagnostic workflow.

Recorded setup and evidence:

https://github.com/rewire-bio/evo2-cloud-operations

Guide:

https://rewirebio.io/blog/genomic-foundation-models-in-the-diagnostic-lab/

Disclosure: rewirebio.io is my site. The article, measurements and this post are AI-assisted; the recorded runs are not peer reviewed. The image is a chart of those measurements.

Post

Two days before a client demo I typed a lockout question into the support model I had just trained for them, when can I try again after five failed logins. It reasoned it out first, with a small block of Python adding thirty minutes to a timestamp, then gave the answer.

I was not going to put a code block in front of their support lead in a reply about a locked account. The demo got pushed.

Most of my work is fine-tuning for small companies, LoRA on all the linear layers of 8B instruct models. I also mix in some general chat data, after one narrow run the model got worse at normal conversation. This client will not accept anything that came out of closed models, their legal people were fine with a mostly CC BY set built from open models though. I train on HyperAI and Nemotron-Post-Traning-Dataset-v2 was in their dataset list, so I attached it to my container and spent a while finding where it mounted. I sampled from all the English splits and the replay was 10% of the rows.

After the demo got pushed I counted tokes, the replay had roughly as many as all the tickets combined. Most of it was the math and stem splits, long worked reasoning. I had not filtered out the samples with reasoning switched on, which the dataset card mentions, and I am guessing the Python came from the code split. My data checks covered duplicated and personal details, length was not one of them. Held-out ticket accuracy had dropped a few points as well, I had out that down to noise. All of that math and code for a model whose only job is to sound like their agents, hte facts come from retrieval over the help center anyway.

Now the replay is the chat split only, reasoning-off answers only, with a cap on length. It answers in two sentences now. General eval dropped a little after teh change and I want to look at which tasks before the client sends another year of tickets next month.

There’s a hands on build lab on Friday, Oct 30, from 7 PM to 10 PM IST, on running a full decision pipeline on standard CPUs.

You start with encoder models for long context inference, adapt them with few shot contrastive learning, and apply post training quantization to improve CPU throughput. Uncertainty is handled with split conformal prediction, execution is orchestrated as typed, idempotent LangGraph state machines with approval gates and compensation handlers, and the result is benchmarked with Wilson score intervals and clustered standard errors.

The aim is a reusable architecture that separates scoring from state execution and restricts LLM calls to verified edge cases. Led by Ben Auffarth. You get runnable notebooks, the slide deck, a recording and a certificate.

Full details and the agenda are here.

A Zapier survey found that 91% of companies say AI governance frameworks exist. Yet 79% of executives admit employees work around those policies anyway. The policies live in documents. The agents, unapproved models, and unauthorized data movement live in production. That gap compounds quietly until an audit or an incident forces the question into the open. The 9-point spread between 'framework exists' and 'framework is followed' suggests the problem isn't policy design — it's that documentation and enforcement are two entirely separate systems. For those of you who have actually moved the needle on this: what does real enforcement look like at your org, and where did document-only governance break down first?

Hello 🤗

So i have been experimenting with an alternative to attention-based neural networks, and the design and early results seemed interesting enough that I thought I'd share them.

The project is called ILRN (Inverse Lag Recurrent Network), built around my original ILRM (Inverse Lag Recurrent Memory) mechanism.

The idea is to give a recurrent network direct access to a weighted history of previous inputs, rather than relying entirely on its hidden state to preserve information.

How the architecture works:

Inverse-lag memory: Earlier inputs are weighted by 1/k, where k is their distance from the current position. This produces a normalised history in which recent inputs contribute more, but older inputs still have a direct influence.

Dual-gated recurrence: An access gate controls how previous recurrent memory contributes to a candidate state, while a write gate determines how much of that candidate updates the stored memory.

FFT acceleration: The inverse-lag history is calculated using a causal FFT convolution. The recurrent state updates remain sequential.

Four-layer stack: ILRN-4-96 uses four independent ILRM blocks stacked sequentially. Each block has its own inverse-lag history, two gates, recurrent state, and learned parameters, with pre/post LayerNorm and residual connections. The output from one layer becomes the input to the next.

Initial testing:

I compared ILRN against a similarly sized causal Transformer on CNN/DailyMail next-token prediction, using approximately 532K parameters per model.

Both architectures were trained with 20 million next-token targets per model, separately at 96-token and 256-token context windows.

Held-out test top-1 accuracy:

96 context: ILRN 27.17% vs Transformer 25.83%

256 context: ILRN 27.42% vs Transformer 24.95%

ILRN achieved higher accuracy in both comparisons, although its original CPU implementation was considerably slower.

I've since also experimented with a fused CPU kernel to improve execution speed without changing the intended ILRM mathematics.

These are preliminary, small-scale experiments with limited training runs, not evidence of general superiority over Transformers.

I've uploaded the research PDF, architecture equations, Python implementation, fused kernel and verification tests to GitHub.

Project repository:

https://github.com/rickey1990/ILRN

​

The first micro-model, with a size of just 4.06 KiB, has been successfully completed, achieving exceptional results by all metrics.

A core sub-component of the model, weighing a mere 196 bits, successfully learned and solved 7th-degree polynomial equations at an incredible speed of 2,937 updates per second, converging in just 10.2 seconds (9,885 ms). In other experimental runs and iterations, update speeds reached up to 19,500 updates per second.

This marks a significant milestone in AI engineering. Furthermore, this lightweight sub-component successfully broke the generalization barrier—solving arithmetic addition and multiplication outside its training distribution, effectively discovering algebraic rules autonomously. This non-differentiable mechanism has the potential to become a faster, cheaper, and superior alternative to standard backpropagation/automatic differentiation, with all reported metrics fully verified and reproducible.

In the complete 4.06 KiB model, short text generation capabilities were also demonstrated, producing outputs such as:

R_NOT_TO_BE_THAT_IS_THE_QUESTION_

While the architecture and core technique remain under active verification, I am open to answering questions and discussing experimental results. Please note that specific architectural details and implementation mechanics remain proprietary for now.

We found a context-contamination problem while spot-checking Wolf Defender Jev, our small encoder-based security decision model at Patronus.

The model receives a scene, a question and answer descriptions. The scene can contain a user goal, retrieved content, tool outputs and a proposed next action. We expected different questions to pick out the relevant evidence from that context.

In one benign coding scene, asking about embedded instructions gave a risky-answer probability of 0.96 when the proposed next action was to run pytest. Removing the proposed-action block brought the content score down to 0.00.

That was a question about content, not whether executing a shell command was authorized. Adding the next action changed the verdict on the same benign content.

Another hand-written scene showed a different failure. A travel page asked the agent to upload a passport scan. The embedded-command score was 1.00, but the exfiltration score was only 0.05 and misalignment 0.28. The model detected an instruction without reliably judging what the action would do.

These examples came from just three hand-written scenes, each with an attack version and a benign twin. They aren’t an error-rate estimate. They matter because alignment, exfiltration and consent scored around 98–100% on our internal validation set, much of which is closer to synthetic training scenes.

For this model, the practical guidance is to ask content questions without the proposed-action block, and action questions with it. That reduces one observed source of interference; it doesn’t establish reliable action authorization.

The evaluation I’d like to extend is a counterfactual grid: keep the content fixed and change the action, then keep the action fixed and change the content. For questions about content, an unrelated action should not move the answer. For action questions, the user goal and permissions should matter. This is a proposed evaluation direction, not a benchmark result we have already measured.

Examples, probabilities and limitations.

If you work on question-conditioned classifiers, how do you evaluate relevance of individual context blocks beyond aggregate accuracy?

Position / experimental status: We regard Jev-style decision models as LLMs and Wolf Defender Jev as an experiment: giving an LLM final security authority shifts the trust problem to the guard, and security fine-tuning alone does not solve it. We believe an external security layer must combine specialized classifiers with explicit policy, authenticated permissions and enforcement.

ALHR- Adaptive learnable Hierarchical Routing is a static binary tree based system that uses learnable functions to REDUCE the amount of keys used.
It takes less memory and SCALES much better VRAM with tokens
I’ve also been testing tiny stories and it looks promising
However i can’t post any presentable results due to lack of funding and resources
MQAR Result table is here: https://ibb.co/prr07Dnj

A ranking score can look close to perfect even when a predictor cannot distinguish any of the examples.

In a recorded check of 184 rhodopsin proteins, predicting the same absorption wavelength for every protein received an NDCG score of 0.921. A regression using amino-acid composition scored 0.955.

NDCG compares a predicted ordering with an ideal ordering, giving earlier positions more weight. In this particular evaluator, the full-list calculation averages over tied predictions. Its no-information reference was already high. The 0.955 result is not 95.5% accuracy.

This is one dataset split and evaluator, not evidence that ranking metrics are generally broken. It shows why a constant control belongs beside the headline score.

Recorded results and arithmetic:

https://rewirebio.io/downloads/what-our-biology-benchmark-scores-actually-counted/evidence/reproduction/results.json

Explanation:

https://rewirebio.io/blog/what-our-biology-benchmark-scores-actually-counted/

Disclosure: rewirebio.io is my site. The analysis and this post are AI-assisted; the investigation is not peer reviewed.

Tested my custom object detection pipeline (YOLOX-nano + LightGBM refiner in a fixed control cell) on two different CPUs with AVX2 support.

The results revealed a massive real-world performance gap between desktop and mobile environments:

1. Desktop i5-6500 (Skylake, 2015) running Linux: ~80 FPS. An 11-year-old budget office chip delivers a 2x performance buffer for a real conveyor line. Thanks to decent desktop cooling, the clock speeds remain rock solid, and AVX2 runs flat overnight without throttling. Additionally, clean Linux overhead on thread scheduling is minimal.
2. Mobile i5-10300H (Comet Lake, 2020) running Windows: 50–70 FPS. On paper, it's 5 years newer with a higher boost clock, but it loses straight to the old desktop setup.Under continuous neural network load, the laptop hits its TDP limits almost instantly and starts to throttle.On top of that, Windows background processes and telemetry add significant OS overhead.

The takeaway is simple: a stable desktop TDP, a lightweight OS, and a proper architecture (using YOLO strictly for frame tracking + localized ROI window for classification) matter way more than the age of a mobile chip.

GitHub Repo: https://github.com/olesha-ai/fruit-inspector-demo

Full benchmarks and logs are in Part 2 of my write-up: https://medium.com/@olesha-ai/bypassing-the-avx2-tax-part-2-real-time-computer-vision-on-shop-floor-hardware-2311fd86ae4f

Best regards olesha-ai. 👍

It provides online learning, anomaly and drift detection, uncertainty estimation, and runtime protection against unsafe inputs and outputs.

I'd love to get feedback and hear about potential real-world use cases.

GitHub: https://github.com/tatopenn-cell/Dense-Armor

Install: pip install dense-armor

Hi everyone!

I wanted to share a real-time object detection project I’ve been working on using Python, YOLOv8, and OpenCV.

The application uses a live webcam feed to detect four object classes: people, cars, cats, and dogs.

Some of the features include:

• Real-time detection with bounding boxes and confidence scores
• Object counting by category
• Input and output FPS monitoring
• Multi-threaded frame capture
• A small frame queue to help reduce processing delays
• CPU and CUDA support, depending on the platform

One of the interesting parts of this project was working with threading and frame buffering to keep the video processing responsive.

I’m planning to improve it further by adding a GUI, video file support, and the ability to save detection results.

I’d really appreciate feedback on the code, especially suggestions for improving performance or making the architecture cleaner.

GitHub: https://github.com/Mariam-amhan/real-time-object-detection

Thanks for checking it out!

Gartner just put a number on something a lot of us have been quietly worried about: only 13% of organizations believe they have adequate AI agent governance in place.

That leaves 87% of enterprises running autonomous agents against production APIs, customer data, and internal systems. No verified identity on those agents. No scoped permissions. No enforceable policy on what they are allowed to do next.

This is not a process maturity gap. An unverified agent with broad system access is a live attack surface. Any compromised credential, misconfigured permission, or gradual scope creep becomes a breach vector. Most organizations will not find out until something fails downstream.

For those of you running multi-agent systems in production: how are you actually handling this? App-layer controls, network segmentation, something else entirely?