DEV Community: Hussein Mahdi

New code is upload of new model 🚀🥇

Hussein Mahdi — Thu, 17 Sep 2026 23:12:34 +0000

Hussein Mahdi

Sep 13

Predicting Drug-Drug Interactions with Hypergraphs — on Two CPU Cores

#ai #productivity #architecture #machinelearning

5 min read

Predicting Drug-Drug Interactions with Hypergraphs — on Two CPU Cores

Hussein Mahdi — Sun, 13 Sep 2026 06:04:00 +0000

When a patient takes several medications at once, two of them can interact in ways that cause real harm. DrugBank catalogues 86 distinct mechanisms for how this happens — one drug slowing another's metabolism, increasing its toxicity, blunting its effect, and so on. Screening every pair by hand does not scale.

Most machine learning approaches to this problem split it in two: one model decides whether two drugs interact, a completely separate one decides how. That split is convenient for benchmarking and awkward for anything practical.

We built H²GNN to do both in one hierarchy, using nothing but SMILES strings as input. The code is now public, and the whole thing runs on two CPU cores.

Code: github.com/Hu8MA/HHGNN
Paper: ECAI 2026, IEEE Xplore

Why hypergraphs

In an ordinary graph, an edge joins exactly two nodes. That is a poor fit for a lot of chemistry. A molecular substructure is not a relationship between two drugs — it is something that dozens of drugs share simultaneously. An interaction mechanism is not a property of one pair; it is a category that hundreds of pairs fall into.

A hyperedge can connect any number of nodes at once, which lines up with both of those facts. H²GNN uses two hypergraphs stacked on top of each other.

Stage 1: the chemical hypergraph

Take a SMILES string and slide a window of size k across it. Each window is a substring — a rough proxy for a local chemical arrangement. Every distinct substring becomes a node, and every drug becomes a hyperedge connecting the substrings it contains.

At k = 9, that gives 29,462 substructure nodes, 1,709 drug hyperedges, and 96,656 connections between them.

A single hypergraph attention layer runs over this structure. Attention flows at the hyperedge level, then the node level, and the result is a 128-dimensional embedding per drug learned end to end from raw SMILES. An MLP decoder takes the embeddings of two drugs and predicts whether they interact.

Result: 98.46% ROC-AUC, 93.20% accuracy.

For comparison, a Random Forest on 4,096-dimensional Morgan fingerprints gets 88% ROC-AUC. A two-layer GCN gets 95%.

Stage 2: the interaction-type hypergraph

Here is the part I find most interesting, and it is a small conceptual shift with a large effect.

The obvious way to classify interaction mechanisms is to attach a label to each drug pair and train a classifier. We did something else: each of the 86 interaction types becomes a hyperedge, connecting every drug that participates in that type. Drugs are the nodes. The type stops being a label on the data and becomes an object in the graph with its own learned representation.

This hypergraph is tiny — 1,709 drug nodes, 86 type hyperedges, 13,486 connections. Hyperedge sizes range wildly: type 42 touches 5 drugs, type 49 touches 1,308.

Drug nodes are initialized with the embeddings transferred from Stage 1, not randomly. Attention then flows hyperedge → node → hyperedge, so the type hyperedges — which are the prediction target — end up holding the final aggregated representation.

Result: 85.73% Top-1 and 98.11% Top-3 accuracy across 86 classes.

That twelve-point gap between Top-1 and Top-3 is itself useful. The correct mechanism is almost always among the top three even when it is not ranked first, which is exactly what you want if a clinician is reading the output rather than a downstream script.

The ablations that mattered

Two experiments did more to convince me the design was right than any headline number.

Attention direction. Stage 2's drug nodes start out well-informed, carrying transferred chemical knowledge, while the type hyperedges start from one-hot vectors. So it seemed plausible that flowing attention from the informed side — node → hyperedge → node — would work better.

It does not. It falls apart:

Configuration	Top-1 Acc.	PR-AUC	Macro F1
hyperedge → node → hyperedge	85.73%	87.24	81
node → hyperedge → node	67.42%	63.54	48

Aligning the attention flow with the prediction target beats starting from the richer initialization, and the rare classes are the first thing you lose. The type hyperedge has to be where aggregation ends.

Embedding transfer. Replace the transferred Stage 1 embeddings with an all-ones vector and hold everything else fixed:

Initialization	Top-1 Acc.	PR-AUC	Weighted F1
Stage 1 embeddings	85.73%	87.24	86
All-ones vector	82.52%	85.70	82

A 3.21-point drop. The hierarchy earns its keep.

There is also a third result I did not expect. During cleaning, 406 drug pairs turned out to carry more than one interaction type; we kept the first and set the others aside. The model never saw those secondary labels for those pairs. It surfaced 94.7% of them within its Top-3 predictions anyway — meaning the hypergraph learned something about multi-mechanistic pharmacology rather than memorizing one label per pair.

The efficiency story

This is the part that surprised me most, and it is worth spelling out for anyone who assumes graph learning implies a GPU budget.

Everything above was trained and evaluated on Google Colab's free tier: two vCPUs, no GPU. We chose it deliberately, for two reasons. It gives every run an identical environment, and its resource ceiling is close to the hardware actually available in a hospital pharmacy.

Model	Training time	Hardware
Interaction-Type HGNN (ours, 1 layer)	18.6 min	CPU, 2 cores
GCN (2 layers)	75.6 min	GPU (T4)
GraphSAGE (2 layers)	148.5 min	GPU (T4)
XGBoost	225.6 min	CPU

Four to twelve times faster — and it still beat GraphSAGE, the strongest baseline, by 4.8 points of Top-1 accuracy and 22 points of macro F1.

The baselines had advantages we did not give ourselves: precomputed Morgan fingerprints as input features, and inverse-frequency class weighting during training to stay stable under the severe class imbalance. Single-layer variants of the GCN and GraphSAGE did not converge at all; both had to be deepened and moved to GPU for the comparison to run. A Graph Attention Network never converged and was dropped.

Peak RAM increase during training: 0.29 GB.

What is in the repo

The dataset is DrugBank — 1,709 drugs, 191,877 unique interaction pairs, 86 types, built by merging two benchmark sources so that every drug has a SMILES string.

Everything needed to reproduce the numbers is there:

Colab notebooks for all 48 experiments, with inline outputs
Pre-computed k-mer files for k = 3, 6, 9, 12
Hypergraph structure files and index maps
The exact seeded train/validation/test partitions, verified for zero leakage
Baseline notebooks (GCN, GAT, GraphSAGE, XGBoost, Random Forest)

Open a notebook, point it at the data files, run all cells. Free tier is enough.

What it does not do

Being honest about the boundaries, since these are the interesting problems:

SMILES only. No protein-target, pathway, or side-effect information. Chemical structure carries the entire representation. Additional modalities could enter as further hyperedge families.
No severity prediction. The model reports the mechanism and its likelihood, not how bad the reaction will be — which is often the thing that actually drives a clinical decision.
1,709 drugs. DrugBank now holds over 4,000, so plenty of approved drugs cannot yet be screened.
Pairs only. Real polypharmacy is not pairwise. The hypergraph formulation could express simultaneous multi-drug combinations directly; we just have not done it.

That last one bothers me the most, because the machinery is already there. A hyperedge over three co-administered drugs is a perfectly natural object in this framework.

If any of these interest you, contributions are welcome — there is a contributing guide in the repo, and the issue tracker is open.

Code: github.com/Hu8MA/HHGNN
Paper: Hierarchical Hypergraph Neural Networks for Multi-Type Drug–Drug Interaction Prediction, ECAI 2026, IEEE Xplore

Thanks to the DrugBank Foundation for access to the curated drug data that made the dataset complete.

Who wants to know what the library is in the context of artificial intelligence development?

Hussein Mahdi — Sun, 12 Jul 2026 22:14:04 +0000

Hussein Mahdi

Feb 9

NumPy vs List: SIMD Vector Processing with Concrete Mathematical Example

#webdev #ai #programming #tutorial

4 min read

For anyone interested in learning about the history, concepts, and philosophy of graph neural networks, please refer to this article.

Hussein Mahdi — Thu, 09 Jul 2026 21:32:09 +0000

Hussein Mahdi

Feb 4 '25

Revisiting the 2009 GNN Paper: Foundations (Part 1)

#ai #machinelearning #tutorial #programming

9 min read

The first article in the Panda Library Mastery series

Hussein Mahdi — Tue, 07 Jul 2026 22:08:27 +0000

Hussein Mahdi

Feb 26

Mastering Pandas — Part 1: Reading, Sorting & Displaying Data

#ai #tutorial #python #programming

8 min read

The Leash That Makes AI Polite

Hussein Mahdi — Tue, 09 Jun 2026 07:05:00 +0000

How a 1951 statistics formula quietly keeps your chatbot from going feral

Two ideas sit underneath every modern AI assistant you've ever used. One is a 70-year-old equation. The other is the training trick that turned a text-prediction engine into something you'd actually want to talk to. They're connected — and the connection is more interesting than either alone.

First: measuring surprise

Start with Kullback–Leibler divergence. The name is intimidating; the idea isn't. It measures how different two sets of expectations are.

Picture a weather forecaster. Reality is: 70% sunny, 30% rain. But you wake up convinced it's a coin flip — 50/50 — and dress accordingly. KL divergence is the price you pay, on average, for believing the wrong thing. Get caught in the rain, get overdressed in the sun — small mismatches, small cost. If instead you believed it was always sunny and walked into a downpour, the cost is enormous.

That's the whole concept. Two numbers: how things actually are, and what you assumed. KL puts a single value on the gap.

Three things to remember about it. It's zero only when your belief is perfect. It can climb toward infinity when you're badly wrong. And it's lopsided — being too optimistic and being too pessimistic don't cost the same. It isn't a tidy ruler; it's a penalty for surprise.

Then: teaching taste

Now the second idea. A raw language model is a spectacularly good guesser of the next word, trained on a firehose of internet text. It is not helpful, honest, or polite. It will cheerfully complete a sentence in whatever direction the statistics pull it.

