diff --git a/python/notebooks/05_data_versioning.ipynb b/python/notebooks/05_data_versioning.ipynb index f5c4afdf2a..504515a2b2 100644 --- a/python/notebooks/05_data_versioning.ipynb +++ b/python/notebooks/05_data_versioning.ipynb @@ -26,6 +26,21 @@ "- Different versions are concurrently queryable without complicate \"git checkout semantics\"" ] }, + { + "cell_type": "markdown", + "id": "bd60091b", + "metadata": {}, + "source": [ + "Setup venv\n", + "\n", + "```sh\n", + "python3 -m venv ~/.venv/lance\n", + "source ~/.venv/lance/bin/activate\n", + "pip install jupyter\n", + "jupyter notebook # in the same directory as this notebook\n", + "```" + ] + }, { "cell_type": "markdown", "id": "72c170b1", @@ -39,9 +54,76 @@ "execution_count": 1, "id": "e8e711c8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: pylance in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (0.2.3)\n", + "Requirement already satisfied: duckdb==0.5.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (0.5.1)\n", + "Requirement already satisfied: fastai in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (2.7.10)\n", + "Requirement already satisfied: matplotlib in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (3.6.2)\n", + "Requirement already satisfied: numpy>=1.14 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from duckdb==0.5.1) (1.23.4)\n", + "Requirement already satisfied: requests in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from pylance) (2.28.1)\n", + "Requirement already satisfied: pyarrow<11,>=10 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from pylance) (10.0.0)\n", + "Requirement already satisfied: pandas in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from pylance) (1.5.1)\n", + "Requirement already satisfied: pillow in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from pylance) (9.3.0)\n", + "Requirement already satisfied: pip in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (22.2.2)\n", + "Requirement already satisfied: pyyaml in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (6.0)\n", + "Requirement already satisfied: scipy in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (1.9.3)\n", + "Requirement already satisfied: fastcore<1.6,>=1.4.5 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (1.5.27)\n", + "Requirement already satisfied: spacy<4 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (3.4.3)\n", + "Requirement already satisfied: scikit-learn in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (1.1.3)\n", + "Requirement already satisfied: fastdownload<2,>=0.0.5 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (0.0.7)\n", + "Requirement already satisfied: packaging in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (21.3)\n", + "Requirement already satisfied: torchvision>=0.8.2 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (0.14.0)\n", + "Requirement already satisfied: torch<1.14,>=1.7 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (1.13.0)\n", + "Requirement already satisfied: fastprogress>=0.2.4 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from fastai) (1.0.3)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from matplotlib) (1.0.6)\n", + "Requirement already satisfied: pyparsing>=2.2.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from matplotlib) (3.0.9)\n", + "Requirement already satisfied: cycler>=0.10 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from matplotlib) (0.11.0)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from matplotlib) (4.38.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from matplotlib) (2.8.2)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from matplotlib) (1.4.4)\n", + "Requirement already satisfied: six>=1.5 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from python-dateutil>=2.7->matplotlib) (1.16.0)\n", + "Requirement already satisfied: setuptools in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (63.2.0)\n", + "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (3.3.0)\n", + "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (3.0.8)\n", + "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (1.0.9)\n", + "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (0.10.1)\n", + "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (1.0.3)\n", + "Requirement already satisfied: typer<0.8.0,>=0.3.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (0.7.0)\n", + "Requirement already satisfied: thinc<8.2.0,>=8.1.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (8.1.5)\n", + "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.11.0,>=1.7.4 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (1.10.2)\n", + "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.10 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (3.0.10)\n", + "Requirement already satisfied: jinja2 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (3.1.2)\n", + "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (4.64.1)\n", + "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (2.0.8)\n", + "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (2.4.5)\n", + "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (2.0.7)\n", + "Requirement already satisfied: pathy>=0.3.5 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from spacy<4->fastai) (0.7.1)\n", + "Requirement already satisfied: charset-normalizer<3,>=2 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from requests->pylance) (2.1.1)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from requests->pylance) (1.26.12)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from requests->pylance) (2022.9.24)\n", + "Requirement already satisfied: idna<4,>=2.5 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from requests->pylance) (3.4)\n", + "Requirement already satisfied: typing-extensions in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from torch<1.14,>=1.7->fastai) (4.4.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from pandas->pylance) (2022.6)\n", + "Requirement already satisfied: joblib>=1.0.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from scikit-learn->fastai) (1.2.0)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from scikit-learn->fastai) (3.1.0)\n", + "Requirement already satisfied: smart-open<6.0.0,>=5.2.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from pathy>=0.3.5->spacy<4->fastai) (5.2.1)\n", + "Requirement already satisfied: confection<1.0.0,>=0.0.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from thinc<8.2.0,>=8.1.0->spacy<4->fastai) (0.0.3)\n", + "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from thinc<8.2.0,>=8.1.0->spacy<4->fastai) (0.7.9)\n", + "Requirement already satisfied: click<9.0.0,>=7.1.1 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from typer<0.8.0,>=0.3.0->spacy<4->fastai) (8.1.3)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /Users/changshe/.venv/nbtest/lib/python3.10/site-packages (from jinja2->spacy<4->fastai) (2.1.1)\n", + "\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.2.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m22.3.1\u001b[0m\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n" + ] + } + ], "source": [ - "!pip install --quiet pylance duckdb fastai matplotlib" + "# Add --quiet after install if you don't want to see the output\n", + "!pip install pylance duckdb==0.5.1 fastai matplotlib" ] }, { @@ -63,26 +145,6 @@ "plt.rcParams.update({\"font.size\": 18})" ] }, - { - "cell_type": "markdown", - "id": "7f41f4c7", - "metadata": {}, - "source": [ - "Install lance duckdb extension" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "c81dfe55", - "metadata": {}, - "outputs": [], - "source": [ - "# This only needs to be done once\n", - "from lance.util.duckdb_ext import install_duckdb_extension\n", - "install_duckdb_extension()" - ] - }, { "cell_type": "markdown", "id": "de35d965", @@ -93,10 +155,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "28a5d571", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.2.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m22.3.1\u001b[0m\r\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\r\n" + ] + }, { "data": { "application/javascript": [ @@ -119,7 +190,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "{'config': {'allow_unsigned_extensions': 'true'}, 'preload_extensions': ['lance']}\n" + "{}\n" ] } ], @@ -127,7 +198,7 @@ "!pip install --quiet duckdb-engine git+https://github.com/eto-ai/ipython-sql\n", "\n", "%load_ext sql\n", - "%sql duckdb:///:memory: --connection_arguments {\"config\":{\"allow_unsigned_extensions\":\"true\"},\"preload_extensions\":[\"lance\"]}" + "%sql duckdb:///:memory:" ] }, { @@ -148,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "7ccda2ca", "metadata": {}, "outputs": [], @@ -167,10 +238,19 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "d5040a4e", "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\r\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip available: \u001b[0m\u001b[31;49m22.2.2\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m22.3.1\u001b[0m\r\n", + "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\r\n" + ] + }, { "data": { "text/html": [ @@ -323,12 +403,14 @@ "4 https://eto-public.s3.us-west-2.amazonaws.com/datasets/oxford_pet/images/Abyssinian_104.jpg " ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "!pip install --quiet xmltodict\n", + "\n", "from lance.data.convert.oxford_pet import OxfordPetConverter\n", "images_root = \"https://eto-public.s3.us-west-2.amazonaws.com/datasets/oxford_pet\"\n", "c = OxfordPetConverter(str(path), images_root)\n", @@ -338,13 +420,21 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "d8adf67f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2.3\n" + ] + } + ], "source": [ "import lance\n", - "lance.__version__\n", + "print(lance.__version__)\n", "\n", "!rm -rf /tmp/pet.lance\n", "uri = \"/tmp/pet.lance\"" @@ -369,42 +459,28 @@ "id": "9e506cc1", "metadata": {}, "source": [ - "Let's create a training dataset from the first 1000 images" + "Let's create a training dataset in batches of 1000 images.\n", + "Assume we're adding training examples in iterations and training a new model after each batch" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "be7ff85e", "metadata": {}, "outputs": [], "source": [ "import lance\n", - "first_batch = c.to_table(metadata[:1000]) # it's just a pyarrow Table\n", - "lance.write_dataset(first_batch, uri)" - ] - }, - { - "cell_type": "markdown", - "id": "6002444a", - "metadata": {}, - "source": [ - "Suppose we iterate on the model 7 more times, each time adding about 1000 more labeled images" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "70075829", - "metadata": {}, - "outputs": [], - "source": [ - "for i in range(1, 8):\n", - " start = i * 1000\n", - " end = (i + 1) * 1000\n", - " end = min(len(metadata), end)\n", - " batch = c.to_table(metadata[start:end])\n", - " lance.write_dataset(batch, uri, mode=\"append\")" + "import pyarrow as pa\n", + "\n", + "tbl = c.to_table(metadata)\n", + "reader = tbl.to_reader(1000)\n", + "\n", + "\n", + "for idx, batch in enumerate(reader):\n", + " lance.write_dataset(pa.Table.from_batches([batch]), \n", + " uri, \n", + " mode=\"append\" if idx > 0 else \"create\")" ] }, { @@ -420,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "id": "f195174c", "metadata": {}, "outputs": [ @@ -437,7 +513,7 @@ " {'version': 8}]" ] }, - "execution_count": 10, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -457,7 +533,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "id": "536b0f24", "metadata": {}, "outputs": [ @@ -467,7 +543,7 @@ "1000" ] }, - "execution_count": 11, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -479,7 +555,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "id": "6d1f0cef", "metadata": {}, "outputs": [ @@ -489,22 +565,12 @@ "text": [ "{'version': 8}\n" ] - }, - { - "data": { - "text/plain": [ - "7349" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ "v8 = lance.dataset(uri, version=8)\n", "print(v8.version)\n", - "v8.count_rows()" + "#v8.count_rows()" ] }, { @@ -520,7 +586,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "id": "7479bb41", "metadata": {}, "outputs": [ @@ -528,7 +594,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Took 0.8775603771209717\n" + "Took 0.36563706398010254\n" ] }, { @@ -681,200 +747,200 @@ " \n", " 20\n", " v8\n", - " Abyssinian\n", - " 198\n", + " Sphynx\n", + " 200\n", " \n", " \n", " 21\n", " v8\n", - " american_bulldog\n", - " 200\n", + " staffordshire_bull_terrier\n", + " 189\n", " \n", " \n", " 22\n", " v8\n", - " american_pit_bull_terrier\n", + " wheaten_terrier\n", " 200\n", " \n", " \n", " 23\n", " v8\n", - " basset_hound\n", + " yorkshire_terrier\n", " 200\n", " \n", " \n", " 24\n", " v8\n", - " beagle\n", - " 200\n", + " Abyssinian\n", + " 198\n", " \n", " \n", " 25\n", " v8\n", - " Bengal\n", + " american_bulldog\n", " 200\n", " \n", " \n", " 26\n", " v8\n", - " Birman\n", + " american_pit_bull_terrier\n", " 200\n", " \n", " \n", " 27\n", " v8\n", - " Bombay\n", - " 184\n", + " basset_hound\n", + " 200\n", " \n", " \n", " 28\n", " v8\n", - " boxer\n", - " 199\n", + " beagle\n", + " 200\n", " \n", " \n", " 29\n", " v8\n", - " British_Shorthair\n", + " Bengal\n", " 200\n", " \n", " \n", " 30\n", " v8\n", - " chihuahua\n", + " Birman\n", " 200\n", " \n", " \n", " 31\n", " v8\n", - " english_cocker_spaniel\n", - " 196\n", + " Bombay\n", + " 184\n", " \n", " \n", " 32\n", " v8\n", - " english_setter\n", - " 200\n", + " boxer\n", + " 199\n", " \n", " \n", " 33\n", " v8\n", - " great_pyrenees\n", + " British_Shorthair\n", " 200\n", " \n", " \n", " 34\n", " v8\n", - " havanese\n", + " chihuahua\n", " 200\n", " \n", " \n", " 35\n", " v8\n", - " japanese_chin\n", - " 200\n", + " english_cocker_spaniel\n", + " 196\n", " \n", " \n", " 36\n", " v8\n", - " leonberger\n", + " english_setter\n", " 200\n", " \n", " \n", " 37\n", " v8\n", - " Maine_Coon\n", + " great_pyrenees\n", " 200\n", " \n", " \n", " 38\n", " v8\n", - " miniature_pinscher\n", + " havanese\n", " 200\n", " \n", " \n", " 39\n", " v8\n", - " newfoundland\n", - " 196\n", + " japanese_chin\n", + " 200\n", " \n", " \n", " 40\n", " v8\n", - " Persian\n", + " leonberger\n", " 200\n", " \n", " \n", " 41\n", " v8\n", - " pomeranian\n", + " Maine_Coon\n", " 200\n", " \n", " \n", " 42\n", " v8\n", - " pug\n", + " miniature_pinscher\n", " 200\n", " \n", " \n", " 43\n", " v8\n", - " Ragdoll\n", - " 200\n", + " newfoundland\n", + " 196\n", " \n", " \n", " 44\n", " v8\n", - " Russian_Blue\n", + " Persian\n", " 200\n", " \n", " \n", " 45\n", " v8\n", - " samoyed\n", + " pomeranian\n", " 200\n", " \n", " \n", " 46\n", " v8\n", - " scottish_terrier\n", - " 199\n", + " pug\n", + " 200\n", " \n", " \n", " 47\n", " v8\n", - " shiba_inu\n", + " Ragdoll\n", " 200\n", " \n", " \n", " 48\n", " v8\n", - " Siamese\n", - " 199\n", + " Russian_Blue\n", + " 200\n", " \n", " \n", " 49\n", " v8\n", - " Sphynx\n", + " samoyed\n", " 200\n", " \n", " \n", " 50\n", " v8\n", - " staffordshire_bull_terrier\n", - " 189\n", + " scottish_terrier\n", + " 199\n", " \n", " \n", " 51\n", " v8\n", - " wheaten_terrier\n", + " shiba_inu\n", " 200\n", " \n", " \n", " 52\n", " v8\n", - " yorkshire_terrier\n", - " 200\n", + " Siamese\n", + " 199\n", " \n", " \n", " 53\n", @@ -932,39 +998,39 @@ "17 v1 keeshond 50\n", "18 v1 leonberger 50\n", "19 v1 Maine_Coon 4\n", - "20 v8 Abyssinian 198\n", - "21 v8 american_bulldog 200\n", - "22 v8 american_pit_bull_terrier 200\n", - "23 v8 basset_hound 200\n", - "24 v8 beagle 200\n", - "25 v8 Bengal 200\n", - "26 v8 Birman 200\n", - "27 v8 Bombay 184\n", - "28 v8 boxer 199\n", - "29 v8 British_Shorthair 200\n", - "30 v8 chihuahua 200\n", - "31 v8 english_cocker_spaniel 196\n", - "32 v8 english_setter 200\n", - "33 v8 great_pyrenees 200\n", - "34 v8 havanese 200\n", - "35 v8 japanese_chin 200\n", - "36 v8 leonberger 200\n", - "37 v8 Maine_Coon 200\n", - "38 v8 miniature_pinscher 200\n", - "39 v8 newfoundland 196\n", - "40 v8 Persian 200\n", - "41 v8 pomeranian 200\n", - "42 v8 pug 200\n", - "43 v8 Ragdoll 200\n", - "44 v8 Russian_Blue 200\n", - "45 v8 samoyed 200\n", - "46 v8 scottish_terrier 199\n", - "47 v8 shiba_inu 200\n", - "48 v8 Siamese 199\n", - "49 v8 Sphynx 200\n", - "50 v8 staffordshire_bull_terrier 189\n", - "51 v8 wheaten_terrier 200\n", - "52 v8 yorkshire_terrier 200\n", + "20 v8 Sphynx 200\n", + "21 v8 staffordshire_bull_terrier 189\n", + "22 v8 wheaten_terrier 200\n", + "23 v8 yorkshire_terrier 200\n", + "24 v8 Abyssinian 198\n", + "25 v8 american_bulldog 200\n", + "26 v8 american_pit_bull_terrier 200\n", + "27 v8 basset_hound 200\n", + "28 v8 beagle 200\n", + "29 v8 Bengal 200\n", + "30 v8 Birman 200\n", + "31 v8 Bombay 184\n", + "32 v8 boxer 199\n", + "33 v8 British_Shorthair 200\n", + "34 v8 chihuahua 200\n", + "35 v8 english_cocker_spaniel 196\n", + "36 v8 english_setter 200\n", + "37 v8 great_pyrenees 200\n", + "38 v8 havanese 200\n", + "39 v8 japanese_chin 200\n", + "40 v8 leonberger 200\n", + "41 v8 Maine_Coon 200\n", + "42 v8 miniature_pinscher 200\n", + "43 v8 newfoundland 196\n", + "44 v8 Persian 200\n", + "45 v8 pomeranian 200\n", + "46 v8 pug 200\n", + "47 v8 Ragdoll 200\n", + "48 v8 Russian_Blue 200\n", + "49 v8 samoyed 200\n", + "50 v8 scottish_terrier 199\n", + "51 v8 shiba_inu 200\n", + "52 v8 Siamese 199\n", "53 v1 german_shorthaired 50\n", "54 v8 Egyptian_Mau 190\n", "55 v8 german_shorthaired 200\n", @@ -972,7 +1038,7 @@ "57 v8 saint_bernard 200" ] }, - "execution_count": 13, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -1000,7 +1066,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "id": "078eccb7", "metadata": { "scrolled": false @@ -1012,13 +1078,13 @@ "" ] }, - "execution_count": 14, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1046,7 +1112,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 13, "id": "9bcdea73", "metadata": {}, "outputs": [ @@ -1054,7 +1120,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Took 0.006819486618041992\n" + "Took 0.0033800601959228516\n" ] }, { @@ -1340,10 +1406,10 @@ "\n" ], "text/plain": [ - "" + "" ] }, - "execution_count": 29, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -1377,7 +1443,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 14, "id": "9755d013", "metadata": {}, "outputs": [ @@ -1386,24 +1452,24 @@ "output_type": "stream", "text": [ "/tmp/pet.lance/_versions\n", + " /tmp/pet.lance/_versions/8.manifest\n", + " /tmp/pet.lance/_versions/2.manifest\n", " /tmp/pet.lance/_versions/3.manifest\n", - " /tmp/pet.lance/_versions/4.manifest\n", - " /tmp/pet.lance/_versions/7.manifest\n", " /tmp/pet.lance/_versions/5.manifest\n", + " /tmp/pet.lance/_versions/4.manifest\n", " /tmp/pet.lance/_versions/1.manifest\n", - " /tmp/pet.lance/_versions/8.manifest\n", - " /tmp/pet.lance/_versions/2.manifest\n", " /tmp/pet.lance/_versions/6.manifest\n", + " /tmp/pet.lance/_versions/7.manifest\n", + "/tmp/pet.lance/_latest.manifest\n", "/tmp/pet.lance/data\n", - " /tmp/pet.lance/data/3cb855db-ce23-4dc0-bbf6-0cc92d31eaaf_0.lance\n", - " /tmp/pet.lance/data/1b47abc3-6f59-42ca-9316-fb0b7e4af318_0.lance\n", - " /tmp/pet.lance/data/58b93c55-9cb7-4f22-bf4d-f45ab8c449a0_0.lance\n", - " /tmp/pet.lance/data/257e6e76-19f3-4f92-bfb7-20bd3c4561d1_0.lance\n", - " /tmp/pet.lance/data/2344d6c3-1f5e-4c89-90c9-bd54094471d3_0.lance\n", - " /tmp/pet.lance/data/5c636bf2-e672-45cf-8937-20a346800f86_0.lance\n", - " /tmp/pet.lance/data/9ee19246-282a-46f4-94c9-2e7ce2d94e3e_0.lance\n", - " /tmp/pet.lance/data/54fa6417-a006-48be-b530-0f3f188c463d_0.lance\n", - "/tmp/pet.lance/_latest.manifest\n" + " /tmp/pet.lance/data/a65f712b-0c98-4867-8d43-235adb9980ad_0.lance\n", + " /tmp/pet.lance/data/02c33f78-151b-4cb0-bfca-e41af5a23276_0.lance\n", + " /tmp/pet.lance/data/bd741e61-2901-4fb5-8ac8-49baedabe5dd_0.lance\n", + " /tmp/pet.lance/data/dd62e66c-0ed5-4acd-aa83-94db0f2edfe9_0.lance\n", + " /tmp/pet.lance/data/946dd9a4-489c-438f-bf02-0c89c97e6c12_0.lance\n", + " /tmp/pet.lance/data/a4a499f3-d505-48a6-9016-087564f8ad2e_0.lance\n", + " /tmp/pet.lance/data/74280958-9fe1-4bc5-95fd-cecab27029d1_0.lance\n", + " /tmp/pet.lance/data/3d02b12c-dfc9-4c95-b3ec-b601c4e6298f_0.lance\n" ] } ], @@ -1427,7 +1493,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 15, "id": "31c6e79e", "metadata": {}, "outputs": [ @@ -1435,19 +1501,66 @@ "name": "stdout", "output_type": "stream", "text": [ + "UnknownAbyssinianamerican_bulldogamerican_pit_bull_terrierbasset_houndbeagleBengalBirmanBombayboxerBritish_ShorthairchihuahuaEgyptian_Mauenglish_cocker_spanielenglish_settergerman_shorthairedgreat_pyreneeshavanesejapanese_chinkeeshondleonbergerMaine_Coonminiature_pinschernewfoundlandPersianpomeranianpugRagdollRussian_Bluesaint_bernardsamoyedscottish_terriershiba_inuSiameseSphynxstaffordshire_bull_terrierwheaten_terrieryorkshire_terrier\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0011\u0000\u0000\u0000\u0000\u0000\u0000\u0000!\u0000\u0000\u0000\u0000\u0000\u0000\u0000:\u0000\u0000\u0000\u0000\u0000\u0000\u0000F\u0000\u0000\u0000\u0000\u0000\u0000\u0000L\u0000\u0000\u0000\u0000\u0000\u0000\u0000R\u0000\u0000\u0000\u0000\u0000\u0000\u0000X\u0000\u0000\u0000\u0000\u0000\u0000\u0000^\u0000\u0000\u0000\u0000\u0000\u0000\u0000c\u0000\u0000\u0000\u0000\u0000\u0000\u0000t\u0000\u0000\u0000\u0000\u0000\u0000\u0000}\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0010\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u001c", + "\u0001\u0000\u0000\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000\u0000\u0000-\u0001\u0000\u0000\u0000\u0000\u0000\u00000\u0001\u0000\u0000\u0000\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000\u0000\u0000\u0000P\u0001\u0000\u0000\u0000\u0000\u0000\u0000W\u0001\u0000\u0000\u0000\u0000\u0000\u0000g\u0001\u0000\u0000\u0000\u0000\u0000\u0000p\u0001\u0000\u0000\u0000\u0000\u0000\u0000w\u0001\u0000\u0000\u0000\u0000\u0000\u0000}\u0001\u0000\u0000\u0000\u0000\u0000\u0000�\u0001\u0000\u0000\u0000\u0000\u0000\u0000�\u0001\u0000\u0000\u0000\u0000\u0000\u0000�\u0001\u0000\u0000\u0000\u0000\u0000\u0000UnknownCatDog�\u0002\u0000\u0000\u0000\u0000\u0000\u0000�\u0002\u0000\u0000\u0000\u0000\u0000\u0000�\u0002\u0000\u0000\u0000\u0000\u0000\u0000�\u0002\u0000\u0000\u0000\u0000\u0000\u0000trainvaltest\u001c", + "\u0003\u0000\u0000\u0000\u0000\u0000\u0000!\u0003\u0000\u0000\u0000\u0000\u0000\u0000$\u0003\u0000\u0000\u0000\u0000\u0000\u0000(\u0003\u0000\u0000\u0000\u0000\u0000\u0000N\u0004\u0000\u0000\r\n", + "\u001b\b\u0002\u0012\u0003_pk ��������\u0001*\u0005int168\u0001\r\n", + "#\b\u0002\u0012\bfilename\u0018\u0001 ���������\u0001*\u0006string8\u0002\r\n", + "7\b\u0002\u0012\u0005class\u0018\u0002 ���������\u0001*\u0016dict:string:int8:false8\u0003B\u0005\b�\u0003\u0010&\r\n", + "9\b\u0002\u0012\u0007species\u0018\u0003 ���������\u0001*\u0016dict:string:int8:false8\u0003B\u0005\b�\u0005\u0010\u0003\r\n", + "\u001f\b\u0002\u0012\u0005breed\u0018\u0004 ���������\u0001*\u0005int168\u0001\r\n", + "7\b\u0002\u0012\u0005split\u0018\u0005 ���������\u0001*\u0016dict:string:int8:false8\u0003B\u0005\b�\u0006\u0010\u0003\r\n", + "!\b\u0002\u0012\u0006folder\u0018\u0006 ���������\u0001*\u0006string8\u0002\r\n", + "\u001d", + "\u0012\u0006source\u0018\u0007 ���������\u0001*\u0006struct\r\n", + "\u001a\b\u0002\u0012\bdatabase\u0018\b \u0007*\u0006string8\u0002\r\n", + "\u001c", + "\b\u0002\u0012\r\n", + "annotation\u0018\t \u0007*\u0006string8\u0002\r\n", + "\u0017\b\u0002\u0012\u0005image\u0018\r\n", + " \u0007*\u0006string8\u0002\r\n", + "\u001b\u0012\u0004size\u0018\u000b", + " ���������\u0001*\u0006struct\r\n", + "\u0016\b\u0002\u0012\u0005width\u0018\f", + " \u000b", + "*\u0005int328\u0001\r\n", + "\u0017\b\u0002\u0012\u0006height\u0018\r", + " \u000b", + "*\u0005int328\u0001\r\n", + "\u0016\b\u0002\u0012\u0005depth\u0018\u000e \u000b", + "*\u0005uint88\u0001\r\n", + "\"\b\u0002\u0012\tsegmented\u0018\u000f ���������\u0001*\u0004bool8\u0001\r\n", + "\u001d", + "\u0012\u0006object\u0018\u0010 ���������\u0001*\u0006struct\r\n", + "\u0014\b\u0001\u0012\u0004name\u0018\u0011 \u0010*\u0004list8\u0001\r\n", + "\u0016\b\u0002\u0012\u0004item\u0018\u0012 \u0011*\u0006string8\u0002\r\n", + "\u0014\b\u0001\u0012\u0004pose\u0018\u0013 \u0010*\u0004list8\u0001\r\n", + "\u0016\b\u0002\u0012\u0004item\u0018\u0014 \u0013*\u0006string8\u0002\r\n", + "\u0019\b\u0001\u0012\ttruncated\u0018\u0015 \u0010*\u0004list8\u0001\r\n", + "\u0014\b\u0002\u0012\u0004item\u0018\u0016 \u0015*\u0004bool8\u0001\r\n", + "\u0018\b\u0001\u0012\boccluded\u0018\u0017 \u0010*\u0004list8\u0001\r\n", + "\u0014\b\u0002\u0012\u0004item\u0018\u0018 \u0017*\u0004bool8\u0001\r\n", + "\u0016\b\u0001\u0012\u0006bndbox\u0018\u0019 \u0010*\u0004list8\u0001\r\n", + "'\b\u0002\u0012\u0004item\u0018\u001a \u0019*\u0017fixed_size_list:float:48\u0001\r\n", + "\u0019\b\u0001\u0012\tdifficult\u0018\u001b \u0010*\u0004list8\u0001\r\n", + "\u0014\b\u0002\u0012\u0004item\u0018\u001c", + " \u001b*\u0004bool8\u0001\r\n", + "5\b\u0002\u0012\u000eexternal_image\u0018\u001d", + " ���������\u0001*\u0006string8\u0002J\r\n", "image[uri]\r\n", - ":\b\u0002\u0012\u0005image\u0018\u001e", - " ���������\u0001*\u0006binary8\u0002@���������\u0001R\r", + "/\b\u0002\u0012\u0005image\u0018\u001e", + " ���������\u0001*\u0006binary8\u0002J\r", "image[binary]\u0012\u0012\r\n", "\u000b", - "primary_key\u0012\u0003_pk \u00012p\u0012n\r\n", - ",9ee19246-282a-46f4-94c9-2e7ce2d94e3e_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "primary_key\u0012\u0003_pk \u00012Q\u0012O\r\n", + ",946dd9a4-489c-438f-bf02-0c89c97e6c12_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", - "\u001e" + "\u001e", + "H\u0003\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000LANC" ] } ], @@ -1457,7 +1570,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 16, "id": "71c8694b", "metadata": {}, "outputs": [ @@ -1465,77 +1578,122 @@ "name": "stdout", "output_type": "stream", "text": [ - "@\b\u0002\u0012\u000eexternal_image\u0018\u001d", - " ���������\u0001*\u0006string8\u0002@���������\u0001R\r\n", + "UnknownAbyssinianamerican_bulldogamerican_pit_bull_terrierbasset_houndbeagleBengalBirmanBombayboxerBritish_ShorthairchihuahuaEgyptian_Mauenglish_cocker_spanielenglish_settergerman_shorthairedgreat_pyreneeshavanesejapanese_chinkeeshondleonbergerMaine_Coonminiature_pinschernewfoundlandPersianpomeranianpugRagdollRussian_Bluesaint_bernardsamoyedscottish_terriershiba_inuSiameseSphynxstaffordshire_bull_terrierwheaten_terrieryorkshire_terrier\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0007\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0011\u0000\u0000\u0000\u0000\u0000\u0000\u0000!\u0000\u0000\u0000\u0000\u0000\u0000\u0000:\u0000\u0000\u0000\u0000\u0000\u0000\u0000F\u0000\u0000\u0000\u0000\u0000\u0000\u0000L\u0000\u0000\u0000\u0000\u0000\u0000\u0000R\u0000\u0000\u0000\u0000\u0000\u0000\u0000X\u0000\u0000\u0000\u0000\u0000\u0000\u0000^\u0000\u0000\u0000\u0000\u0000\u0000\u0000c\u0000\u0000\u0000\u0000\u0000\u0000\u0000t\u0000\u0000\u0000\u0000\u0000\u0000\u0000}\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000�\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0010\u0001\u0000\u0000\u0000\u0000\u0000\u0000\u001c", + "\u0001\u0000\u0000\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000\u0000\u0000-\u0001\u0000\u0000\u0000\u0000\u0000\u00000\u0001\u0000\u0000\u0000\u0000\u0000\u00007\u0001\u0000\u0000\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000\u0000\u0000\u0000P\u0001\u0000\u0000\u0000\u0000\u0000\u0000W\u0001\u0000\u0000\u0000\u0000\u0000\u0000g\u0001\u0000\u0000\u0000\u0000\u0000\u0000p\u0001\u0000\u0000\u0000\u0000\u0000\u0000w\u0001\u0000\u0000\u0000\u0000\u0000\u0000}\u0001\u0000\u0000\u0000\u0000\u0000\u0000�\u0001\u0000\u0000\u0000\u0000\u0000\u0000�\u0001\u0000\u0000\u0000\u0000\u0000\u0000�\u0001\u0000\u0000\u0000\u0000\u0000\u0000UnknownCatDog�\u0002\u0000\u0000\u0000\u0000\u0000\u0000�\u0002\u0000\u0000\u0000\u0000\u0000\u0000�\u0002\u0000\u0000\u0000\u0000\u0000\u0000�\u0002\u0000\u0000\u0000\u0000\u0000\u0000trainvaltest\u001c", + "\u0003\u0000\u0000\u0000\u0000\u0000\u0000!\u0003\u0000\u0000\u0000\u0000\u0000\u0000$\u0003\u0000\u0000\u0000\u0000\u0000\u0000(\u0003\u0000\u0000\u0000\u0000\u0000\u0000�\u0006\u0000\u0000\r\n", + "\u001b\b\u0002\u0012\u0003_pk ��������\u0001*\u0005int168\u0001\r\n", + "#\b\u0002\u0012\bfilename\u0018\u0001 ���������\u0001*\u0006string8\u0002\r\n", + "7\b\u0002\u0012\u0005class\u0018\u0002 ���������\u0001*\u0016dict:string:int8:false8\u0003B\u0005\b�\u0003\u0010&\r\n", + "9\b\u0002\u0012\u0007species\u0018\u0003 ���������\u0001*\u0016dict:string:int8:false8\u0003B\u0005\b�\u0005\u0010\u0003\r\n", + "\u001f\b\u0002\u0012\u0005breed\u0018\u0004 ���������\u0001*\u0005int168\u0001\r\n", + "7\b\u0002\u0012\u0005split\u0018\u0005 ���������\u0001*\u0016dict:string:int8:false8\u0003B\u0005\b�\u0006\u0010\u0003\r\n", + "!\b\u0002\u0012\u0006folder\u0018\u0006 ���������\u0001*\u0006string8\u0002\r\n", + "\u001d", + "\u0012\u0006source\u0018\u0007 ���������\u0001*\u0006struct\r\n", + "\u001a\b\u0002\u0012\bdatabase\u0018\b \u0007*\u0006string8\u0002\r\n", + "\u001c", + "\b\u0002\u0012\r\n", + "annotation\u0018\t \u0007*\u0006string8\u0002\r\n", + "\u0017\b\u0002\u0012\u0005image\u0018\r\n", + " \u0007*\u0006string8\u0002\r\n", + "\u001b\u0012\u0004size\u0018\u000b", + " ���������\u0001*\u0006struct\r\n", + "\u0016\b\u0002\u0012\u0005width\u0018\f", + " \u000b", + "*\u0005int328\u0001\r\n", + "\u0017\b\u0002\u0012\u0006height\u0018\r", + " \u000b", + "*\u0005int328\u0001\r\n", + "\u0016\b\u0002\u0012\u0005depth\u0018\u000e \u000b", + "*\u0005uint88\u0001\r\n", + "\"\b\u0002\u0012\tsegmented\u0018\u000f ���������\u0001*\u0004bool8\u0001\r\n", + "\u001d", + "\u0012\u0006object\u0018\u0010 ���������\u0001*\u0006struct\r\n", + "\u0014\b\u0001\u0012\u0004name\u0018\u0011 \u0010*\u0004list8\u0001\r\n", + "\u0016\b\u0002\u0012\u0004item\u0018\u0012 \u0011*\u0006string8\u0002\r\n", + "\u0014\b\u0001\u0012\u0004pose\u0018\u0013 \u0010*\u0004list8\u0001\r\n", + "\u0016\b\u0002\u0012\u0004item\u0018\u0014 \u0013*\u0006string8\u0002\r\n", + "\u0019\b\u0001\u0012\ttruncated\u0018\u0015 \u0010*\u0004list8\u0001\r\n", + "\u0014\b\u0002\u0012\u0004item\u0018\u0016 \u0015*\u0004bool8\u0001\r\n", + "\u0018\b\u0001\u0012\boccluded\u0018\u0017 \u0010*\u0004list8\u0001\r\n", + "\u0014\b\u0002\u0012\u0004item\u0018\u0018 \u0017*\u0004bool8\u0001\r\n", + "\u0016\b\u0001\u0012\u0006bndbox\u0018\u0019 \u0010*\u0004list8\u0001\r\n", + "'\b\u0002\u0012\u0004item\u0018\u001a \u0019*\u0017fixed_size_list:float:48\u0001\r\n", + "\u0019\b\u0001\u0012\tdifficult\u0018\u001b \u0010*\u0004list8\u0001\r\n", + "\u0014\b\u0002\u0012\u0004item\u0018\u001c", + " \u001b*\u0004bool8\u0001\r\n", + "5\b\u0002\u0012\u000eexternal_image\u0018\u001d", + " ���������\u0001*\u0006string8\u0002J\r\n", "image[uri]\r\n", - ":\b\u0002\u0012\u0005image\u0018\u001e", - " ���������\u0001*\u0006binary8\u0002@���������\u0001R\r", + "/\b\u0002\u0012\u0005image\u0018\u001e", + " ���������\u0001*\u0006binary8\u0002J\r", "image[binary]\u0012\u0012\r\n", "\u000b", - "primary_key\u0012\u0003_pk \b2p\u0012n\r\n", - ",9ee19246-282a-46f4-94c9-2e7ce2d94e3e_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "primary_key\u0012\u0003_pk \b2Q\u0012O\r\n", + ",946dd9a4-489c-438f-bf02-0c89c97e6c12_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", "\u001e", - "2p\u0012n\r\n", - ",3cb855db-ce23-4dc0-bbf6-0cc92d31eaaf_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "2Q\u0012O\r\n", + ",74280958-9fe1-4bc5-95fd-cecab27029d1_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", "\u001e", - "2p\u0012n\r\n", - ",58b93c55-9cb7-4f22-bf4d-f45ab8c449a0_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "2Q\u0012O\r\n", + ",bd741e61-2901-4fb5-8ac8-49baedabe5dd_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", "\u001e", - "2p\u0012n\r\n", - ",1b47abc3-6f59-42ca-9316-fb0b7e4af318_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "2Q\u0012O\r\n", + ",3d02b12c-dfc9-4c95-b3ec-b601c4e6298f_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", "\u001e", - "2p\u0012n\r\n", - ",2344d6c3-1f5e-4c89-90c9-bd54094471d3_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "2Q\u0012O\r\n", + ",dd62e66c-0ed5-4acd-aa83-94db0f2edfe9_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", "\u001e", - "2p\u0012n\r\n", - ",54fa6417-a006-48be-b530-0f3f188c463d_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "2Q\u0012O\r\n", + ",a65f712b-0c98-4867-8d43-235adb9980ad_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", "\u001e", - "2p\u0012n\r\n", - ",5c636bf2-e672-45cf-8937-20a346800f86_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "2Q\u0012O\r\n", + ",02c33f78-151b-4cb0-bfca-e41af5a23276_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", "\u001e", - "2p\u0012n\r\n", - ",257e6e76-19f3-4f92-bfb7-20bd3c4561d1_0.lance\u0012>\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", + "2Q\u0012O\r\n", + ",a4a499f3-d505-48a6-9016-087564f8ad2e_0.lance\u0012\u001f\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\r\n", "\u000b", "\f", "\r", "\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c", "\u001d", - "\u001e" + "\u001e", + "H\u0003\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0001\u0000LANC" ] } ], @@ -1593,7 +1751,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.4" + "version": "3.10.8" } }, "nbformat": 4,