Each sentence is a triple in disguise: two entities and a verb tying them together. If we extract enough of them across enough articles, we get a knowledge graph: a structure we can query, visualize, and reason over.

This post walks through that pipeline end-to-end. We start from raw news text, run named entity recognition with spaCy, infer relationships, and analyze the resulting graph.

Subscribe now

As always, you can find the companion notebook on the Graphs for Data Science GitHub repository:

Graphs For Science GitHub

We use the AG News corpus, 120,000 articles across four categories (World, Sports, Business, Sci/Tech). For the sake of expediency, we sample 2,000 articles, balanced 500 per category. Loading is a single call to Hugging Face:

from datasets import load_dataset

dataset = load_dataset('ag_news', split='train')
df = dataset.to_pandas()
df.columns = ['text', 'label']
df['category'] = df['label'].map({0: 'World', 1: 'Sports',
                                  2: 'Business', 3: 'Sci/Tech'})
df = df.groupby('category').sample(500, random_state=42)

Two thousand articles are enough that real co-occurrences rise above noise, but small enough that the whole pipeline runs in a few minutes. A light cleaning pass to strip HTML, collapse whitespace, etc., is all the preprocessing the parser needs.

Named Entity Recognition

The first step in any knowledge graph pipeline is pulling entities out of the text. We use spaCy’s `en_core_web_lg` model and keep five entity types relevant to news: PERSON, ORG, GPE (countries, cities, states), EVENT, and NORP (nationalities, religious or political groups).

import spacy
nlp = spacy.load('en_core_web_lg')
ENTITY_TYPES = {'PERSON', 'ORG', 'GPE', 'EVENT', 'NORP'}

rows = []
for art_idx, doc in enumerate(nlp.pipe(df['text_clean'], batch_size=100)):
    for sent in doc.sents:
        for ent in sent.ents:
            if ent.label_ in ENTITY_TYPES:
                rows.append({'article_idx': art_idx,
                             'sentence':    sent.text,
                             'entity':      ent.text,
                             'label':       ent.label_})

On my MBP laptop, these 4,000 articles parse in less than five minutes. One problem becomes immediately apparent when NER finishes: The same entity can be referred to in different ways. For example, ”U.S.”, ”US”, ”United States”, and ”the United States” all refer to the same entity, but spaCy returns them as four distinct strings. If we want to prevent the graph from fragmenting into duplicate copies of every common entity, we must merge these variations into a single entity.

We implement this with a few simple hand-curated mappings (see notebook for the full list):

ABBREV_MAP = {'U.S.': 'United States', 'US': 'United States',
              'UK': 'United Kingdom',  'EU': 'European Union'}

def normalize_entity(text):
    text = text.strip()
    for prefix in ('the ', 'The ', 'a ', 'A '):
        if text.startswith(prefix):
            text = text[len(prefix):]
            break
    text = re.sub(r"'s$", '', text)
    return ABBREV_MAP.get(text, text)

On AG News, this reduces duplicate node forms by 40-60%, significantly improving the quality of our graph. For a production system, you’d want to perform entity linking against Wikidata or DBpedia. Still, for a simple exploratory pipeline, this gets you most of the way at a fraction of the cost.

Our sample has a wide range of entities covering a wealth of different topics:

Relation Extraction

Entities alone are just a list. The edges are where the graph becomes interesting, and there are two complementary ways to find them.

The first is co-occurrence. If two entities appear in the same sentence, treat them as related and accumulate a count across sentences:

from itertools import combinations
from collections import Counter

pair_counter = Counter()
for (_, _), group in ent_df.groupby(['article_idx', 'sentence_idx']):
    entities = sorted(set(group['entity_norm']))
    for e1, e2 in combinations(entities, 2):
        pair_counter[(e1, e2)] += 1

Co-occurrence is high-recall and noisy. Two entities mentioned in one sentence aren’t necessarily related. Still, the noise corrects itself at scale: real relationships co-occur repeatedly across articles, while spurious pairings have lower weights and get pruned later. The downside is that the edges are unlabeled: we know two entities are related, but not how.

For labels, we need syntax. The trick is to walk up spaCy’s dependency tree from each entity to the lowest common ancestor, and if that ancestor is a verb, that verb is the relation:

def get_relation_verb(ent1_span, ent2_span):
    e1_ancestors = set()
    tok = ent1_span.root
    while tok.head is not tok:
        e1_ancestors.add(tok.head); tok = tok.head

    tok = ent2_span.root
    while tok.head is not tok:
        if tok.head in e1_ancestors and tok.head.pos_ == 'VERB':
            return tok.head.lemma_
        tok = tok.head
    return None

This produces labeled triples like (Apple, acquire, Beats), (Biden, visit, France), and (Google, announce, Samsung). Dependency parsing is precise when it works, but still limited. Passages using the passive voice, complex clauses with multiple verbs, and conjunctions all defeat it. In practice, the right move is to use both: co-occurrence for edge weights and coverage, dependency parsing as a labeling layer that fills in verbs wherever it can.

Building the Graph and Pruning It Down

NetworkX assembly is mechanical once you have entities and edges. Each node carries its dominant entity type and a mention count; each edge carries a co-occurrence weight and an optional verb label. The interesting work is what comes next.

The raw graph is a messy hairball with thousands of nodes, most appearing once, and most edges are sentence-level coincidences.

We drop edges with weight below 2, then drop nodes with degree below 2. In our data sample, this removes 70-80% of the structure, and what remains are entities that meaningfully co-occur and are connected by relationships that are consistent across multiple articles. The result is much cleaner:

Analysis

Once the graph is clean, classical network analysis answers most of the interesting questions. PageRank ranks entities by structural prominence (an entity is important if it’s connected to many other important entities) and surfaces the heads of state, large corporations, and geopolitical hot spots that sit at the center of news coverage.

If we now size the nodes by their PageRank, and restrict our graph to just the Top 100 nodes by PageRank, we obtain a nice visual representation of the contents of the news knowledge graph:

Betweenness centrality, on the other hand, finds bridges between clusters, entities that show up in multiple otherwise-separate stories. A pharmaceutical company that appears in both Business and Sci/Tech, or a country that turns up in both World and Sports, will have a lower PageRank but a high betweenness. That’s how we can identify cross-domain stories.

Community detection adds one extra layer of nuance to our analysis. News naturally clusters around storylines: the US presidential election, a European football transfer window, a tech acquisition wave. The Louvain algorithm for community detection finds these clusters by maximizing modularity, a measure of how strongly connected a community is internally relative to its external connections.

The communities we identify map cleanly to recognizable real-world stories, even though Louvain knows nothing about news categories. The graph structure alone is enough!

In total, we identify 41 communities of varying sizes:

And a quick look at the nodes that constitute each community makes it clear that they are related, validating the knowledge we included in our knowledge graph:

We hope you enjoyed this Graphs post on the Data for Science Substack and look forward to hearing your thoughts. We hope you

Leave a comment

You can find all the code for the analysis in this post in our companion GitHub Repository https://github.com/DataForScience/Graphs4Sci

And, of course, don’t forget to

Share

this post with others who might be interested, and encourage them to

Subscribe now

so that they have access to the entire backlog of posts and be the first to know when a new a new article is posted.

Subscribe now

You can find the companion notebook on the Visualizarion for Data Science GitHub repository:

Visualization For Science GitHub

The Bureau of Transportation Statistics provides a wide range of datasets on US and global transportation infrastructure. We have used it previously here, here, and here.

The first step in our analysis is to extract the Top destinations for each state. We sort the outgoing destination of each state and extract the Top n:

Applying this function using Pandas apply gives us just the edges we need:

Matplotlib has support for pie charts, but it does not allow us to easily draw multiple pie charts in the same Axes object. To achieve this, we have to build our pie charting function from scratch by leveraging matplotlib’s Patches, 2-D shapes such as a rectangles, circles, wedges, arrows, or arbitrarily complex polygons.

We will represent each slice of the pie as a Wedge.

Our draw_pie function takes a center position, a radius, a list of fractions, and a list of colors. It loops through the fractions, converting each one into a start and end angle, then creates a Wedge patch and adds it to the current Axes:

With the function in place, we need to position the pies on a map. We'll use Cartopy for the geographic projection and map features. For each state, we look up its centroid coordinates and draw a pie chart showing the relative share of traffic to its top destinations:

Before going all-in, it's always a good idea to test with a single state. Here's what the pie chart for one state (California) looks like on its own:

Now we can put it all together. We iterate over every state, compute the traffic fractions for its top destinations, and draw a pie chart at the corresponding location on the map. The radius of each pie is scaled by the total traffic volume, so busier states get larger charts:

And here's the result — a full map of the continental U.S. with pie charts showing the top 5 destinations from each state:

The visualization is already revealing. States like California and Texas have large, diverse pie charts, while smaller states show more concentrated travel patterns — often dominated by a single hub. But what happens when we increase the number of destinations? Let's bump it up to the top 10 and see how the picture changes:

With more slices in each pie, the regional patterns become even clearer. Neighboring states often share the same dominant destinations, creating natural clusters of travel corridors:

What stands out most is how geography shapes air travel. Coastal states connect to distant hubs — New York, Los Angeles, Chicago — while states in the middle of the country funnel traffic through regional powerhouses like Dallas and Denver. The pie charts make these patterns immediately visible in a way that a simple table of numbers never could.

We hope you enjoyed this Visualization post on the Data for Science Substack and look forward to hearing your thoughts. We hope you

Leave a comment

You can find all the code for the analysis in this post in our companion GitHub Repository

Visualization For Science GitHub

And, of course, don’t forget to

Share

this post with others who might be interested, and encourage them to

Subscribe now

so that they have access to the entire backlog of posts and be the first to know when a new a new article is posted.

Subscribe now

As always, you can find the companion notebook on the Graphs for Data Science GitHub repository:

Graphs For Data Science GitHub

In this post, we’re flipping our usual script, and instead of focusing on analyzing a graph, we’re going to learn from one. We’ll build a neural network to predict a molecule's solubility in water purely from the graph structure of the connections between atoms. The family of models that pulls this off goes by the name Graph Neural Networks (GNNs), and they’ve quietly become one of the most versatile tools in the modern ML toolkit.

For the sake of convenience (and a shiny new dataset), we’re using molecules as our playground. Still, the core ideas: message passing, neighborhood aggregation, and graph-level readout are applicable anywhere you encounter graph structure: social networks, road systems, knowledge graphs, protein interactions, you name it.

Why Graph Neural Networks?

If you’re a data scientist, you already have great intuitions for images and text. Images are a grid of pixels, and CNNs exploit that grid by sliding small filters across it. Text is a sequence of tokens that Transformers and RNNs can leverage.

Now look back to your high school chemistry class and think about everyones favorite molecule, Caffeine: 14 heavy atoms in a fused ring system.

There’s no natural “first pixel” or “first token” here. The atoms have no inherent order. The connectivity pattern is a graph.

You *could* try to flatten a molecule into a fixed-length vector. That’s exactly what traditional molecular fingerprints do: walk the graph, hash substructures, and pack everything into a bit vector. It works okay, but you’re throwing away structural information in the process. Atoms that are three hops apart in the molecular graph end up jumbled with their direct neighbors. The representation has no idea who’s bonded to whom.

GNNs take a different approach. They operate directly on the graph, respecting its topology. Every atom “talks” (sends messages) to its neighbors, and the network learns which conversations matter and which ones don’t.

Naturally, these same ideas are applicable well beyond molecules. Traditional Neural networks struggle with *any* graph-structured data for three fundamental reasons:

1. Variable size: different graphs have different numbers of nodes and edges. You can’t just reshape them into a nicely shaped tensor

2. No natural ordering: unlike pixels in a grid or words in a sentence, graph nodes have no inherent sequence.

3. Complex relationships: information flows along edges in patterns that don’t map neatly onto convolutions or recurrence.

GNNs were designed from the ground up to handle all three of these challenges.

Message Passing: A Game of Telephone

The main idea at the heart of every GNN couldn’t be simpler, just message passing (typically known to physicists as Believe Propagation). Think of it like a game of telephone, where you’re an atom sitting inside a molecule. You start with an initial feature vector that describes you: your element type, how many bonds you have, whether you’re part of an aromatic ring, your formal charge, and so on.

Now, at each step, you:

1. Collect the feature vectors (messages) of all your neighbors

2. Aggregate those messages by summing, averaging, etc.

3. Update your own representation by combining what you just learned with what you already knew

After one round, you know about your immediate neighborhood. After two rounds, you know about your neighbors’ neighbors. After k rounds, your representation encodes information from your entire k-hop neighborhood. It’s like each atom gradually building up a richer and richer picture of its local chemical environment.

Mathematically, this looks like:

where h_v^l is the feature vector of node v in layer l, and N(v) is the set of its neighbors. The AGGREGATE function collects information from the neighborhood, and UPDATE combines it with the node’s current state.

The GCN Flavor

The specific architecture we’ll build today is the Graph Convolutional Network (GCN), introduced by Kipf and Welling in their influential 2017 paper. The GCN makes a particularly clean choice: aggregate by taking a normalized sum of linearly transformed neighbor features.

Each neighbor’s features get multiplied by a learnable weight matrix W, then we sum up all those transformed vectors, while scaling each one by

where k is the node degree to prevent high-degree nodes from dominating the aggregation. This is essentially the graph equivalent of batch normalization: a small detail that makes training dramatically more stable.

Finally, f is any nonlinear activation function (we’ll use ReLU), which lets the model learn non-trivial relationships between features.

Alternative GNN Architectures

While we’re building a GCN today, it’s worth knowing that there are many other versions out there:

• Graph Attention Networks (GATs): Learn attention weights so the model can determine which neighbors matter most for each node. More expressive, but computationally heavier.

• GraphSAGE: Samples from a fixed number of neighbors instead of using all of them, making it possible to scale to millions or billions of nodes.

• Graph Isomorphism Network (GIN): Maximizes expressiveness within the message-passing framework, matching the power of the Weisfeiler-Leman graph isomorphism test.

• Message Passing Neural Networks (MPNN): Explicitly separates the message, aggregation, and update steps, encompassing most other architectures as special cases.

But they all correspond to different ways of choosing those AGGREGATE and UPDATE functions.

Our Dataset: Predicting How Well Molecules Dissolve

We’ll use the ESOL (Estimated SOLubility) dataset from the MoleculeNet benchmark. The ESOL contains information on 1,128 small organic molecules, each labeled with how well the molecule dissolves in water, expressed as log mol/L (its experimentally measured aqueous solubility). This is a bread-and-butter property in drug discovery as better solubility implies easier absorption into the bloodstream.

The dataset is in the public domain and easily available from PyTorch Geometric:

from torch_geometric.datasets import MoleculeNet

dataset = MoleculeNet(root=’data/’, name=’ESOL’)

Each molecule comes packaged as a PyTorch Geometric `Data` object:

• x - a node feature matrix of shape (num_atoms × 9). The 9 features per atom are:

  • atomic number

  • chirality

  • degree

  • formal charge

  • number of hydrogens

  • number of radical electrons

  • hybridization

  • aromaticity

  • and whether the atom is in a ring.

• edge_index - the adjacency list in COO format (pairs of connected atoms)

• y - the solubility target (a single float)

• smiles - a standard string representation of the molecule

Exploring the Data

For the sake of brevity, we’ll take a look at just a few details here. You can find a more in-depth EDA in the notebook.

Solubility Distribution

The solubility values span roughly 13 log units, from highly insoluble compounds (around −11.6 log mol/L) to highly soluble ones (+1.58 log mol/L), with a mean of −3.05 and a median of −2.86. The distribution has a rough bell shape with a slight left skew as there are a few *extremely* insoluble molecules pulling the tail.

Graph Properties

We can see that the graph structure of the molecule (which atoms are connected) has a strong impact on the solubility by plotting solubility as a function of various connectivity properites:

The Size-Solubility Connection

Perhaps the most intuitive pattern in the data is that bigger molecules tend to be less soluble. The correlation between atom count and solubility is about −0.59. This makes intuitive chemical sense — larger molecules tend to have bigger hydrophobic surfaces that interact poorly with water.

But notice how broad the distribution of solubility is for a specific number of atoms: Molecular size tells part of the story, but nowhere near the whole thing. That’s exactly why we need a model that can look beyond atom counts.

What’s in These Molecules?

Looking at the element distribution across all 14,991 atoms in the dataset, we see exactly what you’d expect from small organic drug-like molecules:

Carbon dominates, as it does in all organic chemistry. The presence of heteroatoms (O, N, S) and halogens (Cl, F, Br, I) is what makes solubility prediction interesting — these atoms introduce polarity, hydrogen bonding potential, and other interactions with water.

Graph Structure

The degree distribution (how many bonds each atom has) peaks sharply at 2, reflecting the prevalence of carbon chains and rings where most atoms have exactly two heavy-atom neighbors. The average degree across all molecules is about 2.06, with a maximum of 4 (think of a fully-substituted carbon).

We can also compute more sophisticated graph metrics for each molecule and examine their correlations with solubility. The strongest predictors turn out to be:

Graph density (the number of edges relative to the maximum possible) is positively correlated with solubility. In other words, size isn’t everything, and denser, more compact molecules tend to be more soluble than sprawling, chain-like ones.

If you’re new to thinking about molecules as graphs, some plots are worth a thousand words. Here is a side-by-side comparison of the same molecule as traditional 2D chemical structures (rendered with RDKit, top) alongside their graph representations (drawn with NetworkX, bottom).

The bottom row looks much friendlier, doesn’t it?

From Atoms to Molecules

A single GCN layer gives each atom information about its immediate neighbors, just one hop away. We stack three layers, one on top of the other, so that each atom’s final representation captures its 3-hop neighborhood. Naturally, the number of layers depends on the typical diameter of your graph, but 3 is more than enough for our purposes.

Now, to move from the properties of a single atom to properties of the whole molecule, we need a way to reduce a variable-length set of atom representations to a single fixed-size vector for the entire graph. This operation is called pooling (also known as graph-level readout).

The simplest and most common choice is to average all the atom feature vectors, a method known as global mean pooling, which has the advantage of not depending on atom ordering, being independent of molecule size, and it works surprisingly well in practice.

After pooling, we feed the resulting vector through a small MLP (multi-layer perceptron) to produce the final solubility prediction:

class MoleculeGNN(nn.Module):
    def __init__(self, num_features, hidden_dim=64, dropout=0.2):
        super().__init__()
        self.conv1 = GCNConv(num_features, hidden_dim)
        self.conv2 = GCNConv(hidden_dim, hidden_dim)
        self.conv3 = GCNConv(hidden_dim, hidden_dim)
        self.mlp = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim // 2),
            nn.ReLU(),
            nn.Dropout(dropout),
            nn.Linear(hidden_dim // 2, 1)
        )
        self.dropout = dropout

    def forward(self, x, edge_index, batch):
        x = F.relu(self.conv1(x, edge_index))
        x = F.dropout(x, p=self.dropout, training=self.training)
        x = F.relu(self.conv2(x, edge_index))
        x = F.dropout(x, p=self.dropout, training=self.training)
        x = F.relu(self.conv3(x, edge_index))
        x = global_mean_pool(x, batch)   # graph-level readout

        return self.mlp(x).squeeze(-1)

