diff --git "a/notebooks/01_data_exploration.ipynb" "b/notebooks/01_data_exploration.ipynb" new file mode 100644--- /dev/null +++ "b/notebooks/01_data_exploration.ipynb" @@ -0,0 +1,1055 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DVF Data Exploration & Analysis\n", + "\n", + "French property price analysis using DVF (Demandes de Valeurs Foncières) geolocalized data.\n", + "\n", + "**Pipeline**: Download → Clean → Compute Price/m² → Aggregate → Visualize\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0. Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup complete\n" + ] + } + ], + "source": [ + "import sys\n", + "sys.path.insert(0, '..')\n", + "\n", + "import polars as pl\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import logging\n", + "\n", + "logging.basicConfig(level=logging.INFO)\n", + "\n", + "from src.config import (\n", + " RAW_DIR, PROCESSED_DIR, AGGREGATED_DIR,\n", + " DVF_YEARS, TOP_10_CITIES, REGION_NAMES,\n", + " DEPT_TO_REGION, TYPE_LOCAL_SHORT, NO_DVF_DEPARTMENTS,\n", + ")\n", + "\n", + "plt.rcParams['figure.figsize'] = (14, 6)\n", + "plt.rcParams['figure.dpi'] = 100\n", + "sns.set_theme(style='whitegrid')\n", + "\n", + "print('Setup complete')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Download DVF Data\n", + "\n", + "Download the geolocalized DVF data for 2020-2024 (~500MB/year compressed)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:src.downloader:Cached: dvf_2020.csv.gz\n", + "INFO:src.downloader:Already decompressed: dvf_2020.csv\n", + "INFO:src.downloader:Cached: dvf_2021.csv.gz\n", + "INFO:src.downloader:Already decompressed: dvf_2021.csv\n", + "INFO:src.downloader:Cached: dvf_2022.csv.gz\n", + "INFO:src.downloader:Already decompressed: dvf_2022.csv\n", + "INFO:src.downloader:Cached: dvf_2023.csv.gz\n", + "INFO:src.downloader:Already decompressed: dvf_2023.csv\n", + "INFO:src.downloader:Cached: dvf_2024.csv.gz\n", + "INFO:src.downloader:Already decompressed: dvf_2024.csv\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Downloaded 5 files:\n", + " dvf_2020.csv: 358.2 MB\n", + " dvf_2021.csv: 814.5 MB\n", + " dvf_2022.csv: 815.2 MB\n", + " dvf_2023.csv: 662.1 MB\n", + " dvf_2024.csv: 605.8 MB\n" + ] + } + ], + "source": [ + "from src.downloader import download_all\n", + "\n", + "csv_paths = download_all()\n", + "print(f'\\nDownloaded {len(csv_paths)} files:')\n", + "for p in csv_paths:\n", + " size_mb = p.stat().st_size / 1e6\n", + " print(f' {p.name}: {size_mb:.1f} MB')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Load & Explore Raw Data\n", + "\n", + "Load one year first to understand the data structure." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exploring: dvf_2024.csv\n", + "\n", + "Shape: (100000, 16)\n", + "\n", + "Columns (16):\n", + " id_mutation String nulls: 0 (0.0%)\n", + " date_mutation String nulls: 0 (0.0%)\n", + " nature_mutation String nulls: 0 (0.0%)\n", + " valeur_fonciere Float64 nulls: 691 (0.7%)\n", + " code_postal String nulls: 183 (0.2%)\n", + " code_commune String nulls: 0 (0.0%)\n", + " nom_commune String nulls: 0 (0.0%)\n", + " code_departement String nulls: 0 (0.0%)\n", + " id_parcelle String nulls: 0 (0.0%)\n", + " code_type_local String nulls: 50,152 (50.2%)\n", + " type_local String nulls: 50,152 (50.2%)\n", + " surface_reelle_bati Int64 nulls: 72,828 (72.8%)\n", + " nombre_pieces_principales Int64 nulls: 50,266 (50.3%)\n", + " nombre_lots Int64 nulls: 0 (0.0%)\n", + " longitude Float64 nulls: 726 (0.7%)\n", + " latitude Float64 nulls: 726 (0.7%)\n" + ] + } + ], + "source": [ + "from src.cleaner import load_raw_csv\n", + "\n", + "# Load latest year for exploration\n", + "latest = sorted(csv_paths)[-1]\n", + "print(f'Exploring: {latest.name}')\n", + "\n", + "df_sample = load_raw_csv(latest).head(100_000).collect()\n", + "print(f'\\nShape: {df_sample.shape}')\n", + "print(f'\\nColumns ({len(df_sample.columns)}):')\n", + "for col in df_sample.columns:\n", + " dtype = df_sample[col].dtype\n", + " nulls = df_sample[col].null_count()\n", + " pct = nulls / len(df_sample) * 100\n", + " print(f' {col:30s} {str(dtype):15s} nulls: {nulls:,} ({pct:.1f}%)')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (5, 16)
id_mutationdate_mutationnature_mutationvaleur_foncierecode_postalcode_communenom_communecode_departementid_parcellecode_type_localtype_localsurface_reelle_batinombre_pieces_principalesnombre_lotslongitudelatitude
strstrstrf64strstrstrstrstrstrstri64i64i64f64f64
"2024-1""2024-01-02""Vente"346.5"01230""01076""Chaley""01""010760000B0514"nullnullnullnull05.53095245.952439
"2024-2""2024-01-03""Vente"10000.0"01170""01103""Chevry""01""011030000B1782"nullnullnullnull06.04333946.282256
"2024-3""2024-01-08""Vente"249000.0"01290""01203""Laiz""01""012030000C1065"nullnullnullnull04.91114346.247235
"2024-4""2024-01-03""Vente"329500.0"01170""01173""Gex""01""01173000AI0551""2""Appartement"89426.05869546.332212
"2024-4""2024-01-03""Vente"329500.0"01170""01173""Gex""01""01173000AI0551""3""Dépendance"null016.05869546.332212
" + ], + "text/plain": [ + "shape: (5, 16)\n", + "┌───────────┬───────────┬───────────┬───────────┬───┬───────────┬───────────┬───────────┬──────────┐\n", + "│ id_mutati ┆ date_muta ┆ nature_mu ┆ valeur_fo ┆ … ┆ nombre_pi ┆ nombre_lo ┆ longitude ┆ latitude │\n", + "│ on ┆ tion ┆ tation ┆ nciere ┆ ┆ eces_prin ┆ ts ┆ --- ┆ --- │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ cipales ┆ --- ┆ f64 ┆ f64 │\n", + "│ str ┆ str ┆ str ┆ f64 ┆ ┆ --- ┆ i64 ┆ ┆ │\n", + "│ ┆ ┆ ┆ ┆ ┆ i64 ┆ ┆ ┆ │\n", + "╞═══════════╪═══════════╪═══════════╪═══════════╪═══╪═══════════╪═══════════╪═══════════╪══════════╡\n", + "│ 2024-1 ┆ 2024-01-0 ┆ Vente ┆ 346.5 ┆ … ┆ null ┆ 0 ┆ 5.530952 ┆ 45.95243 │\n", + "│ ┆ 2 ┆ ┆ ┆ ┆ ┆ ┆ ┆ 9 │\n", + "│ 2024-2 ┆ 2024-01-0 ┆ Vente ┆ 10000.0 ┆ … ┆ null ┆ 0 ┆ 6.043339 ┆ 46.28225 │\n", + "│ ┆ 3 ┆ ┆ ┆ ┆ ┆ ┆ ┆ 6 │\n", + "│ 2024-3 ┆ 2024-01-0 ┆ Vente ┆ 249000.0 ┆ … ┆ null ┆ 0 ┆ 4.911143 ┆ 46.24723 │\n", + "│ ┆ 8 ┆ ┆ ┆ ┆ ┆ ┆ ┆ 5 │\n", + "│ 2024-4 ┆ 2024-01-0 ┆ Vente ┆ 329500.0 ┆ … ┆ 4 ┆ 2 ┆ 6.058695 ┆ 46.33221 │\n", + "│ ┆ 3 ┆ ┆ ┆ ┆ ┆ ┆ ┆ 2 │\n", + "│ 2024-4 ┆ 2024-01-0 ┆ Vente ┆ 329500.0 ┆ … ┆ 0 ┆ 1 ┆ 6.058695 ┆ 46.33221 │\n", + "│ ┆ 3 ┆ ┆ ┆ ┆ ┆ ┆ ┆ 2 │\n", + "└───────────┴───────────┴───────────┴───────────┴───┴───────────┴───────────┴───────────┴──────────┘" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Sample rows\n", + "df_sample.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== nature_mutation ===\n", + "shape: (6, 2)\n", + "┌─────────────────────────────────┬───────┐\n", + "│ nature_mutation ┆ count │\n", + "│ --- ┆ --- │\n", + "│ str ┆ u32 │\n", + "╞═════════════════════════════════╪═══════╡\n", + "│ Vente ┆ 95878 │\n", + "│ Vente en l'état futur d'achève… ┆ 2440 │\n", + "│ Echange ┆ 1262 │\n", + "│ Adjudication ┆ 220 │\n", + "│ Vente terrain à bâtir ┆ 198 │\n", + "│ Expropriation ┆ 2 │\n", + "└─────────────────────────────────┴───────┘\n", + "\n", + "=== type_local ===\n", + "shape: (5, 2)\n", + "┌─────────────────────────────────┬───────┐\n", + "│ type_local ┆ count │\n", + "│ --- ┆ --- │\n", + "│ str ┆ u32 │\n", + "╞═════════════════════════════════╪═══════╡\n", + "│ null ┆ 50152 │\n", + "│ Dépendance ┆ 22407 │\n", + "│ Maison ┆ 17015 │\n", + "│ Appartement ┆ 7738 │\n", + "│ Local industriel. commercial o… ┆ 2688 │\n", + "└─────────────────────────────────┴───────┘\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_34103/1144193474.py:3: DeprecationWarning: `pl.count()` is deprecated. Please use `pl.len()` instead.\n", + "(Deprecated in version 0.20.5)\n", + " print(df_sample.group_by('nature_mutation').agg(pl.count().alias('count')).sort('count', descending=True))\n", + "/tmp/ipykernel_34103/1144193474.py:6: DeprecationWarning: `pl.count()` is deprecated. Please use `pl.len()` instead.\n", + "(Deprecated in version 0.20.5)\n", + " print(df_sample.group_by('type_local').agg(pl.count().alias('count')).sort('count', descending=True))\n" + ] + } + ], + "source": [ + "# Distribution of nature_mutation\n", + "print('=== nature_mutation ===')\n", + "print(df_sample.group_by('nature_mutation').agg(pl.count().alias('count')).sort('count', descending=True))\n", + "\n", + "print('\\n=== type_local ===')\n", + "print(df_sample.group_by('type_local').agg(pl.count().alias('count')).sort('count', descending=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Distribution of valeur_fonciere (raw)\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "\n", + "vals = df_sample.filter(\n", + " pl.col('valeur_fonciere').is_not_null() & (pl.col('valeur_fonciere') > 0)\n", + ")['valeur_fonciere'].to_list()\n", + "\n", + "axes[0].hist(vals, bins=100, edgecolor='black', alpha=0.7)\n", + "axes[0].set_title('Raw valeur_fonciere distribution')\n", + "axes[0].set_xlabel('Price (EUR)')\n", + "\n", + "# Log scale\n", + "axes[1].hist(vals, bins=100, edgecolor='black', alpha=0.7, log=True)\n", + "axes[1].set_title('Raw valeur_fonciere (log scale)')\n", + "axes[1].set_xlabel('Price (EUR)')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Run Cleaning Pipeline\n", + "\n", + "Apply the full cleaning pipeline on all years." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading all years...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_34103/3610840135.py:6: DeprecationWarning: `pl.count()` is deprecated. Please use `pl.len()` instead.\n", + "(Deprecated in version 0.20.5)\n", + " n_raw = lf_raw.select(pl.count()).collect().item()\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Raw rows: 18,715,662\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_34103/3610840135.py:11: DeprecationWarning: `pl.count()` is deprecated. Please use `pl.len()` instead.\n", + "(Deprecated in version 0.20.5)\n", + " n_sales = lf_sales.select(pl.count()).collect().item()\n", + "INFO:src.cleaner:Loading 5 raw files...\n", + "INFO:src.cleaner:Filtering sales...\n", + "INFO:src.cleaner:Deduplicating mutations...\n", + "INFO:src.cleaner:Adding derived columns...\n", + "INFO:src.cleaner:Removing outliers...\n", + "INFO:src.cleaner:Normalizing commune codes...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "After filtering to sales: 6,183,929 (33.0%)\n", + "\n", + "Running full cleaning pipeline...\n", + "\n", + "Final clean dataset: 4,410,655 transactions\n", + "Columns: ['id_mutation', 'date_mutation', 'nature_mutation', 'valeur_fonciere', 'code_postal', 'code_commune', 'nom_commune', 'code_departement', 'id_parcelle', 'type_local', 'surface_reelle_bati', 'nombre_pieces_principales', 'nombre_lots', 'longitude', 'latitude', 'prix_m2', 'code_section', 'code_region', 'year', 'code_commune_city', 'code_commune_original']\n" + ] + } + ], + "source": [ + "from src.cleaner import clean, load_multiple_csvs, filter_sales\n", + "\n", + "# Load all years\n", + "print('Loading all years...')\n", + "lf_raw = load_multiple_csvs(csv_paths)\n", + "n_raw = lf_raw.select(pl.count()).collect().item()\n", + "print(f'Raw rows: {n_raw:,}')\n", + "\n", + "# After filtering sales\n", + "lf_sales = filter_sales(lf_raw)\n", + "n_sales = lf_sales.select(pl.count()).collect().item()\n", + "print(f'After filtering to sales: {n_sales:,} ({n_sales/n_raw*100:.1f}%)')\n", + "\n", + "# Full pipeline\n", + "print('\\nRunning full cleaning pipeline...')\n", + "lf_clean = clean(csv_paths)\n", + "df_clean = lf_clean.collect()\n", + "print(f'\\nFinal clean dataset: {len(df_clean):,} transactions')\n", + "print(f'Columns: {df_clean.columns}')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved: dvf_clean.parquet (227.1 MB)\n" + ] + } + ], + "source": [ + "# Save cleaned data for reuse\n", + "PROCESSED_DIR.mkdir(parents=True, exist_ok=True)\n", + "parquet_path = PROCESSED_DIR / 'dvf_clean.parquet'\n", + "df_clean.write_parquet(parquet_path)\n", + "size_mb = parquet_path.stat().st_size / 1e6\n", + "print(f'Saved: {parquet_path.name} ({size_mb:.1f} MB)')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "shape: (5, 21)
id_mutationdate_mutationnature_mutationvaleur_foncierecode_postalcode_communenom_communecode_departementid_parcelletype_localsurface_reelle_batinombre_pieces_principalesnombre_lotslongitudelatitudeprix_m2code_sectioncode_regionyearcode_commune_citycode_commune_original
strstrstrf64strstrstrstrstrstri64i64i64f64f64f64strstrstrstrstr
"2023-418148""2023-12-19""Vente"171000.0"33170""33192""Gradignan""33""33192000BH0158""Appartement"4421-0.60030944.7852463886.363636"33192000BH""75""2023""33192""33192"
"2024-17433""2024-07-15""Vente"100000.0"02290""02326""Fontenoy""02""02326000AH0046""Maison"97403.20529149.4086831030.927835"02326000AH""32""2024""02326""02326"
"2021-504860""2021-02-18""Vente"254500.0"33700""33281""Mérignac""33""33281000BL0757""Maison"5630-0.65022844.8564024544.642857"33281000BL""75""2021""33281""33281"
"2022-882228""2022-06-24""Vente"407000.0"54136""54090""Bouxières-aux-Dames""54""540900000B0683""Appartement"207446.17022948.7505341966.183575"540900000B""44""2022""54090""54090"
"2020-246142""2020-11-25""Vente"333500.0"33000""33063""Bordeaux""33""33063000KE0074""Appartement"6021-0.5814144.8384535558.333333"33063000KE""75""2020""33063""33063"
" + ], + "text/plain": [ + "shape: (5, 21)\n", + "┌────────────┬────────────┬────────────┬────────────┬───┬───────────┬──────┬───────────┬───────────┐\n", + "│ id_mutatio ┆ date_mutat ┆ nature_mut ┆ valeur_fon ┆ … ┆ code_regi ┆ year ┆ code_comm ┆ code_comm │\n", + "│ n ┆ ion ┆ ation ┆ ciere ┆ ┆ on ┆ --- ┆ une_city ┆ une_origi │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ┆ --- ┆ str ┆ --- ┆ nal │\n", + "│ str ┆ str ┆ str ┆ f64 ┆ ┆ str ┆ ┆ str ┆ --- │\n", + "│ ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ str │\n", + "╞════════════╪════════════╪════════════╪════════════╪═══╪═══════════╪══════╪═══════════╪═══════════╡\n", + "│ 2023-41814 ┆ 2023-12-19 ┆ Vente ┆ 171000.0 ┆ … ┆ 75 ┆ 2023 ┆ 33192 ┆ 33192 │\n", + "│ 8 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ 2024-17433 ┆ 2024-07-15 ┆ Vente ┆ 100000.0 ┆ … ┆ 32 ┆ 2024 ┆ 02326 ┆ 02326 │\n", + "│ 2021-50486 ┆ 2021-02-18 ┆ Vente ┆ 254500.0 ┆ … ┆ 75 ┆ 2021 ┆ 33281 ┆ 33281 │\n", + "│ 0 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ 2022-88222 ┆ 2022-06-24 ┆ Vente ┆ 407000.0 ┆ … ┆ 44 ┆ 2022 ┆ 54090 ┆ 54090 │\n", + "│ 8 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "│ 2020-24614 ┆ 2020-11-25 ┆ Vente ┆ 333500.0 ┆ … ┆ 75 ┆ 2020 ┆ 33063 ┆ 33063 │\n", + "│ 2 ┆ ┆ ┆ ┆ ┆ ┆ ┆ ┆ │\n", + "└────────────┴────────────┴────────────┴────────────┴───┴───────────┴──────┴───────────┴───────────┘" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_clean.head(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Price/m² Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Price/m² Summary ===\n", + "shape: (9, 2)\n", + "┌────────────┬─────────────┐\n", + "│ statistic ┆ prix_m2 │\n", + "│ --- ┆ --- │\n", + "│ str ┆ f64 │\n", + "╞════════════╪═════════════╡\n", + "│ count ┆ 4.410655e6 │\n", + "│ null_count ┆ 0.0 │\n", + "│ mean ┆ 2948.006941 │\n", + "│ std ┆ 2465.902444 │\n", + "│ min ┆ 200.0 │\n", + "│ 25% ┆ 1356.164384 │\n", + "│ 50% ┆ 2300.0 │\n", + "│ 75% ┆ 3683.673469 │\n", + "│ max ┆ 25000.0 │\n", + "└────────────┴─────────────┘\n", + "\n", + "=== By Property Type ===\n", + "Appartement median: 3,100 EUR/m² volume: 1,845,785\n", + "Maison median: 1,855 EUR/m² volume: 2,382,588\n", + "Local industriel. commercial ou assimilé median: 1,585 EUR/m² volume: 182,282\n" + ] + } + ], + "source": [ + "# Overall price/m² statistics\n", + "print('=== Price/m² Summary ===')\n", + "print(df_clean.select('prix_m2').describe())\n", + "\n", + "# By property type\n", + "print('\\n=== By Property Type ===')\n", + "from src.config import VALID_TYPE_LOCAL\n", + "for ptype in VALID_TYPE_LOCAL:\n", + " subset = df_clean.filter(pl.col('type_local') == ptype)\n", + " med = subset['prix_m2'].median()\n", + " vol = len(subset)\n", + " print(f'{ptype:50s} median: {med:,.0f} EUR/m² volume: {vol:,}')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Price/m² distribution by property type\n", + "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n", + "\n", + "for ax, ptype in zip(axes, VALID_TYPE_LOCAL):\n", + " vals = df_clean.filter(pl.col('type_local') == ptype)['prix_m2'].to_list()\n", + " short = TYPE_LOCAL_SHORT.get(ptype, ptype)\n", + " ax.hist(vals, bins=100, edgecolor='black', alpha=0.7, range=(0, 15000))\n", + " ax.set_title(f'{short}\\n(n={len(vals):,})')\n", + " ax.set_xlabel('Price/m² (EUR)')\n", + " ax.axvline(x=pl.Series(vals).median(), color='red', linestyle='--', label=f'median={pl.Series(vals).median():.0f}')\n", + " ax.legend()\n", + "\n", + "plt.suptitle('Price/m² Distribution by Property Type', fontsize=14, y=1.02)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Geographic coverage:\n", + " Departments: 97\n", + " Communes: 33,218\n", + " Postcodes: 5,861\n", + " Sections: 257,819\n", + "\n", + "=== Transactions by Year ===\n", + "shape: (5, 2)\n", + "┌──────┬─────────┐\n", + "│ year ┆ count │\n", + "│ --- ┆ --- │\n", + "│ str ┆ u32 │\n", + "╞══════╪═════════╡\n", + "│ 2020 ┆ 551479 │\n", + "│ 2021 ┆ 1131286 │\n", + "│ 2022 ┆ 1086453 │\n", + "│ 2023 ┆ 861481 │\n", + "│ 2024 ┆ 779956 │\n", + "└──────┴─────────┘\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_34103/358890167.py:15: DeprecationWarning: `pl.count()` is deprecated. Please use `pl.len()` instead.\n", + "(Deprecated in version 0.20.5)\n", + " print(df_clean.group_by('year').agg(pl.count().alias('count')).sort('year'))\n" + ] + } + ], + "source": [ + "# Geographic coverage\n", + "n_depts = df_clean['code_departement'].n_unique()\n", + "n_communes = df_clean['code_commune'].n_unique()\n", + "n_postcodes = df_clean['code_postal'].n_unique()\n", + "n_sections = df_clean['code_section'].n_unique()\n", + "\n", + "print(f'Geographic coverage:')\n", + "print(f' Departments: {n_depts}')\n", + "print(f' Communes: {n_communes:,}')\n", + "print(f' Postcodes: {n_postcodes:,}')\n", + "print(f' Sections: {n_sections:,}')\n", + "\n", + "# Year distribution\n", + "print('\\n=== Transactions by Year ===')\n", + "print(df_clean.group_by('year').agg(pl.count().alias('count')).sort('year'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Aggregation at All Levels" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:src.aggregator:Aggregating level: country (group by _country)\n", + "INFO:src.aggregator: → 4 rows (1 unique codes)\n", + "INFO:src.aggregator:Aggregating level: region (group by code_region)\n", + "INFO:src.aggregator: → 68 rows (17 unique codes)\n", + "INFO:src.aggregator:Aggregating level: department (group by code_departement)\n", + "INFO:src.aggregator: → 388 rows (97 unique codes)\n", + "INFO:src.aggregator:Aggregating level: commune (group by code_commune)\n", + "INFO:src.aggregator: → 93003 rows (33218 unique codes)\n", + "INFO:src.aggregator:Aggregating level: postcode (group by code_postal)\n", + "INFO:src.aggregator: → 22757 rows (5861 unique codes)\n", + "INFO:src.aggregator:Aggregating level: section (group by code_section)\n", + "INFO:src.aggregator: → 617716 rows (257819 unique codes)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "country : 4 rows (1 unique codes × 4 types)\n", + "region : 68 rows (17 unique codes × 4 types)\n", + "department : 388 rows (97 unique codes × 4 types)\n", + "commune : 93,003 rows (33,218 unique codes × 2 types)\n", + "postcode : 22,757 rows (5,861 unique codes × 3 types)\n", + "section : 617,716 rows (257,819 unique codes × 2 types)\n" + ] + } + ], + "source": [ + "from src.aggregator import aggregate_all_levels, export_json\n", + "\n", + "lf_clean = df_clean.lazy()\n", + "aggregated = aggregate_all_levels(lf_clean)\n", + "\n", + "for level, df_agg in aggregated.items():\n", + " n_codes = df_agg['code'].n_unique()\n", + " print(f'{level:15s}: {len(df_agg):,} rows ({n_codes:,} unique codes × {len(df_agg)//max(n_codes,1)} types)')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Top 10 Most Expensive Departments ===\n", + "shape: (10, 4)\n", + "┌──────┬─────────────────┬────────┬────────────┐\n", + "│ code ┆ median_price_m2 ┆ volume ┆ confidence │\n", + "│ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ u32 ┆ f64 │\n", + "╞══════╪═════════════════╪════════╪════════════╡\n", + "│ 75 ┆ 10333.333333 ┆ 147539 ┆ 0.864 │\n", + "│ 92 ┆ 6896.609195 ┆ 90968 ┆ 0.821 │\n", + "│ 94 ┆ 4918.918919 ┆ 71033 ┆ 0.77 │\n", + "│ 06 ┆ 4318.181818 ┆ 127009 ┆ 0.775 │\n", + "│ 74 ┆ 3984.375 ┆ 71885 ┆ 0.774 │\n", + "│ 93 ┆ 3925.353234 ┆ 66278 ┆ 0.76 │\n", + "│ 78 ┆ 3800.0 ┆ 82039 ┆ 0.757 │\n", + "│ 69 ┆ 3666.666667 ┆ 115504 ┆ 0.759 │\n", + "│ 2A ┆ 3559.819519 ┆ 10404 ┆ 0.711 │\n", + "│ 95 ┆ 3408.627998 ┆ 64618 ┆ 0.824 │\n", + "└──────┴─────────────────┴────────┴────────────┘\n", + "\n", + "=== Top 10 Cheapest Departments ===\n", + "shape: (10, 4)\n", + "┌──────┬─────────────────┬────────┬────────────┐\n", + "│ code ┆ median_price_m2 ┆ volume ┆ confidence │\n", + "│ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ u32 ┆ f64 │\n", + "╞══════╪═════════════════╪════════╪════════════╡\n", + "│ 08 ┆ 1042.659293 ┆ 15324 ┆ 0.684 │\n", + "│ 61 ┆ 1011.834734 ┆ 20076 ┆ 0.68 │\n", + "│ 18 ┆ 1000.0 ┆ 22752 ┆ 0.664 │\n", + "│ 70 ┆ 972.222222 ┆ 13458 ┆ 0.683 │\n", + "│ 03 ┆ 967.741935 ┆ 25834 ┆ 0.662 │\n", + "│ 55 ┆ 903.614458 ┆ 10915 ┆ 0.666 │\n", + "│ 36 ┆ 892.857143 ┆ 15961 ┆ 0.687 │\n", + "│ 58 ┆ 888.888889 ┆ 17109 ┆ 0.685 │\n", + "│ 52 ┆ 887.096774 ┆ 9993 ┆ 0.65 │\n", + "│ 23 ┆ 708.333333 ┆ 9832 ┆ 0.67 │\n", + "└──────┴─────────────────┴────────┴────────────┘\n" + ] + } + ], + "source": [ + "# Show department-level aggregation (tous)\n", + "df_dept = aggregated['department'].filter(pl.col('type') == 'tous').sort('median_price_m2', descending=True)\n", + "print('=== Top 10 Most Expensive Departments ===')\n", + "print(df_dept.head(10).select(['code', 'median_price_m2', 'volume', 'confidence']))\n", + "\n", + "print('\\n=== Top 10 Cheapest Departments ===')\n", + "print(df_dept.tail(10).select(['code', 'median_price_m2', 'volume', 'confidence']))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Department prices bar chart\n", + "fig, ax = plt.subplots(figsize=(16, 8))\n", + "dept_data = df_dept.sort('median_price_m2', descending=True)\n", + "codes = dept_data['code'].to_list()\n", + "prices = dept_data['median_price_m2'].to_list()\n", + "\n", + "colors = ['#CC000A' if p > 5000 else '#FFF64E' if p > 2500 else '#028758' for p in prices]\n", + "ax.bar(range(len(codes)), prices, color=colors, edgecolor='black', linewidth=0.3)\n", + "ax.set_xticks(range(len(codes)))\n", + "ax.set_xticklabels(codes, rotation=90, fontsize=7)\n", + "ax.set_ylabel('Median Price/m² (EUR)')\n", + "ax.set_title('Median Price/m² by Department (All Property Types)')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Prices by Region ===\n", + "shape: (17, 4)\n", + "┌────────────────────────────┬─────────────────┬────────┬────────────┐\n", + "│ region_name ┆ median_price_m2 ┆ volume ┆ confidence │\n", + "│ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ u32 ┆ f64 │\n", + "╞════════════════════════════╪═════════════════╪════════╪════════════╡\n", + "│ Île-de-France ┆ 4545.454545 ┆ 680691 ┆ 0.6 │\n", + "│ Provence-Alpes-Côte d'Azur ┆ 3362.068966 ┆ 455597 ┆ 0.707 │\n", + "│ Corse ┆ 3151.083047 ┆ 21106 ┆ 0.722 │\n", + "│ Guadeloupe ┆ 2830.188679 ┆ 10305 ┆ 0.695 │\n", + "│ Martinique ┆ 2500.0 ┆ 9344 ┆ 0.703 │\n", + "│ … ┆ … ┆ … ┆ … │\n", + "│ Normandie ┆ 1763.888889 ┆ 240293 ┆ 0.672 │\n", + "│ Hauts-de-France ┆ 1733.333333 ┆ 355017 ┆ 0.687 │\n", + "│ Centre-Val de Loire ┆ 1485.714286 ┆ 179969 ┆ 0.653 │\n", + "│ Grand Est ┆ 1414.634146 ┆ 165348 ┆ 0.665 │\n", + "│ Bourgogne-Franche-Comté ┆ 1391.025641 ┆ 195184 ┆ 0.647 │\n", + "└────────────────────────────┴─────────────────┴────────┴────────────┘\n" + ] + } + ], + "source": [ + "# Region-level aggregation\n", + "df_region = aggregated['region'].filter(pl.col('type') == 'tous').sort('median_price_m2', descending=True)\n", + "\n", + "# Add region names\n", + "region_name_map = {code: name for code, name in REGION_NAMES.items()}\n", + "df_region = df_region.with_columns(\n", + " pl.col('code').replace_strict(region_name_map, default='Unknown').alias('region_name')\n", + ")\n", + "\n", + "print('=== Prices by Region ===')\n", + "print(df_region.select(['region_name', 'median_price_m2', 'volume', 'confidence']))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Top 10 Cities" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Top 10 Cities: All Property Types ===\n", + "shape: (9, 5)\n", + "┌─────────────┬─────────────────┬────────┬─────────────┬─────────────┐\n", + "│ city_name ┆ median_price_m2 ┆ volume ┆ q1 ┆ q3 │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ u32 ┆ f64 ┆ f64 │\n", + "╞═════════════╪═════════════════╪════════╪═════════════╪═════════════╡\n", + "│ Paris ┆ 10333.333333 ┆ 147539 ┆ 8603.181818 ┆ 12125.0 │\n", + "│ Lyon ┆ 4819.487847 ┆ 36234 ┆ 3789.928571 ┆ 5744.680851 │\n", + "│ Bordeaux ┆ 4600.0 ┆ 23735 ┆ 3731.343284 ┆ 5575.97561 │\n", + "│ Nice ┆ 4390.243902 ┆ 39344 ┆ 3388.888889 ┆ 5575.757576 │\n", + "│ Nantes ┆ 3814.43299 ┆ 26835 ┆ 3068.181818 ┆ 4593.023256 │\n", + "│ Lille ┆ 3409.090909 ┆ 19293 ┆ 2604.044118 ┆ 4319.5 │\n", + "│ Toulouse ┆ 3275.0 ┆ 39999 ┆ 2558.333333 ┆ 4230.769231 │\n", + "│ Montpellier ┆ 3274.232697 ┆ 24732 ┆ 2500.0 ┆ 4043.478261 │\n", + "│ Marseille ┆ 3009.708738 ┆ 65877 ┆ 2103.448276 ┆ 4069.767442 │\n", + "└─────────────┴─────────────────┴────────┴─────────────┴─────────────┘\n" + ] + } + ], + "source": [ + "from src.top_cities import compute_top_cities\n", + "\n", + "df_cities = compute_top_cities(lf_clean)\n", + "print('=== Top 10 Cities: All Property Types ===')\n", + "print(\n", + " df_cities.filter(pl.col('type') == 'tous')\n", + " .sort('median_price_m2', descending=True)\n", + " .select(['city_name', 'median_price_m2', 'volume', 'q1', 'q3'])\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Top 10 cities breakdown by property type\n", + "fig, ax = plt.subplots(figsize=(14, 7))\n", + "\n", + "cities = df_cities.filter(pl.col('type') == 'tous').sort('median_price_m2', descending=True)['city_name'].to_list()\n", + "x = range(len(cities))\n", + "width = 0.25\n", + "\n", + "for i, ptype in enumerate(['tous', 'appartement', 'maison']):\n", + " subset = df_cities.filter(pl.col('type') == ptype)\n", + " # Reorder to match cities order\n", + " prices = []\n", + " for city in cities:\n", + " row = subset.filter(pl.col('city_name') == city)\n", + " prices.append(row['median_price_m2'][0] if len(row) > 0 else 0)\n", + " ax.bar([xi + i * width for xi in x], prices, width, label=ptype, alpha=0.85)\n", + "\n", + "ax.set_xticks([xi + width for xi in x])\n", + "ax.set_xticklabels(cities, rotation=45, ha='right')\n", + "ax.set_ylabel('Median Price/m² (EUR)')\n", + "ax.set_title('Top 10 Cities: Price/m² by Property Type')\n", + "ax.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Export Aggregated Data" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:src.aggregator:Exported: prices_country.json (1 entries)\n", + "INFO:src.aggregator:Exported: prices_region.json (17 entries)\n", + "INFO:src.aggregator:Exported: prices_department.json (97 entries)\n", + "INFO:src.aggregator:Exported: prices_commune.json (33218 entries)\n", + "INFO:src.aggregator:Exported: prices_postcode.json (5861 entries)\n", + "INFO:src.aggregator:Exported: prices_section.json (257819 entries)\n", + "INFO:src.top_cities:Exported: top_cities.json (9 cities)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Exported files:\n", + " prices_commune.json: 10335.7 KB\n", + " prices_country.json: 0.5 KB\n", + " prices_department.json: 43.8 KB\n", + " prices_postcode.json: 2537.7 KB\n", + " prices_region.json: 7.7 KB\n", + " prices_section.json: 69924.4 KB\n", + " top_cities.json: 5.1 KB\n" + ] + } + ], + "source": [ + "from src.aggregator import export_json\n", + "from src.top_cities import export_top_cities\n", + "\n", + "export_json(aggregated)\n", + "export_top_cities(df_cities)\n", + "\n", + "print('\\nExported files:')\n", + "for f in sorted(AGGREGATED_DIR.glob('*.json')):\n", + " size_kb = f.stat().st_size / 1e3\n", + " print(f' {f.name}: {size_kb:.1f} KB')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Data Quality Summary" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "DATA QUALITY SUMMARY\n", + "============================================================\n", + "Years covered: 2020-2024\n", + "Total clean transactions: 4,410,655\n", + "Departments covered: 97\n", + "Missing departments: {'57', '68', '67', '976'}\n", + "Communes covered: 33,218\n", + "Postcodes covered: 5,861\n", + "Sections covered: 257,819\n", + "\n", + "Property type breakdown:\n", + " appartement 1,845,785 (41.8%) median: 3,100 EUR/m²\n", + " maison 2,382,588 (54.0%) median: 1,855 EUR/m²\n", + " local 182,282 (4.1%) median: 1,585 EUR/m²\n", + "\n", + "National median (tous): 2,300 EUR/m²\n", + "National mean (tous): 2,948 EUR/m²\n" + ] + } + ], + "source": [ + "print('=' * 60)\n", + "print('DATA QUALITY SUMMARY')\n", + "print('=' * 60)\n", + "print(f'Years covered: {DVF_YEARS[0]}-{DVF_YEARS[-1]}')\n", + "print(f'Total clean transactions: {len(df_clean):,}')\n", + "print(f'Departments covered: {df_clean[\"code_departement\"].n_unique()}')\n", + "print(f'Missing departments: {NO_DVF_DEPARTMENTS}')\n", + "print(f'Communes covered: {df_clean[\"code_commune\"].n_unique():,}')\n", + "print(f'Postcodes covered: {df_clean[\"code_postal\"].n_unique():,}')\n", + "print(f'Sections covered: {df_clean[\"code_section\"].n_unique():,}')\n", + "print()\n", + "print('Property type breakdown:')\n", + "for ptype in VALID_TYPE_LOCAL:\n", + " n = len(df_clean.filter(pl.col('type_local') == ptype))\n", + " pct = n / len(df_clean) * 100\n", + " med = df_clean.filter(pl.col('type_local') == ptype)['prix_m2'].median()\n", + " short = TYPE_LOCAL_SHORT.get(ptype, ptype)\n", + " print(f' {short:20s} {n:>10,} ({pct:.1f}%) median: {med:,.0f} EUR/m²')\n", + "print()\n", + "print(f'National median (tous): {df_clean[\"prix_m2\"].median():,.0f} EUR/m²')\n", + "print(f'National mean (tous): {df_clean[\"prix_m2\"].mean():,.0f} EUR/m²')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "realadvisor-mle-challenge", + "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.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}