{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This notebook helps compare the CMIP6 prefix in cmip6-pds zarr bucket versus the esgf-world netcdf buckets.\n",
"It uses intake_esm catalogs and S3 Inventory reports. It can potentially use just the S3 inventory reports.\n",
"\n",
"DCPP (about 20TB) is excluded from the comparison ATM\n",
"\n",
"If you want to dive directly into the comparison plots, please scroll all the way to the bottom.\n",
"\n",
"If you'd like run it on a recent catalog, just update the following cell with the relevant pointers.\n",
"\n",
"Authors: Naomi Henderson, Aparna Radhakrishnan\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"z_inv_list='s3://s3-inventory-collection/cmip6-pds/s3-inventory-config/hive/dt=2021-04-09-00-00/symlink.txt' #'s3://s3-inventory-collection/cmip6-pds/s3-inventory-config/hive/dt=2021-04-01-00-00/symlink.txt'\n",
"\n",
"n_inv_list = 's3://s3-inventory-dest/esgf-world/cmip6-inventory/hive/dt=2021-04-09-00-00/symlink.txt' #'s3://s3-inventory-dest/esgf-world/cmip6-inventory/hive/dt=2021-03-30-00-00/symlink.txt'\n",
"\n",
"zarr_cat = 'https://cmip6-pds.s3.amazonaws.com/pangeo-cmip6-noQC.csv.gz' \n",
"netcdf_cat = 'https://cmip6-nc.s3.us-east-2.amazonaws.com/esgf-world.csv.gz'\n"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import pandas as pd\n",
"import xarray as xr\n",
"import matplotlib.pyplot as plt\n",
"from datetime import datetime\n",
"import sys\n",
"import matplotlib\n",
"matplotlib.rcParams['figure.figsize'] = [18,4]\n",
"import matplotlib.style\n",
"import matplotlib as mpl\n",
"mpl.rcParams['font.size'] = 14\n",
"mpl.rcParams['legend.fontsize'] = 'large'\n",
"mpl.rcParams['figure.titlesize'] = 'large'\n",
"pd.set_option(\"display.max_colwidth\", None)\n",
"from dask import dataframe as dd\n",
"import warnings\n",
"warnings.simplefilter(\"ignore\") \n",
"def launchDask():\n",
" #TODO try, except\n",
" gateway = Gateway()\n",
" options = gateway.cluster_options()\n",
" options.worker_memory=16\n",
" clusters = gateway.list_clusters()\n",
" clusters\n",
" if len(clusters) >0:\n",
" cluster = gateway.connect(clusters[0].name)\n",
" print(\"close existing connection\")#or shut down and start afresh cluster.shutdown(). otherwise I dunno how to apply custom options\n",
" cluster.shutdown()\n",
" cluster = gateway.new_cluster(options)\n",
" else:\n",
" cluster = gateway.new_cluster(options)\n",
" return(cluster)\n",
"from dask_gateway import Gateway\n",
"from dask.distributed import Client\n",
"cluster = launchDask()\n",
"from distributed import Client\n",
"client = Client(cluster)\n",
"client\n",
"cluster.adapt(minimum=0, maximum=30) "
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"
\n",
"\n",
"\n",
"Client\n",
"\n",
" | \n",
"\n",
"Cluster\n",
"\n",
" - Workers: 0
\n",
" - Cores: 0
\n",
" - Memory: 0 B
\n",
" \n",
" | \n",
"
\n",
"
"
],
"text/plain": [
""
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from distributed import Client\n",
"client = Client(cluster)\n",
"client"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def sibytesto(bytes, to, bsize=10):\n",
" a = {'k' : 3, 'm': 6, 'g' : 9, 't' : 12}\n",
" return(bytes / pow(bsize, a[to]))\n",
"#Usage: bytesto(size_in_bytes,'g')\n",
"\n",
"#TiB really.\n",
"def bytesto(bytes, to, bsize=2):\n",
" a = {'g' : 30, 't' : 40,'p': 50}\n",
" return(bytes / pow(bsize, a[to]))\n",
"#Usage: bytesto(size_in_bytes,'g')\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Prepare Input: Inventory lists and intake catalog pointers, read operations,etc.
"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"#z_inv_list='s3://s3-inventory-collection/cmip6-pds/s3-inventory-config/hive/dt=2021-04-09-00-00/symlink.txt' #'s3://s3-inventory-collection/cmip6-pds/s3-inventory-config/hive/dt=2021-04-01-00-00/symlink.txt'\n",
"zsym = pd.read_csv(z_inv_list, delimiter='\\n',dtype='unicode',index_col=False,header=None)\n",
"zarr_inventory_dd = dd.read_parquet(zsym[0].tolist(), columns=['key', 'size'], engine='pyarrow',storage_options=dict(anon=True))\n",
"\n",
"\n",
"#TEST ONLY \n",
"zarr_inventory_dd.loc[0:1000000]"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"908246538633815"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"zarr_inventory_dd['size'].sum().compute()"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"826.0454147910559"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"bytesto(908246538633815,'t') #826 TB #This is how much the cmip6-pds CMIP6 prefix holds"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"zarr_inventory_dd=zarr_inventory_dd.repartition(npartitions=40) #zarr_inventory_dd.npartitions\n",
"zarr_inventory_dd=zarr_inventory_dd.set_index('key',drop=False)\n",
"zarr_inventory_dd['vstore'] = zarr_inventory_dd.apply(\n",
" lambda row: '/'.join([row['key'].split('/v20')[0],'v20'+row['key'].split('v20')[-1].split('/')[0]] ),axis =1).compute() "
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"#client.persist(zarr_inventory_dd)\n",
"cluster.scale(25)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"zarr_inventory_dd = zarr_inventory_dd.groupby(['vstore'])['size'].sum(split_out=40)\n",
"zarr_inventory_dd.compute()\n",
"zarr_inventory_dd = zarr_inventory_dd.to_frame()\n",
"zarr_inventory_dd = zarr_inventory_dd.reset_index(drop=False)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"#zarr_cat = 'https://cmip6-pds.s3.amazonaws.com/pangeo-cmip6-noQC.csv.gz' #'https://cmip6-pds.s3.amazonaws.com/compare/pangeo-cmip6-noQC.csv.gz' \n",
"dzarr = pd.read_csv(zarr_cat, dtype='unicode')\n",
"ddzarr = dd.from_pandas(dzarr, npartitions=40)\n",
"ddzarr['vstore'] = ddzarr.apply(lambda row: (row['zstore'].split('s3://cmip6-pds/')[-1].split('v20')[0]+'v'+row.version), axis = 1).compute()\n",
"dzarrtmp = ddzarr.merge(zarr_inventory_dd, on='vstore', how='outer', suffixes=['', '_'], indicator=True)\n",
"dzarr = dzarrtmp[dzarrtmp._merge=='both']\n",
"\n",
"ddzarr_groupby =dzarr.groupby(['zstore','vstore','version','source_id','table_id','institution_id','variable_id','member_id','grid_label','experiment_id'])#.sum('size').compute()\n",
"series_ddzarr = ddzarr_groupby['size'].sum().compute()\n",
"dzarr = series_ddzarr.to_frame()\n",
"dzarr = dzarr.sort_values(by=['version'])\n",
"\n",
"dzarr=dzarr.reset_index(drop=False)\n",
"dzarr['zstore'] = dzarr.apply(lambda row: (row.vstore.split('s3://cmip6-pds/')[-1].split('v20')[0]), axis = 1)\n",
"dzarr['activity_id'] = dzarr.apply(lambda row: row.vstore.split('CMIP6/')[-1].split('/')[0], axis = 1)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Total AWS-netcdf in TB 603.8197385220765\n"
]
}
],
"source": [
"#esgf-world catalog\n",
"#netcdf_cat = 'https://cmip6-nc.s3.us-east-2.amazonaws.com/esgf-world.csv.gz'\n",
"dnc = pd.read_csv(netcdf_cat, dtype='unicode')\n",
"dnc['key'] = dnc.apply(lambda row: row.path.split('s3://esgf-world/')[-1], axis = 1) #Add key or reuse path as needed--since parquet has the key, for merging later on\n",
"#merge dnc and nc_inventory_pd to incorporate size and then remove version duplicates\n",
"\n",
"#n_inv_list = 's3://s3-inventory-dest/esgf-world/cmip6-inventory/hive/dt=2021-04-09-00-00/symlink.txt' #'s3://s3-inventory-dest/esgf-world/cmip6-inventory/hive/dt=2021-03-30-00-00/symlink.txt'\n",
"nsym = pd.read_csv(n_inv_list, delimiter='\\n',dtype='unicode',header=None)\n",
"nc_inventory_pd = pd.concat(map(pd.read_parquet, (nsym[0].tolist()) ))\n",
"if('is_delete_marker' in nc_inventory_pd): nc_inventory_pd=nc_inventory_pd[nc_inventory_pd['is_delete_marker']==False] \n",
"if('is_latest' in nc_inventory_pd): nc_inventory_pd=nc_inventory_pd[nc_inventory_pd['is_latest']==True]\n",
"nc_inventory_pd = nc_inventory_pd[nc_inventory_pd['size'].notna()] \n",
"\n",
"#merge dnetcdf and nc_inventory_pd to incorporate size and then remove version duplicate\n",
"dnctmp = dnc.merge(nc_inventory_pd, on='key', how='outer', suffixes=['', '_'], indicator=True)\n",
"dnetcdf = dnctmp[dnctmp._merge=='both']\n",
"dnetcdf = dnetcdf[dnetcdf['size'].notna()] \n",
"dnetcdf = dnetcdf.drop(['frequency', 'modeling_realm'], axis=1) #since its NA in esgf-world csv\n",
"dnetcdf['zstore'] = dnetcdf.apply(lambda row: row.key.split('s3://esgf-world/')[-1].split('v20')[0], axis = 1)\n",
"dnetcdf['vstore'] = dnetcdf.apply(lambda row: row.zstore + str(row.version)+'/', axis = 1)\n",
"\n",
"\n",
"dnetcdf=dnetcdf.groupby(['zstore','model','version','mip_table','institute','variable','ensemble_member','grid_label','experiment_id'], as_index=False).sum('size') #sum()['size'].sum()\n",
"dnetcdf = dnetcdf.sort_values(by=['version'])\n",
"\n",
"print(\"Total AWS-netcdf in TB\",bytesto(dnetcdf['size'].sum(),'t')) #\n",
"\n",
"dnetcdf = dnetcdf.drop_duplicates(subset=[\"zstore\"],keep='last')\n",
"\n",
"dnetcdf = dnetcdf.rename(columns={\"mip_table\": \"table_id\",\"institute\":\"institution_id\",\"variable\":\"variable_id\"})\n",
"\n",
"dnetcdf['activity_id'] = dnetcdf.apply(lambda row: row.zstore.split('CMIP6/')[-1].split('/')[0], axis = 1)\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Optional QA
\n"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" zstore | \n",
" model | \n",
" version | \n",
" table_id | \n",
" institution_id | \n",
" variable_id | \n",
" ensemble_member | \n",
" grid_label | \n",
" experiment_id | \n",
" size | \n",
" activity_id | \n",
"
\n",
" \n",
" \n",
" \n",
" 73275 | \n",
" CMIP6/CMIP/NOAA-GFDL/GFDL-CM4/historical/r1i1p1f1/Amon/rlus/gr1/ | \n",
" GFDL-CM4 | \n",
" v20180701 | \n",
" Amon | \n",
" NOAA-GFDL | \n",
" rlus | \n",
" r1i1p1f1 | \n",
" gr1 | \n",
" historical | \n",
" 264327907.0 | \n",
" CMIP | \n",
"
\n",
" \n",
"
\n",
"
"
],
"text/plain": [
" zstore \\\n",
"73275 CMIP6/CMIP/NOAA-GFDL/GFDL-CM4/historical/r1i1p1f1/Amon/rlus/gr1/ \n",
"\n",
" model version table_id institution_id variable_id \\\n",
"73275 GFDL-CM4 v20180701 Amon NOAA-GFDL rlus \n",
"\n",
" ensemble_member grid_label experiment_id size activity_id \n",
"73275 r1i1p1f1 gr1 historical 264327907.0 CMIP "
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#VERIFY\n",
"searchval = 'CMIP6/CMIP/NOAA-GFDL/GFDL-CM4/historical/r1i1p1f1/Amon/rlus/gr1/v20180701/'\n",
"dnetcdf.loc[(dnetcdf['version']=='v20180701') & (dnetcdf['institution_id']=='NOAA-GFDL') & (dnetcdf['experiment_id']=='historical') \n",
" & (dnetcdf['table_id'] == 'Amon')\n",
" & (dnetcdf['variable_id'] == 'rlus')]\n",
" \n",
"#size shows aggregate size as desired \n",
"#old version should not be displayed 'v20180701'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Compare buckets \n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Data volumes of cmip6-pds and esgf-world as a whole, considering latest DRS versions"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"AWS-zarr (number of datasets): 355047 AWS-netcdf (number of datasets): 241760 both (number of datasets): 520909\n",
"AWS-netcdf in TB 559.8580954597983\n",
"AWS-zarr in TB 817.5647525450613\n"
]
}
],
"source": [
"#cdzarr = dzarr.reset_index()\n",
"\n",
"set_L = set(dzarr.zstore.unique())\n",
"set_G = set(dnetcdf.zstore.unique())\n",
"\n",
"print('AWS-zarr (number of datasets): ',len(set_L),' AWS-netcdf (number of datasets):', len(set_G),' both (number of datasets):', len(set_G.union(set_L)))\n",
"#LATEST DRS VERSIONS \n",
"print(\"AWS-netcdf in TB\",bytesto(dnetcdf['size'].sum(),'t')) #\n",
"print(\"AWS-zarr in TB\",bytesto(dzarr['size'].sum(),'t')) #"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" Visual Comparison
"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [],
"source": [
"\n",
"dcpp_nc = len(dnetcdf[dnetcdf.activity_id == 'DCPP'])\n",
"dcpp_zarr = len(dzarr[dzarr.activity_id == 'DCPP'])\n",
"#We are not accounting for DCPP at this time since the definition of a dataset is yet to be determined here. \n",
"dZR = dzarr[dzarr.activity_id != 'DCPP']\n",
"dNC = dnetcdf[dnetcdf.activity_id != 'DCPP']\n"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" zstore | \n",
" vstore | \n",
" version | \n",
" source_id | \n",
" table_id | \n",
" institution_id | \n",
" variable_id | \n",
" member_id | \n",
" grid_label | \n",
" experiment_id | \n",
" size | \n",
" activity_id | \n",
"
\n",
" \n",
" \n",
" \n",
"
\n",
"
"
],
"text/plain": [
"Empty DataFrame\n",
"Columns: [zstore, vstore, version, source_id, table_id, institution_id, variable_id, member_id, grid_label, experiment_id, size, activity_id]\n",
"Index: []"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dzarr.columns \n",
"dzarr[dzarr.activity_id =='DCPP']"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"douter = dZR.merge(dNC, on='zstore', how='outer', suffixes=['', '_n'], indicator=True)\n",
"dZR_notNC = douter[douter._merge=='left_only']\n",
"\n",
"dNC_notZR = douter[douter._merge=='right_only']\n",
"\n",
"#d_inner = dZR.merge(dNC, on='zstore', how='inner', suffixes=['_', ''], indicator=True)\n",
"dboth = douter[douter._merge=='both']\n",
"\n",
"dZRnNC = dZR_notNC[['activity_id', 'institution_id', 'source_id', 'experiment_id',\n",
" 'member_id', 'table_id', 'variable_id', 'grid_label', 'zstore','version', \n",
" 'vstore','size']]\n",
"\n",
"dNCnZR = dNC_notZR[['activity_id_n', 'institution_id_n', 'model', 'experiment_id_n',\n",
" 'member_id', 'table_id_n', 'variable_id_n', 'grid_label_n', 'zstore','version_n', \n",
" 'vstore','size_n']] ##check size here\n",
"dNCnZR=dNCnZR.rename(columns={\"size_n\": \"size\",\"activity_id_n\":\"activity_id\",\"institution_id_n\":\"institution_id\",\"model\":\"source_id\",\"experiment_id_n\":\"experiment_id\"\n",
" ,\"table_id_n\":\"table_id\",\"variable_id_n\":\"variable_id\",\"grid_label_n\":\"grid_label\",\"version_n\":\"version\"})\n",
"\n",
"dNCandZR = dboth[['activity_id', 'institution_id', 'source_id', 'experiment_id',\n",
" 'member_id', 'table_id', 'variable_id', 'grid_label', 'zstore','version', \n",
" 'vstore','size']] #consider the zarr size\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {},
"outputs": [],
"source": [
"dZR = dZRnNC.append(dNCandZR)"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {},
"outputs": [],
"source": [
"dNC = dNCnZR.append(dNCandZR)"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [],
"source": [
"#dNCnZR=dNCnZR.rename(columns={\"size_n\": \"size\"})"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"DCPP (netcdf) datasets attribute to 69619\n",
"DCPP (zarr) datasets attribute to 0\n",
"For all activities other than DCPP, total unique datasets from both: 451290\n",
"S3/zarr has: 355047\n",
"S3/netcdf has: 172141\n",
"S3/zarr needs: 96243\n",
"S3/netcdf needs: 279149\n",
"\n",
" What is common in both buckets: 16 %\n"
]
}
],
"source": [
"\n",
"aws_zarr= len(dZR)\n",
"aws_nc = len(dNC)\n",
"zarr_MissingNC = len(dZRnNC)\n",
"nc_MissingZarr = len(dNCnZR)\n",
"in_both = len(dNCandZR) #aws_zarr - zarr_MissingNC\n",
"num_all = aws_zarr+aws_nc-in_both\n",
"\n",
"print('DCPP (netcdf) datasets attribute to', dcpp_nc)\n",
"print('DCPP (zarr) datasets attribute to', dcpp_zarr)\n",
"print('For all activities other than DCPP, total unique datasets from both:', num_all )\n",
"print('S3/zarr has: ',aws_zarr)\n",
"print('S3/netcdf has:',aws_nc)\n",
"print('S3/zarr needs: ',nc_MissingZarr) #guestimate 402TB\n",
"print('S3/netcdf needs:', zarr_MissingNC )#guestimate 540TB\n",
"print('\\n What is common in both buckets:',int(100*(in_both)/num_all),'%') #225TB\n"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"For all activities other than DCPP, size of total unique datasets from both: 1529143508832265.0\n",
"S3/zarr has: 817.5647525450613\n",
"S3/netcdf has: 573.1831670573774\n",
"S3/zarr needs: 359.45603408402985 TB\n",
"S3/netcdf needs: 603.8376195717137 TB\n",
"\n",
" What is common in both buckets: 214 T\n"
]
}
],
"source": [
"dZR_size= dZR['size'].sum()\n",
"dNC_size = dNC['size'].sum()\n",
"dNCnZR_size = dNCnZR['size'].sum()\n",
"dZRnNC_size = dZRnNC['size'].sum()\n",
"\n",
"in_both_size = dNCandZR['size'].sum()\n",
"num_all_size = dZR_size+dNC_size -in_both\n",
"\n",
"\n",
"print('For all activities other than DCPP, size of total unique datasets from both:', num_all_size )\n",
"print('S3/zarr has: ',bytesto(dZR_size,'t'))\n",
"print('S3/netcdf has:',bytesto(dNC_size ,'t'))\n",
"print('S3/zarr needs: ',bytesto(dNCnZR_size,'t'),'TB') #guestimate 402TB\n",
"print('S3/netcdf needs:', bytesto(dZRnNC_size,'t'),'TB')#guestimate 540TB\n",
"print('\\n What is common in both buckets:',round(bytesto(in_both_size,'t')),'T')\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [],
"source": [
"\n",
"def autolabel(ax,rects):\n",
" \"\"\"Attach a text label above each bar in *rects*, displaying its height.\"\"\"\n",
" for rect in rects:\n",
" height = rect.get_height()\n",
" ax.annotate('{}'.format(height),\n",
" xy=(rect.get_x() + rect.get_width() / 2, height),\n",
" xytext=(0, 3), # 3 points vertical offset\n",
" textcoords=\"offset points\",\n",
" ha='center', va='bottom',fontsize=10)"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [],
"source": [
"def plot_facet(df_dict,facet='table_id',top_n=8,ymax=300000,ylabel='number',title_add='',units='t'): \n",
" labels = df_dict.keys()\n",
" stables = set()\n",
" for label in labels:\n",
" stables = stables.union(set(df_dict[label][facet].unique())) \n",
" tables = sorted(list(stables))\n",
" \n",
" vdfs = {}\n",
" for label in labels:\n",
" df = df_dict[label]\n",
" nvdf = []\n",
" for table in tables:\n",
" if(\"volume\" in ylabel):\n",
" ndf = df[df[facet]==table]['size'].sum()\n",
" ndf = round(bytesto(ndf,units))\n",
" else:\n",
" ndf = df[df[facet]==table].zstore.nunique()\n",
" nvdf += [ndf]\n",
" vdfs[label] = nvdf\n",
" \n",
" names = []\n",
" totals = []\n",
" for item,table in enumerate(tables):\n",
" names += [table]\n",
" tsum = 0\n",
" for label in labels:\n",
" tsum += vdfs[label][item]\n",
" totals += [tsum]\n",
"\n",
" num_dict = {'name': names,'total':totals}\n",
" for label in labels:\n",
" num_dict[label] = vdfs[label]\n",
" \n",
" df_nums = pd.DataFrame(num_dict) \n",
" \n",
" df_nums = df_nums.sort_values(by=['total'],ascending=False)\n",
" #df_nums = df_nums.sort_values(by=[list(labels)[1]],ascending=False)\n",
"\n",
" width = 1.0/(1+len(labels)) # the width of the bars\n",
" \n",
" fig, ax = plt.subplots()\n",
"\n",
" names = df_nums.name.values[:top_n]\n",
" x = np.arange(len(names)) \n",
" \n",
" for item,label in enumerate(labels):\n",
" vdf = df_nums[label].values[:top_n]\n",
" rects = ax.bar(x - (len(labels)/2-item-0.5)*width, vdf, width, label=label)\n",
" autolabel(ax,rects)\n",
"\n",
" # Add some text for labels, title and custom x-axis tick labels, etc.\n",
" ax.set_ylabel(ylabel)\n",
" ax.set_title(f'{ylabel} top {top_n} by {facet}'+title_add)\n",
" ax.set_xticks(x)\n",
" ax.set_xticklabels(names)\n",
" ax.set_ylim([0,ymax])\n",
" ax.legend()\n",
"\n",
" fig.tight_layout()\n",
" #plt.savefig(f'compare-{facet}.png')\n",
"\n",
" plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"