Muhammad Nakhaee's Blog https://mcnakhaee.com/blog/ Articles on data science, analytics, and technology quarto-1.8.25 Fri, 14 Nov 2025 23:00:00 GMT MyNextChart: How I’m using AI for data visualization and it’s not what you think Muhammad Chenariyan Nakhaee https://mcnakhaee.com/blog/posts/mynextchart/

Intro

This is a short blog post to introduce my new project, MyNextChart which came from my frustration with keeping track of 1000s of data visualizations inspirations I saw on the internet and my eternal struggle to categorize them and make sense of them.

I presented this project at PyData Amsterdam 2025 this year and you can find the recording here: MyNextChart: How I Use AI for Data Visualization and It’s not to make Chart Slop. So this blog post will be just a short summary of the talk without going into the details of the project. I’ll write more about the technical details of how I built this project in a future post.

Why I started this project

If you’re reading posts there is a big chance you have more than a 100 open tabs in your browser that you want to read later but never get to it? Or you have 1000s of saved bookmarks on your Twitter, LinkedIn, and other social media accounts that you never get to looked at them.

I suffer from the same problem but probably even worse. I have around a few thousands or more bookmarked tweets, a few hundred bookmarked LinkedIn posts, and I have a few hundred open tabs in my browsers on different computers that I wanted to read look at but never get to it. One time I even realized that I had open tabs from 3 years ago!

A large part of my bookmarked posts and tweets consist of data visualizations articles and charts that I find interesting and want to take inspiration from them for my own data visualizations. To alleviate my problem I have been using a few different applications like Notion to save and organize my bookmarked charts (and articles).

I have been using these saved charts for inspiration when I’m working on a new data visualization project or for challenges such as #TidyTuesday or #30daychartchallenge. And sometimes I also scroll through github repositories for contribution made by others in the #TidyTuesday and #30daychartchallenge to find certain ways of doing things that I can use in my own projects (for example, how create spiral line charts).

However, I realized that it was not practical to save all the charts I find interesting in Notion. The incoming stream of new charts and articles is way more than what I can save in Notion.
Besides that, the same problem still persisted! I almost never looked at the saved charts in my Notion database. And even when I did, it was hard to find what I was looking for among hundreds of saved charts. In the end, I realized that I was spending way more cataloging charts that actually looking at them or creaiing my own charts.

At the time, I was working on our RAG (retrieval-augmented generation) solutions at my job (and I still do) and RAG became a hammer for me and every problem became naturally a nail.

My RAGnar hammer

So I thought what if instead of scrolling through my bookmarked charts and articles and hoping to find something interesting or useful, I could search for the type of charts that I’m looking for in natural language.

For example, what if I search for “circular bar charts” or “lection maps for germany” and get a list of relevant charts that match my query instead of looking through my large Notion gallery and hoping to spot something.

So, this became the start of mynextchart.com project. In essence it uses AI and embeddings to ‘understand’ and making them semantically searchable. In my talk at PyData Amsterdam 2025 I explained how I built this project and the technical challenges of building a semantic search engine for data visualizations. You can watch the recorded talk on YouTube.

How the architecture works in a simple image
]]> data-science python visualization https://mcnakhaee.com/blog/posts/mynextchart/ Fri, 14 Nov 2025 23:00:00 GMT Covid-19 Trends in the Netherlands Muhammad Chenariyan Nakhaee https://mcnakhaee.com/blog/posts/covid-19-netherlands/ Two weeks ago, I made a visualization that shows how Covid-19 cases spread in the Netherlands from the beginning of March and how grim the situation looked. However, someone pointed out the fact that the number of tests has increased significantly. It means that my plot may exaggerate the Covid-19 situation in the Netherlands. Unfortunately, I could not find testing data for each Dutch municipality. Instead, I decided to use hospitalization admissions and deceased cases to see if we can indeed see a massive spread in the second wave of Covid-19 cases in the Netherlands.