RLHF — Reinforcement Learning from Human Feedback — fixes that. Show humans two answers to the same question, ask which is better, collect thousands of these judgments, and train a second model to predict human taste. Then nudge the language model to chase higher scores from that taste-model. That's how it learns to be useful instead of merely plausible.

Where they meet

Here's the catch. Let a model chase a reward with no restraint, and it cheats. It discovers that flattery scores well, that vague hedging is rarely wrong, that "Great question!" pleases the crowd. Left alone, it drifts into a sycophantic mush — gaming the score while forgetting how to talk.

So engineers attach a leash. At every step they ask: how far has the model drifted from its original self? That distance is measured with KL divergence. Drift a little, fine. Drift too far, and the penalty pulls it back.

The polished, agreeable voice of your favorite chatbot is the product of exactly this tension: a reward pulling it toward what people like, and a 1951 formula tugging the other way, whispering don't go feral.

Which is more important to a data scientist: NumPy or List 🎇? But should they also consider performance 🤔? This article explains. Read it; it will be helpful.

Hussein Mahdi — Sun, 31 May 2026 22:45:56 +0000

Hussein Mahdi

Feb 9

NumPy vs List: SIMD Vector Processing with Concrete Mathematical Example

#webdev #ai #programming #tutorial

4 min read

[Boost]

Hussein Mahdi — Sun, 31 May 2026 12:26:01 +0000

Hussein Mahdi

May 24

The Math Behind Neural Networks — Explained Like Nobody Did for Me 🧨

#ai #machinelearning #datascience #deeplearning

1 min read

What will you think of when you read about a neural network!!? Mathematics? 🤔

Hussein Mahdi — Tue, 26 May 2026 23:18:26 +0000

Hussein Mahdi

May 24

The Math Behind Neural Networks — Explained Like Nobody Did for Me 🧨

#ai #machinelearning #datascience #deeplearning

1 min read

The Math Behind Neural Networks — Explained Like Nobody Did for Me 🧨

Hussein Mahdi — Sun, 24 May 2026 23:09:41 +0000

How does a neural network actually learn to be less wrong?

Not the hand-wavy version. The real one. The one with the derivative, the chain rule, and the loss surface that nobody draws for you when you start.

I got tired of tutorials that skip steps, so I wrote the series I wish I had when I began. No formula without explanation. No "as you can see." No magic.

It is now live on GoPenAI — and I am sharing it here on dev.to for the first time.

Part 1 — Where the math actually begins
Slope → linear regression → error (MSE). One continuous idea, built from the ground up. We stop right at the moment the real question appears: now that we can measure how wrong the model is, how does it learn to be less wrong?
👉 https://blog.gopenai.com/the-math-behind-neural-networks-explained-like-nobody-did-for-me-cda519ef63e8

Part 2 — How the network actually learns

The derivative — slope, but instantaneous
Gradient descent — walking down the loss surface
Multiple layers — how a single neuron becomes a network
Backpropagation — the chain rule, finally demystified 👉 https://blog.gopenai.com/the-math-behind-neural-networks-explained-like-nobody-did-for-me-7db69dc6f1bd

What is the one concept in neural network math that confused you the most when you started? Drop it in the comments — it might become a future chapter.

Building QuizTest — A WPF Quiz Application for Educational Institutions

Hussein Mahdi — Thu, 23 Apr 2026 08:13:00 +0000

Building QuizTest — A WPF Quiz Application for Educational Institutions

I'm excited to share QuizTest, a WPF desktop quiz application I built in C# and which is now actively used at Al-Mustaqbal University. What started as a small tool for a sports-college competition has grown into a flexible platform used by the College of Science's AI Department.

🔗 GitHub: github.com/Hu8MA/QuizeTest

The Problem I Wanted to Solve

Most quiz applications I came across fell into one of two categories: either they were heavy web-based platforms that required internet access and accounts, or they were rigid desktop tools where editing questions meant touching the source code. For classroom use and university events in Iraq, I needed something simpler. Instructors should be able to change questions on the fly without asking a developer, and the app should run offline on any Windows machine.

That's how QuizTest was born.

Tech Stack

The application is built on a deliberately minimal stack. It uses C# with WPF on .NET 6.0 for the desktop UI, and relies on ClosedXML for reading the Excel-based question bank. That's essentially it. No database, no server, no cloud dependency.

From v1.0 to v2.0 — A Lesson in Simplification

Version 1.0 was used in an inter-university competition hosted by the College of Sports at Al-Mustaqbal University, involving multiple Iraqi universities. It worked well, but it relied on Entity Framework and SQLite to store questions. Every time a professor wanted to update the question bank, someone had to edit the database or rebuild the project. It felt heavier than it needed to be.

Version 2.0 rethought the architecture. I removed the database entirely and replaced it with two simple files: Questions.xlsx for the question bank and Settings.txt for configuration. Any instructor can now open the Excel file, edit questions, save, and relaunch the app. No developer required. This version is currently in use by the Department of Artificial Intelligence.

