Spaces:
Sleeping
Sleeping
File size: 40,147 Bytes
99a05f0 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 |
{
"cells": [
{
"cell_type": "code",
"execution_count": 22,
"id": "1738c3a5",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"import os.path as osp\n",
"import json\n",
"import os\n",
"\n",
"version = '1'\n",
"out_dir_hico = f'./filtered_data/v_{version}/hico'\n",
"out_dir_vcoco = f'./filtered_data/v_{version}/vcoco'\n",
"out_dir_phosa = f'./filtered_data/v_{version}/phosa_split'\n",
"out_dir_behave = f'./filtered_data/v_{version}/behave_split'\n",
"\n",
"objectwise_img_dict_hico = osp.join(out_dir_hico, 'imgnames_per_object_dict.json')\n",
"objectwise_img_dict_vcoco = osp.join(out_dir_vcoco, 'imgnames_per_object_dict.json')\n",
"\n",
"with open(objectwise_img_dict_hico, 'r') as fp:\n",
" objectwise_img_dict_hico = json.load(fp)\n",
"with open(objectwise_img_dict_vcoco, 'r') as fp:\n",
" objectwise_img_dict_vcoco = json.load(fp)\n",
"\n",
"# sort the dictionary \n",
"objectwise_img_names1 = dict(sorted(objectwise_img_dict_hico.items(), key=lambda x: len(x[1]), reverse=True))\n",
"\n",
"# # Extract object names and image counts\n",
"# obj_names1 = list(objectwise_img_names_hico.keys())\n",
"# print(sorted(obj_names1))\n",
"# image_count1 = [len(objectwise_img_names_hico[obj]) for obj in objectwise_img_names_hico]\n",
"# print(sum(image_count1))\n",
"\n",
"# sort the dictionary \n",
"objectwise_img_names2 = dict(sorted(objectwise_img_dict_vcoco.items(), key=lambda x: len(x[1]), reverse=True))\n",
"\n",
"# # Extract object names and image counts\n",
"# obj_names2 = list(objectwise_img_names_vcoco.keys())\n",
"# print(sorted(obj_names2))\n",
"# image_count2 = [len(objectwise_img_names_vcoco[obj]) for obj in objectwise_img_names_vcoco]\n",
"# print(sum(image_count2))\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "2d6ad5ed",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2119\n",
"saved at ./filtered_data/v_1/phosa_split/imgnames_per_object_dict.json\n"
]
}
],
"source": [
"# Extract image list for object in PHOSA\n",
"def merge_dictionaries(dict1, dict2):\n",
" merged_dict = {}\n",
"\n",
" # Merge values for common keys\n",
" for key in set(dict1.keys()) | set(dict2.keys()):\n",
" merged_dict[key] = list(set(dict1.get(key, [])) | set(dict2.get(key, [])))\n",
"\n",
" return merged_dict\n",
"\n",
"def filter_dictionary(dictionary, keys):\n",
" filtered_dict = {key: dictionary[key] for key in keys if key in dictionary}\n",
" return filtered_dict\n",
"\n",
"phosa_object_names = [\"bat\", \"bench\", \"bicycle\", \"laptop\", \"motorcycle\", \"skateboard\", \"surfboard\", \"tennis\"]\n",
"combined_objectwise_img_names = merge_dictionaries(objectwise_img_names1, objectwise_img_names2)\n",
"phosa_objectwise_img_names = filter_dictionary(combined_objectwise_img_names, phosa_object_names)\n",
"net_img_count = 0\n",
"for v in phosa_objectwise_img_names.values():\n",
" net_img_count += len(v)\n",
"print(net_img_count)\n",
"# Save the object_wise dict\n",
"os.makedirs(out_dir_phosa, exist_ok=True)\n",
"out_path_phosa = osp.join(out_dir_phosa, 'imgnames_per_object_dict.json')\n",
"with open(out_path_phosa, 'w') as fp:\n",
" json.dump(phosa_objectwise_img_names, fp)\n",
" print(f'saved at {out_path_phosa}')\n",
" \n",
" "
]
},
{
"cell_type": "code",
"execution_count": 23,
"id": "3f2a5e62",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"saved at ./filtered_data/v_1/behave_split/imgnames_per_object_dict.json\n"
]
}
],
"source": [
"# Extract image list for object in CHORE\n",
"\n",
"behave_object_names_original = [\"backpack\", \"basketball\", \"boxlarge\", \"boxlong\", \"boxmedium\", \"boxsmall\", \"boxtiny\", \"chairblack\", \"chairwood\", \"keyboard\", \"monitor\", \"plasticcontainer\", \"stool\", \"suitcase\", \"tablesmall\", \"tablesquare\", \"toolbox\", \"trashbin\", \"yogaball\", \"yogamat\"]\n",
"behave_object_names_in_hot = [\"backpack\", \"chair\", \"keyboard\", \"suitcase\"]\n",
"\n",
"combined_objectwise_img_names = merge_dictionaries(objectwise_img_names1, objectwise_img_names2)\n",
"behave_objectwise_img_names = filter_dictionary(combined_objectwise_img_names, behave_object_names_in_hot)\n",
"net_img_count = 0\n",
"for v in behave_objectwise_img_names.values():\n",
" net_img_count += len(v)\n",
"\n",
"# Save the object_wise dict\n",
"os.makedirs(out_dir_behave, exist_ok=True)\n",
"out_path_behave = osp.join(out_dir_behave, 'imgnames_per_object_dict.json')\n",
"with open(out_path_behave, 'w') as fp:\n",
" json.dump(behave_objectwise_img_names, fp)\n",
" print(f'saved at {out_path_behave}')"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "730e9ac2",
"metadata": {},
"outputs": [
{
"ename": "ModuleNotFoundError",
"evalue": "No module named 'seaborn'",
"output_type": "error",
"traceback": [
"\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
"\u001B[0;31mModuleNotFoundError\u001B[0m Traceback (most recent call last)",
"Cell \u001B[0;32mIn[3], line 2\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mmatplotlib\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mpyplot\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m \u001B[38;5;21;01mplt\u001B[39;00m\n\u001B[0;32m----> 2\u001B[0m \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mseaborn\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m \u001B[38;5;21;01msns\u001B[39;00m\n\u001B[1;32m 4\u001B[0m \u001B[38;5;66;03m# sort the dictionary \u001B[39;00m\n\u001B[1;32m 5\u001B[0m objectwise_img_names1 \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mdict\u001B[39m(\u001B[38;5;28msorted\u001B[39m(objectwise_img_names1\u001B[38;5;241m.\u001B[39mitems(), key\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mlambda\u001B[39;00m x: \u001B[38;5;28mlen\u001B[39m(x[\u001B[38;5;241m1\u001B[39m]), reverse\u001B[38;5;241m=\u001B[39m\u001B[38;5;28;01mTrue\u001B[39;00m))\n",
"\u001B[0;31mModuleNotFoundError\u001B[0m: No module named 'seaborn'"
]
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"\n",
"# sort the dictionary \n",
"objectwise_img_names1 = dict(sorted(objectwise_img_names1.items(), key=lambda x: len(x[1]), reverse=True))\n",
"\n",
"# Extract object names and image counts\n",
"obj_names1 = list(objectwise_img_names1.keys())\n",
"print(obj_names1)\n",
"img_counts1 = [len(objectwise_img_names1[obj]) for obj in objectwise_img_names1]\n",
"print(sum(img_counts1))\n",
"\n",
"# sort the dictionary \n",
"objectwise_img_names2 = dict(sorted(objectwise_img_names2.items(), key=lambda x: len(x[1]), reverse=True))\n",
"\n",
"# Extract object names and image counts\n",
"obj_names2 = list(objectwise_img_names2.keys())\n",
"print(obj_names2)\n",
"img_counts2 = [len(objectwise_img_names2[obj]) for obj in objectwise_img_names2]\n",
"print(sum(img_counts2))\n",
"\n",
"# Create a figure with two subplots\n",
"fig, axs = plt.subplots(nrows=2, sharex=True, figsize=(10, 8))\n",
"\n",
"# Plot the first graph in the first subplot\n",
"sns.barplot(x=obj_names1, y=img_counts1, ax=axs[0])\n",
"\n",
"# Add y-axis label to the first subplot\n",
"axs[0].set_ylabel('Number of Images')\n",
"\n",
"# Set the rotation and alignment of x-tick labels in the first subplot\n",
"axs[0].tick_params(axis='x', rotation=45)\n",
"\n",
"# Plot the second graph in the second subplot\n",
"sns.barplot(x=obj_names2, y=img_counts2, ax=axs[1])\n",
"\n",
"# Add x-axis and y-axis labels to the second subplot\n",
"axs[1].set_xlabel('Object')\n",
"axs[1].set_ylabel('Number of Images')\n",
"\n",
"# Set the rotation and alignment of x-tick labels in the second subplot\n",
"axs[1].tick_params(axis='x', rotation=45)\n",
"\n",
"# Save the plot as a high-resolution image file\n",
"out_path = osp.join(out_dir, 'image_per_object_category.png')\n",
"plt.savefig(out_path, dpi=300)\n",
"\n",
"# Show the plot\n",
"plt.show()\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "23c503dd",
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/tmp/ipykernel_135310/1442551168.py:22: UserWarning: FixedFormatter should only be used together with FixedLocator\n",
" ax.set_xticklabels(X1)\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 1000x800 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import matplotlib\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import seaborn as sns\n",
"\n",
"# Create data\n",
"X1 = ['A', 'B', 'C', 'D', 'E']\n",
"Y1 = [10, 15, 20, 25, 30]\n",
"Y2 = [20, 25, 30, 35, 40]\n",
"\n",
"# Set color scheme and font\n",
"colors = sns.color_palette(\"Blues\", 2)\n",
"\n",
"# Create bar plot\n",
"fig, ax = plt.subplots(figsize=(10, 8))\n",
"ax.bar(X1, Y1, color=colors[0], edgecolor='white', linewidth=1)\n",
"ax.bar(X1, Y2, bottom=Y1, color=colors[1], edgecolor='white', linewidth=1)\n",
"\n",
"# Set axis labels and ticks\n",
"ax.set_xlabel('X1')\n",
"ax.set_ylabel('Y')\n",
"ax.set_xticklabels(X1)\n",
"ax.tick_params(axis='both', which='major', labelsize=14)\n",
"ax.grid(axis='y', alpha=0.4)\n",
"\n",
"# Add legend and title\n",
"ax.legend(['Y1', 'Y2'], loc='upper left')\n",
"ax.set_title('Vertical stacked bar graph of Y1 and Y2')\n",
"\n",
"# Save the graph as PDF or PNG\n",
"plt.savefig('vertical_stacked_bar_graph.png', dpi=300, bbox_inches='tight')"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4c055ec7",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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": 5
}
|