Code 
library(tidyverse)
library(CoronaWatchNL)
library(sf)
library(gganimate)
library(santoku)
library(lubridate)
library(foreign)
theme_set(theme_void())
theme_update(
  #plot.background = element_rect(fill = '#FDF6E3',color = '#FDF6E3'),
  text = element_text(family = 'Poppins Light'),
  plot.subtitle = element_text(
    family = 'Poppins Light',
    size = 10,
    margin = margin(b = 10)
  ),
  plot.title = element_text(
    family = 'Poppins Light',
    size = 12,
    margin = margin(t = 10, b = 10)
  )
)

I created an R package called CoronaWatchNL that allows you to access a wide range of Covid-19 datasets. I’ll use this package in this post to get Covid-19 cases, hospital admissions, and deaths for Dutch municipalities.

Note

This post uses R packages that need to be installed: tidyverse, CoronaWatchNL, sf, gganimate, santoku, lubridate, foreign. The code is shown for educational purposes but not executed in this rendered version.

Code 
municipalBoundaries <- st_read(
    "https://geodata.nationaalgeoregister.nl/cbsgebiedsindelingen/wfs?request=GetFeature&service=WFS&version=2.0.0&typeName=cbs_gemeente_2020_gegeneraliseerd&outputFormat=json"
  )

daily_cases_per_municpality <- get_daily_cases_per_municipality()
populatuon_per_region <- get_population_per_region()

daily_cases_per_municpality <- daily_cases_per_municpality %>%
  inner_join(populatuon_per_region, by = c('Municipality_name' = 'Regions')) %>%
  mutate(
    Date_of_publication = as_date(Date_of_publication),
    avg_daily_total_cases = 100000 * as.numeric(Total_reported) / as.numeric(`Bevolking op 1 januari (aantal)`),
    avg_daily_hospital_admissions = 100000 * as.numeric(Hospital_admission) / as.numeric(`Bevolking op 1 januari (aantal)`),
    avg_daily_deceased = 100000 * as.numeric(Deceased) / as.numeric(`Bevolking op 1 januari (aantal)`)
  )

I compute the weekly average number of Covid-19 cases, hospitalizations, and deaths per 100,000 inhabitants in each municipality in the Netherlands. The following piece of code shows how I did this using R.

Code 
weekly_cases <- daily_cases_per_municpality %>%
  mutate(week = round_date(Date_of_publication , unit = 'week'))

weekly_cases_per_municpality <- weekly_cases %>%
  group_by(Municipality_name, week) %>%
  summarise(
    avg_weekly_total_cases = mean(avg_daily_total_cases),
    avg_weekly_hospital_admissions = mean(avg_daily_hospital_admissions),
    avg_weekly_deceased = mean(avg_daily_deceased)) %>%
  ungroup() %>%
  mutate(
    d_avg_weekly_total_cases = chop(avg_weekly_total_cases, c(0, 0, 0.5, 1, 5, 12, 20, 35, 55, 80, 100)),
    d_avg_hospital_admissions = chop(
      avg_weekly_hospital_admissions,
      c(0, 0, 0.5, 1, 2, 3, 5, 7, 9, 10, 15)),
    d_avg_weekly_deceased = chop(avg_weekly_deceased, c(0, 0, 0.1, 0.5, 1, 1.5, 2, 2.5, 3, 5)))

data_weekly <- municipalBoundaries %>%
  right_join(weekly_cases_per_municpality,
             by = c(statnaam = "Municipality_name"))

I will create an animation that shows how Covid-19 cases spread in the Netherlands and which municipalities were and are hit hardest by the pandemic.