How the Question Bank Works

Questions live in a plain spreadsheet with three columns: Id, Text, and Answer. For example:

Id	Text	Answer
1	Machine learning requires labeled data.	FALSE
2	Python is an interpreted language.	TRUE

The application loads the workbook at startup through QuestionLoader.cs, which uses ClosedXML to parse the rows into a list of question objects. From there, a random subset is selected based on the configured question count, so every quiz session feels fresh even with the same bank.

Version 1.0 was used for the sports department events at Al-Mustaqbal University, while version 2.0 was used for the artificial intelligence department competition events at the same university in 2026.

Configurable Settings Without Recompiling

The Settings.txt file keeps things refreshingly simple:

QuestionCount=20
TimePerQuestion=15

SettingsLoader.cs reads this file at launch and applies the values to the quiz engine. Want a 10-question quiz with 30 seconds per question? Change two numbers and save. This small design decision has made the tool genuinely usable by non-technical staff.

Project Structure

The codebase stays intentionally flat and readable:

Quize/
├── Images/
├── ModelData.cs
├── QuestionLoader.cs
├── SettingsLoader.cs
├── MainWindow.xaml(.cs)
├── QuizWindow.xaml(.cs)
├── ResultWindow.xaml(.cs)
├── Questions.xlsx
└── Settings.txt

Three windows handle the full user flow. MainWindow is the landing screen, QuizWindow runs the timed question-by-question experience with visual indicators, and ResultWindow displays the final score.

Getting Started

If you want to try it yourself, clone the repo and open Quize.sln in Visual Studio. Install the ClosedXML NuGet package, then build and run. You'll need .NET 6.0 or later on a Windows machine. Swap in your own questions by editing Questions.xlsx, and you're ready to go.

git clone https://github.com/Hu8MA/QuizeTest.git

What's Next

I'd like to extend QuizTest with support for multiple-choice questions (the current version handles true/false), a richer result screen with per-question review, and possibly a simple question-editor UI for instructors who prefer not to work in Excel. I'm also considering a lightweight export feature so results can be saved as a report after each session.

Closing Thoughts

QuizTest is a reminder that sometimes the best upgrade is removing complexity rather than adding it. Dropping the database in v2.0 made the app smaller, faster, and dramatically easier for real users to maintain.

If you find the project useful, have ideas for features, or want to contribute, the repository is open and MIT-licensed. Issues and pull requests are very welcome.

👉 Repository: github.com/Hu8MA/QuizeTest

Thanks for reading — I'd love to hear your thoughts in the comments.

Mastering Pandas — Part 4: Data Visualization with Matplotlib & Seaborn

Hussein Mahdi — Thu, 02 Apr 2026 06:05:00 +0000

Pandas for Data Science Series — Article #4

From Clean Data to Clear Insight

In Part 3, you learned how to clean messy data and combine multiple sources into one unified DataFrame. Now that your data is ready, the next step is to communicate what's inside it — and nothing communicates data faster or more clearly than a chart.

This article covers the two most important visualization libraries in Python: Matplotlib, the core engine that powers all plotting, and Seaborn, a higher-level library built on top of it that produces beautiful statistical charts with minimal code. By the end, you'll know which tool to reach for depending on what you need to show.

We'll use this sample dataset throughout:

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

data = {
    'Country':         ['China', 'India', 'USA', 'Brazil', 'UK'],
    'Continent':       ['Asia', 'Asia', 'North America', 'South America', 'Europe'],
    '2022 Population': [1412000000, 1380000000, 331000000, 214000000, 67000000],
    'Area (km2)':      [9597000, 3287000, 9834000, 8516000, 243000]
}
df = pd.DataFrame(data)

Part 1 — Matplotlib: The Engine

What is Matplotlib?

Matplotlib is the foundational plotting library in Python. Every chart you create in Python — whether through Pandas, Seaborn, or directly — eventually goes through Matplotlib to render the final output. Think of it as the engine: it handles the low-level work of drawing lines, shapes, colors, axes, and text.

The submodule you'll use in practice is matplotlib.pyplot, which gives you a clean, high-level interface without managing every visual detail manually:

import matplotlib.pyplot as plt

Matplotlib works across three styles, each suited to a different situation:

Style	When to use
`df.plot(kind="bar", y="col")`	Your data is already in a DataFrame — quickest way
`plt.plot(xs, ys)`	Working with raw lists, arrays, or math functions
`fig, ax = plt.subplots()`	Multiple subplots or full layout control

All three ultimately use Matplotlib to render the chart. plt.show() is always called at the end to display it.

Global Settings with `plt.rcParams`

plt.rcParams is a global settings dictionary. Any value you set here applies to every chart created afterward in the session — so you set it once at the top of your notebook and never repeat it.

plt.rcParams['figure.figsize'] = (12, 5)   # default width and height
plt.rcParams['font.size']      = 13         # default font size
plt.rcParams['figure.dpi']     = 100        # image sharpness
plt.rcParams['lines.linewidth'] = 2         # default line thickness
plt.rcParams['axes.grid']      = True       # show grid on all charts

