Race Pixel Intensity - Converting Image to Gray-Scale Counts and Visualizations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ability of Artificial Intelligence to Identify Self-Reported Race in Chest X-Ray Using Pixel Intensity Counts\n",
    "## Transform images into Pixel Counts and Visualize Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#imports\n",
    "from PIL import Image\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.metrics.pairwise import cosine_similarity\n",
    "import pydicom\n",
    "import scipy.stats as ss\n",
    "\n",
    "\n",
    "pd.set_option(\"display.max_columns\", None)\n",
    "\n",
    "#path of images in png format\n",
    "images_path = 'H:/path/to_image_folder/'\n",
    "\n",
    "#path of CSV\n",
    "#expects at least labels of 'File' and 'Race'\n",
    "#will keep all other labels\n",
    "images_csv = pd.read_csv('H:/path/images_and_metadata.csv', index_col=0, header=0)\n",
    "images_csv.head\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#add pixels to the other metadata in the csv\n",
    "pixels = list(range(0,256))\n",
    "freq_df = pd.concat([images_csv, pd.DataFrame(columns=pixels)])\n",
    "freq_df[pixels] = 0\n",
    "#loop through each item of CSV, open image, store pixel values\n",
    "for index, row in freq_df.iterrows():\n",
    "    file = row['File']\n",
    "    #load the image and convert into numpy array\n",
    "    #assumes image is grayscale.\n",
    "    #confim images are grayscale by opening with Image.open, then print img.format. Should return 'L'\n",
    "    #images that can't be opened are dropped\n",
    "    try:\n",
    "        img = Image.open(images_path+'/'+file)\n",
    "        temp = np.asarray(img).flatten()\n",
    "        img.close()\n",
    "        #get all the counts greyscale values, zip together\n",
    "        unique, counts = np.unique(temp, return_counts=True)\n",
    "        freq = dict(zip(unique, counts))\n",
    "        for j in freq:\n",
    "            freq_df.at[index,j] = freq[j]\n",
    "    except:\n",
    "        print('dropping: ' + file)\n",
    "        freq_df.drop(index, inplace=True)\n",
    "\n",
    "freq_df.head(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save/load a CSV\n",
    "Recommended to save a CSV after the initial run, as it's much faster to load it again later"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save to a csv\n",
    "freq_df.to_csv('frequencies.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# read from a saved csv\n",
    "freq_df = pd.read_csv('frequencies.csv', index_col=0, header=0)\n",
    "races = freq_df['race'].unique()\n",
    "freq_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pixel Percent Per Image\n",
    "This normalizes to amount of pixels present, allowing for different resolutions of images to be directly compared."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Keep original, copy to new\n",
    "freq_percent_df = freq_df.copy(deep=True)\n",
    "\n",
    "# Drop the 0 column to remove all pure non-image black space often caused by image rotations\n",
    "freq_percent_df.drop('0',axis=1,inplace=True)\n",
    "\n",
    "# Seperate out the numeric columns\n",
    "freq_percent_df_num = freq_percent_df.select_dtypes(include=[np.number])\n",
    "\n",
    "# Converting percentages instead of total pixel counts\n",
    "freq_percent_df_num = freq_percent_df_num.div(freq_df.sum(axis=1, numeric_only=True), axis=0)\n",
    "\n",
    "# Rejoin the numeric columns to the metadata columns\n",
    "freq_percent_df[freq_percent_df_num.columns] = freq_percent_df_num\n",
    "\n",
    "\n",
    "#calculate the percent frequency average distributions by race\n",
    "temp_dfs = []\n",
    "for race in races:\n",
    "    temp = pd.DataFrame(freq_percent_df.loc[freq_df['race'] == race].iloc[:,:-1].mean()).T\n",
    "    temp.index = [race]\n",
    "    temp_dfs.append(temp)\n",
    "\n",
    "freq_percent_df_race = pd.concat(temp_dfs)\n",
    "print(freq_percent_df_race)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#plot it\n",
    "fig, ax = plt.subplots(figsize=(100,50))\n",
    "for i in range(len(freq_percent_df_race)):\n",
    "    plt.plot(freq_percent_df_race.iloc[i, 0:], label=freq_percent_df_race.index[i])\n",
    "    \n",
    "plt.legend(loc='upper right', prop={'size': 65})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ANOVA Tests\n",
    "Note - ANOVA is not appropriate for data as values are highly correlated\n",
    "MANOVA with Bonferroni Corrections is used for tests\n",
    "ANOVA is displayed on web site, so remains here to demonstrate how that was accomplished"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#p value significance = 0.05\n",
    "#change display so pd can display all columns\n",
    "pd.set_option('display.max_columns', None)\n",
    "\n",
    "#check for significance\n",
    "cols = freq_percent_df.columns[:-1]\n",
    "\n",
    "#samples is a set of all image pixel percentages grouped by race\n",
    "samples = [d[cols] for _, d in freq_percent_df.groupby('race')]\n",
    "\n",
    "#one way ANOVA\n",
    "f_vals, p_vals = ss.f_oneway(*samples)\n",
    "\n",
    "#reorganize F and P for count and display\n",
    "f_df = pd.DataFrame(f_vals).transpose()\n",
    "f_df.index = ['f']\n",
    "print('Count f > 2:', f_df.where(f_df > 10).count(axis=1)[0])\n",
    "p_df = pd.DataFrame(p_vals).transpose()\n",
    "p_df.index = ['p']\n",
    "print('Count p < 0.05:', p_df.where(p_df < 0.0001).count(axis=1)[0])\n",
    "f_p_df = pd.concat([f_df, p_df])\n",
    "\n",
    "#set p-value and f-value of interest\n",
    "def color_by_number(val):\n",
    "    color = 'red'\n",
    "    if val < 0.05 or val > 2:\n",
    "            color = 'green' \n",
    "    return 'color: %s' % color\n",
    "\n",
    "f_p_df.style.applymap(color_by_number)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}