Upload 3 files

image_dataset.ipynb

@@ -0,0 +1,765 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import requests\n",
+    "import zipfile\n",
+    "import io\n",
+    "import os\n",
+    "import shutil\n",
+    "from PIL import Image as PILImage, ImageFile\n",
+    "from tqdm import tqdm\n",
+    "from datasets import Dataset, Features, Value, Image, load_dataset\n",
+    "from huggingface_hub import login, HfApi\n",
+    "import cv2\n",
+    "import concurrent.futures\n",
+    "import csv"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Allow loading of truncated images\n",
+    "ImageFile.LOAD_TRUNCATED_IMAGES = True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def read_excel_and_get_urls(excel_file):\n",
+    "    \"\"\"\n",
+    "    Read Excel file and extract URLs, tilenames, and zones\n",
+    "    \n",
+    "    Args:\n",
+    "        excel_file: Path to Excel file\n",
+    "    \n",
+    "    Returns:\n",
+    "        DataFrame with TILENAME, ZONE, URL columns\n",
+    "    \"\"\"\n",
+    "    print(f\"Reading Excel file: {excel_file}\")\n",
+    "    df = pd.read_excel(excel_file)\n",
+    "    \n",
+    "    # Ensure expected columns exist\n",
+    "    required_columns = ['TILENAME', 'ZONE', 'URL']\n",
+    "    for col in required_columns:\n",
+    "        if col not in df.columns:\n",
+    "            raise ValueError(f\"Required column '{col}' not found in Excel file.\")\n",
+    "    \n",
+    "    print(f\"Found {len(df)} entries in Excel file\")\n",
+    "    return df\n",
+    "\n",
+    "def extract_filename_from_url(url):\n",
+    "    \"\"\"\n",
+    "    Extract the base filename from the URL\n",
+    "    \n",
+    "    Args:\n",
+    "        url: URL of the zip file\n",
+    "    \n",
+    "    Returns:\n",
+    "        Base filename without extension\n",
+    "    \"\"\"\n",
+    "    # Extract filename from URL\n",
+    "    # This may need adjustment based on the URL format\n",
+    "    filename = url.split('/')[-1]\n",
+    "    # Remove .zip extension if present\n",
+    "    if filename.lower().endswith('.zip'):\n",
+    "        filename = os.path.splitext(filename)[0]\n",
+    "    return filename\n",
+    "\n",
+    "\n",
+    "def download_and_extract_jp2(tilename, zone, url, jp2_dir):\n",
+    "    \"\"\"\n",
+    "    Download a zip file from the given URL and extract only the JP2 image file\n",
+    "    \n",
+    "    Args:\n",
+    "        tilename: Name of the tile\n",
+    "        zone: Zone identifier\n",
+    "        url: URL to the zip file\n",
+    "        jp2_dir: Directory to save JP2 images\n",
+    "    \n",
+    "    Returns:\n",
+    "        Dictionary with image information (jp2_path, tilename, zone)\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        # Download the zip file\n",
+    "        response = requests.get(url, stream=True)\n",
+    "        \n",
+    "        if response.status_code != 200:\n",
+    "            print(f\"Failed to download {tilename}: {response.status_code}\")\n",
+    "            return None\n",
+    "        \n",
+    "        # Ensure JP2 directory exists\n",
+    "        os.makedirs(jp2_dir, exist_ok=True)\n",
+    "        \n",
+    "        # Extract image files\n",
+    "        with zipfile.ZipFile(io.BytesIO(response.content)) as zip_ref:\n",
+    "            # Get all files in the zip\n",
+    "            all_files = zip_ref.namelist()\n",
+    "            \n",
+    "            # Filter for JP2 image files\n",
+    "            jp2_files = [f for f in all_files if f.lower().endswith('.jp2')]\n",
+    "            \n",
+    "            if not jp2_files:\n",
+    "                print(f\"No JP2 files found in {tilename} zip\")\n",
+    "                return None\n",
+    "            \n",
+    "            # Get the first JP2 file (assuming one image per zip)\n",
+    "            jp2_file = jp2_files[0]\n",
+    "            jp2_filename = os.path.basename(jp2_file)\n",
+    "            jp2_path = os.path.join(jp2_dir, jp2_filename)\n",
+    "            \n",
+    "            # Extract JP2 file\n",
+    "            with zip_ref.open(jp2_file) as source, open(jp2_path, 'wb') as target:\n",
+    "                shutil.copyfileobj(source, target)\n",
+    "            \n",
+    "            return {\n",
+    "                \"jp2_path\": jp2_path,\n",
+    "                \"tilename\": tilename,\n",
+    "                \"zone\": zone\n",
+    "            }\n",
+    "            \n",
+    "    except Exception as e:\n",
+    "        print(f\"Error processing {tilename}: {e}\")\n",
+    "        return None\n",
+    "    \n",
+    "def process_file(jp2_path, jpeg_path):\n",
+    "    try:\n",
+    "        # Read JP2 image\n",
+    "        img = cv2.imread(jp2_path)\n",
+    "        \n",
+    "        # Check if the image is read properly\n",
+    "        if img is None:\n",
+    "            print(f\"Error reading {jp2_path}, skipping.\")\n",
+    "            return\n",
+    "            \n",
+    "        # Save as JPEG\n",
+    "        cv2.imwrite(jpeg_path, img, [int(cv2.IMWRITE_JPEG_QUALITY), 95])\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error converting {jp2_path}: {e}\")\n",
+    "\n",
+    "def convert_jp2_to_jpeg(jp2_dir, jpeg_dir, max_workers=4):\n",
+    "    \"\"\"\n",
+    "    Convert all JP2 files in a directory to JPEG using OpenCV with multithreading.\n",
+    "    \n",
+    "    Args:\n",
+    "        jp2_dir: Directory containing JP2 files\n",
+    "        jpeg_dir: Directory to save converted JPEG images\n",
+    "        max_workers: Number of threads to use for processing\n",
+    "    \"\"\"\n",
+    "    # Ensure output directory exists\n",
+    "    os.makedirs(jpeg_dir, exist_ok=True)\n",
+    "    \n",
+    "    # Get all JP2 files\n",
+    "    input_files = [f for f in os.listdir(jp2_dir) if f.lower().endswith('.jp2') and f != '.DS_Store']\n",
+    "    \n",
+    "    print(f\"Found {len(input_files)} JP2 files to convert\")\n",
+    "    \n",
+    "    # Prepare task list\n",
+    "    tasks = []\n",
+    "    for f in input_files:\n",
+    "        jp2_path = os.path.join(jp2_dir, f)\n",
+    "        jpeg_filename = os.path.splitext(f)[0] + \".jpg\"\n",
+    "        jpeg_path = os.path.join(jpeg_dir, jpeg_filename)\n",
+    "        \n",
+    "        # Skip if already processed\n",
+    "        if os.path.isfile(jpeg_path):\n",
+    "            print(f\"Already processed: {f}\")\n",
+    "            continue\n",
+    "            \n",
+    "        tasks.append((jp2_path, jpeg_path))\n",
+    "    \n",
+    "    # Process files in parallel\n",
+    "    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:\n",
+    "        list(tqdm(executor.map(lambda args: process_file(*args), tasks), total=len(tasks), desc=\"Converting JP2 to JPEG\"))\n",
+    "\n",
+    "def convert_jp2_to_jpeg(jp2_dir, jpeg_dir):\n",
+    "    \"\"\"\n",
+    "    Convert all JP2 files in a directory to JPEG using OpenCV.\n",
+    "    \n",
+    "    Args:\n",
+    "        jp2_dir: Directory containing JP2 files\n",
+    "        jpeg_dir: Directory to save converted JPEG images\n",
+    "    \"\"\"\n",
+    "    # Ensure output directory exists\n",
+    "    os.makedirs(jpeg_dir, exist_ok=True)\n",
+    "    \n",
+    "    # Get all JP2 files\n",
+    "    input_files = [f for f in os.listdir(jp2_dir) if f.lower().endswith('.jp2') and f != '.DS_Store']\n",
+    "    \n",
+    "    print(f\"Found {len(input_files)} JP2 files to convert\")\n",
+    "    \n",
+    "    # Process files\n",
+    "    for f in tqdm(input_files, desc=\"Converting JP2 to JPEG\"):\n",
+    "        try:\n",
+    "            jp2_path = os.path.join(jp2_dir, f)\n",
+    "            jpeg_filename = os.path.splitext(f)[0] + \".jpg\"\n",
+    "            jpeg_path = os.path.join(jpeg_dir, jpeg_filename)\n",
+    "            \n",
+    "            # Skip if already processed\n",
+    "            if os.path.isfile(jpeg_path):\n",
+    "                print(f\"Already processed: {f}\")\n",
+    "                continue\n",
+    "                \n",
+    "            # Read JP2 image\n",
+    "            img = cv2.imread(jp2_path)\n",
+    "            \n",
+    "            # Check if the image is read properly\n",
+    "            if img is None:\n",
+    "                print(f\"Error reading {f}, skipping.\")\n",
+    "                continue\n",
+    "                \n",
+    "            # Save as JPEG\n",
+    "            cv2.imwrite(jpeg_path, img, [int(cv2.IMWRITE_JPEG_QUALITY), 95])\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error converting {f}: {e}\")\n",
+    "\n",
+    "def convert_jp2_to_jpeg(jp2_dir, jpeg_dir):\n",
+    "    \"\"\"\n",
+    "    Convert all JP2 files in a directory to JPEG\n",
+    "    \n",
+    "    Args:\n",
+    "        jp2_dir: Directory containing JP2 files\n",
+    "        jpeg_dir: Directory to save converted JPEG images\n",
+    "    \"\"\"\n",
+    "    # Ensure directories exist\n",
+    "    if not os.path.exists(jpeg_dir):\n",
+    "        os.makedirs(jpeg_dir)\n",
+    "    if not os.path.exists(jp2_dir):\n",
+    "        os.makedirs(jp2_dir)\n",
+    "    \n",
+    "    # Get all JP2 files\n",
+    "    input_files = os.listdir(jp2_dir)\n",
+    "    input_files = [f for f in input_files if f.lower().endswith('.jp2') and f != '.DS_Store']\n",
+    "    \n",
+    "    print(f\"Found {len(input_files)} JP2 files to convert\")\n",
+    "    \n",
+    "    # Process files one by one\n",
+    "    for f in tqdm(input_files, desc=\"Converting JP2 to JPEG\"):\n",
+    "        try:\n",
+    "            jp2_path = os.path.join(jp2_dir, f)\n",
+    "            jpeg_filename = os.path.splitext(f)[0] + \".jpg\"\n",
+    "            jpeg_path = os.path.join(jpeg_dir, jpeg_filename)\n",
+    "            \n",
+    "            # Skip if already processed\n",
+    "            if os.path.isfile(jpeg_path):\n",
+    "                print(f\"Already processed: {f}\")\n",
+    "                continue\n",
+    "                \n",
+    "            # Open and convert the image\n",
+    "            im = PILImage.open(jp2_path)\n",
+    "            if im.mode != 'RGB':\n",
+    "                im = im.convert('RGB')\n",
+    "            \n",
+    "            # Save as JPEG\n",
+    "            im.save(jpeg_path, 'JPEG', quality=95)\n",
+    "            im.close()\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error converting {f}: {e}\")\n",
+    "\n",
+    "def recreate_image_info_list(excel_file, jpeg_dir):\n",
+    "    \"\"\"\n",
+    "    Recreate image_info_list by matching jpeg files with Excel entries\n",
+    "    \n",
+    "    Args:\n",
+    "        excel_file: Path to Excel file\n",
+    "        jpeg_dir: Directory containing JPEG files\n",
+    "    \n",
+    "    Returns:\n",
+    "        List of dictionaries with image information\n",
+    "    \"\"\"\n",
+    "    # Read Excel file\n",
+    "    df = read_excel_and_get_urls(excel_file)\n",
+    "    \n",
+    "    # Create mapping from filename to tilename and zone\n",
+    "    filename_to_metadata = {}\n",
+    "    \n",
+    "    # Try different approaches to match filenames\n",
+    "    for _, row in df.iterrows():\n",
+    "        tilename = row['TILENAME']\n",
+    "        zone = row['ZONE']\n",
+    "        url = row['URL']\n",
+    "        \n",
+    "        # Extract filename from URL as a potential match criterion\n",
+    "        extracted_filename = extract_filename_from_url(url)\n",
+    "        filename_to_metadata[extracted_filename] = {'tilename': tilename, 'zone': zone}\n",
+    "        \n",
+    "        # Also map the tilename directly as another potential match\n",
+    "        filename_to_metadata[tilename] = {'tilename': tilename, 'zone': zone}\n",
+    "    \n",
+    "    # Get all JPEG files\n",
+    "    jpeg_files = [f for f in os.listdir(jpeg_dir) if f.lower().endswith('.jpg') or f.lower().endswith('.jpeg')]\n",
+    "    print(f\"Found {len(jpeg_files)} JPEG files in the directory\")\n",
+    "    \n",
+    "    # Match JPEG files to metadata\n",
+    "    image_info_list = []\n",
+    "    unmatched_files = []\n",
+    "    \n",
+    "    for jpeg_file in tqdm(jpeg_files, desc=\"Matching JPEG files to metadata\"):\n",
+    "        jpeg_path = os.path.join(jpeg_dir, jpeg_file)\n",
+    "        base_name = os.path.splitext(jpeg_file)[0]\n",
+    "        \n",
+    "        # Try different matching strategies\n",
+    "        metadata = None\n",
+    "        \n",
+    "        # Direct match with the extracted filename\n",
+    "        if base_name in filename_to_metadata:\n",
+    "            metadata = filename_to_metadata[base_name]\n",
+    "        else:\n",
+    "            # Try partial matches\n",
+    "            matched_keys = [key for key in filename_to_metadata.keys() if key in base_name or base_name in key]\n",
+    "            if matched_keys:\n",
+    "                # Use the first match if multiple found\n",
+    "                metadata = filename_to_metadata[matched_keys[0]]\n",
+    "        \n",
+    "        if metadata:\n",
+    "            image_info_list.append({\n",
+    "                \"path\": jpeg_path,\n",
+    "                \"tilename\": metadata['tilename'],\n",
+    "                \"zone\": metadata['zone']\n",
+    "            })\n",
+    "        else:\n",
+    "            unmatched_files.append(jpeg_file)\n",
+    "    \n",
+    "    print(f\"Successfully matched {len(image_info_list)} JPEG files with metadata\")\n",
+    "    \n",
+    "    if unmatched_files:\n",
+    "        print(f\"Warning: Could not match {len(unmatched_files)} files with metadata\")\n",
+    "        if len(unmatched_files) < 10:\n",
+    "            print(\"Unmatched files:\", unmatched_files)\n",
+    "        else:\n",
+    "            print(\"First 10 unmatched files:\", unmatched_files[:10])\n",
+    "    \n",
+    "    return image_info_list\n",
+    "\n",
+    "\n",
+    "def organize_images_for_imagefolder(excel_file, jpeg_dir, output_dir, rename_instead_of_copy=True):\n",
+    "    \"\"\"\n",
+    "    Organize images and create metadata for ImageFolder format\n",
+    "    \n",
+    "    Args:\n",
+    "        excel_file: Path to Excel file with metadata\n",
+    "        jpeg_dir: Directory containing JPEG files\n",
+    "        output_dir: Directory to save organized images and metadata\n",
+    "        rename_instead_of_copy: If True, rename/move files instead of copying them\n",
+    "    \n",
+    "    Returns:\n",
+    "        Path to the organized dataset directory\n",
+    "    \"\"\"\n",
+    "    print(f\"Reading Excel file: {excel_file}\")\n",
+    "    df = pd.read_excel(excel_file)\n",
+    "    \n",
+    "    # Ensure required columns exist\n",
+    "    required_columns = ['TILENAME', 'ZONE', 'URL']\n",
+    "    for col in required_columns:\n",
+    "        if col not in df.columns:\n",
+    "            raise ValueError(f\"Required column '{col}' not found in Excel file.\")\n",
+    "    \n",
+    "    # Use the JPEG directory as the train directory if we're renaming\n",
+    "    if rename_instead_of_copy:\n",
+    "        # Create parent directory if it doesn't exist\n",
+    "        os.makedirs(output_dir, exist_ok=True)\n",
+    "        \n",
+    "        # Just rename the jpeg_dir to be inside the output_dir\n",
+    "        train_dir = os.path.join(output_dir, \"train\")\n",
+    "        \n",
+    "        # If the train directory already exists but is different from jpeg_dir, handle it\n",
+    "        if os.path.exists(train_dir) and os.path.abspath(train_dir) != os.path.abspath(jpeg_dir):\n",
+    "            response = input(f\"Train directory {train_dir} already exists. Do you want to replace it? (yes/no): \")\n",
+    "            if response.lower() == 'yes':\n",
+    "                shutil.rmtree(train_dir)\n",
+    "            else:\n",
+    "                print(\"Using existing train directory.\")\n",
+    "                \n",
+    "        # If train_dir doesn't exist, rename jpeg_dir to train_dir\n",
+    "        if not os.path.exists(train_dir):\n",
+    "            print(f\"Renaming directory {jpeg_dir} to {train_dir}\")\n",
+    "            shutil.move(jpeg_dir, train_dir)\n",
+    "        # If jpeg_dir is already the train_dir, do nothing\n",
+    "        elif os.path.abspath(train_dir) == os.path.abspath(jpeg_dir):\n",
+    "            print(f\"JPEG directory is already {train_dir}, no renaming needed\")\n",
+    "    else:\n",
+    "        # Create the output directory structure for copying\n",
+    "        os.makedirs(output_dir, exist_ok=True)\n",
+    "        train_dir = os.path.join(output_dir, \"train\")\n",
+    "        os.makedirs(train_dir, exist_ok=True)\n",
+    "    \n",
+    "    # Get all JPEG files\n",
+    "    jpeg_files = [f for f in os.listdir(train_dir) if f.lower().endswith('.jpg') or f.lower().endswith('.jpeg')]\n",
+    "    print(f\"Found {len(jpeg_files)} JPEG files\")\n",
+    "    \n",
+    "    # Create a mapping of filename to metadata\n",
+    "    filename_to_metadata = {}\n",
+    "    for _, row in df.iterrows():\n",
+    "        tilename = row['TILENAME']\n",
+    "        zone = row['ZONE']\n",
+    "        # Use both the full tilename and the base name for matching\n",
+    "        filename_to_metadata[tilename] = {'tilename': tilename, 'zone': zone}\n",
+    "        filename_to_metadata[os.path.basename(tilename)] = {'tilename': tilename, 'zone': zone}\n",
+    "    \n",
+    "    # Create metadata.csv file\n",
+    "    metadata_path = os.path.join(train_dir, \"metadata.csv\")\n",
+    "    with open(metadata_path, 'w', newline='') as csvfile:\n",
+    "        fieldnames = ['file_name', 'tilename', 'zone']\n",
+    "        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)\n",
+    "        writer.writeheader()\n",
+    "        \n",
+    "        # Add files to metadata\n",
+    "        successful_matches = 0\n",
+    "        for jpeg_file in tqdm(jpeg_files, desc=\"Creating metadata for images\"):\n",
+    "            # Try to match the image to metadata\n",
+    "            base_name = os.path.splitext(jpeg_file)[0]\n",
+    "            \n",
+    "            # Find matching metadata using different strategies\n",
+    "            metadata = None\n",
+    "            if base_name in filename_to_metadata:\n",
+    "                metadata = filename_to_metadata[base_name]\n",
+    "            else:\n",
+    "                # Try partial matches\n",
+    "                matched_keys = [key for key in filename_to_metadata.keys() \n",
+    "                                if key in base_name or base_name in key]\n",
+    "                if matched_keys:\n",
+    "                    metadata = filename_to_metadata[matched_keys[0]]\n",
+    "            \n",
+    "            if metadata:\n",
+    "                # Add to metadata.csv\n",
+    "                writer.writerow({\n",
+    "                    'file_name': jpeg_file,\n",
+    "                    'tilename': metadata['tilename'],\n",
+    "                    'zone': metadata['zone']\n",
+    "                })\n",
+    "                successful_matches += 1\n",
+    "            else:\n",
+    "                print(f\"Could not find metadata for {jpeg_file}\")\n",
+    "        \n",
+    "        print(f\"Successfully matched {successful_matches} images with metadata\")\n",
+    "    \n",
+    "    return output_dir\n",
+    "\n",
+    "def upload_dataset_to_hub(dataset_dir, repo_name):\n",
+    "    \"\"\"\n",
+    "    Upload the dataset to the Hugging Face Hub\n",
+    "    \n",
+    "    Args:\n",
+    "        dataset_dir: Directory containing the organized dataset\n",
+    "        repo_name: Name of the repository on Hugging Face Hub\n",
+    "    \"\"\"\n",
+    "    # Load the dataset using ImageFolder\n",
+    "    print(f\"Loading dataset from {dataset_dir}\")\n",
+    "    dataset = load_dataset(\"imagefolder\", data_dir=dataset_dir)\n",
+    "    \n",
+    "    # Push to Hugging Face Hub\n",
+    "    print(f\"Pushing dataset to Hugging Face Hub: {repo_name}\")\n",
+    "    dataset.push_to_hub(repo_name)\n",
+    "    print(\"Dataset uploaded successfully!\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Step 4: Creating image info list\n",
+      "Reading Excel file: /fsx/avijit/projects/datacommonsMA/massgis_2023_aerial_imagery/COQ2023INDEX_POLY.xlsx\n",
+      "Found 10218 entries in Excel file\n",
+      "Found 10218 JPEG files in the directory\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Matching JPEG files to metadata: 100%|█████████████████| 10218/10218 [00:00<00:00, 616174.46it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Successfully matched 10218 JPEG files with metadata\n",
+      "Found 10218 matched JPEG files\n",
+      "Step 5: Deleting JP2 files...\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "JP2 files deleted\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Excel file path\n",
+    "excel_file = \"/fsx/avijit/projects/datacommonsMA/massgis_2023_aerial_imagery/COQ2023INDEX_POLY.xlsx\"\n",
+    "\n",
+    "# Define directories\n",
+    "base_dir = \"/fsx/avijit/projects/datacommonsMA/massgis_2023_aerial_imagery\"\n",
+    "output_dir = \"/fsx/avijit/projects/datacommonsMA/massgis_2023_aerial_imagery/imagefolder-dataset\"\n",
+    "\n",
+    "jp2_dir = os.path.join(base_dir, \"jp2-files\")\n",
+    "jpeg_dir = os.path.join(base_dir, \"jpeg-files\")\n",
+    "\n",
+    "# Ensure directories exist\n",
+    "os.makedirs(jp2_dir, exist_ok=True)\n",
+    "os.makedirs(jpeg_dir, exist_ok=True)\n",
+    "\n",
+    "Step 1: Read Excel file\n",
+    "print(\"Step 1: Reading Excel file\")\n",
+    "df = read_excel_and_get_urls(excel_file)\n",
+    "\n",
+    "# Step 2: Download and extract JP2 files\n",
+    "print(\"Step 2: Downloading and extracting JP2 files\")\n",
+    "jp2_info_list = []\n",
+    "\n",
+    "for idx, row in tqdm(df.iterrows(), total=len(df), desc=\"Downloading ZIP files\"):\n",
+    "    tilename = row['TILENAME']\n",
+    "    zone = row['ZONE']\n",
+    "    url = row['URL']\n",
+    "    \n",
+    "    info = download_and_extract_jp2(tilename, zone, url, jp2_dir)\n",
+    "    if info is not None:\n",
+    "        jp2_info_list.append(info)\n",
+    "\n",
+    "print(f\"Successfully downloaded {len(jp2_info_list)} JP2 files\")\n",
+    "\n",
+    "# Step 3: Batch convert JP2 to JPEG\n",
+    "print(\"Step 3: Converting JP2 to JPEG\")\n",
+    "convert_jp2_to_jpeg(jp2_dir, jpeg_dir)\n",
+    "\n",
+    "#Step 4: Create image info list for dataset creation\n",
+    "print(\"Step 4: Creating image info list\")\n",
+    "image_info_list = recreate_image_info_list(excel_file, jpeg_dir)\n",
+    "    \n",
+    "print(f\"Found {len(image_info_list)} matched JPEG files\")\n",
+    "\n",
+    "# Step 5: Delete JP2 files to save space\n",
+    "print(\"Step 5: Deleting JP2 files...\")\n",
+    "shutil.rmtree(jp2_dir)\n",
+    "print(\"JP2 files deleted\")\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Login to Hugging Face (use your API token)\n",
+    "api_token = input(\"Enter your Hugging Face API token: \")\n",
+    "login(token=api_token)\n",
+    "\n",
+    "\n",
+    "# Create and push Hugging Face dataset\n",
+    "hf_dataset_name = input(\"Enter the name for your Hugging Face dataset (username/dataset-name): \")\n",
+    "upload_dataset_to_hub(image_info_list, hf_dataset_name)\n",
+    "\n",
+    "print(\"Done!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading metadata from /fsx/avijit/projects/datacommonsMA/massgis_2023_aerial_imagery/imagefolder-dataset/train/metadata.csv\n",
+      "Selected 50 samples\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Processing images:   0%|                                                  | 0/50 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/fsx/avijit/anaconda3/envs/py312/lib/python3.12/site-packages/PIL/Image.py:3402: DecompressionBombWarning: Image size (100000000 pixels) exceeds limit of 89478485 pixels, could be decompression bomb DOS attack.\n",
+      "  warnings.warn(\n",
+      "Processing images: 100%|█████████████████████████████████████��███| 50/50 [00:48<00:00,  1.04it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Saved sample dataset to /fsx/avijit/projects/datacommonsMA/massgis_2023_aerial_imagery/imagefolder-dataset/data/sample_dataset_256x256.parquet\n",
+      "Processed images saved in /fsx/avijit/projects/datacommonsMA/massgis_2023_aerial_imagery/imagefolder-dataset/data/processed_images\n",
+      "File size: 0.00 MB\n",
+      "Schema of the created Parquet file:\n",
+      "image: string\n",
+      "tilename: string\n",
+      "zone: int64\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import pyarrow as pa\n",
+    "import pyarrow.parquet as pq\n",
+    "from PIL import Image as PILImage\n",
+    "import numpy as np\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "base_dir = \"/fsx/avijit/projects/datacommonsMA/massgis_2023_aerial_imagery/imagefolder-dataset\"\n",
+    "train_dir = os.path.join(base_dir, \"train\")\n",
+    "output_dir = os.path.join(base_dir, \"data\")  # Matches the preview config\n",
+    "output_path = os.path.join(output_dir, \"sample_dataset_256x256.parquet\")\n",
+    "\n",
+    "# Create the output directory if it doesn't exist\n",
+    "os.makedirs(output_dir, exist_ok=True)\n",
+    "\n",
+    "target_size = (256, 256)\n",
+    "num_samples = 50\n",
+    "\n",
+    "metadata_path = os.path.join(train_dir, \"metadata.csv\")\n",
+    "print(f\"Reading metadata from {metadata_path}\")\n",
+    "metadata_df = pd.read_csv(metadata_path)\n",
+    "\n",
+    "# Take a random sample of 50 rows\n",
+    "if len(metadata_df) > num_samples:\n",
+    "    metadata_df = metadata_df.sample(n=num_samples, random_state=42)\n",
+    "\n",
+    "print(f\"Selected {len(metadata_df)} samples\")\n",
+    "\n",
+    "# Initialize lists to store data\n",
+    "image_paths = []\n",
+    "tilenames = []\n",
+    "zones = []\n",
+    "\n",
+    "processed_images_dir = os.path.join(output_dir, \"processed_images\")\n",
+    "os.makedirs(processed_images_dir, exist_ok=True)\n",
+    "\n",
+    "# Process each image\n",
+    "for _, row in tqdm(metadata_df.iterrows(), total=len(metadata_df), desc=\"Processing images\"):\n",
+    "    try:\n",
+    "        # Get image path\n",
+    "        img_path = os.path.join(train_dir, row['file_name'])\n",
+    "        \n",
+    "        # Open, resize, and save the processed image\n",
+    "        with PILImage.open(img_path) as img:\n",
+    "            # Convert to RGB if needed\n",
+    "            if img.mode != 'RGB':\n",
+    "                img = img.convert('RGB')\n",
+    "            \n",
+    "            # Resize to target size\n",
+    "            img_resized = img.resize(target_size)\n",
+    "            \n",
+    "            # Save the resized image in a separate folder\n",
+    "            output_image_path = os.path.join(processed_images_dir, row['file_name'])\n",
+    "            img_resized.save(output_image_path, format='JPEG', quality=90)\n",
+    "            \n",
+    "            # Append data\n",
+    "            image_paths.append(output_image_path)  # Store file path instead of bytes\n",
+    "            tilenames.append(row['tilename'])\n",
+    "            zones.append(int(row['zone']))  # Ensure zone is an integer\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error processing {row['file_name']}: {e}\")\n",
+    "\n",
+    "# Convert lists to Arrow arrays\n",
+    "image_array = pa.array(image_paths, type=pa.string())  # Store paths as strings\n",
+    "tilename_array = pa.array(tilenames, type=pa.string())\n",
+    "zone_array = pa.array(zones, type=pa.int64())\n",
+    "\n",
+    "# Define schema explicitly\n",
+    "schema = pa.schema([\n",
+    "    ('image', pa.string()),  # Store as file path (datasets library will auto-load)\n",
+    "    ('tilename', pa.string()),\n",
+    "    ('zone', pa.int64())\n",
+    "])\n",
+    "\n",
+    "# Create Arrow Table using the schema\n",
+    "table = pa.Table.from_arrays([image_array, tilename_array, zone_array], schema=schema)\n",
+    "\n",
+    "# Write to Parquet\n",
+    "pq.write_table(table, output_path, compression='snappy', flavor=['spark'])\n",
+    "\n",
+    "print(f\"Saved sample dataset to {output_path}\")\n",
+    "print(f\"Processed images saved in {processed_images_dir}\")\n",
+    "print(f\"File size: {os.path.getsize(output_path) / (1024 * 1024):.2f} MB\")\n",
+    "\n",
+    "# To check if the schema matches what's expected\n",
+    "print(\"Schema of the created Parquet file:\")\n",
+    "parquet_schema = pq.read_schema(output_path)\n",
+    "print(parquet_schema)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<pyarrow._parquet.FileMetaData object at 0x7fa0858cc590>\n",
+      "  created_by: parquet-cpp-arrow version 19.0.0\n",
+      "  num_columns: 3\n",
+      "  num_rows: 50\n",
+      "  num_row_groups: 1\n",
+      "  format_version: 2.6\n",
+      "  serialized_size: 943\n"
+     ]
+    }
+   ],
+   "source": [
+    "parquet_file = pq.ParquetFile(output_path)\n",
+    "print(parquet_file.metadata)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py312",
+   "language": "python",
+   "name": "py312"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

structured_docs_dataset.ipynb

@@ -0,0 +1,355 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "import glob\n",
+    "import re"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def combine_excel_files(directory_path, output_csv='combined_mcas_data.csv', output_parquet='combined_mcas_data.parquet'):\n",
+    "    \"\"\"\n",
+    "    Combine all Excel files in a directory into a single dataset with proper headers.\n",
+    "    Converts to both CSV and Parquet formats.\n",
+    "    Handles data types: numbers for most fields, strings for District name, subject, district code and year.\n",
+    "    \n",
+    "    Parameters:\n",
+    "    directory_path (str): Path to the directory containing Excel files\n",
+    "    output_csv (str): Name of the output CSV file\n",
+    "    output_parquet (str): Name of the output Parquet file\n",
+    "    \"\"\"\n",
+    "    # Get list of all Excel files in the directory\n",
+    "    all_files = glob.glob(os.path.join(directory_path, \"*.xlsx\"))\n",
+    "    \n",
+    "    # Create an empty list to store DataFrames\n",
+    "    dfs = []\n",
+    "    all_columns_sets = []\n",
+    "    \n",
+    "    # First pass - examine structure of the first file to identify headers\n",
+    "    if all_files:\n",
+    "        # Read the first few rows of the first file to inspect\n",
+    "        sample_df = pd.read_excel(all_files[0], header=None, nrows=10)\n",
+    "        print(f\"Preview of first file ({all_files[0]}):\")\n",
+    "        print(sample_df.head(10))\n",
+    "        \n",
+    "        # Find the actual header row by looking for rows where many columns have values\n",
+    "        non_empty_counts = sample_df.notna().sum(axis=1)\n",
+    "        potential_header_rows = non_empty_counts[non_empty_counts > 5].index.tolist()\n",
+    "        \n",
+    "        if potential_header_rows:\n",
+    "            header_row = potential_header_rows[1] if len(potential_header_rows) > 1 else potential_header_rows[0]\n",
+    "            # Use row index where we detect MCAS data pattern\n",
+    "            for i in potential_header_rows:\n",
+    "                if 'DISTRICT NAME' in str(sample_df.iloc[i].values).upper() or 'SCHOOL NAME' in str(sample_df.iloc[i].values).upper():\n",
+    "                    header_row = i\n",
+    "                    break\n",
+    "            print(f\"Detected header row at index {header_row}: {sample_df.iloc[header_row].tolist()}\")\n",
+    "        else:\n",
+    "            header_row = 0\n",
+    "            print(\"Could not detect header row, using first row\")\n",
+    "    \n",
+    "    # Get the first file's column order as a reference\n",
+    "    first_file_columns = None\n",
+    "    \n",
+    "    # Loop through each Excel file\n",
+    "    for file in all_files:\n",
+    "        try:\n",
+    "            # Extract year from filename\n",
+    "            year_match = re.search(r'NextGenMCAS_(\\d{4})\\.xlsx', os.path.basename(file))\n",
+    "            if year_match:\n",
+    "                year = year_match.group(1)\n",
+    "            else:\n",
+    "                year = \"Unknown\"\n",
+    "            \n",
+    "            # Define columns that should be treated as strings\n",
+    "            string_cols = []\n",
+    "            \n",
+    "            # First check what columns exist in the file\n",
+    "            temp_df = pd.read_excel(file, header=header_row, nrows=0)\n",
+    "            for col in temp_df.columns:\n",
+    "                col_str = str(col).upper()\n",
+    "                if ('DISTRICT' in col_str and ('CODE' in col_str or 'ID' in col_str or 'NUMBER' in col_str)) or \\\n",
+    "                   ('DISTRICT NAME' in col_str) or ('SUBJECT' in col_str):\n",
+    "                    string_cols.append(col)\n",
+    "            \n",
+    "            # Read the Excel file\n",
+    "            df = pd.read_excel(\n",
+    "                file, \n",
+    "                header=header_row, \n",
+    "                dtype={col: str for col in string_cols}  # Convert specified columns to string\n",
+    "            )\n",
+    "            \n",
+    "            # Clean column names\n",
+    "            df.columns = [col.strip().replace('\\n', ' ') if isinstance(col, str) else str(col) for col in df.columns]\n",
+    "            \n",
+    "            # Store the first file's column order\n",
+    "            if first_file_columns is None:\n",
+    "                first_file_columns = df.columns.tolist()\n",
+    "            \n",
+    "            # Add year column as string\n",
+    "            df['Year'] = str(year)\n",
+    "            \n",
+    "            # Store the columns from this file\n",
+    "            all_columns_sets.append(set(df.columns))\n",
+    "            \n",
+    "            # Append to list\n",
+    "            dfs.append(df)\n",
+    "            print(f\"Successfully processed: {file} (Year: {year})\")\n",
+    "        except Exception as e:\n",
+    "            print(f\"Error processing {file}: {e}\")\n",
+    "    \n",
+    "    # Find common columns across all files (intersection of all column sets)\n",
+    "    if all_columns_sets:\n",
+    "        common_columns = set.intersection(*all_columns_sets)\n",
+    "        print(f\"Common columns across all files: {common_columns}\")\n",
+    "        \n",
+    "        # Ensure 'Year' is in common columns\n",
+    "        if 'Year' not in common_columns:\n",
+    "            common_columns.add('Year')\n",
+    "        \n",
+    "        # Keep only common columns in each DataFrame\n",
+    "        for i in range(len(dfs)):\n",
+    "            dfs[i] = dfs[i][list(common_columns)]\n",
+    "    \n",
+    "    # Combine all DataFrames\n",
+    "    if dfs:\n",
+    "        # Combine DataFrames with only the common columns\n",
+    "        combined_df = pd.concat(dfs, ignore_index=True)\n",
+    "        \n",
+    "        # Remove rows that are likely headers from other files\n",
+    "        possible_header_rows = []\n",
+    "        for col in common_columns:\n",
+    "            if col != 'Year':  # Skip checking Year column\n",
+    "                for i, row in combined_df.iterrows():\n",
+    "                    for val in row:\n",
+    "                        if isinstance(val, str) and col.lower() in str(val).lower():\n",
+    "                            possible_header_rows.append(i)\n",
+    "        \n",
+    "        # Remove duplicate header rows\n",
+    "        possible_header_rows = list(set(possible_header_rows))\n",
+    "        print(f\"Removing {len(possible_header_rows)} possible header rows\")\n",
+    "        combined_df = combined_df.drop(possible_header_rows, errors='ignore')\n",
+    "        \n",
+    "        # Identify string columns and numeric columns\n",
+    "        string_columns = []\n",
+    "        district_col = None\n",
+    "        district_code_col = None\n",
+    "        subject_col = None\n",
+    "        \n",
+    "        for col in combined_df.columns:\n",
+    "            col_upper = col.upper()\n",
+    "            if 'DISTRICT NAME' in col_upper:\n",
+    "                district_col = col\n",
+    "                string_columns.append(col)\n",
+    "            elif ('DISTRICT' in col_upper and ('CODE' in col_upper or 'ID' in col_upper or 'NUMBER' in col_upper)):\n",
+    "                district_code_col = col\n",
+    "                string_columns.append(col)\n",
+    "            elif 'SUBJECT' in col_upper:\n",
+    "                subject_col = col\n",
+    "                string_columns.append(col)\n",
+    "        \n",
+    "        # Add Year to string columns\n",
+    "        string_columns.append('Year')\n",
+    "        \n",
+    "        # Convert all other columns to numeric\n",
+    "        for col in combined_df.columns:\n",
+    "            if col not in string_columns:\n",
+    "                # Try to convert to numeric, replace errors with NaN\n",
+    "                combined_df[col] = pd.to_numeric(combined_df[col], errors='coerce')\n",
+    "        \n",
+    "        # Reorder columns to put DISTRICT NAME and Year first\n",
+    "        if district_col:\n",
+    "            # Create new column order with district_col and Year first, then others in original order\n",
+    "            remaining_cols = [col for col in combined_df.columns \n",
+    "                             if col != district_col and col != 'Year']\n",
+    "            \n",
+    "            # Sort remaining columns based on their order in the first file\n",
+    "            if first_file_columns:\n",
+    "                # Get the indices of each column in the original order\n",
+    "                col_indices = {}\n",
+    "                for i, col in enumerate(first_file_columns):\n",
+    "                    if col in remaining_cols:\n",
+    "                        col_indices[col] = i\n",
+    "                \n",
+    "                # Sort remaining columns based on their original indices\n",
+    "                remaining_cols.sort(key=lambda col: col_indices.get(col, 999))\n",
+    "            \n",
+    "            new_column_order = [district_col, 'Year'] + remaining_cols\n",
+    "            combined_df = combined_df[new_column_order]\n",
+    "        \n",
+    "        # Export to CSV\n",
+    "        csv_path = os.path.join(directory_path, output_csv)\n",
+    "        combined_df.to_csv(csv_path, index=False)\n",
+    "        print(f\"Successfully created CSV: {csv_path}\")\n",
+    "        \n",
+    "        # Export to Parquet\n",
+    "        parquet_path = os.path.join(directory_path, output_parquet)\n",
+    "        combined_df.to_parquet(parquet_path, index=False)\n",
+    "        print(f\"Successfully created Parquet: {parquet_path}\")\n",
+    "        \n",
+    "        print(f\"Combined {len(dfs)} Excel files with {len(combined_df)} total rows\")\n",
+    "        print(f\"Final columns: {', '.join(combined_df.columns)}\")\n",
+    "        \n",
+    "        # Print data types for verification\n",
+    "        print(\"\\nData types in final dataset:\")\n",
+    "        for col, dtype in combined_df.dtypes.items():\n",
+    "            print(f\"{col}: {dtype}\")\n",
+    "    else:\n",
+    "        print(\"No Excel files were successfully processed\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Preview of first file (/fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2018.xlsx):\n",
+      "                                                  0              1        2   \\\n",
+      "0     2018 Next Generation MCAS Achievement Results             NaN      NaN   \n",
+      "1                                      District Name  District Code  Subject   \n",
+      "2       Abby Kelley Foster Charter Public (District)       04450000      ELA   \n",
+      "3       Abby Kelley Foster Charter Public (District)       04450000     MATH   \n",
+      "4                                           Abington       00010000      ELA   \n",
+      "5                                           Abington       00010000     MATH   \n",
+      "6  Academy Of the Pacific Rim Charter Public (Dis...       04120000      ELA   \n",
+      "7  Academy Of the Pacific Rim Charter Public (Dis...       04120000     MATH   \n",
+      "8                                   Acton-Boxborough       06000000      ELA   \n",
+      "9                                   Acton-Boxborough       06000000     MATH   \n",
+      "\n",
+      "             3      4             5    6             7    8             9   \\\n",
+      "0           NaN    NaN           NaN  NaN           NaN  NaN           NaN   \n",
+      "1         M+E #  M+E %           E #  E %           M #  M %          PM #   \n",
+      "2           313     44            31    4           282   39           347   \n",
+      "3           266     37            20    3           246   34           390   \n",
+      "4           554     55            90    9           464   46           374   \n",
+      "5           482     48            46    5           436   44           440   \n",
+      "6           138     44            15    5           123   39           151   \n",
+      "7           103     33            10    3            93   30           175   \n",
+      "8         1,908     73           522   20         1,386   53           622   \n",
+      "9         1,882     72           574   22         1,308   50           619   \n",
+      "\n",
+      "     10            11    12                        13                 14  \\\n",
+      "0   NaN           NaN   NaN                       NaN                NaN   \n",
+      "1  PM %          NM #  NM %  No. of Students Included  Avg. Scaled Score   \n",
+      "2    48            56     8                       716              497.3   \n",
+      "3    54            61     9                       717              494.6   \n",
+      "4    37            75     7                     1,003              502.3   \n",
+      "5    44            79     8                     1,001              498.7   \n",
+      "6    48            26     8                       315              497.3   \n",
+      "7    56            37    12                       315              492.3   \n",
+      "8    24            92     4                     2,622              513.3   \n",
+      "9    24           118     5                     2,619              512.7   \n",
+      "\n",
+      "               15               16  \n",
+      "0             NaN              NaN  \n",
+      "1             SGP  Included In SGP  \n",
+      "2            48.7              586  \n",
+      "3            52.9              587  \n",
+      "4            50.2              784  \n",
+      "5            47.3              785  \n",
+      "6            57.7              289  \n",
+      "7            52.9              289  \n",
+      "8            58.9            2,069  \n",
+      "9            58.8            2,073  \n",
+      "Detected header row at index 1: ['District Name', 'District Code', 'Subject', 'M+E #', 'M+E %', 'E #', 'E %', 'M #', 'M %', 'PM #', 'PM %', 'NM #', 'NM %', 'No. of Students Included', 'Avg. Scaled Score', 'SGP', 'Included In SGP']\n",
+      "Successfully processed: /fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2018.xlsx (Year: 2018)\n",
+      "Successfully processed: /fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2017.xlsx (Year: 2017)\n",
+      "Successfully processed: /fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2020.xlsx (Year: 2020)\n",
+      "Successfully processed: /fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2024.xlsx (Year: 2024)\n",
+      "Successfully processed: /fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2021.xlsx (Year: 2021)\n",
+      "Successfully processed: /fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2022.xlsx (Year: 2022)\n",
+      "Successfully processed: /fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2023.xlsx (Year: 2023)\n",
+      "Successfully processed: /fsx/avijit/projects/datacommonsMA/mcas_results/NextGenMCAS_2019.xlsx (Year: 2019)\n",
+      "Common columns across all files: {'E %', 'M+E #', 'PM #', 'SGP', 'No. of Students Included', 'NM #', 'District Code', 'Avg. Scaled Score', 'M #', 'Year', 'Included In SGP', 'PM %', 'E #', 'NM %', 'M+E %', 'Subject', 'M %', 'District Name'}\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_2144425/3133257492.py:108: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
+      "  combined_df = pd.concat(dfs, ignore_index=True)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Removing 0 possible header rows\n",
+      "Successfully created CSV: /fsx/avijit/projects/datacommonsMA/mcas_results/combined_mcas_data.csv\n",
+      "Successfully created Parquet: /fsx/avijit/projects/datacommonsMA/mcas_results/combined_mcas_data.parquet\n",
+      "Combined 8 Excel files with 6741 total rows\n",
+      "Final columns: District Name, Year, District Code, Subject, M+E #, M+E %, E #, E %, M #, M %, PM #, PM %, NM #, NM %, No. of Students Included, Avg. Scaled Score, SGP, Included In SGP\n",
+      "\n",
+      "Data types in final dataset:\n",
+      "District Name: object\n",
+      "Year: object\n",
+      "District Code: object\n",
+      "Subject: object\n",
+      "M+E #: float64\n",
+      "M+E %: int64\n",
+      "E #: float64\n",
+      "E %: int64\n",
+      "M #: float64\n",
+      "M %: int64\n",
+      "PM #: float64\n",
+      "PM %: int64\n",
+      "NM #: float64\n",
+      "NM %: int64\n",
+      "No. of Students Included: float64\n",
+      "Avg. Scaled Score: float64\n",
+      "SGP: float64\n",
+      "Included In SGP: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "data_folder = \"/fsx/avijit/projects/datacommonsMA/mcas_results\"\n",
+    "combine_excel_files(data_folder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py312",
+   "language": "python",
+   "name": "py312"
+  },
+  "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.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