Code 
make_animation <- function(data, var_name, pal, title) {
  var_name <- rlang::enquo(var_name)
  data %>%
    #filter(week > '2020-10-01') %>%
    ggplot() +
    geom_sf(aes(fill = !!var_name), color = 'gray95') +
    scale_fill_manual(values  = pal) +
    coord_sf(datum = NA) +
    labs(
      title = title,
      subtitle = 'Date: {current_frame}',
      fill = 'Counts per 100,000',
      caption = 'Source: RIVM'
    ) +
    transition_manual(week, cumulative = T) +
    ease_aes("sine") +
    enter_fade(alpha = 0.5) +
    exit_fade(alpha = 0.5)
}

Covid-19 Cases

The first animation shows the number of infections in each municipality, from the start of the pandemic in February until recently. As you can see, the second wave, which began in late September, looks really terrifying. Note that there are some municipalities for which no data is available.

Code 
pal_cases <- c(
      'gray95',
      '#fee440',
      '#FFBA08',
      '#FAA307',
      '#F48C06',
      '#E85D04',
      '#DC2F02',
      '#D00000',
      '#9D0208',
      '#6A040F',
      '#370617',
      '#03071e'
    )
make_animation(data_weekly,d_avg_weekly_total_cases,pal_cases,'The Average Weekly Number of Covid-19 Cases\nper 100,000 Inhabitants in the Netherlands')

Hospital Admissions

If we look at the number of hospital admissions, we see a different story. It seems that the number of hospitalizations was higher during the first wave of Covid-19 compared to the second wave, and mostly the southern parts of the Netherlands were hit harder than the rest of the Netherlands.

Code 
pal_patients <- c(
      'gray95',
      '#caf0f8',
      '#ade8f4',
      '#90e0ef',
      '#48cae4',
      '#00b4d8',
      '#0096c7',
      '#0077b6',
      '#023e8a',
      '#03045e',
      '#03071e'
)
make_animation(data_weekly,d_avg_hospital_admissions,pal_patients,'The Average Weekly Number of Hospital Admissions\nper 100,000 Inhabitants in the Netherlands')

Deaths

The trend for deceased patients looks similar to that of hospital admissions. The average number of deaths during the first wave of coronavirus was higher than the average number of deaths during the second wave.

Code 
pal_deceased <- c(
      'gray95',
      '#fdc5f5',
     '#e0aaff',
      '#c77dff',
      '#9d4edd',
      '#7b2cbf',
      '#5a189a',
      '#3c096c',
      '#240046',
      '#10002b'
)
make_animation(data_weekly,d_avg_weekly_deceased,pal_deceased,'The Average Weekly Number of Deceased Patients\nper 100,000 Inhabitants in the Netherlands')

Conclusion

These different animations show us two distinct trends. On the one hand, we can see the number of confirmed cases rose rapidly during the second wave to affect almost all regions. On the other hand, the number of hospitalizations and deaths during the second wave slightly decreased. This might suggest that the rise in the number of cases is mainly driven by an increase in the number of tests. Alternatively, the virus might have become less deadly and severe.

]]> R data visualization Covid-19 https://mcnakhaee.com/blog/posts/covid-19-netherlands/ Fri, 21 May 2021 22:00:00 GMT How Easy Is It to Understand What Donald Trump Says? Muhammad Chenariyan Nakhaee https://mcnakhaee.com/blog/posts/trump-speech-readability/ Aside from their political differences, Donald Trump and Barack Obama have very contrasting personalities, traits, and characters. Obama is known to be a great communicator and an articulate speaker whose speeches are used in English classes to show how one should speak proper English. On the other hand, Trump is not the most eloquent English speaker or US president in history. Every now and then, you can find a clip on the web where Donald Trump is being mocked for the way he speaks or mispronounces words. This is so obvious that even non-native English speakers can notice how Trump’s speeches are very simple and inarticulate. Of course, this was not a bad thing for Trump at all. Actually, almost every political analyst that you see on the news talks about the fact that a vast majority of Trump’s fervent supporters are not college-educated Americans. We can attribute this to the fact that he knows how to speak to his audience and his base supporters using their language (although it is more likely that he cannot speak English better than this level).

