Sensor and IoT data
Sampling rates, drift, fusion and edge inference — modelling telemetry from devices that are unreliable by nature.
A sensor does not report the world. It reports a voltage that has been digitised, scaled by a calibration constant somebody wrote down once, and stamped with a time from a clock that is drifting. Every one of those steps introduces an error with its own shape, and modelling telemetry well is mostly a matter of knowing which error you are looking at: quantisation noise is white and harmless, aliasing is irreversible, and calibration drift is a slow bias that no amount of averaging removes.
These pages work outward from that. They start at the sampling decision, because it constrains everything downstream and cannot be undone in software, and then cover what to do with the stream once it exists: fusing several noisy channels into one estimate, catching a sensor that is failing before its output looks wrong, aligning clocks that disagree, and deciding what gets computed on the device rather than shipped. Where a number matters, it is derived on the page from inputs you can replace with your own.
Sensor Fusion Algorithms Explained
How two noisy measurements of the same quantity combine into one estimate that is better than either, worked through from inverse-variance weighting to the Kalman recursion.
10 min read
Anomaly Detection Across Correlated Sensor Streams
Why a fault often shows up as a broken relationship between channels while every individual channel stays inside its limits, and how to detect that.
10 min read
Edge Inference for Wearable Sensor Data
What running a model on accelerometer and PPG streams on the device itself actually involves: windowing, feature extraction, memory arithmetic and the duty cycle that decides battery life.
10 min read
Compressing Sensor Data Streams for Storage
What delta-of-delta and XOR encoding do to a telemetry stream, with the storage saving derived from a stated sampling rate and channel count.
10 min read
Choosing a Sampling Rate for IoT Data Collection
The Nyquist limit sets the floor, energy and bandwidth set the ceiling, and this derives data volume and current draw at three rates on one device.
10 min read
Detecting Sensor Calibration Drift Over Time
How to separate a slow bias in a sensor from a slow change in the thing it measures, using periodic references, peer comparison and a bias state.
10 min read
How Much Battery an On-Device Model Actually Uses
Energy per inference derived from a stated power draw and duration, turned into daily drain and device lifetime at three inference rates.
9 min read
Streaming Sensor Data Into a Model in Real Time
Build a windowed inference consumer that reads sensor messages from a queue, buffers them per device, and scores complete windows without blocking the reader.
10 min read
Building a Real-Time Digital Twin From Live Sensor Telemetry
How a continuously updated model of a physical asset stays in sync with telemetry, and what the residual between model and measurement is actually for.
10 min read
What Changes in Cost Moving Inference From the Cloud to the Edge
Derives the fleet size and inference volume at which amortised edge hardware becomes cheaper than per-inference cloud pricing, from labelled assumptions.
10 min read
Handling Schema Drift in a Sensor Data Pipeline
How a firmware update silently changes what a field means, why type checks do not catch it, and the contract a pipeline needs so that it does.
10 min read
Smart Building Occupancy Sensing With AI
Estimating headcount in a room by combining CO2 concentration with motion, using the mass balance that makes CO2 a quantitative occupancy signal.
10 min read
Fleet Telematics Anomaly Detection
Detecting abnormal vehicle behaviour from CAN bus and GPS streams, including why per-vehicle baselines matter more than fleet-wide thresholds.
10 min read
Labeling Challenges in Industrial IoT Sensor Data
Why ground truth for continuous machine telemetry is expensive and often unobtainable, with a worked labelling-cost example and the weak-supervision alternatives.
10 min read
What It Costs to Ingest a Million Sensor Readings a Day
Derives message, storage and query cost for a million readings a day from stated payload sizes and unit prices, and shows why batching dominates the answer.
10 min read
Detecting a Failing Sensor Before It Reports Bad Data
The variance and rate-of-change signatures that precede total sensor failure, and how to monitor a sensor's health separately from the quantity it measures.
10 min read
Time-Aligning Data From Sensors With Different Clocks
Correlated events that do not line up across sensors, diagnosed as a clock offset and fixed by estimating and correcting the offset per device.
10 min read
Choosing Between Edge and Cloud Preprocessing for Sensor Data
Deciding which processing stages run on the device by weighing bandwidth reduction against the compute the device has and the information the reduction discards.
10 min read
Other topics
- LLM fundamentals & architecture
- Tokens, tokenization & context windows
- Prompt engineering
- Reasoning models & test-time compute
- Multimodal AI: vision, audio, video
- RAG & retrieval
- Embeddings & vector search
- AI agents & tool use
- Structured output & function calling
- Fine-tuning & post-training
- Local inference errors, string by string
- Running local models day to day
- Testing code that calls an LLM
- Snapshot and property testing for model output
- Regression suites for prompts
- Eval gates in CI
- Flaky tests against a model
- Determinism and the cost of testing
- Contract and streaming tests
- Testing tool calls and retrieval
- Inference, serving & latency
- Rolling out a prompt change
- Testing AI systems in practice
- Forecasting a time series
- Machine learning on tabular data
- Geospatial data and models
- Understanding audio that is not speech
- Understanding video
- Core computer vision tasks
- Machine learning on graphs
- Point clouds and 3D
- Evaluation, benchmarks & LLM-as-judge
- Logs and event streams
- Models over biological sequences
- Machine learning on molecules
- Embedding and searching code
- Extracting invoices and purchase orders
- Receipts, statements and tax forms
- Insurance policies and contracts
- Deeds, court filings and patents
- Extracting from medical records
- Observability & LLMOps
- CVs, certificates and identity documents
- Shipping, customs and technical documents
- Meetings, email, chat and filled-in forms
- Building an extraction pipeline
- Business, property and inspection documents
- Contract clauses and insurance claims
- Regulated and compliance documents
- Consumer, travel and closing documents
- Mapping one chat API onto another
- SDK and framework migrations
- Hallucination & failure modes
- Re-embedding and model deprecation
- Cutting over between providers
- Parity gaps, shims and legacy endpoints
- Moving between model versions
- Migrating vector stores and caches
- Mapping capabilities and parameters
- Migrating pipelines and agents
- Contracts, runbooks and rollback
- Auditing a codebase before a cutover
- Compliance and fine-tune migration
- LLM cost engineering
- Routing, cost tracking and multi-tenancy
- What a migration does to your prompts
- AI security & prompt injection
- Privacy, compliance & data residency
- AI governance, policy & society
- Building reliable AI applications
- AI hardware, GPUs & compute
- Open-weight models & local inference
- AI for developers & coding agents
- AI in industry: vertical playbooks
- AGI, superintelligence, alignment & the long future
- Machine learning foundations
- NLP fundamentals & classical tasks
- Data engineering for AI
- Synthetic data & dataset curation
- AI product design & UX
- Search, ranking & recommendation
- Enterprise adoption & change management
- AI careers, skills & teams
- Reading AI research
- AI in science & discovery
- Robotics & embodied AI
- AI economics, markets & business models
- AI myths, hype & media literacy
- Context engineering
- Shipping AI features: patterns & anti-patterns
- Build it: end-to-end AI tutorials
- Python for AI: hands-on recipes
- TypeScript, React and the web
- Frameworks and SDKs
- Errors and troubleshooting
- AI facts, numbers and statistics
- The history of AI
- The maths behind AI
- Architectures beyond the transformer
- Reinforcement learning
- Diffusion and generative media
- Speech, audio and voice engineering
- Benchmarks, one at a time
- AI search visibility
- Infrastructure and operations
- Databases and storage for AI
- Knowledge graphs and structured knowledge
- Classical ML in production
- Regulation, jurisdiction by jurisdiction
- Prompt recipes and pattern library
- AI for people who do not write code
- Writing, media and creative work
- Edge and on-device AI
- Interpretability and model internals
- Field notes
- OpenAI model behaviour
- Claude model behaviour
- Gemini model behaviour
- Llama model behaviour
- Mistral model behaviour
- Qwen model behaviour
- DeepSeek model behaviour
- Cohere model behaviour
- Grok model behaviour
- Small model behaviour
- Hybrid model architectures
- Token cost by language and script
- Transliteration, romanization and script handling
- Locale-correct output
- Multilingual generation quality
- Multilingual pipelines
- The EU AI Act, article by article
- AI under the GDPR and EU data law
- US AI regulation, state and sector
- International AI governance and standards
- AI litigation and enforcement
- Running AI workloads on AWS
- Running AI workloads on Google Cloud
- Running AI workloads on Azure
- AI at the edge: Workers, Vercel and Netlify
- Serving models on Kubernetes
- Operating AI infrastructure
- Quantization formats and what they cost
- llama.cpp, flag by flag
- Ollama and the desktop local-model runtimes
- Local models on Apple Silicon
- Hardware for local inference
- Running speech and embedding models locally
- Model files, adapters and conversion
- VRAM arithmetic for local models