Here it’s worth highlighting the Dropout between GCN layers. Dropout randomly zeros out a fraction of the hidden features during training, preventing co-adaptation and improving generalization, and with just ~900 training molecules, we need all the help we can get.

The entire network has only 11,000 parameters, tiny by modern deep learning standards but convenient for demo purposes and to avoid overfitting to our relatively small dataset.

The full architecture, printed out:

MoleculeGNN(
  (conv1): GCNConv(9, 64)
  (conv2): GCNConv(64, 64)
  (conv3): GCNConv(64, 64)
  (mlp): Sequential(
    (0): Linear(in_features=64, out_features=32, bias=True)
    (1): ReLU()
    (2): Dropout(p=0.2, inplace=False)
    (3): Linear(in_features=32, out_features=1, bias=True)
  )
)

Check out the notebook for a more detailed, but perhaps less illuminating, visualization.

Training the Model

With the architecture in place, training is pretty standard PyTorch fare. We start by splitting the 1,128 molecules 80/10/10 into train (902), validation (113), and test (113) sets using a random permutation.

We train with Adam using MSE loss and early stopping with a patience of 30 epochs to prevent overfitting.

The training and validation losses decrease together nicely, with the gap between them staying relatively small: a sign that we’re not overfitting too badly.

On the held-out test set (113 molecules the model has never seen):

The R² value of 0.84 indicates that the model explains 84% of the variance in solubility. That’s genuinely useful for a model with 11K parameters trained on fewer than a thousand molecules.

The residual analysis is encouraging, too. The residual distribution is roughly symmetric and centered near zero, with no obvious systematic bias. The residuals-vs-predicted plot shows no strong patterns, suggesting the model isn’t consistently over- or under-predicting in any particular range.

These numbers, while consistent with published GCN baselines on ESOL, are definitely not state-of-the-art. To achieve better results, we would need to use more advanced architectures such as AttentiveFP or SchNet. We kept it simple to avoid obscuring what we’re trying to learn here.

What Did the GNN Learn?

One of the most satisfying things about GNNs is that the intermediate representations, the atom embeddings produced by the GCN layers, are interpretable, at least qualitatively.

After training, we extract the 64-dimensional embedding that the GCN assigns to each atom across our test molecules, then project these 1,385 embeddings down to 2D using t-Distributed Stochastic Neighbor Embedding (t-SNE).

The model has learned to produce chemically meaningful representations without being told any chemistry beyond the raw atomic features (atomic number, degree, etc.). The graph structure encoded by message passing is enough for the model to discover the chemical patterns that matter for solubility on its own. That’s the power of the message passing framework at work.

Beyond Molecules

We used molecules today because they’re a neat example, but everything we built generalizes to any other graph structure. GNNs tackle three broad categories of tasks:

• Node-level tasks: Predict something about each node. Classify users in a social network, predict functions of proteins in an interaction graph, and detect anomalous transactions in a financial network.

• Edge-level tasks: Predict whether an edge should exist (or what its properties are). Link prediction in social networks, drug-drug interaction prediction, and knowledge graph completion.

• Graph-level tasks: Predict a property of the entire graph. Classify molecules, score protein structures, and assess network robustness.

For graph-level tasks (like the one we explored today), the key ingredient is the readout operation. We used global mean pooling (averaging all node embeddings), but there are other options: sum pooling (preserves information about the graph size), max pooling (captures the most active features), or even learned hierarchical pooling that progressively coarsens the graph.

We hope you enjoyed this Graphs post on the Data for Science Substack and look forward to hearing your thoughts. We hope you

Leave a comment

You can find all the code for the analysis in this post in our companion GitHub Repository https://github.com/DataForScience/Graphs4Sci

And, of course, don’t forget to

Share

this post with others who might be interested, and encourage them to

Subscribe now

so that they have access to the entire backlog of posts and be the first to know when a new a new article is posted.

1. Building AI Agents with LLMs, RAG, and Knowledge Graphs

“Building AI Agents with LLMs, RAG, and Knowledge Graphs“ by S. Raieli and G. Iuculano is a clear-headed guide for anyone trying to turn “cool LLM demos” into an agent that can retrieve facts, use tools, and stay anchored to real information. Raieli and Iuculano keep the focus on what matters in practice. How RAG and knowledge graphs change the reliability profile of an agent, and when you need more structure than “just prompt it better.”

For data scientists and ML engineers, the best part is the build-oriented progression. It connects core concepts to concrete patterns—single-agent tool use, retrieval pipelines, and multi-agent coordination—without drowning you in theory. The examples feel like things you’d actually adapt into a prototype at work, and the overall framing consistently nudges you toward grounded, auditable behavior instead of vibes-based generation.

The tradeoff is breadth: if you already know transformers cold, some early sections may read like a warm-up, and the “production” angle is more of a practical starting line than a full MLOps reliability handbook. Still, as a one-stop map of modern agent building—especially where RAG and knowledge graphs stop being buzzwords and start being design choices—it’s an intense, usable read that tends to leave you with a short list of things you want to try next.

Buy On Amazon

2. Quick Start Guide to Large Language Models

Sinan Ozdemir’s “Quick Start Guide to Large Language Models“ lives up to its name. It moves quickly from core concepts, tokens, context windows, and prompt structure to working patterns like chat apps, RAG, summarization, and lightweight agents. The sequencing is pragmatic: read a chapter, ship a prototype.

The standout value for DS/ML folks is its treatment of embeddings and retrieval. Ozdemir shows when embeddings beat fine-tuning, how to chunk and index, and how to trade off accuracy, latency, and cost with clear, reusable checklists. His sections on prompt patterns, tool use/function-calling, and interface design treat prompting like API design, constrain inputs, structure outputs, plan for failure modes, making it easy to slot into existing services.

In short: an excellent on-ramp and onboarding text. Pair it with heavier resources for evaluation, alignment, and production-grade deployments.

Buy On Amazon