This post will investigate how difficult it is to understand what each US politician talked about in the 2020 US Election cycle. I will use several readability metrics that can help us compute text comprehensibility. A wide range of these measures are implemented in the {textstat} Python package, and it is super easy to calculate them using this package.

Aside from their political differences, Donald Trump and Barack Obama have very contrasting personalities, traits, and characters. Obama is known to be a great communicator and an articulate speaker whose speeches are used in English classes to show how one should speak proper English. On the other hand, Trump is not the most eloquent English speaker or US president in history. Every now and then, you can find a clip on the web where Donald Trump is mocked for the way he speaks or mispronounces words. This is so obvious that even non-native English speakers can notice how Trump’s speeches are very simple and inarticulate. Of course, this was not a bad thing for Trump at all. Actually, almost every political analyst you see on the news talks about the fact that a vast majority of Trump’s fervent supporters are not college-educated Americans. We can attribute this to the fact that he knows how to speak to his audience and his base supporters using their language (although it is more likely that he cannot speak English better than this level).

This post will investigate how difficult it is to understand what each US politician talked about in the 2020 US Election cycle. I will use several readability metrics that can help us compute text comprehensibility. A wide range of these measures is implemented in the {textstat} Python package, and it is super easy to calculate them using this package.

I compiled a list of US Election-related speeches from rev.com and turned them into an R package called {us2020election}. I use this package as my data source for my analysis. Like some of my other posts, I use Python to perform the analysis and R to visualize my results. Now let’s get started by importing the necessary packages.

Note

This post uses R packages that need to be installed: tidyverse, reticulate, ggthemes, us2020election, ggridges. The code is shown for educational purposes but not executed in this rendered version.

I compiled a list of US Election-related speeches from rev.com and turned them into an R package called {us2020election}. I use this package as my data source for my analysis. Like some of my other posts, I use Python to perform the analysis and R to visualize my results. Now, let’s get started by importing the necessary packages.

Code 
library(tidyverse)
library(reticulate)
library(ggthemes)
library(us2020election)
library(ggridges)
theme_set(theme_tufte())
theme_update(legend.position = 'none',
          text = element_text(family = 'Lobster'),
          plot.title = element_text(margin = margin(t= 10,b= 5),family = 'Lobster'),
          plot.subtitle = element_text(margin = margin(b= 10),family = 'Lobster'),
          panel.background = element_rect(fill = '#FDF6E3'),
          plot.background = element_rect(fill = '#FDF6E3'))
Code 
import numpy as np
import pandas as pd 
import textstat

There are several readability measures for English text included in {textstat}. Calculating these measures is very straightforward and easy. I will explain what each metric represents in more detail.

Code 
us_election_speeches = r.us_election_speeches
us_election_speeches['Flesch_Reading_Ease_formula'] = us_election_speeches['text'].apply(lambda x: textstat.flesch_reading_ease(x))
us_election_speeches['gunning_fog'] = us_election_speeches['text'].apply(lambda x: textstat.gunning_fog(x))
us_election_speeches['smog_index'] = us_election_speeches['text'].apply(lambda x: textstat.smog_index(x))
us_election_speeches['automated_readability_index'] = us_election_speeches['text'].apply(lambda x: textstat.automated_readability_index(x))
us_election_speeches['coleman_liau_index'] = us_election_speeches['text'].apply(lambda x: textstat.coleman_liau_index(x))
us_election_speeches['linsear_write_formula'] = us_election_speeches['text'].apply(lambda x: textstat.linsear_write_formula(x))
us_election_speeches['dale_chall_readability_score'] = us_election_speeches['text'].apply(lambda x: textstat.dale_chall_readability_score(x))
us_election_speeches['text_standard'] = us_election_speeches['text'].apply(lambda x: textstat.text_standard(x))
us_election_speeches['text_standard_float'] = us_election_speeches['text'].apply(lambda x: textstat.text_standard(x,float_output  = True))