Setting a Visual Theme with `plt.style.use()`

One line changes the entire look of your charts — colors, background, grid style, and fonts. Call it before your plot, not after.

plt.style.use("ggplot")
df.plot(kind="bar", y="2022 Population")
plt.show()

Style	Look
`"ggplot"`	Gray background, colored lines — popular R-like style
`"seaborn-v0_8-whitegrid"`	Clean, modern, white with grid
`"fivethirtyeight"`	Bold, thick lines — news article style
`"dark_background"`	Black background
`"bmh"`	Soft colors, Bayesian style
`"grayscale"`	Shades of gray only
`"tableau-colorblind10"`	Colorblind-friendly palette

Run print(plt.style.available) to see every available option.

Plotting from a DataFrame with `.plot()`

Since Pandas is built on Matplotlib, every DataFrame and Series has a .plot() method that creates a chart in one line.

df.plot(kind="bar", x="Country", y="2022 Population", figsize=(10, 5), title="Population by Country")
plt.show()

The kind= parameter selects the chart type. All common types are supported:

`kind=`	Chart
`"bar"`	Vertical bars
`"barh"`	Horizontal bars
`"line"`	Line chart (default)
`"pie"`	Pie chart
`"hist"`	Histogram
`"scatter"`	Scatter plot
`"box"`	Box plot

You can also call the chart type directly as a method — both styles produce identical output:

# These two are exactly the same:
df.plot(kind="bar", x="Country", y="2022 Population")
df.plot.bar(x="Country", y="2022 Population")

The direct method style (df.plot.bar()) is shorter and more common in practice.

Key parameters you'll use on almost every chart:

Parameter	What it does	Example
`kind`	Chart type	`"bar"`, `"line"`, `"scatter"`
`x` / `y`	Columns for axes	`x="Country"`, `y="2022 Population"`
`figsize`	Width and height in inches	`figsize=(10, 5)`
`title`	Chart title	`title="Population by Country"`
`color`	Bar/line color	`color="steelblue"`
`legend`	Show or hide legend	`legend=True`
`xlabel` / `ylabel`	Axis labels	`xlabel="Country"`
`rot`	Rotation of tick labels	`rot=45`
`grid`	Show background grid	`grid=True`
`alpha`	Transparency	`alpha=0.8`
`bins`	Bin count (histogram only)	`bins=20`

df.plot(
    kind="bar",
    x="Country",
    y="2022 Population",
    figsize=(10, 5),
    title="2022 World Population",
    color="steelblue",
    xlabel="Country",
    ylabel="Population",
    rot=0,
    grid=True,
    alpha=0.85
)
plt.show()

Plotting Directly with `plt.plot()`

When your data is not in a DataFrame — raw lists, NumPy arrays, or a mathematical function — use plt.plot() directly.

import numpy as np

xs = np.arange(-5, 5, 0.25)
ys = xs ** 2

plt.figure(figsize=(8, 5))
plt.plot(xs, ys, color="steelblue", linewidth=2, linestyle="--")
plt.title("Quadratic Function")
plt.xlabel("X")
plt.ylabel("Y")
plt.grid(True)
plt.show()

Matplotlib doesn't know your data is a curve — it connects the dots you give it with straight lines. When points are closely spaced (as with np.arange step 0.25), hundreds of short segments visually blend into a smooth curve.

Customizing plt.plot():

# Color
plt.plot(xs, ys, color='red')

# Line style
plt.plot(xs, ys, linestyle='--')    # dashed
plt.plot(xs, ys, linestyle=':')     # dotted
plt.plot(xs, ys, linestyle='-.')    # dash-dot

# Markers at each point
plt.plot(xs, ys, marker='o')        # circles
plt.plot(xs, ys, marker='s')        # squares
plt.plot(xs, ys, marker='^')        # triangles

# Everything combined
plt.plot(xs, ys, color='green', linestyle='--', linewidth=2, marker='o')
plt.show()

If you want dots without a line, use plt.scatter():

plt.scatter(xs, ys)
plt.show()

Decorating Any Chart

These functions work on any chart — whether drawn through Pandas or directly:

plt.title("Chart Title")
plt.xlabel("X Axis Label")
plt.ylabel("Y Axis Label")
plt.grid(True)
plt.legend()      # shows labels defined with label= on each line
plt.show()

When plotting multiple lines, use label= with each plt.plot() call, then plt.legend() to display them:

ys1 = xs ** 2
ys2 = xs ** 3

plt.plot(xs, ys1, label="f(x) = x²")
plt.plot(xs, ys2, label="f(x) = x³", linestyle="--")
plt.legend()
plt.show()

Multiple Subplots with Object-Oriented Style

When you need more than one chart in the same figure, use the object-oriented style. It gives you full control over each subplot independently.

# 1 row, 2 columns — side by side
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

ax1.bar(df["Country"], df["2022 Population"], color="steelblue")
ax1.set_title("Population by Country")
ax1.set_xlabel("Country")
ax1.set_ylabel("Population")