3. Generative AI For Academics

Mark Carrigan’s “Generative AI for Academics“ is a brisk, sensible map for using LLMs in scholarly life. It avoids both hype and doom, treating generative AI as a set of tools that demand judgment, not blind adoption. The tone is practical and reflective—ideal for faculty, PIs, and grad students who need shared language and guardrails.

The book shines in how it organizes academic work (Thinking, Collaborating, Communicating, Engaging), then pairs each with concrete practices (rubber-ducking, draft refinement, critical oversight). It isn’t a prompt cookbook or a windy manifesto; it’s a clear framework for responsible use, culture-setting, and policy discussions in departments and labs.

Data scientists and ML engineers will find valuable takeaways for literature synthesis, design reviews, code docs, and stakeholder comms. But if you want model internals, rigorous eval protocols, threat modeling, or MLOps patterns, the book skims the surface. Bottom line: keep it close for norms, ethics, and mentoring; pair it with technical playbooks when you need depth.

Buy On Amazon

4. AI Agents in Action

Michael Lanham’s book, “AI Agents in Action“, is a practical guide for developers who want to build autonomous AI agents using large language models (LLMs) and open-source frameworks. The book focuses on real-world engineering rather than abstract theory, offering a step-by-step approach to building agent architectures, managing multi-agent systems, and using LLMs to solve business problems. It’s written for developers and technical professionals who have the necessary foundational skills in Python and want to move from theoretical knowledge to hands-on development.

The book’s strength lies in its gradual layering of complexity, starting with basic concepts and progressing to advanced topics such as multi-agent orchestration and prompt engineering. Lanham uses open-source tools such as CrewAI, AutoGen, and Nexus and includes annotated code examples to help readers follow along. This approach effectively bridges the gap between academic theory and practical development, making it a valuable toolkit for machine learning engineers who want to build production-ready solutions for tasks such as workflow automation and customer service bots. The book also provides insightful commentary on integrating key components, such as memory and feedback loops, into agent-based systems.

However, the book has some notable limitations. A major critique is its optimistic portrayal of the tools and techniques, often overlooking critical discussions about their limitations, trade-offs, and performance at scale. It focuses on illustrative projects rather than addressing issues of robustness and reliability, which are crucial for high-stakes, enterprise-grade deployments. Another drawback is the lack of extended use cases or full-scale system integration examples, which would provide a more complete understanding of an agent system’s lifecycle, maintenance, and long-term performance in a real-world business environment.

Buy On Amazon

5. Behavioral Network Science: Language, Mind, and Society

“​Behavioral Network Science: Language, Mind, and Society​“ by T. T. Hills successfully bridges two distinct scientific domains, demonstrating how network analysis can reveal hidden patterns in human behavior. The book tackles an impressive scope of topics, from language evolution and childhood learning to cognitive aging, creativity, and social dynamics, while maintaining remarkable coherence throughout. What sets this work apart is Hills’ commitment to practical application, which equips readers with concrete tools, including an introductory guide to network science and accompanying R code that enable hands-on analysis.

This practical approach makes the book uniquely valuable to a diverse audience. Behavioral scientists unfamiliar with network methods will find an accessible entry point, while data scientists can discover rich applications in behavioral research. Hills demonstrates particular skill in addressing contemporary social issues through a network lens, offering fresh perspectives on polarization, echo chambers, and conspiracy theories. The interdisciplinary framework proves especially powerful when examining how individual cognitive processes scale up to shape collective behavior and social structures.

The book’s most significant achievement lies in its clarity without oversimplification. Hills effectively conveys complex concepts with precision while maintaining an engaging and accessible tone. This balance makes “Behavioral Network Science” essential reading for anyone seeking to understand how network structures influence human behavior across scales—from individual minds to entire societies.

Buy On Amazon

6. Prompt Engineering for LLMs

“Prompt Engineering for LLMs“ by J. Berryman and A. Ziegler is an essential resource for anyone working with large language models. The authors expertly position prompt engineering not merely as writing effective prompts but as a crucial component throughout the entire application development lifecycle. By balancing technical depth with practical accessibility, they create a guide that serves both newcomers and experienced practitioners in the rapidly evolving AI landscape.

​

The book’s greatest strength lies in its practical techniques, which go beyond basic prompt crafting. Readers will discover innovative approaches, such as using log probabilities to quantitatively assess completion quality, generating multiple outputs at varying temperatures, and structuring prompts with multiple roles to enhance focus and relevance. Particularly valuable is the “Little Red Riding Hood Principle,” which emphasizes aligning prompts with a model’s training patterns to achieve optimal responses.

​

Beyond techniques, Berryman and Ziegler offer crucial insights into real-world application strategies, including how teams like GitHub Copilot incorporate user feedback for continuous improvement. The authors skillfully explain complex concepts like tokenization and auto-regressive generation while maintaining accessibility for developers who might otherwise struggle with the non-human communication style of LLMs. This balanced approach makes the book an indispensable guide for anyone aiming to build robust, efficient LLM-powered applications in today’s AI-driven technological environment.

Buy On Amazon

7. The Complete Developer

“The Complete Developer” by M. Krause is a comprehensive guide that takes readers through the intricacies of modern full-stack web and API development. With over two decades of experience building websites and leading development teams, Krause offers an indispensable resource for developers at any career stage. The book covers various technologies, including TypeScript, React, Next.js, MongoDB, and Docker, providing a 360-degree view of web development.

One of the standout features of this book is its beginner-friendly approach, breaking down complex concepts into easy-to-follow steps. Krause meticulously covers every aspect of modern web application development, from building a React-driven frontend to constructing a robust backend using Mongoose and MongoDB, and integrating both REST and GraphQL APIs. The book is structured in two halves: one for demonstrating parts of the stack like React, Next.js, and Docker, and another for writing the final application and connecting the stack parts cohesively.

While some readers have found the material challenging for absolute beginners, many developers, including those with experience in other areas, have praised the book for its comprehensive coverage and practical approach. The inclusion of modern development practices and tools, such as Docker, Express.js, and OAuth for authentication, prepares readers for real-world development scenarios. Despite the rapidly evolving nature of web technologies. “The Complete Developer” provides a solid foundation for mastering the modern full stack, making it a valuable resource for those looking to enhance their development skills with the latest JavaScript-based technologies.

Buy On Amazon

8. The Nvidia Way