unstructured_docs_dataset.ipynb

@@ -0,0 +1,333 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from PIL import Image\n",
+    "from transformers import AutoProcessor, AutoModelForVision2Seq\n",
+    "import re\n",
+    "import html\n",
+    "from threading import Thread\n",
+    "from transformers.generation.streamers import TextIteratorStreamer\n",
+    "from docling_core.types.doc import DoclingDocument\n",
+    "from docling_core.types.doc.document import DocTagsDocument\n",
+    "import fitz\n",
+    "import os\n",
+    "import pandas as pd\n",
+    "import json\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load model and processor\n",
+    "processor = AutoProcessor.from_pretrained(\"ds4sd/SmolDocling-256M-preview\")\n",
+    "model = AutoModelForVision2Seq.from_pretrained(\n",
+    "    \"ds4sd/SmolDocling-256M-preview\", \n",
+    "    torch_dtype=torch.bfloat16\n",
+    ").to(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def image_to_markdown(image, query_text=\"Convert this page to docling.\"):\n",
+    "    \"\"\"\n",
+    "    Convert an input image to markdown output using SmolDocling model\n",
+    "    \n",
+    "    Parameters:\n",
+    "    image: Input image file in RGB\n",
+    "    query_text (str): Query text to guide the conversion (default: \"Convert this page to docling.\")\n",
+    "    \n",
+    "    Returns:\n",
+    "    str: Markdown output of the converted image\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # Special handling for code or OTSL content\n",
+    "    if \"OTSL\" in query_text or \"code\" in query_text:\n",
+    "        # Add padding to image as in the original code\n",
+    "        width, height = image.size\n",
+    "        pad_w = int(width * 0.1)  # 10% padding\n",
+    "        pad_h = int(height * 0.1)  # 10% padding\n",
+    "        corner_pixel = image.getpixel((0, 0))\n",
+    "        from PIL import ImageOps\n",
+    "        image = ImageOps.expand(image, border=(pad_w, pad_h, pad_w, pad_h), fill=corner_pixel)\n",
+    "    \n",
+    "    # Prepare input for the model\n",
+    "    resulting_messages = [\n",
+    "        {\n",
+    "            \"role\": \"user\",\n",
+    "            \"content\": [{\"type\": \"image\"}] + [\n",
+    "                {\"type\": \"text\", \"text\": query_text}\n",
+    "            ]\n",
+    "        }\n",
+    "    ]\n",
+    "    \n",
+    "    prompt = processor.apply_chat_template(resulting_messages, add_generation_prompt=True)\n",
+    "    inputs = processor(text=prompt, images=[[image]], return_tensors=\"pt\").to(model.device)\n",
+    "    \n",
+    "    # Generate output using streamer for better memory management\n",
+    "    streamer = TextIteratorStreamer(processor, skip_prompt=True, skip_special_tokens=False)\n",
+    "    generation_args = dict(inputs, streamer=streamer, max_new_tokens=8192)\n",
+    "    \n",
+    "    thread = Thread(target=model.generate, kwargs=generation_args)\n",
+    "    thread.start()\n",
+    "    \n",
+    "    # Collect the generated output\n",
+    "    full_output = \"\"\n",
+    "    for new_text in streamer:\n",
+    "        full_output += new_text\n",
+    "    \n",
+    "    # Clean up the output\n",
+    "    cleaned_output = full_output.replace(\"<end_of_utterance>\", \"\").strip()\n",
+    "    \n",
+    "    # Process doctags if present\n",
+    "    if any(tag in cleaned_output for tag in [\"<doctag>\", \"<otsl>\", \"<code>\", \"<chart>\", \"<formula>\"]):\n",
+    "        doctag_output = cleaned_output\n",
+    "        \n",
+    "        # Handle chart tags\n",
+    "        if \"<chart>\" in doctag_output:\n",
+    "            doctag_output = doctag_output.replace(\"<chart>\", \"<otsl>\").replace(\"</chart>\", \"</otsl>\")\n",
+    "            doctag_output = re.sub(r'(<loc_500>)(?!.*<loc_500>)<[^>]+>', r'\\1', doctag_output)\n",
+    "        \n",
+    "        # Create document and convert to markdown\n",
+    "        doc = DoclingDocument(name=\"Document\")\n",
+    "        doctags_doc = DocTagsDocument.from_doctags_and_image_pairs([doctag_output], [image])\n",
+    "        doc.load_from_doctags(doctags_doc)\n",
+    "        \n",
+    "        return doc.export_to_markdown()\n",
+    "    \n",
+    "    # Return the cleaned output if no doctags are present\n",
+    "    return cleaned_output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def process_pdfs_folder(pdf_folder, output_folder):\n",
+    "    \"\"\"\n",
+    "    Process all PDFs in a folder, converting each page to markdown immediately and saving results as JSON.\n",
+    "    \n",
+    "    Parameters:\n",
+    "    pdf_folder (str): Path to folder containing PDFs\n",
+    "    output_folder (str): Path to save output JSON files\n",
+    "    \"\"\"\n",
+    "    # Create output folder if it doesn't exist\n",
+    "    if not os.path.exists(output_folder):\n",
+    "        os.makedirs(output_folder)\n",
+    "    \n",
+    "    # Get all PDF files in the folder\n",
+    "    pdf_files = [f for f in os.listdir(pdf_folder) if f.lower().endswith('.pdf')]\n",
+    "    \n",
+    "    # Process each PDF file\n",
+    "    for pdf_file in tqdm(pdf_files, desc=\"Processing PDFs\"):\n",
+    "        pdf_path = os.path.join(pdf_folder, pdf_file)\n",
+    "        pdf_name = os.path.splitext(pdf_file)[0]\n",
+    "        output_json = os.path.join(output_folder, f\"{pdf_name}.json\")\n",
+    "        \n",
+    "        # Initialize an empty list to store the data\n",
+    "        pdf_data = []\n",
+    "        \n",
+    "        try:\n",
+    "            # Open the PDF\n",
+    "            pdf_document = fitz.open(pdf_path)\n",
+    "            total_pages = pdf_document.page_count\n",
+    "            \n",
+    "            print(f\"Processing {pdf_file} ({total_pages} pages)\")\n",
+    "            \n",
+    "            # Process each page one by one\n",
+    "            for page_number in tqdm(range(total_pages), desc=f\"Pages in {pdf_file}\", leave=False):\n",
+    "                try:\n",
+    "                    # Get the page\n",
+    "                    page = pdf_document[page_number]\n",
+    "                    \n",
+    "                    # Convert page to image\n",
+    "                    pixmap = page.get_pixmap()\n",
+    "                    image = Image.frombytes(\"RGB\", [pixmap.width, pixmap.height], pixmap.samples)\n",
+    "                    \n",
+    "                    # Convert image to markdown immediately\n",
+    "                    markdown_text = image_to_markdown(image)\n",
+    "                    \n",
+    "                    # Display first 100 characters for verification\n",
+    "                    preview = markdown_text[:100].replace('\\n', ' ')\n",
+    "                    print(f\"Page {page_number+1}/{total_pages}: {preview}...\")\n",
+    "                    \n",
+    "                    # Add to data list\n",
+    "                    page_data = {\n",
+    "                        'pdf_name': pdf_name,\n",
+    "                        'slide_number': page_number+1,\n",
+    "                        'markdown_text': markdown_text\n",
+    "                    }\n",
+    "                    pdf_data.append(page_data)\n",
+    "                    \n",
+    "                    # Save JSON after each page\n",
+    "                    with open(output_json, 'w', encoding='utf-8') as jsonfile:\n",
+    "                        json.dump(pdf_data, jsonfile, ensure_ascii=False, indent=2)\n",
+    "                    \n",
+    "                except Exception as e:\n",
+    "                    error_msg = f\"Error processing page {page_number+1} from {pdf_file}: {e}\"\n",
+    "                    print(error_msg)\n",
+    "                    # Add error info to data\n",
+    "                    error_data = {\n",
+    "                        'pdf_name': pdf_name,\n",
+    "                        'slide_number': page_number+1,\n",
+    "                        'markdown_text': f\"ERROR: {str(e)}\"\n",
+    "                    }\n",
+    "                    pdf_data.append(error_data)\n",
+    "                    \n",
+    "                    # Save JSON after error\n",
+    "                    with open(output_json, 'w', encoding='utf-8') as jsonfile:\n",
+    "                        json.dump(pdf_data, jsonfile, ensure_ascii=False, indent=2)\n",
+    "            \n",
+    "            # Close the PDF after processing\n",
+    "            pdf_document.close()\n",
+    "            \n",
+    "        except Exception as e:\n",
+    "            error_msg = f\"Error opening PDF {pdf_file}: {e}\"\n",
+    "            print(error_msg)\n",
+    "            error_data = {\n",
+    "                'pdf_name': pdf_name,\n",
+    "                'slide_number': 1,\n",
+    "                'markdown_text': f\"ERROR: Failed to process PDF: {str(e)}\"\n",
+    "            }\n",
+    "            pdf_data.append(error_data)\n",
+    "            \n",
+    "            # Save JSON after PDF error\n",
+    "            with open(output_json, 'w', encoding='utf-8') as jsonfile:\n",
+    "                json.dump(pdf_data, jsonfile, ensure_ascii=False, indent=2)\n",
+    "    \n",
+    "    print(f\"Processing complete. Results saved to {output_folder}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# input_folder = \"/fsx/avijit/projects/datacommonsMA/labormarketreports/pdfs\" ## First convert the ppts to pdf\n",
+    "# output_folder = \"/fsx/avijit/projects/datacommonsMA/labormarketreports/processed_reports\"\n",
+    "\n",
+    "input_folder = \"/fsx/avijit/projects/datacommonsMA/occupational_injury_reports/pdfs\"\n",
+    "output_folder = \"/fsx/avijit/projects/datacommonsMA/occupational_injury_reports/processed_reports\"\n",
+    "\n",
+    "process_pdfs_folder(input_folder,output_folder)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def combine_json_files(folder_path, output_file=\"combined_results.json\"):\n",
+    "    \"\"\"\n",
+    "    Read individual JSON files from a folder and simply concatenate them,\n",
+    "    changing \"pdf_name\" to \"report name\" in each entry.\n",
+    "    \n",
+    "    Args:\n",
+    "        folder_path (str): Path to the folder containing JSON files\n",
+    "        output_file (str): Path to save the combined JSON file\n",
+    "    \n",
+    "    Returns:\n",
+    "        list: The combined data list\n",
+    "    \"\"\"\n",
+    "    import json\n",
+    "    from pathlib import Path\n",
+    "    \n",
+    "    # Initialize data list\n",
+    "    combined_data = []\n",
+    "    \n",
+    "    # Get all JSON files in the folder\n",
+    "    folder_path = Path(folder_path)\n",
+    "    json_files = list(folder_path.glob(\"*.json\"))\n",
+    "    \n",
+    "    if not json_files:\n",
+    "        print(f\"No JSON files found in {folder_path}\")\n",
+    "        return []\n",
+    "    \n",
+    "    print(f\"Found {len(json_files)} JSON files in {folder_path}\")\n",
+    "    \n",
+    "    # Read each JSON file\n",
+    "    for json_file in json_files:\n",
+    "        try:\n",
+    "            with open(json_file, \"r\", encoding=\"utf-8\") as f:\n",
+    "                file_data = json.load(f)\n",
+    "                \n",
+    "                # Handle both list and single object formats\n",
+    "                if isinstance(file_data, list):\n",
+    "                    items = file_data\n",
+    "                else:\n",
+    "                    items = [file_data]\n",
+    "                \n",
+    "                # Rename pdf_name to report name in each item\n",
+    "                for item in items:\n",
+    "                    if \"pdf_name\" in item:\n",
+    "                        item[\"report name\"] = item.pop(\"pdf_name\")\n",
+    "                        item[\"page number\"] = item.pop(\"slide_number\")\n",
+    "                \n",
+    "                # Add to combined data\n",
+    "                combined_data.extend(items)\n",
+    "                \n",
+    "        except Exception as e:\n",
+    "            print(f\"Error reading {json_file}: {e}\")\n",
+    "    \n",
+    "    # Write to file\n",
+    "    with open(output_file, \"w\", encoding=\"utf-8\") as f:\n",
+    "        json.dump(combined_data, output_folder+'/'+f, indent=2, ensure_ascii=False)\n",
+    "    \n",
+    "    print(f\"Combined {len(combined_data)} items into {output_file}\")\n",
+    "    return combined_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 7 JSON files in /fsx/avijit/projects/datacommonsMA/occupational_injury_reports/processed_reports\n",
+      "Error reading /fsx/avijit/projects/datacommonsMA/occupational_injury_reports/processed_reports/combined_reports.json: Extra data: line 73 column 1 (char 109380)\n",
+      "Combined 78 items into occupational_injury_combined_reports.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "combined_data = combine_json_files(output_folder, \"occupational_injury_combined_reports.json\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "py312",
+   "language": "python",
+   "name": "py312"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}