ax2.scatter(df["Area (km2)"], df["2022 Population"], color="tomato")
ax2.set_title("Area vs Population")
ax2.set_xlabel("Area (km²)")
ax2.set_ylabel("Population")

plt.tight_layout()
plt.show()

fig is the whole figure container. ax1 and ax2 are the individual plotting areas. The pattern is the same as plt.* calls, just moved to ax.set_*() methods.

Part 2 — Seaborn: Statistical Visualization

What is Seaborn?

Seaborn is a library built on top of Matplotlib, designed for statistical data visualization. It produces polished, publication-quality charts with far less code than raw Matplotlib, and works natively with Pandas DataFrames.

import seaborn as sns

Every Seaborn chart follows the same basic structure:

sns.chart_type(data=df, x='column_name', y='column_name')
plt.show()

The hue= parameter is Seaborn's most powerful feature — it automatically splits and colors your data by a category column, adding a legend with no extra work:

sns.scatterplot(data=df, x='Area (km2)', y='2022 Population', hue='Continent')
plt.show()

Global Styling with `set_theme()`

Call this once at the top. Every chart afterward follows these settings automatically.

sns.set_theme(style='whitegrid', palette='deep', font_scale=1.2)

style controls the background:

sns.set_theme(style='whitegrid')   # white background with grid — most common
sns.set_theme(style='darkgrid')    # dark background with grid
sns.set_theme(style='white')       # white background, no grid
sns.set_theme(style='ticks')       # minimal, axis ticks only

palette controls the colors of chart elements:

sns.set_theme(palette='deep')        # default, rich colors
sns.set_theme(palette='muted')       # softer, less saturated
sns.set_theme(palette='pastel')      # light pastel colors
sns.set_theme(palette='colorblind')  # accessible for colorblind readers

font_scale scales all text up or down:

sns.set_theme(font_scale=1.5)    # larger text
sns.set_theme(font_scale=0.8)    # smaller text

To apply a style to one chart only without changing global settings:

with sns.axes_style('whitegrid'):
    sns.barplot(data=df, x='Continent', y='2022 Population')
    plt.show()

To reset everything back to Matplotlib defaults: sns.reset_defaults()

Relational Charts — Showing Relationships Between Numbers

Use these when you want to see how two numeric columns relate to each other.

scatterplot() — each row becomes one dot on the chart:

# Basic
sns.scatterplot(data=df, x='Area (km2)', y='2022 Population')

# Colored by continent
sns.scatterplot(data=df, x='Area (km2)', y='2022 Population', hue='Continent')
plt.title("Area vs Population")
plt.show()

lineplot() — connects points with a line. Best for time series or ordered data:

sns.lineplot(data=df, x='Country', y='2022 Population', hue='Continent')
plt.show()

relplot() — a single figure-level function for both scatter and line. Use kind= to switch:

sns.relplot(data=df, x='Area (km2)', y='2022 Population', kind='scatter', hue='Continent')
sns.relplot(data=df, x='Country', y='2022 Population', kind='line')
plt.show()

Distribution Charts — Showing How Values Are Spread

Use these to understand the shape and spread of a numeric column.

histplot() — bars showing how many values fall within each range:

# Basic histogram
sns.histplot(data=df, x='2022 Population')

# With smooth density curve on top
sns.histplot(data=df, x='2022 Population', kde=True)

# Split by category
sns.histplot(data=df, x='2022 Population', hue='Continent')
plt.show()

kdeplot() — a smooth density curve, more refined than a histogram:

sns.kdeplot(data=df, x='2022 Population', hue='Continent')
plt.show()

For a 2D density plot showing where two numeric columns overlap:

sns.kdeplot(data=df, x='Area (km2)', y='2022 Population')
plt.show()

rugplot() — adds small tick marks along an axis showing where individual data points are. Typically layered on top of a kdeplot:

sns.kdeplot(data=df, x='2022 Population')
sns.rugplot(data=df, x='2022 Population')
plt.show()

ecdfplot() — shows the cumulative distribution: what percentage of values fall below each point:

sns.ecdfplot(data=df, x='2022 Population')
plt.show()

displot() — one function to rule all distribution charts. Use kind= to switch:

sns.displot(data=df, x='2022 Population', kind='hist', hue='Continent')
sns.displot(data=df, x='2022 Population', kind='kde')
sns.displot(data=df, x='2022 Population', kind='ecdf')
plt.show()

Categorical Charts — Comparing Groups

Use these when one axis is a category and the other is numeric.

barplot() — shows the mean value per category, with confidence interval bars:

sns.barplot(data=df, x='Continent', y='2022 Population', hue='Continent')
plt.title("Average Population by Continent")
plt.show()

Note: barplot() shows the mean, not the raw values. If you want raw counts by category, use countplot().

countplot() — counts how many rows belong to each category:

sns.countplot(data=df, x='Continent')
plt.show()

boxplot() — shows median, quartiles, and outliers. A fast way to spot unusual values:

sns.boxplot(data=df, x='Continent', y='2022 Population')
plt.show()

violinplot() — like a boxplot, but also shows the full distribution shape on both sides. More informative for larger datasets:

