plots.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import yaml\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "results_file = ''\n",
    "\n",
    "data = pd.read_csv('')\n",
    "filtered_data = data\n",
    "datasets = filtered_data['dataset.name'].unique()\n",
    "\n",
    "with open('experiment_config.yml') as f:\n",
    "    experiment_config = yaml.full_load(f)\n",
    "datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "paper_replication_experiments = experiment_config['paper_replication_experiments']\n",
    "\n",
    "dataset_to_dataset_choice = {\n",
    "    'FieldGuide28': 'fg28', \n",
    "    'FieldGuide2': 'fg2',\n",
    "    'CIFAR20': 'cifar20',\n",
    "    'CIFAR10': 'cifar10', \n",
    "    'ImageNet50': 'imagenet'\n",
    "}\n",
    "\n",
    "approach_to_metric_map = {\n",
    "    'SCAN' : {\n",
    "        'test_acc': 'scan_alone_best_acc',\n",
    "        'test_err': 'scan_alone_reconstruction_error_L1'\n",
    "    },\n",
    "    'DDFA (SPI)': {\n",
    "        'test_acc': 'test_post_cluster_acc',\n",
    "        'test_err': 'test_post_cluster_p_y_given_d_l1_norm'\n",
    "    },\n",
    "    'DDFA (SI)': {\n",
    "        'test_acc': 'test_post_cluster_acc',\n",
    "        'test_err': 'test_post_cluster_p_y_given_d_l1_norm'\n",
    "    },\n",
    "    'DDFA (RI)': {\n",
    "        'test_acc': 'test_post_cluster_acc',\n",
    "        'test_err': 'test_post_cluster_p_y_given_d_l1_norm'\n",
    "    },\n",
    "    'Naïve': {\n",
    "        'test_acc': 'test_post_cluster_acc',\n",
    "        'test_err': 'test_post_cluster_p_y_given_d_l1_norm'\n",
    "    },\n",
    "    'Naïve (ICA)': {\n",
    "        'test_acc': 'test_post_cluster_acc',\n",
    "        'test_err': 'test_post_cluster_p_y_given_d_l1_norm'\n",
    "    },\n",
    "    'Naïve (PCA)': {\n",
    "        'test_acc': 'test_post_cluster_acc',\n",
    "        'test_err': 'test_post_cluster_p_y_given_d_l1_norm'\n",
    "    },\n",
    "}\n",
    "\n",
    "approaches = {\n",
    "    'CIFAR10': ['SCAN','DDFA (RI)', 'DDFA (SI)'], \n",
    "    'CIFAR20': ['SCAN','DDFA (RI)', 'DDFA (SI)', 'Naïve', 'Naïve (ICA)', 'Naïve (PCA)'], \n",
    "    'ImageNet50': ['SCAN','DDFA (SI)'], \n",
    "    'FieldGuide2': ['SCAN','DDFA (SPI)'], \n",
    "    'FieldGuide28': ['SCAN','DDFA (SPI)'], \n",
    "}\n",
    "\n",
    "approach_to_dd_name = {\n",
    "    'CIFAR10': {\n",
    "        'SCAN': 'scan_scan',\n",
    "        'DDFA (RI)': 'CIFAR10PytorchCifar',\n",
    "        'DDFA (SI)': 'scan_scan'\n",
    "    }, \n",
    "    'CIFAR20': {\n",
    "        'SCAN': 'scan_scan',\n",
    "        'DDFA (RI)': 'CIFAR10PytorchCifar',\n",
    "        'DDFA (SI)': 'scan_scan',\n",
    "        'Naïve': 'scan_scan_naive',\n",
    "        'Naïve (ICA)': 'scan_scan_naive_ica',\n",
    "        'Naïve (PCA)': 'scan_scan_naive_pca',\n",
    "    }, \n",
    "    'ImageNet50': {\n",
    "        'SCAN': 'scan_scan_imagenet',\n",
    "        'DDFA (SI)': 'scan_scan_imagenet'\n",
    "    }, \n",
    "    'FieldGuide2': {\n",
    "        'SCAN': 'scan_pretext',\n",
    "        'DDFA (SPI)': 'scan_pretext',\n",
    "    }, \n",
    "    'FieldGuide28': {\n",
    "        'SCAN': 'scan_pretext',\n",
    "        'DDFA (SPI)': 'scan_pretext',\n",
    "    }, \n",
    "}\n",
    "\n",
    "approach_to_class_prior_estimator_name = copy.deepcopy(approach_to_dd_name)\n",
    "for dataset in approach_to_class_prior_estimator_name:\n",
    "    for approach in approach_to_class_prior_estimator_name[dataset]:\n",
    "        approach_to_class_prior_estimator_name[dataset][approach] = 'ClusterNMFClassPriorEstimation'\n",
    "\n",
    "dataset_to_kappa_list = {\n",
    "    dataset : paper_replication_experiments['datasets'][dataset_to_dataset_choice[dataset]]['max_condition_numbers']\n",
    "    for dataset in datasets\n",
    "}\n",
    "\n",
    "dataset_to_domains = {\n",
    "    dataset : sorted(paper_replication_experiments['datasets'][dataset_to_dataset_choice[dataset]]['domains'])\n",
    "    for dataset in datasets\n",
    "}\n",
    "\n",
    "def compute_metric_agg(d, metric, alpha, approach, dataset):\n",
    "\n",
    "    dd_name = approach_to_dd_name[dataset][approach]\n",
    "    class_prior_estimator_name = approach_to_class_prior_estimator_name[dataset][approach]\n",
    "\n",
    "    # necessary for clustering ablation\n",
    "    main_size_cifar_20 = 20\n",
    "    if dataset == 'CIFAR20' and (approach == 'DDFA (SI)' or approach == 'SCAN'):\n",
    "        rows = filtered_data[(filtered_data['class_prior.n_domains'] == d) & \\\n",
    "                                (filtered_data['class_prior.alpha'] == alpha) & \\\n",
    "                                    (filtered_data['dataset.name'] == dataset) & \\\n",
    "                                        (filtered_data['discriminator.name'] == dd_name) & \\\n",
    "                                            (filtered_data['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                                             (filtered_data['class_prior_estimator.n_discretization'] == main_size_cifar_20)]\n",
    "    else:\n",
    "        rows = filtered_data[(filtered_data['class_prior.n_domains'] == d) & \\\n",
    "                        (filtered_data['class_prior.alpha'] == alpha) & \\\n",
    "                            (filtered_data['dataset.name'] == dataset) & \\\n",
    "                                (filtered_data['discriminator.name'] == dd_name) & \\\n",
    "                                    (filtered_data['class_prior_estimator.name'] == class_prior_estimator_name)]\n",
    "\n",
    "    if len(rows) == 3:\n",
    "        mean_pre_round = float(rows[approach_to_metric_map[approach][metric]].mean())\n",
    "        if metric == 'test_err':\n",
    "            mean_pre_round /= (d * filtered_data[filtered_data['dataset.name'] == dataset]['class_prior.n_classes'].mean())\n",
    "        mean = np.round(mean_pre_round, decimals=3)\n",
    "\n",
    "        std_pre_round = float(rows[approach_to_metric_map[approach][metric]].std())\n",
    "        if metric == 'test_err':\n",
    "            std_pre_round /= (d * filtered_data[filtered_data['dataset.name'] == dataset]['class_prior.n_classes'].mean())\n",
    "        std = np.round(std_pre_round, decimals=3)\n",
    "        return mean, std\n",
    "    else:\n",
    "        return '---', '---'\n",
    "\n",
    "plot_results = {}\n",
    "for dataset in datasets:\n",
    "    metrics_and_metric_names = [('test_acc','Test accuracy'), ('test_err',r'Avg $Q_{Y|D}$ L1 reconstruction error per domain')]\n",
    "    alpha_kappa_list = list(zip([0.5,3,10],dataset_to_kappa_list[dataset]))\n",
    "    domains = dataset_to_domains[dataset]\n",
    "    plot_results[dataset] = {\n",
    "        d : {\n",
    "            metric : {\n",
    "                (alpha, kappa) : {\n",
    "                    approach : compute_metric_agg(d, metric, alpha, approach, dataset)\n",
    "                    for approach in approaches[dataset]\n",
    "                } for alpha, kappa in alpha_kappa_list\n",
    "            } for metric, metric_name in metrics_and_metric_names\n",
    "        } for d in domains\n",
    "    }\n",
    "plot_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print outputs for main results and naive ablation\n",
    "print_std = True\n",
    "print_naive = True\n",
    "for dataset in ['CIFAR10','CIFAR20','ImageNet50','FieldGuide2','FieldGuide28']:\n",
    "    print(dataset)\n",
    "    print('\\n')\n",
    "    for d in dataset_to_domains[dataset]:\n",
    "        for approach in approaches[dataset]:\n",
    "            if not print_naive and 'Naïve' in approach:\n",
    "                continue\n",
    "            format_string = '&'\n",
    "            if approach == 'SCAN':\n",
    "                print('\\midrule')\n",
    "                format_string = f'\\multirow{{2}}{{*}}{{{d}}} &'\n",
    "            format_string += f'{approach}'\n",
    "            for alpha, kappa in list(zip([0.5,3,10],dataset_to_kappa_list[dataset])):\n",
    "                for metric, metric_name in [('test_acc','Test accuracy'), ('test_err',r'Avg $Q_{Y|D}$ L1 reconstruction error per domain')]:\n",
    "                    mean, std = plot_results[dataset][d][metric][(alpha, kappa)][approach]\n",
    "                    if mean == '---' or std == '---':\n",
    "                        format_string += f' & ---'\n",
    "                    else:\n",
    "                        if (metric == 'test_acc' and mean >= max(filter(lambda e : not isinstance(e,str), [plot_results[dataset][d][metric][(alpha, kappa)][approach][0] for approach in approaches[dataset]])  )) or (metric == 'test_err' and mean <= min(filter(lambda e : not isinstance(e,str), [plot_results[dataset][d][metric][(alpha, kappa)][approach][0] for approach in approaches[dataset]]))):\n",
    "                            if print_std:\n",
    "                                format_string += f' & \\\\textbf{{{mean:.3f}}} $\\pm$ {std:.3f} '\n",
    "                            else:\n",
    "                                format_string += f' & \\\\textbf{{{mean:.3f}}}'\n",
    "                        else:\n",
    "                            if print_std:\n",
    "                                format_string += f' & {mean:.3f} $\\pm$ {std:.3f} '\n",
    "                            else:\n",
    "                                format_string += f' & {mean:.3f} '\n",
    "            format_string += ' \\\\\\\\'\n",
    "            print(format_string)\n",
    "    print('\\n\\n\\n\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print poster barplots\n",
    "fig, axes = plt.subplots(4, 2, figsize=(9,10),dpi=1000)\n",
    "domains = dataset_to_domains['FieldGuide28']\n",
    "alpha_kappa_list = list(zip([0.5,3,10],dataset_to_kappa_list['FieldGuide28']))\n",
    "for row, d in enumerate(domains):\n",
    "    for col, (metric, metric_name) in enumerate(metrics_and_metric_names):\n",
    "        ax = axes[row,col]\n",
    "\n",
    "        # https://stackoverflow.com/questions/25812255/row-and-column-headers-in-matplotlibs-subplots\n",
    "        if row == 0:\n",
    "            ax.set_title(metric_name)\n",
    "\n",
    "        if col == 0:\n",
    "            ax.set_ylabel(f'{d} domains', rotation=90, size='large')\n",
    "\n",
    "        # https://matplotlib.org/stable/gallery/lines_bars_and_markers/barchart.html\n",
    "\n",
    "        labels = [f'$\\\\alpha$: {alpha}, $\\\\kappa$: {kappa}' for alpha, kappa in alpha_kappa_list]\n",
    "        scan     = [plot_results['FieldGuide28'][d][metric][(alpha, kappa)]['SCAN'][0] for alpha, kappa in alpha_kappa_list]\n",
    "        ddfa_spi = [plot_results['FieldGuide28'][d][metric][(alpha, kappa)]['DDFA (SPI)'][0] for alpha, kappa in alpha_kappa_list]\n",
    "        x = np.arange(len(alpha_kappa_list))  # the label locations\n",
    "        width = 0.35  # the width of the bars\n",
    "\n",
    "        rects1 = ax.bar(x - width/2, scan, width, label='SCAN')\n",
    "        rects2 = ax.bar(x + width/2, ddfa_spi, width, label='DDFA (SPI)')\n",
    "\n",
    "        # Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "        # ax.set_ylabel('Scores')\n",
    "        # ax.set_title('Semi-synthetic generatio')\n",
    "        ax.set_xticks(x, labels)\n",
    "        if metric == 'test_acc':\n",
    "            ax.set_ylim([0,0.81])\n",
    "        else:\n",
    "            ax.set_ylim([0,2.5])\n",
    "        ax.legend()\n",
    "\n",
    "        ax.bar_label(rects1, padding=3)\n",
    "        ax.bar_label(rects2, padding=3)\n",
    "\n",
    "fig.suptitle('FieldGuide-28 Performance at different domain counts, avg. over 5 trials')\n",
    "fig.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prior = pd.read_csv('prior_lookup.csv')\n",
    "data = pd.read_csv('wandb_export_2023-01-15T10_07_03.702-05_00.csv')\n",
    "\n",
    "def get_prior_cond_number(n_classes, n_domains, alpha, seed, dataframe_lookup):\n",
    "\n",
    "    filtered_data = dataframe_lookup[\n",
    "        (dataframe_lookup['class_prior.n_classes'] == n_classes) & \n",
    "        (dataframe_lookup['class_prior.n_domains'] == n_domains) & \n",
    "        (dataframe_lookup['class_prior.alpha'] == alpha) &\n",
    "        (dataframe_lookup['class_prior.random_seed'] == seed)\n",
    "    ]\n",
    "\n",
    "    lookup_entry = filtered_data.iloc[0]\n",
    "\n",
    "    string_to_parse = lookup_entry['class_prior.matrices.class_prior']\n",
    "    num_classes     = lookup_entry['class_prior.n_classes']\n",
    "    num_domains     = lookup_entry['class_prior.n_domains']\n",
    "\n",
    "    condition_number = lookup_entry['class_prior.condition_number']\n",
    "\n",
    "    return condition_number\n",
    "\n",
    "for i, row in data.iterrows():\n",
    "    cond  = row['class_prior.condition_number']\n",
    "    n_classes     = row['class_prior.n_classes']\n",
    "    n_domains     = row['class_prior.n_domains']\n",
    "    alpha         = row['class_prior.alpha']\n",
    "    seed          = row['class_prior.random_seed']\n",
    "\n",
    "    prior_cond = get_prior_cond_number(n_classes, n_domains, alpha, seed, prior)\n",
    "\n",
    "    assert(cond == prior_cond)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PLOT cluster ablation - accuracy\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv('wandb_export_2023-01-15T10_07_03.702-05_00.csv')\n",
    "\n",
    "d = 20\n",
    "dataset = 'CIFAR20'\n",
    "dd_name = 'scan_scan'\n",
    "class_prior_estimator_name = 'ClusterNMFClassPriorEstimation'\n",
    "\n",
    "ms = [10, 20, 35, 50, 100, 150]\n",
    "alphas = [0.5, 3, 10]\n",
    "\n",
    "plt.figure(figsize=(9,6))\n",
    "\n",
    "colors_1 = ['red','blue','orange']\n",
    "colors_2 = ['green','black','brown']\n",
    "\n",
    "for alpha, color_1, color_2 in zip(alphas, colors_1, colors_2):\n",
    "\n",
    "\n",
    "    attr = 'test_post_cluster_acc'\n",
    "    perfs = [df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr].mean() for m in ms]\n",
    "    std = [df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr].std() for m in ms]\n",
    "    plt.plot(ms, perfs, label=f'alpha {alpha}: DDFA (SI)', color=color_1)\n",
    "    plt.fill_between(ms, [p + s for p,s in zip(perfs, std)], [p - s for p,s in zip(perfs, std)], alpha=0.1, color=color_1)\n",
    "    plt.plot(ms, perfs, 'ko')\n",
    "\n",
    "    for m in ms:\n",
    "        assert(len(df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr]) == 3)\n",
    "\n",
    "    attr = 'scan_alone_best_acc'\n",
    "    perfs = [df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr].mean() for m in ms]\n",
    "    std = [df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr].std() for m in ms]\n",
    "    plt.fill_between(ms, [p + s for p,s in zip(perfs, std)], [p - s for p,s in zip(perfs, std)], alpha=0.1, color=color_2)\n",
    "    plt.plot(ms, perfs, '--', label=f'alpha {alpha}: SCAN', color=color_2)\n",
    "\n",
    "\n",
    "    # plt.plot(ms, perfs, 'ko')\n",
    "\n",
    "\n",
    "plt.title('Test accuracy vs. number of clusters m, on CIFAR20 with 20 domains, across problem settings (alpha)')\n",
    "plt.xticks(np.arange(min(ms), max(ms)+1, 10))\n",
    "plt.legend()\n",
    "plt.xlabel('Number of clusters m')\n",
    "plt.ylabel('Test accuracy')\n",
    "plt.savefig('m_ablation_test_acc.pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PLOT cluster ablation - error\n",
    "\n",
    "plt.clf()\n",
    "plt.figure(figsize=(9,6))\n",
    "colors_1 = ['red','blue','orange']\n",
    "colors_2 = ['green','black','brown']\n",
    "\n",
    "for alpha, color_1, color_2 in zip(alphas, colors_1, colors_2):\n",
    "\n",
    "    for m in ms:\n",
    "        assert(len(df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr]) == 3)\n",
    "\n",
    "    attr = 'test_post_cluster_p_y_given_d_l1_norm'\n",
    "    perfs = [df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr].mean() / (20 * 20) for m in ms]\n",
    "    std = [df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr].std() / (20 * 20) for m in ms]\n",
    "    plt.fill_between(ms, [p + s for p,s in zip(perfs, std)], [p - s for p,s in zip(perfs, std)], alpha=0.1, color=color_1)\n",
    "    plt.plot(ms, perfs, label=f'alpha {alpha}: DDFA (SI)', color=color_1)\n",
    "    plt.plot(ms, perfs, 'ko')\n",
    "\n",
    "    attr = 'scan_alone_reconstruction_error_L1'\n",
    "    perfs = [df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr].mean() / (20 * 20) for m in ms]\n",
    "    std = [df.loc[(df['class_prior.n_domains'] == d) & \\\n",
    "            (df['class_prior.alpha'] == alpha) & \\\n",
    "                (df['dataset.name'] == dataset) & \\\n",
    "                    (df['discriminator.name'] == dd_name) & \\\n",
    "                        (df['class_prior_estimator.name'] == class_prior_estimator_name) & \n",
    "                            (df['class_prior_estimator.n_discretization'] == m)][attr].std() / (20 * 20) for m in ms]\n",
    "    plt.plot(ms, perfs, '--', label=f'alpha {alpha}: SCAN', color=color_2)\n",
    "    plt.fill_between(ms, [p + s for p,s in zip(perfs, std)], [p - s for p,s in zip(perfs, std)], alpha=0.1, color=color_2)\n",
    "\n",
    "    # plt.plot(ms, perfs, 'ko')\n",
    "\n",
    "    if alpha == 10:\n",
    "        print(perfs)\n",
    "\n",
    "\n",
    "\n",
    "plt.title(r'$Q_{Y|D}$ err vs. number of clusters m, on CIFAR20 with 20 domains, across problem settings (alpha)')\n",
    "plt.xticks(np.arange(min(ms), max(ms)+1, 10))\n",
    "plt.legend()\n",
    "plt.xlabel('Number of clusters m')\n",
    "plt.ylabel(r'$Q_{Y|D}$ err')\n",
    "plt.savefig('m_ablation_q_y_d_err.pdf')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "lls-ddfa",
   "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.9.16 (main, Jan 11 2023, 10:02:19) \n[Clang 14.0.6 ]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "5c7e44792bcd163b1d00440ed929d70ccc4fbe689d6fa8f4a26799fa4456c4b7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}