diff --git a/distillation/analysis.ipynb b/distillation/analysis.ipynb new file mode 100644 index 0000000..b8d0b26 --- /dev/null +++ b/distillation/analysis.ipynb @@ -0,0 +1,1433 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training Data vs Model Output Distribution Analysis\n", + "\n", + "Goal: Compare relation/type distributions in training data vs model predictions to identify data skew and model biases." + ], + "id": "34fa91527cc2111a" + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Setup and Load Data" + ], + "id": "51fe592b4f0c8e36" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:17:03.023475Z", + "start_time": "2026-05-04T13:17:01.960810Z" + } + }, + "source": [ + "import json\n", + "from pathlib import Path\n", + "from collections import Counter\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "TRAIN_PATH = Path(\"./data/train.jsonl\")\n", + "VAL_PATH = Path(\"./data/val.jsonl\")\n", + "\n", + "def load_jsonl(path):\n", + " with open(path, \"r\", encoding=\"utf-8\") as f:\n", + " return [json.loads(line) for line in f]\n", + "\n", + "train_data = load_jsonl(TRAIN_PATH)\n", + "val_data = load_jsonl(VAL_PATH)\n", + "\n", + "print(f\"Train examples: {len(train_data)}\")\n", + "print(f\"Val examples: {len(val_data)}\")" + ], + "id": "e6ef21d00b6e2f54", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train examples: 1800\n", + "Val examples: 199\n" + ] + } + ], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Parse Triplets from Training Data\n", + "\n", + "Training data is in prompt/completion format. We parse the JSON from completions." + ], + "id": "297d2a857a28e14a" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:21:15.022160Z", + "start_time": "2026-05-04T13:21:15.019082Z" + } + }, + "cell_type": "code", + "source": "train_data[0][\"messages\"][2][\"content\"]", + "id": "7905b562cdf2d13f", + "outputs": [ + { + "data": { + "text/plain": [ + "'{\"triplets\": [{\"subject\": \"John David McPhun\", \"object\": \"September 8, 1940\", \"subject_type\": \"human\", \"object_type\": \"calendar date\", \"relation\": \"date of birth\", \"qualifiers\": []}, {\"subject\": \"John David McPhun\", \"object\": \"Salisbury, Rhodesia\", \"subject_type\": \"human\", \"object_type\": \"geographic location\", \"relation\": \"place of birth\", \"qualifiers\": []}, {\"subject\": \"John David McPhun\", \"object\": \"first-class cricketer\", \"subject_type\": \"human\", \"object_type\": \"profession\", \"relation\": \"occupation\", \"qualifiers\": []}, {\"subject\": \"John David McPhun\", \"object\": \"Rhodesia cricket team\", \"subject_type\": \"human\", \"object_type\": \"sports team\", \"relation\": \"member of sports team\", \"qualifiers\": []}, {\"subject\": \"Rhodesia cricket team\", \"object\": \"Currie Cup\", \"subject_type\": \"sports team\", \"object_type\": \"sports competition\", \"relation\": \"participant in\", \"qualifiers\": []}]}'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 12 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:22:48.394660Z", + "start_time": "2026-05-04T13:22:48.341887Z" + } + }, + "source": [ + "def parse_completion_triplets(example):\n", + " \"\"\"Extract triplets from the completion field.\"\"\"\n", + " completion = example.get(\"messages\")[2][\"content\"]\n", + " try:\n", + " data = json.loads(completion)\n", + " if isinstance(data, dict) and \"triplets\" in data:\n", + " return data[\"triplets\"]\n", + " except (json.JSONDecodeError, TypeError):\n", + " pass\n", + " return []\n", + "\n", + "train_triplets = []\n", + "train_parse_failures = 0\n", + "for ex in train_data:\n", + " triplets = parse_completion_triplets(ex)\n", + " if not triplets:\n", + " train_parse_failures += 1\n", + " train_triplets.extend(triplets)\n", + "\n", + "val_triplets_gt = []\n", + "val_parse_failures = 0\n", + "for ex in val_data:\n", + " triplets = parse_completion_triplets(ex)\n", + " if not triplets:\n", + " val_parse_failures += 1\n", + " val_triplets_gt.extend(triplets)\n", + "\n", + "print(f\"Train triplets parsed: {len(train_triplets)} | Failures: {train_parse_failures}\")\n", + "print(f\"Val triplets parsed: {len(val_triplets_gt)} | Failures: {val_parse_failures}\")" + ], + "id": "5482852799a9c2b1", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train triplets parsed: 20203 | Failures: 0\n", + "Val triplets parsed: 2109 | Failures: 0\n" + ] + } + ], + "execution_count": 13 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Training Data Statistics" + ], + "id": "9060b479047600" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:23:13.185073Z", + "start_time": "2026-05-04T13:23:13.166356Z" + } + }, + "source": [ + "def compute_stats(triplets, label=\"Training\"):\n", + " relations = [t.get(\"relation\", \"UNKNOWN\") for t in triplets]\n", + " subject_types = [t.get(\"subject_type\", \"UNKNOWN\") for t in triplets]\n", + " object_types = [t.get(\"object_type\", \"UNKNOWN\") for t in triplets]\n", + "\n", + " qualifiers = []\n", + " for t in triplets:\n", + " for q in t.get(\"qualifiers\", []):\n", + " qualifiers.append(q.get(\"relation\", \"UNKNOWN\"))\n", + "\n", + " stats = {\n", + " \"total_triplets\": len(triplets),\n", + " \"relation_counts\": Counter(relations),\n", + " \"subject_type_counts\": Counter(subject_types),\n", + " \"object_type_counts\": Counter(object_types),\n", + " \"qualifier_counts\": Counter(qualifiers),\n", + " }\n", + "\n", + " print(f\"\\n=== {label} Statistics ===\")\n", + " print(f\"Total triplets: {stats['total_triplets']}\")\n", + " print(f\"Unique relations: {len(stats['relation_counts'])}\")\n", + " print(f\"Unique subject types: {len(stats['subject_type_counts'])}\")\n", + " print(f\"Unique object types: {len(stats['object_type_counts'])}\")\n", + " print(f\"Total qualifiers: {len(qualifiers)}\")\n", + " print(f\"Unique qualifier relations: {len(stats['qualifier_counts'])}\")\n", + "\n", + " # Show top relations\n", + " print(f\"\\nTop 15 relations:\")\n", + " for rel, cnt in stats[\"relation_counts\"].most_common(15):\n", + " pct = cnt / len(triplets) * 100\n", + " print(f\" {rel}: {cnt} ({pct:.1f}%)\")\n", + "\n", + " # Show top subject types\n", + " print(f\"\\nTop 10 subject types:\")\n", + " for st, cnt in stats[\"subject_type_counts\"].most_common(10):\n", + " pct = cnt / len(triplets) * 100\n", + " print(f\" {st}: {cnt} ({pct:.1f}%)\")\n", + "\n", + " # Show top qualifier relations\n", + " if qualifiers:\n", + " print(f\"\\nTop 5 qualifier relations:\")\n", + " for qr, cnt in stats[\"qualifier_counts\"].most_common(5):\n", + " pct = cnt / len(qualifiers) * 100\n", + " print(f\" {qr}: {cnt} ({pct:.1f}%)\")\n", + "\n", + " return stats\n", + "\n", + "train_stats = compute_stats(train_triplets, \"Training Data\")\n", + "val_stats = compute_stats(val_triplets_gt, \"Validation Ground Truth\")" + ], + "id": "4a7f4861e0a57d55", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Training Data Statistics ===\n", + "Total triplets: 20203\n", + "Unique relations: 740\n", + "Unique subject types: 687\n", + "Unique object types: 1057\n", + "Total qualifiers: 8682\n", + "Unique qualifier relations: 1294\n", + "\n", + "Top 15 relations:\n", + " instance of: 1300 (6.4%)\n", + " has part(s): 967 (4.8%)\n", + " occupation: 925 (4.6%)\n", + " part of: 494 (2.4%)\n", + " date of birth: 452 (2.2%)\n", + " location: 450 (2.2%)\n", + " position held: 431 (2.1%)\n", + " country of citizenship: 421 (2.1%)\n", + " notable work: 345 (1.7%)\n", + " film crew member: 321 (1.6%)\n", + " participant in: 284 (1.4%)\n", + " award received: 276 (1.4%)\n", + " member of: 275 (1.4%)\n", + " genre: 268 (1.3%)\n", + " inception: 262 (1.3%)\n", + "\n", + "Top 10 subject types:\n", + " human: 5947 (29.4%)\n", + " film: 1517 (7.5%)\n", + " musical group: 591 (2.9%)\n", + " organization: 559 (2.8%)\n", + " album: 558 (2.8%)\n", + " television series: 547 (2.7%)\n", + " musical work: 435 (2.2%)\n", + " building: 397 (2.0%)\n", + " company: 349 (1.7%)\n", + " sports team: 293 (1.5%)\n", + "\n", + "Top 5 qualifier relations:\n", + " point in time: 1871 (21.6%)\n", + " start time: 313 (3.6%)\n", + " location: 263 (3.0%)\n", + " end time: 254 (2.9%)\n", + " publication date: 242 (2.8%)\n", + "\n", + "=== Validation Ground Truth Statistics ===\n", + "Total triplets: 2109\n", + "Unique relations: 315\n", + "Unique subject types: 166\n", + "Unique object types: 372\n", + "Total qualifiers: 882\n", + "Unique qualifier relations: 233\n", + "\n", + "Top 15 relations:\n", + " instance of: 142 (6.7%)\n", + " occupation: 116 (5.5%)\n", + " has part(s): 100 (4.7%)\n", + " located in the administrative territorial entity: 58 (2.8%)\n", + " part of: 54 (2.6%)\n", + " country of citizenship: 54 (2.6%)\n", + " position held: 51 (2.4%)\n", + " date of birth: 49 (2.3%)\n", + " location: 38 (1.8%)\n", + " film crew member: 32 (1.5%)\n", + " inception: 30 (1.4%)\n", + " notable work: 29 (1.4%)\n", + " country of origin: 28 (1.3%)\n", + " named after: 26 (1.2%)\n", + " genre: 25 (1.2%)\n", + "\n", + "Top 10 subject types:\n", + " human: 603 (28.6%)\n", + " film: 137 (6.5%)\n", + " organization: 112 (5.3%)\n", + " television series: 63 (3.0%)\n", + " human settlement: 63 (3.0%)\n", + " musical group: 58 (2.8%)\n", + " musical work: 49 (2.3%)\n", + " album: 48 (2.3%)\n", + " railway: 48 (2.3%)\n", + " company: 46 (2.2%)\n", + "\n", + "Top 5 qualifier relations:\n", + " point in time: 194 (22.0%)\n", + " location: 39 (4.4%)\n", + " start time: 37 (4.2%)\n", + " country: 32 (3.6%)\n", + " end time: 31 (3.5%)\n" + ] + } + ], + "execution_count": 14 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Visualize Training Distributions" + ], + "id": "7a5130806ca855ea" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:23:47.124503Z", + "start_time": "2026-05-04T13:23:46.534844Z" + } + }, + "source": [ + "def plot_distribution(counter, title, top_n=20, figsize=(12, 6)):\n", + " items = counter.most_common(top_n)\n", + " labels, values = zip(*items) if items else ([], [])\n", + "\n", + " fig, ax = plt.subplots(figsize=figsize)\n", + " bars = ax.barh(range(len(labels)), values, color='steelblue')\n", + " ax.set_yticks(range(len(labels)))\n", + " ax.set_yticklabels(labels)\n", + " ax.invert_yaxis()\n", + " ax.set_xlabel(\"Count\")\n", + " ax.set_title(title)\n", + "\n", + " # Add count labels on bars\n", + " for bar in bars:\n", + " width = bar.get_width()\n", + " ax.text(width + 1, bar.get_y() + bar.get_height()/2,\n", + " f'{int(width)}', va='center', fontsize=9)\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "plot_distribution(train_stats[\"relation_counts\"], \"Training: Top 20 Relations\")\n", + "plot_distribution(train_stats[\"subject_type_counts\"], \"Training: Subject Types\", top_n=15)\n", + "plot_distribution(train_stats[\"object_type_counts\"], \"Training: Object Types\", top_n=15)\n", + "if train_stats[\"qualifier_counts\"]:\n", + " plot_distribution(train_stats[\"qualifier_counts\"], \"Training: Qualifier Relations\", top_n=10)" + ], + "id": "60dbbebdeacf4da9", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAJOCAYAAABm7rQwAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAiHdJREFUeJzt3Qm8jPX7//ELx3bsW/Y1sq9JIREiidAmsoXInp2ItJAoSqmUrUVRocWSSKGyLynZRRFF9uzzf7w/3//Mb+Y45zi2+2yv5+Nx/86ZmXvuueeeu/M17991XXcSn8/nMwAAAAAAAMBDSb18MQAAAAAAAEAIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAK6h1q1bW4ECBa7ouUOHDrUkSZIk+M9D77FLly6XXG/y5Mlu3V27dnmyXwAAwFuEUgAAIFFQuBGTZfHixbG9q3HKmTNnbOzYsVa+fHlLnz69ZcyY0UqWLGmPP/64/fbbbxaf/fDDDy4IPHz4cLTr6ZyI6fkDAABiLonP5/NdxvoAAADx0vvvvx9ye+rUqbZgwQJ77733Qu6/6667LHv27Ff8OmfPnrULFy5YypQpL/u5586dc0uqVKksrmjQoIHNnTvXHnnkEatcubJ7fwqjvvzyS3v22WddZdjlUnjTuXNnGzduXLTrnT9/3r2ejuX1CHxGjRplffr0sZ07d0Zb3bZ//353rgQbMGCApU2b1p566qmQ+x999NFrvp8AACRUYbG9AwAAAF6IGBb89NNPLmi4VIhw8uRJCw8Pj/HrJE+e/Ir3MSwszC1xxcqVK1349Pzzz9vAgQNDHlOgdKkKo6uVLFkyt8Q2hZQRz5MRI0ZY1qxZCaEAALgKtO8BAAD8fzVq1LBSpUrZ6tWr7Y477nBhlD+MmT17ttWvX99y5crlKnduvPFGVymkap7oZkppHpKqfFSV8/bbb7vn6fm33HKLC30uNVPKP39p1qxZbt/0XLXPzZs3L9I2s4oVK7pKK73OW2+9Fek2//nnH1ftpMAtOtu3b3c/q1atetFjCouyZMkS5fuO7j35ffDBB1a0aFG3vzfffLN9//33MZoppcqtatWqWZo0aSxdunTuc/nll18u2r7e40MPPWTZsmWz1KlTu9fyVzZpv1QlJQULFgy0313J/Co1Hui933fffRc9durUKcuQIYN16NAhpBXw448/dudWjhw53Pto2LCh7dmz56LnL1++3O6++263DZ2P1atXt2XLloWsc+zYMevRo4fbB50fN9xwg6v4W7NmzWW/FwAAvBR3/l9xAAAAccDBgwetXr161rRpU1cF42/lU0Cidq2ePXu6n4sWLbKnn37ajh49ai+99NIlt/vhhx+68EDhhEKJkSNHWpMmTWzHjh2XrK5aunSpffbZZ9apUycXwrz66qt2//332+7duwPB0Nq1a114kTNnTnvmmWdcWDZs2DAXyESkKiet8+2337ogLir58+cPhEcKpq5lFdd3333ngplu3bq5IOWNN95w+79ixQoXvkVF7ZatWrWyunXr2osvvuiCtfHjx9vtt9/ujoE/GNuwYYMLrnRsNf9K9ytk++KLL1zll479li1bbNq0afbKK6+4qieJ7Hhdij5PnSv6TA8dOmSZM2cOPKbX0zkSsdJK+6Dn9evXzw4cOGBjxoyx2rVr27p161yAJjrHdC4qsBsyZIglTZrUJk2aZDVr1rQlS5ZYpUqV3HodO3a0Tz75xIWXJUqUcOewzplNmzZZhQoVLvv9AADgGc2UAgAASGw6d+6suZoh91WvXt3d9+abb160/smTJy+6r0OHDr7w8HDfqVOnAve1atXKlz9//sDtnTt3um1myZLFd+jQocD9s2fPdvd/8cUXgfuGDBly0T7pdooUKXzbtm0L3Ld+/Xp3/2uvvRa4r0GDBm5f/vzzz8B9W7du9YWFhV20Tf/rfPvtt9EeowsXLgSOSfbs2X2PPPKI7/XXX/f9/vvvF60b8X1f6j1pWbVqVeA+bTNVqlS+xo0bB+6bNGmSW0/HUI4dO+bLmDGjr3379iHb++uvv3wZMmQIuf+OO+7wpUuX7qJ91Xvye+mll0K2fzlKlizpjo3f5s2b3bbGjx8fsl7Dhg19BQoUCLyujrnWy507t+/o0aOB9aZPn+7uHzt2bGA/ixQp4qtbt27IPus8LFiwoO+uu+4K3Kf3rvMZAID4hvY9AACAIKraadOmzUXHxF+9Iqp4UgucKnFUqROTq9A9/PDDlilTpsBtPVdUKXUpqqBRO55fmTJl3JXw/M9VVdQ333xjjRo1cu2FfoULF3aVNhGpdU3ZUHRVUqJKnvnz59tzzz3n9l1VRRpQrgoqvZ+rmSmloemqAPLLly+fa3/T60VsifTTDDC9poau6/j7F7US3nrrra7yS/7++2/XCvjYY4+57UZ8T9fDTTfd5PZBVWV+qppSq2Hz5s0vet2WLVu6qje/Bx54wFW5zZkzx91WxdTWrVutWbNmrvLJ/15PnDhhtWrVcu9PA/VFV0RUm9/evXuvy3sDAOB6oX0PAAAgSO7cuS1FihQXHRPNLBo0aJBrqVI7VrAjR45c8hhGDEf8AdW///572c/1P9//XLV//ffffy6Eiiiy+y43pNMcJi379u1zbXdjx4616dOnu9a4iFc1jKkiRYpEGuwo5FOopFlLESmkEbWvRUZBnfjDuujaAK8HBU1qofv9999dcDdjxgx39cAWLVpc8v0rtNJn5Z9p5X+valWMis47nQdqG9R6efPmdUHfPffc4/alUKFC1/w9AgBwLRFKAQAARFER5afqHA2YVuihOU2qWtJwbg2S1kwgf8VKdKK6itz/utmu33OvJVXyaNaW5llp2LqCKc3a0qypqCqQoqp6uhL+46y5UpGFVrF95UIdmyeffNJVS2mIuQI7DZ7XgPUrfa+aV1auXLlI19FsM9Ewd1XezZw5077++mv3HM3b0hyyyCrlAACIKwilAAAALkFXTFMLlb7k66p8fjt37owTx05XW1NItm3btosei+y+q6UKKbUQqppHLWUKiFSxE1k7n6qGIuOvBAqmweO6wlxUw8b9LYx6v2ppjIq/Qmjjxo3Rvo9r3cqnAee6EqBCKbXs6Sp5GmAek/evgFGflY5r8HtVEBrdew0ODDUIX4sq5zTgXMPUCaUAAHEZM6UAAABiWKkUXJl05swZd8W4uLJ/Ci5mzZoVMldIIYdmGkWkIElzsNQqFx0FJ7rCX0QKn3788UcXRPkDJIUoaifTVe/81O6n6p3I6PmqNPPbs2ePzZ492+rUqRNlZZiuuKeQ5oUXXnBtcRGp7U+0TwoPJ06ceNH+B3+GadKkCbyfa0Wter/++qv16dPHvQ9VT0Vm6tSpbjaZn66ep+PlD5HUhqdjOmrUKDt+/HiU71WVaBHbRxXaabbY6dOnr9n7AgDgeqBSCgAA4BKqVKniAhjN7enWrZursFELmdftc9HR8HK1blWtWtWeeOIJF1aMGzfOzVXS0Oxguv+ZZ55xg8GjG3a+fv16N2hbQYnaw1QJ9Oeff9qUKVNc+KUqIH+ApPBFrYyNGzd2x0iB1/jx492cqODwyU/7pZBJ62pulT/g035FRYGUtqngR5VAek0FUAqevvrqK/fe9d7k1Vdftdtvv92t9/jjj1vBggXdvCat5z8e/kHrmpelbakCrEGDBoGw6kqoUipLlixunpSOmwKiyOhYav80VH///v3uWGqmVPv27d3jSZMmtXfeecdtQ62SWk/zznT89bnpWHzxxRcu2MqTJ48blF62bFnX0qeh9ytXrrTRo0df8fsAAMALhFIAAACXoJDhyy+/tF69erlh5wqoHn30UXcVNAUrcYECFlVF9e7d2wYPHuyGXmv+1aZNm2J0dcDIqNro2Wefddt9+eWXXXWOrhhXvnx5N7NIs6WCj5Gqonr27Gl9+/Z1IdDw4cNdtVVkoZRmdOkKfAqhFCqVKFHCzafyt69FRSGZqoBGjBjhZiepGkhhjUKz4KsmKqD56aef3LFQkHXq1Ck3fFzzl/xuueUW9/7efPNNmzdvnpvjpJbMqwmlNCRfVyZUyBbZgHM/zZxSVZmOkYIlnUt6jtoX/RQYqqJM+6iwTRVTapXUVf46dOjg1tH6atlTIKn2Ur0HhVvalsJJAADisiS+uPT/4gMAAMA11ahRI3flwMhmOMV17777rrVr18619qkaKL7QsHPt+19//RUSMvnnk915552ukkrVTQAAJGbMlAIAAEgg/vvvv5DbCqLmzJkTbYteXKYZS2qVVKtbfKGKLF11T1VkEQMpAAAQivY9AACABEJXnWvdurX7qaveqW1N7WRqp4tPNGNJg7/VVqcWv/gQ7uiKd5rlpP3WlRq7d+8e27sEAECcRygFAACQQNx99902bdo01zam4eEKdHSluiJFilh8ojlYunpdpUqVbMKECRYf6Ip7zZs3d4PNNWS9XLlysb1LAADEecyUAgAAAAAAgOeYKQUAAAAAAADPEUoBAAAAAADAc8yUgucuXLhge/futXTp0rkr6gAAAAAAgITD5/PZsWPHLFeuXJY0adT1UIRS8JwCqbx583LkAQAAAABIwPbs2WN58uSJ8nFCKXhOFVL+kzN9+vR8AgAAAAAAJCBHjx51xSj+7/9RIZSC5/wtewqkCKUAAAAAAEiYLjWyh0HnAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc2HevyTwP41fnG9hqcI5HAAAAAAABJk/uL4lBlRKAQAAAAAAwHOEUgAAAAAAAPAcoRQAAAAAAAA8RygFAAAAAAAAzxFKAQAAAAAAwHOEUgAAAAAAAPAcoVQcVKNGDevRo0ds7wYAAAAAAIglrVu3thQpUljatGkDy48//hh4fPv27VavXj3LlCmT5c6d20aOHBnpdvbv32+ZM2e2cuXKBe5bsmRJyHa1JE2a1Lp162ZeIpQCAAAAAACIgzp16mTHjx8PLJUrV3b3nz9/3ho2bGgVKlSwAwcO2KJFi2zcuHH24YcfXrSNLl26WPny5UPuq1atWsh2FXAlS5bMmjZtal4ilAIAAAAAAIhHNm/e7JYhQ4ZY8uTJrWjRota2bVt7++23Q9abPXu2HTp0yFq0aBHt9qZMmWJFihSxKlWqmJcIpeKoCxcuWN++fV2JXY4cOWzo0KHu/l27dlmSJEls3bp1gXUPHz7s7lu8eLG7rZ+6PX/+fJeGpk6d2mrWrOnS07lz51rx4sUtffr01qxZMzt58mRgO/PmzbPbb7/dMmbMaFmyZLF7773XpaV+/tf+7LPP7M4777Tw8HArW7ZsSPkgAAAAAAC4NqZOnepygZIlS9ro0aNdViD+nz6fL7Cu7tuwYUPg9pEjR6xnz5725ptvXvJ1Jk6c6EItrxFKxVFKKdOkSWPLly93faHDhg2zBQsWXNY2FGSpfO+HH36wPXv22EMPPWRjxoxx5XxfffWVff311/baa68F1j9x4oQ7YVetWmULFy50/aSNGzcOnOx+Tz31lPXu3dsFYzfddJM98sgjdu7cuWv23gEAAAAASOy6devmqqH+/vtve/fdd23s2LFuEVVGFShQwJ5++mk7ffq0/fLLLy5YOnr0aOD5KnTRXCpVQEVH86V27NhhLVu2NK+Fef6KiJEyZcq4MjzRCaRwSUHRpU6mYM8995xVrVrV/a7Ec8CAAa7yqVChQu6+Bx54wL799lvr16+fu33//feHPF8ndLZs2ezXX3+1UqVKBe5XIFW/fn33+zPPPOMS223btlmxYsUi3Q/9B6LFL/g/EgAAAAAAcDHNi/K77bbbrH///q5y6sknn3Qte2rN0+8acp4nTx5r06aNvfXWW4GgadmyZbZmzRq7FAVemk+l7/9eo1IqDodSwXLmzOna7650G9mzZ3ftdv5Ayn9f8Da3bt3qqp60jtr7lLrK7t27o9yu9kui27fhw4dbhgwZAkvevHkv630AAAAAAJDYJU0aGuGoQEQdUP/884/rZFIxSPXq1d1jKmpR9VOuXLksa9as1rVrV9u4caP7fd++fSFFIzNmzLB27dpZbCCUiqOUegbTLCe10flPwuC+0bNnz15yG3p+VNv0a9CggRuANmHCBNc2qEXOnDkT7XYlYotfMFVoqZfVv6iVEAAAAAAARG369OkuNNL3f43ZGTFiREiHk+ZHaQyPvrNr9rO6nQYNGuQe02ieLVu2uLBKi0YCqeVPv99www2BbUybNs3NlK5Tp47FBtr34hl/OZ2STf8lHYOHnl+pgwcPul5VBVK6NKQsXbrUroWUKVO6BQAAAAAAxMy4cePs8ccfdzOc1aLXqVMn69WrV0hoNX78eDt16pS7CNmsWbMCnU3qftLilylTJldgoja/iK17avuLWIXlFUKpeEZX0lMvqRLSggULurY5fxJ6NXSCKh3V5SPVkqeWPfWrAgAAAAAA733//feXnCOtJSY08FxLRCtWrLDYRPtePKSSPCWlN998s/Xo0SPGJ2F0lIp+9NFHtnr1ajfUXMPSXnrppWuyvwAAAAAAABEl8QUPJwI8oJ5YDTyvOXC6haUK55gDAAAAABBk/uD/XfE+vn/v11zp4DbCiKiUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOC5MO9fEvifmf3qRntpSAAAAAAAkHBRKQUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPcfU9xJrGL863sFThfAJAAjN/cP3Y3gUAAAAA8QCVUgAAAAAAAPAcoRQAAAAAAAA8RygFAAAAAAAAzxFKAQAAAAAAwHOEUgAAAAAAAPAcoRQAAAAAAAA8RyiViPh8Pnv88cctc+bMliRJEsuYMaP16NEj8HiBAgVszJgxsbqPABKGcePGWcWKFS1lypTWqFGjkMdq1Kjh7k+bNm1g2bt3b+DxwYMHW+nSpS0sLCzkb5QsWbIk5HlakiZNat26dfPsvQEAAAC4NsKu0XYQD8ybN88mT55sixcvtkKFCrkvcqlTp47t3QKQAOXKlcsGDRpk33zzjf3xxx8XPf7iiy9eFDj5FS5c2EaOHGkTJky46LFq1arZ8ePHA7f3799vefLksaZNm17jdwAAAADgeiOUSkS2b99uOXPmtCpVqsT2rgBI4Jo0aeJ+rlu3LtJQKjqtWrVyPz/++ONLrjtlyhQrUqQIf9cAAACAeIj2vUSidevW1rVrV9u9e7dr3VOrnlpooqpUEK331ltv2b333mvh4eFWvHhx+/HHH23btm3uuWnSpHFfBBV2AcDleO6551wrcfny5W3q1KlXfPAmTpxobdu25eADAAAA8RChVCIxduxYGzZsmGtz2bdvn61cuTJGz3v22WetZcuWrtqhWLFi1qxZM+vQoYMNGDDAVq1a5eZUdenS5brvP4CEY/jw4S7MVuvdiBEjXGA+c+bMy96O5kvt2LHD/Y0CAAAAEP8QSiUSGTJksHTp0lmyZMksR44cli1bthg9r02bNvbQQw/ZTTfdZP369bNdu3ZZ8+bNrW7duq5yqnv37m5GVXROnz5tR48eDVkAJF6VK1d2f5OSJ0/u/pYo6I5Jq15E7777rjVs2DDGf88AAAAAxC2EUohWmTJlAr9nz57d/dRVsYLvO3XqVLRBk6oi9AXUv+TNm5ejDuD//oco6eX/T5H+5syYMcPatWvHkQQAAADiKUIpREuVDMEzpqK678KFC1FuQ61+R44cCSx79uzhqAMJ3Llz51xgrZ/6+6Dfz5w5Y4cPH7Y5c+bYyZMn7fz587Zw4UJ788037f777w889+zZs259Pa5Fv+u+YNOmTbMsWbJYnTp1YuHdAQAAALgWuPoerruUKVO6BUDiGmT+zDPPBG6nTp3aqlev7qqbdH/Tpk3d/browssvv2wPPvhgYN327du7q+r5jRs3zl2Rb/LkySGte2ovvpIqKwAAAABxA6EUAOCaGzp0qFsis3z58mifq/ApOICKzIoVK65q/wAAAADEPv5fzAAAAAAAAPBcEp/P5/P+ZZGYaUCxBp7XHDjdwlKFx/buALjG5g+uzzEFAAAAErGj//97v+ZKp0+fPsr1qJQCAAAAAACA5wilAAAAAAAA4DlCKQAAAAAAAHiOUAoAAAAAAACeI5QCAAAAAACA5wilAAAAAAAA4Lkw718S+J+Z/epGe2lIAAAAAACQcFEpBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM9x9T3EmsYvzrewVOF8ArFg/uD6HHcAAAAAQKyiUgoAAAAAAACeI5QCAAAAAACA5wilAAAAAAAA4DlCKQAAAAAAAHiOUAoAAAAAAACeI5QCAAAAAACA5wilrtLkyZMtY8aM1+bTMLPFixdbkiRJ7PDhw9dsm0BUWrdubSlSpLC0adMGlh9//DHw+Pbt261evXqWKVMmy507t40cOTLk+YMHD7bSpUtbWFiY9ejRgwMNAAAAAIgxQqmr9PDDD9uWLVuudjNArOnUqZMdP348sFSuXNndf/78eWvYsKFVqFDBDhw4YIsWLbJx48bZhx9+GHhu4cKFXVCl9QAAAAAAuByEUlcpderUdsMNN1hcd/bs2djeBcQzmzdvdsuQIUMsefLkVrRoUWvbtq29/fbbgXVatWrlKqnSp08fq/sKAAAAAIh/ElQoVaNGDevatatrI1K7Ufbs2W3ChAl24sQJa9OmjaVLl85VdsydOzfa9rtZs2a5Fjq/9evX25133umery/fN998s61atSrK53/xxRd2yy23WKpUqSxr1qzWuHHjwGPvvfeeVaxY0W0rR44c1qxZM1eFcjl+++03u/322932S5QoYd98843bX+237Nq1y93++OOPrXr16m69Dz74wC5cuGDDhg2zPHnyWMqUKa1cuXI2b968aFsH161b5+7TNoPfr16rSJEibtt169a1PXv2XNZ7QNwxdepUy5w5s5UsWdJGjx7tzhPx//T5fIF1dd+GDRtibV8BAAAAAAlHggqlZMqUKS4IWrFihQuonnjiCXvwwQetSpUqtmbNGqtTp461aNHCTp48GeNtNm/e3AU5K1eutNWrV1v//v1d5UhkvvrqKxdC3XPPPbZ27VpbuHChVapUKaRi6dlnn3VBl4IdhT2a6xNTaqlq1KiRhYeH2/Lly13VylNPPRXputrP7t2726ZNm1xwNHbsWBc6jBo1ygULuk9tV1u3brXLoWP3/PPPuzBj2bJlLsRq2rTpZW0DcUO3bt1cNdTff/9t7777rjtHtIgqowoUKGBPP/20nT592n755RebOHGiHT16NLZ3GwAAAACQAIRZAlO2bFkbNGiQ+33AgAE2YsQIF1K1b9/e3acv2OPHj3ehzG233Rajbe7evdv69OljxYoVc7dVIRQVhTUKaJ555pmQffJ77LHHAr8XKlTIXn31VVdVpVk+GjJ9KQsWLHDDp1XVpEor/2veddddF62rirEmTZoEbiuM6tevXyBAevHFF+3bb7+1MWPG2Ouvv24xpWBNs4VuvfXWQBBYvHhxFwQGB3B+CjS0+BFqxB2aF+Wn/x4UZCpsfPLJJ13wOnv2bPe7hpwrmFXF4VtvvRWr+wwAAAAASBgSXKVUmTJlAr8nS5bMsmTJ4q4O5qeWPrmclrmePXtau3btrHbt2i7kUigUFbW71apVK8rHVWnVoEEDy5cvn2vhU3udP/iKCVW15M2bNxBISWRBkKhNMDgI2rt3r1WtWjVkHd1WJdXl0JXWFKT5KaxTS19U2xk+fLhlyJAhsGj/ETclTRr6J0EtfV9//bX9888/7txWuOg/ZwEAAAAAuBoJLpSK2FaneUjB9/lnRfnn5ehLePDMnMiGgg8dOtS1LtWvX99dgUxznGbOnBnl4POoaLaVWuY0l0ozntQO6N/OmTNn7FpLkybNFQUSwcfjWgxIV8XakSNHAgvzp+KO6dOnu8BSn7nmpCl0vf/++wOPq6JQ563Oz88++8y17/krEf3nx6lTp1xbqRb9zlB9AAAAAECiDKUuV7Zs2ezYsWPui7efKkIiuummm1wbk6pG1BI3adKkKCu1NEcqqgHlBw8edF/8q1Wr5iqMLnfIueb8KNTZv39/4D6FW5eiICxXrlxuBlQw3VbI5j8Wsm/fvmiPxblz5wKD3v3VW5orpRa+yGioul4/eEHcoDZMf9WeZqd16tTJevXqFRJa6XFdOEDtn5qDFlyNqLZYBbHvv/++25Z+97fKAgAAAACQqGZKXS7NRdLQ8IEDB7qhzxoerivM+f33339untQDDzxgBQsWtD/++MOFQMHVJMGGDBni2vduvPFGN7tJAc6cOXPcLCd9uU+RIoW99tpr1rFjR9u4caMben45NDtK227VqpWNHDnSBWr+ypXgKwZGRu9D+6fn68p7CtYUOqlqS3RlQrXWqTJMc6q2bNniBqNHpMozDZHXPCy18nXp0sXNI4qqjRBx1/fffx/t488995xboqL/VoL/ewEAAAAAIKYSfaVU5syZXZWHgiPNnpo2bZoLZYLnUqm6qWXLlq5a6qGHHrJ69eqFDDIPVqNGDZsxY4Z9/vnnLvipWbOmGwDur0TSF3g9ruokVUyp+uRyaH9UraLB6JrrpFlX/qvvpUqVKtrnKnTTfCxVwui9zps3z+2nf3C7wia9f1V0qRpGg9AjCyQU4ilka9asmZtJpQHtH3/88WW9DwAAAAAAkLgl8UUcqIR4Ry14t99+u23bts1VQV1PCtV0VT+1610pzTDSwPOaA6dbWKrwa7p/iJn5g+tzqAAAAAAA14X/e7/mSkc3wifRt+/FRxqOruokVTgpiOrevburWLregRQAAAAAAMC1QigVD2mOlNrndu/ebVmzZrXatWtHOvsJAAAAAAAgrqJ9D56jfS/20b4HAAAAAIjt9r1EP+gcAAAAAAAA3iOUAgAAAAAAgOcIpQAAAAAAAOA5Bp0j1szsVzfa3lIAAAAAAJBwUSkFAAAAAAAAzxFKAQAAAAAAwHOEUgAAAAAAAPAcoRQAAAAAAAA8RygFAAAAAAAAz3H1PcSaxi/Ot7BU4XwC19n8wfU5xgAAAACAOIdKKQAAAAAAAHiOUAoAAAAAAACeI5QCAAAAAACA5wilAAAAAAAA4DlCKQAAAAAAAHiOUAoAAAAAAACeI5SKo4YOHWrlypW7rq+xa9cuS5Ikia1bt+66vg5iX+vWrS1FihSWNm3awPLjjz/G+PHt27dbvXr1LFOmTJY7d24bOXJkLL0TAAAAAEBCQSgVR/Xu3dsWLlx4zban0KFRo0Yh9+XNm9f27dtnpUqVumavg7irU6dOdvz48cBSuXLlGD1+/vx5a9iwoVWoUMEOHDhgixYtsnHjxtmHH34YS+8EAAAAAJAQEErFkM/ns3PnzplXVKmSJUuW6/oayZIlsxw5clhYWNh1fR3Eb5s3b3bLkCFDLHny5Fa0aFFr27atvf3227G9awAAAACAeCxRh1KnT5+2bt262Q033GCpUqWy22+/3VauXOkeW7x4sWttmzt3rt18882WMmVKW7p0qR07dsyaN29uadKksZw5c9orr7xiNWrUsB49egS2+95771nFihUtXbp0LvRp1qyZqzDx829blVBaLzw83KpUqeK++EfVvqf1Iy4FChQIVLIoJChYsKClTp3ahQZjx44N2daUKVNs9uzZgedqHyJr3/vuu++sUqVK7v3q/fXv3z8kjNN71THr27evZc6c2b0/bR9x39SpU91nVrJkSRs9erRduHAhRo/7fyqY9dN9GzZs8PgdAAAAAAASkkQdSilY+fTTT11gs2bNGitcuLDVrVvXDh06FFhHocyIESNs06ZNVqZMGevZs6ctW7bMPv/8c1uwYIEtWbLEPTfY2bNn7dlnn7X169fbrFmzXPij9rmInnrqKfflf9WqVa5a6bHHHotyX9Vm51+2bdvm9vWOO+4IBAR58uSxGTNm2K+//mpPP/20DRw40KZPnx5oBXzooYfs7rvvDmxDIVhEf/75p91zzz12yy23uH0fP368vfvuu/bcc8+FrKfjpVBu+fLlbrbQsGHD3LFA3KUgUaHn33//7T5ThZbBwWV0jyvkVACq80pB7i+//GITJ060o0ePxuI7AgAAAADEd0l8weUPiciJEyfc0ObJkye7SiZ/mKQv36p6UjBz5513ulDpvvvuc4+rSkotdZql88ADD7j7jhw5Yrly5bL27dvbmDFjIn0thU7anp6vtjxVKWnb33zzjdWqVcutM2fOHKtfv779999/rmpL1Ud67YhDyPVx3X///bZ7924XiKkyKjJdunSxv/76yz755BN3W6HY4cOH3Tb9FJapumrt2rWuKkshmUI6BXCqoJI33njD+vXr595n0qRJXaWUKrP02n6qrKpZs6YL7yKjIEOLn8IMzbOqOXC6haUKj9HnhSs3f3D9i+7T56rKqJ9++inS50R8XEHUk08+6QJYBaCaMfXWW2/Z/v37+WgAAAAAACH0vT9DhgwuS0ifPr1FJdFWSulqYgqhqlatGrhP83IUsCiU8VN7nd+OHTvcc7SOnw6yKkmCrV692ho0aGD58uVzLXzVq1d39ytICqbKKz+1yklwm19kVAGlq6KpFS84kHr99dddm2G2bNlc8KV5PxFf71L0vjXc2h9IiY6Phl7/8ccfke63f9+j2+/hw4e74+RfFEghdilgvJzH1dL39ddf2z///OOCUoWM/vMaAAAAAIArkWhDqZhSm9rlVmCpBVBJ4AcffOBmVM2cOdM9dubMmZB1FYL5+YOgiHN+gr3//vtuhpW2lzt37sD9H330kWvR01wpBQcKDdq0aXPR610rwfvt3/fo9nvAgAEuHfUve/bsuS77haiplVNJtSrtVLmnqjZV3MX0cc2P0rmtc+qzzz5z7XuDBg3ikAMAAAAArliiDaVuvPFGS5EihZsP5acqKIVIJUqUiPQ5hQoVcoGMfxi6KGTZsmVL4PZvv/1mBw8edF/qq1WrZsWKFbtk9VNMqDqqXbt2rmXqtttuC3lM70Ezojp16mTly5d386ZUCRZM71Vtd9EpXry4e53gjk5tW9Veatm6UhqarpAueIG3xo0bF6jc06B+nSu9evWK8eMKrfS4Wl5HjRrl2kAjVswBAAAAAHA5wiwRV0A98cQT1qdPH3fFMX3h1tDukydPuoojDfqOSF/YW7VqFXiOrto3ZMgQ1+rkr3TSdhQAvfbaa9axY0fbuHGjG3p+NTQbqnHjxta0aVNXhaXbkixZMteuV6RIETf/Z/78+W5GlK7+p+BMv/tpVpYe1zBrzcVSG11ECiI0F6tr165uJpXW1fvTcPdLtXshbvv++++v6nENu4848B4AAAAAgKuRqJMGf4tSixYtrEKFCu6qdgpuVA0SlZdfftnNXbr33nutdu3abuaSKow0nFwUEml4uq6Ep4orvYYqS66Gqq80UFpXvdP8Jv+i4enSoUMHa9KkiT388MN26623ukotBUzBNIhds680I0v7GFwh5qeWQA1cX7FihZUtW9aFagroaNMCAAAAAADXWqK9+t61ojk7CnNGjx7tAhzEfAo/V9+LvavvAQAAAAAQ21ffS7Tte1dq7dq1rnJJV+DTwR02bJi7/7777ovtXQMAAAAAAIg3CKWugNrxNG9Js6NuvvlmW7JkiWXNmvXafzoAAAAAAAAJFKHUZdLV7VavXn19Pg0AAAAAAIBEIlEPOgcAAAAAAEDsIJQCAAAAAACA5wilAAAAAAAA4DlmSiHWzOxXN9pLQwIAAAAAgISLSikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jqvvIdY0fnG+haUK5xO4zuYPrs8xBgAAAADEOVRKAQAAAAAAwHOEUgAAAAAAAPAcoRQAAAAAAAA8RygFAAAAAAAAzxFKAQAAAAAAwHOEUgAAAAAAAPAcoVQCsGvXLkuSJImtW7fO3V68eLG7ffjw4djeNcQRrVu3thQpUljatGkDy48//hjjx//8809r1KiRZcmSxbJmzWoPPfSQ/f3337H0bgAAAAAACQGhFJBIdOrUyY4fPx5YKleuHOPHO3fu7H7+/vvvtnPnTjt16pR169bN8/cAAAAAAEg4CKUAXNKOHTtcdZQqqNKlS2cPP/yw/fzzzxw5AAAAAMAVI5SKJ+bNm2e33367ZcyY0bVQ3XvvvbZ9+/Zon7Ns2TIrU6aMpUqVym677TbbuHFj4LGhQ4dauXLlQtYfM2aMFShQIKSlSy1bL7zwgmXPnt299rBhw+zcuXPWp08fy5w5s+XJk8cmTZp0Hd4xrrWpU6e6z6xkyZI2evRou3DhQowf79mzp82YMcOOHDni2kKnTZtmDRo04EMCAAAAAFwxQql44sSJEy4YWLVqlS1cuNCSJk1qjRs3vihYCKbgSOHCypUrLVu2bC5EOHv27GW97qJFi2zv3r32/fff28svv2xDhgxxgVimTJls+fLl1rFjR+vQoYP98ccf1+Bd4npRq93mzZvdHKh3333Xxo4d65aYPl61alU7cOCA+9wVXP377782YMAAPjAAAAAAwBUjlIon7r//fmvSpIkVLlzYVThNnDjRtU/9+uuvUT5HAdJdd91lpUuXtilTptj+/ftt5syZl/W6CiBeffVVK1q0qD322GPu58mTJ23gwIFWpEgRF0xoQPbSpUuj3Mbp06ft6NGjIQu8VaFCBRdMJkuWzFXN9e/f3z7++OMYPa7gU+eRgin/vCn9XqdOHT5GAAAAAMAVI5SKJ7Zu3WqPPPKIFSpUyNKnTx9os9u9e3eUzwkeVK1wSYHSpk2bLut11cqlqiw/tfEp5PJTiKF2QlXRRGX48OGWIUOGwJI3b97L2gdce8Gf6aUeP3TokBtwrmqq8PBwt3Tt2tVVyv3zzz98PAAAAACAK0IoFU+o9U7hwIQJE1wYoEXOnDlzRdtT6ODz+ULui6y1L3ny5CG3kyRJEul90bURqppKs4j8y549e65on3Hlpk+f7irU9JmrBXTEiBGu+i4mj2fNmtVV6L3++uvuqnta9LvmiekxAAAAAACuRNgVPQueOnjwoJv3o0CqWrVq7r7o2uX8fvrpJ8uXL5/7XTOAtmzZYsWLF3e31ar1119/uRBCoZKsW7fuuux/ypQp3YLYM27cOHv88cfdkPrcuXNbp06drFevXjF+fPbs2fbkk0+6xxRAli9f3j7//PNYejcAAAAAgISAUCoe0HBptci9/fbbljNnTteyp5k/l6Ir5el5arl76qmnXFWLrqYnNWrUcEOtR44caQ888IC7ut/cuXNdayASHg2qv5rHS5QoYfPnz7/GewUAAAAASMxo34sH1Gr30Ucf2erVq61UqVKuYuWll1665PPUgtW9e3e7+eabXVXUF1984YaSiyqm3njjDdeGVbZsWVuxYoX17t3bg3cDAAAAAABglsQXcbAQcJ1pdpEGntccON3CUoVzvK+z+YPrc4wBAAAAAJ5/79dc6eg6sqiUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOC5MO9fEvifmf3qRntpSAAAAAAAkHBRKQUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPcfU9xJrGL863sFThfALXyfzB9Tm2AAAAAIA4i0opAAAAAAAAeI5QCgAAAAAAAJ4jlAIAAAAAAIDnCKUAAAAAAADgOUIpAAAAAAAAeI5QCgAAAAAAAJ5LUKFUjRo1rEePHtdse7t27bIkSZLYunXrrum6cc3ixYvdvh8+fDi2dwXXWOvWrS1FihSWNm3awPLjjz9etN5///1nhQsXtowZMwbu2717d8jztISFhVnDhg35nAAAAAAACTOUutbh0pXKmzev7du3z0qVKnVN141rqlSp4vY9Q4YMsb0ruA46depkx48fDyyVK1e+aJ2nn37a8ufPH3Jfvnz5Qp536NAhF1o1bdqUzwkAAAAAkDBDqbgiWbJkliNHDlcdci3XjUvOnj3rKmm076qWQuKzevVqmzdvnvXr1y/a9WbNmmUXLlywJk2aeLZvAAAAAICEK2lcbDf67rvvbOzYsS4k0aLWONm4caPVq1fPtRFlz57dWrRoYf/880+U2zp9+rT17t3bcufObWnSpLFbb73VtarJ0aNHLXXq1DZ37tyQ58ycOdPSpUtnJ0+evKgl799//7XmzZtbtmzZ3HOLFClikyZNirJ9T++jUqVKljJlSsuZM6f179/fzp07F1IR1q1bN+vbt69lzpzZBUNDhw6N9vho/7VNvR9VrVStWtV+//33wOOzZ8+2ChUqWKpUqaxQoUL2zDPPhLym9nH8+PGuBUvbeP755yNt31u6dKlVq1bNvU9VgWk/T5w4EXj8jTfecO9fr6PP4oEHHoh2vxF7pk6d6s6vkiVL2ujRo12w5Kdzo3379vb666+7cDI67777rjv/9ZkDAAAAAJDgQimFUWov0hdltZRpUSiiwKRmzZpWvnx5W7Vqlavs2L9/vz300ENRbqtLly5ufs5HH31kGzZssAcffNDuvvtu27p1q6VPn97uvfde+/DDD0Oe88EHH1ijRo0sPDz8ou0NHjzYfv31Vxdkbdq0yYU7WbNmjfS1//zzT7vnnnvslltusfXr17t19aX+ueeeC1lvypQpLhxavny5jRw50oYNG2YLFiyIdJsKELRv1atXd+9H7+3xxx8PVDgtWbLEWrZsad27d3f7+dZbb9nkyZNd8BRMwVfjxo3t559/tscee+yi19m+fbs7Tvfff797nY8//tiFVDqeouOvkEr7unnzZvdZ3HHHHVF+Dog9+pz0Gf3999/u/NN/X1r8XnrpJfff1KU+PwWf33zzjbVr186DvQYAAAAAJAZxrtdMc41UsaFQSJVDfuPGjXNfnl944YXAfRMnTnSB1ZYtW+ymm24K2Y6GNKuKST9z5crl7lPVlAIU3a/tqOpD1VaqitLrqXrqq6++ctVSkdG2tA8VK1Z0twsUKBDl+1AlkfZN+63QqFixYrZ3717XIqX5PUmT/i8PLFOmjA0ZMsT9rsojrb9w4UK76667Ltqm9u/IkSMuTLvxxhvdfcWLFw88rqooVWO1atXK3Val1LPPPusqsfyvIc2aNbM2bdoEbu/YsSPkdYYPH+6OjX+ul/br1VdfdWGYwjUdBwVp2g9VlWkWkY5LdBVrWoLfB7yhqjm/2267zZ0fqpx68sknbdu2bfbmm2/a2rVrL7kd/Tejz7hs2bLXeY8BAAAAAIlFnAuloqJqo2+//da17kVW2RMxlFIV0Pnz5y+6X+FIlixZ3O+qZEqePLl9/vnnbnjzp59+6iqoateuHek+PPHEE656aM2aNVanTh1XtaQh4ZFRJZUqvoLnNKnVTgOj//jjDzdE2h9KBVOb34EDByLdplqw1N5Yt25dF1ppP1Uppuf4j9GyZctCKqN0DE6dOhUI3sQfqkVF21GFlKrG/Hw+n2v72rlzp3ttBVEKvVRRpUWVV5FVl/lDLgVmiH3+MFRU/aZqQ/9/I5ovduzYMVf9p3BW7a6iz12h1IABA2JtvwEAAAAACU+ca9+LisKcBg0auJlNwYta8SJrPdL6Gj6uIc7B6yss8rcvqSJLs5D8LXz6+fDDD0c5rFzzrNTGpCoTVT3VqlXLVV9dDYViwRRiBc/8iUjhgNr2FIaprU6Bwk8//RR4zwp/gt+vwjkdo+A5QKpyio6206FDh5DtKKjSdlShpeooBXPTpk1zgZgqv1RBEzyTKpjCDFV4+Zc9e/Zc5lHClZo+fbqrTFOoqLbLESNGuGBVFGiqWsr/Gb/zzjvus9XvwZVvaifV7LZHHnmEDwIAAAAAkLArpRQWqcInYhuSKpnUMheTK9zpS7W2oaojDeyOitrUVPnzyy+/2KJFiy6a+RSRhpyrPU6LttunTx8bNWrUReuprU77qzDAXy2lKiZ96c+TJ88l9/9S702Lwh5VYylMU2uWjpHmBxUuXPiqtq/taCZVdNvRZ6BKLS1qDdTQdR2/yK7MpkHvWuA9tYNq7pjmkWngf6dOnaxXr17uMVW2BVe36dzWuRrx/NQsKoW3aq0FAAAAACBBh1IKnjT4W1e0U7ue2tY6d+5sEyZMcNUa/qvVqcpDQ8xV4aGqqGCqIFLgpMHfuuKYQhwNe9a8JrXM1a9f362nKivNrtK6BQsWDLQsRUYVQTfffLO7ipnaAL/88suQmU7B9OV/zJgx1rVrVzcgXGGRwpuePXuGtFBdDrXOvf322+7KeZqTpW2qeknv0b9/mvOk1kCFCHodVTjpqoWXCtuCae6VQi7ttwZbq7JKIZUqZhRy6H1rDpWOXaZMmWzOnDmuuqto0aJX9L5w/Xz//fcxXldXg4ys2k3VVgAAAAAAJIr2PbXEKWQqUaKEq97wDytXpZGqnzTPqXTp0m4Qtyp0ogp51OqmwEaVIQpMNANq5cqVgXlOosoQBV0KbxRMXaqCS9VJCrUUyGgfFYpFRlUpCmtWrFjhWts6duxobdu2tUGDBl3xcVFVy2+//ebarxS6qQJGYZ1a7USzphQYff311+6qfwqWXnnlFTf/6XLo/X333XdugLyqwRToKfDyD4zXMf/ss8/c1RAVymlYtlr5FNYBAAAAAADERBKf+ssAD2nGkVrBag6cbmGpIh+Ojqs3f/D/qgEBAAAAAIiN7/2aK60LysWrSikAAAAAAAAkbIRSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8FyY9y8J/M/MfnWjvTQkAAAAAABIuKiUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOe4+h5iTeMX51tYqnA+gQjmD67PMQEAAAAAJHhUSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKHUdTJ58mTLmDHjNdve4sWLLUmSJHb48GFLSO8Ll/bff/9Z4cKFQ477Aw88YDlz5rT06dNbwYIF7bnnngt5ToECBSx16tSWNm1at/CZAQAAAADiGkKp6+Thhx+2LVu2XK/NIxF5+umnLX/+/CH3DRkyxHbt2mVHjx617777zj788EN7//33Q9aZNm2aHT9+3C2xHWYCAAAAABARodR1oiqVG264wRKSs2fPxvYuJDqrV6+2efPmWb9+/ULuL126tKVMmdL9rgq6pEmT2tatW2NpLwEAAAAAuHyJIpSqUaOGde3a1Xr06GGZMmWy7Nmz24QJE+zEiRPWpk0bS5cunWuPmjt3brRtarNmzXIBgN/69evtzjvvdM9XG9XNN99sq1ativL5X3zxhd1yyy2WKlUqy5o1qzVu3Djw2HvvvWcVK1Z028qRI4c1a9bMDhw4EOP32Lt3b7v33nsDt8eMGeP2VYGGn97jO++8436/cOGCDRs2zPLkyePCjXLlyoWsqyocPf/jjz+26tWru33+4IMPLnrdv//+2+233svp06djvL+4tHPnzln79u3t9ddftxQpUlz0eKdOnSw8PNzy5cvnqqFat24d8niHDh3ceVa5cmWbM2cOhxwAAAAAEKckilBKpkyZ4r6gr1ixwgVUTzzxhD344INWpUoVW7NmjdWpU8datGhhJ0+ejPE2mzdv7kKdlStXuoqW/v37W/LkySNd96uvvnLBzT333GNr1661hQsXWqVKlUKqkJ599lkXdCn8UigUMWSIjoKjpUuX2vnz591ttXTp/WoWlfz555+2fft2F9DJ2LFjbfTo0TZq1CjbsGGD1a1b1xo2bHhRtY3eU/fu3W3Tpk1unWB79uyxatWqWalSpeyTTz4JVO7g2njppZesfPnydscdd0T6+BtvvOHCKJ1/LVu2dIFrcMi5c+dO97nrfL///vvdegAAAAAAxBWJJpQqW7asDRo0yIoUKWIDBgwIVCupEkX3aW7PwYMHXUATU7t377batWtbsWLF3DYUcul1IvP8889b06ZN7ZlnnrHixYu79bQffo899pjVq1fPChUqZLfddpu9+uqrrnJLoUNMKBw6duyYC7x8Pp99//331qtXr0AopZ+5c+d21VKiMEotYdqnokWL2osvvuiqpVRhFUzVZU2aNHHDtDVY22/z5s1WtWpVF1RNmjTJkiVLFuW+qYJKs4+CF0Rv27Zt9uabb7pgKjpq2/NX2KlaLvh8UBWVgkJV3TVo0MA+/fRTDjsAAAAAIM5INKFUmTJlAr8rQMmSJYuby+Onlj65nJa5nj17Wrt27VwwNWLECFeJFJV169ZZrVq1onxclVYKDtSKpYBBlU/+4Csm1CqooEvh088//+zavR5//HEXUinYUuWUf5sKhfbu3etCpWC6rYqoYAo8IrsanEIPhVWquApuaYzM8OHDLUOGDIElb968MXpPiZmq3vbv32833XSTC0/vu+8+97np9+XLl1+0virtopsppfAKAAAAAIC4JNF8U43YVqcgJfg+f7CiWUv+L/GqOIpu0PfQoUPtl19+sfr169uiRYusRIkSNnPmzCgHn0dFs61UcaS5VJrbpDYr/3bOnDkT4/eo1jyFUv4AKnPmzK4qSwFHcCh1OdKkSXPRfaq+URD35ZdfuvawS1FF2JEjRwKL2v4QvYceeshVSynM1KJZYAor9btmjqnqSWGjztcffvjBVdb52ysVZKpSThVqOmenT59us2fPtkaNGnHYAQAAAABxRqIJpS5XtmzZXDucAiM/BQIRqZLlySeftK+//tpVDqmVLapKLc2Risxvv/3mWgdVbaUKJLUDXk7FVsS5Unod/+wo/Zw2bZpt2bIlcJ/Cr1y5ctmyZctCnq/bCtYuRYGdZhZpsLsGvavqKjoKsfSawQuip9Y7zSvzLzofFZzqd1GbpX5XhZxaPzU3SvO/RGFVt27dXDWgnqdWTQVTagsFAAAAACCuCIvtHYirbr31VhcMDBw40H3BV8uUrqgX3MLWp08fe+CBB9y8pT/++MNVOGmgdGSGDBni2vduvPFGN8dJV1bTFdE010kte2q3e+2116xjx462ceNGN/T8cmkgtoI0VTAp4BIFUdpHzYNSgOanfdc+aX80S0phmkK3yK6wFxm1QGrdRx55xGrWrOkqtFTBg+tDn+Phw4fd7/nz57clS5ZEua6CxcgCVAAAAAAA4hIqpaKg1rf333/fBUeaPaVqI7XrBYcyqm7SVc8U9qjdSoPKNcg8qlBhxowZ9vnnn7sQSEGOrgQoqmZR4KXHFSgoUFJ1y+XS1de0r9qeqq38QZVavCK27ilo00wsDUPXc+bNm+f2TQPbYyosLMwdl5IlS7r3cyXVXQAAAAAAIHFK4os4OAm4zjSwWwPPaw6cbmGpwjneEcwfXJ9jAgAAAACI99/7NVc6uhE+VEoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8FyY9y8J/M/MfnWjvTQkAAAAAABIuKiUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOe4+h5iTeMX51tYqvBE+wnMH1w/tncBAAAAAIBYQ6UUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM8RSsWCGjVqWI8ePa74+bt27bIkSZLYunXr3O3Fixe724cPH47yOZMnT7aMGTMGbg8dOtTKlSt3xfuAa6dr166WN29eS58+veXOndudG2fOnHGPrV692m6//Xb3WKFChWzq1KmB5y1ZssTSpk0bsiRNmtS6devGxwMAAAAAiPMIpeIhBRj79u2zUqVKXfE2evfubQsXLrym+4Ur06lTJ/vtt9/s6NGjtn79ereMHDnShYz33HOPPfroo/bvv//atGnTXIC1dOlS97xq1arZ8ePHA8v27dstWbJk1rRpUz4KAAAAAECcRygVDyl4yJEjh4WFhV3xNlRVkyVLlmu6X7gyxYsXtzRp0rjffT6fq3baunWr/fDDD5YyZUrr2LGj+8xvvfVWa9Kkib3zzjuRbmfKlClWpEgRq1KlCh8FAAAAACDOI5SKJefOnbMuXbpYhgwZLGvWrDZ48GAXSIha8WbNmhWyvlrv1IIXWfteZLRuvnz5LDw83Bo3bmwHDx4MeTxi+17r1q2tUaNGNmrUKMuZM6cLrDp37mxnz54NrKPqrPr161vq1KmtYMGC9uGHH1qBAgVszJgx1+y4JFYjRoxwQeENN9zgKqVUEXXhwoXAOeGn+zZs2BDpNiZOnGht27b1aI8BAAAAALg6hFKxRFUtqnRasWKFjR071l5++eUoK2Au1/Lly104odBLwdWdd95pzz333CWf9+2337oWMP3U/inY8gdh0rJlS9u7d6+bYfXpp5/a22+/bQcOHLgm+5zY9e/f37Xg/frrr64ySpVwlStXthMnTti4ceNcOLhs2TKbOXOma/OLSPOlduzY4T4jAAAAAADigyvv/8JVz4V65ZVXXMVT0aJF7eeff3a327dvf9VHViHX3XffbX379nW3b7rpJtcKNm/evGiflylTJheAqFWsWLFiripKc6e0T5p59M0339jKlSutYsWKbn2FaGoXu5TTp0+7xS+yUAX/18pXtmxZV7mm4/3FF19Ynz59bMiQIVaiRAlr06aN/fTTTxcdrnfffdcaNmxo2bJl41ACAAAAAOIFKqViyW233eYCKT9VxWiO0Pnz569625s2bXLzh4Jp+5dSsmRJF0j5qY3PXwm1efNmV9lVoUKFwOOFCxd2QdalDB8+3LUp+hcFcoiaqqJ0LkjVqlVdoKj2S1VD/fXXX1a9evWQ9RXyzZgxw9q1a8dhBQAAAADEG4RScZDCqoizhIJnO10vyZMnv2g/NMPoag0YMMCOHDkSWPbs2XPV20wo1LI3adIkd6U9feaqmFOrZd26dd3ja9eudVVm//33n02YMMG1Tvbo0SNkG7oqn2aA1alTJ5beBQAAAAAAl49QKpZo7lMwtWSpFU6VSmrB0lBxP1XNnDx58rJawCLb/tVQi6GGsysk8du2bZv9+++/l3yuriCXPn36kAX/F/xpYPyNN95o6dKls/vuu8+1TfqHx7/66quWPXt2d06oGmrRokWWK1eui1r31Nanq/YBAAAAABBfMFMqluzevdt69uxpHTp0sDVr1thrr71mo0ePdo/VrFnTzXZSy53a+fr163dRFVN0unXr5tq+dCU9hRzz58+/5DypS9GMqdq1a9vjjz9u48ePd/vTq1cvdyW+4DZEXJ40adLYggULonxcVVRaoqNh+QAAAAAAxDeUVsQSXSVNLVmVKlWyzp07W/fu3V3gIwqnNHepWrVq1qxZM+vdu7eFh4df1rwqtXpp4LmGZn/99dc2aNCgq97nqVOnuqqdO+64wxo3buwGoKu6J1WqVFe9bQAAAAAAkLgk8UUcXgTE0B9//OHCM10lrlatWjE+bhrMrYHnNQdOt7BUMQ/bEpr5g+vH9i4AAAAAAHDN+b/3a650dCN8aN9DjGmekQZzly5d2s286tu3rxUoUMBVTgEAAAAAAFwOQinEmK4AOHDgQNuxY4dr26tSpYp98MEHlzXvCgAAAAAAgFAKl6Vu3bpuAQAAAAAAuFoMOgcAAAAAAIDnCKUAAAAAAADgOUIpAAAAAAAAeI5B54g1M/vVjfbSkAAAAAAAIOGiUgoAAAAAAACeI5QCAAAAAACA5wilAAAAAAAA4DlCKQAAAAAAAHiOUAoAAAAAAACe4+p7iDWNX5xvYanCE+wnMH9w/djeBQAAAAAA4iwqpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKuM66du1qefPmtfTp01vu3LmtR48edubMmZB19u/fb5kzZ7Zy5cqF3L9gwQKrUKGCpUuXzkqUKGHz5s3j8wIAAAAAJAiEUsB11qlTJ/vtt9/s6NGjtn79ereMHDkyZJ0uXbpY+fLlQ+7bsWOHNW7c2IYNG2ZHjhxxz7n//vvd/QAAAAAAxHeEUsB1Vrx4cUuTJo373efzWdKkSW3r1q2Bx2fPnm2HDh2yFi1ahDxPVVGqkrr33nvdc/SzUqVKNnXqVD4zAAAAAEC8Ryh1HVy4cMFVtRQuXNhSpkxp+fLls+eff9499vPPP1vNmjUtderUliVLFnv88cft+PHjgee2bt3aGjVqZC+88IJlz57dMmbM6Cplzp07Z3369HEtXnny5LFJkyYFnrNr1y5LkiSJffTRR1alShVLlSqVlSpVyr777rvAOufPn7e2bdtawYIF3WsXLVrUxo4dG7Lf/tceNWqU5cyZ0+1f586d7ezZs+5x7Ye2G5FazgYPHnw9DmWCMWLECEubNq3dcMMNrlJKLX2iCqiePXvam2++Gel5pBAr4n0bNmzwbL8BAAAAALheCKWugwEDBrgQQkHNr7/+ah9++KELmE6cOGF169a1TJky2cqVK23GjBn2zTffuNatYIsWLbK9e/fa999/by+//LINGTLEVcnoecuXL7eOHTtahw4d7I8//gh5nkKrXr162dq1a61y5crWoEEDO3jwYCDMUJil19Q+Pf300zZw4ECbPn16yDa+/fZb2759u/s5ZcoUmzx5slvkscces02bNrl999NrKSRp06bN9TiUCUb//v1d+Khjr88vR44c7v6+ffu6MLBIkSIXPeeuu+5yx3rWrFkulNTPZcuWuTZAAAAAAADiuyS+iKUYuCrHjh2zbNmy2bhx46xdu3Yhj02YMMH69etne/bsCbRzzZkzx4VHCqEUXCmgWLx4sZsbpJYtKVasmKuwUUjlr3rKkCGDvfPOO9a0aVNXKaUKKAVh2r4oxNB9qshR8BEZhWF//fWXffLJJ+62/7UVSiVLlszd99BDD7n9UBWW3HPPPVagQAF744033O1u3bq56i+FWFE5ffq0W/wUqmjwd82B0y0sVbglVPMH14/0fgWDb731lgsbn3jiCVuzZo2lSJHChX9jxoyxdevWhbT2DR061H7//XerWrWq+9xVufbxxx97+E4AAAAAAIg5fe/X91d1B+miX1GhUuoaUyWRAphatWpF+ljZsmUDgZQoaFAV0+bNmwP3lSxZMhBIicKq0qVLB24rMFJr3YEDB0K2r+oov7CwMKtYsaJ7Tb/XX3/dbr75ZheaqZXs7bfftt27d4dsQ6/tD6REbXzBr9O+fXubNm2anTp1yl1BTlVgqqCKzvDhw93J6F8USCVmCpU0U2rhwoUufMyVK5dlzZrVBYgbN250v+/bt8+te99997lqNM2c+uKLL9zzqlevHttvAQAAAACAq0YodY1pXtPVSp48echtzYuK7D6FWTGlSqfevXu7uVJff/21q8ZRy52CpUu9dvDrqKpLc7JmzpzpQhIFLA888MAl2xmVjvoXVYolFmrZ0/yvw4cPu/lQqip77rnnXBunZklt2bLFfRZaNLNLs770uyrjZNWqVa7qTRV4elzhVKtWrWL7bQEAAAAAcNUIpa4xzQZSMKUqmMiuwqYh15ot5acZQaqKUhhxtX766afA7woyVq9e7V7T/zoagt6pUycrX768G8KuNr3LpQoshSIKWrSoffBSQZxCLJXrBS+JhUI9VZPdeOONli5dOlf5VL9+fdemp+OgOV/+RTPDFArqd3+1mgI9/3B7ze5Sm2RwpR0AAAAAAPFVWGzvQEKjK99prpPmOGlOkNrz/v77b/vll1+sefPmbo6QQh3NCdL9atlq0aKFa9G7WmrPUyimIOqVV16xf//9N9Bap/unTp1q8+fPd7Om3nvvPTdEW79fLs3KCg67EDUFSAsWLIjRIdJMLy3BYvpcAAAAAADiG0Kp60BX3VNFka5wpwHmmsukK66Fh4e7UKh79+52yy23uNv333+/u8LetaBB51rU/qVKqM8//9zNJxJdrU+ziR5++GFXvfPII4+4qqm5c+de9uso4FLVlVrJbr311muy7wAAAAAAIHHh6nsJgP/qewqdypUrd91fT7ORFEwp1NJcpCudwp9Yr74HAAAAAEBCFtOr71EphcuilkMNTf/rr7/coHQAAAAAAIArQSiFy6Krwqkl8O2333aDuQEAAAAAAK4EoVQCUKBAAddS5wWvXgcAAAAAACRsSWN7BwAAAAAAAJD4EEoBAAAAAADAc4RSAAAAAAAA8BwzpRBrZvarG+2lIQEAAAAAQMJFpRQAAAAAAAA8RygFAAAAAAAAzxFKAQAAAAAAwHOEUgAAAAAAAPAcoRQAAAAAAAA8x9X3EGsavzjfwlKFx8tPYP7g+rG9CwAAAAAAxGtUSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUcIVOnz5t7du3t4IFC1q6dOmsWLFiNnHixMDjq1evtttvv93Sp09vhQoVsqlTp4Y8t0aNGnbDDTe4x/Xct99+m88CAAAAAJBoEErFoqFDh1q5cuVifRu4MufOnbOcOXPaN998Y0ePHrXJkydbr1697Ouvv7bDhw/bPffcY48++qj9+++/Nm3aNOvatastXbrUPTcsLMxee+0127t3r3vuZ599ZoMHD7YlS5bwcQAAAAAAEgVCqVjg8/lcoIH4LU2aNDZs2DC78cYbLUmSJHbbbbfZnXfe6YKnH374wVKmTGkdO3a0ZMmS2a233mpNmjSxd955xz1X95UuXdqFU6Lna9m2bVssvysAAAAAALxBKGVmn3zyiQsIUqdObVmyZLHatWvbiRMn3AFq3bq1NWrUyJ555hnLli2ba7VS0HDmzJmQVqxu3bq5VqxUqVK5lq2VK1cGHl+8eLELHObOnWs333yzCyvef/99t83169cHAglV2iiwUvVTvnz53Hq5cuVy246M1o9sG6JKnXbt2gX2uWbNmm49v+3bt9t9991n2bNnt7Rp09ott9ziKn6CFShQwJ577jlr2bKlWyd//vz2+eef299//+2eq/vKlCljq1atutbnZbx06tQpW7FihTsmFy5ccJ9lMN23YcOGkPvuvfded86UKFHCfRaNGzf2eK8BAAAAAIgdiT6U2rdvnz3yyCP22GOP2aZNm1yApIqW4EBh4cKFgcfUhqVWK4VBfn379rVPP/3UpkyZYmvWrLHChQtb3bp17dChQyEHu3///jZixAi3rbvuusu1epUsWdLtg5aHH37YbeeVV16xt956y7Zu3WqzZs1ygVlktH5k25AHH3zQDhw44IIwzTaqUKGC1apVK7BPx48fd+1lem9r1661u+++2xo0aGC7d+8OeQ3tS9WqVd069evXtxYtWriQSm1peq+qEtLtiAFMMIV2alELXhIavX+FgEWKFHHnT+XKlV2wOW7cODt79qwtW7bMZs6cedF7//LLL916Orfuv/9+F4wCAAAAAJAYEErt2+da6RQkqDJIAVCnTp1cFZBfihQp3ABrhT8KZtSy9eqrr7rKFwUK48ePt5deesnq1avnKl4mTJjgwoV333035GDreQqjFOTkzp3bvYbat3LkyOEWPUehkH5XtZaqpSpVquSGaUdG60e2DbWPqWJnxowZVrFiRReUjBo1yjJmzOiqwqRs2bLWoUMHK1WqlHv82WefdfulSqhgCq60ntZ5+umnXaiiqiqFXjfddJP169fPhWz79++P8iQbPny4ZciQIbDkzZvXElogpXNm8+bNLkRMmjSpq7j74osv7MMPP3SfiwLJNm3auPsjUitf9erV3THUeQQAAAAAQGKQ6EMphTOqIFIYpaBFgZIGU0dcJzw8PHBbVTCqNNqzZ49rg1MljKqJ/JInT+7CJIU1wRQQXYr24b///nNXa1MYpeqay50/pTY97Z8CEIVW/mXnzp1uf0WP9+7d24oXL+7CKj2u/Y1YKaVWND+1l0lw5Zb/PlVlRWXAgAF25MiRwKLjlpACqc6dO9vy5cvdgHOFbn46JzRb6uDBg26A+V9//eXCp6joPFJ1HAAAAAAAicH/piwnYqpSWbBggQsPFCroimhPPfWUCxkKFix4zQdjX4qqiFRxo/lO2i9V4Kh65rvvvnNhV0wocNJV4dQSFpECKFEgpe2rgkrthqqweuCBB0JmZUnwa2pmVVT3qWosKpqNpSUh6tKli2vNW7RokWXKlCnkMbU8qnJOx0YzxPR56D5Zt26dm82l+WM6nvPnz7cPPvjAhaIAAAAAACQGib5Syh+sqKpFc6IUGqhdTxVKwZVHql7y++mnn1xlkQIktbxpfQUTwRUvGnSuQCI6et758+cvul8BkeY7qUVQQcaPP/5oP//8c4y3oflRqspRW58Cp+Ala9asbh3tr4a4a7C2Kp/UYrZr164Ynzgw+/333+2NN95wIaKGwPsr0jQIX/T5qZJMw+bVSqngSoPrRdVvAwcOdI+rok2/v/zyy9asWTMOLQAAAAAgUUj0lVKqiNKw7zp16rir5+m2KljU1uan6qG2bdvaoEGDXHAzZMgQVyGj2UGqfnriiSesT58+ljlzZjcHauTIkXby5En3nOhohpVa6lQ1kydPHkuXLp0bpK6Q6dZbb3Utg6qwUUil0COm29A8KrUY6qqB2hfNftq7d6999dVXLoTyz5nSwHaFXwrlBg8eHG21Ey6mzyS6Ae+TJk1yS2T0GQRfoREAAAAAgMQm0YdS6dOnt++//97GjBnjhngraBg9erQbWu6nmVMKce644w53JTldrW/o0KGBx3VFPQU6ujLdsWPHXOCgdqyI7VwR6WprCobuvPNOO3z4sAsw1F6n7fXs2dOFU6pi0sDsyAZkR7UNVUDNmTPHtSFquLZCNlVCaf/9M6BUlaMrDlapUsVVT2lgeUK8Kh4AAAAAAIibkviiK/WAC3gU9uiqarg2FH5pIHjNgdMtLNX/DZCPT+YPrh/buwAAAAAAQJz+3q+LnakYKCrMlAIAAAAAAIDnCKUAAAAAAADguUQ/U+pSJk+e7MkHAQAAAAAAkJhQKQUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8BwzpRBrZvarG+2lIQEAAAAAQMJFpRQAAAAAAAA8RygFAAAAAAAAzxFKAQAAAAAAwHOEUgAAAAAAAPAcoRQAAAAAAAA8x9X3EGsavzjfwlKFx4tPYP7g+rG9CwAAAAAAJChUSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKHUZRg6dKiVK1cu2nVat25tjRo1utrPBXHQ6dOnrX379lawYEFLly6dFStWzCZOnOge2717t6VNmzZkCQsLs4YNG160nf3791vmzJkveS4BAAAAAJCQhcX2DsQnvXv3tq5du8b2biCWnDt3znLmzGnffPONFSpUyJYvX2716tWzPHnyWJ06dez48eOBdc+cOWO5cuWypk2bXrSdLl26WPny5e3gwYMevwMAAAAAAOIOKqUug6pfsmTJcv0+DcRpadKksWHDhtmNN95oSZIksdtuu83uvPNOW7p06UXrzpo1yy5cuGBNmjQJuX/27Nl26NAha9GihYd7DgAAAABA3EMo9f+9/fbbrrJFQUKw++67zx577LFI2/fOnz9vPXv2tIwZM7qwqm/fvubz+UKer+0NHz7ctXylTp3aypYta5988knIOt99951VqlTJUqZM6Spx+vfv76pyojNhwgTLmzevhYeHW+PGje3ll192++G3fft2t+/Zs2d3Ydott9ziKnyCFShQwJ577jlr2bKlWyd//vz2+eef299//+2eq/vKlCljq1atCnmeQphq1aq596N96Natm504ccISm1OnTtmKFSvcMYro3XfftebNm1uqVKkC9x05csSdL2+++abHewoAAAAAQNxDKPX/Pfjgg66d6ttvvw0cHFW0zJs3z4ULkRk9erRNnjzZzRVSUKP1Z86cGbKOAqmpU6e6IOKXX36xJ5980h599FEXRMmff/5p99xzjwuN1q9fb+PHj3eBhsKiqCxbtsw6duxo3bt3t3Xr1tldd91lzz//fMg6aiXTdhcuXGhr1661u+++2xo0aOBmHwV75ZVXrGrVqm6d+vXruwoehVTaxzVr1riqIN32h20Ku7St+++/3zZs2GAff/yxe+9qSYtuFtPRo0dDlvhOx6Ndu3ZWpEiRi6qhfv/9dxcA6vFgCi01c0zPAQAAAAAgsUvii1jak4hpQLkqnhQK+aunnnnmGduzZ48lTZrUVUqpLUtBkKiySiFTnz593G1VN6ki6uabb3brKYzRQGsFFJUrVw68jsKKkydP2ocffmhPPfWUffrpp7Zp0ybXEiZvvPGG9evXz1XW6HUj0pwihU5ffvll4D6FSLp9+PDhKN9fqVKlXJjlD5BUKaWKp/fee8/d/uuvv1yl1uDBg12bmvz0009u3/ft22c5cuRw+54sWTJ76623AttVKFW9enVXLRVcGeSn46bjGFHNgdMtLFW4xQfzB9cP/K7/ZDp16uQqyPTZZsiQ4aL3q88iuMJsyZIl9sQTT7igL0WKFC7MHDNmTOBcAgAAAAAgoVAxir4rK9dInz59lOtRKRVEFVEKiBQmyQcffOACoMiCIR1YBTW33npr4D5dba1ixYqB29u2bXPhkyqZgq/KpsopVRyJwiiFPv5ASlS5pNDpjz/+iPRD27x5s2v3Cxbxtp6vwezFixd3bX16Xb1WxEqp4NYztfpJ6dKlL7rvwIED7qequRSoBL+funXrujbFnTt3Rrq/AwYMcMfLvyjki68USHXu3NkNOf/6668vCqR0HCZNmnRRlZQq1nbs2OGCzKxZs7qB+Rs3bnS/6zwCAAAAACCx4ep7QdTeptDhq6++cu10qm5Re9uV8l+NTdvLnTt3yGOaH3U9KZBasGCBjRo1ygoXLuzmPz3wwAPuqnDBkidPHvjdH4xFdp9/1pbeU4cOHdwcqYjy5csX6b7ovV7v9+sVVZmpfXLRokWWKVOmix7XMf/nn3/skUceCblfs6SCg6oZM2bYO++8Y/Pnz7cbbrjBk30HAAAAACAuIZQKotYzzQdShZSqnIoWLWoVKlSI9MCpQkatbqqYueOOOwLte6tXrw48p0SJEi6MUXWS2tsio0omVWcpDPMHQAo90qVLZ3ny5In0OdqvlStXhtwX8ba2oflFGoLuD5N27dplV0vv7ddff3VBV2KjWVFqrdRnqqHwwa2T/uHlav1U+BexgkrlisEliwq0FP5F9RkDAAAAAJDQEUpF0sJ37733uqHkChuio0HjI0aMcIOrixUr5q6AFzzTScGSKpY0d0qVRrfffrtrX1NgpICiVatWbjaRZgupnUtVOGrNGzJkiKusiaxtULSugjC9nqq7VLUzd+7ckBZA7dNnn33mHtf9mhMV8cqCV0Kzrm677Ta3r6r8SZMmjQupVCE0btw4S8gURF1qBNv06dNjtC0FhloAAAAAAEismCkVQc2aNd1wcoVDzZo1i/bg9erVy12tTuGS5kIphPJXJvk9++yzLhDSVfhUFaUr16mdTwPRRW19c+bMsRUrVljZsmXdIPK2bdvaoEGDonxdzZxSZY5CKT1HVwhU8BU8ZFyPqRqnSpUqLpjS3Keoqr4uh2ZQ6cqBW7ZscUPSy5cvb08//bSblQQAAAAAABBTXH0vgWjfvr399ttvbg5WfJnCH1+vvgcAAAAAAK7+6nu078VTGmCuq/qpfU6te1OmTHHzjgAAAAAAAOIDQql4Su1+I0eOtGPHjlmhQoXs1VdfDbm6GwAAAAAAQFxGKBVPxXSgNgAAAAAAQFzEoHMAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOeYKYVYM7Nf3WgvDQkAAAAAABIuKqUAAAAAAADgOUIpAAAAAAAAeI5QCgAAAAAAAJ4jlAIAAAAAAIDnCKUAAAAAAADgOa6+h1jT+MX5FpYqPE5+AvMH14/tXQAAAAAAIEGjUgoAAAAAAACeI5QCAAAAAACA5wilAAAAAAAA4DlCKQAAAAAAAHiOUAoAAAAAAACeI5QCAAAAAACA5wilgCicPn3a2rdvbwULFrR06dJZsWLFbOLEiRett3//fsucObOVK1cucN+SJUssbdq0IUvSpEmtW7duHG8AAAAAAMwsjKMARO7cuXOWM2dO++abb6xQoUK2fPlyq1evnuXJk8fq1KkTWK9Lly5Wvnx5O3jwYOC+atWq2fHjx0OCKz2vadOmHG4AAAAAAKiUAqKWJk0aGzZsmN14442WJEkSu+222+zOO++0pUuXBtaZPXu2HTp0yFq0aBHtoZwyZYoVKVLEqlSpwiEHAAAAAIBQKuH55JNPrHTp0pY6dWrLkiWL1a5d206cOGEXLlxwAYuqdVKmTOlazebNmxd43q5du1zw8tlnn7ngJTw83MqWLWs//vhjyPYnTJhgefPmdY83btzYXn75ZcuYMaMlBqdOnbIVK1ZYmTJl3O0jR45Yz5497c0337zkc9X217ZtWw/2EgAAAACA+IGZUgnIvn377JFHHrHHHnvMNm3aZIsXL7YmTZqYz+ezsWPH2ujRo23UqFG2YcMGq1u3rjVs2NC2bt0aso2nnnrKevfubevWrbObbrrJbU9tbLJs2TLr2LGjde/e3T1+11132fPPPx+j2UxHjx4NWeIbHcN27dq5aicdU+nbt6+1bt3a3RcdzZfasWOHtWzZ0qO9BQAAAAAg7mOmVAILpRQgKTTJnz+/u09VU6Iwql+/foGZRi+++KJ9++23NmbMGHv99dcD21AgVb9+fff7M888YyVLlrRt27a5Id+vvfaam6mkdUSh1Q8//GBffvlltPs1fPhwt634SoFUp06dbPPmzW6+lAaWK2hSSLdmzZpLPv/dd991AWC2bNk82V8AAAAAAOIDKqUSELXb1apVywVRDz74oGu1+/fff11l0t69e61q1aoh6+u2KqqC+VvTREO+5cCBA+6nQplKlSqFrB/xdmQGDBjgWt38y549eyw+BVKdO3d2Q86//vpry5Ahg7t/4cKFrvopV65cljVrVuvatatt3LjR/a5w0E/HfsaMGa7KCgAAAAAA/B9CqQQkWbJktmDBAps7d66VKFHCVTYVLVrUdu7cGeNtJE+ePPC7ZkyJ5lFdDc2wSp8+fcgSX+jKeqqI0nHNlClT4H7NktqyZYtrY9SieV061vr9hhtuCKw3bdo0N9sr+Gp9AAAAAACAUCrBUZCkCii1y61du9ZSpEjhqnpU0aNwJZhuK7yKKYUuK1euDLkv4u2E5Pfff7c33njDVYipHTJt2rRu0VwtBWsaGu9fFFgp0NPvCgeDW/fatGnjWv4AAAAAAMD/YaZUAqIWMwVQqspRtY5u//3331a8eHHr06ePDRkyxG688UZ35b1Jkya5qp4PPvggxttXi9odd9zhrrjXoEEDW7RokavK8ldUJTQKotS+FxMaeK4lIl2tDwAAAAAAXIxQKgFR9c7333/vhpdrlpFCFV1xT8PJdbU9zXPq1auXmxGlCqnPP//8kleOC6YKrDfffNNVYQ0aNMht88knn7Rx48Zd1/cFAAAAAAASniS+mJaCAJFo3769/fbbb+5qdDGlwEwDw2sOnG5hqcLj5HGdP/h/VyAEAAAAAACXx/+9X8Ux0c2VplIKl2XUqFF21113WZo0aVzr3pQpU9zcJQAAAAAAgMtBKIXLohlJI0eOtGPHjlmhQoXs1VdftXbt2nEUAQAAAADAZSGUwmWZPn06RwwAAAAAAFw1rlMPAAAAAAAAzxFKAQAAAAAAwHOEUgAAAAAAAPAcM6UQa2b2qxvtpSEBAAAAAEDCRaUUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPMfV9xBrGr8438JShceZT2D+4PqxvQsAAAAAACQaVEoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8ByhVAJSo0YN69Gjx3V9jQIFCtiYMWMsoTp9+rS1b9/eChYsaOnSpbNixYrZxIkT3WMHDhyw5s2bW548eSx9+vRWvnx5+/zzz0Oe7/P5bPjw4e44pUmTxm666SZbvnx5LL0bAAAAAADirrDY3gEgLjl37pzlzJnTvvnmGytUqJALlOrVq+eCqMKFC7sg6sUXX7RcuXLZV199ZU2bNrWVK1daiRIl3POfeuop+/77793zb7zxRtu9e7elSJEitt8WAAAAAABxDqEUEETVTcOGDQvcvu222+zOO++0pUuXWp06dax3796Bxxo0aGBFixa1n376yYVShw4dspdfftk2bNjgAizJnz8/xxcAAAAAgEjQvpcAK326dOliGTJksKxZs9rgwYNdS5n8+++/1rJlS8uUKZOFh4e7CqCtW7eGPP/TTz+1kiVLWsqUKV0L2ujRo6N9vXfeeccyZsxoCxcutITo1KlTtmLFCitTpsxFj6mdb9OmTYHHFE7puE2bNs1VUun49evXz86cORMLew4AAAAAQNxGKJXATJkyxcLCwlyQMnbsWFe5o+BIWrdubatWrXJzkH788UcXVt1zzz129uxZ9/jq1avtoYceci1pP//8sw0dOtSFWpMnT470tUaOHGn9+/e3r7/+2mrVqhXtnKajR4+GLPGBjk+7du2sSJEi1qRJk5DHFDTpOOl4VaxY0d2nSim9NwV9W7ZscW18c+fOde1+AAAAAAAgFO17CUzevHntlVdesSRJkrjWMoVLuq0h6Aqjli1bZlWqVHHrfvDBB279WbNm2YMPPugCLIVLCqJEQ7p//fVXe+mll1ygFUwVQO+995599913rrIqOhr8/cwzz1h8okCqU6dOtnnzZjcfKmnSpCGB1AMPPOCqzSZMmBC4P23atO6n3qt+19K9e3d76623AscUAAAAAAD8D5VSCYxmICmQ8qtcubKr3FG4pAqqW2+9NfBYlixZXHClFjTRz6pVq4ZsT7f1/PPnzwfuU0ufwhjNWbpUICUDBgywI0eOBJY9e/ZYXA+kOnfu7IacqwpMrZDBgZQCPP1Uq2PwEPOyZcvG0h4DAAAAABD/EErhslWrVs2FVNOnT4/R+pqzlD59+pAlLtNMLlWULViwwM3f8lObo9r1Tpw44arL9L6CFSxY0GrXru0GpZ88edL27t1rr732mt13332x8C4AAAAAAIjbCKUSGFX3BNPwbc1E0tXhNAQ9+PGDBw+69jQ9JsWLF3dhTDDdVhtfsmTJAvdVqlTJzUp64YUXbNSoUZaQ/P777/bGG2+446Ir5/nb8Dp27Gg//PCDzZ492x0TDZH3P6bj4KeWSFWDZc+e3W655RarW7eu9e3bN1bfEwAAAAAAcREzpRKY3bt3W8+ePa1Dhw62Zs0aV6mjdjsFU6rYad++vZtxlC5dOjekPHfu3IFKnl69erkg5dlnn7WHH37YDUMfN26cC2ki0lyqOXPmuCv4qS2wR48elhAoiPJfrTAy0T0mN9xwg6uiAgAAAAAA0SOUSmBatmxp//33n6tmUnWTBm0//vjj7rFJkya52/fee6+biXTHHXe4YCl58uTu8QoVKriWvKefftoFUzlz5nStaBGHnPvdfvvt9tVXX7kr+Om1unbt6ul7BQAAAAAA8VcS36VKP4Br7OjRo254eM2B0y0sVXicOb7zB9eP7V0AAAAAACDBfO/XeJvo5kozUwoAAAAAAACeI5QCAAAAAACA5wilAAAAAAAA4DlCKQAAAAAAAHiOUAoAAAAAAACeI5QCAAAAAACA58K8f0ngf2b2qxvtpSEBAAAAAEDCRaUUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPMfV9xBrGr8438JShXv2evMH1/fstQAAAAAAQPSolAIAAAAAAIDnCKUAAAAAAADgOUIpAAAAAAAAeI5QCgAAAAAAAJ4jlAIAAAAAAIDnCKUAAAAAAADgOUIpJDrjxo2zihUrWsqUKa1Ro0Yhj/36669Wq1Yty5Qpk+XIkcMef/xxO3nyZODxwYMHW+nSpS0sLMx69OgRC3sPAAAAAEDCQCiFK1ajRo14GczkypXLBg0aZO3bt7/osWbNmlnRokVt//799vPPP9v69evt2WefDTxeuHBhGzlypDVs2NDjvQYAAAAAIGEhlEKi06RJE1chlTVr1ose27Fjhz366KOWIkUKy5YtmwufFE75tWrVyurVq2fp06f3eK8BAAAAAEhYCKXiqQsXLtjw4cOtYMGCljp1aitbtqx98skn7v48efLY+PHjQ9Zfu3atJU2a1H7//Xd3+/Dhw9auXTsXvChgqVmzpqsK8hs6dKiVK1fO3nvvPStQoIBlyJDBmjZtaseOHXOPt27d2r777jsbO3asJUmSxC27du2y+K537942depU+++//+yvv/6ymTNnWoMGDWJ7twAAAAAASHAIpeIpBVIKT95880375Zdf7Mknn3QVPkuWLLFHHnnEPvzww5D1P/jgA6tatarlz5/f3X7wwQftwIEDNnfuXFu9erVVqFDBzVI6dOhQ4Dnbt2+3WbNm2ZdffukWhVAjRoxwjymMqly5smuB27dvn1vy5s0b6b6ePn3ajh49GrLEVaqCWrp0qaVLl85y5szp3tNjjz0W27sFAAAAAECCQygVDynkeeGFF2zixIlWt25dK1SokKtcUij11ltvWfPmzW3ZsmW2e/dut76qpz766CN3vyh0WbFihc2YMcMN/C5SpIiNGjXKMmbM6Kqt/PS8yZMnW6lSpaxatWrWokULW7hwoXtMlVNqcQsPD3cDwbUkS5YsygBN6/uXqMKr2Pbvv/9a7dq1XdCm4eYK6NKkSeOOKwAAAAAAuLYIpeKhbdu2udDkrrvusrRp0wYWVU6pukltd8WLFw9US6nCSVVRqo4StekdP37csmTJEvL8nTt3uuf7qW1PFUN+qhzSdi7XgAED7MiRI4Flz549Fhfpvattr1u3bi5w0xX4OnToYF999VVs7xoAAAAAAAlOWGzvAC6fAiVRWJI7d+6Qx1KmTOl+qipKoVT//v3dz7vvvtuFUP7nK2BavHjxRdtWtZRf8uTJQx7T3ChVT10u7ZN/v+KCc+fOBRa9n1OnTrl5W8WKFXPh3BtvvOHCKAVUEyZMsPLlyweee/bsWTt//nxg0XNVIRbxWAEAAAAAgOhRKRUPlShRwoU8as8rXLhwyOJvjWvWrJlt3LjRzYtSS56/dU80P0pDvMPCwi56fmRXpIuKqokUzMQ3zz33nBsO//zzz9sXX3zhfq9Tp44LpHR72rRp7jioUkwD4adMmRJ4rlr7tP77779v48aNc7/rPgAAAAAAcHmolIqH1FKnq8RpuLkqfW6//XbXFqc5UrqSXqtWrVygUqVKFWvbtq0Ljho2bBh4vuYmaUh5o0aNbOTIkXbTTTfZ3r17XeVV48aN3ZypmNBrLF++3F11T4FO5syZXcVRXKcrC2qJjIbBa+ZWVDRjSwsAAAAAALg6cT9BQKSeffZZGzx4sBsirvlRas9TqFSwYMHAOqqO0vwoBU2q6Aluw5szZ47dcccd1qZNGxdKNW3a1H7//XfLnj17jI+4gjG1rqlyK1u2bIHB6gAAAAAAAJeSxOfz+S65FnANHT161F2Fr+bA6RaWKtyzYzt/cH3PXgsAAAAAgMT+vf/IkSOuoysqVEoBAAAAAADAc4RSAAAAAAAA8ByhFAAAAAAAADxHKAUAAAAAAADPEUoBAAAAAADAc4RSAAAAAAAA8FyY9y8J/M/MfnWjvTQkAAAAAABIuKiUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOe4+h5iTeMX51tYqnBPXmv+4PqevA4AAAAAAIgZKqUAAAAAAADgOUIpAAAAAAAAeI5QCgAAAAAAAJ4jlAIAAAAAAIDnCKUAAAAAAADgOUIpAAAAAAAAJMxQqkaNGtajR49rtr1du3ZZkiRJbN26ddd03etJ+zBr1qxY3QeYjRs3zipWrGgpU6a0Ro0aBQ7J7t27LW3atCFLWFiYNWzYMOQ81vOC19m7dy+HFQAAAACA6x1KXetw6UrlzZvX9u3bZ6VKlbqm6yZWrVu3DgloErJcuXLZoEGDrH379iH358uXz44fPx5YDh06ZBkzZrSmTZuGrPfiiy+GrKftAQAAAACAyxdm8VCyZMksR44c13zd+ObMmTOWIkUKiyvi2v5EpkmTJu6nKuf++OOPKNdTVduFCxcC6wMAAAAAgFiqlFI1zXfffWdjx451rWha1BonGzdutHr16rl2puzZs1uLFi3sn3/+iXJbp0+ftt69e1vu3LktTZo0duutt9rixYvdY0ePHrXUqVPb3LlzQ54zc+ZMS5cunZ08efKilrx///3XmjdvbtmyZXPPLVKkiE2aNCnK9j29j0qVKrlWrJw5c1r//v3t3LlzIRVh3bp1s759+1rmzJldqDV06NBLHqOJEydayZIlA9vt0qVLyOM6Jo0bN7bw8HC3j59//nngsfPnz1vbtm2tYMGC7j0ULVrUHevIKpqef/55V6GjdeS9995zLWk6PtrXZs2a2YEDB0Ke+8svv9i9995r6dOnd+tVq1bNtm/f7t7XlClTbPbs2YHP1f9Z7Nmzxx566CFXMaTjcN999wU+8+j2JyF499133TmVKlWqkPufe+45dyzKly9vU6dOjbX9AwAAAAAg0YRSCkgqV67s2p7UDqdFrXGHDx+2mjVrui/pq1atsnnz5tn+/ftdmBEVhTU//vijffTRR7ZhwwZ78MEH7e6777atW7e60EThyYcffhjynA8++MAFIAp0Iho8eLD9+uuvLsjatGmTjR8/3rJmzRrpa//55592zz332C233GLr16936yqAUNgQTEGNArPly5fbyJEjbdiwYbZgwYIo35O207lzZ3v88cft559/doFT4cKFQ9Z55pln3HHRe9Y+KPRQm5ioKidPnjw2Y8YM916efvppGzhwoE2fPj1kGwsXLrTNmze7ffnyyy/dfWfPnrVnn33WvR9V+Cg4UmAU/J7vuOMOF5YtWrTIVq9ebY899pgL4hQOap90/P2fa5UqVdw269at6wKsJUuW2LJly1zoqPVUERXd/kQWQipsDF7ist9//92++eYba9euXcj9w4cPd0Gezu8RI0ZY165dXVgKAAAAAACuY/tehgwZXGuWQqHgdjgNjlYg9cILL4RUDCmw2rJli910000h29FAaVUx6ad/Ho+CEYVZul/bUVijaitVRen1FGJ89dVXUQYA2pb2QdVCUqBAgSjfxxtvvOH2TfutqqBixYq5YdX9+vVzQVDSpP/L6cqUKWNDhgxxv6uqSesrgLnrrrsi3a5CrV69eln37t0D9yn4Cqag6JFHHnG/632++uqrtmLFChf0JE+e3IVWfqqYUnCnUCo44FNQ9s4774S0ySlg8itUqJDbrl5bM48UJL3++uvu81MIqNeR4M9FlVkKjoI/1/fff98FZXotHSfR56OqKVVS1alTJ8r9iUhhTvB7i+v0PnU+lS1bNuR+hbJ+Cuw6dOhgH3/8sat+AwAAAAAAHl99T9U53377bcgVyRT0iKpKIlIVkVrVFIoEP0ctdf71VUWk8MTf3vbpp5+6CqratWtHug9PPPGEC1zKlSvnWu5++OGHKPdXlVQKF/xBi1StWtUFOMEzhhRKBVM7XsSWOD/dr2CrVq1a0R6r4G0qzNF7Ct6mwqObb77ZtSHqmLz99tsucAtWunTpiwIgVT41aNDADetWZVP16tXd/f7nqnVR7Xr+QCqmn+u2bdvc9vyfkdrWTp06FfK5RrY/EQ0YMMCOHDkSWNQWGFcpiFMoFbFKKjL+ABMAAAAAAMTCoHOFOQpEdFWyiBTkRLa+ho8rSNHPYAo+RCHHAw884Fr4dPUz/Xz44YctLCzy3dU8K7VczZkzx7WRKRxSK92oUaOu+H1FDHAUYimwiIwqja52mwrVVDE2evRoF5opDHrppZdc+2AwhVnBTpw44ap2tKjFUYGWwijd9rfZxXT/In5OCsi0zYj0GlHtT2TUNqglLlDLon/RsVfIpnDJH6zp/NHsL39Fm5/aVBV2at6Y3ouqxd58802bMGFCLL0TAAAAAAASUSilL+6qcgpWoUIFV8mklrmoQqNgaovSNlQhpOqdqKiFT61yGtCtOUgRZz5FFpS0atXKLdpunz59Ig2lihcv7vbX5/MFqqU0L0khkGY6XQk9V+9f7X133nnnFW1D+6BZTp06dQrcF1mlWUS//fabHTx40M04UluiaLZXxAotzcjSnKjIqqWi+lzVmnbDDTe4iq6EQudRcCuhAjtVlvmHu2u+mAJRtTsG07HT8xSSij7vl19+2c1DAwAAAAAAl++y+o/0RVyVOxqkrWoSVZqoIknDulVZsnLlShekzJ8/39q0aXNR0CFq21Pg1LJlS/vss89s586dbq6S5g5pbpSfBnNrxpHW1XwlXaEvKpoFpavHqd1MIZYGbit8ioxCH7WPaUi1Ah09T7OjevbseVXtWLqKnaqcNM9JA9vXrFljr732Woyfr7lVCpN07DSLS8PbdTwvRS17CpX0Wjt27HAtjxp6HnGwvOZyKVDRa2j/dMU+DSj3f64avq7b+lwVwOi4a1i8rrinQef6nBTc6KqEwW2O8Y0+JwWSwYs/kBLN8FKAF1noqXPfP6hdxyt4lhcAAAAAALg8l5XCqL1MLXclSpQItIlpWLmqfBRAafi1Zgz16NHDDcSOKuTRzB6FUhoMXrRoUXdVPQUwClj8VMWkoEuzjRSQREehjOYWqSJIYZb2Ue1wkcmdO7dr81MQpkHWHTt2tLZt29qgQYPsaqhCa8yYMW6QesmSJd0VBBX+xJSGZjdp0sS1KSqAU/VTcNVUVPQ5TJ482V21T5+LKqYiVohlyZLFVZupJU9VQWrLU9uZv2pKV1TU56BB8dqePk8NmP/+++/dZ6L9Usin46R2t4RUOQUAAAAAAGJHEp9KRQAPqdJI7XE1B063sFThnrzm/MH1PXkdAAAAAAASu6P//3u/LnYWXWELlw8DAAAAAACA5wilAAAAAAAA4DlCKQAAAAAAAHiOUAoAAAAAAACeI5QCAAAAAACA5wilAAAAAAAA4Lkw718S+J+Z/epGe2lIAAAAAACQcFEpBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM8RSgEAAAAAAMBzhFIAAAAAAADwHKEUAAAAAAAAPEcoBQAAAAAAAM+Fef+SSOx8Pp/7efTo0djeFQAAAAAAcI35v+/7v/9HhVAKnjt48KD7mTdvXo4+AAAAAAAJ1LFjxyxDhgxRPk4oBc9lzpzZ/dy9e3e0JyfgRXqvcHTPnj2WPn16DjhiFecj4hLOR8QlnI+IKzgXEZccjePfZVQhpUAqV65c0a5HKAXPJU36v1FmCqTi4n88SHx0HnIuIq7gfERcwvmIuITzEXEF5yLikvRx+LtMTIpQGHQOAAAAAAAAzxFKAQAAAAAAwHOEUvBcypQpbciQIe4nEJs4FxGXcD4iLuF8RFzC+Yi4gnMRcUnKBPK9OonvUtfnAwAAAAAAAK4xKqUAAAAAAADgOUIpAAAAAAAAeI5QCgAAAAAAAJ4jlIKnXn/9dStQoIClSpXKbr31VluxYgWfAK7K999/bw0aNLBcuXJZkiRJbNasWSGPa2ze008/bTlz5rTUqVNb7dq1bevWrSHrHDp0yJo3b27p06e3jBkzWtu2be348eMh62zYsMGqVavmzt28efPayJEj+eRwkeHDh9stt9xi6dKlsxtuuMEaNWpkmzdvDlnn1KlT1rlzZ8uSJYulTZvW7r//ftu/f3/IOrt377b69etbeHi4206fPn3s3LlzIessXrzYKlSo4IZbFi5c2CZPnswngoDx48dbmTJl3N81LZUrV7a5c+dyHiJOGDFihPvf7B49egTu428jvDJ06FB3/gUvxYoV41xErPjzzz/t0Ucfdf8u1HeV0qVL26pVqxLXdxkNOge88NFHH/lSpEjhmzhxou+XX37xtW/f3pcxY0bf/v37+QBwxebMmeN76qmnfJ999pku2uCbOXNmyOMjRozwZciQwTdr1izf+vXrfQ0bNvQVLFjQ999//wXWufvuu31ly5b1/fTTT74lS5b4Chcu7HvkkUcCjx85csSXPXt2X/PmzX0bN270TZs2zZc6dWrfW2+9xSeHEHXr1vVNmjTJnSfr1q3z3XPPPb58+fL5jh8/HlinY8eOvrx58/oWLlzoW7Vqle+2227zValSJfD4uXPnfKVKlfLVrl3bt3btWneOZ82a1TdgwIDAOjt27PCFh4f7evbs6fv11199r732mi9ZsmS+efPm8YnA+fzzz31fffWVb8uWLb7Nmzf7Bg4c6EuePLk7NzkPEZtWrFjhK1CggK9MmTK+7t27B+7nbyO8MmTIEF/JkiV9+/btCyx///035yI8d+jQIV/+/Pl9rVu39i1fvtz9+27+/Pm+bdu2JarvMoRS8EylSpV8nTt3Dtw+f/68L1euXL7hw4fzKeCaiBhKXbhwwZcjRw7fSy+9FLjv8OHDvpQpU7o/xqIv9HreypUrA+vMnTvXlyRJEt+ff/7pbr/xxhu+TJky+U6fPh1Yp1+/fr6iRYvyySFaBw4ccOfXd999Fzj/FAzMmDEjsM6mTZvcOj/++KO7rRAqadKkvr/++iuwzvjx433p06cPnIN9+/Z1/6AO9vDDD7tQDIiK/o698847nIeINceOHfMVKVLEt2DBAl/16tUDoRR/G+F1KKUv8JHhXISX9H3i9ttvj/LxxPJdhvY9eOLMmTO2evVqV27olzRpUnf7xx9/5FPAdbFz507766+/Qs67DBkyuNZR/3mnnypzrVixYmAdra/zc/ny5YF17rjjDkuRIkVgnbp167q2rH///ZdPD1E6cuSI+5k5c2b3U38Hz549G3JOqmUgX758IeekSrezZ88ecr4dPXrUfvnll8A6wdvwr8PfU0Tm/Pnz9tFHH9mJEydcGx/nIWKLWpfVmhzx7xfnJLym9ieNfihUqJBre1LbPOcivPb555+77yAPPvigG9dQvnx5mzBhQqL7LkMoBU/8888/7h/FwV+yRLf1HxpwPfjPrejOO/3U/wgECwsLcyFC8DqRbSP4NYCILly44OalVK1a1UqVKhU4X/QPAv3jIbpz8lLnW1TrKLj677//+DDg/Pzzz25umeaOdezY0WbOnGklSpTgPESsUDC6Zs0aN3svIv42wkv6Qq85jPPmzXPz9/TFX7N2jh07xrkIT+3YscOdg0WKFLH58+fbE088Yd26dbMpU6Ykqu8yYbG9AwAAJNSKgI0bN9rSpUtje1eQSBUtWtTWrVvnKvY++eQTa9WqlX333XexvVtIhPbs2WPdu3e3BQsWuCG7QGyqV69e4HddEEIhVf78+W369OlukDTg5f8Ds2LFivbCCy+426qU0r8d33zzTfe/2YkFlVLwRNasWS1ZsmQXXWFKt3PkyMGngOvCf25Fd97p54EDB0Ie11XOdBWL4HUi20bwawDBunTpYl9++aV9++23lidPnpBzUu3Mhw8fjvacvNT5FtU6uuoK/6CGn6rydGXGm2++2VWnlC1b1saOHct5CM+pPU//W6srhur/g69FAemrr77qftf/x56/jYgtql6+6aabbNu2bfx9hKd0Rb0SJUqE3Fe8ePFAO2li+S5DKAXP/mGsfxQvXLgwJBnWbc23AK6HggULuj+0weed2pvUX+0/7/RTAYH+wey3aNEid37q/3PmX+f77793s4D89P/tVRVCpkyZ+PAQoHn7CqTUJqXzSOdgMP0dTJ48ecg5qX5+/eMj+JxU21XwPzB0vilw8v/DResEb8O/Dn9PER39XTt9+jTnITxXq1Yt93dNlXv+RdUBmuXj/52/jYgtx48ft+3bt7uAgP+dhpc04mHz5s0h923ZssVV7iWq7zKxPWkdicdHH33krhQwefJkd5WAxx9/3JcxY8aQK0wBV3Iln7Vr17pFf9Jefvll9/vvv/8euIyqzrPZs2f7NmzY4LvvvvsivYxq+fLl3aVYly5d6q4MFHwZVV3lQpdRbdGihbuMqs7l8PDwOHMZVcQdTzzxhLts7+LFi0MuNX3y5MmQy57ny5fPt2jRIt+qVat8lStXdovfuXPnfKVKlfLVqVPHt27dOt+8efN82bJl8w0YMCCwji4ZrHOwT58+7up9r7/+ui9ZsmRuXUD69+/vrvq4c+dO97dPt3Ulnq+//przEHFC8NX3hL+N8EqvXr3c/07r7+OyZct8tWvX9mXNmtVdMZdzEV5asWKFLywszPf888/7tm7d6vvggw/cv+/ef//9wDqJ4bsMoRQ89dprr7kvYylSpPBVqlTJ99NPP/EJ4Kp8++23LoyKuLRq1SpwKdXBgwe7P8QKRWvVquXbvHlzyDYOHjzo/nCnTZvWlz59el+bNm1c2BVs/fr17pKt2kbu3Lnd/0AAEUV2LmqZNGlSYB39I6JTp07u0rz6B0Hjxo1dcBVs165dvnr16vlSp07t/qGsf0CfPXv2onO/XLly7u9poUKFQl4DeOyxx3z58+d354dCTf3t8wdSnIeIi6EUfxvhlYcfftiXM2dO9/dR/6bT7W3btnEuIlZ88cUX7v8Zqe8YxYoV87399tshjyeG7zJJ9H9iu1oLAAAAAAAAiQszpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOA5QikAAABE6a+//rKuXbtaoUKFLGXKlJY3b15r0KCBLVy40NOjliRJEps1a5anrwkAAK6vsOu8fQAAAMRTu3btsqpVq1rGjBntpZdestKlS9vZs2dt/vz51rlzZ/vtt99iexcBAEA8lsTn8/lieycAAAAQ99xzzz22YcMG27x5s6VJkybkscOHD7uwavfu3a6SSpVTSZMmtbvvvttee+01y549u1uvdevWbt3gKqcePXrYunXrbPHixe52jRo1rEyZMpYqVSp75513LEWKFNaxY0cbOnSoe7xAgQL2+++/B56fP39+F5gBAID4jfY9AAAAXOTQoUM2b948VxEVMZASBVIXLlyw++67z6373Xff2YIFC2zHjh328MMPX/YRnTJlinud5cuX28iRI23YsGFue7Jy5Ur3c9KkSbZv377AbQAAEL/RvgcAAICLbNu2zVRQX6xYsSiPjqqjfv75Z9u5c6ebNSVTp061kiVLuuDolltuifGRVaXUkCFD3O9FihSxcePGue3fddddli1btkAQliNHDj4tAAASCCqlAAAAcJGYTHjYtGmTC6P8gZSUKFHChUd67HIolAqWM2dOO3DgAJ8MAAAJGKEUAAAALqJqJV3x7mqHmWvOVMSAS8PSI0qePHnIbb222gMBAEDCRSgFAACAi2TOnNnq1q1rr7/+up04ceKixzW8vHjx4rZnzx63+P3666/uMVVMiVrvNAcqmIacXy6FVufPn+eTAgAgASGUAgAAQKQUSCkIqlSpkn366ae2detW15b36quvWuXKla127dpWunRpa968ua1Zs8ZWrFhhLVu2tOrVq1vFihXdNmrWrGmrVq1ys6b0fM2N2rhx42UfcV2BTzOm/vrrL/v333/5xAAASAAIpQAAABCpQoUKubDpzjvvtF69elmpUqXc4HGFQ+PHj3ctdrNnz7ZMmTLZHXfc4UIqPefjjz8ObEPVVoMHD7a+ffu6wefHjh1zwdXlGj16tLsan+ZXlS9fnk8MAIAEIIkvJlMsAQAAAAAAgGuISikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAOA5QikAAAAAAAB4jlAKAAAAAAAAniOUAgAAAAAAgOcIpQAAAAAAAGBe+38Tpbs0/HCejgAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 15 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Triplets per Example Statistics" + ], + "id": "29467e89dc7d8ac8" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:23:59.868872Z", + "start_time": "2026-05-04T13:23:59.748568Z" + } + }, + "source": [ + "def triplets_per_example(examples):\n", + " counts = []\n", + " for ex in examples:\n", + " triplets = parse_completion_triplets(ex)\n", + " counts.append(len(triplets))\n", + " return counts\n", + "\n", + "train_tpe = triplets_per_example(train_data)\n", + "val_tpe = triplets_per_example(val_data)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 4))\n", + "axes[0].hist(train_tpe, bins=30, color='steelblue', edgecolor='white')\n", + "axes[0].set_title(f\"Train: Triplets per Example\\n(mean={np.mean(train_tpe):.1f}, median={np.median(train_tpe):.0f})\")\n", + "axes[0].set_xlabel(\"Triplets per example\")\n", + "axes[0].set_ylabel(\"Frequency\")\n", + "\n", + "axes[1].hist(val_tpe, bins=20, color='coral', edgecolor='white')\n", + "axes[1].set_title(f\"Val: Triplets per Example\\n(mean={np.mean(val_tpe):.1f}, median={np.median(val_tpe):.0f})\")\n", + "axes[1].set_xlabel(\"Triplets per example\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "print(f\"Train triplets/example: min={min(train_tpe)}, max={max(train_tpe)}, mean={np.mean(train_tpe):.1f}\")\n", + "print(f\"Val triplets/example: min={min(val_tpe)}, max={max(val_tpe)}, mean={np.mean(val_tpe):.1f}\")" + ], + "id": "d9cb0859a9a9b1f3", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train triplets/example: min=1, max=48, mean=11.2\n", + "Val triplets/example: min=2, max=48, mean=10.6\n" + ] + } + ], + "execution_count": 16 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Run Inference on Validation Set\n", + "\n", + "Load model and generate predictions for all validation examples." + ], + "id": "45c77c66e20ee28d" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:25:06.924202Z", + "start_time": "2026-05-04T13:24:33.290664Z" + } + }, + "source": [ + "import torch\n", + "from transformers import AutoTokenizer, AutoModelForCausalLM\n", + "from peft import PeftModel\n", + "\n", + "BASE_MODEL = \"HuggingFaceTB/SmolLM2-1.7B-Instruct\"\n", + "CHECKPOINT_DIR = \"./checkpoints/wikontic-full-pipeline\"\n", + "\n", + "print(\"Loading tokenizer...\")\n", + "tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)\n", + "tokenizer.pad_token = tokenizer.eos_token\n", + "\n", + "print(\"Loading base model...\")\n", + "base_model = AutoModelForCausalLM.from_pretrained(\n", + " BASE_MODEL,\n", + " torch_dtype=torch.bfloat16,\n", + " device_map=\"auto\",\n", + ")\n", + "\n", + "print(\"Loading LoRA adapter...\")\n", + "model = PeftModel.from_pretrained(base_model, CHECKPOINT_DIR)\n", + "model.eval()\n", + "\n", + "print(\"Model loaded.\")" + ], + "id": "4e17bc55a96bba0e", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\PycharmProjects\\Wikontic\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading tokenizer...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading base model...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "`torch_dtype` is deprecated! Use `dtype` instead!\n", + "Loading weights: 100%|██████████| 218/218 [00:03<00:00, 60.69it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading LoRA adapter...\n", + "Model loaded.\n" + ] + } + ], + "execution_count": 17 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:25:52.029557Z", + "start_time": "2026-05-04T13:25:52.026159Z" + } + }, + "cell_type": "code", + "source": "val_data[0]", + "id": "74d905c243edd65a", + "outputs": [ + { + "data": { + "text/plain": [ + "{'messages': [{'role': 'system',\n", + " 'content': 'You are an algorithm designed to extract structured knowledge from texts to build a Wikidata-like knowledge graph. A knowledge graph consists of **triplets** in the format (subject, relation, object), where:\\n\\n- **Subject**: A named entity or a concept that describes a group of people, events, or any abstract objects that serves as the source of the relation.\\n- **Relation**: A Wikidata-style predicate that connects the subject and object.\\n- **Object**: A named entity or a concept that describes a group of people, events, or any abstract objects that is related to the subject.\\n\\nAdditionally, some triplets may have **qualifiers** that provide more context (e.g., date, place, or other attributes). Qualifiers should have relations and object like triplets do, but instead of subject their relation connects an object and the triplet qualifier belongs to. **Qualifiers must always be attached to a triplet** and never exist as standalone triplets.\\n\\nYou will receive a text labeled **\"Text:\"**. Your task is to extract meaningful triplets that represent factual relationships.\\n\\n### Output Format\\nReturn only triplets in **JSON format** as a list of dictionaries, where each dictionary contains:\\n- \"subject\": Subject entity. \\n- \"relation\": Relation connecting subject and object. \\n- \"object\": Object entity. \\n- \"qualifiers\": List of dictionaries, where each dictionary contains:\\n - \"relation\": Relation connecting triplet and object,\\n - \"object\": Object entity connected to the main triplet\\n- \"subject_type\": a class that describes the subject \\n- \"object_type\": a class that describes the object \\n\\nNO additional text, NO \"```\" in json, ONLY triplets in JSON format.\\n\\n\\n\\n### Input: \\n Text: \"Marie Curie (7 November 1867 - 4 July 1934) was a physicist and chemist who conducted pioneering research on radioactivity. She received the Nobel Prize in Physics in 1903 and the Nobel Prize in Chemistry in 1911. \\n### Output: \\n {\\n \"triplets\":\\n [\\n {\\n \"subject\": \"Marie Curie\",\\n \"relation\": \"date of birth\",\\n \"object\": \"7 November 1867\",\\n \"qualifiers\": [],\\n \"subject_type\": \"human\",\\n \"object_type\": \"date\"\\n },\\n {\\n \"subject\": \"Marie Curie\",\\n \"relation\": \"date of death\",\\n \"object\": \"4 July 1934\",\\n \"qualifiers\": [],\\n \"subject_type\": \"human\",\\n \"object_type\": \"date\"\\n },\\n {\\n \"subject\": \"Marie Curie\",\\n \"relation\": \"occupation\",\\n \"object\": \"physicist\",\\n \"qualifiers\": [],\\n \"subject_type\": \"human\",\\n \"object_type\": \"profession\"\\n },\\n {\\n \"subject\": \"Marie Curie\",\\n \"relation\": \"occupation\",\\n \"object\": \"chemist\",\\n \"qualifiers\": [],\\n \"subject_type\": \"human\",\\n \"object_type\": \"profession\"\\n },\\n {\\n \"subject\": \"Marie Curie\",\\n \"relation\": \"field of work\",\\n \"object\": \"radioactivity\",\\n \"qualifiers\": [],\\n \"subject_type\": \"human\",\\n \"object_type\": \"physical phenomenon\"\\n },\\n {\\n \"subject\": \"Marie Curie\",\\n \"relation\": \"award received\",\\n \"object\": \"Nobel Prize in Physics\",\\n \"qualifiers\": [{\"relation\": \"point in time\", \"object\": \\'1903\\'}],\\n \"subject_type\": \"human\",\\n \"object_type\": \"award\"\\n },\\n {\\n \"subject\": \"Marie Curie\",\\n \"relation\": \"award received\",\\n \"object\": \"Nobel Prize in Chemistry\",\\n \"qualifiers\": [{\"relation\": \"point in time\", \"object\": \"1911\"}],\\n \"subject_type\": \"human\",\\n \"object_type\": \"award\"\\n }\\n ]\\n }\\n\\n'},\n", + " {'role': 'user',\n", + " 'content': 'Text: \"The 1991 Currie Cup (known as the \"Bankfin Currie Cup\" for sponsorship reasons) was the top division of the Currie Cup competition, the premier domestic rugby union competition in South Africa. This was the 53rd season since the competition started in 1889 and the first time it was known as the Bankfin Currie Cup, following the sponsors\\' name change from Santam Bank.\"'},\n", + " {'role': 'assistant',\n", + " 'content': '{\"triplets\": [{\"subject\": \"1991 Currie Cup\", \"object\": \"Currie Cup season\", \"subject_type\": \"sports season\", \"object_type\": \"sports season\", \"relation\": \"instance of\", \"qualifiers\": []}, {\"subject\": \"1991 Currie Cup\", \"object\": \"53\", \"subject_type\": \"sports season\", \"object_type\": \"positive integer\", \"relation\": \"quantity\", \"qualifiers\": []}, {\"subject\": \"1991 Currie Cup\", \"object\": \"Currie Cup\", \"subject_type\": \"sports season\", \"object_type\": \"sports competition\", \"relation\": \"part of\", \"qualifiers\": []}, {\"subject\": \"Currie Cup\", \"object\": \"South Africa\", \"subject_type\": \"sports competition\", \"object_type\": \"country\", \"relation\": \"country\", \"qualifiers\": []}, {\"subject\": \"Currie Cup\", \"object\": \"rugby union\", \"subject_type\": \"sports competition\", \"object_type\": \"sport\", \"relation\": \"sport\", \"qualifiers\": []}, {\"subject\": \"1991 Currie Cup\", \"object\": \"1991\", \"subject_type\": \"sports season\", \"object_type\": \"calendar year\", \"relation\": \"start time\", \"qualifiers\": []}, {\"subject\": \"Bankfin Currie Cup\", \"object\": \"Bankfin\", \"subject_type\": \"name\", \"object_type\": \"company\", \"relation\": \"sponsor\", \"qualifiers\": []}, {\"subject\": \"Bankfin\", \"object\": \"Santam Bank\", \"subject_type\": \"company\", \"object_type\": \"company\", \"relation\": \"replaces\", \"qualifiers\": []}, {\"subject\": \"Currie Cup\", \"object\": \"1889\", \"subject_type\": \"sports competition\", \"object_type\": \"calendar year\", \"relation\": \"inception\", \"qualifiers\": []}]}'}]}" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 19 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:26:43.160794Z", + "start_time": "2026-05-04T13:26:43.157391Z" + } + }, + "source": [ + "# Extract text from validation prompts for inference\n", + "def extract_text_from_prompt(prompt):\n", + " \"\"\"Extract the user text portion from a formatted prompt.\"\"\"\n", + " # Try to find the Text: \"...\" pattern\n", + " marker = 'Text: \"'\n", + " idx = prompt.find(marker)\n", + " if idx >= 0:\n", + " start = idx + len(marker)\n", + " # Find closing quote at end of line/content\n", + " end = prompt.find('\"', start)\n", + " if end >= 0:\n", + " return prompt[start:end]\n", + " # Fallback: return whole prompt\n", + " return prompt\n", + "\n", + "# Validation texts\n", + "val_texts = [extract_text_from_prompt(ex[\"messages\"][1][\"content\"]) for ex in val_data]\n", + "print(f\"Extracted {len(val_texts)} validation texts.\")\n", + "print(\"Example:\", val_texts[0][:200], \"...\")" + ], + "id": "cfd2b9a11a845b0b", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracted 199 validation texts.\n", + "Example: The 1991 Currie Cup (known as the ...\n" + ] + } + ], + "execution_count": 20 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T13:27:10.607974Z", + "start_time": "2026-05-04T13:27:10.577829Z" + } + }, + "source": [ + "def robust_extract_triplets(text):\n", + " \"\"\"Robust triplet extractor with multiple fallback strategies.\"\"\"\n", + " # Attempt 1: Clean trailing garbage and parse full JSON\n", + " cleaned = text.rstrip(\". \\n\\t\")\n", + " try:\n", + " data = json.loads(cleaned)\n", + " if isinstance(data, dict) and \"triplets\" in data:\n", + " return data\n", + " except (json.JSONDecodeError, TypeError):\n", + " pass\n", + "\n", + " # Attempt 2: Find JSON object with brace-depth matching\n", + " candidates = []\n", + " for i, ch in enumerate(text):\n", + " if ch == \"{\":\n", + " depth = 1\n", + " for j in range(i + 1, len(text)):\n", + " if text[j] == \"{\":\n", + " depth += 1\n", + " elif text[j] == \"}\":\n", + " depth -= 1\n", + " if depth == 0:\n", + " candidates.append(text[i:j+1])\n", + " break\n", + "\n", + " triplets = []\n", + " seen = set()\n", + " for candidate in candidates:\n", + " if '\"subject\"' not in candidate or '\"relation\"' not in candidate or '\"object\"' not in candidate:\n", + " continue\n", + " try:\n", + " obj = json.loads(candidate)\n", + " if isinstance(obj, dict) and all(k in obj for k in (\"subject\", \"relation\", \"object\")):\n", + " key = (obj.get(\"subject\"), obj.get(\"relation\"), obj.get(\"object\"))\n", + " if key not in seen:\n", + " seen.add(key)\n", + " triplets.append(obj)\n", + " except (json.JSONDecodeError, TypeError):\n", + " pass\n", + "\n", + " if triplets:\n", + " return {\"triplets\": triplets}\n", + "\n", + " return None\n", + "\n", + "def inference(text, max_new_tokens=2048):\n", + " messages = [\n", + " {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n", + " {\"role\": \"user\", \"content\": f'Text: \"{text}\"'},\n", + " ]\n", + " prompt = tokenizer.apply_chat_template(\n", + " messages,\n", + " tokenize=False,\n", + " add_generation_prompt=True\n", + " )\n", + " inputs = tokenizer(prompt, return_tensors=\"pt\").to(model.device)\n", + "\n", + " with torch.no_grad():\n", + " output = model.generate(\n", + " **inputs,\n", + " max_new_tokens=max_new_tokens,\n", + " temperature=0.0,\n", + " do_sample=False,\n", + " pad_token_id=tokenizer.pad_token_id,\n", + " eos_token_id=tokenizer.eos_token_id,\n", + " )\n", + "\n", + " full_output = tokenizer.decode(output[0], skip_special_tokens=False)\n", + "\n", + " # Extract assistant portion\n", + " marker = \"\\nassistant\\n\"\n", + " marker_pos = full_output.find(marker)\n", + " if marker_pos >= 0:\n", + " answer = full_output[marker_pos + len(marker):].strip()\n", + " else:\n", + " answer = full_output[len(prompt):].strip()\n", + "\n", + " # Strip trailing hallucinated turns\n", + " for turn_marker in [\"<|im_start|>user\", \"<|im_start|>system\", \"<|endoftext|>\", \"\"]:\n", + " pos = answer.find(turn_marker)\n", + " if pos >= 0:\n", + " answer = answer[:pos].strip()\n", + "\n", + " return answer\n", + "\n", + "# Load system prompt\n", + "SYSTEM_PROMPT_PATH = Path(\"../src/wikontic/utils/prompts/triplet_extraction/propmt_1_types_qualifiers.txt\")\n", + "SYSTEM_PROMPT = open(SYSTEM_PROMPT_PATH, encoding=\"utf-8\").read()\n", + "print(f\"System prompt loaded: {len(SYSTEM_PROMPT)} chars\")" + ], + "id": "6accbc96d4fd4844", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "System prompt loaded: 4034 chars\n" + ] + } + ], + "execution_count": 21 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T15:25:45.147285Z", + "start_time": "2026-05-04T13:27:19.841082Z" + } + }, + "source": [ + "# Run inference on validation set (this may take a while)\n", + "val_predictions = []\n", + "val_parsed = []\n", + "parse_successes = 0\n", + "empty_outputs = 0\n", + "\n", + "for i, text in enumerate(val_texts):\n", + " raw = inference(text)\n", + " parsed = robust_extract_triplets(raw)\n", + "\n", + " val_predictions.append({\n", + " \"text\": text,\n", + " \"raw_output\": raw,\n", + " \"parsed\": parsed,\n", + " })\n", + "\n", + " if parsed and \"triplets\" in parsed:\n", + " parse_successes += 1\n", + " if len(parsed[\"triplets\"]) == 0:\n", + " empty_outputs += 1\n", + " else:\n", + " val_parsed.append([])\n", + " continue\n", + "\n", + " val_parsed.append(parsed[\"triplets\"])\n", + "\n", + " if (i + 1) % 20 == 0:\n", + " print(f\" Processed {i+1}/{len(val_texts)}...\")\n", + "\n", + "print(f\"\\nDone!\")\n", + "print(f\"Parse success rate: {parse_successes}/{len(val_texts)} ({parse_successes/len(val_texts)*100:.1f}%)\")\n", + "print(f\"Empty outputs (parsed but zero triplets): {empty_outputs}\")" + ], + "id": "e214a23fc19c7691", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The following generation flags are not valid and may be ignored: ['temperature']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Processed 20/199...\n", + " Processed 40/199...\n", + " Processed 60/199...\n", + " Processed 80/199...\n", + " Processed 100/199...\n", + " Processed 120/199...\n", + " Processed 140/199...\n", + " Processed 160/199...\n", + " Processed 180/199...\n", + "\n", + "Done!\n", + "Parse success rate: 193/199 (97.0%)\n", + "Empty outputs (parsed but zero triplets): 0\n" + ] + } + ], + "execution_count": 22 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T17:07:56.130563Z", + "start_time": "2026-05-04T17:07:56.072080Z" + } + }, + "source": [ + "# Save predictions for later inspection\n", + "import pickle\n", + "\n", + "with open(\"./data/val_predictions.pkl\", \"wb\") as f:\n", + " pickle.dump(val_predictions, f)\n", + "\n", + "print(\"Saved predictions to ./data/val_predictions.pkl\")" + ], + "id": "81f21084990d625b", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved predictions to ./data/val_predictions.pkl\n" + ] + } + ], + "execution_count": 23 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. Model Output Statistics" + ], + "id": "189b19966117a826" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T17:08:01.541629Z", + "start_time": "2026-05-04T17:08:01.467241Z" + } + }, + "source": [ + "pred_triplets = []\n", + "for triplets in val_parsed:\n", + " pred_triplets.extend(triplets)\n", + "\n", + "pred_stats = compute_stats(pred_triplets, \"Model Predictions\")\n", + "\n", + "# Triplets per predicted example\n", + "pred_tpe = [len(t) for t in val_parsed]\n", + "print(f\"\\nPredictions triplets/example: min={min(pred_tpe)}, max={max(pred_tpe)}, mean={np.mean(pred_tpe):.1f}\")" + ], + "id": "dfa5f4a139888f09", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=== Model Predictions Statistics ===\n", + "Total triplets: 1033\n", + "Unique relations: 134\n", + "Unique subject types: 80\n", + "Unique object types: 180\n", + "Total qualifiers: 195\n", + "Unique qualifier relations: 7\n", + "\n", + "Top 15 relations:\n", + " instance of: 223 (21.6%)\n", + " occupation: 174 (16.8%)\n", + " award received: 78 (7.6%)\n", + " date of birth: 58 (5.6%)\n", + " date of death: 38 (3.7%)\n", + " field of work: 33 (3.2%)\n", + " located in: 29 (2.8%)\n", + " record label: 28 (2.7%)\n", + " is a part of: 27 (2.6%)\n", + " proximity: 21 (2.0%)\n", + " award: 17 (1.6%)\n", + " position: 14 (1.4%)\n", + " history: 10 (1.0%)\n", + " operates: 9 (0.9%)\n", + " film: 8 (0.8%)\n", + "\n", + "Top 10 subject types:\n", + " human: 436 (42.2%)\n", + " UNKNOWN: 61 (5.9%)\n", + " person: 49 (4.7%)\n", + " film: 41 (4.0%)\n", + " company: 34 (3.3%)\n", + " geographic_area: 28 (2.7%)\n", + " institution: 26 (2.5%)\n", + " railway: 23 (2.2%)\n", + " record label: 21 (2.0%)\n", + " building: 18 (1.7%)\n", + "\n", + "Top 5 qualifier relations:\n", + " point in time: 148 (75.9%)\n", + " instance of: 37 (19.0%)\n", + " record label: 3 (1.5%)\n", + " color: 3 (1.5%)\n", + " award: 2 (1.0%)\n", + "\n", + "Predictions triplets/example: min=0, max=27, mean=5.2\n" + ] + } + ], + "execution_count": 24 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T17:08:10.076591Z", + "start_time": "2026-05-04T17:08:09.412511Z" + } + }, + "source": [ + "plot_distribution(pred_stats[\"relation_counts\"], \"Predictions: Top 20 Relations\")\n", + "plot_distribution(pred_stats[\"subject_type_counts\"], \"Predictions: Subject Types\", top_n=15)\n", + "plot_distribution(pred_stats[\"object_type_counts\"], \"Predictions: Object Types\", top_n=15)\n", + "if pred_stats[\"qualifier_counts\"]:\n", + " plot_distribution(pred_stats[\"qualifier_counts\"], \"Predictions: Qualifier Relations\", top_n=10)" + ], + "id": "78224765ee9edd1a", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABKYAAAJOCAYAAACN2Q8zAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAh9ZJREFUeJzt3QmcjfX////XMBj7vu8kZF8iVISoSGgjWUokS4kQmezJrtKmBZUSn7K1TQhJkYjslbKVUvYl+/nfnu/v/5zfOWOGwYxrlsf9djvNnHOuc53rXOeazHnO6/W6wnw+n88AAAAAAACAqyzV1X5CAAAAAAAAQAimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAArpJixYpZhw4dAteXLFliYWFh7mt80foGDx5sydn27dvd6xw7duxFl9W+0LIAACBxIpgCAAApwtSpU11A4b9ERETYtddea927d7e///7bkpLPPvss2YVPx44ds2HDhlnFihUtQ4YMljVrVrvpppvsnXfeMZ/PZ0n9vYh+/MV2UXgJAEBKEu71BgAAAFxNQ4cOteLFi9uJEyfsm2++sVdffdWFCxs2bHCByNV0880323///Wdp06a9pMdpe19++eUYAxGtLzw8af2Kp2CwQYMGtnnzZmvVqpULC/X+fPTRR9a+fXv3eqdPn26pU6e+5HUPHDjQnn76aUsoF3ovor/X7777bshtjzzyiNWoUcM6d+4cuC1TpkwJtq0AACRGSeu3FgAAgCt0++23W/Xq1QPBQM6cOW38+PE2d+5ca926dazVPBkzZoz3fZ8qVSpXuRWf4nt9V4PCJ4VSs2fPtmbNmgVuf/zxx61Pnz6uZa9KlSrWr1+/S163QrrEENSVKFHCXYJ16dLF3fbggw96tl0AAHiNVj4AAJCi1a9f3339/fff3VfNgFLVyrZt2+yOO+6wzJkzW5s2bdx9586ds4kTJ1q5cuVcAJQ3b1579NFH7cCBAyHrVOvZ8OHDrVChQq4K65ZbbrGNGzee99yxzZhauXKle+7s2bO7QEztbS+88EJg+1ShI8EtYBeaMfXjjz+6QC5Llizutak6acWKFTG2mi1fvtx69epluXPnds/dokUL++eff0KW/eGHH6xx48aWK1cuS58+vatAe/jhh0OW2bNnj23ZssVOnz59wf2v7YiKinKvKziU8hs5cqSVKlXKRo0a5arBopswYYIVLVrUbUfdunVd5VtcZky99957Vq1aNfe4HDlyuEqtXbt2nbfclbwXl+Lo0aNu/U888cR59+3evdtVi2lfBL9XX3/9tTv+FK7qvW3Xrt15x6J8/vnnri1S69fx3KRJk/OOx7/++sseeughd8ymS5fO8ufPb3fddZeb5wUAQELy/s9HAAAAHlIAJfpw73fmzBkXvNx4442uWsff4qcQQKGAPsCrmkdh1qRJk1zwo0AnTZo0brlnn33WBVMKNHRZs2aNNWrUyE6dOnXR7VmwYIE1bdrUBQMKKfLly+eqiT755BN3Xdvw559/uuWit4bFRAGEQgkFF3379nXb+Prrr1u9evVs6dKlVrNmzZDle/To4UKYQYMGuVBCQZxa6z788EN3/969e91rUXClFrls2bK55T7++OOQ9fTv39+mTZvm9tGF5ibNnz/ffVWoEhNVOz3wwAM2ZMgQt48bNmwYuE/zp44cOWLdunVzrX8KjBQ0rl+/3oWGsRkxYoRFRkbafffd56rmFLy99NJLrt1O76VeU0K8FxeiwFAhoPazKviC2xY/+OADF3b6A1I/vS/aVoVvW7dudW2pO3bsCASeou1SRZqOZ4V7x48fd8vp2NZr9b83d999tztW9P7rNr3Pel07d+5k7hUAIGH5AAAAUoApU6ZogrZv4cKFvn/++ce3a9cu34wZM3w5c+b0pU+f3rd79263XPv27d1yTz/9dMjjly1b5m6fPn16yO1ffPFFyO179+71pU2b1tekSRPfuXPnAssNGDDALaf1+y1evNjdpq9y5swZX/HixX1Fixb1HThwIOR5gtfVrVs397iY6PZBgwYFrjdv3txtz7Zt2wK3/fnnn77MmTP7br755vP2T8OGDUOe68knn/SlTp3ad/DgQXd99uzZbrlVq1ZdcH/79+Pvv/9+weW0fVou+usN9vHHH7tlXnzxRXdd69T14PdNVq5c6W7XNvtpXwTvq+3bt7vXM2LEiJDnWL9+vS88PDxwe3y8FxeTMWPGkOMhKirKrevzzz8PWa5ixYq+unXrnvdeVatWzXfq1KnA7aNHj3a3z507110/cuSIL1u2bL5OnTqFrO+vv/7yZc2aNXC7Xp8eN2bMmMt6HQAAXAla+QAAQIqiihtV+xQuXNi1b6lSRbONChYsGLLcY489FnJ91qxZ7kxxt956q/3777+Bi9rBtI7Fixe75RYuXOgqo1R5EtzW1bNnz4tumypYVGGkZf1VO36X0yJ29uxZ+/LLL6158+Yh841UAaQqJA1/P3z4cMhjNIg7+LlUbaX1qBJH/NulqqELtempskw52cXOMqeKJ1GLWWz890XfVr2u4PdNg8RVAaaB5LFRZZdaMlUtFfw+qhpKLYP+9zG+34u4HpsFChRwg9791Jr4008/xTiHSu+Vv0rPf8yqwsz/+lXxdPDgQTc7Lfi1qhpL+8n/WtXOqAH8qrSKqRUQAICERCsfAABIUTQT6Nprr3Uf4NXuVbp0aTeEPJju06ydYL/88osdOnTI8uTJE+N61fok/gBHIUcwhWFqkYtLW2H58uUtPqhFTa1beo3RlS1b1gU0mqukmVl+RYoUCVnOv83+wEJznNT2pdY6zXdSS6ACIgVdmk10qfyhkwKq6AHQxcKr6PtY9N7OnDkz1ufT+6jALKbHij/oie/3Ii50HKpdT612et/UQqqQSvPM7r333vOWj/4aFJAqdPTPhdJrDZ6jFp3aO0Xvm9r8evfu7X4mbrjhBtfCqPZKBXYAACQkgikAAJCiqKrGf1a+2OiDevSwSiGOQqngapbowVNyEDzbKNj/dQn+X7XQ//73Pze0XPOhNLhcg8/HjRvnblM4cikUkM2ZM8dVBWnGU0x0n1x33XV2pfQ+6jVoIHhMr/VStz++KQwaM2aM2yeqdHr//fddSKRqvct5rf45UzEFTMFnK1Rl2J133umeV++pZnBp2PpXX33lzogIAEBCIZgCAACIg5IlS7o2vTp16rjWp9joDHH+apXg9jlVL12sTUrP4W/fCh7yHV1cW8kUlqnqRoOxo9MZ8xS+qaXxcqiqRhcNEld4okqfGTNmuGHil0KhiwIQDTKPKZhSG6HWr8ot7ftg/oqgYD///PMF2we1jxWy6UyCqq660HLx+V7ElSq0FAQpAFXVnoaPazB7TPT6dcbH4DP76WyIGrgf/BoUqF7oNfhpeVVN6aJ1V65c2QWOOoMhAAAJhRlTAAAAcaCZRApJhg0bdt59OoufZvmIAgC1gylM8FcZic5udzFVq1Z1gYmW9a/PL3hdGTNmdF+jLxOdKoJ0Br25c+cG2rvk77//dmGPzszmb+eKK4VrwdsiCjDk5MmTgdsUkCj8utAcKqldu7bbZ1OmTHFzq6J75plnXNikMwpGDwRV3fPHH38Ern///fe2cuVKu/3222N9vpYtW7r9olbE6K9D1/ft25cg78WlaNu2rZsNpufW2SJjez2TJ08O2b9qAdSx6F9eZ+LT+/vcc8/F+D4oLBW1DeqshtFDKrVOBr+nAAAkBCqmAAAA4kCzlR599FFX3bN27VoX+CiAUmWJBqO/8MILds8997gqpaeeesotp2ogVa9okLZax3LlynXB51AFk8IFtVQp7HnooYfczCAFPBs3bnQtVqKB6/L444+78EFBiwa5x2T48OFuCLZCqK5du7r2rddff90FDqNHj77k937atGn2yiuvWIsWLVx4oflPb7zxhgtA/JU60r9/f7esBohfbAC6qqUaNGhgd911l5tVpYHr2j4NKtdA7vvvv9/69Olz3uOuueYa97o09FvL+4MchVix0TZrn2j7FNZpPpYCGG2nhuBroLjev4R4L+JK+0CvQduj1xY84DyYhuxrvyk0VVWc3hftj2bNmrn79Z7oNSjoUtCm7dLxqSqsTz/91FWgTZo0yQV//vWoXVLHiJ5bAeaVvhYAAC7qis7pBwAAkERMmTJFZS6+VatWXXC59u3b+zJmzBjr/ZMnT/ZVq1bNlz59el/mzJl9FSpU8PXt29f3559/BpY5e/asb8iQIb78+fO75erVq+fbsGGDr2jRom79fosXL3bbpK/BvvnmG9+tt97q1q9tqVixou+ll14K3H/mzBlfjx49fLlz5/aFhYW5dfjp+0GDBoWsb82aNb7GjRv7MmXK5MuQIYPvlltu8X377bdx2j/Rt1Hrat26ta9IkSK+dOnS+fLkyeNr2rSp74cffjhvP+pxv//+uy8ujhw54hs8eLCvXLlygX1bp04d39SpU33nzp0LWVbr1LrHjBnjGzdunK9w4cJuW2666SbfunXrQpbVvojpV96PPvrId+ONN7r9q0uZMmV83bp1823dujXe3ouL0fqCj4dgd9xxh1tX9Pcp+L1aunSpr3Pnzr7s2bO797ZNmza+ffv2nbe83ju9/1mzZvVFRET4SpYs6evQoUPgPfv333/da9c+0DZpuZo1a/pmzpwZ59cCAMDlCtN/Lh5fAQAAAEmPf4i3WtySElWkrV+/3n799dfz7ps6daqr4Fq1atVFB/kDAJDYMWMKAAAAyZZmXV2shTIxbrNa7dSCBwBAcseMKQAAACQ7v/32m5uTpPlfmvWVFGjO1fLly+3NN990c6U00wwAgOSOiikAAAAkO19//bU7856G1o8fP96SgqVLl7oqKQVUGhyfL18+rzcJAIAEx4wpAAAAAAAAeIKKKQAAAAAAAHiCYAoAAAAAAACeYPg5koxz587Zn3/+aZkzZ7awsDCvNwcAAAAAAMTA5/PZkSNHrECBApYq1YVrogimkGQolCpcuLDXmwEAAAAAAOJg165dVqhQoQsuQzCFJEOVUv4DO0uWLF5vDgAAAAAAiMHhw4ddYYn/c/yFEEwhyfC37ymUIpgCAAAAACBxi8sYHoafAwAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAAT4R787TA5WsxKsrCIzKwCwEAAAAAyVZUZBNLCaiYAgAAAAAAgCcIpgAAAAAAAOAJgikAAAAAAAB4gmAKAAAAAAAAniCYAgAAAAAAgCcIpgAAAAAAAOAJgqlk4vjx43b33XdblixZLCwszA4ePJhgz7V9+3b3HGvXrk2w5wAAAAAAALGbNGmSVa9e3dKlS2fNmzePcZm///7bcuTIYZUrVw7ctmzZMsuUKVPIJVWqVPb444+bF8I9eVbEu2nTprmD69tvv7VcuXJZ1qxZE2wvFy5c2Pbs2eOeBwAAAAAAXH0FChSwgQMH2sKFC2337t0xLtO9e3erUqWK7du3L3DbTTfdZEePHg0JrwoVKmStWrUyL1AxlcidOnUqTstt27bNypYta+XLl7d8+fK5iqaEkjp1avcc4eHkmgAAAAAAeKFly5auUiq2opG5c+fa/v37rW3bthctdClVqpTVrl3bvEAwdZXVq1fPJZa6qKpJB1BkZKT5fD53f7FixWzYsGHWrl0715bXuXNnd/tHH31k5cqVcyV6WmbcuHEh69T1r7/+2gVSui4nT560p556ygoWLGgZM2a0mjVr2pIlSwKP27Fjh915552WPXt2d7/W/9lnn7n7Dhw4YG3atLHcuXNb+vTp3UE6ZcqUWFv5li5dajVq1HDblz9/fnv66aftzJkzIduossC+ffu6MkIFW4MHD07w/Q0AAAAAQEpz6NAh69Wrl7322msXXfbtt9+2jh07mlcIpjygNFLVRt9//7298MILNn78eHvzzTcD948dO9YqVapkP/74owutVq9ebffdd58rq1u/fr0LdHT71KlT3fIff/yxderUyWrVquVa7HRdFH599913NmPGDPvpp5/s3nvvtdtuu81++eUXd3+3bt1ceKVAS+sdNWqU6y0VrX/Tpk32+eef2+bNm+3VV1+NNYX9448/7I477rDrr7/e1q1b55Z96623bPjw4ee9bgVgK1eutNGjR9vQoUNtwYIFCbafAQAAAABIifr27WsdOnRwRSYXopFAv/32myuO8Qq9WB7QjKYJEya4qqPSpUu7UEjXFS5J/fr1rXfv3oHlVbnUoEEDFxbJtdde60KjMWPGuANNFUgZMmSwtGnTukok2blzp6tw0lf1nYqqp7744gt3+3PPPefu08D0ChUquPtLlCgReE7dpz5UDVITVWnF5pVXXnGvSYPX9JrKlCljf/75p/Xr18+effZZN0RNKlasaIMGDXLf64dDyy9atMhuvfXWGNer0EwXv8OHD1/2PgcAAAAAICVYtmyZLV++3NasWXPRZVVU0qxZM9ct5RUqpjxwww03hMyAUqWTqpjOnj3rrvvDID9VLNWpUyfkNl0Pfkx0Crt0n0Ks4En7arnTPCpRa52qmrQuBUaqqvJ77LHHXKWVJvcradVQ9dho+/Qagl+T1qlhasED2BRMBVPL3969e2Nd78iRI127o/+i8AsAAAAAAMROBSCqglKRijqfevToYRs2bHDfq8squPhj1qxZ9sgjj5iXCKYSIbW7XSmFQhpSrjZAzYLyXxQiqX1QdPDpYNUgNAVZCsReeukld9/tt9/uZlA9+eSTrvpJFVuquLoSadKkCbmuIOvcuXOxLt+/f3/XF+u/7Nq164qeHwAAAACA5OLMmTN24sQJ91WfrfW9TqCm2VI///xzIAfQGB11a+n7PHnyBB7/wQcfWM6cOa1Ro0aevg5a+TygGUvBVqxY4VrbFCTFRGfbUxleMF1XNVRsj1EbniqmVJGkU0HGRlVIXbp0cRcFQW+88YZLU0WlfO3bt3cXraNPnz5u/lVM26fh7Brg7q+a0vZlzpzZnXLycmmQui4AAAAAACCUOqCGDBkSuK4Tl9WtW9ed9EwnU/PTCc9UKBL987na+B566KHA+B2vUDHlAc1vUoK5detWl1CqSumJJ56IdXnNm1Ipns7Wp9RTQ8Q1n+lCFUwKrTSbSgPMNAz9999/d8PW1R736aefumV69uxpUVFR7j71ni5evNiFTKLZUDq15K+//mobN260Tz75JHBfdF27dnXVTAq0tmzZ4h6n1kC9Rq8PcAAAAAAAkqPBgwe7ApHgi0Kp6DSbWtVS0SkjCA62vELFlAcUFv33339Wo0YNV/GkUKpz586xLl+1alWbOXOmC4sUTmk2k0rxdHBdiIacK0FVsKUz56mfVPOtmjZt6u5XRZXOzKc5UEpTdcY+DWEXDVJXBdX27dtd6qqKKc2ciknBggXts88+cxVVOpughrHrVJMDBw68ov0EAAAAAACStzCfIjVcNfXq1XMDxSdOnMhev0QazKYh6PUHzLTwiAzsPwAAAABAshUV2cSS+ud3zYsObiuMCX1WAAAAAAAA8ATBFAAAAAAAADzBjKmrLKZBZAAAAAAAACkRFVMAAAAAAADwBMEUAAAAAAAAPEEwBQAAAAAAAE8wYwpJzux+jS96ukkAAAAAAJD4UTEFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAAT3BWPiQ5LUZFWXhEBq83AwAAAEh2oiKbeL0JAFIYKqYAAAAAAADgCYIpAAAAAAAAeIJgCgAAAAAAAJ4gmAIAAAAAAIAnCKYAAAAAAADgCYIpAAAAAAAAeIJgCnFSr14969mzJ3sLAAAASKEmTZpk1atXt3Tp0lnz5s1D7ouMjLQKFSpYeHj4eZ8bfv75Z2vRooXly5fPsmXLZnXq1LHly5df5a0HkFgRTCHeLVmyxMLCwuzgwYPsXQAAACCZKFCggA0cONA6dep03n3XXHONjR492po1a3beffpccPvtt9v69ett37591qFDB7vjjjvs33//vUpbDiAxI5gCAAAAAFxUy5YtXaVUrly5zruvffv2LnzKkiXLeffVqFHDOnfubLlz57bUqVO7YEtff/rpJ/Y6AIIpnO/YsWPWrl07y5Qpk+XPn9/GjRsXcv+7777rSngzZ87synEfeOAB27t3r7tv+/btdsstt7jvs2fP7iqn9BcROXfunI0cOdKKFy9u6dOnt0qVKtn//vc/3gIAAAAgBVHl1JEjR+y6667zelMAJAJUTOE8ffr0saVLl9rcuXPtyy+/dK15a9asCdx/+vRpGzZsmK1bt87mzJnjwih/+FS4cGH76KOP3Pdbt261PXv22AsvvOCuK5R655137LXXXrONGzfak08+aQ8++KB7LgAAAADJn9r6WrVqZQMGDHB/5AaAcHYBgh09etTeeuste++996xBgwbutmnTplmhQoUCyzz88MOB70uUKGEvvviiXX/99e6xqrLKkSOHuy9PnjxuuKGcPHnSnnvuOVu4cKHVqlUr8NhvvvnGXn/9datbt+55b4Qeo4vf4cOHebMAAACAJOrQoUPWuHFju/HGG23w4MFebw6ARIJgCiG2bdtmp06dspo1awZuU9BUunTpwPXVq1e7f0hUMXXgwAHXoic7d+6MtRz3119/tePHj9utt94acrueq0qVKjE+RhVWQ4YM4R0CAAAAkkkoVa5cOddBoZEfACAEU7jk+VP6B0WX6dOnuwGGCqR0XSFTbFRNJZ9++qkVLFgw5D6dbjYm/fv3t169eoVUTKlVEAAAAMDVd+bMmcBFf5w+ceKEpUqVytKmTevGfZw9ezZw0X0acJ4mTRr3e/xtt91m1157rb355puEUgBCMGMKIUqWLOn+8Vi5cmXgNlVF/fzzz+77LVu2uFO8Pv/883bTTTdZmTJlAoPP/fQPk+gfJD9VUimAUoilU8kGX2ILm7S8zuoRfAEAAADgjeHDh7uTGI0YMcLmz5/vvm/UqJG7T2fa03WNBJk0aZL7XrfJ7NmzbcWKFW4WrX6n1/gPXfSHbgCgYgoh9A9Ex44d3QD0nDlzujlRzzzzjPtLiBQpUsQFTy+99JJ16dLFNmzY4AahBytatKj7K8gnn3xid9xxh/tHSWfwe+qpp9zAc/11RX3lKuddvny5+8dJp5cFAAAAkHhpnEdss6GmTp3qLjHR7/r8vg8gNlRM4Txjxoxx1VB33nmnNWzY0IVI1apVc/epdU//4MyaNctVQalyauzYsSGPV6ueZkM9/fTTljdvXuvevbu7XQFWZGSkmx1VtmxZV86r1r7ixYvzLgAAAAAAkAKF+Xw+n9cbAcSFetOzZs1q9QfMtPCIDOw0AAAAIJ5FRTZhnwKIt8/v6pS62FgeKqYAAAAAAADgCYIpAAAAAAAAeIJgCgAAAAAAAJ4gmAIAAAAAAIAnCKYAAAAAAADgCYIpAAAAAAAAeCLcm6cFLt/sfo0verpJAAAAAACQ+FExBQAAAAAAAE8QTAEAAAAAAMATBFMAAAAAAADwBMEUAAAAAAAAPEEwBQAAAAAAAE9wVj4kOS1GRVl4RAavNwMAAADxKCqyCfsTAFIgKqYAAAAAAADgCYIpAAAAAAAAeIJgCgAAAAAAAJ4gmAIAAAAAAIAnCKYAAAAAAADgCYIpAAAAAAAAeIJgCp7q0KGDNW/enHcBAAAAF7Rt2za7/fbbLXv27FawYEEbPXq0u33nzp2WKVOmkEt4eLg1a9aMPQoASUC41xsAAAAAABdy9uxZFzTpD5rz5s2z3377zW699VYrVKiQPfDAA3b06NHAsqdOnbICBQpYq1at2KkAkARQMYWr4vTp0+xpAAAAXJatW7e6y6BBgyxNmjRWunRp69ixo02ePPm8ZefMmWPnzp2zli1bsrcBIAkgmEohvvjiC7vxxhstW7ZsljNnTmvatKkrh5Z77rnHunfvHli2Z8+eFhYWZlu2bAn81Sljxoy2cOHCi65Ltm/f7h7/4YcfWt26dS0iIsKmT5/u/tLVq1evwOP69u1rPp/vqu8LAAAAJC0KmiT4d0fd9tNPP5237FtvvWVt2rRxv4MCABI/gqkU4tixYy4U+uGHH2zRokWWKlUqa9GihfsHXeHRkiVLAssuXbrUcuXKFbht1apVruKpdu3aF11XsKefftqeeOIJ27x5szVu3NjGjRtnU6dOtbffftu++eYb279/v82ePfsq7wkAAAAkNaqQKlasmD377LN28uRJ27hxo/ud8vDhwyHL7dixw/0x9ZFHHvFsWwEAlybMR8lKivTvv/9a7ty5bf369e4vT5UqVbK///7bDYrMly+fRUZG2oYNG2zGjBk2YsQI++yzz2z58uUXXVf58uVdxVTx4sVt4sSJLpjyU6//k08+aX369HHXz5w545arVq2aK7mOTr906OKnXzwKFy5s9QfMtPCIDAmyXwAAAOCNqMgmF7xfYZR+l1yzZo2bLaWZU6+//rr7HdZv8ODB9sknn7g/oAIAvKPP71mzZrVDhw5ZlixZLrgsFVMpxC+//GKtW7e2EiVKuINCf3Hyn8VEYVKOHDlcpdSyZcusSpUqrj1P10Vf69WrF6d1BatevXrgex2Me/bssZo1awZuUwgWvEx0I0eOdAey/6JQCgAAAClTuXLl7Msvv3R/FF27dq37A6Yq//1UvT9lyhSqpQAgieGsfCnEnXfeaUWLFrU33njDVS7pH24FUpofpXlQN998s2vdS5cunQuhKlas6P6xV9XUt99+a0899VSc1hVMc6muRP/+/V3LYPSKKQAAAKQ8midVsmRJN/xcVVFq5dNYCb8FCxa40Ep/QAUAJB1UTKUA+/btc2cxGThwoDVo0MDKli1rBw4cCFnGP2dKFwVTmhulsGrMmDEuoKpTp06c1xUTVTzlz5/fVq5cGbhNrXyrV6+O9TEKyVSRFXwBAABAyjRz5kwrUqSIZc+e3caOHetGQeiPqcFDz3VSH/3eCQBIOqiYSgH0j7fOgqfT6SocUsudBpMHUxilnv20adO6M+75b1Ol1PXXXx+oforLumKjeVPPP/+8lSpVysqUKWPjx4+3gwcPJsArBgAAQHIzfPhwd7lQcAUASHqomEoBVP2kIeaqTlLLnQIoVUIFq1ChgmXLls0qV65smTJlCgRTZ8+eDZkvFZd1xaZ3797Wtm1ba9++vdWqVcsyZ87szuYHAAAAAABSJs7KhyQ31Z+z8gEAAKS8s/IBAJIOzsoHAAAAAACARI9WPgAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHgi3JunBS7f7H6NLUuWLOxCAAAAAACSOCqmAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AnOyockp8WoKAuPyOD1ZgAAkoioyCZebwIAAABiQcUUAAAAAAAAPEEwBQAAAAAAAE8QTAEAAAAAAMATBFMAAAAAAADwBMEUAAAAAAAAPEEwBQAAAAAAAE8QTAEAgBRv3rx5VrlyZcuYMaMVKFDAXnvtNbdPIiMjrUKFChYeHm49e/ZM8fsJAAAgvhFMXQX16tWL8ZfZqVOnWrZs2dz3gwcPtrCwMOvSpUvIMmvXrnW3b9++3V3XV13X7X5HjhyxW265xa677jrbvXt3YJk8efK4+4Lpl249V7CNGzfafffdZ7lz57Z06dLZtddea88++6wdP348sEyrVq3stttuC3ncF1984Z4n+vp0vUiRIiHbG9dtAQDgatO/Z127drWJEyfa4cOH3b+L+rdbrrnmGhs9erQ1a9aMNwYAACABEEwlIhEREfbWW2/ZL7/8EufH/PPPPy6UOnbsmC1btswKFSoUuE9B0NixYy/4+BUrVljNmjXt1KlT9umnn9rPP/9sI0aMcKHZrbfe6m4XPcfy5cvtzJkzgccuXrzYChcubEuWLAlZp27X8sHisi0AAHhBVVH6g4zCqNSpU1v27NmtTJky7r727dvb7bffblmyZOHNAQAASAAEU4lI6dKlXaDzzDPPxGn5Xbt22U033WRZs2a1r776ynLmzBlyf48ePWz8+PG2d+/eGB/v8/msY8eOVrZsWfv444+tRo0aVrRoUbv33ntt/vz59t1339mECRPcstquo0eP2g8//BB4vAKpp59+2lauXGknTpxwt+mrrkcPpi62LQAAeEF/2Fm9erX98ccfrmI4X7587t/BPXv28IYAAABcBQRTiczzzz9vH330UUgAFJOtW7danTp1XPveZ599ZpkyZTpvmdatW7sWhKFDh8a4DrUDbtq0yXr16mWpUoUeCpUqVbKGDRvaBx984K7rl3XN3FA1lL8Cas2aNe6X92LFirkQS7799ls7efLkecHUxbYFAAAvHDhwwP2hZs6cObZgwQL79ddfXVv7gw8+yBsCAABwFRBMJTJVq1Z185769et3weXatWvngp5Zs2a5X6BjotlOCromT55s27ZtO+9+te2JKqZiotv9y4jCJn/bntoGFVZpLtXNN98cuF1fixcv7iqvLmVbYqKAS7M+gi8AAMQn/x92Hn/8cfdvl64PGTLE/SFG1VQAAABIWARTidDw4cNd8PPll1/GuoyGsGoZteBdSOPGje3GG2908zNio78Ux4Vmb2jO1OnTp10A5R8MW7du3ZBgKnq11KVsS7CRI0e6NkX/RfOsAACITzoJif+EHZf77yMAAAAuH8HUVaCBqYcOHTrv9oMHD7rAJbqSJUtap06d3Pym2H4p1hwqDWp94IEHbObMmRd8flUqffjhh/bjjz+G3K6KJ9m8eXOMj9Pt/mXEP2R91apV7i/JCqREXzVXav/+/e5r/fr1L3lbYtK/f3+33/wXzdQCACC+de7c2V566SU3Z+q///5zbecNGjRw1VP6Y4zmJ549e9Zd9L1uAwAAQPwgmLpKQ801jyk63RYc/ART6KQ2uhkzZsS6XlUeDR482Nq0aePCnthoqHnLli1d0BWscuXK7qxDGnB+7ty5kPvWrVtnCxcudLOhggMzVS3NmzfPzafyB1MFCxZ0l3Hjxrmz+MVWMXWhbYmJWhQV6gVfAACIb/o3SUGU5ivq37njx4/bu+++6+7TH4rSp09v7733nk2aNMl9r9sAAAAQP8LjaT24gMcee8z9Mqv5FY888ogLXD799FM3WFxnv4tJ3rx53VDyMWPGXHDfqnJKp7ZWOKVwKThICjZixAgrV66chYeHh8x9euutt+zWW2+1u+++21Uo6WxEqnrq3bu31apVy3r27BmyHoVOr7zyiptvpW30U0ilvzb7h6RfSEzbAgCAV/TvqP64okt0U6dOdRcAAAAkDCqmroISJUrY119/bVu2bHFnuqtZs6Zrv9Pg8ttuuy3Wxz311FMxnm0vpr/0Pvfcc9a2bVt7//33Y1xGgdHDDz/sWhCC1a5d21asWOF+Kb/99ttd4KSAqn379u7sRNEHqyuY0hn5/POlgoMp3X6haqmLbQsAAAAAAEhZwnxM9kQSobPyaSZX/QEzLTwig9ebAwBIIqIim3i9CQAAACny8/uhQ4cuOpaHiikAAAAAAAB4gmAKAAAAAAAAniCYAgAAAAAAgCcIpgAAAAAAAOAJgikAAAAAAAB4gmAKAAAAAAAAngj35mmByze7X+OLnm4SAAAAAAAkflRMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBOclQ9JTotRURYekcHrzQAStajIJl5vAgAAAABcFBVTAAAAAAAA8ATBFAAAAAAAADxBMAUAAAAAAABPEEwBAAAAAADAEwRTAAAAAAAA8ATBFAAAAAAAADxBMAUAKVCPHj2scOHCliVLFitYsKD17NnTTp065e6LjIy0ChUqWHh4uLsdAAAAABIKwRQApEBdu3a1LVu22OHDh23dunXuMnr0aHffNddc475v1qyZ15sJAAAAIJkL93oDkPypCiNt2rRebwaAIGXLlg187/P5LFWqVPbLL7+46+3bt3dfP/zwQ/YZAAAAgARFxVQKc+TIEWvTpo1lzJjR8ufPbxMmTLB69eoF2nVOnjxpTz31lGvt0TI1a9a0JUuWBB4/depUy5Ytm0VFRbkPtpkyZbLbbrvN9uzZE1imQ4cO1rx5cxsxYoQVKFDASpcu7W7ftWuX3Xfffe7xOXLksLvuusu2b9/uwV4AIM8//7z7Gc6TJ4+rmFJ7HwAAAABcTQRTKUyvXr1s+fLlNm/ePFuwYIEtW7bM1qxZE7i/e/fu9t1339mMGTPsp59+snvvvdcFT/5KCjl+/LiNHTvW3n33Xfv6669t586dLswKtmjRItu6dat7jk8++cROnz5tjRs3tsyZM7vn1Db4Qy3/XBsAV9fTTz9tR48etU2bNlmXLl0sX758vAUAAAAAripa+VJYtdS0adPs/ffftwYNGrjbpkyZ4qqaRAGTruur/zYFTl988YW7/bnnnnO3KWR67bXXrGTJkoEwa+jQoSHPpWqrN998M9DC995779m5c+fcbWFhYYHnVvWUKrIaNWp03vaqeksXP83CARD/VP1YqVIlV+24cOFCdjEAAACAq4ZgKgX57bffXKhUo0aNwG1Zs2YNtNqtX7/ezp49a9dee23I4xQO5cyZM3A9Q4YMgVBK1BK4d+/ekMfojF7Bc6XUJvTrr7+6iqlgJ06csG3btsW4vSNHjrQhQ4Zc9usFEHf6f0NwZSQAAAAAXA0EUwhQS0/q1Klt9erV7mswtd35pUmTJuQ+VUBpeHL0iqno665WrZpNnz79vD2eO3fuGN+F/v37u9bD4Iopnd4ewJXRz+OsWbOsRYsWLpzesGGDDR8+3LXb+kMqhdT+iwJk/T8h+s8+AAAAAFwpgqkUpESJEu6D5apVq6xIkSLutkOHDtnPP/9sN998s1WpUsV9CFX100033RSvz121alV3hi8NWc6SJUucHpMuXTp3ARC/FCarpVetuqqI1M/l3XffHahQ7NSpk2v79Zs0aZI7U59OfgAAAAAA8YlgKgVRG50+XPbp08edFU8fRgcNGuROE68Pqmrh0xn72rVrZ+PGjXNB1T///OMGmVesWNGaNGly2c+t9Y4ZM8adiU/zqAoVKmQ7duywjz/+2Pr27euuA7g6VNGoExPERgEUIRQAAACAq4Gz8qUw48ePt1q1alnTpk2tYcOGVqdOHTf4OCIiIjCQXMFU79693eyp5s2bh1RYXS7NpdIZ/LSeli1buufs2LGjaxGKawUVAAAAAABIXsJ80YcDIUU5duyYFSxY0FVIKShKzDRjSvNw6g+YaeERGbzeHCBRi4q8/ApHAAAAAIiPz+8aH3SxYhRa+VKYH3/80bZs2eLOzKcDRG11ohY7AAAAAACAq4lgKgUaO3asbd261dKmTevOlLds2TLLlSuX15sFAAAAAABSGIKpFEYDzVevXu31ZgAAAAAAADD8HAAAAAAAAN7grHwAAAAAAADwBMEUAAAAAAAAPMGMKSQ5s/s1vujpJgEAAAAAQOJHxRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8wVn5kOS0GBVl4REZvN4M4KqJimzC3gYAAACQLFExBQAAAAAAAE8QTAEAAAAAAMATBFMAAAAAAADwBMEUAAAAAAAAPEEwBQAAAAAAAE8QTAEAAAAAAMATBFMeqVevnvXs2TPB1j948GCrXLlygq2/WLFiNnHixARbP4C4OXnypHXq1MmKFy9umTNntjJlytjbb78duH/16tV24403WpYsWaxEiRL2zjvvsGsBAAAAJBoEUx75+OOPbdiwYfGyrrCwMJszZ07IbU899ZQtWrQocL1Dhw7WvHnzS1731KlTLVu2bOfdvmrVKuvcufNlbjGA+HLmzBnLnz+/LVy40A4fPux+Znv37m1ffvmlHTx40O644w578MEH7cCBA/bBBx9Yjx497JtvvuENAAAAAJAohHu9ASlVjhw5EnT9mTJlcpeEkjt37gRbN4C4y5gxow0dOjRw/YYbbrBbbrnFhU8KrdKlS2ddunRx99WsWdNatmxpb775pquiAgAAAACvUTGVCFr51Bb33HPP2cMPP+xacYoUKWKTJ08OLHvq1Cnr3r27q4qIiIiwokWL2siRIwOPlRYtWrjKKf/14FY+fT9t2jSbO3euW0aXJUuWuIu+V1WF39q1a91t27dvd/c/9NBDdujQocDjtK6YWvl27txpd911lwvD1DJ033332d9//x2437897777rnts1qxZrVWrVnbkyJEE3tNAynLixAn7/vvvrWLFinbu3Dnz+Xwh9+u2n376ybPtAwAAAIBgBFOJxLhx46x69er2448/WteuXe2xxx6zrVu3uvtefPFFmzdvns2cOdPdNn369EAApZY6mTJliu3ZsydwPXpbn4Ki2267zS2jS+3atS+6TVpG4ZOCJv/jtK7o9EFXodT+/ftt6dKltmDBAvvtt9/s/vvvD1lu27ZtruXwk08+cRct+/zzz1/2PgMQSiHUI488YqVKlXKVUbVq1bJjx47ZpEmT7PTp07Z8+XKbPXu2a/kDAAAAgMSAVr5EQnNgFEhJv379bMKECbZ48WIrXbq0q0bSB0213qhqSRVT0VvqNAcqX758Ma5bVUzp06d3Q5JjWyYmadOmdZVNes4LPU6zrNavX2+///67FS5c2N2mAcvlypVzQdn1118fCLA0/0ZVYdK2bVv32BEjRsS4Xm2vLn58mAYuHErp/yEKrzVvKlWqVJYzZ06bP3++9enTxwYNGmTXXXedq4JcsWIFuxIAAABAokDFVCKhths/fxC0d+/ewOBytdgppHr88cfdUOPEZPPmzS6Q8odSog/ACst0n5+qvPyhlKg10f8aY6J2RQVj/kvw+gGEhlLdunWzlStXuv8/6OfFr06dOvbtt9/avn37bNmyZfbXX39Z3bp12X0AAAAAEgWCqUQiTZo0IdcVTqnCSKpWreqqkXQWv//++8+15d1zzz1X/JyqqJDgGTRq9/HiNcakf//+br6V/7Jr164E2zYgKdMMOrXpqY02e/bsIfepPViVh/p/xxtvvOFmx/nn2wEAAACA1wimkgjNedLMJn2w/PDDD+2jjz5yM538gc/Zs2cv2pYXfRl/G6BmR/mpMutij4uubNmyLjQKDo42bdrkhqqrcupy6Wxiet3BFwChduzYYa+88opr4VObr/+MnP4z8WlGXd68ed3P+6xZs+yrr76yAgUKsBsBAAAAJArMmEoCxo8f79reqlSp4qqc9OFSrX5qlfO3yGlWk1p2FOZEr5jwLxMVFeU+vGrujFp9rrnmGtcepzPmac7Tzz//7IawR3/c0aNH3forVapkGTJkcJdgDRs2tAoVKlibNm3csHSdol6zbtQupIHuABKOwqjoZ94LphMj6AIAAAAAiREVU0mA5jKNHj3ahTwaJL59+3b77LPPAq14CpPUwqOQSeFVTDp16uRmVGkdqpxQ248qrT744APbsmWLm3E1atQoGz58+Hln5lPlhaq19DhtR3RqyZs7d64LxG6++WYXVJUoUcJVdgEAAAAAAMQmzHehP7UDiYjOyqdKr/oDZlp4RGjVFpCcRUU28XoTAAAAAOCSP79rXvTFxvJQMQUAAAAAAABPEEwBAAAAAADAEwRTAAAAAAAA8ATBFAAAAAAAADxBMAUAAAAAAABPEEwBAAAAAADAE+HePC1w+Wb3a3zR000CAAAAAIDEj4opAAAAAAAAeIJgCgAAAAAAAJ4gmAIAAAAAAIAnCKYAAAAAAADgCYIpAAAAAAAAeIKz8iHJaTEqysIjMni9GcBliYpswp4DAAAAgP8fFVMAAAAAAADwBMEUAAAAAAAAPEEwBQAAAAAAAE8QTAEAAAAAAMATBFMAAAAAAADwBMEUAAAAAAAAPEEwlQJs377dwsLCbO3atbEuU6xYMZs4cWKc1zl16lTLli3bFW+btmvOnDlXvB4gOTh58qR16tTJihcvbpkzZ7YyZcrY22+/7e7buXOnZcqUKeQSHh5uzZo183qzAQAAAOCyhV/+QwEA8enMmTOWP39+W7hwoZUoUcJWrlxpt99+uxUqVMgaNWpkR48eDSx76tQpK1CggLVq1Yo3AQAAAECSRcVUAtAHxpT0vADiR8aMGW3o0KFWsmRJV014ww032C233GLffPPNecuq0vDcuXPWsmVLdj8AAACAJItgKh7Uq1fPunfvbj179rRcuXJZ48aN3e0bNmxw1Q5qucmbN6+1bdvW/v3338Dj9KFy9OjRds0111i6dOmsSJEiNmLEiMD969evt/r161v69OktZ86c1rlz55CKiQ4dOljz5s3dY1Q5Ubp0aXf7999/b1WqVLGIiAirXr26/fjjj5f8msaPH28VKlRwH5QLFy5sXbt2DXnu4A/HpUqVcs+l171r166Q++fOnWtVq1Z196sCZMiQIa4qBMDFnThxwv08V6xY8bz73nrrLWvTpo372QIAAACApIpgKp5MmzbN0qZNa8uXL7fXXnvNDh486EIlBUQ//PCDffHFF/b333/bfffdF3hM//797fnnn7fIyEjbtGmTvf/++y7AkmPHjrmgJ3v27LZq1SqbNWuWa+9RABZs0aJFtnXrVluwYIF98sknLjxq2rSpXXfddbZ69WobPHiwPfXUU5f8elKlSmUvvviibdy40b22r776yvr27RuyzPHjx10o9s4777jXrdcc3Fa0bNkya9eunT3xxBPu9b3++utuNlVw+AYgZj6fzx555BEX/EavitqxY4f7/4HuBwAAAICkjBlT8UQfHlX95Dd8+HAXSj333HOB2zTEWNVHP//8s5sj88ILL9ikSZOsffv27n6179x4443ue4VUqpZQ6KOqJdGyd955p40aNSoQYOm+N99804ViMnnyZFeJpWoKVVKUK1fOdu/ebY899tglvR5VfwUPRtfr6dKli73yyiuB20+fPu22qWbNmu66AqyyZcu6Co8aNWq46qinn3468PpUMTVs2DAXcA0aNChOg6B18Tt8+PAlvQYgKYdSqlJU6KwASkFxsClTprj/v1SqVMmzbQQAAACA+EAwFU+qVasWcn3dunW2ePFi18YX3bZt21x1kUKXBg0axLi+zZs3uw+d/lBK6tSp40InfVj1B1Nqt/OHUv7Hqe0nuL2nVq1al/x69GF45MiRtmXLFhcIqf1OQZmqpDJkyOCW0RnBrr/++sBjdAYxnalP26BgSvtAlVTBFVJnz549bz2x0fMr3AJSWijVrVs3N/hcFZFZs2YNuV//D1AwpYpLAAAAAEjqCKbiSXCAJGqp81c3Radqqd9++y1Bnjc+bN++3bUDqspKoVKOHDnc8OWOHTu6AesXC5SC94GCpZiGM8dlLo4+ePfq1StwXQGZKs6A5Eztugp01T6rVt7o1LarWXWtW7f2ZPsAAAAAID4RTCUQDfz+6KOPXBucKotiav3TUHNVRMQ0J0YtcZrHpFlT/vBJH1bV0uMfch4TPe7dd991VUn+8GfFihWXtO2aTaWqjHHjxgVaiGbOnHnecqqi0vwsVUeJKrlUCaZt8O8D3abh7pdDA+F1AVIKzY5Su6yO+6JFiwZuf/DBB93sOlGb7j333HNeJRUAAAAAJEUMP08gasXZv3+/q2rQ8HK170VFRdlDDz3k2tkUGvXr18/NW9IcKd2vAEkfOsV/ti3NZ9LZ/dQW2KNHD3dmP38bX0weeOABd5r5Tp06uYHjn332mY0dO/aStl1BkuZHvfTSS66yS0GX/0NxsDRp0rhtUsuRwiydJVCnt/cHVc8++6x7baqa0hB1tfjNmDHDBg4ceMn7E0gJFEaplU/BsioO/Zfgnz+FxJrnBgAAAADJAcFUAilQoICrcFII1ahRIzcLSgPFNYPJX4Wks/H17t3bBTiqMrr//vtt79697j61yynIUrilOU6qkNA8Kg0bvxDNtJo/f76tX7/eDUd+5plnYmwnvBDNtho/frx7XPny5W369Olu3lN02kaFawrDNP9Kz/3hhx8G7tdZBXWmwC+//NK9BoVWEyZMCKkEAQAAAAAAKVeYT3+eB5IAzZhS+1L9ATMtPCJuc66AxCYqsonXmwAAAAAAV+Xz+6FDhyxLliwXXJaKKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeCPfmaYHLN7tf44uebhIAAAAAACR+VEwBAAAAAADAEwRTAAAAAAAA8ATBFAAAAAAAADxBMAUAAAAAAABPEEwBAAAAAADAE5yVD0lOi1FRFh6RwevNgMeiIpt4vQkAAAAAgCtExRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAATxBMJQH16tWznj17XnCZsLAwmzNnzlXbJiAxO3nypHXq1MmKFy9umTNntjJlytjbb78duP/w4cP2wAMPWJYsWSxv3rw2bNgwT7cXAAAAAFKqcK83APFjz549lj17dnYnYGZnzpyx/Pnz28KFC61EiRK2cuVKu/32261QoULWqFEj69Gjh+3fv9927txpe/futYYNG1rRokWtXbt27D8AAAAAuIqomEogp0+ftqspX758li5dOvPCqVOnPHleIDYZM2a0oUOHWsmSJV014Q033GC33HKLffPNN3b8+HGbMWOGDR8+3LJly2bXXnutC6reeustdigAAAAAXGVJPpg6cuSItWnTxn0QVYXEhAkTQlrf1NLz1FNPWcGCBd0yNWvWtCVLloSs46OPPrJy5cq5YKdYsWI2bty486qRmjRpYunTp3etQe+//75bbuLEiYFl9OH31VdftWbNmrnnGTFihJ09e9Y6duzoHqPHli5d2l544YWQdXfo0MGaN29uQ4YMsdy5c7vWoi5dupwX9pw7d8769u1rOXLkcCHU4MGDL9jKt3v3bmvdurVbXttTvXp1VzVyMdu2bbO77rrLtTdlypTJrr/+eld1EkyvXa1Pqi7R9nbu3Nndrg/9N910k3uthQsXtscff9yOHTsWeNy7777rtkOtVXoNaqVStQqQ0E6cOGHff/+9VaxY0bZu3ep+vipXrhy4X9//9NNPvBEAAAAAcJUl+WCqV69etnz5cps3b54tWLDAli1bZmvWrAnc3717d/vuu+9chYQ+eN57771222232S+//OLuX716td13333WqlUrW79+vQt8IiMjberUqYF1KID5888/XaClEGvy5MkxBip6bIsWLdx6Hn74YRcmqXVo1qxZtmnTJnv22WdtwIABNnPmzJDHLVq0yDZv3uzW/8EHH9jHH3/sgqpg06ZNcwGTwqXRo0e7ahC93pgcPXrU6tata3/88YfbL+vWrXOhlrbnYvTYO+64w23Tjz/+6PbVnXfe6Vqego0dO9YqVarkltH+UqClZe+++263nz/88EMXVGn/B1eRKdDS9ihE2759uwvmgITk8/nskUcesVKlSlnLli3dMa6fpfDw/9fJrMophdwAAAAAgKsrzKdPbUmUPkjmzJnTVTDdc8897rZDhw5ZgQIF3OBjhVaaL6NQRbf5aZ5MjRo17LnnnnPVVv/88499+eWXgfsV4nz66ae2ceNG27Jli5UtW9ZWrVrlqn3k119/dR9yVZ3lr8xSxZK+120XoqDmr7/+sv/973/uuoKZ+fPn265duyxDhgzuttdee8369OnjXkuqVKlcBZiqrxS6+Wn769evb88//3zg+WfPnu2qrxScqUpMwY8qpq5U+fLlXRWXP2RSxVSVKlXc8/npg3/q1Knt9ddfD9ymYEoBmaqmIiIizlvvDz/84Cqy9D6qOis6VbvpEjywWpVY9QfMtPCI/9tXSLmiIptcdBn9761r167uWFPlX9asWV2YWq1aNVc15Q+ndJ9C6wMHDlyFLQcAAACA5O3w4cPu85dyDXVaJduKqd9++81V4Sik8dMLV8ucqHJJgY5myCj48F+WLl3qKnxElUp16tQJWa+uq6JKj1Xbjz68Vq1aNXD/NddcE+OgcX9wFezll192H4LVpqfnVmgUvfpIlUf+UEpq1arlqjoUVvmpBSmY2hZja4Nbu3atC44uJ5TS8yrUUhinKhJts/ZR9G2O/lpVBaUqs+D93LhxY1el9fvvvweq01R9VaRIEdfOp9BKoq/bb+TIke799F8USgFxpVCqW7durspQwbOOIdH/H9KkSeOO2eCfmQoVKrBzAQAAAOAqS9Zn5VPIoioeBSL6GiymCp0rpfagYGofVMijmVUKmxTGjBkzJk6znqLTB+lgqpCKrTVPM54ul7ZXLYJq1VMAp3WpGi36zKvor1X7+tFHH3VzpaJTEKWqKQVVukyfPt0FdQqkdD224en9+/d3VW/RK6aAuFCFn9p8v/rqq5AgWSHw/fff71pQ1TqrgPell15ybaYAAAAAgKsrSQdTatNTYKM2O4UfojKxn3/+2W6++WZXNaSqJ33w1FDumKgySB9eg+m6qqwUZqm6Qqee97f/+Fv54tLyo/XUrl3btRL5+Su1gqly47///gsESitWrHDB2eWGMKquevPNN23//v2XXDWlbVZ7oWZl+QMntQRejCrKNEdLYVZMVL22b98+13rof11qr7oQDaP36kyDSNp27Nhhr7zyijt+ihYtGrj9wQcfdK2ykyZNckGqZsDp504hlmbJAQAAAACuriQdTKkCqX379m4ekwKYPHny2KBBg9xcJlUUKVzSDCl94FTVkoIqzZPSYG+FNzrTXu/evd2cI1VLqIpCg9L1oVUfaqVMmTJuJpXOPKez7ikI02P0YVbPcSGaQ/XOO+9YVFSUOzOfzkqnEE3fB1PFkM7eN3DgQBcC6TXog7Jex+XQ2fg0P0vzptQOp7Y/BWuas6XKrYtts4avq+VOr09VJXEZmt6vXz+74YYb3HZr3pQqqhRUqfpK+1PBYdq0aV1liuZVbdiwgQoVJBiFURcan6ceZ1VLAQAAAAC8laRnTMn48eNd2NK0aVMXIGk+lKqg/MO2p0yZ4oIphUmqflJYE1xhpUofnSVPbXca8q0z5+mMd8Fni1O4lDdvXleFpUoiDVZXKBbTQO9gqsjQWcAUeNWsWdNVDAVXT/k1aNDABUJav5Zt1qyZO8Pf5VIApJk6Cup0hj3NzlGlUvR2xtj2p9qeVOmlcEqtdsHztWKjoE+zu1Stpuo0hYDal/6h82rd0wwqnaHwuuuuc9ujdkEAAAAAAJByJemz8sVEs4wKFizoKqRUhZQQdu/e7drRdCYvhUpXQgHYwYMHbc6cOfG2fcl9qj9n5UNcz8oHAAAAAEjcZ+VL0q18oha1LVu2uDPz6QWr2knuuuuueHsODU/WrCVVHu3Zs8f69u1rxYoVcxVOAAAAAAAASKGtfKKWsEqVKrlWPlVMLVu2zHLlyhVv6z99+rQNGDDAypUr51r51Ja2ZMmS886UlxToNWiwekwXnS0PAAAAAADgakl2rXy4+NnKFLTFRHO0NDsrsaKVD8Fo5QMAAACAxClFtfLh0s9WBgAAAAAAkBgki1Y+AAAAAAAAJD0EUwAAAAAAAPAErXxIcmb3a3zRHlUAAAAAAJD4UTEFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAAT3BWPiQ5LUZFWXhEBq83Ax6Limzi9SYAAAAAAK4QFVMAAAAAAADwBMEUAAAAAAAAPEEwBQAAAAAAAE8QTAEAAAAAAMATBFMAAAAAAADwBMEUAAAAAAAAPEEwdRXUq1fPevbsecFlwsLCbM6cOZf9HFu2bLEbbrjBIiIirHLlype9HiA5OHnypHXq1MmKFy9umTNntjJlytjbb78duP/w4cP2wAMPWJYsWSxv3rw2bNgwT7cXAAAAAFKqcK83AP9nz549lj179sveHYMGDbKMGTPa1q1bLVOmTPG2WxWYzZ4925o3bx5v6wQS2pkzZyx//vy2cOFCK1GihK1cudJuv/12K1SokDVq1Mh69Ohh+/fvt507d9revXutYcOGVrRoUWvXrh1vDgAAAABcRVRMxeL06dNX832wfPnyWbp06S778du2bbMbb7zRfbjOmTOnJTanTp3yehOQgiikHTp0qJUsWdKFq6omvOWWW+ybb76x48eP24wZM2z48OGWLVs2u/baa11Q9dZbb3m92QAAAACQ4ngaTB05csTatGnjPkSqumHChAnntb2pJeepp56yggULuuVq1qxpS5YsCVnPRx99ZOXKlXPBTrFixWzcuHHnVSM1adLE0qdP71p73n//fbfcxIkTA8vow+urr75qzZo1c88zYsQIO3v2rHXs2NE9Ro8tXbq0vfDCCyHr7tChg6smGjJkiOXOndu1BnXp0uW8IObcuXPWt29fy5EjhwuhBg8efMFWvt27d1vr1q3d8tqe6tWru6qPmOixq1evdh/E9b1/3bt27bL77rvPffjWeu666y7bvn174HGrVq2yW2+91XLlymVZs2a1unXr2po1awL3ax9JixYt3Hr91/2vOZjeM713fvq+e/fu7natv3Hjxu72DRs2uMoVVXWphapt27b277//xvi6gPhy4sQJ+/77761ixYquqlA/n8Etr/r+p59+YocDAAAAQEoKpnr16mXLly+3efPm2YIFC2zZsmUhwYgo3Pjuu+9chYM+ON57771222232S+//OLuVyCj8KVVq1a2fv16F8pERkba1KlTA+tQe86ff/7pAi2FWJMnT3btO9HpsQphtJ6HH37YhUlq/Zk1a5Zt2rTJnn32WRswYIDNnDkz5HGLFi2yzZs3u/V/8MEH9vHHH7ugKti0adNcwKRwafTo0S5E0muOydGjR11I9Mcff7h9s27dOhdqaXtiouBNwVzv3r3d9wryVPGlMEjzdbRftZ8VBmnf+UMzBYPt27d3VSQrVqywUqVK2R133OFu9wdXMmXKFLde//W40mtOmzate+7XXnvNDh48aPXr17cqVarYDz/8YF988YX9/fff7v0DEorP57NHHnnEHd8tW7Z0P1/6WQwP/3+dzApv/cc9AAAAACAFzJjSh0AFF6peatCgQSAAKVCgQGAZzX/Rbfrqv12hiwIN3f7cc8/Z+PHj3eMVRonachQijRkzxlX2aCi45swoVFHVkbz55pvuQ2p0Gob80EMPhdwWHDCpckohmYKp4DBF4YsGK2fIkMEFRAqd+vTp4wYqp0r1f9mfKjU0B0r03JMmTXKBliqWotM++eeff9w2q9JJrrnmmlj3pSqw9CFbwZO+l/fee88FWXqtqnby7199AFeApjk7ComCKbDT/UuXLrWmTZu6CjDRbf71Xgq9ToVwfmqdUiil981P+61w4cL2888/u/cumKrldAkeWA1caijVtWtXVyWl/w/o51E/J2rn0xwqfzh16NAhF+ICAAAAAFJIxdRvv/3mqnpq1KgRuE3tZGqX81PlktrpFFjow6T/ouBEM5VElUp16tQJWbeuq6JKj9UHUn34rFq1auB+hTwxDRr3B1fBXn75ZatWrZoLafTcCm8UlAWrVKmSC6X8atWq5aoy1Ernp2AqmFoXY6rakrVr17oAxx9KXQ5VWf3666/uw7Z/v2l9amny7ztVK+nMZQqQtO/Vhqjtjv76Lpf2W/RtWrx4cch7qbOliX+bgo0cOdJtl/+iAAu4lFCqW7durkrxyy+/dMeQ6P8xadKkccdj8M9chQoV2LkAAAAAcJUl6rPyKSRJnTq1a9fT12DxeeY5P7X3BFP7oCq0NLNKYZNCHlVixTbr6UL0QTiYqphia83TPKv42HcKhqZPn37eff5KKLXx7du3z83N0tB0zejS67zYoHJVnehD/8WGxUffn9qmO++800aNGnXesgrqouvfv79r9wyumCKcQlypDVhtpF999VVIEK0Q+f7773dVlmq9VUD80ksvuQpHAAAAAEAKCaZ0CneFNWpXK1KkSKCdRi1dN998s7uuqiFVPemD40033RTjesqWLes+fAbTdVVZKcxSdYRadn788cdABY8qiQ4cOHDRbdR6ateu7VqB/GKq7FHlxX///RcIlDSvScHZ5YYoqq5SC55OZ3+5VVOqEPvwww8tT548rhIqttf3yiuvuLlSogqv6IPI9R7pPYgebGmIeTBVnEQP32LaJs340hD14Pk+sVFQdiVnKkTKtWPHDnds6/hR6Or34IMPunlnaqV99NFH3Qw5/dwqxNIsOgAAAABACmnlU/WRKnY0i0ntXRs3bnRnwFM1jn8mksIlnbVPHxg1UPz33393Z9ZSi9enn37qltHAb81qUrWDQi3NrdKHTlU6iVrFGjZsaJ07d3aPVUCl7/Vh1P88sVGLm4Z0R0VFuXWrwiKmAeCqMNK2a7bVZ5995mZJ6YOuf77UpdLZ+DTTSWe+U3iktkcFOppvFVfabzobns7Ep+Hn2neaLfX444+7M/75X9+7777r2iFVBabHRK/WUoik/fvXX38FwjzNptJ+eeedd1zLpF5v9KAqJmqrUtim16f9qJBP+1ZzvaKHX8CVUBilqj61rqpSz39RKCUKa1UtpVl3Cr51YgMAAAAAQAo7K58Gl6t1TIO2FR5pNpQqoCIiIgLLaGC3gikFUKp+UlgTXGWlKhwNI1fbXfny5d0HTA0f1+BzPwUoefPmdZVYOuue5iopGAt+npiookJn8VLbT82aNV3bW3D1lJ+Gryvk0fq1bLNmzdwZ/i6XhqlrJo6qnVTNpNk3zz///HntjBeidqWvv/7a7Se9Bu1XhWf6oO6voHrrrbdc2KR92LZtWxda6TmDqY1RZw9U9Zcq2ERn+1NIpzMFXn/99e7DfVyqTTTAXkGbQigNX9fr6tmzpxuufrkhHgAAAAAASLrCfNGHBXno2LFjVrBgQReGKERJKKoYUtCis3T5zwh4uRSAHTx40ObMmRNv24eYacaUBljXHzDTwiP+37B5pExRkU283gQAAAAAwAU+v2tkU2zjhRLF8HO11W3ZssWdmU8bq0onUftZfNLwY7XxqEJnz549rtJHLWr+WVYAAAAAAABIgWflGzt2rG3dutW1r2k4ueYhaTZSfNIZ4wYMGOBmNamFTwPNdba6iw3rBgAAAAAAQApp5QMuhFY+BKOVDwAAAACSfisfE6cBAAAAAADgCYIpAAAAAAAAeIJgCgAAAAAAAClz+DlwqWb3a3zRHlUAAAAAAJD4UTEFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAAT3BWPiQ5LUZFWXhEBq83A5coKrIJ+wwAAAAAEIKKKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCkChMmjTJqlevbunSpbPmzZsHbt+5c6dlypQp5BIeHm7NmjXzdHsBAAAAAFcuPB7WAQBXrECBAjZw4EBbuHCh7d69O3B7kSJF7OjRo4Hrp06dcsu2atWKvQ4AAAAASRzBFIBEoWXLlu7r2rVrQ4Kp6ObMmWPnzp0LLA8AAAAASLpo5Utk9IF79OjRds0117iWJlWLjBgxwt23fv16q1+/vqVPn95y5sxpnTt3Dqkk6dChg2uBeu655yxv3ryWLVs2Gzp0qJ05c8b69OljOXLksEKFCtmUKVMCj9m+fbuFhYXZjBkzrHbt2hYREWHly5e3pUuXBpY5e/asdezY0YoXL+6eu3Tp0vbCCy+EbLf/uceOHWv58+d329etWzc7ffq0u1/bofVGV7lyZYuMjEyQfYnk6a233rI2bdq4YxUAAAAAkLQRTCUy/fv3t+eff96FNZs2bbL333/fhUzHjh2zxo0bW/bs2W3VqlU2a9Ys1/LUvXv3kMd/9dVX9ueff9rXX39t48ePt0GDBlnTpk3d41auXGldunSxRx999LyKFAVXvXv3th9//NFq1apld955p+3bty8QlinQ0nNqm5599lkbMGCAzZw5M2Qdixcvtm3btrmv06ZNs6lTp7qLPPzww7Z582a37X56rp9++skeeuihGPfFyZMn7fDhwyEXpGw7duxwx/0jjzzi9aYAAAAAAOIBwVQicuTIEVeJpIqp9u3bW8mSJe3GG290H8IVUJ04ccLeeecdV3mkyikNi3733Xft77//DqxDVVEvvviiq2pSGKSvx48fd0FSqVKlXPCVNm1a++abb0KeWwHX3XffbWXLlrVXX33VsmbN6ipTJE2aNDZkyBA3mFpVU6pWUZgUPZhS+KVtKlOmjAvDmjRpYosWLXL3KdhSsBZcraXv69atayVKlIhxf4wcOdJth/9SuHDheN3fSHp0zFSpUsUqVark9aYAAAAAAOIBwVQioooiVQk1aNAgxvv0YTxjxoyB2+rUqeOqmbZu3Rq4rVy5cpYq1f97W1VtVaFChcD11KlTuza7vXv3hqxfVVJ+OuOZQig9p9/LL79s1apVs9y5c7uzok2ePNmdLS2Ynlvr91NLX/DzdOrUyT744AMXsGmAtcI2hWexUYh26NChwGXXrl0X2HtI7nSsK5iiWgoAAAAAkg+Gnycimt90pVTdFEzzo2K6TR/y40rzp5566ikbN26cC7AyZ85sY8aMca2BF3vu4OdRe6DmZs2ePdtVbWn+1D333BPr82pZXZAyaBaa/6LjRgGmQlYdK7JgwQL7999/rXXr1l5vKgAAAAAgnlAxlYio1U7hlL/9LZha7NatW+dmTfktX77cfXBXu96VWrFiReB7BQOrV692z+l/Hg1G79q1q2uj0mB2zZK6VKrEUouiql50adWqVbyEcUgehg8f7o4HDfufP3+++75Ro0aB+9VaqiBTbZ0AAAAAgOSBiqlERGcZ69evn/Xt29dViahV759//rGNGze6uU4aZK5gZ/Dgwe72Hj16WNu2bV273pVSq56CMYVREyZMsAMHDgTa7HS7ZltFRUW5GVOaa6Uh5vr+UqkNKzjwAvx0XOsSm+gzzQAAAAAASR/BVCKjs/GpskhnvtPZ9TSnSWfSy5AhgwuGnnjiCbv++uvddQ0r15n34oPOBKjL2rVrXUXUvHnzLFeuXO4+ncVPZ9C7//77XXueWqlUPfX5559f8vMo5FL11f79+61mzZrxsu0AAAAAACBpCvP5fD6vNwLe2b59u6t8UvBUuXLlBH8+HW4KpxRs9erV65Iee/jwYdfGVX/ATAuPyJBg24iEERXZhF0LAAAAACnA4f//87tOZJYlS5YLLkvFFK4atR9qkPpff/1lDz30EHseAAAAAIAUjmAKV02ePHlce+DkyZMte/bs7HkAAAAAAFI4gqkUrlixYq697mqgaxQAAAAAAARLFXINAAAAAAAAuEoIpgAAAAAAAOAJgikAAAAAAAB4ghlTSHJm92t80dNNAgAAAACAxI+KKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCs/IhyWkxKsrCIzJ4vRmIRVRkE/YNAAAAACBOqJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKcSJz+ezzp07W44cOSwsLMyyZctmPXv2DNxfrFgxmzhxInsTFzVp0iSrXr26pUuXzpo3b37e/W+++aaVLl3aMmbM6I6ruXPnslcBAAAAIJkK93oDkDR88cUXNnXqVFuyZImVKFHCUqVKZenTp/d6s5AEFShQwAYOHGgLFy603bt3h9w3efJkmzBhgs2YMcMqV65se/futWPHjnm2rQAAAACAhEUwhTjZtm2b5c+f32rXrs0ewxVp2bKl+7p27dqQYOrs2bP27LPP2jvvvGNVqlRxt+XNm5e9DQAAAADJGK18uKgOHTpYjx49bOfOna6NT+1V9erVC2nli07Lvf7669a0aVPLkCGDlS1b1r777jv79ddf3WPVpqWQS4EXIFu3brW///7b1qxZ446xQoUKWadOnezw4cPsIAAAAABIpgimcFEvvPCCDR061AUFe/bssVWrVsVprw0bNszatWvnKmPKlCljDzzwgD366KPWv39/++GHH9zcqu7du8f6+JMnT7pQIviC5Gv//v3uq1r8dHzouPn999/tySef9HrTAAAAAAAJhGAKF5U1a1bLnDmzpU6d2vLly2e5c+eO01576KGH7L777rNrr73W+vXrZ9u3b7c2bdpY48aNXQXVE0884WZWxWbkyJHuuf2XwoUL824lY5kyZXJfFVzmypXLXfT9/Pnzvd40AAAAAEACIZhCgqlYsWLge/+soAoVKoTcduLEiVgroRRKHDp0KHDZtWsX71YypjPxRUREeL0ZAAAAAICriOHnSDBp0qQJmTkV223nzp2L8fHp0qVzFyQvZ86cCVz03iuc9J/l8cEHH7RRo0ZZ1apV3fGh7++66y6vNxkAAAAAkEComAJwVQ0fPtyFUCNGjHBtevq+UaNG7r6JEydagQIFrHjx4q6CqmjRojZ+/HjeIQAAAABIpqiYAnBVDR482F1iorM1Tp06lXcEAAAAAFIIKqYAAAAAAADgiTCfz+fz5qmBS6Mh6To7X/0BMy08IgO7L5GKimzi9SYAAAAAABLB53edyCxLliwXXJaKKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeCPfmaYHLN7tf44uebhIAAAAAACR+VEwBAAAAAADAEwRTAAAAAAAA8ATBFAAAAAAAADxBMAUAAAAAAABPEEwBAAAAAADAE5yVD0lOi1FRFh6RwevNSNGiIpt4vQkAAAAAgGSAiikAAAAAAAB4gmAKAAAAAAAAniCYAgAAAAAAgCcIpgAAAAAAAOAJgikAAAAAAAB4gmAKAAAAAAAAySOYKlasmE2cONESSr169axnz57xtr4OHTpY8+bNr2gdgwcPtsqVK8fbNgFJ3aRJk6x69eqWLl26836+9DOs2zNlyhS4/Pnnn55tKwAAAADAO+GWxHz88ceWJk0arzcDwAUUKFDABg4caAsXLrTdu3efd/+oUaPiNWAGAAAAACRNSS6YypEjh9ebAOAiWrZs6b6uXbs2xmAKAAAAAIBLbuVTC0737t3dJWvWrJYrVy6LjIw0n88Xstzx48ft4YcftsyZM1uRIkVs8uTJgfvq16/vHh/sn3/+sbRp09qiRYvc9VdeecVKlSplERERljdvXrvnnntCtiG40uLkyZPWr18/K1y4sGsPuuaaa+ytt95y9509e9Y6duxoxYsXt/Tp01vp0qXthRdeuKR3furUqZYtWzabM2dOYJsaN25su3btOm/Zd99917Uyat+0atXKjhw5Erjv3LlzNnLkyMC2VKpUyf73v/8F7l+yZImFhYW5faAWqAwZMljt2rVt69atIc/x6quvWsmSJd3+0uvRcwbTOl5//XVr2rSpW0fZsmXtu+++s19//dXtu4wZM7r1btu2LeRxc+fOtapVq7rXV6JECRsyZIidOXMmZL1vvvmmtWjRwq1X+2LevHkh61i6dKnVqFHDvQ/58+e3p59+OmQdev7HH3/c+vbt6wLGfPnyuTZIpDzDhw93x0CVKlXsnXfe8XpzAAAAAABJZcbUtGnTLDw83L7//nsX8owfP94FFsHGjRvnwpUff/zRunbtao899lggYHnkkUfs/fffd4GS33vvvWcFCxZ0odUPP/zgwouhQ4e6x3zxxRd28803x7o97dq1sw8++MBefPFF27x5swtlNLPGHwYVKlTIZs2aZZs2bbJnn33WBgwYYDNnzryk16ygbcSIEe4D9PLly+3gwYMueAqmoEfh1SeffOIuCmmef/75wP0KpfT41157zTZu3GhPPvmkPfjgg265YM8884zbf9oP2s8K+Pxmz55tTzzxhPXu3ds2bNhgjz76qD300EO2ePHikHUMGzbM7RdVq5QpU8YeeOABt2z//v3dehUkBoeDy5Ytc8tr3dpP2ocK5PSagymsuu++++ynn36yO+64w9q0aWP79+939/3xxx/utuuvv97WrVvnAjQFhAogoh8/CsdWrlxpo0ePdu/zggULYtzvOkYOHz4cckHSp58F/bz8/fff7mekR48e7tgGAAAAAKQ8Yb7o5U4XoIqXvXv3umBFFTSiqhhVzijQEFUM3XTTTYFKHq1elTEKNbp06WInTpxw82cU0CjkEFUPqfVn0KBBboaUwha1/6jiKqZt0KBxDVj/+eefXdWQgo2GDRvG6TUokPnrr78C1Uoafq6gSaFSTBTQaHtWrFhhNWvWdLdt2bLFVSIpXFGFkKp+xowZ49br32ZVBX399dfucQpYVB2ieTu1atUKrFshnUIvBXWqmLrlllvcMg0aNHD3f/bZZ9akSRP777//XCVTnTp1rFy5ciEVaNqHx44ds08//dRd1/ui2T4Kp0TPr+dUSOQPuWbMmOFek9Yr2nd6TgVXwWGhXoN/KHX09eo5FQB+/vnndtttt7lA7aOPPnLhoP/YUOWbqtkOHTpkqVKlcu+dqtgUhPlp/ymQDA7x/LRfddxEV3/ATAuPyBCn9xsJIyqySZyW03uogDS2ny/RcbZz5053XAIAAAAAkj4VlqibTHlAlixZ4rdi6oYbbggED6LQ45dffnGBg1/FihUD32tZBVMKtEQBS9u2be3tt99219esWeOqfxQQya233mpFixZ17WRabvr06S68iYk+8KZOndrq1q0b6/a+/PLLVq1aNcudO7cLUhTq6EPwpVDlkiqB/FSFpPY+hTB+CuSCgzS1svlfs9ro9Br02oLPRKYKqugtdcH7TusQ/3r0fAqngul68HZEX4daIaVChQohtykg9FcgqcJJlUvB29apUyfbs2dPyL4PXq+qnnRwBW+bjoXgY0PbdvTo0ZAZQ8HriL6folNQpoPYf4mpfRJJn0JLAAAAAEDKlCDDz6OfNU9hhdrqgiuFVPWkwGLKlCmuYkZhlCjcUVilCqIvv/zStd+p6mLVqlUuDAqmWU0XogqMp556yrXGKTTRulXZpEqnq/maFc6IqprUshhM85hiW48/5Aned5e6Lf51XGi92j5VJvkHVgdTkBiX13g523axdWjfRN8/SBo0W8x/0furIFQBlILOb7/91lXP6b3Vz7mqJ9944w2vNxkAAAAAkBSCqeihjlrFNAhblUtxpeodzaDSh1G1sU2aNCl0o8LDXXuZLmrvUyD11VdfnRecaD360Ks5TTG18mkelAZ9a86VX/QKpbjQh2vNZlLbmWj2ldr/1M4XF9ddd537EK5KrQtVd12Mnk+vqX379oHbdF3rvxIaeq7XpMHxV7JtauVT66Y/+NK2KQzUnC+kLJotFtyGqRBZx77mvel2/4w2VRpqTt29997r4dYCAAAAAJJMMKVwpVevXm6YtiqbXnrpJVeRdKlUNaV5T2oJ05ne/DQ4/LfffnMDz7Nnz+7mLCl80iyp6PShViGNZidp+LlmVe3YscO1hmn2kgIztctFRUW5s+Fp7pUqr/T9pVb5aECznkOhmbZbLY3+oOpiFM6ocksDz/VabrzxRteapuBG7XDBQdOF9OnTx70unclMQdz8+fPdTC7NpboSqkrTWfx0BkWdAVGVLWrvU4tl9OHlsVH4p7lf2k/aPwq6FCrqWKFVK+VRlWNsZ1xMiIpFAAAAAEDSdMnDXXT2Ng3NVijTrVs3dya3zp07X/ITt27d2oU8+hrcLqbqKIUtau9TFY7afHTWPQ39jonO/qYwRcGIZj9pNpIGc4vCM1VZ3X///W5w+b59+0Kqp+IqQ4YMboi3zm6nuUmawfThhx9e0jo0NDwyMtKdkUyvSwPD1dp3KSFZ8+bN3ZkQx44d6/aHzp6nVki1RV2Jxo0bu0BQrZOapaXQbcKECYH2yrhQi6JCRJ2tUQGhBt137NjRDUwHAAAAAACIl7Py+c+Id6W2b99uJUuWdBVMaiVLrHRWvp49e7rWPSSOqf6clS/pnJUPAAAAAJDyHL6Es/IlyPDzCzl9+rSrXFIljSpzEnMoBQAAAAAAgIRz1c/TrrlK+fPnd5VSatMDAAAAAABAynRJrXyAl2jlSzxo5QMAAAAAxEcr31WvmAIAAAAAAACEYAoAAAAAAACeIJgCAAAAAACAJ676WfmAKzW7X+OL9qgCAAAAAIDEj4opAAAAAAAAeIJgCgAAAAAAAJ4gmAIAAAAAAIAnCKYAAAAAAADgCYIpAAAAAAAAeIKz8iHJaTEqysIjMni9GSlaVGQTrzcBAAAAAJAMUDEFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBMEU0lQvXr1rGfPnp5uQ4cOHax58+aebgMSr0mTJln16tUtXbp05x0nOn51e6ZMmQKXP//807NtBQAAAAB4h2AKF7R9+3YLCwuztWvXhtz+wgsv2NSpU9l7iFGBAgVs4MCB1qlTpxjvHzVqlB09ejRw0fIAAAAAgJQn3OsNQNKUNWtWrzcBiVjLli3dVwWau3fv9npzAAAAAACJFBVTSdyBAwesXbt2lj17dsuQIYPdfvvt9ssvv4Qss3z5ctc+pfu1XOPGjd3j5IsvvrAbb7zRsmXLZjlz5rSmTZvatm3bAo8tXry4+1qlShVXOaX1xNTKd/LkSXv88cctT548FhER4da5atWqwP1Llixxj1+0aJFr8dK21K5d27Zu3Zrg+wiJz/Dhwy1HjhzuuHrnnXe83hwAAAAAgEcIppI4BUQ//PCDzZs3z7777jvz+Xx2xx132OnTpwMVKw0aNLDrrrvO3f/NN9/YnXfeaWfPnnX3Hzt2zHr16uXWodAoVapU1qJFCzt37py7//vvv3dfFy5caHv27LGPP/44xu3o27evffTRRzZt2jRbs2aNXXPNNS4A279/f8hyzzzzjI0bN849X3h4uD388MOxvjaFXYcPHw65IOkbOXKkCz///vtve/75561Hjx42e/ZsrzcLAAAAAOABWvmSMFVGKZBSRZSqj2T69OlWuHBhmzNnjt177702evRoV6H0yiuvBB5Xrly5wPd33313yDrffvtty507t23atMnKly/vvhdVU+XLly/G7VC49eqrr7qZU6rYkjfeeMMWLFhgb731lvXp0yew7IgRI6xu3bru+6efftqaNGliJ06ccFVWMQUYQ4YMucK9hMSmVq1age8VXj766KP24YcfukAUAAAAAJCyUDGVhG3evNlVHdWsWTNwmwKk0qVLu/uCK6YuFG61bt3aSpQoYVmyZLFixYq523fu3Bnn7VD1iyq06tSpE7gtTZo0VqNGjcB2+FWsWDHwff78+d3XvXv3xrje/v3726FDhwKXXbt2xXmbkHSoSg8AAAAAkDJRMZXMpU+f/oL3q62vaNGirsJJZ0ZTC58qpU6dOpUg26PAyk8zp8TfNhhdunTp3AVJz5kzZwIXvb+qilMAdfz4cfv222/drDK9t5o99tprr7njDwAAAACQ8lCqkISVLVvWffBfuXJl4LZ9+/a5geKaKeWvUNLsqJj4lx04cKCrqtL6/EPR/dKmTeu++mdSxaRkyZJuObUU+qmCSsPP/duBlDfcXKGoWjfnz5/vvm/UqJE7LtSeqbZQDeJ/8sknbfz48a7tFAAAAACQ8lAxlYSVKlXK7rrrLuvUqZO9/vrrljlzZje3qWDBgu52fztchQoVrGvXrtalSxcXIC1evNgFATormlr/Jk+e7Nrq1L6nxwfTWfYUKujsfYUKFXKzoLJmzRqyTMaMGe2xxx5zs6S0ziJFirjZVqqO6dix41XdJ0gcBg8e7C4xCQ5SAQAAAAApGxVTSdyUKVOsWrVq1rRpUzdUWmfl++yzzwItc9dee619+eWXtm7dOjfzScvMnTvXzaZSa9WMGTNs9erVrn1P1StjxowJWb+We/HFF13wpVY/f+AVnc6upkHqbdu2tapVq9qvv/5qUVFRrioGAAAAAAAgJmE+JRlAEnD48GFXrVV/wEwLj8jg9eakaFGRTbzeBAAAAABAIv/8rhOZ6URrF0LFFAAAAAAAADxBMAUAAAAAAABPEEwBAAAAAADAEwRTAAAAAAAA8ATBFAAAAAAAADxBMAUAAAAAAABPhHvztMDlm92v8UVPNwkAAAAAABI/KqYAAAAAAADgCYIpAAAAAAAAeIJgCgAAAAAAAJ4gmAIAAAAAAIAnCKYAAAAAAADgCc7KhySnxagoC4/I4PVmpAhRkU283gQAAAAAQDJGxRQAAAAAAAA8QTAFAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEwRQAAAAAAAA8QTAFAAAAAAAATxBMAbhskyZNsurVq1u6dOmsefPmMS7z999/W44cOaxy5crsaQAAAABACIIpAJetQIECNnDgQOvUqVOsy3Tv3t2qVKnCXgYAAAAAnIdgCp47e/asnTt3zuvNwGVo2bKlq5TKlStXjPfPnTvX9u/fb23btmX/AgAAAADOQzCFEO+8847lzJnTTp48GXK7wgd/uKCwoWrVqhYREWElSpSwIUOG2JkzZwLLjh8/3ipUqGAZM2a0woULW9euXe3o0aOB+6dOnWrZsmWzefPm2XXXXefawHbu3Mk7kcwcOnTIevXqZa+99prXmwIAAAAASKQIphDi3nvvdRVMCo389u7da59++qk9/PDDtmzZMmvXrp098cQTtmnTJnv99ddd0DRixIj/d1ClSmUvvviibdy40aZNm2ZfffWV9e3bN+R5jh8/bqNGjbI333zTLZcnT57z3gmFY4cPHw65IOnQe96hQwcrVaqU15sCAAAAAEikCKYQIn369PbAAw/YlClTAre99957VqRIEatXr56rjnr66aetffv2rlrq1ltvtWHDhrmAyq9nz552yy23WLFixax+/fo2fPhwmzlzZsjznD592l555RWrXbu2lS5d2jJkyHDeOzFy5EjLmjVr4KLqKyQNCjCXL19u/fr183pTAAAAAACJWLjXG4DER4Osr7/+evvjjz+sYMGCriJKlS9hYWG2bt06FzgEV0ipwurEiROuCkoB08KFC12otGXLFlflpDa/4Pslbdq0VrFixQtuR//+/V0rmJ/WRTiVNCxatMh+++03NxzdX/3233//uVlU69evt/z583u9iQAAAACARIBgCufRGdQqVark5k01atTItdqplU80K0pVUxp6HZ1mTm3fvt2aNm1qjz32mAuvcuTIYd9884117NjRTp06FQimVJmloOtCNHtKFyReCh39Fw2wVwCpVk4Fio888khguVmzZrm2zaioqBjbNgEAAAAAKRPBFGKkUGHixImuaqphw4aBSiUNPd+6datdc801MT5u9erVLqAYN26cCygkehsfkg+1aSqo9FPgWLduXVuyZIllyZIlcHv27NktTZo0VqhQIY+2FAAAAACQGDFjCjHSnKndu3fbG2+84Yae+z377LOukkphhCqpNm/ebDNmzLCBAwe6+xVYaX7USy+95Fq53n33Xc7KlowNHjzYfD5fyEWhVHRqBV27dq0n2wgAAAAASLwIphAjDRu/++67LVOmTNa8efPA7Y0bN7ZPPvnEvvzySzeH6oYbbrAJEyZY0aJF3f1qARw/frw741758uVt+vTpbt4UAAAAAABAdGE+lTgAMWjQoIGVK1fOXnzxxUSxfzT8XIFZ/QEzLTzi/LP4If5FRTZhtwIAAAAALuvz+6FDh0LGvMSEGVM4z4EDB1w7li6vvPIKewgAAAAAACQIginEeFY+hVNqxytdujR7CAAAAAAAJAiCKZxn+/bt7BUAAAAAAJDgGH4OAAAAAAAATxBMAQAAAAAAwBMEUwAAAAAAAPAEM6aQ5Mzu1/iip5sEAAAAAACJHxVTAAAAAAAA8ATBFAAAAAAAADxBMAUAAAAAAABPEEwBAAAAAADAEwRTAAAAAAAA8ARn5UOS02JUlIVHZPB6M5KNqMgmXm8CAAAAACCFomIKAAAAAAAAniCYAgAAAAAAgCcIpgAAAAAAAOAJgikAAAAAAAB4gmAKAAAAAAAAniCYAgAAAAAAgCcIpuJZvXr1rGfPnhdcJiwszObMmXNZ69++fbt7/Nq1a81rV/I6kHRMmjTJqlevbunSpbPmzZuH3HfPPfdY/vz5LUuWLFa8eHEbPny4Z9sJAAAAAEh6wr3egJRoz549lj17dksqBg8e7AKo6GFYUnsduDwFChSwgQMH2sKFC2337t0h9w0aNMiuvfZaF1rt3LnTbrvtNitWrJg9+OCD7G4AAAAAwEURTJnZ6dOnLU2aNHa15MuXz5KD5PI6cGEtW7Z0XxVMRg+mKlSoEFJBlypVKvvll1/YpQAAAACAxNXKd+TIEWvTpo1lzJjRtf5MmDDhvLa3kydP2lNPPWUFCxZ0y9WsWdOWLFkSsp6PPvrIypUr5yo0VJkxbty486p4mjRpYunTp3etRe+//75bbuLEiSEfoF999VVr1qyZe54RI0bY2bNnrWPHju4xemzp0qXthRdeCFl3hw4dXCvTkCFDLHfu3K59qUuXLnbq1KmQ5c6dO2d9+/a1HDlyuPBGFUcXaoHTh/3WrVu75bU9aptauXJlnPft0qVLrUaNGm6faN8+/fTTdubMmZDtGT16tF1zzTVumSJFirjX7NevXz9X9ZIhQwYrUaKERUZGurBOpk6d6l7vunXr3Hbrottieh3r16+3+vXru/2XM2dO69y5sx09evS8/Td27Fi3nVqmW7dugedC0tS1a1d37Oi40vut9xkAAAAAgERVMdWrVy9bvny5zZs3z/LmzWvPPvusrVmzxipXrhxYpnv37rZp0yabMWOGax+aPXu2aw1S4FGqVClbvXq13XfffS7ouf/+++3bb791H4oVcPg/DLdr187+/fdfF2ipCkrPu3fv3vO2R+t4/vnnXWAVHh7uwptChQrZrFmz3Pq0bgUrClD0nH6LFi2yiIgIt37Ne3rooYfc8sFBz7Rp09zzKlz67rvv3LbVqVPHbr311vO2Qx/k69at68I47RsFWdov2p64+OOPP+yOO+5wz/HOO+/Yli1brFOnTm4b/YFY//797Y033nBh4I033ujCOy3nlzlzZhc2aZ9rX+vxuk3hmvbzhg0b7IsvvnCtXJI1a9bztuPYsWPWuHFjq1Wrlq1atcrt80ceecS9p/4gSxYvXuz2qb7++uuvbv06BvSc0Smo1MXv8OHDcdonuLpeeeUVN4dKx62OYdo7AQAAAACJKphStZTCGlUvNWjQwN02ZcoUF4T4aT6NbtNX/+2qnlIgotufe+45Gz9+vHu8KnpEVT4KssaMGeOCGYUtCk8UjKjqSN58800XakX3wAMPuFApmCqD/FQ5pVBp5syZIcFU2rRp7e2333YVIqrcGjp0qPXp08eGDRvm2pikYsWKbvaO6Ln1oV2BVkzBlPbJP//847ZZFVOiyqZLCQUKFy7snkMVTGXKlLE///zTVUEp/FNgpMov3d++fXv3mJIlS7qAyk/zg/xUXab9rnBQwZSqnzJlyuTCuwu17ul1nDhxwoVjqvoSPeedd95po0aNcmGkKLTQ7alTp3bbquo27ZuYgqmRI0eGvCdIvHTs62dOgaOOH/3cAQAAAACQKFr5fvvtN9eupXYzP1XdqF3OT5U6aqdT2KQgxH9Rm9q2bdvcMps3b3aVR8F0XTNt9NitW7e6AKVq1aqB+xXyxFTB4Q+ugr388stWrVo116an5548ebILyoJVqlTJhVJ+qhBS1dOuXbsCtymYCqYKoZiqtvxze6pUqRIIpS6V9om2QaFU8D7RNqlFUPer6sgfCMbkww8/dI9R8KTXraAq+uuOy3Zo3/hDKf92qPJL74ufwjyFUnHZN6r0OnToUOASvI+ROOnnnBlTAAAAAIAkN/xcQYoCC7XrBQcXorAkvgUHKKIKIVV6aGaVgh61sqkS61JmPflFH6Su0Ci21jxVJCWki61fVWGa/aXKJLXiKTDUvog+uyu+XMq+0TwsXeAtzSvzX/ReqTJOFVJqCf3hhx/ccaOwdsWKFfbiiy/a448/zlsGAAAAAEg8FVMaqK1AQu1qfqqA+fnnnwPXVTWkqidVz6jKKfjibyErW7asm1MVTNdVZaUwSxVY+vD8448/Bu7XHKMDBw5cdBu1ntq1a7uZVdoWPa+/UiuYhoD/999/gev6MK7gTO10l0PVVaqa2r9//2U9XvtE4ZLP5wt5LQrWNDNLrYQKp9QuFxPN0ipatKg988wzropMy+/YsSNkGbUv6r252HZo36h1MHg7FGAEV8Yh6Rk+fLg7hjRHbf78+e77Ro0aufs0o03HWbZs2ezhhx+2Hj16uOH7AAAAAAAkmmBKIYnmG2kWk2bQbNy40Z0BT6GFvwVN4ZIqdzS8/OOPP7bff//dvv/+ezdn6NNPP3XL9O7d2wUsmuekUEtzqzSvSJVOoplFDRs2dEPL9VgFVPpeH6SDW91iokBG1R9RUVFu3ZpjFRyk+ekMfNp2zbb67LPP3CwpDfj2z5e6VDobn4I3na1OQY7aHnXmQYVNcaEgTS1uCgQ0Y2vu3LlumzR8XdukIeiaN6V5UZr/pLBNYdpbb70VeN1q21OVlO5TxYuGzgfT3Cm9HwrQNFg+eCC5n947PZfeZw1L1/usbWrbtm1gvhSSJg3RV/AZfNHwfwWay5Yts4MHD7rB9Dr+FHBe7s8CAAAAACDluWqfIDW4XC1yTZs2deGR5g+pykZhhp+GnCuYUgClKhuFNQqHdBp60ewoDSNXiFK+fHk33FvDx4NPT6/wRUHIzTffbC1atAicYS74eWLy6KOPWsuWLd1Z4mrWrGn79u1zoU90mtWkMEfr17LNmjULnP3ucqga6csvv7Q8efK4s+tVqFDBnS0wejtjbHQ2PwVkCuI046lLly4uOAseaK6QTftU+0v7XNvtn+uk7X/yySdduKaz46mCyj9c3u/uu+92Z0e85ZZb3PytDz744LztUCuXQj1Vfl1//fV2zz33uH2l4BAAAAAAACAmYb7gHrCrSC1fClU0y0hBSkLRAHC12elsfRcaAB4XCsBUHTJnzpx42z7EnapyNAOr/oCZFh7x/wbQ48pERTZhFwIAAAAA4v3zu8Y4ZcmSJXEMP1dbnVp9dGY+bZgqneSuu+6K1+f56quv3CB1VR5pOLNa2NSKpgonAAAAAAAApNCz8o0dO9a2bt3q2teqVavm5tPkypUr3k9XP2DAADerSS18Gmg+ffr0884GBwAAAAAAgBTaygdcKlr5EgatfAAAAAAAr1r5OH0WAAAAAAAAPEEwBQAAAAAAAE8QTAEAAAAAACD5Dz8H4sPsfo0v2qMKAAAAAAASPyqmAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJgCAAAAAACAJwimAAAAAAAA4Ilwb54WuHQ+n899PXz4MLsPAAAAAIBEyv+53f85/kIIppBk7Nu3z30tXLiw15sCAAAAAAAu4siRI5Y1a9YLLkMwhSQjR44c7uvOnTsvemAj+afvCih37dplWbJk8Xpz4CGOBXAcgP8ngH8bwO8J4PfFxEeVUgqlChQocNFlCaaQZKRK9X8j0RRKEUZAdBxwLIBjAX78PwEcCwjG/xPAsQD+n+CtuBaUMPwcAAAAAAAAniCYAgAAAAAAgCcIppBkpEuXzgYNGuS+ImXjWADHAvh/Avj3AfyeAH5nBJ8dkocwX1zO3QcAAAAAAADEMyqmAAAAAAAA4AmCKQAAAAAAAHiCYAoAAAAAAACeIJhCkvHyyy9bsWLFLCIiwmrWrGnff/+915uEBDRy5Ei7/vrrLXPmzJYnTx5r3ry5bd26NWSZEydOWLdu3SxnzpyWKVMmu/vuu+3vv//mfUnmnn/+eQsLC7OePXsGbuNYSBn++OMPe/DBB93PfPr06a1ChQr2ww8/BO7X2Mxnn33W8ufP7+5v2LCh/fLLL55uM+Lf2bNnLTIy0ooXL+7e55IlS9qwYcPc++/HsZA8ff3113bnnXdagQIF3L8Dc+bMCbk/Lu/7/v37rU2bNpYlSxbLli2bdezY0Y4ePXqVXwkS6jg4ffq09evXz/37kDFjRrdMu3bt7M8//wxZB8dByvh/QrAuXbq4ZSZOnBhyO8dC4kAwhSThww8/tF69ermz8q1Zs8YqVapkjRs3tr1793q9aUggS5cudaHTihUrbMGCBe4XjUaNGtmxY8cCyzz55JM2f/58mzVrlltev3S0bNmS9yQZW7Vqlb3++utWsWLFkNs5FpK/AwcOWJ06dSxNmjT2+eef26ZNm2zcuHGWPXv2wDKjR4+2F1980V577TVbuXKl+1CifysUXCL5GDVqlL366qs2adIk27x5s7uu9/6ll14KLMOxkDzpdwD9Dqg/VsYkLu+7QqmNGze63y0++eQT98G2c+fOV/FVICGPg+PHj7vPCgqv9fXjjz92f9hs1qxZyHIcBynj/wl+s2fPdp8pFGBFx7GQSOisfEBiV6NGDV+3bt0C18+ePesrUKCAb+TIkZ5uF66evXv36k/hvqVLl7rrBw8e9KVJk8Y3a9aswDKbN292y3z33Xe8NcnQkSNHfKVKlfItWLDAV7duXd8TTzzhbudYSBn69evnu/HGG2O9/9y5c758+fL5xowZE7hNx0a6dOl8H3zwwVXaSlwNTZo08T388MMht7Vs2dLXpk0b9z3HQsqgf+9nz54duB6X933Tpk3ucatWrQos8/nnn/vCwsJ8f/zxx1V+BUiI4yAm33//vVtux44d7jrHQco6Fnbv3u0rWLCgb8OGDb6iRYv6JkyYELiPYyHxoGIKid6pU6ds9erVrhzbL1WqVO76d9995+m24eo5dOiQ+5ojRw73VceEqqiCj4syZcpYkSJFOC6SKVXQNWnSJOQ9F46FlGHevHlWvXp1u/fee117b5UqVeyNN94I3P/777/bX3/9FXJ8ZM2a1bV+829F8lK7dm1btGiR/fzzz+76unXr7JtvvrHbb7/dXedYSJni8r7rq9r39P8SPy2v3ytVYYXk+zukWrj03gvHQcpx7tw5a9u2rfXp08fKlSt33v0cC4lHuNcbAFzMv//+6+ZJ5M2bN+R2Xd+yZQs7MIX8o6J5QmrjKV++vLtNv3ymTZs28EtG8HGh+5C8zJgxw5Xkq5UvOo6FlOG3335z7Vtq6x4wYIA7Fh5//HH3/4H27dsHfu5j+reC/yckL08//bQdPnzY/TEiderU7neEESNGuHYM4VhImeLyvuurgu1g4eHh7o9e/H8ieVIbp2ZOtW7d2s0VE46DlEOt3voZ1+8LMeFYSDwIpgAkiUqZDRs2uL+II+XZtWuXPfHEE24eiE5+gJQbUKvK4bnnnnPXVTGl/y9oloyCKaQcM2fOtOnTp9v777/v/gK+du1a98cLzQ7hWADgp8r6++67zw3F1x82kLKoov6FF15wf9hUxRwSN1r5kOjlypXL/UU0+tnWdD1fvnyebReuju7du7vhpIsXL7ZChQoFbtd7rzbPgwcPhizPcZE8f7HQiQ6qVq3q/uqli4bda8CtvtdfwzkWkj+dZeu6664Lua1s2bK2c+dO973/3wP+rUj+1JKhqqlWrVq5M2+pTUMnQNDZXIVjIWWKy/uur9FPnHPmzBl3Vi5+p0yeodSOHTvcH7b81VLCcZAyLFu2zP28a8yH//dHHQ+9e/d2Z3oXjoXEg2AKiZ7aNKpVq+bmSQT/5VzXa9Wq5em2IeHor1sKpXQWja+++sqdFjyYjgmdnSv4uNBZV/QhleMieWnQoIGtX7/eVUX4L6qcUduO/3uOheRPrbz6GQ+mGUNFixZ13+v/EfoFM/j/CWr30twY/p+QvOisW5oJFEx/wNLvBsKxkDLF5X3XV/1BS3/w8NPvGDp2NIsKySuU+uWXX2zhwoWWM2fOkPs5DlIG/dHip59+Cvn9UZW1+uNGVFSUW4ZjIfGglQ9JgmaKqDxfH0Br1KhhEydOdKcHfeihh7zeNCRg+57aNObOnWuZM2cOzH7QINP06dO7rx07dnTHhmZD6C9hPXr0cP/A3HDDDbwvyYjef/9sMT+dAly/aPpv51hI/lQRo6HXauXTB47vv//eJk+e7C6iMn21cw0fPtxKlSrlPqTqdOH6JbR58+Zebz7i0Z133ulmSumv4Grl+/HHH238+PH28MMPu/s5FpKvo0eP2q+//hoy8FwfNvV7gI6Hi/0/QFWWt912m3Xq1Mm1ASvA0B/BVH0X02nkkfSOA1XX3nPPPa59SxX3mkHn/x1S9+sP3hwHKef/CdFDSf0hUwF26dKl3XWOhUTE69MCAnH10ksv+YoUKeJLmzatr0aNGr4VK1aw85Ix/e8ppsuUKVMCy/z333++rl27+rJnz+7LkCGDr0WLFr49e/Z4ut24OurWret74oknAtc5FlKG+fPn+8qXL+9O/16mTBnf5MmTQ+7X6eIjIyN9efPmdcs0aNDAt3XrVs+2Fwnj8OHD7udfvxNERET4SpQo4XvmmWd8J0+eDCzDsZA8LV68OMbfDdq3bx/n933fvn2+1q1b+zJlyuTLkiWL76GHHvIdOXLEo1eE+D4Ofv/991h/h9Tj/DgOUsb/E6IrWrSob8KECSG3cSwkDmH6j9fhGAAAAAAAAFIeZkwBAAAAAADAEwRTAAAAAAAA8ATBFAAAAAAAADxBMAUAAAAAAABPEEwBAAAAAADAEwRTAAAAAAAA8ATBFAAAAAAAADxBMAUAAAAAAABPEEwBAAAAAADAEwRTAAAAuCx//fWX9ejRw0qUKGHp0qWzwoUL25133mmLFi26qns0LCzM5syZc1WfEwAAxI/weFoPAAAAUpDt27dbnTp1LFu2bDZmzBirUKGCnT592qKioqxbt262ZcsWrzcRAAAkAWE+n8/n9UYAAAAgabnjjjvsp59+sq1bt1rGjBlD7jt48KALrHbu3OkqqlRBlSpVKrvtttvspZdesrx587rlOnTo4JYNrnbq2bOnrV271pYsWeKu16tXzypWrGgRERH25ptvWtq0aa1Lly42ePBgd3+xYsVsx44dgccXLVrUhWYAACBpoJUPAAAAl2T//v32xRdfuMqo6KGUKJQ6d+6c3XXXXW7ZpUuX2oIFC+y3336z+++//5L39rRp09zzrFy50kaPHm1Dhw5165NVq1a5r1OmTLE9e/YErgMAgKSBVj4AAABckl9//dVUdF+mTJlYl1GV1Pr16+333393s6fknXfesXLlyrnw6Prrr4/z86liatCgQe77UqVK2aRJk9z6b731VsudO3cgDMuXLx/vJAAASQwVUwAAALgkcZkEsXnzZhdI+UMpue6661yApPsuhYKpYPnz57e9e/de0joAAEDiRDAFAACAS6KqJZ0J70oHnGvuVPSQSwPUo0uTJk3IdT23WgUBAEDSRzAFAACAS5IjRw5r3Lixvfzyy3bs2LHz7tdA87Jly9quXbvcxW/Tpk3uPlVOidrwNBcqmAafXyoFV2fPnuVdBAAgCSKYAgAAwCVTKKUwqEaNGvbRRx/ZL7/84lr0XnzxRatVq5Y1bNjQKlSoYG3atLE1a9bY999/b+3atbO6deta9erV3Trq169vP/zwg5s9pcdrjtSGDRsueVt0Zj7NnPrrr7/swIEDvJsAACQhBFMAAAC4ZCVKlHCB0y233GK9e/e28uXLu2HkCoheffVV1243d+5cy549u918880uqNJjPvzww8A6VHUVGRlpffv2dcPQjxw54sKrSzVu3Dh3lj7Ns6pSpQrvJgAASUiYLy7TKwEAAAAAAIB4RsUUAAAAAAAAPEEwBQAAAAAAAE8QTAEAAAAAAMATBFMAAAAAAADwBMEUAAAAAAAAPEEwBQAAAAAAAE8QTAEAAAAAAMATBFMAAAAAAADwBMEUAAAAAAAAPEEwBQAAAAAAAE8QTAEAAAAAAMATBFMAAAAAAAAwL/x/tR+6kNNmU9UAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 25 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Side-by-Side Comparison\n", + "\n", + "Compare training distribution vs prediction distribution." + ], + "id": "6ef379468d0634eb" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T17:08:27.619347Z", + "start_time": "2026-05-04T17:08:27.255268Z" + } + }, + "source": [ + "def compare_distributions(train_counter, pred_counter, label, top_n=15):\n", + " \"\"\"Compare two distributions side by side.\"\"\"\n", + " # Get union of top items from both\n", + " train_top = set([k for k, _ in train_counter.most_common(top_n)])\n", + " pred_top = set([k for k, _ in pred_counter.most_common(top_n)])\n", + " all_keys = sorted(train_top | pred_top)\n", + "\n", + " train_total = sum(train_counter.values())\n", + " pred_total = sum(pred_counter.values())\n", + "\n", + " train_pcts = [train_counter.get(k, 0) / train_total * 100 for k in all_keys]\n", + " pred_pcts = [pred_counter.get(k, 0) / pred_total * 100 for k in all_keys]\n", + "\n", + " x = np.arange(len(all_keys))\n", + " width = 0.35\n", + "\n", + " fig, ax = plt.subplots(figsize=(14, max(4, len(all_keys) * 0.4)))\n", + " ax.barh(x - width/2, train_pcts, width, label='Training', color='steelblue')\n", + " ax.barh(x + width/2, pred_pcts, width, label='Predictions', color='coral')\n", + " ax.set_yticks(x)\n", + " ax.set_yticklabels(all_keys)\n", + " ax.set_xlabel(\"Percentage of total triplets (%)\")\n", + " ax.set_title(f\"{label} Distribution Comparison\")\n", + " ax.legend()\n", + " ax.invert_yaxis()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "compare_distributions(train_stats[\"relation_counts\"], pred_stats[\"relation_counts\"], \"Relation\")\n", + "compare_distributions(train_stats[\"subject_type_counts\"], pred_stats[\"subject_type_counts\"], \"Subject Type\")\n", + "compare_distributions(train_stats[\"object_type_counts\"], pred_stats[\"object_type_counts\"], \"Object Type\")" + ], + "id": "4d06c73572d35e18", + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": null + } + } + ], + "execution_count": 26 + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T20:49:38.233541Z", + "start_time": "2026-05-04T20:49:38.225541Z" + } + }, + "source": [ + "# Relation ranking comparison\n", + "train_rel_rank = {rel: i for i, (rel, _) in enumerate(train_stats[\"relation_counts\"].most_common())}\n", + "pred_rel_rank = {rel: i for i, (rel, _) in enumerate(pred_stats[\"relation_counts\"].most_common())}\n", + "\n", + "print(\"=== Relation Ranking Comparison (Top 20) ===\")\n", + "print(f\"{'Relation':<35} {'Train Rank':<12} {'Pred Rank':<12} {'Diff':<8}\")\n", + "print(\"-\" * 75)\n", + "for rel, _ in train_stats[\"relation_counts\"].most_common(20):\n", + " tr = train_rel_rank.get(rel, \"-\")\n", + " pr = pred_rel_rank.get(rel, \"-\")\n", + " if isinstance(tr, int) and isinstance(pr, int):\n", + " diff = pr - tr\n", + " diff_str = f\"{diff:+d}\"\n", + " else:\n", + " diff_str = \"N/A\"\n", + " print(f\"{rel:<35} {str(tr):<12} {str(pr):<12} {diff_str:<8}\")\n", + "\n", + "# Qualifier comparison\n", + "print(\"\\n=== Qualifier Relation Comparison ===\")\n", + "train_q_top = [q for q, _ in train_stats[\"qualifier_counts\"].most_common(10)]\n", + "pred_q_top = [q for q, _ in pred_stats[\"qualifier_counts\"].most_common(10)]\n", + "print(f\"Train top qualifiers: {train_q_top}\")\n", + "print(f\"Predict top qualifiers: {pred_q_top}\")" + ], + "id": "ee621be8be1af963", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Relation Ranking Comparison (Top 20) ===\n", + "Relation Train Rank Pred Rank Diff \n", + "---------------------------------------------------------------------------\n", + "instance of 0 0 +0 \n", + "has part(s) 1 - N/A \n", + "occupation 2 1 -1 \n", + "part of 3 86 +83 \n", + "date of birth 4 3 -1 \n", + "location 5 32 +27 \n", + "position held 6 - N/A \n", + "country of citizenship 7 66 +59 \n", + "notable work 8 - N/A \n", + "film crew member 9 - N/A \n", + "participant in 10 - N/A \n", + "award received 11 2 -9 \n", + "member of 12 115 +103 \n", + "genre 13 16 +3 \n", + "inception 14 - N/A \n", + "located in the administrative territorial entity 15 - N/A \n", + "named after 16 18 +2 \n", + "country of origin 17 - N/A \n", + "produced by 18 - N/A \n", + "publication date 19 - N/A \n", + "\n", + "=== Qualifier Relation Comparison ===\n", + "Train top qualifiers: ['point in time', 'start time', 'location', 'end time', 'publication date', 'series ordinal', 'country', 'employer', 'position held', 'located in the administrative territorial entity']\n", + "Predict top qualifiers: ['point in time', 'instance of', 'record label', 'color', 'award', 'company', 'date']\n" + ] + } + ], + "execution_count": 27 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Chi-Squared Test for Distribution Difference\n", + "\n", + "Statistical test to check if prediction relation distribution is significantly different from training." + ], + "id": "b58c799109a626ca" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T20:51:10.080094Z", + "start_time": "2026-05-04T20:51:08.979055Z" + } + }, + "source": [ + "from scipy.stats import chisquare\n", + "\n", + "# Use top-N relations shared by both to avoid zero-count issues\n", + "common_rels = set(train_stats[\"relation_counts\"].keys()) & set(pred_stats[\"relation_counts\"].keys())\n", + "common_rels = sorted(common_rels, key=lambda r: train_stats[\"relation_counts\"][r], reverse=True)[:30]\n", + "\n", + "train_counts = np.array([train_stats[\"relation_counts\"][r] for r in common_rels])\n", + "pred_counts = np.array([pred_stats[\"relation_counts\"][r] for r in common_rels])\n", + "\n", + "# Normalize training to prediction total for expected frequencies\n", + "pred_total = sum(pred_counts)\n", + "train_total = sum(train_counts)\n", + "expected = train_counts / train_total * pred_total\n", + "\n", + "# Chi-squared test\n", + "chi2, p_value = chisquare(f_obs=pred_counts, f_exp=expected)\n", + "\n", + "print(f\"Chi-squared statistic: {chi2:.2f}\")\n", + "print(f\"p-value: {p_value:.2e}\")\n", + "if p_value < 0.05:\n", + " print(\"RESULT: Predicted relation distribution is SIGNIFICANTLY different from training (p < 0.05)\")\n", + "else:\n", + " print(\"RESULT: No significant difference detected (p >= 0.05)\")\n", + "\n", + "# Show per-relation residuals (observed - expected)\n", + "residuals = pred_counts - expected\n", + "print(\"\\nTop over-represented in predictions (residual > 0):\")\n", + "for i in np.argsort(residuals)[::-1][:10]:\n", + " print(f\" {common_rels[i]}: residual={residuals[i]:.1f}, pred={pred_counts[i]}, expected={expected[i]:.1f}\")\n", + "\n", + "print(\"\\nTop under-represented in predictions (residual < 0):\")\n", + "for i in np.argsort(residuals)[:10]:\n", + " print(f\" {common_rels[i]}: residual={residuals[i]:.1f}, pred={pred_counts[i]}, expected={expected[i]:.1f}\")" + ], + "id": "ff31ab35a5289a67", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi-squared statistic: 507.04\n", + "p-value: 5.76e-92\n", + "RESULT: Predicted relation distribution is SIGNIFICANTLY different from training (p < 0.05)\n", + "\n", + "Top over-represented in predictions (residual > 0):\n", + " instance of: residual=82.9, pred=223, expected=140.1\n", + " occupation: residual=74.3, pred=174, expected=99.7\n", + " award received: residual=48.3, pred=78, expected=29.7\n", + " field of work: residual=20.4, pred=33, expected=12.6\n", + " record label: residual=17.8, pred=28, expected=10.2\n", + " date of death: residual=15.4, pred=38, expected=22.6\n", + " date of birth: residual=9.3, pred=58, expected=48.7\n", + " color: residual=2.0, pred=4, expected=2.0\n", + " employees: residual=1.6, pred=2, expected=0.4\n", + " population: residual=0.6, pred=2, expected=1.4\n", + "\n", + "Top under-represented in predictions (residual < 0):\n", + " part of: residual=-52.2, pred=1, expected=53.2\n", + " location: residual=-44.5, pred=4, expected=48.5\n", + " country of citizenship: residual=-43.4, pred=2, expected=45.4\n", + " member of: residual=-28.6, pred=1, expected=29.6\n", + " genre: residual=-21.9, pred=7, expected=28.9\n", + " named after: residual=-20.3, pred=7, expected=27.3\n", + " director: residual=-15.9, pred=3, expected=18.9\n", + " point in time: residual=-12.1, pred=2, expected=14.1\n", + " country: residual=-10.4, pred=4, expected=14.4\n", + " place of birth: residual=-7.9, pred=4, expected=11.9\n" + ] + } + ], + "execution_count": 29 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10. Detailed Failure Analysis\n", + "\n", + "Look at specific examples where parse failed or model output was empty." + ], + "id": "5652baa3377e54a6" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T20:51:20.123647Z", + "start_time": "2026-05-04T20:51:20.119648Z" + } + }, + "source": [ + "# Show a few failed parses\n", + "failed_examples = [p for p in val_predictions if p[\"parsed\"] is None]\n", + "print(f\"Failed parses: {len(failed_examples)}\")\n", + "\n", + "for i, ex in enumerate(failed_examples[:3]):\n", + " print(f\"\\n--- Failed Parse {i+1} ---\")\n", + " print(f\"Text: {ex['text'][:200]}...\")\n", + " print(f\"Raw output: {ex['raw_output'][:500]}\")\n", + "\n", + "# Show a few empty outputs\n", + "empty_examples = [p for p in val_predictions if p[\"parsed\"] and len(p[\"parsed\"].get(\"triplets\", [])) == 0]\n", + "print(f\"\\nEmpty outputs: {len(empty_examples)}\")\n", + "for i, ex in enumerate(empty_examples[:3]):\n", + " print(f\"\\n--- Empty Output {i+1} ---\")\n", + " print(f\"Text: {ex['text'][:200]}...\")\n", + " print(f\"Raw output: {ex['raw_output'][:500]}\")" + ], + "id": "19714d54c890c547", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Failed parses: 6\n", + "\n", + "--- Failed Parse 1 ---\n", + "Text: Margarethe Siems (20 December 1879 – 13 April 1952) was a German operatic soprano and voice teacher. A Kammersängerin of the Dresden State Opera, between 1909 and 1912 Siems created leading roles in ...\n", + "Raw output: {\"triplets\": [{\"subject\": \"Margarethe Siems\", \"relation\": \"date of birth\", \"object\": \"20 December 1879\", \"qualifiers\": [], \"subject_type\": \"human\", \"object_type\": \"date\", \"subject\": \"Margarethe Siems\", \"object\": \"20 December 1879\", \"object\": \"human\", \"object\": \"date\", \"object\": \"20 December 1879\", \"object\": \"human\", \"object\": \"date\", \"object\": \"20 December 1879\", \"object\": \"human\", \"object\": \"date\", \"object\": \"20 December 1879\", \"object\": \"human\", \"object\": \"date\", \"object\": \"20 December 1879\", \n", + "\n", + "--- Failed Parse 2 ---\n", + "Text: Frederick Alexander Lindemann, 1st Viscount Cherwell, (5 April 18863 July 1957), pronounced , was a British physicist and an influential scientific adviser to the British government from the early 194...\n", + "Raw output: {\"triplets\": [{\"subject\": \"Frederick Alexander Lindemann\", \"relation\": \"date of birth\", \"object\": \"5 April 1886\", \"qualifiers\": [], \"subject_type\": \"human\", \"object_type\": \"date\", \"subject\": \"Frederick Alexander Lindemann\", \"relation\": \"date of birth\", \"object\": \"5 April 1886\", \"qualifiers\": [], \"subject_type\": \"human\", \"object_type\": \"date\", \"subject\": \"Frederick Alexander Lindemann\", \"relation\": \"date of birth\", \"object\": \"5 April 1886\", \"qualifiers\": [], \"subject_type\": \"human\", \"object_type\"\n", + "\n", + "--- Failed Parse 3 ---\n", + "Text: Richard Edward Cavazos (born January 31, 1929), a Korean War recipient of the Distinguished Service Cross as a first lieutenant, who advanced in rank to become the United States Army's first Hispanic ...\n", + "Raw output: {\"triplets\": [{\"relation\": \"date of birth\", \"object\": \"1929\", \"qualifiers\": [], \"subject_type\": \"human\", \"object_type\": \"date\"}, {\"relation\": \"date of death\", \"object\": \"1976\", \"qualifiers\": [], \"subject_type\": \"human\", \"object_type\": \"date\"}, {\"relation\": \"award received\", \"object\": \"Distinguished Service Cross\", \"qualifiers\": [{\"relation\": \"point in time\", \"object\": \"1965\"}], \"subject_type\": \"human\", \"object_type\": \"award\"}, {\"relation\": \"award received\", \"object\": \"Distinguished Service Cross\n", + "\n", + "Empty outputs: 0\n" + ] + } + ], + "execution_count": 30 + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 11. Summary\n", + "\n", + "Key takeaways from the analysis:" + ], + "id": "26b0b2bf3d23c01d" + }, + { + "cell_type": "code", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-04T20:51:29.937697Z", + "start_time": "2026-05-04T20:51:29.931697Z" + } + }, + "source": [ + "# Auto-generated summary stats\n", + "print(\"=== Distribution Analysis Summary ===\")\n", + "print()\n", + "print(\"TRAINING DATA:\")\n", + "print(f\" Total triplets: {train_stats['total_triplets']}\")\n", + "print(f\" Unique relations: {len(train_stats['relation_counts'])}\")\n", + "print(f\" Top relation: {train_stats['relation_counts'].most_common(1)[0][0]} ({train_stats['relation_counts'].most_common(1)[0][1]} occurrences)\")\n", + "print(f\" Top 5 relations cover: {sum(c for _, c in train_stats['relation_counts'].most_common(5)) / train_stats['total_triplets'] * 100:.1f}%\")\n", + "print(f\" Top 10 relations cover: {sum(c for _, c in train_stats['relation_counts'].most_common(10)) / train_stats['total_triplets'] * 100:.1f}%\")\n", + "print()\n", + "print(\"MODEL PREDICTIONS:\")\n", + "print(f\" Total triplets: {pred_stats['total_triplets']}\")\n", + "print(f\" Unique relations: {len(pred_stats['relation_counts'])}\")\n", + "print(f\" Parse success rate: {parse_successes}/{len(val_texts)} ({parse_successes/len(val_texts)*100:.1f}%)\")\n", + "print(f\" Empty outputs: {empty_outputs}/{parse_successes}\")\n", + "print(f\" Top relation: {pred_stats['relation_counts'].most_common(1)[0][0] if pred_stats['relation_counts'] else 'N/A'}\")\n", + "print()\n", + "print(\"COMPARISON:\")\n", + "train_top5 = set([r for r, _ in train_stats['relation_counts'].most_common(5)])\n", + "pred_top5 = set([r for r, _ in pred_stats['relation_counts'].most_common(5)])\n", + "shared_top5 = train_top5 & pred_top5\n", + "print(f\" Shared top-5 relations: {len(shared_top5)}/5 ({', '.join(sorted(shared_top5))})\")\n", + "\n", + "# Bias metric: is model dominated by top relation?\n", + "if pred_stats['relation_counts']:\n", + " top_pred_pct = pred_stats['relation_counts'].most_common(1)[0][1] / sum(pred_stats['relation_counts'].values()) * 100\n", + " top_train_pct = train_stats['relation_counts'].most_common(1)[0][1] / sum(train_stats['relation_counts'].values()) * 100\n", + " print(f\" Top-relation dominance in predictions: {top_pred_pct:.1f}% (training: {top_train_pct:.1f}%)\")\n", + " if top_pred_pct > top_train_pct * 1.5:\n", + " print(\" ⚠️ WARNING: Model is heavily biased toward the most common relation!\")\n", + " else:\n", + " print(\" ✅ Top-relation distribution is similar to training.\")" + ], + "id": "1520cfc38fcdee8c", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Distribution Analysis Summary ===\n", + "\n", + "TRAINING DATA:\n", + " Total triplets: 20203\n", + " Unique relations: 740\n", + " Top relation: instance of (1300 occurrences)\n", + " Top 5 relations cover: 20.5%\n", + " Top 10 relations cover: 30.2%\n", + "\n", + "MODEL PREDICTIONS:\n", + " Total triplets: 1033\n", + " Unique relations: 134\n", + " Parse success rate: 193/199 (97.0%)\n", + " Empty outputs: 0/193\n", + " Top relation: instance of\n", + "\n", + "COMPARISON:\n", + " Shared top-5 relations: 3/5 (date of birth, instance of, occupation)\n", + " Top-relation dominance in predictions: 21.6% (training: 6.4%)\n", + " ⚠️ WARNING: Model is heavily biased toward the most common relation!\n" + ] + } + ], + "execution_count": 31 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/distillation/configs/infer.yaml b/distillation/configs/infer.yaml new file mode 100644 index 0000000..fcdd601 --- /dev/null +++ b/distillation/configs/infer.yaml @@ -0,0 +1,38 @@ +# Inference & evaluation config for Wikontic distillation. +# Paths are resolved relative to the directory where infer.py lives. +# +# Workflow: +# - Use --split val (default) during development: comparing checkpoints, +# tuning whitelist settings, etc. +# - Use --split test ONLY once for the final unbiased evaluation after +# model & hyperparameters are frozen. + +# Model paths +base_model: "HuggingFaceTB/SmolLM2-1.7B-Instruct" +adapter_path: "./checkpoints/wikontic-v4" + +# Data (same chat format used for training) +val_path: "./data/val.jsonl" +test_path: "./data/test.jsonl" +output_dir: "./inference_outputs" + +# Generation +temperature: 0.0 +do_sample: false +max_new_tokens: 2048 +batch_size: 1 + +# Quantization (must match training settings) +load_in_4bit: true +bnb_4bit_quant_type: "nf4" +bnb_4bit_compute_dtype: "bfloat16" + +# Whitelist filtering +# Extract allowed relations/types from training data and filter predictions +use_whitelist: true +whitelist_soft_mapping: false # hard drop — reject any unknown relation +whitelist_min_similarity: 0.6 # minimum similarity threshold for soft mapping + +# Comparison report +# Path to training data for distribution comparison and whitelist extraction +train_path: "./data/train.jsonl" diff --git a/distillation/configs/train.yaml b/distillation/configs/train.yaml new file mode 100644 index 0000000..ba25474 --- /dev/null +++ b/distillation/configs/train.yaml @@ -0,0 +1,51 @@ +# Training config for Wikontic distillation — v4 +# (stronger LoRA, Focal Loss, no curriculum, no hand-tuned weights) +# Paths are resolved relative to the directory where train.py lives. + +train_path: "./data/train.jsonl" +val_path: "./data/val.jsonl" +test_path: "./data/test.jsonl" +system_prompt_path: "../src/wikontic/utils/prompts/triplet_extraction/propmt_1_types_qualifiers.txt" +output_dir: "./checkpoints/wikontic-v4" + +# Model +base_model: "HuggingFaceTB/SmolLM2-1.7B-Instruct" + +# Quantization (QLoRA) +load_in_4bit: true +bnb_4bit_quant_type: "nf4" +bnb_4bit_compute_dtype: "bfloat16" + +# LoRA +lora_r: 32 # increased from 16 +lora_alpha: 64 +lora_dropout: 0.05 +target_modules: + - "q_proj" + - "v_proj" + - "k_proj" + - "o_proj" + - "gate_proj" + - "up_proj" + - "down_proj" + +# Training hyperparameters +num_train_epochs: 5 +per_device_train_batch_size: 1 +per_device_eval_batch_size: 1 +gradient_accumulation_steps: 4 +learning_rate: 2.0e-4 +warmup_steps: 100 +logging_steps: 10 +save_steps: 1000 +eval_strategy: "steps" +eval_steps: 1000 +bf16: true +dataloader_num_workers: 0 +save_total_limit: 2 +report_to: "none" + +# --------------------------------------------------------------------------- +# Focal Loss gamma (set to 0.0 for standard CE, 1.0-2.0 for focal) +# --------------------------------------------------------------------------- +focal_gamma: 2.0 diff --git a/distillation/distill_wikontic.ipynb b/distillation/distill_wikontic.ipynb new file mode 100644 index 0000000..cced265 --- /dev/null +++ b/distillation/distill_wikontic.ipynb @@ -0,0 +1,1744 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-1", + "metadata": {}, + "source": [ + "# Distilling Wikontic Full Pipeline into SmolLM2-1.7B\n\n**Goal:** Train a small local model (SmolLM2-1.7B-Instruct) to replace the entire Wikontic pipeline -- taking raw text and producing ontology-aligned triplets in a single forward pass.\n\n**Data:**\n- datasets/hotpotqa200.json -- source texts (200 samples, ~10 paragraphs each)\n- datasets/kg_dump_hotpot_gpt4_1_onto_triplets.json -- ground-truth ontology-aligned triplets produced by GPT-4.1 via the full Wikontic pipeline\n\n**Approach:** QLoRA fine-tuning with trl.SFTTrainer. Each training example is a chat-formatted (text -> triplets) pair derived from the same prompt that Wikontic uses for extraction." + ] + }, + { + "cell_type": "code", + "id": "cell-2", + "metadata": { + "ExecuteTime": { + "end_time": "2026-04-30T21:40:00.852172Z", + "start_time": "2026-04-30T21:40:00.000330Z" + } + }, + "source": [ + "# Install missing dependencies (trl, peft, bitsandbytes, datasets)\n", + "! pip install -q trl peft bitsandbytes datasets\n" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "[notice] A new release of pip is available: 25.1.1 -> 26.0.1\n", + "[notice] To update, run: python.exe -m pip install --upgrade pip\n" + ] + } + ], + "execution_count": 1 + }, + { + "cell_type": "markdown", + "id": "cell-3", + "metadata": {}, + "source": [ + "## 1. Load and Prepare Data" + ] + }, + { + "cell_type": "code", + "id": "cell-4", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-02T17:27:02.978240Z", + "start_time": "2026-05-02T17:27:02.886727Z" + } + }, + "source": [ + "import json\n", + "from pathlib import Path\n", + "import os\n", + "import sys\n", + "os.environ['PYTHONUTF8'] = '1'\n", + "\n", + "HOTPOT_PATH = Path(\"../datasets/hotpotqa200.json\")\n", + "DUMP_PATH = Path(\"../datasets/kg_dump_hotpot_gpt4_1_onto_triplets.json\")\n", + "SYSTEM_PROMPT_PATH = Path(\"../src/wikontic/utils/prompts/triplet_extraction/propmt_1_types_qualifiers.txt\")\n", + "\n", + "OUTPUT_DIR = Path(\"./data\")\n", + "TRAIN_OUT = OUTPUT_DIR / \"train.jsonl\"\n", + "VAL_OUT = OUTPUT_DIR / \"val.jsonl\"\n", + "\n", + "CHECKPOINT_DIR = \"./checkpoints/wikontic-full-pipeline\"\n", + "\n", + "OUTPUT_DIR.mkdir(parents=True, exist_ok=True)\n", + "\n", + "# Load hotpotqa -- indexed by sample_id\n", + "with open(HOTPOT_PATH) as f:\n", + " hotpot = {s[\"_id\"]: s for s in json.load(f)}\n", + "\n", + "# Load kg_dump -- same structure: {sample_id: {source_id: {triplets, ...}}}\n", + "with open(DUMP_PATH) as f:\n", + " dump = json.load(f)\n", + "\n", + "print(f\"HotPotQA samples: {len(hotpot)}\")\n", + "print(f\"KG dump samples: {len(dump)}\")\n", + "print(f\"Overlapping IDs: {len(set(hotpot) & set(dump))}\")\n", + "\n", + "# Load system prompt\n", + "SYSTEM_PROMPT = open(SYSTEM_PROMPT_PATH, encoding=\"utf-8\").read()\n", + "print(f\"\\nSystem prompt length: {len(SYSTEM_PROMPT)} chars\")\n", + "\n" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "HotPotQA samples: 200\n", + "KG dump samples: 200\n", + "Overlapping IDs: 200\n", + "\n", + "System prompt length: 4034 chars\n" + ] + } + ], + "execution_count": 1 + }, + { + "cell_type": "markdown", + "id": "cell-5", + "metadata": {}, + "source": [ + "## 2. Inspect Data Structure" + ] + }, + { + "cell_type": "code", + "id": "cell-6", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-02T17:27:05.464639Z", + "start_time": "2026-05-02T17:27:05.460636Z" + } + }, + "source": [ + "# Inspect a single example\n", + "sample_id = list(dump.keys())[0]\n", + "sample = hotpot[sample_id]\n", + "entry = dump[sample_id][\"0\"] # first paragraph\n", + "\n", + "print(\"=== HotPotQA sample ===\")\n", + "print(\"Question:\", sample[\"question\"])\n", + "print(\"Answer:\", sample[\"answer\"])\n", + "print(\"Context count:\", len(sample[\"context\"]))\n", + "title, chunks = sample[\"context\"][0]\n", + "print(\"First paragraph title:\", title)\n", + "print(\"First paragraph text:\", \" \".join(chunks)[:200], \"...\")\n", + "\n", + "print(\"\\n=== KG dump for this paragraph ===\")\n", + "print(\"Triplets count:\", len(entry[\"triplets\"]))\n", + "for t in entry[\"triplets\"][:3]:\n", + " print(\" -\", t)" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== HotPotQA sample ===\n", + "Question: Which of these universities, Northwestern University or Johns Hopkins University, have a campus outside of the United States territories?\n", + "Answer: with other campuses located in Chicago and Doha, Qatar\n", + "Context count: 10\n", + "First paragraph title: Northwestern University\n", + "First paragraph text: Northwestern University (NU) is a private research university based in Evanston, Illinois, with other campuses located in Chicago and Doha, Qatar, and academic programs and facilities in Washington, D ...\n", + "\n", + "=== KG dump for this paragraph ===\n", + "Triplets count: 6\n", + " - {'object': 'private research university', 'object_type': 'educational institution', 'relation': 'instance of', 'subject': 'Northwestern University', 'subject_type': 'university', 'qualifiers': []}\n", + " - {'object': 'Evanston, Illinois', 'object_type': 'city', 'relation': 'headquarters location', 'subject': 'Northwestern University', 'subject_type': 'university', 'qualifiers': []}\n", + " - {'object': 'Chicago', 'object_type': 'city', 'relation': 'has part(s)', 'subject': 'Northwestern University', 'subject_type': 'university', 'qualifiers': []}\n" + ] + } + ], + "execution_count": 2 + }, + { + "cell_type": "markdown", + "id": "cell-7", + "metadata": {}, + "source": [ + "## 3. Build Training Examples" + ] + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-02T17:27:09.100724Z", + "start_time": "2026-05-02T17:27:09.066465Z" + } + }, + "cell_type": "code", + "source": [ + "def build_example(text: str, triplets: list, system_prompt: str) -> dict:\n", + " \"\"\"Format one text-triplets pair as chat messages for SFT training.\"\"\"\n", + " assistant_content = json.dumps({\"triplets\": triplets}, ensure_ascii=False)\n", + " messages = [\n", + " {\"role\": \"system\", \"content\": system_prompt},\n", + " {\"role\": \"user\", \"content\": f'Text: \"{text}\"'},\n", + " {\"role\": \"assistant\", \"content\": assistant_content},\n", + " ]\n", + " return {\"messages\": messages}\n", + "\n", + "\n", + "examples = []\n", + "skipped_empty = 0\n", + "\n", + "for sample_id, source_dict in dump.items():\n", + " if sample_id not in hotpot:\n", + " continue\n", + " sample = hotpot[sample_id]\n", + " context = sample[\"context\"] # list of [title, [text_segments]]\n", + "\n", + " for sid_str, entry in source_dict.items():\n", + " sid = int(sid_str)\n", + " if sid >= len(context):\n", + " continue\n", + "\n", + " title, text_segments = context[sid]\n", + " text = \" \".join(text_segments).strip()\n", + " triplets = entry.get(\"triplets\", [])\n", + "\n", + " if not text or not triplets:\n", + " skipped_empty += 1\n", + " continue\n", + "\n", + " examples.append(build_example(text, triplets, SYSTEM_PROMPT))\n", + "\n", + "print(f\"Total examples: {len(examples)}\")\n", + "print(f\"Skipped (empty text or triplets): {skipped_empty}\")\n" + ], + "id": "f88ea43dbe78c780", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total examples: 1999\n", + "Skipped (empty text or triplets): 0\n" + ] + } + ], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-02T17:27:12.611733Z", + "start_time": "2026-05-02T17:27:12.388717Z" + } + }, + "cell_type": "code", + "source": [ + "# Basic statistics\n", + "def count_triplets(example_text):\n", + " \"\"\"Extract JSON object from text and return triplet count.\"\"\"\n", + " try:\n", + " start = example_text.rfind('{\"triplets\":')\n", + " if start < 0:\n", + " return 0\n", + " json_start = example_text.find('[', start)\n", + " if json_start < 0:\n", + " return 0\n", + " depth = 1\n", + " pos = json_start + 1\n", + " while pos < len(example_text) and depth > 0:\n", + " c = example_text[pos]\n", + " if c == '[':\n", + " depth += 1\n", + " elif c == ']':\n", + " depth -= 1\n", + " pos += 1\n", + " if pos < len(example_text) and example_text[pos] == '}':\n", + " candidate = example_text[start:pos + 1]\n", + " return len(json.loads(candidate)['triplets'])\n", + " return 0\n", + " except Exception:\n", + " return 0\n", + "\n", + "triplet_counts = [count_triplets(e['messages'][2]['content']) for e in examples]\n", + "non_zero = sum(1 for c in triplet_counts if c > 0)\n", + "print(f\"Min / Max / Avg triplets per example: {min(triplet_counts)} / {max(triplet_counts)} / {sum(triplet_counts)/len(triplet_counts):.1f}\")\n", + "print(f\"Non-zero: {non_zero} / {len(triplet_counts)}\")\n", + "\n", + "# Show one formatted example\n", + "ex = examples[10]\n", + "print()\n", + "print(\"=== Example #10 (assistant output) ===\")\n", + "print(ex['messages'][2]['content'][:200])\n" + ], + "id": "6bef20c0f642d3bc", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Min / Max / Avg triplets per example: 1 / 48 / 11.2\n", + "Non-zero: 1999 / 1999\n", + "\n", + "=== Example #10 (assistant output) ===\n", + "{\"triplets\": [{\"subject_type\": \"human\", \"object_type\": \"social group\", \"relation\": \"part of\", \"subject\": \"K. Ravindran Nair\", \"object\": \"rich family\", \"qualifiers\": []}, {\"subject_type\": \"human\", \"obj\n" + ] + } + ], + "execution_count": 4 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 4. Train / Val Split and Save\n\n> **DEPRECATED:** This cell shuffles paragraphs ignoring `article_id`, which causes train/val entity leakage. \n> Use `split_data.py` instead for an article-level split:\n> ```bash\n> python split_data.py --train-ratio 0.8 --val-ratio 0.1 --test-ratio 0.1 --seed 42\n> ```", + "id": "d4d476826a8e96ce" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-02T17:27:16.220650Z", + "start_time": "2026-05-02T17:27:16.155868Z" + } + }, + "cell_type": "code", + "source": [ + "import random\n", + "\n", + "# WARNING: paragraph-level shuffle leaks entities across splits.\n", + "# Use split_data.py for article-level splitting.\n", + "\n", + "random.seed(42)\n", + "random.shuffle(examples)\n", + "\n", + "val_size = max(1, int(len(examples) * 0.1))\n", + "val_examples = examples[:val_size]\n", + "train_examples = examples[val_size:]\n", + "\n", + "def write_jsonl(path: Path, items: list):\n", + " with open(path, \"w\", encoding=\"utf-8\") as f:\n", + " for item in items:\n", + " f.write(json.dumps(item, ensure_ascii=False) + \"\\n\")\n", + "\n", + "write_jsonl(TRAIN_OUT, train_examples)\n", + "write_jsonl(VAL_OUT, val_examples)\n", + "\n", + "print(f\"Train: {len(train_examples)} | Val: {len(val_examples)}\")\n", + "print(f\"Saved to {TRAIN_OUT} and {VAL_OUT}\")" + ], + "id": "9a51b6d2c8faff7b", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: 1800 | Val: 199\n", + "Saved to data\\train.jsonl and data\\val.jsonl\n" + ] + } + ], + "execution_count": 5 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 5. Load Model -- SmolLM2-1.7B-Instruct with QLoRA", + "id": "8276ffacad22a9f" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-02T17:27:53.471594Z", + "start_time": "2026-05-02T17:27:20.476053Z" + } + }, + "cell_type": "code", + "source": [ + "import torch\n", + "from transformers import AutoTokenizer, AutoModelForCausalLM\n", + "from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training\n", + "from transformers import BitsAndBytesConfig\n", + "\n", + "BASE_MODEL = \"HuggingFaceTB/SmolLM2-1.7B-Instruct\"\n", + "\n", + "# 4-bit NF4 quantization\n", + "bnb_config = BitsAndBytesConfig(\n", + " load_in_4bit=True,\n", + " bnb_4bit_quant_type=\"nf4\",\n", + " bnb_4bit_compute_dtype=torch.bfloat16,\n", + ")\n", + "\n", + "print(\"Loading base model...\")\n", + "model = AutoModelForCausalLM.from_pretrained(\n", + " BASE_MODEL,\n", + " quantization_config=bnb_config,\n", + " device_map=\"auto\",\n", + ")\n", + "model = prepare_model_for_kbit_training(model)\n", + "\n", + "# LoRA adapter\n", + "lora_config = LoraConfig(\n", + " r=16,\n", + " lora_alpha=32,\n", + " lora_dropout=0.05,\n", + " target_modules=[\"q_proj\", \"v_proj\"],\n", + " task_type=\"CAUSAL_LM\",\n", + ")\n", + "model = get_peft_model(model, lora_config)\n", + "model.print_trainable_parameters()\n", + "\n", + "# Tokenizer\n", + "tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)\n", + "tokenizer.pad_token = tokenizer.eos_token" + ], + "id": "eb94982cd188921", + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\PycharmProjects\\Wikontic\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading base model...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Loading weights: 100%|██████████| 218/218 [00:03<00:00, 63.83it/s]\n", + "Warning: You are sending unauthenticated requests to the HF Hub. Please set a HF_TOKEN to enable higher rate limits and faster downloads.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 3,145,728 || all params: 1,714,522,112 || trainable%: 0.1835\n" + ] + } + ], + "execution_count": 6 + }, + { + "metadata": {}, + "cell_type": "markdown", + "source": "## 6. Configure and Run SFT Training", + "id": "54cbee74721621ea" + }, + { + "cell_type": "code", + "id": "cell-15", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-01T03:42:01.568793Z", + "start_time": "2026-04-30T21:40:07.180465Z" + } + }, + "source": [ + "# Fix encoding issue on Windows before importing trl\nfrom pathlib import Path\nimport sys\nsys.path.insert(0, str(Path(\".\").resolve()))\nimport trl_utf8_fix # noqa: E402\n\nfrom trl import SFTTrainer\nfrom trl import SFTConfig\nfrom datasets import load_dataset\n\nCHECKPOINT_DIR = \"./checkpoints/wikontic-full-pipeline\"\n\n# Load datasets\nfrom datasets import Dataset, DatasetDict\n\ndef load_jsonl(path):\n with open(path, \"r\", encoding=\"utf-8\") as f:\n return [json.loads(line) for line in f]\n\nds = DatasetDict({\n \"train\": Dataset.from_list(load_jsonl(TRAIN_OUT)),\n \"val\": Dataset.from_list(load_jsonl(VAL_OUT)),\n})\nprint(f\"Train: {len(ds['train'])} | Val: {len(ds['val'])}\")\n\n\n# Pre-process: split each example into prompt / completion columns.\n# This is required for completion_only_loss=True to work (it needs a\n# prompt-completion dataset, not a raw text formatter).\ndef split_prompt_completion(example):\n messages = example[\"messages\"]\n # Prompt: all turns up to (but not including) the assistant response,\n # with add_generation_prompt=True so the assistant header is included.\n prompt = tokenizer.apply_chat_template(\n messages[:-1],\n tokenize=False,\n add_generation_prompt=True,\n )\n # Full formatted conversation without a trailing generation prompt.\n full = tokenizer.apply_chat_template(\n messages,\n tokenize=False,\n add_generation_prompt=False,\n )\n # Completion is everything after the prompt prefix.\n completion = full[len(prompt):]\n # Ensure the completion ends with EOS so the model learns to stop.\n if not completion.endswith(tokenizer.eos_token):\n completion += tokenizer.eos_token\n return {\"prompt\": prompt, \"completion\": completion}\n\n\nds[\"train\"] = ds[\"train\"].map(split_prompt_completion, remove_columns=[\"messages\"])\nds[\"val\"] = ds[\"val\"].map(split_prompt_completion, remove_columns=[\"messages\"])\nprint(\"Prepared prompt/completion dataset.\")\n\n# Drop any examples where completion is empty (would produce NaN in eval loss)\ndef has_nonempty_completion(example):\n return bool(example.get(\"completion\", \"\").strip())\n\nds[\"train\"] = ds[\"train\"].filter(has_nonempty_completion)\nds[\"val\"] = ds[\"val\"].filter(has_nonempty_completion)\nprint(f\"After filtering empty completions -- Train: {len(ds['train'])} | Val: {len(ds['val'])}\")\n\n\n# Training arguments with completion-only loss\n# This ensures model only learns to predict assistant responses, not system/user prompts\ntraining_args = SFTConfig(\n output_dir=CHECKPOINT_DIR,\n num_train_epochs=3,\n per_device_train_batch_size=8,\n gradient_accumulation_steps=4, # effective batch = 32\n learning_rate=5e-5,\n lr_scheduler_type=\"cosine\",\n warmup_steps=100,\n max_grad_norm=0.3,\n bf16=True,\n logging_steps=10,\n eval_strategy=\"epoch\",\n save_strategy=\"epoch\",\n save_total_limit=1,\n report_to=\"none\",\n completion_only_loss=True, # KEY: Only train on assistant responses\n seed=42,\n)\n\n# Clamp extreme logits during eval to avoid bf16 overflow → NaN loss\ndef preprocess_logits_for_metrics(logits, labels):\n if isinstance(logits, tuple):\n logits = logits[0]\n # Cast to fp32 and clamp to a safe range before metrics/loss computation\n return logits.float().clamp(min=-50, max=50)\n\n# SFT Trainer - model is already a PeftModel\n# NOTE: We do NOT pass formatting_func because the dataset is already in\n# prompt-completion format, which SFTTrainer natively supports for\n# completion-only loss.\ntrainer = SFTTrainer(\n model=model,\n args=training_args,\n train_dataset=ds[\"train\"],\n eval_dataset=ds[\"val\"],\n processing_class=tokenizer,\n preprocess_logits_for_metrics=preprocess_logits_for_metrics,\n)\n\nprint(\"Starting training...\")\ntrainer.train()\n\n\n" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train: 1800 | Val: 199\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Map: 100%|██████████| 1800/1800 [00:00<00:00, 12014.54 examples/s]\n", + "Map: 100%|██████████| 199/199 [00:00<00:00, 18560.11 examples/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prepared prompt/completion dataset.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Adding EOS to train dataset: 100%|██████████| 1800/1800 [00:00<00:00, 71905.78 examples/s]\n", + "Tokenizing train dataset: 100%|██████████| 1800/1800 [00:04<00:00, 394.98 examples/s]\n", + "Adding EOS to eval dataset: 100%|██████████| 199/199 [00:00<00:00, 66317.06 examples/s]\n", + "Tokenizing eval dataset: 100%|██████████| 199/199 [00:00<00:00, 396.11 examples/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting training...\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [171/171 5:59:33, Epoch 3/3]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EpochTraining LossValidation Loss
11.082464nan
20.577714nan
30.449056nan

" + ] + }, + "metadata": {}, + "output_type": "display_data", + "jetTransient": { + "display_id": "caec808310342f201c4ccc54cd7c6448" + } + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=171, training_loss=0.7492968443541499, metrics={'train_runtime': 21707.2582, 'train_samples_per_second': 0.249, 'train_steps_per_second': 0.008, 'total_flos': 5.35439622537216e+16, 'train_loss': 0.7492968443541499})" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 8 + }, + { + "cell_type": "markdown", + "id": "cell-16", + "metadata": {}, + "source": [ + "## 7. Save Model" + ] + }, + { + "cell_type": "code", + "id": "cell-17", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-01T03:42:02.146586Z", + "start_time": "2026-05-01T03:42:01.668353Z" + } + }, + "source": [ + "trainer.save_model(CHECKPOINT_DIR)\n", + "tokenizer.save_pretrained(CHECKPOINT_DIR)\n", + "print(f\"Model saved to {CHECKPOINT_DIR}\")" + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model saved to ./checkpoints/wikontic-full-pipeline\n" + ] + } + ], + "execution_count": 9 + }, + { + "cell_type": "markdown", + "id": "cell-18", + "metadata": {}, + "source": [ + "## 8. Quick Validation -- Inference on a Few Examples" + ] + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-01T03:42:02.156095Z", + "start_time": "2026-05-01T03:42:02.151591Z" + } + }, + "cell_type": "code", + "source": "CHECKPOINT_DIR+\"/checkpoint-57\"", + "id": "b4e42d7e60b2d667", + "outputs": [ + { + "data": { + "text/plain": [ + "'./checkpoints/wikontic-full-pipeline/checkpoint-57'" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 10 + }, + { + "cell_type": "code", + "id": "cell-19", + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-02T17:30:06.866070Z", + "start_time": "2026-05-02T17:27:53.477598Z" + } + }, + "source": [ + "from peft import PeftModel\n", + "import re\n", + "\n", + "\n", + "def extract_triplets(text):\n", + " \"\"\"Extract triplets from model output, handling complete and partial JSON.\"\"\"\n", + " # Attempt 1: Clean trailing garbage and parse full JSON\n", + " cleaned = text.rstrip(\".\")\n", + " try:\n", + " data = json.loads(cleaned)\n", + " if isinstance(data, dict) and \"triplets\" in data:\n", + " return data\n", + " except (json.JSONDecodeError, TypeError):\n", + " pass\n", + "\n", + " # Attempt 2: Find JSON object with a \"triplets\" key anywhere in the text\n", + " # Greedy match from first '{' to last '}' that makes a valid dict\n", + " start = text.find(\"{\")\n", + " end = text.rfind(\"}\")\n", + " if start != -1 and end != -1 and end > start:\n", + " for candidate in [text[start:end+1], text[start:end+1].rstrip(\".\")]:\n", + " try:\n", + " data = json.loads(candidate)\n", + " if isinstance(data, dict) and \"triplets\" in data:\n", + " return data\n", + " except (json.JSONDecodeError, TypeError):\n", + " pass\n", + "\n", + " # Attempt 3: Use brace-depth extraction for nested structures\n", + " candidates = []\n", + " for i, ch in enumerate(text):\n", + " if ch == \"{\":\n", + " depth = 1\n", + " for j in range(i + 1, len(text)):\n", + " if text[j] == \"{\":\n", + " depth += 1\n", + " elif text[j] == \"}\":\n", + " depth -= 1\n", + " if depth == 0:\n", + " candidates.append(text[i:j+1])\n", + " break\n", + "\n", + " triplets = []\n", + " seen = set()\n", + " for candidate in candidates:\n", + " # Quick heuristic: must mention subject, relation, object\n", + " if '\"subject\"' not in candidate or '\"relation\"' not in candidate or '\"object\"' not in candidate:\n", + " continue\n", + " try:\n", + " obj = json.loads(candidate)\n", + " if isinstance(obj, dict) and all(k in obj for k in (\"subject\", \"relation\", \"object\")):\n", + " key = (obj.get(\"subject\"), obj.get(\"relation\"), obj.get(\"object\"))\n", + " if key not in seen:\n", + " seen.add(key)\n", + " triplets.append(obj)\n", + " except (json.JSONDecodeError, TypeError):\n", + " pass\n", + "\n", + " if triplets:\n", + " return {\"triplets\": triplets}\n", + "\n", + " return None\n", + "\n", + "def inference(text, max_new_tokens=2048):\n", + " \"\"\"Run the student model on a single text.\"\"\"\n", + " messages = [\n", + " {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n", + " {\"role\": \"user\", \"content\": f'Text: \"{text}\"'},\n", + " ]\n", + " prompt = tokenizer.apply_chat_template(\n", + " messages, \n", + " tokenize=False, \n", + " add_generation_prompt=True\n", + " )\n", + " inputs = tokenizer(prompt, return_tensors=\"pt\").to(model.device)\n", + "\n", + " with torch.no_grad():\n", + " output = model.generate(\n", + " **inputs,\n", + " max_new_tokens=max_new_tokens,\n", + " temperature=0.0,\n", + " do_sample=False,\n", + " pad_token_id=tokenizer.pad_token_id,\n", + " eos_token_id=tokenizer.eos_token_id,\n", + " )\n", + "\n", + " full_output = tokenizer.decode(output[0], skip_special_tokens=True)\n", + "\n", + " print(\"Full output:\", full_output)\n", + " \n", + " # Extract assistant portion (after assistant role marker)\n", + " marker = \"assistant\\n\"\n", + " marker_pos = full_output.find(marker)\n", + " if marker_pos >= 0:\n", + " answer = full_output[marker_pos + len(marker):].strip()\n", + " else:\n", + " # Fallback: remove prompt portion\n", + " answer = full_output[len(prompt):].strip()\n", + "\n", + " # Remove any trailing system/user turns if model hallucinated them\n", + " for turn_marker in [\"<|im_start|>user\", \"<|im_start|>system\"]:\n", + " pos = answer.find(turn_marker)\n", + " if pos >= 0:\n", + " answer = answer[:pos].strip()\n", + " \n", + " print(\"Model answer (first 500 chars):\\n\", answer[:500])\n", + " \n", + " return extract_triplets(answer)\n", + "\n", + "\n", + "pred_results = []\n", + "# Run on 3 val examples\n", + "for i in range(3):\n", + " ex = val_examples[i]\n", + " # Extract text from messages\n", + " text = ex[\"messages\"][1][\"content\"].replace('Text: \"', '').rstrip('\"')\n", + " \n", + " # Extract ground truth triplets\n", + " gt_text = ex[\"messages\"][2][\"content\"]\n", + " # Remove EOS token if present\n", + " gt_text = gt_text.replace(tokenizer.eos_token, \"\")\n", + " gt_parsed = extract_triplets(gt_text)\n", + " gt_triplets = gt_parsed['triplets'] if gt_parsed else []\n", + "\n", + " pred = inference(text)\n", + "\n", + " pred_results.append(pred)\n", + " print(f\"--- Example {i} ---\")\n", + " print(f\"Ground truth triplets ({len(gt_triplets)}):\")\n", + " for t in gt_triplets[:3]:\n", + " print(f\" {t['subject']} | {t['relation']} | {t['object']}\")\n", + " print(f\"\\nPredicted (valid JSON: {pred is not None}):\")\n", + " if pred and \"triplets\" in pred:\n", + " for t in pred[\"triplets\"][:3]:\n", + " print(f\" {t.get('subject','?')} | {t.get('relation','?')} | {t.get('object','?')}\")\n", + " else:\n", + " print(\" (failed to parse or no triplets)\")\n", + " print()\n" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The following generation flags are not valid and may be ignored: ['temperature']. Set `TRANSFORMERS_VERBOSITY=info` for more details.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Full output: system\n", + "You are an algorithm designed to extract structured knowledge from texts to build a Wikidata-like knowledge graph. A knowledge graph consists of **triplets** in the format (subject, relation, object), where:\n", + "\n", + "- **Subject**: A named entity or a concept that describes a group of people, events, or any abstract objects that serves as the source of the relation.\n", + "- **Relation**: A Wikidata-style predicate that connects the subject and object.\n", + "- **Object**: A named entity or a concept that describes a group of people, events, or any abstract objects that is related to the subject.\n", + "\n", + "Additionally, some triplets may have **qualifiers** that provide more context (e.g., date, place, or other attributes). Qualifiers should have relations and object like triplets do, but instead of subject their relation connects an object and the triplet qualifier belongs to. **Qualifiers must always be attached to a triplet** and never exist as standalone triplets.\n", + "\n", + "You will receive a text labeled **\"Text:\"**. Your task is to extract meaningful triplets that represent factual relationships.\n", + "\n", + "### Output Format\n", + "Return only triplets in **JSON format** as a list of dictionaries, where each dictionary contains:\n", + "- \"subject\": Subject entity. \n", + "- \"relation\": Relation connecting subject and object. \n", + "- \"object\": Object entity. \n", + "- \"qualifiers\": List of dictionaries, where each dictionary contains:\n", + " - \"relation\": Relation connecting triplet and object,\n", + " - \"object\": Object entity connected to the main triplet\n", + "- \"subject_type\": a class that describes the subject \n", + "- \"object_type\": a class that describes the object \n", + "\n", + "NO additional text, NO \"```\" in json, ONLY triplets in JSON format.\n", + "\n", + "\n", + "\n", + "### Input: \n", + " Text: \"Marie Curie (7 November 1867 - 4 July 1934) was a physicist and chemist who conducted pioneering research on radioactivity. She received the Nobel Prize in Physics in 1903 and the Nobel Prize in Chemistry in 1911. \n", + "### Output: \n", + " {\n", + " \"triplets\":\n", + " [\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"date of birth\",\n", + " \"object\": \"7 November 1867\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"date\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"date of death\",\n", + " \"object\": \"4 July 1934\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"date\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"physicist\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"chemist\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"field of work\",\n", + " \"object\": \"radioactivity\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"physical phenomenon\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"award received\",\n", + " \"object\": \"Nobel Prize in Physics\",\n", + " \"qualifiers\": [{\"relation\": \"point in time\", \"object\": '1903'}],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"award\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"award received\",\n", + " \"object\": \"Nobel Prize in Chemistry\",\n", + " \"qualifiers\": [{\"relation\": \"point in time\", \"object\": \"1911\"}],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"award\"\n", + " }\n", + " ]\n", + " }\n", + "\n", + "\n", + "user\n", + "Text: \"The 1991 Currie Cup (known as the \"Bankfin Currie Cup\" for sponsorship reasons) was the top division of the Currie Cup competition, the premier domestic rugby union competition in South Africa. This was the 53rd season since the competition started in 1889 and the first time it was known as the Bankfin Currie Cup, following the sponsors' name change from Santam Bank.\"\n", + "assistant\n", + "\n", + "### Input: \n", + " Text: \"The 1991 Currie Cup (known as the \"Bankfin Currie Cup\" for sponsorship reasons) was the top division of the Currie Cup competition, the premier domestic rugby union competition in South Africa. This was the 53rd season since the competition started in 1889 and the first time it was known as the Bankfin Currie Cup, following the sponsors' name change from Santam Bank.\"\n", + "\n", + "### Output:\n", + "{\n", + " \"triplets\": [\n", + " {\n", + " \"subject\": \"1991\",\n", + " \"relation\": \"year\",\n", + " \"object\": \"1991\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"integer\",\n", + " \"object_type\": \"year\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"Bankfin Currie Cup\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"premier domestic rugby union competition\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"top division\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"South Africa\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"premier domestic rugby union competition in South Africa\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"1889\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"season\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"53rd\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"season\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"1991\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"season\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"Bankfin\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"Bankfin\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"Bankfin\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"season\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"season\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"season\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\",\n", + " \"relation\": \"name\",\n", + " \"object\": \"year\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"string\",\n", + " \"object_type\": \"string\"\n", + " },\n", + " {\n", + " \"subject\": \"Currie Cup\n", + "Model answer (first 500 chars):\n", + " \n", + "### Input: \n", + " Text: \"The 1991 Currie Cup (known as the \"Bankfin Currie Cup\" for sponsorship reasons) was the top division of the Currie Cup competition, the premier domestic rugby union competition in South Africa. This was the 53rd season since the competition started in 1889 and the first time it was known as the Bankfin Currie Cup, following the sponsors' name change from Santam Bank.\"\n", + "\n", + "### Output:\n", + "{\n", + " \"triplets\": [\n", + " {\n", + " \"subject\": \"1991\",\n", + " \"relation\":\n", + "--- Example 0 ---\n", + "Ground truth triplets (9):\n", + " 1991 Currie Cup | instance of | Currie Cup season\n", + " 1991 Currie Cup | quantity | 53\n", + " 1991 Currie Cup | part of | Currie Cup\n", + "\n", + "Predicted (valid JSON: True):\n", + " 1991 | year | 1991\n", + " Currie Cup | name | Bankfin Currie Cup\n", + " Currie Cup | name | premier domestic rugby union competition\n", + "\n", + "Full output: system\n", + "You are an algorithm designed to extract structured knowledge from texts to build a Wikidata-like knowledge graph. A knowledge graph consists of **triplets** in the format (subject, relation, object), where:\n", + "\n", + "- **Subject**: A named entity or a concept that describes a group of people, events, or any abstract objects that serves as the source of the relation.\n", + "- **Relation**: A Wikidata-style predicate that connects the subject and object.\n", + "- **Object**: A named entity or a concept that describes a group of people, events, or any abstract objects that is related to the subject.\n", + "\n", + "Additionally, some triplets may have **qualifiers** that provide more context (e.g., date, place, or other attributes). Qualifiers should have relations and object like triplets do, but instead of subject their relation connects an object and the triplet qualifier belongs to. **Qualifiers must always be attached to a triplet** and never exist as standalone triplets.\n", + "\n", + "You will receive a text labeled **\"Text:\"**. Your task is to extract meaningful triplets that represent factual relationships.\n", + "\n", + "### Output Format\n", + "Return only triplets in **JSON format** as a list of dictionaries, where each dictionary contains:\n", + "- \"subject\": Subject entity. \n", + "- \"relation\": Relation connecting subject and object. \n", + "- \"object\": Object entity. \n", + "- \"qualifiers\": List of dictionaries, where each dictionary contains:\n", + " - \"relation\": Relation connecting triplet and object,\n", + " - \"object\": Object entity connected to the main triplet\n", + "- \"subject_type\": a class that describes the subject \n", + "- \"object_type\": a class that describes the object \n", + "\n", + "NO additional text, NO \"```\" in json, ONLY triplets in JSON format.\n", + "\n", + "\n", + "\n", + "### Input: \n", + " Text: \"Marie Curie (7 November 1867 - 4 July 1934) was a physicist and chemist who conducted pioneering research on radioactivity. She received the Nobel Prize in Physics in 1903 and the Nobel Prize in Chemistry in 1911. \n", + "### Output: \n", + " {\n", + " \"triplets\":\n", + " [\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"date of birth\",\n", + " \"object\": \"7 November 1867\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"date\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"date of death\",\n", + " \"object\": \"4 July 1934\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"date\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"physicist\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"chemist\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"field of work\",\n", + " \"object\": \"radioactivity\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"physical phenomenon\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"award received\",\n", + " \"object\": \"Nobel Prize in Physics\",\n", + " \"qualifiers\": [{\"relation\": \"point in time\", \"object\": '1903'}],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"award\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"award received\",\n", + " \"object\": \"Nobel Prize in Chemistry\",\n", + " \"qualifiers\": [{\"relation\": \"point in time\", \"object\": \"1911\"}],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"award\"\n", + " }\n", + " ]\n", + " }\n", + "\n", + "\n", + "user\n", + "Text: \"Khalid Latif is Executive Director and Chaplain (Imam) for the Islamic Center at New York University (NYU).\"\n", + "assistant\n", + "\n", + "### Input: \n", + " Text: \"Khalid Latif is Executive Director and Chaplain (Imam) for the Islamic Center at New York University (NYU).\"\n", + "### Output:\n", + " {\n", + " \"triplets\":\n", + " [\n", + " {\n", + " \"subject\": \"Khalid Latif\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"Executive Director and Chaplain (Imam) for the Islamic Center at New York University (NYU).\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " }\n", + " ]\n", + " }\n", + "\n", + "Model answer (first 500 chars):\n", + " \n", + "### Input: \n", + " Text: \"Khalid Latif is Executive Director and Chaplain (Imam) for the Islamic Center at New York University (NYU).\"\n", + "### Output:\n", + " {\n", + " \"triplets\":\n", + " [\n", + " {\n", + " \"subject\": \"Khalid Latif\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"Executive Director and Chaplain (Imam) for the Islamic Center at New York University (NYU).\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"\n", + "--- Example 1 ---\n", + "Ground truth triplets (3):\n", + " Khalid Latif | position held | Executive Director\n", + " Khalid Latif | position held | Chaplain (Imam)\n", + " Islamic Center at New York University | part of | New York University\n", + "\n", + "Predicted (valid JSON: True):\n", + " Khalid Latif | occupation | Executive Director and Chaplain (Imam) for the Islamic Center at New York University (NYU).\n", + "\n", + "Full output: system\n", + "You are an algorithm designed to extract structured knowledge from texts to build a Wikidata-like knowledge graph. A knowledge graph consists of **triplets** in the format (subject, relation, object), where:\n", + "\n", + "- **Subject**: A named entity or a concept that describes a group of people, events, or any abstract objects that serves as the source of the relation.\n", + "- **Relation**: A Wikidata-style predicate that connects the subject and object.\n", + "- **Object**: A named entity or a concept that describes a group of people, events, or any abstract objects that is related to the subject.\n", + "\n", + "Additionally, some triplets may have **qualifiers** that provide more context (e.g., date, place, or other attributes). Qualifiers should have relations and object like triplets do, but instead of subject their relation connects an object and the triplet qualifier belongs to. **Qualifiers must always be attached to a triplet** and never exist as standalone triplets.\n", + "\n", + "You will receive a text labeled **\"Text:\"**. Your task is to extract meaningful triplets that represent factual relationships.\n", + "\n", + "### Output Format\n", + "Return only triplets in **JSON format** as a list of dictionaries, where each dictionary contains:\n", + "- \"subject\": Subject entity. \n", + "- \"relation\": Relation connecting subject and object. \n", + "- \"object\": Object entity. \n", + "- \"qualifiers\": List of dictionaries, where each dictionary contains:\n", + " - \"relation\": Relation connecting triplet and object,\n", + " - \"object\": Object entity connected to the main triplet\n", + "- \"subject_type\": a class that describes the subject \n", + "- \"object_type\": a class that describes the object \n", + "\n", + "NO additional text, NO \"```\" in json, ONLY triplets in JSON format.\n", + "\n", + "\n", + "\n", + "### Input: \n", + " Text: \"Marie Curie (7 November 1867 - 4 July 1934) was a physicist and chemist who conducted pioneering research on radioactivity. She received the Nobel Prize in Physics in 1903 and the Nobel Prize in Chemistry in 1911. \n", + "### Output: \n", + " {\n", + " \"triplets\":\n", + " [\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"date of birth\",\n", + " \"object\": \"7 November 1867\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"date\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"date of death\",\n", + " \"object\": \"4 July 1934\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"date\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"physicist\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"chemist\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"field of work\",\n", + " \"object\": \"radioactivity\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"physical phenomenon\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"award received\",\n", + " \"object\": \"Nobel Prize in Physics\",\n", + " \"qualifiers\": [{\"relation\": \"point in time\", \"object\": '1903'}],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"award\"\n", + " },\n", + " {\n", + " \"subject\": \"Marie Curie\",\n", + " \"relation\": \"award received\",\n", + " \"object\": \"Nobel Prize in Chemistry\",\n", + " \"qualifiers\": [{\"relation\": \"point in time\", \"object\": \"1911\"}],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"award\"\n", + " }\n", + " ]\n", + " }\n", + "\n", + "\n", + "user\n", + "Text: \"Suhotra Swami or Suhotra Dasa (born Roger Terrence Crowley, December 11, 1950, Holyoke, Massachusetts – April 8, 2007, Mayapur, India) was a Hindu Vaishnava author, philosopher and a leading guru in the International Society of Krishna Consciousness (ISKCON). He was ISKCON's Governing Body Commissioner (GBC), an initiating spiritual master (diksa guru) and a sannyasi in ISKCON. He also served as a chairman of the GBC. Since joining ISKCON Suhotra Swami has spent much of his time lecturing and teaching in Europe, especially in Germany and Eastern European countries. Suhotra Swami authored several books on Gaudiya Vaishnava philosophy and Vedanta.\"\n", + "assistant\n", + "\n", + "### Input: \n", + " Text: \"Suhotra Swami or Suhotra Dasa (born Roger Terrence Crowley, December 11, 1950, Holyoke, Massachusetts – April 8, 2007, Mayapur, India) was a Hindu Vaishnava author, philosopher and a leading guru in the International Society of Krishna Consciousness (ISKCON). He was ISKCON's Governing Body Commissioner (GBC), an initiating spiritual master (diksa guru) and a sannyasi in ISKCON. He also served as a chairman of the GBC. Since joining ISKCON Suhotra Swami has spent much of his time lecturing and teaching in Europe, especially in Germany and Eastern European countries. Suhotra Swami authored several books on Gaudiya Vaishnava philosophy and Vedanta.\"\n", + "\n", + "### Output:\n", + "{\n", + " \"triplets\": [\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"philosopher\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"spiritual master\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"teacher\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"chairman of the GBC\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"position\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"chairman of the GBC\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"position\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\": \"occupation\",\n", + " \"object\": \"author\",\n", + " \"qualifiers\": [],\n", + " \"subject_type\": \"human\",\n", + " \"object_type\": \"profession\"\n", + " },\n", + " {\n", + " \"subject\": \"Suhotra Swami\",\n", + " \"relation\n", + "Model answer (first 500 chars):\n", + " \n", + "### Input: \n", + " Text: \"Suhotra Swami or Suhotra Dasa (born Roger Terrence Crowley, December 11, 1950, Holyoke, Massachusetts – April 8, 2007, Mayapur, India) was a Hindu Vaishnava author, philosopher and a leading guru in the International Society of Krishna Consciousness (ISKCON). He was ISKCON's Governing Body Commissioner (GBC), an initiating spiritual master (diksa guru) and a sannyasi in ISKCON. He also served as a chairman of the GBC. Since joining ISKCON Suhotra Swami has spent\n", + "--- Example 2 ---\n", + "Ground truth triplets (19):\n", + " Suhotra Swami | different from | Suhotra Dasa\n", + " Suhotra Swami | named after | Roger Terrence Crowley\n", + " Suhotra Swami | date of birth | December 11, 1950\n", + "\n", + "Predicted (valid JSON: True):\n", + " Suhotra Swami | occupation | author\n", + " Suhotra Swami | occupation | philosopher\n", + " Suhotra Swami | occupation | spiritual master\n", + "\n" + ] + } + ], + "execution_count": 7 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "5775bd875914f4a4" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.11.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/distillation/how_to_run.md b/distillation/how_to_run.md new file mode 100644 index 0000000..91b275f --- /dev/null +++ b/distillation/how_to_run.md @@ -0,0 +1,23 @@ +## How to run distillation +First change directory to distillation: +``` +cd distillation +``` +1. Prepare data:
+You can change HOTPOT_PATH and DUMP_PATH in split_data.py +
+then run: +``` +python split_data.py --train-ratio 0.8 --val-ratio 0.1 --test-ratio 0.1 --seed 42 +``` +2. To train + +``` +python train.py --config configs/train.yaml +``` + +3. To infer (evaluate)
+You can choose either _val_ or test _split_ +``` +python infer.py --config configs/infer.yaml --split test +``` diff --git a/distillation/infer.py b/distillation/infer.py new file mode 100644 index 0000000..94f6b74 --- /dev/null +++ b/distillation/infer.py @@ -0,0 +1,705 @@ +""" +Inference & evaluation script for Wikontic distillation — v2. + +Runs the fine-tuned model on validation data, parses predicted triplets, +applies whitelist constraints, and produces a detailed comparison report +including distribution analysis, per-relation P/R/F1, subject/object +hallucination, partial-match metrics, and confused-relation analysis. +""" +import argparse +import json +import re +from collections import Counter, defaultdict +from difflib import SequenceMatcher +from pathlib import Path +from typing import Any, Dict, List, Optional, Set, Tuple + +import torch +import yaml +from peft import PeftModel +from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig + + +def load_yaml_config(path: str) -> Dict[str, Any]: + with open(path, "r", encoding="utf-8") as f: + return yaml.safe_load(f) + + +def load_jsonl(path: Path) -> List[Dict[str, Any]]: + examples = [] + with open(path, "r", encoding="utf-8") as f: + for line in f: + examples.append(json.loads(line)) + return examples + + +def extract_whitelist(train_examples: List[Dict[str, Any]]) -> Dict[str, Set[str]]: + """Extract unique relations, subject_types, and object_types from training data.""" + relations: Set[str] = set() + subject_types: Set[str] = set() + object_types: Set[str] = set() + for ex in train_examples: + try: + parsed = json.loads(ex["messages"][2]["content"]) + for t in parsed.get("triplets", []): + if t.get("relation"): + relations.add(t["relation"]) + if t.get("subject_type"): + subject_types.add(t["subject_type"]) + if t.get("object_type"): + object_types.add(t["object_type"]) + except (json.JSONDecodeError, IndexError, KeyError): + pass + return { + "relations": relations, + "subject_types": subject_types, + "object_types": object_types, + } + + +def _similar(a: str, b: str) -> float: + """Case-insensitive string similarity ratio.""" + return SequenceMatcher(None, a.lower(), b.lower()).ratio() + + +def apply_whitelist( + triplets: List[Dict[str, Any]], + whitelist: Dict[str, Set[str]], + soft_mapping: bool = True, + min_similarity: float = 0.6, +) -> Tuple[List[Dict[str, Any]], Dict[str, int]]: + """ + Filter triplets against training whitelist. + + * Dropping unknown relations entirely. + * If ``soft_mapping=True``, map unknown relations to the most similar + valid relation when similarity >= ``min_similarity``. + * Type mismatches are mapped when possible but never cause dropping. + + Returns (valid_triplets, stats). + """ + valid_relations = whitelist.get("relations", set()) + valid_subj_types = whitelist.get("subject_types", set()) + valid_obj_types = whitelist.get("object_types", set()) + + valid: List[Dict[str, Any]] = [] + stats: Dict[str, int] = defaultdict(int) + for t in triplets: + rel = t.get("relation", "") + st = t.get("subject_type", "") + ot = t.get("object_type", "") + + # --- relation --- + mapped_rel = rel + if rel not in valid_relations: + if soft_mapping and valid_relations: + best = max(valid_relations, key=lambda v: _similar(rel, v)) + if _similar(rel, best) >= min_similarity: + mapped_rel = best + stats["relation_soft_mapped"] += 1 + else: + stats["relation_dropped"] += 1 + continue + else: + stats["relation_dropped"] += 1 + continue + + # --- types (try to map, but never drop) --- + mapped_st = st + if st and st not in valid_subj_types: + if soft_mapping and valid_subj_types: + best = max(valid_subj_types, key=lambda v: _similar(st, v)) + if _similar(st, best) >= min_similarity: + mapped_st = best + stats["subject_type_mapped"] += 1 + + mapped_ot = ot + if ot and ot not in valid_obj_types: + if soft_mapping and valid_obj_types: + best = max(valid_obj_types, key=lambda v: _similar(ot, v)) + if _similar(ot, best) >= min_similarity: + mapped_ot = best + stats["object_type_mapped"] += 1 + + new_t = dict(t) + new_t["relation"] = mapped_rel + new_t["subject_type"] = mapped_st + new_t["object_type"] = mapped_ot + valid.append(new_t) + + return valid, dict(stats) + + +def parse_completion_triplets(example: Dict[str, Any]) -> List[Dict[str, Any]]: + """Extract triplets from the completion field of a chat example.""" + try: + completion = example["messages"][2]["content"] + data = json.loads(completion) + if isinstance(data, dict) and "triplets" in data: + return data["triplets"] + except (json.JSONDecodeError, TypeError, IndexError, KeyError): + pass + return [] + + +def robust_extract_triplets(text: str) -> Optional[Dict[str, Any]]: + """Robust triplet extractor with multiple fallback strategies.""" + cleaned = text.rstrip(". \n\t") + try: + data = json.loads(cleaned) + if isinstance(data, dict) and "triplets" in data: + return data + except (json.JSONDecodeError, TypeError): + pass + + # Attempt 2: find all JSON objects via brace-depth matching + candidates = [] + for i, ch in enumerate(text): + if ch == "{": + depth = 1 + for j in range(i + 1, len(text)): + if text[j] == "{": + depth += 1 + elif text[j] == "}": + depth -= 1 + if depth == 0: + candidates.append(text[i : j + 1]) + break + + triplets = [] + seen = set() + for candidate in candidates: + if '"subject"' not in candidate or '"relation"' not in candidate or '"object"' not in candidate: + continue + try: + obj = json.loads(candidate) + if isinstance(obj, dict) and all(k in obj for k in ("subject", "relation", "object")): + key = (obj.get("subject"), obj.get("relation"), obj.get("object")) + if key not in seen: + seen.add(key) + triplets.append(obj) + except (json.JSONDecodeError, TypeError): + pass + + if triplets: + return {"triplets": triplets} + + # Attempt 3: largest top-level dict + start = text.find("{") + end = text.rfind("}") + if start != -1 and end != -1 and end > start: + for candidate in [text[start : end + 1], text[start : end + 1].rstrip(".")]: + try: + data = json.loads(candidate) + if isinstance(data, dict) and "triplets" in data: + return data + except (json.JSONDecodeError, TypeError): + pass + return None + + +def triplet_key_full(t: Dict[str, Any]) -> Tuple: + return ( + t.get("subject", ""), + t.get("relation", ""), + t.get("object", ""), + t.get("subject_type", ""), + t.get("object_type", ""), + ) + + +def triplet_key_sro(t: Dict[str, Any]) -> Tuple: + """Subject-Relation-Object key (ignores types).""" + return ( + t.get("subject", ""), + t.get("relation", ""), + t.get("object", ""), + ) + + +def compute_metrics( + gt_triplets: List[Dict], + pred_triplets: List[Dict], + key_fn=triplet_key_full, +) -> Dict[str, Any]: + gt_set = set(key_fn(t) for t in gt_triplets) + pred_set = set(key_fn(t) for t in pred_triplets) + tp = len(gt_set & pred_set) + precision = tp / len(pred_set) if pred_set else 0.0 + recall = tp / len(gt_set) if gt_set else 0.0 + f1 = (2 * precision * recall / (precision + recall)) if (precision + recall) > 0 else 0.0 + return { + "tp": tp, + "precision": precision, + "recall": recall, + "f1": f1, + "gt_count": len(gt_set), + "pred_count": len(pred_set), + } + + +def compute_relation_metrics( + gt_examples: List[List[Dict]], + pred_examples: List[List[Dict]], + key_fn=triplet_key_full, +) -> Dict[str, Dict[str, Any]]: + stats: Dict[str, Dict[str, Any]] = {} + for gt_triplets, pred_triplets in zip(gt_examples, pred_examples): + gt_by_rel: Dict[str, set] = {} + for t in gt_triplets: + r = t.get("relation", "UNKNOWN") + gt_by_rel.setdefault(r, set()).add(key_fn(t)) + pred_by_rel: Dict[str, set] = {} + for t in pred_triplets: + r = t.get("relation", "UNKNOWN") + pred_by_rel.setdefault(r, set()).add(key_fn(t)) + all_rels = set(gt_by_rel.keys()) | set(pred_by_rel.keys()) + for r in all_rels: + if r not in stats: + stats[r] = {"tp": 0, "gt": 0, "pred": 0} + gt_set = gt_by_rel.get(r, set()) + pred_set = pred_by_rel.get(r, set()) + stats[r]["tp"] += len(gt_set & pred_set) + stats[r]["gt"] += len(gt_set) + stats[r]["pred"] += len(pred_set) + results = {} + for r, s in stats.items(): + p = s["tp"] / s["pred"] if s["pred"] else 0.0 + rec = s["tp"] / s["gt"] if s["gt"] else 0.0 + f1 = (2 * p * rec / (p + rec)) if (p + rec) > 0 else 0.0 + results[r] = {"precision": p, "recall": rec, "f1": f1, "support_gt": s["gt"], "support_pred": s["pred"]} + return results + + +def extract_text_from_prompt(prompt_content: str) -> str: + """Strip the 'Text: "..."' wrapper used in the dataset.""" + m = re.search(r'Text:\s*"((?:[^"\\]|\\.)*?)"', prompt_content) + if m: + return m.group(1) + return prompt_content + + +def compute_hallucination_stats( + texts: List[str], + pred_examples: List[List[Dict]], +) -> Dict[str, Any]: + """ + For each predicted triplet, check whether subject / object strings + appear (at word level) in the source text. + """ + text_words = [set(re.findall(r"\b\w+\b", text.lower())) for text in texts] + + subj_hallucinated = 0 + obj_hallucinated = 0 + subj_total = 0 + obj_total = 0 + + for text_words_set, pred_triplets in zip(text_words, pred_examples): + for t in pred_triplets: + subj = t.get("subject", "").lower() + obj = t.get("object", "").lower() + + subj_words = set(re.findall(r"\b\w+\b", subj)) + obj_words = set(re.findall(r"\b\w+\b", obj)) + + # Consider hallucinated if NONE of the entity's words appear in text + if subj_words and not subj_words.intersection(text_words_set): + subj_hallucinated += 1 + subj_total += 1 + + if obj_words and not obj_words.intersection(text_words_set): + obj_hallucinated += 1 + obj_total += 1 + + return { + "subject_hallucination_rate": subj_hallucinated / subj_total if subj_total else 0.0, + "object_hallucination_rate": obj_hallucinated / obj_total if obj_total else 0.0, + "subject_hallucinated_count": subj_hallucinated, + "object_hallucinated_count": obj_hallucinated, + "total_triplets_checked": subj_total, + } + + +def find_confused_relations( + gt_examples: List[List[Dict]], + pred_examples: List[List[Dict]], + top_k: int = 10, +) -> List[Tuple[Tuple[str, str], int]]: + """ + Find the most common (gt_relation, pred_relation) mismatches. + Only counts cases where subject & object match but relation differs. + """ + confusion = Counter() + for gt_triplets, pred_triplets in zip(gt_examples, pred_examples): + gt_map = {} + for t in gt_triplets: + key = (t.get("subject", ""), t.get("object", "")) + gt_map[key] = t.get("relation", "UNKNOWN") + + for t in pred_triplets: + key = (t.get("subject", ""), t.get("object", "")) + pred_rel = t.get("relation", "UNKNOWN") + if key in gt_map: + gt_rel = gt_map[key] + if gt_rel != pred_rel: + confusion[(gt_rel, pred_rel)] += 1 + + return confusion.most_common(top_k) + + +def compute_type_accuracy( + gt_examples: List[List[Dict]], + pred_examples: List[List[Dict]], +) -> Dict[str, Any]: + """Compute per-type accuracy for subject_type and object_type on SRO matches.""" + subj_type_tp = 0 + subj_type_total = 0 + obj_type_tp = 0 + obj_type_total = 0 + + for gt_triplets, pred_triplets in zip(gt_examples, pred_examples): + gt_map = {triplet_key_sro(t): t for t in gt_triplets} + for t in pred_triplets: + key = triplet_key_sro(t) + if key in gt_map: + gt_t = gt_map[key] + if t.get("subject_type") == gt_t.get("subject_type"): + subj_type_tp += 1 + subj_type_total += 1 + if t.get("object_type") == gt_t.get("object_type"): + obj_type_tp += 1 + obj_type_total += 1 + + return { + "subject_type_accuracy": subj_type_tp / subj_type_total if subj_type_total else 0.0, + "object_type_accuracy": obj_type_tp / obj_type_total if obj_type_total else 0.0, + "subject_type_checked": subj_type_total, + "object_type_checked": obj_type_total, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--config", + type=str, + default="configs/infer.yaml", + help="Path to YAML inference config (relative to infer.py dir).", + ) + parser.add_argument( + "--split", + type=str, + choices=["val", "test"], + default="val", + help="Which split to evaluate on. Use 'val' during development, 'test' only for final evaluation.", + ) + args = parser.parse_args() + + cfg = load_yaml_config(args.config) + script_dir = Path(__file__).resolve().parent + + split = args.split + data_path_key = f"{split}_path" + eval_path = script_dir / cfg[data_path_key] + output_dir = script_dir / cfg["output_dir"] + output_dir.mkdir(parents=True, exist_ok=True) + adapter_path = script_dir / cfg["adapter_path"] + + eval_examples = load_jsonl(eval_path) + print(f"Loaded {len(eval_examples)} {split} examples from {eval_path}") + + # Tokenizer + base_model_name = cfg["base_model"] + tokenizer = AutoTokenizer.from_pretrained(base_model_name) + tokenizer.pad_token = tokenizer.eos_token + + # Quantization + bnb_config = None + if cfg.get("load_in_4bit", False): + compute_dtype = getattr(torch, cfg.get("bnb_4bit_compute_dtype", "bfloat16")) + bnb_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_quant_type=cfg.get("bnb_4bit_quant_type", "nf4"), + bnb_4bit_compute_dtype=compute_dtype, + ) + + print(f"Loading base model {base_model_name} ...") + model = AutoModelForCausalLM.from_pretrained( + base_model_name, + quantization_config=bnb_config, + device_map="auto", + torch_dtype=getattr(torch, cfg.get("torch_dtype", "bfloat16")) if not bnb_config else None, + ) + print(f"Loading adapter from {adapter_path} ...") + model = PeftModel.from_pretrained(model, adapter_path) + model.eval() + + max_new_tokens = cfg.get("max_new_tokens", 2048) + temperature = cfg.get("temperature", 0.0) + do_sample = cfg.get("do_sample", False) + + # ── Whitelist from training data ── + train_path = script_dir / cfg.get("train_path", "./data/train.jsonl") + train_examples = load_jsonl(train_path) + whitelist = extract_whitelist(train_examples) + print( + f"Whitelist: {len(whitelist['relations'])} relations, " + f"{len(whitelist['subject_types'])} subj types, " + f"{len(whitelist['object_types'])} obj types" + ) + + use_whitelist = cfg.get("use_whitelist", True) + whitelist_soft = cfg.get("whitelist_soft_mapping", True) + whitelist_min_sim = cfg.get("whitelist_min_similarity", 0.6) + + results = [] + pred_examples_triplets: List[List[Dict]] = [] + gt_examples_triplets: List[List[Dict]] = [] + all_texts: List[str] = [] + + for idx, ex in enumerate(eval_examples): + text = extract_text_from_prompt(ex["messages"][1]["content"]) + prompt_messages = ex["messages"][:] # system + user + prompt_text = tokenizer.apply_chat_template( + prompt_messages, tokenize=False, add_generation_prompt=True + ) + inputs = tokenizer(prompt_text, return_tensors="pt").to(model.device) + + with torch.no_grad(): + output = model.generate( + **inputs, + max_new_tokens=max_new_tokens, + temperature=temperature, + do_sample=do_sample, + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + ) + + full_output = tokenizer.decode(output[0], skip_special_tokens=False) + + # Extract assistant answer + marker = "\nassistant\n" + marker_pos = full_output.find(marker) + if marker_pos >= 0: + answer = full_output[marker_pos + len(marker) :].strip() + else: + answer = full_output[len(prompt_text) :].strip() + + for turn_marker in ["<|im_start|>user", "<|im_start|>system", "<|endoftext|>", ""]: + pos = answer.find(turn_marker) + if pos >= 0: + answer = answer[:pos].strip() + + parsed = robust_extract_triplets(answer) + raw_pred_triplets: List[Dict] = parsed["triplets"] if parsed else [] + gt_triplets = parse_completion_triplets(ex) + + # ── Apply whitelist filtering ── + if use_whitelist: + pred_triplets, wl_stats = apply_whitelist( + raw_pred_triplets, + whitelist, + soft_mapping=whitelist_soft, + min_similarity=whitelist_min_sim, + ) + else: + pred_triplets = raw_pred_triplets + wl_stats = {} + + results.append({ + "index": idx, + "text": text, + "raw_output": answer, + "raw_triplets": raw_pred_triplets, + "filtered_triplets": pred_triplets, + "gt_triplets": gt_triplets, + "whitelist_stats": wl_stats, + }) + pred_examples_triplets.append(pred_triplets) + gt_examples_triplets.append(gt_triplets) + all_texts.append(text) + + if (idx + 1) % 20 == 0: + print(f" Processed {idx + 1}/{len(eval_examples)} ...") + + # ── Save predictions ── + preds_filename = f"{split}_predictions.json" + preds_path = output_dir / preds_filename + with open(preds_path, "w", encoding="utf-8") as f: + json.dump(results, f, ensure_ascii=False, indent=2) + print(f"Saved predictions to {preds_path}") + + # ── Build report ── + all_pred_triplets = [t for ex in pred_examples_triplets for t in ex] + all_gt_triplets = [t for ex in gt_examples_triplets for t in ex] + all_raw_triplets = [t for ex in results for t in ex["raw_triplets"]] + + pred_relation_counts = Counter(t.get("relation", "UNKNOWN") for t in all_pred_triplets) + gt_relation_counts = Counter(t.get("relation", "UNKNOWN") for t in all_gt_triplets) + + # Training distribution + train_triplets = [t for ex in train_examples for t in parse_completion_triplets(ex)] + train_relation_counts = Counter(t.get("relation", "UNKNOWN") for t in train_triplets) + + lines = [] + lines.append("=" * 70) + lines.append(f"WIKONTIC DISTILLATION INFERENCE REPORT — {split.upper()} SPLIT") + lines.append("=" * 70) + + lines.append(f"\n--- Overall counts ---") + lines.append(f"{split.capitalize()} examples: {len(eval_examples)}") + lines.append(f"GT triplets total: {len(all_gt_triplets)}") + lines.append(f"Raw pred triplets: {len(all_raw_triplets)}") + lines.append(f"Filtered pred triplets: {len(all_pred_triplets)}") + empty = sum(1 for ex in pred_examples_triplets if not ex) + lines.append(f"Empty predictions: {empty}") + + # Full-match metrics (subject + relation + object + types) + total_tp = 0 + total_pred = 0 + total_gt = 0 + for gt, pred in zip(gt_examples_triplets, pred_examples_triplets): + m = compute_metrics(gt, pred, key_fn=triplet_key_full) + total_tp += m["tp"] + total_pred += m["pred_count"] + total_gt += m["gt_count"] + + overall_p = total_tp / total_pred if total_pred else 0.0 + overall_r = total_tp / total_gt if total_gt else 0.0 + overall_f1 = (2 * overall_p * overall_r / (overall_p + overall_r)) if (overall_p + overall_r) > 0 else 0.0 + lines.append("\n--- Overall FULL-MATCH metrics (subj+rel+obj+types) ---") + lines.append(f"Precision: {overall_p:.3f}") + lines.append(f"Recall: {overall_r:.3f}") + lines.append(f"F1: {overall_f1:.3f}") + + # SRO-only metrics (ignore types) + total_tp_sro = 0 + total_pred_sro = 0 + total_gt_sro = 0 + for gt, pred in zip(gt_examples_triplets, pred_examples_triplets): + m = compute_metrics(gt, pred, key_fn=triplet_key_sro) + total_tp_sro += m["tp"] + total_pred_sro += m["pred_count"] + total_gt_sro += m["gt_count"] + + overall_p_sro = total_tp_sro / total_pred_sro if total_pred_sro else 0.0 + overall_r_sro = total_tp_sro / total_gt_sro if total_gt_sro else 0.0 + overall_f1_sro = (2 * overall_p_sro * overall_r_sro / (overall_p_sro + overall_r_sro)) if (overall_p_sro + overall_r_sro) > 0 else 0.0 + lines.append("\n--- Overall SRO-MATCH metrics (subj+rel+obj only) ---") + lines.append(f"Precision: {overall_p_sro:.3f}") + lines.append(f"Recall: {overall_r_sro:.3f}") + lines.append(f"F1: {overall_f1_sro:.3f}") + diff = overall_f1 - overall_f1_sro + lines.append(f" (Type labels cost {abs(diff):.3f} F1 {'full>' if diff > 0 else 'SRO>'})") + + # Per-relation metrics (full match) + rel_metrics = compute_relation_metrics(gt_examples_triplets, pred_examples_triplets, key_fn=triplet_key_full) + lines.append("\n--- Per-relation metrics FULL-MATCH (top 15 by GT support) ---") + sorted_rels = sorted(rel_metrics.items(), key=lambda kv: kv[1]["support_gt"], reverse=True) + for r, m in sorted_rels[:15]: + lines.append( + f" {r:25s} P={m['precision']:.3f} R={m['recall']:.3f} F1={m['f1']:.3f} " + f"gt={m['support_gt']:>4} pred={m['support_pred']:>4}" + ) + + # Per-relation metrics (SRO only) + rel_metrics_sro = compute_relation_metrics(gt_examples_triplets, pred_examples_triplets, key_fn=triplet_key_sro) + lines.append("\n--- Per-relation metrics SRO-MATCH (top 15 by GT support) ---") + sorted_rels_sro = sorted(rel_metrics_sro.items(), key=lambda kv: kv[1]["support_gt"], reverse=True) + for r, m in sorted_rels_sro[:15]: + lines.append( + f" {r:25s} P={m['precision']:.3f} R={m['recall']:.3f} F1={m['f1']:.3f} " + f"gt={m['support_gt']:>4} pred={m['support_pred']:>4}" + ) + + # Hallucination stats + hall = compute_hallucination_stats(all_texts, pred_examples_triplets) + lines.append("\n--- Subject / Object hallucination ---") + lines.append( + f"Subject hallucination rate: {hall['subject_hallucination_rate']:.3f} " + f"({hall['subject_hallucinated_count']}/{hall['total_triplets_checked']})" + ) + lines.append( + f"Object hallucination rate: {hall['object_hallucination_rate']:.3f} " + f"({hall['object_hallucinated_count']}/{hall['total_triplets_checked']})" + ) + + # Type accuracy + type_acc = compute_type_accuracy(gt_examples_triplets, pred_examples_triplets) + lines.append("\n--- Type accuracy (on correctly-matched SRO triplets) ---") + lines.append( + f"Subject type accuracy: {type_acc['subject_type_accuracy']:.3f} " + f"({type_acc['subject_type_checked']} checked)" + ) + lines.append( + f"Object type accuracy: {type_acc['object_type_accuracy']:.3f} " + f"({type_acc['object_type_checked']} checked)" + ) + + # Confused relations + confused = find_confused_relations(gt_examples_triplets, pred_examples_triplets) + lines.append("\n--- Most confused relation pairs (GT relation → predicted relation) ---") + for (gt_rel, pred_rel), count in confused: + lines.append(f" {gt_rel:25s} → {pred_rel:25s} {count:4d} times") + + # Whitelist stats + if use_whitelist: + total_dropped = sum( + v for ex in results for v in ex.get("whitelist_stats", {}).values() if "dropped" in str(v) + ) + # Actually stats are per-example dicts + agg_stats: Dict[str, int] = defaultdict(int) + for ex in results: + for k, v in ex.get("whitelist_stats", {}).items(): + agg_stats[k] += v + lines.append("\n--- Whitelist filtering ---") + for k, v in sorted(agg_stats.items()): + lines.append(f" {k}: {v}") + + # Distribution comparison + lines.append("\n--- Distribution comparison ---") + lines.append("TRAINING DATA:") + lines.append(f" Total triplets: {len(train_triplets)}") + lines.append(f" Unique relations: {len(train_relation_counts)}") + if train_relation_counts: + top_r, top_c = train_relation_counts.most_common(1)[0] + lines.append(f" Top relation: {top_r} ({top_c} occurrences)") + top5_train = train_relation_counts.most_common(5) + top5_cov_train = sum(c for _, c in top5_train) / len(train_triplets) * 100 if train_triplets else 0 + lines.append(f" Top 5 relations cover: {top5_cov_train:.1f}%") + top10_cov_train = sum(c for _, c in train_relation_counts.most_common(10)) / len(train_triplets) * 100 if train_triplets else 0 + lines.append(f" Top 10 relations cover: {top10_cov_train:.1f}%") + + lines.append("\nMODEL PREDICTIONS:") + lines.append(f" Total triplets: {len(all_pred_triplets)}") + lines.append(f" Unique relations: {len(pred_relation_counts)}") + parse_success = sum(1 for ex in pred_examples_triplets if ex) + lines.append(f" Parse success rate: {parse_success}/{len(eval_examples)} ({parse_success / len(eval_examples) * 100:.1f}%)") + if pred_relation_counts: + top_r, top_c = pred_relation_counts.most_common(1)[0] + lines.append(f" Top relation: {top_r}") + lines.append(f" Top-relation dominance: {top_c / len(all_pred_triplets) * 100:.1f}%") + + lines.append("\nCOMPARISON:") + train_top5 = {r for r, _ in train_relation_counts.most_common(5)} + pred_top5 = {r for r, _ in pred_relation_counts.most_common(5)} + shared = len(train_top5 & pred_top5) + lines.append(f" Shared top-5 relations: {shared}/5") + top_train_share = (train_relation_counts.most_common(1)[0][1] / len(train_triplets) * 100) if train_relation_counts else 0 + top_pred_share = (pred_relation_counts.most_common(1)[0][1] / len(all_pred_triplets) * 100) if pred_relation_counts else 0 + lines.append(f" Top-relation dominance train: {top_train_share:.1f}%") + lines.append(f" Top-relation dominance pred: {top_pred_share:.1f}%") + if top_pred_share > top_train_share * 1.5: + lines.append(" WARNING: Model is heavily biased toward the most common relation!") + + report_text = "\n".join(lines) + print("\n" + report_text) + report_filename = f"{split}_report.txt" + report_path = output_dir / report_filename + with open(report_path, "w", encoding="utf-8") as f: + f.write(report_text + "\n") + print(f"\nSaved report to {report_path}") + + +if __name__ == "__main__": + main() diff --git a/distillation/inference_outputs/report.txt b/distillation/inference_outputs/report.txt new file mode 100644 index 0000000..9f0dc49 --- /dev/null +++ b/distillation/inference_outputs/report.txt @@ -0,0 +1,98 @@ +====================================================================== +WIKONTIC DISTILLATION INFERENCE REPORT +====================================================================== + +--- Overall counts --- +Validation examples: 200 +GT triplets total: 2270 +Raw pred triplets: 1334 +Filtered pred triplets: 1310 +Empty predictions: 0 + +--- Overall FULL-MATCH metrics (subj+rel+obj+types) --- +Precision: 0.830 +Recall: 0.479 +F1: 0.607 + +--- Overall SRO-MATCH metrics (subj+rel+obj only) --- +Precision: 0.853 +Recall: 0.493 +F1: 0.625 + (Type labels cost 0.017 F1 SRO>) + +--- Per-relation metrics FULL-MATCH (top 15 by GT support) --- + instance of P=0.791 R=0.611 F1=0.689 gt= 149 pred= 115 + occupation P=0.971 R=0.835 F1=0.898 gt= 121 pred= 104 + has part(s) P=0.682 R=0.333 F1=0.448 gt= 90 pred= 44 + country of citizenship P=0.964 R=0.885 F1=0.923 gt= 61 pred= 56 + date of birth P=0.964 R=0.915 F1=0.939 gt= 59 pred= 56 + position held P=0.727 R=0.453 F1=0.558 gt= 53 pred= 33 + part of P=0.774 R=0.500 F1=0.608 gt= 48 pred= 31 + member of P=0.688 R=0.234 F1=0.349 gt= 47 pred= 16 + location P=0.789 R=0.417 F1=0.545 gt= 36 pred= 19 + genre P=0.880 R=0.611 F1=0.721 gt= 36 pred= 25 + director P=0.929 R=0.722 F1=0.813 gt= 36 pred= 28 + film crew member P=0.833 R=0.429 F1=0.566 gt= 35 pred= 18 + country of origin P=0.963 R=0.765 F1=0.852 gt= 34 pred= 27 + award received P=0.545 R=0.182 F1=0.273 gt= 33 pred= 11 + inception P=0.952 R=0.606 F1=0.741 gt= 33 pred= 21 + +--- Per-relation metrics SRO-MATCH (top 15 by GT support) --- + instance of P=0.887 R=0.685 F1=0.773 gt= 149 pred= 115 + occupation P=0.971 R=0.835 F1=0.898 gt= 121 pred= 104 + has part(s) P=0.682 R=0.333 F1=0.448 gt= 90 pred= 44 + country of citizenship P=0.964 R=0.885 F1=0.923 gt= 61 pred= 56 + date of birth P=0.982 R=0.932 F1=0.957 gt= 59 pred= 56 + position held P=0.818 R=0.509 F1=0.628 gt= 53 pred= 33 + part of P=0.806 R=0.521 F1=0.633 gt= 48 pred= 31 + member of P=0.812 R=0.277 F1=0.413 gt= 47 pred= 16 + location P=0.789 R=0.417 F1=0.545 gt= 36 pred= 19 + genre P=0.880 R=0.611 F1=0.721 gt= 36 pred= 25 + director P=0.929 R=0.722 F1=0.813 gt= 36 pred= 28 + film crew member P=0.833 R=0.429 F1=0.566 gt= 35 pred= 18 + country of origin P=0.963 R=0.765 F1=0.852 gt= 34 pred= 27 + award received P=0.545 R=0.182 F1=0.273 gt= 33 pred= 11 + inception P=1.000 R=0.636 F1=0.778 gt= 33 pred= 21 + +--- Subject / Object hallucination --- +Subject hallucination rate: 0.140 (184/1310) +Object hallucination rate: 0.313 (410/1310) + +--- Type accuracy (on correctly-matched SRO triplets) --- +Subject type accuracy: 0.991 (1117 checked) +Object type accuracy: 0.980 (1117 checked) + +--- Most confused relation pairs (GT relation → predicted relation) --- + located in the administrative territorial entity → location 2 times + point in time → refine date 2 times + produced by → lyricist 2 times + has part(s) → founded by 1 times + replaced by → used by 1 times + participant in → home venue 1 times + follows → founded by 1 times + variety of lexeme, form or sense → named after 1 times + uses → has characteristic 1 times + appears in the form of → has characteristic 1 times + +--- Whitelist filtering --- + relation_dropped: 24 + +--- Distribution comparison --- +TRAINING DATA: + Total triplets: 17761 + Unique relations: 715 + Top relation: instance of (1156 occurrences) + Top 5 relations cover: 21.0% + Top 10 relations cover: 30.6% + +MODEL PREDICTIONS: + Total triplets: 1310 + Unique relations: 185 + Parse success rate: 200/200 (100.0%) + Top relation: instance of + Top-relation dominance: 8.8% + +COMPARISON: + Shared top-5 relations: 3/5 + Top-relation dominance train: 6.5% + Top-relation dominance pred: 8.8% diff --git a/distillation/inference_outputs/test_report.txt b/distillation/inference_outputs/test_report.txt new file mode 100644 index 0000000..1e8cab1 --- /dev/null +++ b/distillation/inference_outputs/test_report.txt @@ -0,0 +1,98 @@ +====================================================================== +WIKONTIC DISTILLATION INFERENCE REPORT — TEST SPLIT +====================================================================== + +--- Overall counts --- +Test examples: 200 +GT triplets total: 2281 +Raw pred triplets: 2005 +Filtered pred triplets: 1972 +Empty predictions: 0 + +--- Overall FULL-MATCH metrics (subj+rel+obj+types) --- +Precision: 0.656 +Recall: 0.567 +F1: 0.609 + +--- Overall SRO-MATCH metrics (subj+rel+obj only) --- +Precision: 0.703 +Recall: 0.609 +F1: 0.653 + (Type labels cost 0.044 F1 SRO>) + +--- Per-relation metrics FULL-MATCH (top 15 by GT support) --- + instance of P=0.556 R=0.511 F1=0.532 gt= 137 pred= 126 + has part(s) P=0.577 R=0.544 F1=0.560 gt= 103 pred= 97 + position held P=0.583 R=0.589 F1=0.586 gt= 95 pred= 96 + occupation P=0.853 R=0.659 F1=0.744 gt= 88 pred= 68 + performer P=0.840 R=0.857 F1=0.848 gt= 49 pred= 50 + part of P=0.655 R=0.404 F1=0.500 gt= 47 pred= 29 + country of citizenship P=0.897 R=0.761 F1=0.824 gt= 46 pred= 39 + date of birth P=0.912 R=0.689 F1=0.785 gt= 45 pred= 34 + product or material produced P=0.744 R=0.727 F1=0.736 gt= 44 pred= 43 + located in the administrative territorial entity P=0.750 R=0.786 F1=0.767 gt= 42 pred= 44 + award received P=0.765 R=0.619 F1=0.684 gt= 42 pred= 34 + location P=0.566 R=0.750 F1=0.645 gt= 40 pred= 53 + participant in P=0.614 R=0.794 F1=0.692 gt= 34 pred= 44 + inception P=0.735 R=0.758 F1=0.746 gt= 33 pred= 34 + produced by P=0.652 R=0.484 F1=0.556 gt= 31 pred= 23 + +--- Per-relation metrics SRO-MATCH (top 15 by GT support) --- + instance of P=0.659 R=0.606 F1=0.631 gt= 137 pred= 126 + has part(s) P=0.701 R=0.660 F1=0.680 gt= 103 pred= 97 + position held P=0.604 R=0.611 F1=0.607 gt= 95 pred= 96 + occupation P=0.853 R=0.659 F1=0.744 gt= 88 pred= 68 + performer P=0.860 R=0.878 F1=0.869 gt= 49 pred= 50 + part of P=0.759 R=0.468 F1=0.579 gt= 47 pred= 29 + country of citizenship P=0.897 R=0.761 F1=0.824 gt= 46 pred= 39 + date of birth P=0.912 R=0.689 F1=0.785 gt= 45 pred= 34 + product or material produced P=0.814 R=0.814 F1=0.814 gt= 43 pred= 43 + located in the administrative territorial entity P=0.750 R=0.786 F1=0.767 gt= 42 pred= 44 + award received P=0.853 R=0.690 F1=0.763 gt= 42 pred= 34 + location P=0.623 R=0.825 F1=0.710 gt= 40 pred= 53 + participant in P=0.682 R=0.882 F1=0.769 gt= 34 pred= 44 + inception P=0.794 R=0.818 F1=0.806 gt= 33 pred= 34 + produced by P=0.652 R=0.484 F1=0.556 gt= 31 pred= 23 + +--- Subject / Object hallucination --- +Subject hallucination rate: 0.119 (234/1972) +Object hallucination rate: 0.255 (502/1972) + +--- Type accuracy (on correctly-matched SRO triplets) --- +Subject type accuracy: 0.956 (1387 checked) +Object type accuracy: 0.970 (1387 checked) + +--- Most confused relation pairs (GT relation → predicted relation) --- + creator → author 10 times + represented by → represents 4 times + presented works → field of work 4 times + uses → operator 4 times + has part(s) → record of 3 times + characteristic of → has part(s) 3 times + located in the administrative territorial entity → location 3 times + variety of lexeme, form or sense → named after 2 times + located in/on physical feature → located in the administrative territorial entity 2 times + named by → named after 2 times + +--- Whitelist filtering --- + relation_dropped: 33 + +--- Distribution comparison --- +TRAINING DATA: + Total triplets: 17761 + Unique relations: 715 + Top relation: instance of (1156 occurrences) + Top 5 relations cover: 21.0% + Top 10 relations cover: 30.6% + +MODEL PREDICTIONS: + Total triplets: 1972 + Unique relations: 242 + Parse success rate: 200/200 (100.0%) + Top relation: instance of + Top-relation dominance: 6.4% + +COMPARISON: + Shared top-5 relations: 4/5 + Top-relation dominance train: 6.5% + Top-relation dominance pred: 6.4% diff --git a/distillation/split_data.py b/distillation/split_data.py new file mode 100644 index 0000000..31d541d --- /dev/null +++ b/distillation/split_data.py @@ -0,0 +1,427 @@ +""" +Split Wikontic distillation data into train / val / test at the ARTICLE level. + +This prevents data leakage: when paragraphs from the same article are shuffled +into different splits, entities overlap and validation metrics are inflated. +By splitting on article_id (sample_id), every entity in val/test is truly +unseen during training. + +Usage: + python split_data.py --train-ratio 0.8 --val-ratio 0.1 --test-ratio 0.1 --seed 42 + +Outputs (in ./data/): + train.jsonl, val.jsonl, test.jsonl – chat-formatted examples + split_manifest.json – which article_ids went where +""" +import argparse +import json +import random +import sys +from pathlib import Path +from typing import Any, Dict, List, Set, Tuple + +# --------------------------------------------------------------------------- +# Paths (relative to this script's location in distillation/) +# --------------------------------------------------------------------------- +_SCRIPT_DIR = Path(__file__).resolve().parent +HOTPOT_PATH = _SCRIPT_DIR / ".." / "datasets" / "hotpotqa200.json" +DUMP_PATH = _SCRIPT_DIR / ".." / "datasets" / "kg_dump_hotpot_gpt4_1_onto_triplets.json" +SYSTEM_PROMPT_PATH = ( + _SCRIPT_DIR + / ".." + / "src" + / "wikontic" + / "utils" + / "prompts" + / "triplet_extraction" + / "propmt_1_types_qualifiers.txt" +) +OUTPUT_DIR = _SCRIPT_DIR / "data" + +TRAIN_OUT = OUTPUT_DIR / "train.jsonl" +VAL_OUT = OUTPUT_DIR / "val.jsonl" +TEST_OUT = OUTPUT_DIR / "test.jsonl" +MANIFEST_OUT = OUTPUT_DIR / "split_manifest.json" + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def load_json(path: Path) -> Any: + with open(path, "r", encoding="utf-8") as f: + return json.load(f) + + +def load_system_prompt() -> str: + with open(SYSTEM_PROMPT_PATH, "r", encoding="utf-8") as f: + return f.read() + + +def build_example(text: str, triplets: list, system_prompt: str) -> dict: + """Format one text-triplets pair as chat messages for SFT training.""" + assistant_content = json.dumps({"triplets": triplets}, ensure_ascii=False) + messages = [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": f'Text: "{text}"'}, + {"role": "assistant", "content": assistant_content}, + ] + return {"messages": messages} + + +def get_text(ex: dict) -> str: + return ex["messages"][1]["content"] + + +def get_entities(examples: List[dict]) -> Set[str]: + """Extract all subject and object strings from triplets.""" + entities = set() + for ex in examples: + try: + content = ex["messages"][2]["content"] + parsed = json.loads(content) + for t in parsed.get("triplets", []): + if t.get("subject"): + entities.add(t["subject"]) + if t.get("object"): + entities.add(t["object"]) + except (json.JSONDecodeError, IndexError, KeyError): + pass + return entities + + +def write_jsonl(path: Path, items: List[dict]) -> None: + with open(path, "w", encoding="utf-8") as f: + for item in items: + f.write(json.dumps(item, ensure_ascii=False) + "\n") + + +# --------------------------------------------------------------------------- +# Build article-level examples +# --------------------------------------------------------------------------- + +def build_article_examples( + hotpot: Dict[str, Any], + dump: Dict[str, Any], + system_prompt: str, +) -> Dict[str, List[dict]]: + """ + Returns a dict mapping article_id -> list of chat-formatted examples. + """ + article_examples: Dict[str, List[dict]] = {} + skipped_empty = 0 + + for sample_id, source_dict in dump.items(): + if sample_id not in hotpot: + continue + sample = hotpot[sample_id] + context = sample["context"] # list of [title, [text_segments]] + examples = [] + + for sid_str, entry in source_dict.items(): + sid = int(sid_str) + if sid >= len(context): + continue + + title, text_segments = context[sid] + text = " ".join(text_segments).strip() + triplets = entry.get("triplets", []) + + if not text or not triplets: + skipped_empty += 1 + continue + + examples.append(build_example(text, triplets, system_prompt)) + + if examples: + article_examples[sample_id] = examples + + print(f"Articles with examples: {len(article_examples)}") + print(f"Skipped (empty text or triplets): {skipped_empty}") + return article_examples + + +# --------------------------------------------------------------------------- +# Split articles +# --------------------------------------------------------------------------- + +def split_articles( + article_examples: Dict[str, List[dict]], + train_ratio: float, + val_ratio: float, + test_ratio: float, + seed: int, +) -> Tuple[List[str], List[str], List[str]]: + """ + Shuffle article IDs and split into train / val / test. + """ + if abs(train_ratio + val_ratio + test_ratio - 1.0) > 1e-6: + raise ValueError("Ratios must sum to 1.0") + + article_ids = list(article_examples.keys()) + random.seed(seed) + random.shuffle(article_ids) + + n = len(article_ids) + n_train = int(n * train_ratio) + n_val = int(n * val_ratio) + # Test gets the remainder to avoid rounding issues. + n_test = n - n_train - n_val + + train_ids = article_ids[:n_train] + val_ids = article_ids[n_train : n_train + n_val] + test_ids = article_ids[n_train + n_val :] + + return train_ids, val_ids, test_ids + + +# --------------------------------------------------------------------------- +# Leakage check +# --------------------------------------------------------------------------- + +def check_leakage( + train: List[dict], + val: List[dict], + test: List[dict], + train_ids: List[str], + val_ids: List[str], + test_ids: List[str], +) -> None: + """Print leakage statistics.""" + print("\n" + "=" * 70) + print("DATA LEAKAGE CHECK") + print("=" * 70) + + # 1. Article overlap + train_id_set = set(train_ids) + val_id_set = set(val_ids) + test_id_set = set(test_ids) + + print("\n1. ARTICLE OVERLAP") + print(f" Train articles: {len(train_ids)}") + print(f" Val articles: {len(val_ids)}") + print(f" Test articles: {len(test_ids)}") + print(f" Train-Val overlap: {len(train_id_set & val_id_set)}") + print(f" Train-Test overlap: {len(train_id_set & test_id_set)}") + print(f" Val-Test overlap: {len(val_id_set & test_id_set)}") + + # 2. Exact text overlap + train_texts = set(get_text(ex) for ex in train) + val_texts = set(get_text(ex) for ex in val) + test_texts = set(get_text(ex) for ex in test) + + print("\n2. EXACT TEXT OVERLAP") + print(f" Train-Val exact duplicates: {len(train_texts & val_texts)}") + print(f" Train-Test exact duplicates: {len(train_texts & test_texts)}") + print(f" Val-Test exact duplicates: {len(val_texts & test_texts)}") + + # 3. Entity overlap + train_entities = get_entities(train) + val_entities = get_entities(val) + test_entities = get_entities(test) + + print("\n3. ENTITY OVERLAP") + print(f" Total unique train entities: {len(train_entities)}") + print(f" Total unique val entities: {len(val_entities)}") + print(f" Total unique test entities: {len(test_entities)}") + + if val_entities: + val_overlap = len(train_entities & val_entities) + print(f" Entities in train & val: {val_overlap} ({val_overlap/len(val_entities)*100:.1f}%)") + if test_entities: + test_overlap = len(train_entities & test_entities) + print(f" Entities in train & test: {test_overlap} ({test_overlap/len(test_entities)*100:.1f}%)") + if test_entities and val_entities: + vt_overlap = len(val_entities & test_entities) + print(f" Entities in val & test: {vt_overlap} ({vt_overlap/len(test_entities)*100:.1f}%)") + + # 4. Per-example entity leakage (val only) + print("\n4. PER-EXAMPLE ENTITY LEAKAGE (VAL)") + fully_leaked = 0 + partially_leaked = 0 + fully_unseen = 0 + + for ex in val: + try: + content = ex["messages"][2]["content"] + parsed = json.loads(content) + triplets = parsed.get("triplets", []) + ex_entities = set() + for t in triplets: + if t.get("subject"): + ex_entities.add(t["subject"]) + if t.get("object"): + ex_entities.add(t["object"]) + if not ex_entities: + continue + overlap_count = len(ex_entities & train_entities) + if overlap_count == len(ex_entities): + fully_leaked += 1 + elif overlap_count > 0: + partially_leaked += 1 + else: + fully_unseen += 1 + except (json.JSONDecodeError, IndexError, KeyError): + pass + + total = fully_leaked + partially_leaked + fully_unseen + if total: + print(f" All entities in train: {fully_leaked} ({fully_leaked/total*100:.1f}%)") + print(f" Some entities in train: {partially_leaked} ({partially_leaked/total*100:.1f}%)") + print(f" All entities UNSEEN: {fully_unseen} ({fully_unseen/total*100:.1f}%)") + + print("\n" + "=" * 70) + print("CONCLUSION") + print("=" * 70) + if train_id_set & val_id_set or train_id_set & test_id_set or val_id_set & test_id_set: + print("CRITICAL: Article overlap detected — split logic is broken!") + else: + print("Article-level split is clean: no articles shared between splits.") + + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +def main() -> None: + parser = argparse.ArgumentParser( + description="Split Wikontic distillation data by article_id." + ) + parser.add_argument( + "--train-ratio", + type=float, + default=0.8, + help="Fraction of articles for training (default: 0.8)", + ) + parser.add_argument( + "--val-ratio", + type=float, + default=0.1, + help="Fraction of articles for validation (default: 0.1)", + ) + parser.add_argument( + "--test-ratio", + type=float, + default=0.1, + help="Fraction of articles for test (default: 0.1). Set to 0 to skip test.", + ) + parser.add_argument( + "--seed", + type=int, + default=42, + help="Random seed for reproducibility (default: 42)", + ) + args = parser.parse_args() + + if args.test_ratio == 0.0: + # Adjust train/val to sum to 1.0 if test is disabled. + total = args.train_ratio + args.val_ratio + if abs(total - 1.0) > 1e-6: + raise ValueError("train-ratio + val-ratio must equal 1.0 when test-ratio is 0") + + # ------------------------------------------------------------------ + # Load data + # ------------------------------------------------------------------ + print("Loading data...") + hotpot = {s["_id"]: s for s in load_json(HOTPOT_PATH)} + dump = load_json(DUMP_PATH) + system_prompt = load_system_prompt() + + print(f"HotPotQA samples: {len(hotpot)}") + print(f"KG dump samples: {len(dump)}") + print(f"Overlapping IDs: {len(set(hotpot) & set(dump))}") + print(f"System prompt: {len(system_prompt)} chars") + + # ------------------------------------------------------------------ + # Build examples grouped by article + # ------------------------------------------------------------------ + article_examples = build_article_examples(hotpot, dump, system_prompt) + total_examples = sum(len(v) for v in article_examples.values()) + print(f"Total paragraph examples: {total_examples}") + + # ------------------------------------------------------------------ + # Split articles + # ------------------------------------------------------------------ + train_ids, val_ids, test_ids = split_articles( + article_examples, + args.train_ratio, + args.val_ratio, + args.test_ratio, + args.seed, + ) + + train_examples = [] + for aid in train_ids: + train_examples.extend(article_examples[aid]) + + val_examples = [] + for aid in val_ids: + val_examples.extend(article_examples[aid]) + + test_examples = [] + for aid in test_ids: + test_examples.extend(article_examples[aid]) + + print(f"\nSplit result:") + print(f" Train: {len(train_ids)} articles, {len(train_examples)} examples") + print(f" Val: {len(val_ids)} articles, {len(val_examples)} examples") + if args.test_ratio > 0: + print(f" Test: {len(test_ids)} articles, {len(test_examples)} examples") + + # ------------------------------------------------------------------ + # Write outputs + # ------------------------------------------------------------------ + OUTPUT_DIR.mkdir(parents=True, exist_ok=True) + write_jsonl(TRAIN_OUT, train_examples) + write_jsonl(VAL_OUT, val_examples) + if args.test_ratio > 0: + write_jsonl(TEST_OUT, test_examples) + else: + # Remove stale test file if it exists from a previous run. + if TEST_OUT.exists(): + TEST_OUT.unlink() + + manifest = { + "seed": args.seed, + "ratios": { + "train": args.train_ratio, + "val": args.val_ratio, + "test": args.test_ratio, + }, + "train_ids": train_ids, + "val_ids": val_ids, + "test_ids": test_ids if args.test_ratio > 0 else [], + "counts": { + "train_articles": len(train_ids), + "val_articles": len(val_ids), + "test_articles": len(test_ids) if args.test_ratio > 0 else 0, + "train_examples": len(train_examples), + "val_examples": len(val_examples), + "test_examples": len(test_examples) if args.test_ratio > 0 else 0, + }, + } + with open(MANIFEST_OUT, "w", encoding="utf-8") as f: + json.dump(manifest, f, indent=2, ensure_ascii=False) + + print(f"\nSaved to {OUTPUT_DIR}") + print(f" {TRAIN_OUT.name}") + print(f" {VAL_OUT.name}") + if args.test_ratio > 0: + print(f" {TEST_OUT.name}") + print(f" {MANIFEST_OUT.name}") + + # ------------------------------------------------------------------ + # Leakage check + # ------------------------------------------------------------------ + check_leakage( + train_examples, + val_examples, + test_examples if args.test_ratio > 0 else [], + train_ids, + val_ids, + test_ids if args.test_ratio > 0 else [], + ) + + +if __name__ == "__main__": + main() diff --git a/distillation/train.py b/distillation/train.py new file mode 100644 index 0000000..4ff8466 --- /dev/null +++ b/distillation/train.py @@ -0,0 +1,284 @@ +""" +Training script for Wikontic distillation — v4. + +Key changes vs v3: + - Stronger LoRA: added MLP targets (gate_proj, up_proj, down_proj). + - Removed curriculum learning (trains on full triplets from start). + - Removed hand-tuned relation weighting; replaced with Focal Loss + (gamma=2.0) which automatically focuses on hard tokens. + - Removed "instance of" triplet reordering to avoid length bias. + - Simplified trainer; eval_loss still used for checkpointing. +""" +import argparse +import json +import sys +from pathlib import Path +from typing import Any, Dict, List + +# Apply TRL UTF-8 fix before importing trl (required on Windows) +sys.path.insert(0, str(Path(__file__).resolve().parent)) +import trl_utf8_fix # noqa: E402, F401 + +import torch +import yaml +from datasets import Dataset +from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training +from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig +from trl import SFTConfig, SFTTrainer + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + +def load_yaml_config(path: str) -> Dict[str, Any]: + with open(path, "r", encoding="utf-8") as f: + return yaml.safe_load(f) + + +def load_jsonl(path: Path) -> List[Dict[str, Any]]: + examples = [] + with open(path, "r", encoding="utf-8") as f: + for line in f: + examples.append(json.loads(line)) + return examples + + +def build_dataset( + examples: List[Dict[str, Any]], + tokenizer: AutoTokenizer, +) -> Dataset: + """ + Build a **pre-tokenized** dataset from chat-formatted examples. + + Returns a dataset with columns: + - ``input_ids``: token IDs for prompt + completion + - ``completion_mask``: 0 for prompt tokens, 1 for completion tokens + """ + processed = [] + for ex in examples: + messages = ex["messages"] + assistant = messages[2]["content"] + try: + parsed = json.loads(assistant) + except json.JSONDecodeError: + continue + + triplets = parsed.get("triplets", []) + # No reordering or truncation — preserve natural order and full length. + new_assistant = json.dumps({"triplets": triplets}, ensure_ascii=False) + new_messages = messages[:2] + [{"role": "assistant", "content": new_assistant}] + + # Prompt includes the generation header so the model starts emitting. + prompt_text = tokenizer.apply_chat_template( + new_messages[:-1], tokenize=False, add_generation_prompt=True + ) + # Full conversation without the trailing generation prompt. + full_text = tokenizer.apply_chat_template( + new_messages, tokenize=False, add_generation_prompt=False + ) + completion_text = full_text[len(prompt_text):] + if tokenizer.eos_token and not completion_text.endswith(tokenizer.eos_token): + completion_text += tokenizer.eos_token + + prompt_ids = tokenizer(prompt_text, add_special_tokens=False)["input_ids"] + full_ids = tokenizer(full_text, add_special_tokens=False)["input_ids"] + # Guarantee EOS token ID at the end. + if tokenizer.eos_token_id is not None and ( + not full_ids or full_ids[-1] != tokenizer.eos_token_id + ): + full_ids.append(tokenizer.eos_token_id) + + completion_mask = [0] * len(prompt_ids) + [1] * (len(full_ids) - len(prompt_ids)) + + processed.append({ + "input_ids": full_ids, + "completion_mask": completion_mask, + }) + + return Dataset.from_list(processed) + + +# --------------------------------------------------------------------------- +# Custom SFTTrainer with Focal Loss +# --------------------------------------------------------------------------- + +class FocalSFTTrainer(SFTTrainer): + """ + SFTTrainer subclass that replaces standard CE with Focal Loss. + Focal Loss automatically down-weights easy tokens and focuses on + hard/rare tokens (e.g. under-represented relations), removing the + need for hand-tuned per-relation weights. + """ + + def __init__( + self, + focal_gamma: float = 2.0, + *args: Any, + **kwargs: Any, + ): + super().__init__(*args, **kwargs) + self.focal_gamma = focal_gamma + + def compute_loss( + self, model, inputs, return_outputs=False, num_items_in_batch=None + ): + labels = inputs.get("labels") + # Pop completion_mask so the base Trainer doesn't see an unexpected key. + completion_mask = inputs.pop("completion_mask", None) + + # Forward without labels — we compute loss manually. + outputs = model( + input_ids=inputs["input_ids"], + attention_mask=inputs["attention_mask"], + ) + logits = outputs.logits + + # Standard next-token shift. + shift_logits = logits[..., :-1, :].contiguous() + shift_labels = labels[..., 1:].contiguous() + + # Compute per-token CE. + loss_fct = torch.nn.CrossEntropyLoss(reduction="none") + ce = loss_fct( + shift_logits.view(-1, shift_logits.size(-1)), + shift_labels.view(-1), + ) + ce = ce.view(shift_labels.size()) + + # Convert CE to probability for focal weighting: p = exp(-ce) + pt = torch.exp(-ce) + + # Focal weight: (1 - p)^gamma + weights = (1.0 - pt) ** self.focal_gamma + + # valid_mask: 1 for completion tokens, 0 for prompt / padding. + valid_mask = (shift_labels != -100).to(ce.dtype) + + loss = (ce * weights * valid_mask).sum() / (valid_mask.sum() + 1e-8) + return (loss, outputs) if return_outputs else loss + + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument( + "--config", + type=str, + default="configs/train.yaml", + help="Path to YAML training config (relative to train.py dir).", + ) + args = parser.parse_args() + + cfg = load_yaml_config(args.config) + + script_dir = Path(__file__).resolve().parent + train_path = script_dir / cfg["train_path"] + val_path = script_dir / cfg["val_path"] + output_dir = script_dir / cfg["output_dir"] + + train_examples = load_jsonl(train_path) + val_examples = load_jsonl(val_path) + print(f"Loaded {len(train_examples)} train, {len(val_examples)} val examples.") + + # Tokenizer + base_model_name = cfg["base_model"] + tokenizer = AutoTokenizer.from_pretrained(base_model_name) + tokenizer.pad_token = tokenizer.eos_token + + # Build datasets (no curriculum, no truncation) + train_dataset = build_dataset(train_examples, tokenizer) + eval_dataset = build_dataset(val_examples, tokenizer) + + print(f"Train dataset columns: {train_dataset.column_names}") + print(f"Eval dataset columns: {eval_dataset.column_names}") + + # ------------------------------------------------------------------ + # Model + QLoRA + # ------------------------------------------------------------------ + bnb_config = None + if cfg.get("load_in_4bit", False): + compute_dtype = getattr(torch, cfg.get("bnb_4bit_compute_dtype", "bfloat16")) + bnb_config = BitsAndBytesConfig( + load_in_4bit=True, + bnb_4bit_quant_type=cfg.get("bnb_4bit_quant_type", "nf4"), + bnb_4bit_compute_dtype=compute_dtype, + ) + + print(f"Loading base model {base_model_name} ...") + model = AutoModelForCausalLM.from_pretrained( + base_model_name, + quantization_config=bnb_config, + device_map="auto", + torch_dtype=getattr(torch, cfg.get("torch_dtype", "bfloat16")) + if not bnb_config + else None, + ) + if bnb_config: + model = prepare_model_for_kbit_training(model) + + lora_config = LoraConfig( + r=cfg["lora_r"], + lora_alpha=cfg["lora_alpha"], + target_modules=cfg["target_modules"], + lora_dropout=cfg["lora_dropout"], + bias="none", + task_type="CAUSAL_LM", + ) + model = get_peft_model(model, lora_config) + model.print_trainable_parameters() + + # ------------------------------------------------------------------ + # SFTConfig + # ------------------------------------------------------------------ + sft_cfg = SFTConfig( + output_dir=str(output_dir), + num_train_epochs=cfg["num_train_epochs"], + per_device_train_batch_size=cfg["per_device_train_batch_size"], + per_device_eval_batch_size=cfg["per_device_eval_batch_size"], + gradient_accumulation_steps=cfg["gradient_accumulation_steps"], + learning_rate=cfg["learning_rate"], + warmup_steps=cfg.get("warmup_steps", 0), + logging_steps=cfg.get("logging_steps", 10), + save_steps=cfg.get("save_steps", 1000), + eval_strategy=cfg.get("eval_strategy", "steps"), + eval_steps=cfg.get("eval_steps", 1000), + bf16=cfg.get("bf16", False), + dataloader_num_workers=cfg.get("dataloader_num_workers", 0), + report_to=cfg.get("report_to", "none"), + save_total_limit=cfg.get("save_total_limit", 2), + load_best_model_at_end=True, + metric_for_best_model="eval_loss", + greater_is_better=False, + lr_scheduler_type=cfg.get("lr_scheduler_type", "linear"), + completion_only_loss=True, + max_length=cfg.get("max_seq_length", 2048), + packing=False, + dataset_text_field=None, + dataset_kwargs={"skip_prepare_dataset": True}, + ) + + focal_gamma = cfg.get("focal_gamma", 2.0) + + trainer = FocalSFTTrainer( + model=model, + args=sft_cfg, + train_dataset=train_dataset, + eval_dataset=eval_dataset, + processing_class=tokenizer, + focal_gamma=focal_gamma, + ) + + print("Starting training...") + trainer.train() + + print(f"Saving model to {output_dir}") + trainer.save_model(str(output_dir)) + tokenizer.save_pretrained(str(output_dir)) + + +if __name__ == "__main__": + main() diff --git a/distillation/trl_utf8_fix.py b/distillation/trl_utf8_fix.py new file mode 100644 index 0000000..77422a7 --- /dev/null +++ b/distillation/trl_utf8_fix.py @@ -0,0 +1,68 @@ +""" +Fix for trl's encoding issue on Windows. +Pre-loads trl's template files with UTF-8 encoding to prevent cp1252 decode errors. +""" + +from pathlib import Path +import sys + + +def fix_trl_encoding(): + """ + Pre-read trl's chat template files with UTF-8 encoding. + This prevents trl from trying to read them later with the wrong encoding. + """ + try: + # Find trl installation path WITHOUT importing trl + # (importing trl would trigger the encoding error we're trying to fix) + import importlib.util + + spec = importlib.util.find_spec("trl") + if spec is None or spec.origin is None: + return + + trl_path = Path(spec.origin).parent + # Correct path: trl/chat_templates/ not trl/data/chat_templates/ + templates_dir = trl_path / "chat_templates" + + if not templates_dir.exists(): + return # trl structure might be different + + # Pre-read all jinja files with UTF-8 + template_cache = {} + for jinja_file in templates_dir.glob("*.jinja"): + try: + template_cache[jinja_file.name] = jinja_file.read_text(encoding="utf-8") + except Exception: + pass + + if not template_cache: + return + + # Now monkey-patch Path.read_text ONLY for trl's template directory + original_read_text = Path.read_text + + def patched_read_text(self, encoding=None, errors=None): + # Check if this is a trl template file + try: + resolved = self.resolve() + if resolved.parent == templates_dir.resolve(): + filename = resolved.name + if filename in template_cache: + return template_cache[filename] + except Exception: + pass + # Otherwise, use original with explicit UTF-8 default + if encoding is None: + encoding = "utf-8" + return original_read_text(self, encoding=encoding, errors=errors) + + Path.read_text = patched_read_text + + except Exception: + # If anything fails, don't break the import + pass + + +# Apply fix immediately when module is imported +fix_trl_encoding() diff --git a/inference_and_eval/qa_eval_hotpot.py b/inference_and_eval/qa_eval_hotpot.py index 3a5c3a2..770daf3 100644 --- a/inference_and_eval/qa_eval_hotpot.py +++ b/inference_and_eval/qa_eval_hotpot.py @@ -109,7 +109,6 @@ def get_args(): if __name__ == "__main__": - args = get_args() mongo_client = get_mongo_client(args.mongo_uri) db = mongo_client.get_database(args.ontology_db_name) @@ -118,6 +117,7 @@ def get_args(): ontology_db = mongo_client.get_database(args.ontology_db_name) api_key = os.getenv("OPENROUTER_KEY") + base_url = os.getenv("OPENROUTER_BASE_URL") proxy_url = os.getenv("PROXY_URL") model_name = args.model_name @@ -141,7 +141,9 @@ def get_args(): logger.info("Structured inference disabled, using dynamic inference") aligner = DynamicDBAligner(triplets_db=triplets_db) - extractor = LLMTripletExtractor(model=model_name, api_key=api_key, proxy=proxy_url) + extractor = LLMTripletExtractor( + model=model_name, api_key=api_key, base_url=base_url, proxy=proxy_url + ) if args.structured_inference: inference_with_db = StructuredInferenceWithDB( @@ -161,7 +163,6 @@ def get_args(): sample_id2ans = {} if args.multi_step_qa: - for sample_id in tqdm(unique_sample_ids): try: question = id2sample[sample_id]["question"] diff --git a/inference_and_eval/qa_eval_musique.py b/inference_and_eval/qa_eval_musique.py index 393f995..2be3302 100644 --- a/inference_and_eval/qa_eval_musique.py +++ b/inference_and_eval/qa_eval_musique.py @@ -104,7 +104,6 @@ def get_args(): if __name__ == "__main__": - args = get_args() mongo_client = get_mongo_client(args.mongo_uri) db = mongo_client.get_database(args.ontology_db_name) @@ -113,6 +112,7 @@ def get_args(): ontology_db = mongo_client.get_database(args.ontology_db_name) api_key = os.getenv("OPENROUTER_KEY") + base_url = os.getenv("OPENROUTER_BASE_URL") proxy_url = os.getenv("PROXY_URL") model_name = args.model_name @@ -135,7 +135,9 @@ def get_args(): logger.info("Structured inference disabled, using dynamic inference") aligner = DynamicDBAligner(triplets_db=triplets_db) - extractor = LLMTripletExtractor(model=model_name, api_key=api_key, proxy=proxy_url) + extractor = LLMTripletExtractor( + model=model_name, api_key=api_key, base_url=base_url, proxy=proxy_url + ) if args.structured_inference: inference_with_db = StructuredInferenceWithDB( @@ -155,7 +157,6 @@ def get_args(): sample_id2ans = {} if args.multi_step_qa: - for sample_id in tqdm(unique_sample_ids): try: question = id2sample[sample_id]["question"] diff --git a/pages/1_KG_Extraction.py b/pages/1_KG_Extraction.py index ee8d5c1..997ebf2 100644 --- a/pages/1_KG_Extraction.py +++ b/pages/1_KG_Extraction.py @@ -38,6 +38,7 @@ _ = load_dotenv(find_dotenv()) mongo_client = MongoClient(os.getenv("MONGO_URI")) api_key = os.getenv("KEY") +base_url = os.getenv("OPENROUTER_BASE_URL") proxy_url = os.getenv("PROXY_URL") ontology_db = mongo_client.get_database(WIKIDATA_ONTOLOGY_DB_NAME) triplets_db = mongo_client.get_database(TRIPLETS_DB_NAME) @@ -85,7 +86,6 @@ def visualize_knowledge_graph(triplets, highlight_entities=None): net.save_graph(tmp_file.name) html_path = tmp_file.name with open(html_path, "r", encoding="utf-8") as f: - st.components.v1.html(f.read(), height=600, scrolling=True) os.remove(html_path) @@ -210,7 +210,7 @@ def visualize_initial_knowledge_graph(initial_triplets): st.warning("Please select a model for KG extraction.") else: extractor = LLMTripletExtractor( - model=selected_model, api_key=api_key, proxy=proxy_url + model=selected_model, api_key=api_key, base_url=base_url, proxy=proxy_url ) inference_with_db = StructuredInferenceWithDB( extractor=extractor, aligner=aligner, triplets_db=triplets_db @@ -223,13 +223,13 @@ def visualize_initial_knowledge_graph(initial_triplets): ) = inference_with_db.extract_triplets_with_ontology_filtering_and_add_to_db( text=input_text, sample_id=user_id, source_text_id=None ) - logger.info("Initial triplets: ", initial_triplets) + logger.info("Initial triplets: %s", initial_triplets) logger.info("-" * 100) - logger.info("Refined triplets: ", final_triplets) + logger.info("Refined triplets: %s", final_triplets) logger.info("-" * 100) - logger.info("filtered_triplets: ", filtered_triplets) + logger.info("filtered_triplets: %s", filtered_triplets) logger.info("-" * 100) - logger.info("ontology_filtered_triplets: ", ontology_filtered_triplets) + logger.info("ontology_filtered_triplets: %s", ontology_filtered_triplets) logger.info("-" * 100) new_entities = {t["subject"] for t in final_triplets} | { t["object"] for t in final_triplets @@ -242,7 +242,6 @@ def visualize_initial_knowledge_graph(initial_triplets): col1, col2 = st.columns(2) with col1: - st.subheader("Extracted Triplets") visualize_initial_knowledge_graph(initial_triplets) diff --git a/pages/2_QA.py b/pages/2_QA.py index 36a79fd..2336284 100644 --- a/pages/2_QA.py +++ b/pages/2_QA.py @@ -35,6 +35,7 @@ TRIPLETS_DB_NAME = "demo" mongo_client = MongoClient(os.getenv("MONGO_URI")) api_key = os.getenv("KEY") +base_url = os.getenv("OPENROUTER_BASE_URL") proxy_url = os.getenv("PROXY_URL") triplets_db = mongo_client.get_database(TRIPLETS_DB_NAME) ontology_db = mongo_client.get_database(WIKIDATA_ONTOLOGY_DB_NAME) @@ -116,7 +117,7 @@ def query_kg(inferer, question_text): st.warning("Please select a model.") else: extractor = LLMTripletExtractor( - model=selected_model, api_key=api_key, proxy=proxy_url + model=selected_model, api_key=api_key, base_url=base_url, proxy=proxy_url ) inferer = StructuredInferenceWithDB( extractor=extractor, aligner=aligner, triplets_db=triplets_db diff --git a/pages/4_Personal_KG.py b/pages/4_Personal_KG.py index e506b64..a4be20e 100644 --- a/pages/4_Personal_KG.py +++ b/pages/4_Personal_KG.py @@ -30,6 +30,7 @@ _ = load_dotenv(find_dotenv()) mongo_client = MongoClient(os.getenv("MONGO_URI")) api_key = os.getenv("KEY") +base_url = os.getenv("OPENROUTER_BASE_URL") proxy_url = os.getenv("PROXY_URL") ontology_db = mongo_client.get_database(WIKIDATA_ONTOLOGY_DB_NAME) triplets_db = mongo_client.get_database(TRIPLETS_DB_NAME) @@ -77,7 +78,6 @@ def visualize_knowledge_graph(triplets, highlight_entities=None): net.save_graph(tmp_file.name) html_path = tmp_file.name with open(html_path, "r", encoding="utf-8") as f: - st.components.v1.html(f.read(), height=600, scrolling=True) os.remove(html_path) @@ -127,7 +127,7 @@ def visualize_knowledge_graph(triplets, highlight_entities=None): st.warning("Please select a model for KG extraction for the person.") else: extractor = LLMTripletExtractor( - model=selected_model, api_key=api_key, proxy=proxy_url + model=selected_model, api_key=api_key, base_url=base_url, proxy=proxy_url ) response = extractor.client.responses.create( model="gpt-4.1", diff --git a/setup_db.sh b/setup_db.sh index 15285c7..1213be1 100644 --- a/setup_db.sh +++ b/setup_db.sh @@ -1,7 +1,9 @@ docker pull mongodb/mongodb-atlas-local:latest -docker run --name text2kg_mongo -d -p 27018:27018 mongodb/mongodb-atlas-local:latest -python3 create_wikidata_ontology_db.py -python3 create_ontological_triplets_db.py +docker run --name text2kg_mongo -p 27018:27017 -d mongodb/mongodb-atlas-local:latest +sleep 15 +cd src/wikontic +python3 create_wikidata_ontology_db.py --mongo_uri "mongodb://localhost:27018/?directConnection=true" +python3 create_ontological_triplets_db.py --mongo_uri "mongodb://localhost:27018/?directConnection=true" # to not use the ontology from wikidata, run: # python3 create_triplets_db.py diff --git a/tutorial.ipynb b/tutorial.ipynb index e8314b5..bf56275 100644 --- a/tutorial.ipynb +++ b/tutorial.ipynb @@ -2,34 +2,208 @@ "cells": [ { "cell_type": "code", - "execution_count": null, "id": "40bf7409", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-24T17:52:47.448814Z", + "start_time": "2026-03-24T17:52:46.407967Z" + } + }, "source": [ "! pip install -U wikontic" - ] + ], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: wikontic in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (0.0.7)\n", + "Requirement already satisfied: streamlit in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (1.55.0)\n", + "Requirement already satisfied: numpy in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (2.4.3)\n", + "Requirement already satisfied: pyvis in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (0.3.2)\n", + "Requirement already satisfied: python-dotenv in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (1.2.2)\n", + "Requirement already satisfied: pymongo in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (4.16.0)\n", + "Requirement already satisfied: openai in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (2.29.0)\n", + "Requirement already satisfied: tenacity in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (9.1.4)\n", + "Requirement already satisfied: pathlib in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (1.0.1)\n", + "Requirement already satisfied: typing in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (3.7.4.3)\n", + "Requirement already satisfied: unidecode in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (1.4.0)\n", + "Requirement already satisfied: torch>=2.4.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (2.5.1+cu121)\n", + "Requirement already satisfied: transformers in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (5.3.0)\n", + "Requirement already satisfied: dataclasses in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (0.6)\n", + "Requirement already satisfied: pydantic in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (2.12.5)\n", + "Requirement already satisfied: accelerate in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (1.13.0)\n", + "Requirement already satisfied: langchain in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (1.2.13)\n", + "Requirement already satisfied: langchain_openai in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from wikontic) (1.1.11)\n", + "Requirement already satisfied: filelock in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from torch>=2.4.0->wikontic) (3.25.2)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from torch>=2.4.0->wikontic) (4.15.0)\n", + "Requirement already satisfied: networkx in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from torch>=2.4.0->wikontic) (3.6.1)\n", + "Requirement already satisfied: jinja2 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from torch>=2.4.0->wikontic) (3.1.6)\n", + "Requirement already satisfied: fsspec in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from torch>=2.4.0->wikontic) (2026.2.0)\n", + "Requirement already satisfied: setuptools in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from torch>=2.4.0->wikontic) (82.0.1)\n", + "Requirement already satisfied: sympy==1.13.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from torch>=2.4.0->wikontic) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from sympy==1.13.1->torch>=2.4.0->wikontic) (1.3.0)\n", + "Requirement already satisfied: packaging>=20.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from accelerate->wikontic) (26.0)\n", + "Requirement already satisfied: psutil in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from accelerate->wikontic) (7.2.2)\n", + "Requirement already satisfied: pyyaml in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from accelerate->wikontic) (6.0.3)\n", + "Requirement already satisfied: huggingface_hub>=0.21.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from accelerate->wikontic) (1.7.2)\n", + "Requirement already satisfied: safetensors>=0.4.3 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from accelerate->wikontic) (0.7.0)\n", + "Requirement already satisfied: hf-xet<2.0.0,>=1.4.2 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from huggingface_hub>=0.21.0->accelerate->wikontic) (1.4.2)\n", + "Requirement already satisfied: httpx<1,>=0.23.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from huggingface_hub>=0.21.0->accelerate->wikontic) (0.28.1)\n", + "Requirement already satisfied: tqdm>=4.42.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from huggingface_hub>=0.21.0->accelerate->wikontic) (4.67.3)\n", + "Requirement already satisfied: typer in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from huggingface_hub>=0.21.0->accelerate->wikontic) (0.24.1)\n", + "Requirement already satisfied: anyio in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from httpx<1,>=0.23.0->huggingface_hub>=0.21.0->accelerate->wikontic) (4.12.1)\n", + "Requirement already satisfied: certifi in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from httpx<1,>=0.23.0->huggingface_hub>=0.21.0->accelerate->wikontic) (2026.2.25)\n", + "Requirement already satisfied: httpcore==1.* in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from httpx<1,>=0.23.0->huggingface_hub>=0.21.0->accelerate->wikontic) (1.0.9)\n", + "Requirement already satisfied: idna in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from httpx<1,>=0.23.0->huggingface_hub>=0.21.0->accelerate->wikontic) (3.11)\n", + "Requirement already satisfied: h11>=0.16 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from httpcore==1.*->httpx<1,>=0.23.0->huggingface_hub>=0.21.0->accelerate->wikontic) (0.16.0)\n", + "Requirement already satisfied: colorama in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from tqdm>=4.42.1->huggingface_hub>=0.21.0->accelerate->wikontic) (0.4.6)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from jinja2->torch>=2.4.0->wikontic) (3.0.3)\n", + "Requirement already satisfied: langchain-core<2.0.0,>=1.2.10 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langchain->wikontic) (1.2.20)\n", + "Requirement already satisfied: langgraph<1.2.0,>=1.1.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langchain->wikontic) (1.1.3)\n", + "Requirement already satisfied: jsonpatch<2.0.0,>=1.33.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (1.33)\n", + "Requirement already satisfied: langsmith<1.0.0,>=0.3.45 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (0.7.22)\n", + "Requirement already satisfied: uuid-utils<1.0,>=0.12.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (0.14.1)\n", + "Requirement already satisfied: jsonpointer>=1.9 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from jsonpatch<2.0.0,>=1.33.0->langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (3.1.0)\n", + "Requirement already satisfied: langgraph-checkpoint<5.0.0,>=2.1.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langgraph<1.2.0,>=1.1.1->langchain->wikontic) (4.0.1)\n", + "Requirement already satisfied: langgraph-prebuilt<1.1.0,>=1.0.8 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langgraph<1.2.0,>=1.1.1->langchain->wikontic) (1.0.8)\n", + "Requirement already satisfied: langgraph-sdk<0.4.0,>=0.3.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langgraph<1.2.0,>=1.1.1->langchain->wikontic) (0.3.12)\n", + "Requirement already satisfied: xxhash>=3.5.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langgraph<1.2.0,>=1.1.1->langchain->wikontic) (3.6.0)\n", + "Requirement already satisfied: ormsgpack>=1.12.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langgraph-checkpoint<5.0.0,>=2.1.0->langgraph<1.2.0,>=1.1.1->langchain->wikontic) (1.12.2)\n", + "Requirement already satisfied: orjson>=3.11.5 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langgraph-sdk<0.4.0,>=0.3.0->langgraph<1.2.0,>=1.1.1->langchain->wikontic) (3.11.7)\n", + "Requirement already satisfied: requests-toolbelt>=1.0.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langsmith<1.0.0,>=0.3.45->langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (1.0.0)\n", + "Requirement already satisfied: requests>=2.0.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langsmith<1.0.0,>=0.3.45->langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (2.32.5)\n", + "Requirement already satisfied: zstandard>=0.23.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langsmith<1.0.0,>=0.3.45->langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (0.25.0)\n", + "Requirement already satisfied: annotated-types>=0.6.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pydantic->wikontic) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.41.5 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pydantic->wikontic) (2.41.5)\n", + "Requirement already satisfied: typing-inspection>=0.4.2 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pydantic->wikontic) (0.4.2)\n", + "Requirement already satisfied: charset_normalizer<4,>=2 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from requests>=2.0.0->langsmith<1.0.0,>=0.3.45->langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (3.4.6)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from requests>=2.0.0->langsmith<1.0.0,>=0.3.45->langchain-core<2.0.0,>=1.2.10->langchain->wikontic) (2.6.3)\n", + "Requirement already satisfied: tiktoken<1.0.0,>=0.7.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from langchain_openai->wikontic) (0.12.0)\n", + "Requirement already satisfied: distro<2,>=1.7.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from openai->wikontic) (1.9.0)\n", + "Requirement already satisfied: jiter<1,>=0.10.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from openai->wikontic) (0.13.0)\n", + "Requirement already satisfied: sniffio in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from openai->wikontic) (1.3.1)\n", + "Requirement already satisfied: regex>=2022.1.18 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from tiktoken<1.0.0,>=0.7.0->langchain_openai->wikontic) (2026.2.28)\n", + "Requirement already satisfied: dnspython<3.0.0,>=2.6.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pymongo->wikontic) (2.8.0)\n", + "Requirement already satisfied: ipython>=5.3.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pyvis->wikontic) (9.11.0)\n", + "Requirement already satisfied: jsonpickle>=1.4.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pyvis->wikontic) (4.1.1)\n", + "Requirement already satisfied: decorator>=5.1.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from ipython>=5.3.0->pyvis->wikontic) (5.2.1)\n", + "Requirement already satisfied: ipython-pygments-lexers>=1.0.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from ipython>=5.3.0->pyvis->wikontic) (1.1.1)\n", + "Requirement already satisfied: jedi>=0.18.2 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from ipython>=5.3.0->pyvis->wikontic) (0.19.2)\n", + "Requirement already satisfied: matplotlib-inline>=0.1.6 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from ipython>=5.3.0->pyvis->wikontic) (0.2.1)\n", + "Requirement already satisfied: prompt_toolkit<3.1.0,>=3.0.41 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from ipython>=5.3.0->pyvis->wikontic) (3.0.52)\n", + "Requirement already satisfied: pygments>=2.14.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from ipython>=5.3.0->pyvis->wikontic) (2.19.2)\n", + "Requirement already satisfied: stack_data>=0.6.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from ipython>=5.3.0->pyvis->wikontic) (0.6.3)\n", + "Requirement already satisfied: traitlets>=5.13.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from ipython>=5.3.0->pyvis->wikontic) (5.14.3)\n", + "Requirement already satisfied: wcwidth in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from prompt_toolkit<3.1.0,>=3.0.41->ipython>=5.3.0->pyvis->wikontic) (0.6.0)\n", + "Requirement already satisfied: parso<0.9.0,>=0.8.4 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from jedi>=0.18.2->ipython>=5.3.0->pyvis->wikontic) (0.8.6)\n", + "Requirement already satisfied: executing>=1.2.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from stack_data>=0.6.0->ipython>=5.3.0->pyvis->wikontic) (2.2.1)\n", + "Requirement already satisfied: asttokens>=2.1.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from stack_data>=0.6.0->ipython>=5.3.0->pyvis->wikontic) (3.0.1)\n", + "Requirement already satisfied: pure-eval in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from stack_data>=0.6.0->ipython>=5.3.0->pyvis->wikontic) (0.2.3)\n", + "Requirement already satisfied: altair!=5.4.0,!=5.4.1,<7,>=4.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (6.0.0)\n", + "Requirement already satisfied: blinker<2,>=1.5.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (1.9.0)\n", + "Requirement already satisfied: cachetools<8,>=5.5 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (7.0.5)\n", + "Requirement already satisfied: click<9,>=7.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (8.3.1)\n", + "Requirement already satisfied: gitpython!=3.1.19,<4,>=3.0.7 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (3.1.46)\n", + "Requirement already satisfied: pandas<3,>=1.4.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (2.3.3)\n", + "Requirement already satisfied: pillow<13,>=7.1.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (12.1.1)\n", + "Requirement already satisfied: pydeck<1,>=0.8.0b4 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (0.9.1)\n", + "Requirement already satisfied: protobuf<7,>=3.20 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (6.33.6)\n", + "Requirement already satisfied: pyarrow>=7.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (23.0.1)\n", + "Requirement already satisfied: toml<2,>=0.10.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (0.10.2)\n", + "Requirement already satisfied: tornado!=6.5.0,<7,>=6.0.3 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (6.5.5)\n", + "Requirement already satisfied: watchdog<7,>=2.1.5 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from streamlit->wikontic) (6.0.0)\n", + "Requirement already satisfied: jsonschema>=3.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from altair!=5.4.0,!=5.4.1,<7,>=4.0->streamlit->wikontic) (4.26.0)\n", + "Requirement already satisfied: narwhals>=1.27.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from altair!=5.4.0,!=5.4.1,<7,>=4.0->streamlit->wikontic) (2.18.0)\n", + "Requirement already satisfied: gitdb<5,>=4.0.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from gitpython!=3.1.19,<4,>=3.0.7->streamlit->wikontic) (4.0.12)\n", + "Requirement already satisfied: smmap<6,>=3.0.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from gitdb<5,>=4.0.1->gitpython!=3.1.19,<4,>=3.0.7->streamlit->wikontic) (5.0.3)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pandas<3,>=1.4.0->streamlit->wikontic) (2.9.0.post0)\n", + "Requirement already satisfied: pytz>=2020.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pandas<3,>=1.4.0->streamlit->wikontic) (2026.1.post1)\n", + "Requirement already satisfied: tzdata>=2022.7 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from pandas<3,>=1.4.0->streamlit->wikontic) (2025.3)\n", + "Requirement already satisfied: attrs>=22.2.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from jsonschema>=3.0->altair!=5.4.0,!=5.4.1,<7,>=4.0->streamlit->wikontic) (26.1.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from jsonschema>=3.0->altair!=5.4.0,!=5.4.1,<7,>=4.0->streamlit->wikontic) (2025.9.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from jsonschema>=3.0->altair!=5.4.0,!=5.4.1,<7,>=4.0->streamlit->wikontic) (0.37.0)\n", + "Requirement already satisfied: rpds-py>=0.25.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from jsonschema>=3.0->altair!=5.4.0,!=5.4.1,<7,>=4.0->streamlit->wikontic) (0.30.0)\n", + "Requirement already satisfied: six>=1.5 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from python-dateutil>=2.8.2->pandas<3,>=1.4.0->streamlit->wikontic) (1.17.0)\n", + "Requirement already satisfied: tokenizers<=0.23.0,>=0.22.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from transformers->wikontic) (0.22.2)\n", + "Requirement already satisfied: shellingham>=1.3.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from typer->huggingface_hub>=0.21.0->accelerate->wikontic) (1.5.4)\n", + "Requirement already satisfied: rich>=12.3.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from typer->huggingface_hub>=0.21.0->accelerate->wikontic) (14.3.3)\n", + "Requirement already satisfied: annotated-doc>=0.0.2 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from typer->huggingface_hub>=0.21.0->accelerate->wikontic) (0.0.4)\n", + "Requirement already satisfied: markdown-it-py>=2.2.0 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from rich>=12.3.0->typer->huggingface_hub>=0.21.0->accelerate->wikontic) (4.0.0)\n", + "Requirement already satisfied: mdurl~=0.1 in d:\\pycharmprojects\\wikontic\\.venv\\lib\\site-packages (from markdown-it-py>=2.2.0->rich>=12.3.0->typer->huggingface_hub>=0.21.0->accelerate->wikontic) (0.1.2)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "[notice] A new release of pip is available: 25.1.1 -> 26.0.1\n", + "[notice] To update, run: python.exe -m pip install --upgrade pip\n" + ] + } + ], + "execution_count": 14 }, { "cell_type": "code", - "execution_count": null, "id": "b44a1cae", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-24T17:54:32.469590Z", + "start_time": "2026-03-24T17:54:26.792298Z" + } + }, "source": [ "from wikontic.utils.structured_inference_with_db import StructuredInferenceWithDB\n", "from wikontic.utils.openai_utils import LLMTripletExtractor\n", "from wikontic.utils.structured_aligner import Aligner\n", "\n", "from pymongo.mongo_client import MongoClient" - ] + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "D:\\PycharmProjects\\Wikontic\\.venv\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "2026-03-24 20:54:29,239 - INFO - HTTP Request: HEAD https://huggingface.co/facebook/contriever/resolve/main/config.json \"HTTP/1.1 307 Temporary Redirect\"\n", + "2026-03-24 20:54:29,268 - INFO - HTTP Request: HEAD https://huggingface.co/api/resolve-cache/models/facebook/contriever/2bd46a25019aeea091fd42d1f0fd4801675cf699/config.json \"HTTP/1.1 200 OK\"\n", + "2026-03-24 20:54:29,434 - INFO - HTTP Request: HEAD https://huggingface.co/facebook/contriever/resolve/main/tokenizer_config.json \"HTTP/1.1 307 Temporary Redirect\"\n", + "2026-03-24 20:54:29,463 - INFO - HTTP Request: HEAD https://huggingface.co/api/resolve-cache/models/facebook/contriever/2bd46a25019aeea091fd42d1f0fd4801675cf699/tokenizer_config.json \"HTTP/1.1 200 OK\"\n", + "2026-03-24 20:54:29,622 - INFO - HTTP Request: GET https://huggingface.co/api/models/facebook/contriever/tree/main/additional_chat_templates?recursive=false&expand=false \"HTTP/1.1 404 Not Found\"\n", + "2026-03-24 20:54:29,777 - INFO - HTTP Request: GET https://huggingface.co/api/models/facebook/contriever/tree/main?recursive=true&expand=false \"HTTP/1.1 200 OK\"\n", + "2026-03-24 20:54:29,962 - INFO - HTTP Request: HEAD https://huggingface.co/facebook/contriever/resolve/main/config.json \"HTTP/1.1 307 Temporary Redirect\"\n", + "2026-03-24 20:54:29,991 - INFO - HTTP Request: HEAD https://huggingface.co/api/resolve-cache/models/facebook/contriever/2bd46a25019aeea091fd42d1f0fd4801675cf699/config.json \"HTTP/1.1 200 OK\"\n", + "2026-03-24 20:54:30,741 - INFO - HTTP Request: GET https://huggingface.co/api/models/facebook/contriever \"HTTP/1.1 200 OK\"\n", + "2026-03-24 20:54:30,902 - INFO - HTTP Request: GET https://huggingface.co/api/models/facebook/contriever/commits/main \"HTTP/1.1 200 OK\"\n", + "2026-03-24 20:54:31,065 - INFO - HTTP Request: GET https://huggingface.co/api/models/facebook/contriever/discussions?p=0 \"HTTP/1.1 200 OK\"\n", + "2026-03-24 20:54:31,266 - INFO - HTTP Request: GET https://huggingface.co/api/models/facebook/contriever/commits/refs%2Fpr%2F2 \"HTTP/1.1 200 OK\"\n", + "2026-03-24 20:54:31,421 - INFO - HTTP Request: HEAD https://huggingface.co/facebook/contriever/resolve/refs%2Fpr%2F2/model.safetensors.index.json \"HTTP/1.1 404 Not Found\"\n", + "2026-03-24 20:54:31,578 - INFO - HTTP Request: HEAD https://huggingface.co/facebook/contriever/resolve/refs%2Fpr%2F2/model.safetensors \"HTTP/1.1 302 Found\"\n", + "Loading weights: 100%|██████████| 199/199 [00:00<00:00, 12055.03it/s]\n", + "\u001B[1mBertModel LOAD REPORT\u001B[0m from: facebook/contriever\n", + "Key | Status | | \n", + "------------------------+------------+--+-\n", + "embeddings.position_ids | UNEXPECTED | | \n", + "\n", + "\u001B[3mNotes:\n", + "- UNEXPECTED\u001B[3m\t:can be ignored when loading from different task/architecture; not ok if you expect identical arch.\u001B[0m\n" + ] + } + ], + "execution_count": 1 }, { "cell_type": "code", - "execution_count": null, "id": "77bb4e1a", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-24T17:54:36.232867Z", + "start_time": "2026-03-24T17:54:36.039874Z" + } + }, "source": [ "from langchain.agents import create_agent\n", "\n", @@ -40,7 +214,9 @@ "import httpx\n", "\n", "import os" - ] + ], + "outputs": [], + "execution_count": 2 }, { "cell_type": "markdown", @@ -62,10 +238,13 @@ }, { "cell_type": "code", - "execution_count": null, "id": "de2002d6", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-24T17:54:38.692363Z", + "start_time": "2026-03-24T17:54:38.543576Z" + } + }, "source": [ "_ = load_dotenv(find_dotenv())\n", "\n", @@ -73,7 +252,9 @@ "api_key = os.getenv(\"OPENROUTER_KEY\")\n", "proxy_url = os.getenv(\"PROXY_URL\")\n", "http_client = httpx.Client(proxy=proxy_url)" - ] + ], + "outputs": [], + "execution_count": 3 }, { "cell_type": "markdown", @@ -103,41 +284,140 @@ "- object_type — class describing the object entity" ] }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-25T16:45:16.522372Z", + "start_time": "2026-03-25T16:45:16.495442Z" + } + }, + "cell_type": "code", + "source": [ + "from pymongo import MongoClient\n", + "\n", + "mongo_client = MongoClient(\"mongodb://localhost:27018/?directConnection=true\")\n", + "\n", + "indexes = list(\n", + " mongo_client.get_database(\"demo\")\n", + " .get_collection(\"Q5\")\n", + " .list_search_indexes()\n", + ")\n", + "\n", + "db = mongo_client[\"demo\"]\n", + "print(db.list_collection_names())\n", + "print(indexes)\n", + "print(mongo_client.list_database_names())" + ], + "id": "4626ecf6f96c482e", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['initial_triplets', 'ontology_filtered_triplets']\n", + "[]\n", + "['admin', 'config', 'demo', 'local']\n" + ] + } + ], + "execution_count": 12 + }, { "cell_type": "code", - "execution_count": null, "id": "1d35201d", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-24T17:54:41.216796Z", + "start_time": "2026-03-24T17:54:41.065591Z" + } + }, "source": [ "from wikontic.utils.openai_utils import LLMTripletExtractor\n", "\n", - "extractor = LLMTripletExtractor(model=\"gpt-4o\", api_key=api_key, proxy=proxy_url)" - ] + "extractor = LLMTripletExtractor(model=\"gpt-4o\", api_key=api_key, base_url=base_url, proxy=proxy_url)" + ], + "outputs": [], + "execution_count": 4 }, { "cell_type": "code", - "execution_count": null, "id": "468ce3a0", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-24T17:54:43.464194Z", + "start_time": "2026-03-24T17:54:43.461803Z" + } + }, "source": [ "text_1 = \"\"\"\n", " Steven Paul Jobs (February 24, 1955 – October 5, 2011) was an American businessman, inventor, \n", " and investor best known for co-founding the technology company Apple Inc.\n", " \"\"\"" - ] + ], + "outputs": [], + "execution_count": 5 }, { "cell_type": "code", - "execution_count": null, "id": "859bcd01", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-03-24T17:54:48.771247Z", + "start_time": "2026-03-24T17:54:44.890525Z" + } + }, "source": [ "triplets = extractor.extract_triplets_from_text(text=text_1)\n", "triplets" - ] + ], + "outputs": [ + { + "data": { + "text/plain": [ + "{'triplets': [{'subject': 'Steven Paul Jobs',\n", + " 'relation': 'date of birth',\n", + " 'object': 'February 24, 1955',\n", + " 'qualifiers': [],\n", + " 'subject_type': 'human',\n", + " 'object_type': 'date'},\n", + " {'subject': 'Steven Paul Jobs',\n", + " 'relation': 'date of death',\n", + " 'object': 'October 5, 2011',\n", + " 'qualifiers': [],\n", + " 'subject_type': 'human',\n", + " 'object_type': 'date'},\n", + " {'subject': 'Steven Paul Jobs',\n", + " 'relation': 'occupation',\n", + " 'object': 'businessman',\n", + " 'qualifiers': [],\n", + " 'subject_type': 'human',\n", + " 'object_type': 'profession'},\n", + " {'subject': 'Steven Paul Jobs',\n", + " 'relation': 'occupation',\n", + " 'object': 'inventor',\n", + " 'qualifiers': [],\n", + " 'subject_type': 'human',\n", + " 'object_type': 'profession'},\n", + " {'subject': 'Steven Paul Jobs',\n", + " 'relation': 'occupation',\n", + " 'object': 'investor',\n", + " 'qualifiers': [],\n", + " 'subject_type': 'human',\n", + " 'object_type': 'profession'},\n", + " {'subject': 'Steven Paul Jobs',\n", + " 'relation': 'notable work',\n", + " 'object': 'Apple Inc.',\n", + " 'qualifiers': [],\n", + " 'subject_type': 'human',\n", + " 'object_type': 'organization'}]}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 6 }, { "cell_type": "markdown", @@ -228,7 +508,7 @@ "mongo_client = get_mongo_client(\"mongodb://localhost:27018/?directConnection=true\")\n", "triplets_db = mongo_client.get_database(\"test_db_non_onto\")\n", "\n", - "extractor = LLMTripletExtractor(model=\"gpt-4o\", api_key=api_key, proxy=proxy_url)\n", + "extractor = LLMTripletExtractor(model=\"gpt-4o\", api_key=api_key, base_url=base_url, proxy=proxy_url)\n", "\n", "aligner = Aligner(triplets_db=triplets_db)\n", "inferer = InferenceWithDB(extractor, aligner, triplets_db)"