sns.violinplot(data=df, x='Continent', y='2022 Population')
plt.show()

stripplot() — shows every individual data point as a dot per category. Useful when you want to see actual values rather than a summary:

sns.stripplot(data=df, x='Continent', y='2022 Population', hue='Continent')
plt.show()

swarmplot() — same as stripplot but repositions overlapping points so each one is visible:

sns.swarmplot(data=df, x='Continent', y='2022 Population')
plt.show()

pointplot() — shows the mean per category as a dot, connected by lines across categories. Good for spotting trends:

sns.pointplot(data=df, x='Continent', y='2022 Population', hue='Continent')
plt.show()

catplot() — one function for all categorical charts. Use kind= to switch between them:

sns.catplot(data=df, x='Continent', y='2022 Population', kind='bar')
sns.catplot(data=df, x='Continent', y='2022 Population', kind='box')
sns.catplot(data=df, x='Continent', y='2022 Population', kind='violin')
sns.catplot(data=df, x='Continent', y='2022 Population', kind='strip')
sns.catplot(data=df, x='Continent', y='2022 Population', kind='swarm')
sns.catplot(data=df, x='Continent', y='2022 Population', kind='point')
plt.show()

Matrix & Regression Charts — Correlations and Trends

corr() + heatmap() — the most common combination for exploring how numeric columns relate to each other:

corr = df.select_dtypes(include='number').corr()
sns.heatmap(corr, annot=True, cmap='coolwarm')
plt.title("Correlation Matrix")
plt.show()

The values range from -1.0 (perfect negative relationship) to 1.0 (perfect positive relationship). annot=True displays the number inside each cell. cmap='coolwarm' colors high values red and low values blue.

clustermap() — same as heatmap but automatically reorders rows and columns by similarity using clustering:

sns.clustermap(corr, annot=True, cmap='coolwarm')
plt.show()

pairplot() — creates scatter plots for every combination of numeric columns at once, with distribution plots along the diagonal. The fastest way to get a complete overview of your data:

# All numeric columns
sns.pairplot(df.select_dtypes(include='number'))

# Colored by a category
sns.pairplot(df, hue='Continent')
plt.show()

jointplot() — shows a scatter plot of two columns, plus the distribution of each column on the margins:

sns.jointplot(data=df, x='Area (km2)', y='2022 Population')

# With a regression line
sns.jointplot(data=df, x='Area (km2)', y='2022 Population', kind='reg')
plt.show()

lmplot() — scatter plot with a regression line fitted through the data. Supports separate lines per group:

sns.lmplot(data=df, x='Area (km2)', y='2022 Population')

# Separate regression line per continent
sns.lmplot(data=df, x='Area (km2)', y='2022 Population', hue='Continent')
plt.show()

regplot() — the axes-level version of lmplot(). Does the same thing but doesn't support grouping. Use when you want to embed a regression plot inside a larger figure with subplots:

sns.regplot(data=df, x='Area (km2)', y='2022 Population')
plt.show()

residplot() — shows the residuals of a regression: how far each actual point is from the predicted line. A flat, random scatter around zero means the regression is a good fit:

sns.residplot(data=df, x='Area (km2)', y='2022 Population')
plt.show()

Combining Seaborn with Matplotlib

Seaborn creates the chart. Matplotlib customizes it. Both work together in the same block — you never have to choose one or the other:

sns.boxplot(data=df, x='Continent', y='2022 Population', palette='pastel')

plt.title('Population Distribution by Continent')
plt.xlabel('Continent')
plt.ylabel('Population')
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

This is the standard workflow: Seaborn for the chart, Matplotlib for the title, labels, rotation, and layout.

Choosing the Right Tool

Use Matplotlib when:

Your data is in raw lists or NumPy arrays, not a DataFrame
You need multiple subplots in a specific layout
You want pixel-level control over every visual element

Use Seaborn when:

Your data is in a DataFrame and ready to visualize
You want a beautiful chart quickly with minimal code
You're doing statistical analysis — distributions, correlations, regressions, group comparisons

In most real projects, you'll use both: Seaborn to draw the chart, Matplotlib to label and polish it.

Complete Summary Table

