Delete build_dataset.py with huggingface_hub

build_dataset.py

@@ -1,315 +0,0 @@
-#!/usr/bin/env python3
-"""
-Build dataset from merged_result.parquet + LakeFS.
-Downloads PCD and JPG files, packages into ~250 MB ZIP archives in 3D_o/.
-"""
-
-import pandas as pd
-import numpy as np
-import requests
-import os
-import sys
-import json
-import time
-import shutil
-import zipfile
-import concurrent.futures
-import pickle
-from pathlib import Path
-from collections import defaultdict
-
-# Config
-LAKEFS_BASE = 'http://10.248.52.100:8001'
-AK = os.environ['LAKEFS_ACCESS_KEY']
-SK = os.environ['LAKEFS_SECRET_KEY']
-OUTPUT_DIR = Path('/workspace/3D_o')
-PCD_SIZE_FILE = '/workspace/pcd_file_sizes.parquet'
-JPG_SIZE_FILE = '/workspace/jpg_file_sizes.parquet'
-MERGED_FILE = '/workspace/merged_result.parquet'
-PLAN_FILE = '/workspace/chunks_data.pkl'
-CHUNK_TARGET = 250 * 1024 * 1024  # 250 MB
-CHUNK_MIN = 200 * 1024 * 1024     # 200 MB
-MAX_WORKERS = 30  # parallel downloads per chunk
-REQUEST_TIMEOUT = 120
-
-OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-session = requests.Session()
-session.auth = (AK, SK)
-
-# ----- STEP 0: Load sizes -----
-print("[0] Loading data...")
-merged = pd.read_parquet(MERGED_FILE)
-pcd_sizes = pd.read_parquet(PCD_SIZE_FILE)
-jpg_sizes = pd.read_parquet(JPG_SIZE_FILE)
-pcd_size_map = dict(zip(pcd_sizes['path'], pcd_sizes['size']))
-jpg_size_map = dict(zip(jpg_sizes['path'], jpg_sizes['size']))
-
-# ----- STEP 1: Build deduplicated PCD list -----
-print("[1] Building deduplicated PCD list...")
-# For each unique PCD, get its bag_id (first occurrence's bag_id and timestamp)
-pcd_info = merged.drop_duplicates(subset='path')[['path', 'path_to_jpg', 'bag_id', 'main_timestamp']].copy()
-pcd_info = pcd_info.sort_values(['bag_id', 'main_timestamp']).reset_index(drop=True)
-print(f"  Unique PCDs: {len(pcd_info)}")
-
-# Add sizes
-pcd_info['pcd_size'] = pcd_info['path'].map(pcd_size_map)
-pcd_info['jpg_size'] = pcd_info['path_to_jpg'].map(jpg_size_map).fillna(0).astype(int)
-pcd_info['total_size'] = pcd_info['pcd_size'] + pcd_info['jpg_size']
-
-missing_sizes = pcd_info['pcd_size'].isna().sum()
-if missing_sizes:
-    print(f"  WARNING: {missing_sizes} PCDs missing sizes, estimating at 5MB")
-    pcd_info['pcd_size'] = pcd_info['pcd_size'].fillna(5_000_000).astype(int)
-    pcd_info['total_size'] = pcd_info['pcd_size'] + pcd_info['jpg_size']
-
-total_data_size = pcd_info['total_size'].sum()
-print(f"  Total dataset size: {total_data_size / 1e9:.1f} GB")
-print(f"  Estimated archives: {total_data_size / CHUNK_TARGET:.0f}")
-
-# Count how many PCDs have JPGs
-with_jpg = (pcd_info['jpg_size'] > 0).sum()
-print(f"  PCDs with JPGs: {with_jpg}")
-
-# ----- STEP 2: Build chunk plan -----
-chunk_plan_path = Path(PLAN_FILE)
-if chunk_plan_path.exists():
-    print("[2] Loading existing chunk plan...")
-    with open(chunk_plan_path, 'rb') as f:
-        chunks = pickle.load(f)
-    print(f"  Loaded {len(chunks)} chunks")
-else:
-    print("[2] Building chunk plan...")
-    chunks = []
-    current_chunk = []
-    current_size = 0
-    chunk_idx = 0
-    
-    for idx, row in pcd_info.iterrows():
-        item_size = int(row['total_size'])
-        
-        if current_size > 0 and current_size + item_size > CHUNK_TARGET and current_size >= CHUNK_MIN:
-            chunks.append({
-                'index': chunk_idx,
-                'name': f'data_{chunk_idx:04d}.zip',
-                'files': current_chunk,
-                'total_size': current_size,
-                'bag_ids': list(set(f['bag_id'] for f in current_chunk)),
-            })
-            chunk_idx += 1
-            current_chunk = []
-            current_size = 0
-        
-        current_chunk.append({
-            'pcd_path': row['path'],
-            'jpg_path': row['path_to_jpg'] if pd.notna(row['path_to_jpg']) else None,
-            'bag_id': row['bag_id'],
-            'pcd_size': int(row['pcd_size']),
-            'jpg_size': int(row['jpg_size']),
-            'main_timestamp': int(row['main_timestamp']),
-        })
-        current_size += item_size
-    
-    # Last chunk
-    if current_chunk:
-        chunks.append({
-            'index': chunk_idx,
-            'name': f'data_{chunk_idx:04d}.zip',
-            'files': current_chunk,
-            'total_size': current_size,
-            'bag_ids': list(set(f['bag_id'] for f in current_chunk)),
-        })
-    
-    with open(chunk_plan_path, 'wb') as f:
-        pickle.dump(chunks, f)
-    print(f"  Created {len(chunks)} chunks, saved plan")
-
-# Summary
-total_planned = sum(c['total_size'] for c in chunks)
-print(f"  Total planned size: {total_planned / 1e9:.1f} GB")
-print(f"  Chunks: {len(chunks)}, avg size: {total_planned/len(chunks)/1e6:.0f} MB")
-
-# ----- STEP 3: Process chunks (download + zip) -----
-# Find out which chunks are already done
-existing_zips = set(f.name for f in OUTPUT_DIR.iterdir() if f.suffix == '.zip')
-done_indices = set()
-for c in chunks:
-    if c['name'] in existing_zips:
-        # Verify zip is valid
-        try:
-            with zipfile.ZipFile(OUTPUT_DIR / c['name'], 'r') as zf:
-                if zf.testzip() is None:
-                    done_indices.add(c['index'])
-        except:
-            pass
-
-todo_chunks = [c for c in chunks if c['index'] not in done_indices]
-print(f"\n[3] Processing chunks ({len(todo_chunks)} remaining, {len(done_indices)} done)...")
-
-def download_file(file_info):
-    """Download a single PCD or JPG file to temp directory."""
-    result = {}
-    
-    # Download PCD
-    pcd_uuid = Path(file_info['pcd_path']).stem
-    pcd_tmp = OUTPUT_DIR / f'tmp_{pcd_uuid}.pcd'
-    if not pcd_tmp.exists():
-        url = f'{LAKEFS_BASE}/api/v1/repositories/astraldb/refs/main/objects'
-        r = session.get(url, params={'path': file_info['pcd_path']}, timeout=REQUEST_TIMEOUT)
-        if r.status_code != 200:
-            return {'error': f'PCD download failed: {r.status_code}', 'pcd_uuid': pcd_uuid}
-        with open(pcd_tmp, 'wb') as f:
-            f.write(r.content)
-    result['pcd_tmp'] = str(pcd_tmp)
-    result['pcd_arc'] = f"pcd/{pcd_uuid}.pcd"
-    
-    # Download JPG if exists
-    if file_info['jpg_path']:
-        jpg_uuid = Path(file_info['jpg_path']).stem
-        jpg_tmp = OUTPUT_DIR / f'tmp_{jpg_uuid}.jpg'
-        if not jpg_tmp.exists():
-            url = f'{LAKEFS_BASE}/api/v1/repositories/ros2bags/refs/main/objects'
-            r = session.get(url, params={'path': file_info['jpg_path']}, timeout=REQUEST_TIMEOUT)
-            if r.status_code != 200:
-                result['jpg_error'] = f'JPG download failed: {r.status_code}'
-            else:
-                with open(jpg_tmp, 'wb') as f:
-                    f.write(r.content)
-        if jpg_tmp.exists():
-            result['jpg_tmp'] = str(jpg_tmp)
-            result['jpg_arc'] = f"jpg/{jpg_uuid}.jpg"
-    
-    return result
-
-def process_chunk(chunk):
-    """Download all files for a chunk and create ZIP."""
-    chunk_name = chunk['name']
-    zip_path = OUTPUT_DIR / chunk_name
-    
-    if zip_path.exists():
-        try:
-            with zipfile.ZipFile(zip_path, 'r') as zf:
-                if zf.testzip() is None:
-                    return {'index': chunk['index'], 'name': chunk_name, 'status': 'already_done'}
-        except:
-            pass
-    
-    # Parallel download
-    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
-        dl_results = list(ex.map(download_file, chunk['files']))
-    
-    errors = [r for r in dl_results if 'error' in r]
-    if errors:
-        # Clean up temps
-        for r in dl_results:
-            for key in ['pcd_tmp', 'jpg_tmp']:
-                if key in r and Path(r[key]).exists():
-                    Path(r[key]).unlink()
-        return {'index': chunk['index'], 'name': chunk_name, 'status': 'error', 'errors': errors}
-    
-    # Create ZIP
-    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED, compresslevel=1) as zf:
-        for r in dl_results:
-            zf.write(r['pcd_tmp'], r['pcd_arc'])
-            if 'jpg_tmp' in r:
-                zf.write(r['jpg_tmp'], r['jpg_arc'])
-    
-    # Clean up temp files
-    for r in dl_results:
-        for key in ['pcd_tmp', 'jpg_tmp']:
-            if key in r and Path(r[key]).exists():
-                Path(r[key]).unlink()
-    
-    actual_size = zip_path.stat().st_size
-    return {'index': chunk['index'], 'name': chunk_name, 'status': 'ok', 'size': actual_size}
-
-# Process chunks one by one to manage disk space
-for i, chunk in enumerate(todo_chunks):
-    print(f"  Chunk {i+1}/{len(todo_chunks)}: {chunk['name']} ({chunk['total_size']/1e6:.0f} MB, {len(chunk['files'])} files)...", end=' ')
-    sys.stdout.flush()
-    result = process_chunk(chunk)
-    if result['status'] == 'ok':
-        print(f"OK ({result['size']/1e6:.0f} MB)")
-    elif result['status'] == 'error':
-        print(f"ERROR: {result['errors'][:2]}")
-    elif result['status'] == 'already_done':
-        print("already done")
-
-# Save updated plan (in case we need to resume)
-final_chunks = []
-for c in chunks:
-    zip_path = OUTPUT_DIR / c['name']
-    c['actual_size'] = zip_path.stat().st_size if zip_path.exists() else 0
-    final_chunks.append(c)
-with open(chunk_plan_path, 'wb') as f:
-    pickle.dump(final_chunks, f)
-
-print(f"\n[3] Done processing. Zips in {OUTPUT_DIR}:")
-for f in sorted(OUTPUT_DIR.glob('*.zip')):
-    print(f"  {f.name}: {f.stat().st_size / 1e6:.0f} MB")
-
-# ----- STEP 4: Update merged_result.parquet -----
-print("\n[4] Updating merged_result.parquet...")
-
-# Build PCD -> archive mapping
-pcd_to_archive = {}
-pcd_to_arcpath = {}
-for c in chunks:
-    zip_path = OUTPUT_DIR / c['name']
-    if not zip_path.exists():
-        continue
-    for f_info in c['files']:
-        pcd_path = f_info['pcd_path']
-        pcd_uuid = Path(pcd_path).stem
-        pcd_to_archive[pcd_path] = c['name']
-        pcd_to_arcpath[pcd_path] = f'pcd/{pcd_uuid}.pcd'
-
-# Update merged_result
-merged['archive'] = merged['path'].map(pcd_to_archive)
-merged['pcd_path'] = merged['path'].map(pcd_to_arcpath)
-
-# Build JPG path mapping
-jpg_to_arcpath = {}
-for c in chunks:
-    for f_info in c['files']:
-        if f_info['jpg_path']:
-            jpg_uuid = Path(f_info['jpg_path']).stem
-            jpg_to_arcpath[f_info['jpg_path']] = f'jpg/{jpg_uuid}.jpg'
-
-merged['jpg_path'] = merged['path_to_jpg'].map(jpg_to_arcpath)
-
-# Drop old path columns
-merged = merged.drop(columns=['path', 'path_to_jpg'])
-
-# Reorder columns
-col_order = ['frame_id', 'label', 'data', 'main_timestamp', 'bag_id', 'archive', 'pcd_path', 'jpg_path']
-available_cols = [c for c in col_order if c in merged.columns]
-merged = merged[available_cols]
-
-# Save updated merged_result
-merged.to_parquet('/workspace/merged_result.parquet')
-print(f"  Saved {len(merged)} rows to merged_result.parquet")
-print(f"  Columns: {merged.columns.tolist()}")
-
-# ----- STEP 5: Create archive_index.parquet -----
-print("\n[5] Creating archive_index.parquet...")
-archive_index = []
-for c in chunks:
-    zip_path = OUTPUT_DIR / c['name']
-    if not zip_path.exists():
-        continue
-    timestamps = [f['main_timestamp'] for f in c['files']]
-    archive_index.append({
-        'archive': c['name'],
-        'bag_ids': ','.join(c['bag_ids']),
-        'min_timestamp': min(timestamps),
-        'max_timestamp': max(timestamps),
-        'size_mb': round(zip_path.stat().st_size / 1e6, 1),
-        'file_count': len(c['files']),
-    })
-
-index_df = pd.DataFrame(archive_index)
-index_df.to_parquet('/workspace/archive_index.parquet')
-print(f"  Saved {len(index_df)} entries to archive_index.parquet")
-
-print("\nDone!")