Let’s look at the resulting dataframe.

Code 
us_election_speeches <- py$us_election_speeches 
us_election_speeches %>% 
glimpse()

Now I am going to visualize the changes in the distribution of speech complexity for each politician. To make things easier, I will select a list of politicians that I’d like to analyze in this post.

Code 
speakers <- c('Barack Obama','Pete Buttigieg','Mike Pence','Elizabeth Warren','Bernie Sanders','Donald Trump','Kamala Harris','Joe Biden','Mike Bloomberg')
custom_palette <-c(
    'Mike Bloomberg' = '#4E79A7',
    'Amy Klobuchar' = '#4E79A7',
    'Joe Biden' = '#4E79A7',
    'Pete Buttigieg' = '#4E79A7',
    'Elizabeth Warren' =  '#4E79A7',
    'Barack Obama'  = '#4E79A7',
    'Bernie Sanders' = '#4E79A7',
    'Kamala Harris' = '#4E79A7',
    'Donald Trump'  = '#E15759' ,
     'Mike Pence' = '#E15759' 
  )

Also, I created a function to make ridge plots for each metric easier.

Code 
create_plot <- function(metric = Flesch_Reading_Ease_formula,subtitle = subtitle) {
  metrics <- rlang::enquo(metric)
  us_election_speeches %>%
    separate_rows(speaker, sep = ',') %>%
    filter(speaker %in% speakers, type != 'Debate') %>%
    add_count(speaker) %>%
    ggplot() +
    geom_density_ridges(aes(
      x = !!metrics ,
      y = speaker,
      fill = speaker
    )) +
    labs(x = '', y = '',title = "How Easy Is It to Comprehend Different US Politicians?",subtitle = str_wrap(subtitle,width = 100)) +
    scale_fill_manual(values = custom_palette) 
}

Now, let’s look at several readability measures in more depth.

Flesch Reading Ease Scores

The first readability score that I will look at is based on the Flesch Reading Ease formula. It computes the number of syllables to determine how easy a piece of text is. The maximum value of Flesch Reading Ease is 122, and there is no minimum value for it. Higher Flesch Reading Ease scores indicate that the text (speech) is easier to understand by the audience. In our case, it would show how sophisticated each politician is in terms of language use. You can find more about this metric on Wikipedia!

Code 
create_plot(Flesch_Reading_Ease_formula ,
            subtitle = 'The Flesch Reading Ease scores measure the complexity of a text document. Higher scores indicate a text is easier to comprehend.')

We can interpret the scores using the following table:

Score School level Notes
100.00–90.00 5th grade Very easy to read. Easily understood by an average 11-year-old student.
90.0–80.0 6th grade Easy to read. Conversational English for consumers.
80.0–70.0 7th grade Fairly easy to read.
70.0–60.0 8th & 9th grade Plain English. Easily understood by 13- to 15-year-old students.
60.0–50.0 10th to 12th grade Fairly difficult to read.
50.0–30.0 College Difficult to read.
30.0–10.0 College graduate Very difficult to read. Best understood by university graduates.
10.0–0.0 Professional Extremely difficult to read. Best understood by university graduates.

Gunning Fog Index

The Gunning fog index is another metric to measure the complexity of a text document. It shows how many years of education one might need to understand a piece of text. Larger values of the Gunning fog index correspond to more difficult writings.

The Gunning fog index is another metric to measure the complexity of a text document. It shows how many years of education one might need to understand a piece of text. Larger values of the Gunning fog index correspond to more difficult writing.

Code 
create_plot(gunning_fog,subtitle = 'The Gunning fog index measures the complexity of a text document. Larger values of the Gunning fog index correspond to more difficult writings.' )

The SMOG Index