Function	Library	Category	What it shows
`plt.rcParams`	Matplotlib	Settings	Global defaults for all charts
`plt.style.use()`	Matplotlib	Settings	Visual theme for all charts
`df.plot()`	Pandas/Matplotlib	General	Any chart type from a DataFrame
`plt.plot()`	Matplotlib	Line/Scatter	Lines and points from raw data
`plt.scatter()`	Matplotlib	Scatter	Dots from raw data
`plt.bar()`	Matplotlib	Bar	Bars from raw data
`plt.hist()`	Matplotlib	Distribution	Histogram from raw data
`plt.subplots()`	Matplotlib	Layout	Multiple charts in one figure
`sns.set_theme()`	Seaborn	Settings	Global style for all Seaborn charts
`sns.scatterplot()`	Seaborn	Relational	Relationship between two numeric columns
`sns.lineplot()`	Seaborn	Relational	Trend or time series
`sns.relplot()`	Seaborn	Relational	Wrapper for scatter and line
`sns.histplot()`	Seaborn	Distribution	Histogram with optional KDE
`sns.kdeplot()`	Seaborn	Distribution	Smooth density curve
`sns.ecdfplot()`	Seaborn	Distribution	Cumulative distribution
`sns.rugplot()`	Seaborn	Distribution	Data point ticks on axis
`sns.displot()`	Seaborn	Distribution	Wrapper for all distribution charts
`sns.barplot()`	Seaborn	Categorical	Mean per category
`sns.countplot()`	Seaborn	Categorical	Row count per category
`sns.boxplot()`	Seaborn	Categorical	Median, quartiles, outliers
`sns.violinplot()`	Seaborn	Categorical	Distribution shape per category
`sns.stripplot()`	Seaborn	Categorical	Individual data points per category
`sns.swarmplot()`	Seaborn	Categorical	Non-overlapping dots per category
`sns.pointplot()`	Seaborn	Categorical	Mean per category with trend line
`sns.catplot()`	Seaborn	Categorical	Wrapper for all categorical charts
`sns.heatmap()`	Seaborn	Matrix	Color-coded correlation matrix
`sns.clustermap()`	Seaborn	Matrix	Clustered heatmap
`sns.pairplot()`	Seaborn	Matrix	All column pairs at once
`sns.jointplot()`	Seaborn	Regression	Scatter + marginal distributions
`sns.lmplot()`	Seaborn	Regression	Scatter with regression line (supports grouping)
`sns.regplot()`	Seaborn	Regression	Scatter with regression line (no grouping)
`sns.residplot()`	Seaborn	Regression	Regression residuals

This is Part 4 of the Pandas for Data Science series. This is the last article in this series; we'll see you in another series 👨‍💻.

References

GitHub Repo: https://github.com/Hu8MA/Mastering-Pandas-Reference
Matplotlib Documentation: https://matplotlib.org/
Course : https://youtu.be/Mdq1WWSdUtw
Seaborn Documentation: https://seaborn.pydata.org/
Pandas Visualization Guide: https://pandas.pydata.org/docs/user_guide/visualization.html

DEV Community: Hussein Mahdi

New code is upload of new model 🚀🥇

Predicting Drug-Drug Interactions with Hypergraphs — on Two CPU Cores

Predicting Drug-Drug Interactions with Hypergraphs — on Two CPU Cores

Why hypergraphs

Stage 1: the chemical hypergraph

Stage 2: the interaction-type hypergraph

The ablations that mattered

The efficiency story

What is in the repo

What it does not do

Who wants to know what the library is in the context of artificial intelligence development?

NumPy vs List: SIMD Vector Processing with Concrete Mathematical Example

For anyone interested in learning about the history, concepts, and philosophy of graph neural networks, please refer to this article.

Revisiting the 2009 GNN Paper: Foundations (Part 1)

The first article in the Panda Library Mastery series

Mastering Pandas — Part 1: Reading, Sorting & Displaying Data

The Leash That Makes AI Polite

How a 1951 statistics formula quietly keeps your chatbot from going feral

First: measuring surprise

Then: teaching taste

Where they meet

Which is more important to a data scientist: NumPy or List 🎇? But should they also consider performance 🤔? This article explains. Read it; it will be helpful.

NumPy vs List: SIMD Vector Processing with Concrete Mathematical Example

[Boost]

The Math Behind Neural Networks — Explained Like Nobody Did for Me 🧨

What will you think of when you read about a neural network!!? Mathematics? 🤔

The Math Behind Neural Networks — Explained Like Nobody Did for Me 🧨

The Math Behind Neural Networks — Explained Like Nobody Did for Me 🧨

Building QuizTest — A WPF Quiz Application for Educational Institutions

Building QuizTest — A WPF Quiz Application for Educational Institutions

The Problem I Wanted to Solve

Tech Stack

From v1.0 to v2.0 — A Lesson in Simplification

How the Question Bank Works

Configurable Settings Without Recompiling

Project Structure

Getting Started

What's Next

Closing Thoughts

Mastering Pandas — Part 4: Data Visualization with Matplotlib & Seaborn

From Clean Data to Clear Insight

Part 1 — Matplotlib: The Engine

What is Matplotlib?

Global Settings with plt.rcParams

Setting a Visual Theme with plt.style.use()

Plotting from a DataFrame with .plot()

Plotting Directly with plt.plot()

Decorating Any Chart

Multiple Subplots with Object-Oriented Style

Part 2 — Seaborn: Statistical Visualization

What is Seaborn?

Global Styling with set_theme()

Relational Charts — Showing Relationships Between Numbers

Distribution Charts — Showing How Values Are Spread

Categorical Charts — Comparing Groups

Matrix & Regression Charts — Correlations and Trends

Combining Seaborn with Matplotlib

Choosing the Right Tool

Complete Summary Table

Global Settings with `plt.rcParams`

Setting a Visual Theme with `plt.style.use()`

Plotting from a DataFrame with `.plot()`

Plotting Directly with `plt.plot()`

Global Styling with `set_theme()`