Machine learning on molecules
Fingerprints, SMILES, property prediction and screening — representing chemistry so a model can compute over it.
A molecule is not a vector, a string or a sequence. It is a labelled graph with a three-dimensional shape, and almost every decision in molecular machine learning is about which parts of that object you agree to throw away. A SMILES string discards geometry. A fingerprint discards the graph and keeps a hashed inventory of neighbourhoods. A message- passing network keeps the graph and learns the inventory instead. None of those is the molecule, and the gap between the representation and the chemistry is where the surprising results come from.
These pages work from the representation outward. Each one names the parameter that actually changes the answer — a fingerprint’s radius, a split’s scaffold rule, a docking box — and says what breaks when the obvious choice is made. They describe research methods: a model that ranks a compound highly has produced a hypothesis for a laboratory to test, not a result.
Molecular Fingerprints Explained
How a Morgan/ECFP fingerprint turns a molecular graph into a bit vector, and what the radius and bit length each change about the answer.
10 min read
SMILES Notation Explained
The grammar of SMILES from atoms to stereochemistry, worked on one molecule, plus why two toolkits disagree about the canonical form.
10 min read
Graph Neural Networks for Molecules Explained
Why atoms-as-nodes and bonds-as-edges is the natural representation, how message passing builds an atom's environment, and what depth costs.
10 min read
Predicting Molecular Properties With Machine Learning
A four-descriptor solubility regression worked end to end, and the splitting and error-floor decisions that decide whether the number means anything.
10 min read
Retrosynthesis Prediction Explained
How a model proposes precursors for a target molecule, worked on one amide disconnection, and why top-1 accuracy understates what a good model does.
10 min read
Molecule Generation Models Explained
How generative models emit molecules as strings or graphs, what a validity check actually tests, and why validity is the easiest metric to satisfy.
10 min read
Predicting Chemical Reaction Outcomes With AI
How forward reaction models map reactants to products, worked on one esterification, and why yield is much harder than product identity.
10 min read
Virtual Screening: How AI Narrows a Compound Library
The filter-and-dock funnel from ten million compounds to a shortlist, with the enrichment arithmetic that tells you whether it worked.
11 min read
Molecular Similarity Search With Fingerprint Embeddings
Tanimoto similarity computed by hand, the size bias hiding in it, and the popcount bound that makes billion-compound search tractable.
10 min read
Predicting Protein-Ligand Binding Explained
What a binding-affinity model is actually scoring, the free-energy arithmetic that sets the accuracy it needs, and the shortcuts these models learn instead.
11 min read
What It Costs to Screen a Compound Library With AI
The compute cost of a ten-million-compound screen derived line by line from stated per-compound times and a stated hourly rate.
10 min read
Converting a Chemical Name to a Structure With AI
A lookup-first pipeline that resolves chemical names to SMILES with a deterministic parser, a database and a model fallback that is always validated.
11 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
- Sensor and IoT data
- Logs and event streams
- Models over biological sequences
- 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