“The Nvidia way“ by T. Kim offers a wealth of profound lessons for entrepreneurs and managers, extending far beyond a mere chronicle of technological achievements. It explores Nvidia’s strategic approach to innovation, providing valuable insights into how the company consistently stayed ahead of industry trends. The narrative highlights Nvidia’s founder, Jensen Huang’s, obsession with solving the Innovator’s Dilemma, demonstrating how this focus drove Nvidia to reinvent its corporate strategy and maintain its competitive edge.

One of the key takeaways is Nvidia’s unique organizational structure. The book emphasizes the benefits of the company’s flat hierarchy, which empowers employees at all levels to contribute to the company’s direction. This approach fosters a culture of innovation and agility, allowing Nvidia to adapt quickly to market changes and technological shifts. Entrepreneurs and managers can learn from this model to create more dynamic and responsive organizations.

Nvidia’s long-term strategic thinking is highlighted, particularly when it comes to recognizing and capitalizing on emerging technologies. The company’s early bet on AI, long before it became mainstream, serves as a powerful example of visionary leadership and calculated risk-taking. This aspect of the book offers valuable lessons on the importance of anticipating future trends and having the courage to invest in unproven technologies. For entrepreneurs and managers, it underscores the significance of looking beyond short-term gains and fostering a culture that embraces calculated risks for long-term success.

Buy On Amazon

9. The Atomic Human: What Makes Us Unique in the Age of AI

“The Atomic Human: What Makes Us Unique in the Age of AI“ by N. D. Lawrence presents a compelling exploration of what defines humanity in the context of advancing artificial intelligence. The central thesis is that our vulnerabilities and imperfections, rather than our technological capabilities, truly characterize us as human beings. The book argues that while AI can replicate certain aspects of human thought and behavior, it fundamentally lacks the emotional depth, moral judgment, and ability to navigate complex, ambiguous situations that define human experience.

Lawrence emphasizes the importance of our flaws and social connections in fostering growth and creativity. He posits that these qualities allow us to form cultures and communities that go beyond mere survival, highlighting the unique aspects of human decision-making through historical examples. This perspective challenges the prevailing narrative that positions AI as a competitor to human intelligence, instead suggesting that AI should be viewed as a tool that complements, rather than replaces, our intrinsic human qualities.

This book offers an engaging examination of what it means to be human in an era increasingly defined by technological advancements, prompting readers to reflect on the essence of humanity amid the rise of intelligent machines.

Buy On Amazon

10. Life as No One Knows It: the Physics of Life’s Emergence

“Life as No One Knows It: The Physics of Life’s Emergence“ by S. I. Walker. In this book, Walker offers a groundbreaking reimagining of life’s nature, challenging traditional definitions and exploring the origins of living systems from a fresh perspective. At the heart of the book lies Assembly Theory, which proposes that all matter can be viewed as information, with life representing a highly complex assembly of causal information. This paradigm-shifting framework not only redefines life universally but also paves the way for identifying non-terrestrial life forms.

In an interdisciplinary approach that blends insights from Physics and Philosophy, the book explores key distinctions between knowledge, information, and consciousness. It encourages readers to move beyond anthropocentric perspectives, prompting us to consider the existence of life forms vastly different from anything encountered on Earth.

Buy On Amazon

What books kept you company throughout 2025? And which ones are you looking forward to in 2026? Leave the most interesting ones in the comment section below. And my fondest wishes for a 2026 full of great books.

Also, don’t forget to check out our reading list from previous years:

• Top 10 Books we read in 2024

• Top 10 Books we read in 2023

• Top 10 Books we read in 2022

• Top 10 Books we read in 2021

• Top 10 Books we read in 2020