The SMOG index computes the ratio of polysyllables (words with three or more syllables) in sentences to determine text complexity.

Code 
create_plot(smog_index,subtitle = 'The SMOG index measures the complexity of a text document. Larger values of the SMOG index indicate more difficult writings.' )

Linsear Write Formula

Like the previous metric, the Linsear Write Formula uses words with three or more syllables to compute text readability. It also relies on the sentence length to measure how difficult reading a text could be.

Code 
create_plot(linsear_write_formula, subtitle = 'The Linsear Write Formula measures the complexity of a text document. Larger values indicate more difficult writings.')

Dale-Chall Readability Score

This metric is different from the other metrics that we have talked about. It uses a dictionary of 3000 words that are easy to read and understand for a fourth-grade student. So, words that are not in this dictionary are considered to be complex. The higher the Dale-Chall Score is, the more difficult it is to read a text.

This metric is different from the other metrics that we have talked about. It uses a dictionary of 3,000 words that are easy to read and understand for a fourth-grade student. So, words that are not in this dictionary are considered to be complex. The higher the Dale-Chall Score is, the more difficult it is to read a text.

Code 
create_plot(dale_chall_readability_score,subtitle = 'The Dale-Chall Readability Score measures the complexity of a text document. The higher the Dale-Chall Score is, the more difficult it is to read a text.')

A Unified Readability Score

We introduced several readability metrics, but each one of them might give us a slightly different result. There is a way in textstat to combine all these metrics and have a single readability metric.

Code 
us_election_speeches %>%
  filter(speaker %in% speakers) %>%
  mutate(text_standard = str_replace(text_standard,' and ','-'),
        text_standard = factor(
    text_standard,
    levels = c(
      '4th-5th grade',
      '5th-6th grade',
      '6th-7th grade',
      '7th-8th grade',
      '8th-9th grade',
      '9th-10th grade',
      '10th-11th grade',
      '11th-12th grade',
      '12th-13th grade',
      '14th-15th grade'
    )
  )) %>%
  count(speaker, text_standard) %>%
  mutate(n = n + 1) %>%
  ggplot()  +
  geom_col(aes(x = text_standard , y =  n, fill = speaker)) +
  labs(x = '', y = 'Number of Speeches', title = "How Easy Is It to Understand Trump's Speeches?",
       subtitle = 'Based on several readability tests, the education level that one needs to comprehend the 2020 Election speeches by different US politicians is illustrated in this plot.' ) +
  scale_fill_manual(values = custom_palette) +
  scale_y_log10() +
  facet_wrap(~ speaker, ncol = 1) +
  theme(axis.text  = element_text(size = 13),
        axis.title.y = element_text(size = 15,margin = margin(r = 10,l = 10)),
        plot.title = element_text(size = 20,margin = margin(b = 10,t = 10)),
        plot.subtitle = element_text(size = 14,margin = margin(b = 10)),
        strip.text = element_text(size = 15))

Interestingly, we can observe that Trump never gave a speech to an audience with difficulty more than the 7th or 8th grade. We can also convert this readability metric to numbers to visualize and compare it to other metrics.

Interestingly, we can observe that Trump never gave a speech to an audience with a difficulty higher than the 7th or 8th grade. We can also convert this readability metric to numbers to visualize and compare it to other metrics.

Code 
create_plot(text_standard_float,
            subtitle = 'The complexity of a text document was measured based on several readability metrics where larger values indicate more difficult writings.')

Conclusion

We can consistently see that Trump’s speeches are less sophisticated and less complex than the speeches given by the rest of the politicians. We can attribute this to his lack of sophistication in terms of language, the fact that he knows how to speak to his audience, or both. Also, we can notice that Mike Pence and Barack Obama seem to use more advanced language in their speeches.

]]> politics data analysis NLP python R https://mcnakhaee.com/blog/posts/trump-speech-readability/ Mon, 02 Nov 2020 23:00:00 GMT