Every new laptop today is marketed as an ‘AI PC’ thanks to a built-in Neural Processing Unit (NPU). But beyond chatting with small local LLMs, what practical work can this silicon actually do? Recently, I hit a wall with a classic IT problem: data gravity. I had about a hundred gigabytes of scanned family photos that needed to be organized and enhanced. Uploading gigabytes of media to a cloud AI API for something as straightforward as deduplication is unreasonable. The compute needed to move to the data, and that meant putting my laptop’s idle NPU to work. Source code for the scripts used in this article is available on GitHub.
Why heavy media work belongs on local silicon
Archiving thousands of pre-digital-age photos and massive video files is a common challenge for most households. Those archives easily span terabytes, making cloud uploads a bandwidth nightmare. While data privacy is a major reason to keep workloads local, data gravity is the physical bottleneck I had to design around here.
It definitely isn’t just my problem—it’s the industry’s. The default architecture of the AI boom, which ships every inference task to a centralized cloud API, is colliding with hard physical limits. The electrical grid simply cannot support the current pace of hyperscale build-outs. Recent industry projections show US utility capacity falling short of data center power demand by over 100 gigawatts by 2030. Regulators are actively stepping in to throttle this: just days ago in September 2026, Virginia (the densest data center region in the world) signed Executive Order 22, heavily restricting state assistance for new hyperscale deployments over 25 megawatts due to acute grid and water constraints. The cloud’s physical room is running out, which is exactly why compute has to move to the data.
Fortunately, consumer hardware is evolving to support this. Most modern machines now ship with an NPU specifically designed for tensor operations. Let’s look at how edge processing can replace cloud APIs for heavy media.
Understanding the edge hardware trade-offs
To understand why local AI architecture is shifting, it helps to look at how modern silicon divides the workload across different classes of hardware:
- CPU (Central Processing Unit): It handles system logic and file I/O effortlessly, but running continuous neural network math requires brute force—pegging core usage at 100%, drawing 35W+ of power and rapidly draining a laptop battery.
- GPU (Graphics Processing Unit): Built for massive graphics rendering and high-throughput compute, but highly power-hungry and often reserved for heavy graphics or dedicated model running or training.
- NPU (Neural Processing Unit): Purpose-built specifically for low-power matrix operations on consumer devices, it handles smaller AI workloads at single-digit wattage (~6W).
Apple platforms are a special case. Projects like qwen-ane are proving that Apple’s 32-core NPU can run massive 27B models while sipping just 8W of power. While this level of efficiency is exactly what the industry needs, it is still strictly experimental—the inference speeds aren’t yet viable for production workloads.
High-end AI desktops like the NVIDIA GB10 also don’t have NPUs. Instead, they rely on massive GPUs packed with thousands of Tensor Cores and unified memory, with combined consumption sometimes exceeding 160W.
Building a semantic deduplication pipeline with OpenCLIP
For this project, I focused on image deduplication and making the idle NPU speed up the pipeline.
Very simply put, semantic deduplication works by comparing the distance between image embeddings—high-dimensional digital representations of the pictures. Generating these embeddings is the heavy lifting done by the AI model. Before anything reaches the model, each photo goes through a pinned preprocessing step: resize the short side to 256 pixels, center-crop to 224 and then normalize with OpenAI’s published constants. Applying the exact same crop and transform to every image on every run is what keeps the comparisons mathematically stable.
The foundation for this approach was laid in March 2021, when OpenAI introduced Contrastive Language-Image Pre-training (CLIP). Prior to CLIP, computer vision models were largely rigid classifiers trained on fixed datasets like ImageNet, capable of recognizing only a pre-defined set of categories. OpenAI changed this by training a dual-encoder architecture on 400 million image-text pairs scraped from the web. By training an image encoder and text encoder simultaneously to pull matching pairs together in a shared vector space and push mismatched pairs apart, CLIP learned generalized visual concepts rather than narrow labels.
When OpenAI released CLIP, they published the pre-trained weights for several architectures, including ResNet variants and a then-novel Vision Transformer (ViT). Over the last few years, the open-source community (notably the OpenCLIP
[…]
Content was trimmed to protect the source. Please visit the original article for the full text.
Read the original article: