{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"nvidiaTeslaT4","dataSources":[{"sourceId":10200,"databundleVersionId":868375,"sourceType":"competition"}],"dockerImageVersionId":30746,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":true}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Doodle Classifier Dataset Preparation\n\n![Doodle Classifier](https://storage.googleapis.com/gweb-cloudblog-publish/images/quick-draw-1u639.max-900x900.PNG)\n\n## Overview\n\nThis notebook prepares a dataset for a doodle classifier. It involves loading and filtering recognized doodle drawings from multiple CSV files, sampling a fixed number of images per class, converting the drawing data from JSON strings to Python objects, and saving the processed images in an organized format.\n\n## Steps\n\n### 1. Loading and Filtering Data\n\n- Load each CSV file containing doodle drawings.\n- Filter to retain only the recognized doodles.\n- Sample a fixed number of images from each class.\n\n### 2. Data Conversion\n\n- Convert the drawing data from JSON format to Python objects.\n\n### 3. Image Generation\n\n- Plot the doodles using Matplotlib.\n- Convert the plots to grayscale images.\n- Save the images using OpenCV.\n\n### 4. Parallel Processing\n\n- Utilize `joblib.Parallel` to speed up the data loading and image processing tasks.\n\n### 5. Organized Storage\n\n- Store the processed images in a structured directory format, with each class having its own folder.\n- Save metadata about the images in a CSV file.\n\n### 6. Compression\n\n- Compress the directory containing the processed images into a ZIP file for easy distribution.\n\n## Functions\n\n### `get_samples(file_path, master_df, no_of_images=5000)`\n\n- Loads data from a CSV file.\n- Filters recognized doodles.\n- Samples a fixed number of images.\n- Concatenates the results into a master dataframe.\n\n### `apply_parallel(df, func, n_jobs=-1)`\n\n- Applies a function in parallel across a dataframe using `joblib.Parallel`.\n\n### `get_imgs(doodle_data)`\n\n- Converts doodle data into grayscale images by plotting the strokes with Matplotlib and converting the plot to an image.\n\n### `save_img(doodle_data, image_path)`\n\n- Saves doodle data as an image to the specified path.\n\n## Usage\n\n1. **Data Loading**:\n    ```python\n    master_df = pd.DataFrame()\n    file_paths = [os.path.join(path, i) for i in os.listdir(path)]\n    for file_path in tqdm(file_paths):\n        master_df = get_samples(file_path, master_df, no_of_images=1000)\n    ```\n\n2. **Data Conversion**:\n    ```python\n    master_df['drawing_pr'] = master_df['drawing'].progress_apply(json.loads)\n    ```\n\n3. **Image Generation**:\n    ```python\n    master_df['drawing_img'] = apply_parallel(master_df['drawing_pr'], get_imgs)\n    ```\n\n4. **Image Saving**:\n    ```python\n    for index, row in master_df.iterrows():\n        save_img(row['drawing_pr'], row['image_path'])\n    ```\n\n5. **Compression**:\n    ```python\n    shutil.make_archive('doodle_images', 'zip', 'data')\n    ```","metadata":{}},{"cell_type":"code","source":"import os\nimport cv2\nimport ast\nimport json\nimport shutil\nimport numpy as np\nimport pandas as pd\nfrom tqdm.notebook import tqdm\n\nfrom joblib import Parallel, delayed\n\nimport matplotlib.pyplot as plt\n\npath = '/kaggle/input/quickdraw-doodle-recognition/train_simplified/'","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2025-11-25T16:05:49.764058Z","iopub.execute_input":"2025-11-25T16:05:49.764355Z","iopub.status.idle":"2025-11-25T16:05:50.367573Z","shell.execute_reply.started":"2025-11-25T16:05:49.764331Z","shell.execute_reply":"2025-11-25T16:05:50.366534Z"},"trusted":true},"outputs":[],"execution_count":1},{"cell_type":"markdown","source":"### 1. Making Single CSV with Fix Number of Samples\n\n#### 1.1) One by One","metadata":{}},{"cell_type":"code","source":"master_df = pd.DataFrame()\n\ndef get_samples(file_path, master_df, no_of_images=5000):\n    df_sim = pd.read_csv(file_path)\n    df_sim = df_sim[df_sim['recognized'] == True]\n    df_sim = df_sim.sample(frac=1).reset_index(drop=True)\n    df_sim = df_sim.head(no_of_images)\n\n    master_df = pd.concat([master_df, df_sim], ignore_index=True)\n\n    return master_df\n\nfile_paths = [os.path.join(path, i) for i in os.listdir(path)]\n\n\n# for file_path in tqdm(file_paths):\n#     master_df = get_samples(file_path, master_df, no_of_images=1000)\n\n# print(master_df.head())","metadata":{"execution":{"iopub.status.busy":"2025-11-25T16:05:50.369198Z","iopub.execute_input":"2025-11-25T16:05:50.369715Z","iopub.status.idle":"2025-11-25T16:05:50.387549Z","shell.execute_reply.started":"2025-11-25T16:05:50.369683Z","shell.execute_reply":"2025-11-25T16:05:50.38671Z"},"trusted":true},"outputs":[],"execution_count":2},{"cell_type":"markdown","source":"#### 1.2) Multiprocessing","metadata":{}},{"cell_type":"code","source":"dataframes = []\nno_of_images = 500\npath = '/kaggle/input/quickdraw-doodle-recognition/train_simplified/'\n\n\ndef get_samples(file_path, no_of_images=5000):\n    df_sim = pd.read_csv(file_path)\n    df_sim = df_sim[df_sim['recognized'] == True]\n    df_sim = df_sim.sample(frac=1).reset_index(drop=True)\n    df_sim = df_sim.head(no_of_images)\n    return df_sim\n\nfile_paths = [os.path.join(path, i) for i in os.listdir(path)]\n\nresults = Parallel(n_jobs=-1)(delayed(get_samples)(file_path, no_of_images = no_of_images) for file_path in tqdm(file_paths))\n\nmaster_df = pd.concat(results, ignore_index=True)\n\nprint(f'Total samples in master dataframe: {len(master_df)}')\n\nmaster_df.to_csv('master_doodle_dataframe.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2025-11-25T16:05:50.388766Z","iopub.execute_input":"2025-11-25T16:05:50.389094Z","iopub.status.idle":"2025-11-25T16:08:09.518884Z","shell.execute_reply.started":"2025-11-25T16:05:50.389065Z","shell.execute_reply":"2025-11-25T16:08:09.518072Z"},"trusted":true},"outputs":[{"output_type":"display_data","data":{"text/plain":"  0%|          | 0/340 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"c693b942c61b4d52b757eab48666ecd5"}},"metadata":{}},{"name":"stdout","text":"Total samples in master dataframe: 136000\n","output_type":"stream"}],"execution_count":3},{"cell_type":"markdown","source":"#### 1.3) Loading the Strokes","metadata":{}},{"cell_type":"code","source":"tqdm.pandas()\n\nmaster_df['drawing'] = master_df['drawing'].progress_apply(json.loads)\n\ndel master_df['timestamp']\n\nmaster_df.to_csv('master_doodle_dataframe.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2025-11-25T16:08:09.520768Z","iopub.execute_input":"2025-11-25T16:08:09.521047Z","iopub.status.idle":"2025-11-25T16:08:15.511506Z","shell.execute_reply.started":"2025-11-25T16:08:09.52102Z","shell.execute_reply":"2025-11-25T16:08:15.510741Z"},"trusted":true},"outputs":[{"output_type":"display_data","data":{"text/plain":"  0%|          | 0/136000 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"2fe4b862d0984a9d90053bdcd5dae62d"}},"metadata":{}}],"execution_count":4},{"cell_type":"markdown","source":"#### 1.4) Sample Image","metadata":{}},{"cell_type":"code","source":"doodle_data = master_df['drawing'][100]\n\nfor stroke in doodle_data:\n    x, y = stroke\n    \n    plt.plot(x,y)\n\nplt.gca().invert_yaxis()\nplt.axis('equal')\nplt.show()","metadata":{"execution":{"iopub.status.busy":"2025-11-25T16:08:15.512603Z","iopub.execute_input":"2025-11-25T16:08:15.512927Z","iopub.status.idle":"2025-11-25T16:08:15.743958Z","shell.execute_reply.started":"2025-11-25T16:08:15.512893Z","shell.execute_reply":"2025-11-25T16:08:15.743227Z"},"trusted":true},"outputs":[{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}],"execution_count":5},{"cell_type":"markdown","source":"#### 1.5) Creating Images from Strokes","metadata":{}},{"cell_type":"code","source":"def get_imgs(doodle_data):\n    \n    fig, ax = plt.subplots(figsize=(2.55, 2.55))\n\n    for stroke in doodle_data:\n        x, y = stroke  \n        plt.plot(x,y)\n\n    plt.gca().invert_yaxis()\n    ax.axis('off')\n\n    fig.canvas.draw()\n    image = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n    image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n    plt.close(fig)\n\n    image_gray= cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n\n    return image_gray\n\nplt.imshow(get_imgs(master_df['drawing'][100]),cmap = 'gray')\n\n# tqdm.pandas()\n# df_sim['drawing_img'] = master_df['drawing_pr'].progress_apply(get_imgs)","metadata":{"execution":{"iopub.status.busy":"2025-11-25T16:08:15.745247Z","iopub.execute_input":"2025-11-25T16:08:15.745818Z","iopub.status.idle":"2025-11-25T16:08:16.027176Z","shell.execute_reply.started":"2025-11-25T16:08:15.745788Z","shell.execute_reply":"2025-11-25T16:08:16.026368Z"},"trusted":true},"outputs":[{"execution_count":6,"output_type":"execute_result","data":{"text/plain":"<matplotlib.image.AxesImage at 0x7df1437df040>"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 640x480 with 1 Axes>","image/png":"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"},"metadata":{}}],"execution_count":6},{"cell_type":"markdown","source":"#### 1.6) Loading Images in Parallel","metadata":{}},{"cell_type":"code","source":"def get_imgs(doodle_data):\n    fig, ax = plt.subplots(figsize=(2.55, 2.55))\n\n    for stroke in doodle_data:\n        x, y = stroke  \n        plt.plot(x, y)\n\n    plt.gca().invert_yaxis()\n    ax.axis('off')\n\n    fig.canvas.draw()\n    image = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n    image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n    plt.close(fig)\n\n    image_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n\n    return image_gray\n\n# tqdm.pandas()\n\n# def apply_parallel(df, func, n_jobs=-1):\n#     results = Parallel(n_jobs=n_jobs)(delayed(func)(doodle) for doodle in tqdm(df))\n#     return results\n\n# # master_df['drawing_img'] = apply_parallel(master_df['drawing'], get_imgs)\n\n# # master_df.to_csv('master_doodle_dataframe.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2025-11-25T16:08:16.028477Z","iopub.execute_input":"2025-11-25T16:08:16.029121Z","iopub.status.idle":"2025-11-25T16:08:16.034759Z","shell.execute_reply.started":"2025-11-25T16:08:16.02909Z","shell.execute_reply":"2025-11-25T16:08:16.033903Z"},"trusted":true},"outputs":[],"execution_count":7},{"cell_type":"markdown","source":"#### 1.7) Creating Folder for each Class","metadata":{}},{"cell_type":"code","source":"base_dir = 'data'\nos.makedirs(base_dir, exist_ok=True)\n\nfor label in master_df['word'].unique():\n    os.makedirs(os.path.join(base_dir, label), exist_ok=True)","metadata":{"execution":{"iopub.status.busy":"2025-11-25T16:08:16.035911Z","iopub.execute_input":"2025-11-25T16:08:16.036514Z","iopub.status.idle":"2025-11-25T16:08:16.064634Z","shell.execute_reply.started":"2025-11-25T16:08:16.036452Z","shell.execute_reply":"2025-11-25T16:08:16.063843Z"},"trusted":true},"outputs":[],"execution_count":8},{"cell_type":"markdown","source":"#### 1.8) Saving Images in Folders","metadata":{}},{"cell_type":"code","source":"def save_img(doodle_data, image_path):\n    fig, ax = plt.subplots(figsize=(2.55, 2.55))\n\n    for stroke in doodle_data:\n        x, y = stroke  \n        plt.plot(x, y)\n\n    plt.gca().invert_yaxis()\n    ax.axis('off')\n\n    fig.canvas.draw()\n    image = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n    image = image.reshape(fig.canvas.get_width_height()[::-1] + (3,))\n    plt.close(fig)\n\n    image_gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n    cv2.imwrite(image_path, image_gray)\n\n\ndef apply_parallel(df, func, n_jobs=-1):\n    Parallel(n_jobs=n_jobs)(delayed(func)(doodle, path) for doodle, path in tqdm(zip(df['drawing'], df['image_path']), total=len(df)))\n\n\nmaster_df['image_path'] = master_df.apply(lambda row: os.path.join(base_dir, row['word'], f\"{row['key_id']}.png\"), axis=1)\n\napply_parallel(master_df, save_img)\n\nmaster_df.to_csv('master_doodle_dataframe.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2025-11-25T16:08:16.065591Z","iopub.execute_input":"2025-11-25T16:08:16.065791Z","execution_failed":"2025-11-25T16:17:13.298Z"},"trusted":true},"outputs":[{"output_type":"display_data","data":{"text/plain":"  0%|          | 0/136000 [00:00<?, ?it/s]","application/vnd.jupyter.widget-view+json":{"version_major":2,"version_minor":0,"model_id":"760cba582fe045c6b0bfde945ab344a2"}},"metadata":{}}],"execution_count":null},{"cell_type":"markdown","source":"#### 1.9) Zipping Images","metadata":{}},{"cell_type":"code","source":"shutil.make_archive('doodle', 'zip', base_dir)","metadata":{"trusted":true,"execution":{"execution_failed":"2025-11-25T16:17:13.298Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## Conclusion\n\nThis notebook provides a comprehensive pipeline for preparing a doodle dataset, making it ready for machine learning tasks. By leveraging parallel processing and efficient data handling techniques, it ensures that the dataset is clean, balanced, and easy to use.","metadata":{}}]}