If you would like a quick refresher before we get started, check out our previous posts in this series (especially the…

Read more

We hope your enjoy this post and don’t forget to

Subscribe now

so you never miss a post and

Share

to help us grow!

The US Census Bureau provides detailed shapefiles for various regions in the US. We download the shapefile for the 50 …

Read more

1. Natural Language Processing with Transformers

Read more

Features

• Homogeneously mixed Model: Easily define compartmental models by just specifying the transitions and rates

• Seasonality: Allow parameters to evolve in time

• Age Structure: Convert any compartmental model to an age-structured model b…

Read more

Welcome to the 10th post of the Epidemic Modeling series. In this post, we go beyond single populations and start modeling the spread of a disease through multiple coupled populations. Our fundamental assumptions are that the disease structure is the same everywhere and that individuals can travel between any two populations with a given fixed probabili…

Read more

Subscribe now

Real-world networks are typically large and hard to visualize, leading to the development of sophisticated methods and algorithms, such as …

Read more

This is a conversation space in the Substack app that I set up exclusively for my subscribers — kind of like a group chat or live hangout. I’ll post short prompts, thoughts, and updates that come my way, and you can jump into the discussion.

Read more

Welcome to the latest post on our long-running epidemic modeling series. In this post, we’ll cover how to introduce age structure into our compartmental models and its impact on how an epidemic spreads.

If you need a quick refresher, check out our previous posts in this series (especially the first 2):

1. Epidemic Modeling 101: Or why your CoVID19 exponentia…

Read more

2023 was a year full of great books, some just published and others that have been around for a while and that have just gotten to my hands. Below, you’ll find some of the ones I found the most impactful for my work and personal interests.

1. Computing the Climate 

A captivating journey into the synergy of climate science and computing, making it a must-read for anyone intrigued by the intersection of these fields. Easterbrook’s engaging writing style effortlessly demystifies complex concepts, ensuring accessibility for readers with diverse backgrounds. The book’s strength lies in its seamless blend of theoretical discussions with real-world examples, showcasing the instrumental role of computing in unraveling the intricacies of climate dynamics.

Easterbrook’s balanced perspective sets this book apart, acknowledging the uncertainties in climate science while underscoring the transformative impact of technological advancements. By delving into interdisciplinary connections with policy, economics, and environmental science, Easterbrook provides a holistic understanding of the challenges associated with climate change. This comprehensive approach educates and empowers readers to recognize the pivotal role of computational progress in shaping our collective response to climate-related issues.

In essence, “Computing the Climate” stands as a persuasive testament to the indispensable role of computing in climate research. Easterbrook’s skillful narrative not only informs but also inspires readers to grasp the significance of technological innovation in confronting the pressing challenges of our changing climate. This book is an essential addition to the literature, urging readers to actively engage in the ongoing dialogue surrounding the future of our planet.

Buy On Amazon

2. SQL for Data Analysis 

A must-have resource for anyone serious about data analysis and SQL. It equips you with the tools and knowledge to confidently tackle complex data analysis tasks. With its clear explanations, real-world examples, and comprehensive coverage of advanced topics, this book will undoubtedly become an invaluable asset in your data analysis journey. Whether you’re a data analyst, data scientist, or SQL enthusiast, this book will help you take your skills to the next level and transform data into actionable insights.

Buy On Amazon

3. Network Science with Python 

A highly recommended book for anyone interested in network analysis. It provides a comprehensive and accessible introduction to the topic. The book’s linear progression and friendly tone make it highly engaging and easy to follow. The author’s contagious enthusiasm and practical examples effectively communicate the power and importance of network analysis. The book covers various domains, including language and social media data mining, and explores the relationship between NLP and networks, an approach similar to our very own Graphs for Data Science substack. It emphasizes the value of actionable insights in the conversational AI domain and provides historical context and real-world use cases for NLP solutions. The book also introduces the Python packages used and dives into network science using the NetworkX library. It demonstrates how graphs can be used in machine learning and covers important concepts like betweenness centrality, page rank, and community detection with real-world applications. Overall, “Network Science with Python” is a well-written and comprehensive guide that offers practical insights and is suitable for readers of all levels.

Buy On Amazon

4. What is ChatGPT Doing… and Why Does It Work? 

This book offers a compelling exploration of ChatGPT’s success and the broader implications of artificial intelligence while delving into the inner workings of ChatGPT and its historical context.

The book stands out for its accessibility, making complex concepts understandable to non-computer scientists and non-mathematicians alike. Wolfram provides a high-level overview of ChatGPT’s components, such as embeddings and transformers, without getting bogged down in technical details.

While acknowledging ChatGPT’s successes, Wolfram candidly addresses its limitations, especially in real-world computational tasks. He critically examines ChatGPT’s reliance on neural network weightings and raises intriguing questions about intelligence, drawing parallels with biological evolution.

In conclusion, “What Is ChatGPT doing … and Why Does It Work?” is a thought-provoking read that demystifies AI for a wide audience. Wolfram’s expertise and candid exploration make it a must-read for those interested in AI’s frontiers and the complexities of intelligence.

Buy On Amazon

5. Causal Factor Investing 

 Causal Factor Investing introduces a unique approach by emphasizing causality, a factor often overlooked in traditional quantitative models. The book provides a refreshing perspective on financial markets, challenging conventional wisdom and offering a comprehensive guide to understanding and implementing causal factor investing.

What sets this book apart is its practicality. López de Prado delves into the theoretical underpinnings of causal factor investing and provides real-world examples and case studies. This hands-on approach ensures that readers can grasp and apply the concepts to their investment strategies. The author’s writing style is engaging and approachable, balancing academic rigor and practical applicability.

In a landscape where financial strategies constantly evolve, “Causal Factor Investing” stands out as a timely and relevant resource. López de Prado’s expertise shines through, making this book essential for both seasoned professionals and those new to quantitative finance. It’s a must-read for anyone serious about staying ahead in the dynamic world of investment, offering a thought-provoking and informative guide that will shape the future of quantitative finance.

Buy On Amazon

6. Data Science in Context 

Provides a comprehensive overview of Data Science, covering the technical aspects of the field and the ethical considerations and challenges it presents. It is structured to make it easy for readers to understand and absorb the information and offers recommendations for addressing ethical concerns. The authors focus on real-life examples from their various fields, such as healthcare and finance, to illustrate data science applications and their potential impact. Aimed at a wide audience, it includes data science novices and experienced professionals and is recommended for anyone with an interest in data science and its role in daily life and various industries.

Buy On Amazon

7. AI and Machine Learning for Coders 

 AI and Machine Learning for Coders  exceeds expectations with excellent explanations on how to code machine learning using TensorFlow and different ML techniques. The book covers various topics, including computer vision, natural language processing, and time series forecasting, and even includes a section on text generation.

The book is aimed specifically at coders with Python experience and explains how neural networks work at a high level without overwhelming readers with too much math. The author does an excellent job of explaining convolution, maxpooling, interpretability, bias/fairness, and Google’s AI principles.

Overall, anyone who wants to learn about deep learning using TensorFlow will find here an excellent resource that provides a solid foundation in deep learning and is suitable for hands-on practitioners without overwhelming them with math.

Buy On Amazon

8. Automate the Boring Stuff with Python 

 This is an exceptional book that is perfect for anyone who wants to learn how to use Python to automate mundane tasks. The author has done an excellent job of explaining complex concepts in a simple and easy-to-understand manner.

The book is well-organized and starts with the basics of Python programming and gradually progresses to more advanced topics such as web scraping, working with Excel spreadsheets, and sending automated emails. The real-life examples and practical exercises included in each chapter make it easy for readers to apply what they have learned and see the results.

One of the most remarkable aspects of this book is that it doesn’t require any prior programming experience, making it perfect for beginners. However, it is also an excellent resource for experienced programmers who want to learn how to automate repetitive tasks.

Overall, this is a must-read for anyone who wants to learn how to use Python for automating everyday tasks. The book is well-written, easy to follow, and the author’s sense of humor makes it an enjoyable read. I highly recommend this book to anyone who wants to learn Python programming and automate their boring tasks.

Buy On Amazon

9. Introduction to Algorithms 

Affectionately known as the bible of algorithms and over the years has proven to be an essential reading and, at over 1300 pages, a complete reference for anyone interested in gaining a broad understanding of algorithms. The content can at times be challenging but is presented in a fashion that is engaging and easily digestible. Exercises at the end of each chapter are expressly presented without the benefit of solutions but were carefully designed to help students to think algorithmically and thoroughly absorb the material presented.

Buy On Amazon

10. Advanced Algorithms and Data Structures 

 This book is a great resource for engineers who want to enhance their knowledge of algorithms and data structures without having to go back to traditional, academic-style textbooks. The author has a deep understanding of how to deliver high-quality code and each algorithm is thoroughly illustrated with pseudo-code and diagrams. The book is especially helpful for tackling contemporary problems such as multidimensional search, understanding caches better, classification, and graph theory.

The writing is friendly and approachable, making it relatively easy to understand, although some familiarity with math may be helpful. It is a book that can be read, skipped around, and returned to occasionally when needed. Overall, this book is strongly recommended for engineers looking to enhance their algorithm and data structure knowledge.

Buy On Amazon

What books kept you company throughout 2023? And which ones are you looking forward to in 2024? Leave the most interesting ones in the comment section below. And my fondest wishes for a 2024 full of great books.

Also, don’t forget to check out our reading list from previous years:

• Top 10 Books we read in 2022

• Top 10 Books we read in 2021

• Top 10 Books we read in 2020

We hope your …

Read more

In this post, we w…

Read more

1. The Order of Time 

Carlo Rovelli explores the concept of time and how it has been understood by scientists and philosophers throughout history. It discusses advances in our understanding of time, such as Einstein’s theory of relativity, which proposed that time is affected by mass and speed. The book also explores the idea of a universe without time and discusses theories and models that have been developed to explain the universe in this way, such as Loop Quantum theory, the theory that Rovelli works on. The book is intellectually stimulating and interesting although it sometimes struggles to find the right balance between being accessible to a general audience and being a serious work of science.

Buy On Amazon

2. Code: The Hidden Language of Computer Hardware and Software  

This book provides a step-by-step timeline of how computers came to be, clearly and concisely. It takes you on a tour of what happens “behind” the pixels on your screen, from logical gates on up, without requiring a heavy technical background. Chapter, by chapter, introduces each concept and technology necessary to make modern computers work. By the end of it, you’ll have a detailed and intuitive understanding of how Computers really work and will be able to mode easily optimize how you write your own software. It might also make you want to learn to program in Assembly! A book that should be required reading for anyone interested in Computer Science.

Buy On Amazon

3. Interactive Dashboards and Data Apps with Plotly and Dash 

In our lives as data scientists and machine learning engineers, we are often called upon to develop Dashboards and other Data Drive apps to communicate results or to monitor the performance of models deployed to production. Plotly and Dash are the current State of the Art libraries for interactive visualizations with a web frontend. This book does a remarkable job of getting you up to speed with both of these libraries taking you from basic to advanced level through practical building blocks that you can immediately customize for your own use.

Buy On Amazon

4. DeFi and the Future of Finance 

Decentralized Finance (DeFi) is a new industry that aims to increase financial freedom in the world. The book explains the problems that DeFi solves for the current financial system, such as inefficiency, limited access, opacity, centralized control, and lack of interoperability. It then goes on to describe the solutions that DeFi offers, using examples and diagrams to illustrate the concepts. Finally, the book discusses the risks that DeFi faces, such as smart contract, governance, scaling, and regulatory risks. A highly recommended read for anyone interested in this burgeoning field and with some previous familiarity with financial concepts.

Buy On Amazon

5. Bayes’ Rule: A Tutorial Introduction to Bayesian Analysis 

Despite its simplicity, Bayes Rule is one of the most powerful theorems in probability theory. This relatively short book (170 pages) provides an excellent overview and hands-on introduction to Bayesian analysis. While the main text provides a strong foundation for the main ideas and concepts, the companion Python code gives you a leg up in introducing these techniques into your daily work. Overall, an excellent first introduction to the topic and a good refresher reference if you haven’t touched this area in some time.

Buy On Amazon

6. Causality 

Causal Inference is a lively and fast-developing area in Data Science that we believe has the potential to be truly revolutionary in coming years (you can get a quick overview of the main ideas in our Causal Inference series over at Medium). Judea Pearl is one of the most prominent founding fathers of this field that he introduces masterfully in this textbook. While the approach Pearl chooses is mathematically rigorous, thanks to his rich use of toy examples, the key ideas and concepts are easily grasped and adapted to real-world datasets. Causal Inference is a powerful arrow in any Data Scientist’s quiver and this is the ideal starting point if you’re interested in taking the first steps in this exciting area.

Buy On Amazon

7. The Practitioner’s Guide to Graph Data 

Graph Thinking and Graph Data are topics near and dear to our hearts here at D4Sci (checkout G4Sci if you haven’t yet) and this book does an excellent job of introducing both fundamental and advanced topics and techniques using practical real-world datasets and state of the art graph databases. The book is exceptionally well written and easy to follow, with practical “rules of thumb” generously sprinkled throughout along with practical examples that you can use to grok as the various concepts are they are introduced. A must-have for anyone interested in Graph Thinking and Graph Databases.

Buy On Amazon

8. Essential Math for Data Science 

Good mathematical foundations are paramount to being successful as a Data Scientist. In his recent book, T. Nield introduces the reader to enough of the mathematics underlying Data Science and Machine Learning to give you a head start in grokking both classic and state-of-the-art algorithms that you're likely to encounter in your career as a Data Scientist. This is a highly recommended read to anyone who wants to look inside the black boxes we use every day.

Buy On Amazon

9. The Unicorn Project 

This is a novel that focuses on the transformation required for companies to achieve sustained velocity and quality in their operations. The book explores the roles of development and business teams in this process and highlights the importance of communication and data-driven decision-making. The story is entertaining and a good illustration of industry standards in the field of IT despite (or perhaps because of) the occasional over-emphasis on long hours and burnout.

Buy On Amazon

10. Scientific Computing with Python 

 Fills an important gap in most Data Scientist's bookshelves. High-performance computing, especially scientific and numeric computing, is a fairly technical branch of computer science that most programmers aren’t familiar with. It requires a deep understanding of the finer points of the data structures being used and of their specific implementations. With this book, the authors have managed to demystify a highly complex subject with clear explanations and analysis that will appeal to developers of all levels. Naturally, some of the subjects could gain from being further developed, but in every project of this kind, a balance must be struck between breadth and depth. Overall, a useful book that I’ll refer to often.

Buy On Amazon

What books kept you company throughout 2022? And which ones are you looking forward to in 2023?

Also, don’t forget to check out our reading list from previous years

• Top 10 Books we read in 2021

• Top 10 Books we read in 2020

Thanks to node correlations, we can (preferentially) reach network hubs by selecting a node a random and then reaching out to one of their neighbors. We demonstrate the effectiv…

Read more

Subscribe now

Share

Topological Sorting

Topological Sorting is a …

Read more

We hope your enjoy this post and don’t forget to

Subscribe now

so you never miss a post and

Share

to help us grow! We’re looking forward to hearing your thoughts, so go ahead…

Read more

MSTs have a wide range of practical applications, specially in distribution networks where we must reach every node in…

Read more