From 84666dcc0caf82151e391a3015d216f04ad33c7d Mon Sep 17 00:00:00 2001 From: MQN-80 <3218290253@qq.com> Date: Sat, 15 Feb 2025 14:18:48 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E5=BC=80=E6=BA=90=E5=AE=9E=E4=B9=A0-Layout?= =?UTF-8?q?LM=E6=A8=A1=E5=9E=8B=E5=BA=94=E7=94=A8=E5=BC=80=E5=8F=91-jinyi?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- applications/LayoutLM/layoutlm.ipynb | 5702 ++++++++++++++++++++++++++ 1 file changed, 5702 insertions(+) create mode 100644 applications/LayoutLM/layoutlm.ipynb diff --git a/applications/LayoutLM/layoutlm.ipynb b/applications/LayoutLM/layoutlm.ipynb new file mode 100644 index 000000000..75fc3b373 --- /dev/null +++ b/applications/LayoutLM/layoutlm.ipynb @@ -0,0 +1,5702 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9feee1e8", + "metadata": { + "tags": [] + }, + "source": [ + "# **环境配置**: \n", + "```\n", + "python 3.9\n", + "mindspore 2.3.0\n", + "mindnlp 0.3.1\n", + "```\n", + "\n", + "在该notebook中，我们将以mindnlp为基础，在FUNSD数据集上对LayoutLM进行微调，并像原始论文中那样，加入来自预训练骨干网络（即ResNet-101）的视觉特征。该骨干网络的参数也将在训练过程中进行更新。 \n", + "正如我们将看到的，这将比仅在文本和布局（边界框）信息上训练的模型提高性能 \n", + "原始LayoutLM论文：https://arxiv.org/abs/1912.13318 \n", + "原始FUNSD论文：https://arxiv.org/abs/1905.13538 \n", + "modelarts链接:https://developer.huaweicloud.com/develop/aigallery/notebook/detail?id=346d8403-ee68-49a2-b79e-83f578c568bd" + ] + }, + { + "cell_type": "markdown", + "id": "a8f743b3-c464-4441-bea2-b8ee0ff35bf4", + "metadata": {}, + "source": [ + "在环境搭建部分，使用了AI gallery社区中相关mindnlp项目搭建mindnlp环境的代码。" + ] + }, + { + "cell_type": "markdown", + "id": "2e38c494-398f-4943-ab36-2a6cb6dc26e7", + "metadata": {}, + "source": [ + "1 环境配置\n", + "配置python3.9环境" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "03fa0e50-2402-41ae-add0-2cf9beac9639", + "metadata": {}, + "outputs": [], + "source": [ + "%%capture captured_output\n", + "!/home/ma-user/anaconda3/bin/conda create -n python-3.9.0 python=3.9.0 -y --override-channels --channel https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main\n", + "!/home/ma-user/anaconda3/envs/python-3.9.0/bin/pip install ipykernel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23ef5aea-0fbc-400f-adc3-efef4bad4316", + "metadata": {}, + "outputs": [], + "source": [ + "import json\n", + "import os\n", + "\n", + "data = {\n", + " \"display_name\": \"python-3.9.0\",\n", + " \"env\": {\n", + " \"PATH\": \"/home/ma-user/anaconda3/envs/python-3.9.0/bin:/home/ma-user/anaconda3/envs/python-3.7.10/bin:/modelarts/authoring/notebook-conda/bin:/opt/conda/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/ma-user/modelarts/ma-cli/bin:/home/ma-user/modelarts/ma-cli/bin\"\n", + " },\n", + " \"language\": \"python\",\n", + " \"argv\": [\n", + " \"/home/ma-user/anaconda3/envs/python-3.9.0/bin/python\",\n", + " \"-m\",\n", + " \"ipykernel\",\n", + " \"-f\",\n", + " \"{connection_file}\"\n", + " ]\n", + "}\n", + "\n", + "if not os.path.exists(\"/home/ma-user/anaconda3/share/jupyter/kernels/python-3.9.0/\"):\n", + " os.mkdir(\"/home/ma-user/anaconda3/share/jupyter/kernels/python-3.9.0/\")\n", + "\n", + "with open('/home/ma-user/anaconda3/share/jupyter/kernels/python-3.9.0/kernel.json', 'w') as f:\n", + " json.dump(data, f, indent=4)" + ] + }, + { + "cell_type": "markdown", + "id": "6a8d66b2-55a7-4cbe-bc86-a1b637954eec", + "metadata": {}, + "source": [ + "注：以上代码执行完成后，稍等片刻，或刷新页面，点击右上角（或左上角）kernel选择python-3.9.0 change-kernel" + ] + }, + { + "cell_type": "markdown", + "id": "c9d092ef-d781-4349-a57b-f4a05bf5ef90", + "metadata": {}, + "source": [ + "下面安装相关依赖" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "7bf2dc4f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: http://mirrors.aliyun.com/pypi/simple/\n", + "Collecting mindspore==2.3.0\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/69/3c/889efc96009a803702a8b81b111c72a78b2ea74f52efb0d22e27fa349d89/mindspore-2.3.0-cp39-none-any.whl (273.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m273.2/273.2 MB\u001b[0m \u001b[31m8.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numpy<2.0.0,>=1.20.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore==2.3.0) (1.26.1)\n", + "Requirement already satisfied: protobuf>=3.13.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore==2.3.0) (3.20.3)\n", + "Requirement already satisfied: asttokens>=2.0.4 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore==2.3.0) (2.4.1)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore==2.3.0) (9.0.1)\n", + "Requirement already satisfied: scipy>=1.5.4 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore==2.3.0) (1.11.3)\n", + "Requirement already satisfied: packaging>=20.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore==2.3.0) (23.2)\n", + "Requirement already satisfied: psutil>=5.6.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore==2.3.0) (5.9.5)\n", + "Requirement already satisfied: astunparse>=1.6.3 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore==2.3.0) (1.6.3)\n", + "Requirement already satisfied: six>=1.12.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from asttokens>=2.0.4->mindspore==2.3.0) (1.16.0)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from astunparse>=1.6.3->mindspore==2.3.0) (0.41.2)\n", + "\u001b[33mWARNING: The candidate selected for download or install is a yanked version: 'mindspore' candidate (version 2.3.0 at http://mirrors.aliyun.com/pypi/packages/69/3c/889efc96009a803702a8b81b111c72a78b2ea74f52efb0d22e27fa349d89/mindspore-2.3.0-cp39-none-any.whl#sha256=fcd913d6f508afaa6b5fa0a8d3b76a17c28c93c63ad42f38cff266ca568cdb55 (from http://mirrors.aliyun.com/pypi/simple/mindspore/) (requires-python:>=3.7))\n", + "Reason for being yanked: uploading x86 files failed\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mDEPRECATION: moxing-framework 2.1.16.2ae09d45 has a non-standard version number. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of moxing-framework or contact the author to suggest that they release a version with a conforming version number. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0mInstalling collected packages: mindspore\n", + "Successfully installed mindspore-2.3.0\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0mLooking in indexes: http://mirrors.aliyun.com/pypi/simple/\n", + "Collecting mindnlp==0.3.1\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/72/37/ef313c23fd587c3d1f46b0741c98235aecdfd93b4d6d446376f3db6a552c/mindnlp-0.3.1-py3-none-any.whl (5.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m5.7/5.7 MB\u001b[0m \u001b[31m28.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: mindspore in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (2.3.0)\n", + "Requirement already satisfied: tqdm in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (4.66.1)\n", + "Requirement already satisfied: requests in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (2.32.3)\n", + "Requirement already satisfied: datasets in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (2.18.0)\n", + "Collecting evaluate (from mindnlp==0.3.1)\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/a2/e7/cbca9e2d2590eb9b5aa8f7ebabe1beb1498f9462d2ecede5c9fd9735faaf/evaluate-0.4.3-py3-none-any.whl (84 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m84.0/84.0 kB\u001b[0m \u001b[31m1.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m-:--:--\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: tokenizers in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (0.19.1)\n", + "Requirement already satisfied: safetensors in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (0.4.3)\n", + "Requirement already satisfied: sentencepiece in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (0.1.99)\n", + "Requirement already satisfied: regex in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (2023.10.3)\n", + "Requirement already satisfied: addict in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (2.4.0)\n", + "Requirement already satisfied: ml-dtypes in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages/ml_dtypes-0.2.0-py3.9-linux-aarch64.egg (from mindnlp==0.3.1) (0.2.0)\n", + "Collecting pyctcdecode (from mindnlp==0.3.1)\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/a5/8a/93e2118411ae5e861d4f4ce65578c62e85d0f1d9cb389bd63bd57130604e/pyctcdecode-0.5.0-py2.py3-none-any.whl (39 kB)\n", + "Requirement already satisfied: jieba in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindnlp==0.3.1) (0.42.1)\n", + "Collecting pytest==7.2.0 (from mindnlp==0.3.1)\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/67/68/a5eb36c3a8540594b6035e6cdae40c1ef1b6a2bfacbecc3d1a544583c078/pytest-7.2.0-py3-none-any.whl (316 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m316.8/316.8 kB\u001b[0m \u001b[31m51.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: attrs>=19.2.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from pytest==7.2.0->mindnlp==0.3.1) (23.1.0)\n", + "Collecting iniconfig (from pytest==7.2.0->mindnlp==0.3.1)\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl (5.9 kB)\n", + "Requirement already satisfied: packaging in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from pytest==7.2.0->mindnlp==0.3.1) (23.2)\n", + "Collecting pluggy<2.0,>=0.12 (from pytest==7.2.0->mindnlp==0.3.1)\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl (20 kB)\n", + "Requirement already satisfied: exceptiongroup>=1.0.0rc8 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from pytest==7.2.0->mindnlp==0.3.1) (1.1.3)\n", + "Requirement already satisfied: tomli>=1.0.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from pytest==7.2.0->mindnlp==0.3.1) (2.0.1)\n", + "Requirement already satisfied: filelock in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (3.12.4)\n", + "Requirement already satisfied: numpy>=1.17 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (1.26.1)\n", + "Requirement already satisfied: pyarrow>=12.0.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (12.0.1)\n", + "Requirement already satisfied: pyarrow-hotfix in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (0.6)\n", + "Requirement already satisfied: dill<0.3.9,>=0.3.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (0.3.8)\n", + "Requirement already satisfied: pandas in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (2.1.2)\n", + "Requirement already satisfied: xxhash in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (3.4.1)\n", + "Requirement already satisfied: multiprocess in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (0.70.16)\n", + "Requirement already satisfied: fsspec<=2024.2.0,>=2023.1.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from fsspec[http]<=2024.2.0,>=2023.1.0->datasets->mindnlp==0.3.1) (2023.10.0)\n", + "Requirement already satisfied: aiohttp in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (3.9.5)\n", + "Requirement already satisfied: huggingface-hub>=0.19.4 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (0.23.3)\n", + "Requirement already satisfied: pyyaml>=5.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from datasets->mindnlp==0.3.1) (6.0.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from requests->mindnlp==0.3.1) (3.3.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from requests->mindnlp==0.3.1) (3.4)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from requests->mindnlp==0.3.1) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from requests->mindnlp==0.3.1) (2023.7.22)\n", + "Requirement already satisfied: protobuf>=3.13.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore->mindnlp==0.3.1) (3.20.3)\n", + "Requirement already satisfied: asttokens>=2.0.4 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore->mindnlp==0.3.1) (2.4.1)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore->mindnlp==0.3.1) (9.0.1)\n", + "Requirement already satisfied: scipy>=1.5.4 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore->mindnlp==0.3.1) (1.11.3)\n", + "Requirement already satisfied: psutil>=5.6.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore->mindnlp==0.3.1) (5.9.5)\n", + "Requirement already satisfied: astunparse>=1.6.3 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore->mindnlp==0.3.1) (1.6.3)\n", + "Collecting pygtrie<3.0,>=2.1 (from pyctcdecode->mindnlp==0.3.1)\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/ec/cd/bd196b2cf014afb1009de8b0f05ecd54011d881944e62763f3c1b1e8ef37/pygtrie-2.5.0-py3-none-any.whl (25 kB)\n", + "Collecting hypothesis<7,>=6.14 (from pyctcdecode->mindnlp==0.3.1)\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/55/97/36e2e1dec3d60c99443a9d25e8a21e9bfdf4ba91c1396587b8b74f37db13/hypothesis-6.125.3-py3-none-any.whl (480 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m480.8/480.8 kB\u001b[0m \u001b[31m47.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: six>=1.12.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from asttokens>=2.0.4->mindspore->mindnlp==0.3.1) (1.16.0)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from astunparse>=1.6.3->mindspore->mindnlp==0.3.1) (0.41.2)\n", + "Requirement already satisfied: aiosignal>=1.1.2 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from aiohttp->datasets->mindnlp==0.3.1) (1.3.1)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from aiohttp->datasets->mindnlp==0.3.1) (1.4.1)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from aiohttp->datasets->mindnlp==0.3.1) (6.0.5)\n", + "Requirement already satisfied: yarl<2.0,>=1.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from aiohttp->datasets->mindnlp==0.3.1) (1.9.4)\n", + "Requirement already satisfied: async-timeout<5.0,>=4.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from aiohttp->datasets->mindnlp==0.3.1) (4.0.3)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from huggingface-hub>=0.19.4->datasets->mindnlp==0.3.1) (4.8.0)\n", + "Requirement already satisfied: sortedcontainers<3.0.0,>=2.1.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from hypothesis<7,>=6.14->pyctcdecode->mindnlp==0.3.1) (2.4.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from pandas->datasets->mindnlp==0.3.1) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from pandas->datasets->mindnlp==0.3.1) (2023.3.post1)\n", + "Requirement already satisfied: tzdata>=2022.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from pandas->datasets->mindnlp==0.3.1) (2023.3)\n", + "\u001b[33mDEPRECATION: moxing-framework 2.1.16.2ae09d45 has a non-standard version number. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of moxing-framework or contact the author to suggest that they release a version with a conforming version number. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0mInstalling collected packages: pygtrie, pluggy, iniconfig, hypothesis, pytest, pyctcdecode, evaluate, mindnlp\n", + "Successfully installed evaluate-0.4.3 hypothesis-6.125.3 iniconfig-2.0.0 mindnlp-0.3.1 pluggy-1.5.0 pyctcdecode-0.5.0 pygtrie-2.5.0 pytest-7.2.0\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0mLooking in indexes: http://mirrors.aliyun.com/pypi/simple/\n", + "Requirement already satisfied: mindspore in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (2.3.0)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.20.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore) (1.26.1)\n", + "Requirement already satisfied: protobuf>=3.13.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore) (3.20.3)\n", + "Requirement already satisfied: asttokens>=2.0.4 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore) (2.4.1)\n", + "Requirement already satisfied: pillow>=6.2.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore) (9.0.1)\n", + "Requirement already satisfied: scipy>=1.5.4 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore) (1.11.3)\n", + "Requirement already satisfied: packaging>=20.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore) (23.2)\n", + "Requirement already satisfied: psutil>=5.6.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore) (5.9.5)\n", + "Requirement already satisfied: astunparse>=1.6.3 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from mindspore) (1.6.3)\n", + "Requirement already satisfied: six>=1.12.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from asttokens>=2.0.4->mindspore) (1.16.0)\n", + "Requirement already satisfied: wheel<1.0,>=0.23.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from astunparse>=1.6.3->mindspore) (0.41.2)\n", + "\u001b[33mDEPRECATION: moxing-framework 2.1.16.2ae09d45 has a non-standard version number. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of moxing-framework or contact the author to suggest that they release a version with a conforming version number. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0m\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0mFound existing installation: mindformers 0.8.0\n", + "Uninstalling mindformers-0.8.0:\n", + " Successfully uninstalled mindformers-0.8.0\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0mLooking in indexes: http://mirrors.aliyun.com/pypi/simple/\n", + "Collecting setuptools_scm\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/a0/b9/1906bfeb30f2fc13bb39bf7ddb8749784c05faadbd18a21cf141ba37bff2/setuptools_scm-8.1.0-py3-none-any.whl (43 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.7/43.7 kB\u001b[0m \u001b[31m3.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: packaging>=20 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from setuptools_scm) (23.2)\n", + "Requirement already satisfied: setuptools in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from setuptools_scm) (68.2.2)\n", + "Requirement already satisfied: typing-extensions in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from setuptools_scm) (4.8.0)\n", + "Requirement already satisfied: tomli>=1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from setuptools_scm) (2.0.1)\n", + "\u001b[33mDEPRECATION: moxing-framework 2.1.16.2ae09d45 has a non-standard version number. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of moxing-framework or contact the author to suggest that they release a version with a conforming version number. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0mInstalling collected packages: setuptools_scm\n", + "Successfully installed setuptools_scm-8.1.0\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0mLooking in indexes: http://mirrors.aliyun.com/pypi/simple/\n", + "Collecting seqeval\n", + " Downloading http://mirrors.aliyun.com/pypi/packages/9d/2d/233c79d5b4e5ab1dbf111242299153f3caddddbb691219f363ad55ce783d/seqeval-1.2.2.tar.gz (43 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.6/43.6 kB\u001b[0m \u001b[31m528.3 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m:--:--\u001b[0m\n", + "\u001b[?25h Preparing metadata (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25hRequirement already satisfied: numpy>=1.14.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from seqeval) (1.26.1)\n", + "Requirement already satisfied: scikit-learn>=0.21.3 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from seqeval) (1.3.2)\n", + "Requirement already satisfied: scipy>=1.5.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from scikit-learn>=0.21.3->seqeval) (1.11.3)\n", + "Requirement already satisfied: joblib>=1.1.1 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from scikit-learn>=0.21.3->seqeval) (1.3.2)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/site-packages (from scikit-learn>=0.21.3->seqeval) (3.2.0)\n", + "Building wheels for collected packages: seqeval\n", + " Building wheel for seqeval (setup.py) ... \u001b[?25ldone\n", + "\u001b[?25h Created wheel for seqeval: filename=seqeval-1.2.2-py3-none-any.whl size=16162 sha256=041de07c5b85c31cf32c989985a14f02900f9b909e529c1a51af56898d8665cc\n", + " Stored in directory: /root/.cache/pip/wheels/4d/9d/34/0a1c1e876c4d06b2e010392abc3c8f84ed0ff577e2d1031656\n", + "Successfully built seqeval\n", + "\u001b[33mDEPRECATION: moxing-framework 2.1.16.2ae09d45 has a non-standard version number. pip 24.0 will enforce this behaviour change. A possible replacement is to upgrade to a newer version of moxing-framework or contact the author to suggest that they release a version with a conforming version number. Discussion can be found at https://github.com/pypa/pip/issues/12063\u001b[0m\u001b[33m\n", + "\u001b[0mInstalling collected packages: seqeval\n", + "Successfully installed seqeval-1.2.2\n", + "\u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n", + "\u001b[0mLast metadata expiration check: 477 days, 1:18:10 ago on Fri Oct 27 03:23:05 2023.\n", + "Dependencies resolved.\n", + "================================================================================\n", + " Package Arch Version Repository Size\n", + "================================================================================\n", + "Installing:\n", + " libsndfile aarch64 1.0.28-9.h7.eulerosv2r8 base 174 k\n", + "Installing dependencies:\n", + " flac-libs aarch64 1.3.2-8.h2.eulerosv2r8 base 171 k\n", + " gsm aarch64 1.0.18-3.eulerosv2r8 base 31 k\n", + " libogg aarch64 2:1.3.3-1.eulerosv2r8 base 22 k\n", + " libvorbis aarch64 1:1.3.6-3.h3.eulerosv2r8 base 173 k\n", + "\n", + "Transaction Summary\n", + "================================================================================\n", + "Install 5 Packages\n", + "\n", + "Total download size: 571 k\n", + "Installed size: 2.0 M\n", + "Downloading Packages:\n", + "(1/5): gsm-1.0.18-3.eulerosv2r8.aarch64.rpm 30 kB/s | 31 kB 00:01 \n", + "(2/5): flac-libs-1.3.2-8.h2.eulerosv2r8.aarch64 163 kB/s | 171 kB 00:01 \n", + "(3/5): libogg-1.3.3-1.eulerosv2r8.aarch64.rpm 21 kB/s | 22 kB 00:01 \n", + "(4/5): libsndfile-1.0.28-9.h7.eulerosv2r8.aarch 4.3 MB/s | 174 kB 00:00 \n", + "(5/5): libvorbis-1.3.6-3.h3.eulerosv2r8.aarch64 13 MB/s | 173 kB 00:00 \n", + "--------------------------------------------------------------------------------\n", + "Total 533 kB/s | 571 kB 00:01 \n", + "Running transaction check\n", + "Transaction check succeeded.\n", + "Running transaction test\n", + "Transaction test succeeded.\n", + "Running transaction\n", + " Preparing : 1/1 \n", + "Installed: libogg-2:1.3.3-1.eulerosv2r8.aarch64\n", + " Installing : libogg-2:1.3.3-1.eulerosv2r8.aarch64 1/5 \n", + "Installed: libogg-2:1.3.3-1.eulerosv2r8.aarch64\n", + "Installed: flac-libs-1.3.2-8.h2.eulerosv2r8.aarch64\n", + " Installing : flac-libs-1.3.2-8.h2.eulerosv2r8.aarch64 2/5 \n", + "Installed: flac-libs-1.3.2-8.h2.eulerosv2r8.aarch64\n", + "Installed: libvorbis-1:1.3.6-3.h3.eulerosv2r8.aarch64\n", + " Installing : libvorbis-1:1.3.6-3.h3.eulerosv2r8.aarch64 3/5 \n", + "Installed: libvorbis-1:1.3.6-3.h3.eulerosv2r8.aarch64\n", + "Installed: gsm-1.0.18-3.eulerosv2r8.aarch64\n", + " Installing : gsm-1.0.18-3.eulerosv2r8.aarch64 4/5 \n", + "Installed: gsm-1.0.18-3.eulerosv2r8.aarch64\n", + "Installed: libsndfile-1.0.28-9.h7.eulerosv2r8.aarch64\n", + " Installing : libsndfile-1.0.28-9.h7.eulerosv2r8.aarch64 5/5 \n", + " Running scriptlet: libsndfile-1.0.28-9.h7.eulerosv2r8.aarch64 5/5 \n", + "Installed: libsndfile-1.0.28-9.h7.eulerosv2r8.aarch64\n", + " Verifying : flac-libs-1.3.2-8.h2.eulerosv2r8.aarch64 1/5 \n", + " Verifying : gsm-1.0.18-3.eulerosv2r8.aarch64 2/5 \n", + " Verifying : libogg-2:1.3.3-1.eulerosv2r8.aarch64 3/5 \n", + " Verifying : libsndfile-1.0.28-9.h7.eulerosv2r8.aarch64 4/5 \n", + " Verifying : libvorbis-1:1.3.6-3.h3.eulerosv2r8.aarch64 5/5 \n", + "\n", + "Installed:\n", + " libsndfile-1.0.28-9.h7.eulerosv2r8.aarch64 \n", + " flac-libs-1.3.2-8.h2.eulerosv2r8.aarch64 \n", + " gsm-1.0.18-3.eulerosv2r8.aarch64 \n", + " libogg-2:1.3.3-1.eulerosv2r8.aarch64 \n", + " libvorbis-1:1.3.6-3.h3.eulerosv2r8.aarch64 \n", + "\n", + "Complete!\n" + ] + } + ], + "source": [ + "!pip install mindspore==2.3.0\n", + "!pip install mindnlp==0.3.1\n", + "!pip install mindspore\n", + "!pip uninstall mindformers -y\n", + "!pip install setuptools_scm\n", + "!pip install seqeval\n", + "#!yum install libsndfile -y" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d6765c2b", + "metadata": {}, + "outputs": [], + "source": [ + "检查mindspore版本是否正确,在这里我们选用目标设备为Ascend,也可以根据自己的实际平台需求改为GPU或CPU" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3a07370b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ma-user/anaconda3/envs/MindSpore/lib/python3.9/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", + "Building prefix dict from the default dictionary ...\n", + "Dumping model to file cache /tmp/jieba.cache\n", + "Loading model cost 1.382 seconds.\n", + "Prefix dict has been built successfully.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MindSpore version: 2.3.0\n", + "The result of multiplication calculation is correct, MindSpore has been installed on platform [Ascend] successfully!\n" + ] + } + ], + "source": [ + "import mindspore\n", + "import mindnlp\n", + "mindspore.set_context(device_target='Ascend')\n", + "mindspore.run_check()" + ] + }, + { + "cell_type": "markdown", + "id": "38c35585", + "metadata": {}, + "source": [ + "下载FUNSD数据集,假如网络太慢可以自己从本地上传" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a815d25b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Archive: testing_data.zip\n", + "replace testing_data/.DS_Store? [y]es, [n]o, [A]ll, [N]one, [r]ename: " + ] + } + ], + "source": [ + "!wget https://guillaumejaume.github.io/FUNSD/dataset.zip\n", + "!unzip dataset.zip && mv dataset data && rm -rf dataset.zip __MACOSX\n", + "#!cd data && unzip testing_data.zip && unzip training_data.zip" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "589fd8dd", + "metadata": {}, + "outputs": [], + "source": [ + "from mindnlp.transformers import (\n", + " LayoutLMForMaskedLM,\n", + " LayoutLMForQuestionAnswering,\n", + " LayoutLMForSequenceClassification,\n", + " LayoutLMForTokenClassification,\n", + " LayoutLMModel,\n", + " )\n", + "model = LayoutLMModel.from_pretrained(\"microsoft/layoutlm-base-uncased\",num_labels=13)\n", + "print(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "160b7069", + "metadata": {}, + "outputs": [], + "source": [ + "首先来随机看数据集中的一个文档" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c8b021a0", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from PIL import Image, ImageDraw, ImageFont\n", + "\n", + "image = Image.open(\"data/training_data/images/0000971160.png\")\n", + "image = image.convert(\"RGB\")\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76d482a2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "image的大小为" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9d4d4337", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "(762, 1000)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image.size" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b975442f", + "metadata": {}, + "outputs": [], + "source": [ + "再来看每张图片的标注(文本内容,文本框和标签)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "248a12ec", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Words: ['R&D', ':', 'Suggestion:', 'Date:', 'Licensee', 'Yes', 'No', '597005708', 'R&D', 'QUALITY', 'IMPROVEMENT', 'SUGGESTION/', 'SOLUTION', 'FORM', 'Name', '/', 'Phone', 'Ext.', ':', 'M.', 'Hamann', 'P.', 'Harper,', 'P.', 'Martinez', '9/', '3/', '92', 'R&D', 'Group:', 'J.', 'S.', 'Wigand', 'Supervisor', '/', 'Manager', 'Discontinue', 'coal', 'retention', 'analyses', 'on', 'licensee', 'submitted', 'product', 'samples', '(Note', ':', 'Coal', 'Retention', 'testing', 'is', 'not', 'performed', 'by', 'most', 'licensees.', 'Other', 'B&W', 'physical', 'measurements', 'as', 'ends', 'stability', 'and', 'inspection', 'for', 'soft', 'spots', 'in', 'ciparettes', 'are', 'thought', 'to', 'be', 'sufficient', 'measures', 'to', 'assure', 'cigarette', 'physical', 'integrity.', 'The', 'proposed', 'action', 'will', 'increase', 'laboratory', 'productivity', '.', ')', 'Suggested', 'Solutions', '(s)', ':', 'Delete', 'coal', 'retention', 'from', 'the', 'list', 'of', 'standard', 'analyses', 'performed', 'on', 'licensee', 'submitted', 'product', 'samples.', 'Special', 'requests', 'for', 'coal', 'retention', 'testing', 'could', 'still', 'be', 'submitted', 'on', 'an', 'exception', 'basis.', 'Have', 'you', 'contacted', 'your', 'Manager/', 'Supervisor?', 'Manager', 'Comments:', 'Manager,', 'please', 'contact', 'suggester', 'and', 'forward', 'comments', 'to', 'the', 'Quality', 'Council.', 'qip', '.', 'wp']\n", + "Bounding boxes: [[292, 91, 376, 175], [219, 316, 225, 327], [95, 355, 169, 370], [482, 268, 518, 282], [511, 309, 570, 323], [461, 605, 483, 619], [545, 603, 563, 617], [525, 904, 641, 926], [257, 203, 279, 214], [285, 203, 334, 216], [341, 201, 418, 211], [256, 215, 324, 229], [331, 214, 387, 228], [395, 215, 423, 228], [89, 274, 118, 289], [117, 274, 127, 288], [128, 274, 163, 289], [169, 272, 196, 287], [196, 274, 204, 288], [215, 272, 230, 287], [237, 272, 287, 286], [293, 272, 307, 286], [314, 274, 363, 285], [370, 272, 384, 285], [390, 271, 451, 282], [543, 265, 560, 279], [560, 264, 575, 279], [575, 264, 590, 279], [420, 310, 442, 323], [448, 310, 491, 323], [236, 313, 251, 327], [256, 313, 273, 326], [278, 313, 327, 327], [91, 316, 161, 330], [163, 318, 169, 331], [169, 317, 218, 327], [190, 355, 268, 366], [274, 353, 303, 366], [309, 352, 375, 365], [381, 351, 435, 365], [443, 352, 458, 363], [464, 348, 520, 362], [527, 346, 594, 361], [190, 369, 240, 383], [247, 367, 301, 380], [318, 365, 352, 379], [352, 367, 359, 380], [373, 366, 402, 376], [408, 366, 472, 376], [479, 365, 529, 376], [536, 363, 549, 374], [554, 363, 578, 374], [190, 383, 256, 394], [261, 381, 275, 394], [282, 383, 311, 393], [318, 380, 386, 391], [401, 378, 437, 389], [443, 378, 465, 389], [471, 377, 528, 391], [191, 398, 275, 406], [282, 397, 297, 405], [304, 394, 332, 405], [339, 394, 402, 405], [409, 392, 430, 402], [437, 392, 508, 403], [515, 391, 535, 402], [542, 391, 571, 401], [193, 411, 228, 422], [235, 409, 250, 420], [256, 409, 327, 419], [332, 408, 352, 418], [360, 406, 410, 419], [415, 406, 430, 416], [436, 404, 453, 417], [458, 405, 529, 415], [535, 405, 592, 415], [193, 425, 208, 433], [214, 423, 255, 431], [261, 420, 325, 434], [331, 419, 390, 432], [395, 418, 463, 431], [478, 416, 500, 429], [506, 418, 566, 431], [193, 436, 236, 447], [240, 436, 269, 447], [277, 434, 333, 445], [339, 433, 410, 446], [418, 430, 502, 445], [503, 433, 507, 444], [508, 430, 514, 444], [95, 489, 159, 504], [165, 487, 222, 501], [223, 486, 241, 503], [243, 489, 250, 503], [263, 486, 306, 500], [313, 486, 341, 499], [348, 486, 412, 497], [416, 485, 447, 498], [453, 485, 475, 498], [480, 483, 508, 496], [515, 483, 532, 494], [536, 483, 593, 494], [264, 501, 320, 514], [324, 501, 392, 512], [397, 501, 412, 511], [419, 499, 475, 512], [482, 499, 546, 510], [264, 517, 314, 528], [320, 514, 374, 528], [390, 513, 439, 526], [446, 513, 502, 524], [508, 511, 530, 522], [538, 510, 566, 523], [263, 529, 330, 540], [335, 527, 387, 540], [390, 527, 428, 538], [433, 525, 468, 536], [473, 525, 488, 535], [496, 524, 560, 537], [566, 524, 584, 537], [264, 543, 281, 553], [286, 539, 350, 553], [355, 541, 397, 551], [96, 612, 127, 623], [131, 613, 156, 624], [161, 612, 225, 623], [229, 610, 260, 623], [264, 609, 314, 622], [323, 608, 398, 621], [98, 654, 150, 665], [154, 651, 211, 664], [232, 648, 288, 662], [296, 649, 338, 662], [344, 648, 394, 662], [401, 648, 464, 661], [469, 647, 491, 658], [497, 644, 547, 657], [99, 666, 155, 677], [162, 665, 177, 676], [183, 665, 205, 675], [211, 663, 261, 676], [267, 662, 323, 676], [102, 824, 123, 837], [124, 824, 130, 838], [130, 823, 145, 837]]\n", + "Labels: ['other', 'question', 'question', 'question', 'answer', 'question', 'question', 'other', 'header', 'header', 'header', 'header', 'header', 'header', 'question', 'question', 'question', 'question', 'question', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'question', 'question', 'answer', 'answer', 'answer', 'question', 'question', 'question', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'question', 'question', 'question', 'question', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'header', 'header', 'header', 'header', 'header', 'header', 'question', 'question', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'answer', 'other', 'other', 'other']\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "with open('data/training_data/annotations/0000971160.json') as f:\n", + " data = json.load(f)\n", + "\n", + "words = []\n", + "bounding_boxes = []\n", + "labels = []\n", + "for annotation in data['form']:\n", + " # get label\n", + " label = annotation['label']\n", + " # get words\n", + " for annotated_word in annotation['words']:\n", + " if annotated_word['text'] == '':\n", + " continue\n", + " words.append(annotated_word['text'])\n", + " bounding_boxes.append(annotated_word['box'])\n", + " labels.append(label)\n", + "\n", + "print(\"Words:\", words)\n", + "print(\"Bounding boxes:\", bounding_boxes)\n", + "print(\"Labels:\", labels)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08676aa0", + "metadata": {}, + "outputs": [], + "source": [ + "接下来让我们可视化bounding boxs" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "137b05b8", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image_with_bboxes = image.copy()\n", + "\n", + "draw = ImageDraw.Draw(image_with_bboxes, \"RGBA\")\n", + "for bbox in bounding_boxes:\n", + " draw.rectangle(bbox, outline='red', width=1)\n", + "\n", + "image_with_bboxes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ca661f9", + "metadata": {}, + "outputs": [], + "source": [ + "接下来我们将image调整为(224,224)来适应模型输入," + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "02c67002", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from PIL import Image\n", + "import numpy as np\n", + "\n", + "# resize image\n", + "target_size = 224\n", + "resized_image = image.copy().resize((target_size, target_size))\n", + "\n", + "# resize corresponding bounding boxes (annotations)\n", + "# Thanks, Stackoverflow: https://stackoverflow.com/questions/49466033/resizing-image-and-its-bounding-box\n", + "def resize_bounding_box(bbox, original_image, target_size):\n", + " x_, y_ = original_image.size\n", + "\n", + " x_scale = target_size / x_ \n", + " y_scale = target_size / y_\n", + " \n", + " origLeft, origTop, origRight, origBottom = tuple(bbox)\n", + " \n", + " x = int(np.round(origLeft * x_scale))\n", + " y = int(np.round(origTop * y_scale))\n", + " xmax = int(np.round(origRight * x_scale))\n", + " ymax = int(np.round(origBottom * y_scale))\n", + " \n", + " return [x, y, xmax, ymax]\n", + "\n", + "resized_bounding_boxes = [resize_bounding_box(bbox, image, target_size) for bbox in bounding_boxes]\n", + "\n", + "draw = ImageDraw.Draw(resized_image, \"RGBA\")\n", + "for bbox in resized_bounding_boxes:\n", + " draw.rectangle(bbox, outline='red', width=1)\n", + "\n", + "resized_image" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "07573a1c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 3, 224, 224)\n" + ] + } + ], + "source": [ + "from mindspore.dataset.vision import ToTensor\n", + "from mindspore import ops\n", + "from mindspore import Tensor\n", + "# 假设 resized_image 是读取的图像数据\n", + "# MindNLP 中的 ToTensor 操作可以将图像数据转换为归一化后的 Tensor\n", + "image = Tensor.from_numpy(ToTensor()(resized_image))\n", + "# 使用 ops.ExpandDims 添加一个 batch 维度\n", + "image = ops.ExpandDims()(image, 0) # batch size of 1\n", + "\n", + "# 打印图像的形状\n", + "print(image.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "96a0d537", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The following parameters in checkpoint files are not loaded:\n", + "['classifier.1.weight', 'classifier.1.bias']\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 1024, 14, 14)\n" + ] + } + ], + "source": [ + "import mindspore\n", + "from mindnlp.transformers import ResNetBackbone\n", + "\n", + "# 加载预训练的ResNet101骨干网络，获取第三个阶段的特征图（对应layer3输出）\n", + "model = ResNetBackbone.from_pretrained(\"microsoft/resnet-101\", out_indices=[3])\n", + "model.set_train(False) # 设置为评估模式\n", + "# 前向传播获取特征图\n", + "output = model(image)\n", + "feature_map = output.feature_maps[0]\n", + "\n", + "print(feature_map.shape) # 输出应为(1, 1024, 14, 14)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a1fdb26d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature Maps BBoxes Shape:\n", + "(145, 1024, 3, 3)\n", + "-\r" + ] + } + ], + "source": [ + "import numpy as np\n", + "import mindspore\n", + "from mindspore import Tensor, ops\n", + "\n", + "# 输入特征图\n", + "# feature_map = Tensor(\n", + "# np.random.rand(1, 1024, 14, 14),\n", + "# dtype=mindspore.float32\n", + "# )\n", + "\n", + "# 目标尺寸和输入特征图尺寸\n", + "target_size = 224 # 假设目标尺寸为 224\n", + "spatial_scale = feature_map.shape[2] / target_size # 14/224\n", + "\n", + "# RoIAlign 配置\n", + "output_size = (3, 3)\n", + "sampling_ratio = 2\n", + "\n", + "# 定义 RoIAlign\n", + "roi_align = ops.ROIAlign(\n", + " pooled_height =output_size[0],\n", + " pooled_width=output_size[1],\n", + " spatial_scale=spatial_scale,\n", + " sample_num=sampling_ratio,\n", + ")\n", + "\n", + "# 假设的边界框\n", + "# resized_bounding_boxes = [\n", + "# [2.0, 3.0, 5.0, 6.0], # 示例边界框\n", + "# [0.5, 1.0, 4.0, 5.0],\n", + "# [0.5, 1.0, 4.0, 5.0],\n", + "# ]\n", + "\n", + "def align_bounding_boxes(bounding_boxes):\n", + " aligned_bounding_boxes = []\n", + " for bbox in bounding_boxes:\n", + " aligned_bbox = [bbox[0] - 0.5, bbox[1] - 0.5, bbox[2] + 0.5, bbox[3] + 0.5]\n", + " aligned_bounding_boxes.append(aligned_bbox)\n", + " return aligned_bounding_boxes\n", + "\n", + "# 对边界框进行调整\n", + "aligned_bboxes = align_bounding_boxes(resized_bounding_boxes)\n", + "\n", + "# 构造 RoIs\n", + "rois = []\n", + "for i, bbox in enumerate(aligned_bboxes):\n", + " rois.append([0] + bbox) # 添加批次索引\n", + "rois = Tensor(rois, dtype=mindspore.float32)\n", + "\n", + "# 执行 RoIAlign\n", + "feature_maps_bboxes = roi_align(feature_map, rois)\n", + "\n", + "# 打印结果形状\n", + "print(\"Feature Maps BBoxes Shape:\")\n", + "print(feature_maps_bboxes.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "38c25091", + "metadata": {}, + "source": [ + "## 将feature map转为视觉embedding\n", + "1. 首先利用Flatten转换\n", + "2. 再用线性层将其转换到layoutlm维度" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "688c8ca4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(145, 9216)\n", + "(145, 768)\n" + ] + } + ], + "source": [ + "import mindspore\n", + "from mindspore import ops\n", + "from mindspore import nn\n", + "flatten = ops.Flatten()\n", + "visual_embeddings = flatten(feature_maps_bboxes)\n", + "print(visual_embeddings.shape)\n", + "projection = nn.Dense(\n", + " in_channels=visual_embeddings.shape[-1],\n", + " out_channels=768\n", + ")\n", + "output = projection(visual_embeddings)\n", + "print(output.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "24def09c", + "metadata": {}, + "outputs": [], + "source": [ + "## 定义pytorch数据集和dataloader\n", + "之间我们示例了如何在单个文档上使用，现在我们定义基于mindspore的数据集和dataloaders \n", + "首先划分训练集和验证集" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "74d17894", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from os import listdir\n", + "\n", + "# list all training image file names\n", + "image_files_train = [f for f in listdir('data/training_data/images')]\n", + "# list all test image file names\n", + "image_files_test = [f for f in listdir('data/testing_data/images')]" + ] + }, + { + "cell_type": "markdown", + "id": "135be8bb", + "metadata": { + "tags": [] + }, + "source": [ + "接着创建一个字典，用于将标签映射到索引，以及将索引映射回标签。" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5b375f13", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['B-answer',\n", + " 'I-answer',\n", + " 'B-header',\n", + " 'I-header',\n", + " 'B-question',\n", + " 'I-question',\n", + " 'B-other',\n", + " 'I-other']" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labels = ['B-answer', 'I-answer', 'B-header', 'I-header', 'B-question', 'I-question', 'B-other', 'I-other']\n", + "labels" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "89385135", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'B-answer': 0,\n", + " 'I-answer': 1,\n", + " 'B-header': 2,\n", + " 'I-header': 3,\n", + " 'B-question': 4,\n", + " 'I-question': 5,\n", + " 'B-other': 6,\n", + " 'I-other': 7}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "idx2label = {v: k for v, k in enumerate(labels)}\n", + "label2idx = {k: v for v, k in enumerate(labels)}\n", + "label2idx" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51686961", + "metadata": {}, + "outputs": [], + "source": [ + "接下来定义mindspore数据集" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2c48348a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from mindspore.dataset import GeneratorDataset, SourceDataset\n", + "from PIL import Image\n", + "import json\n", + "import numpy as np\n", + "# from mindspore import Tensor\n", + "# from mindspore import ops\n", + "# import mindspore.common.dtype as mstype\n", + "from mindspore.dataset.vision import ToTensor\n", + "import imageio.v3 as iio\n", + "def normalize_box(box, width, height):\n", + " return [\n", + " int(1000 * (box[0] / width)),\n", + " int(1000 * (box[1] / height)),\n", + " int(1000 * (box[2] / width)),\n", + " int(1000 * (box[3] / height)),\n", + " ]\n", + "\n", + "def resize_and_align_bounding_box(bbox, original_image, target_size):\n", + " width, height = original_image.size\n", + " x_scale = target_size / width\n", + " y_scale = target_size / height\n", + " orig_left, orig_top, orig_right, orig_bottom = bbox\n", + " x = int(np.round(orig_left * x_scale))\n", + " y = int(np.round(orig_top * y_scale))\n", + " xmax = int(np.round(orig_right * x_scale))\n", + " ymax = int(np.round(orig_bottom * y_scale))\n", + " return [x - 0.5, y - 0.5, xmax + 0.5, ymax + 0.5]\n", + "\n", + "class FUNSDDataset():\n", + " def __init__(self, image_file_names, tokenizer, max_length, target_size, train=True):\n", + " self.image_file_names = image_file_names\n", + " self.tokenizer = tokenizer\n", + " self.max_seq_length = max_length\n", + " self.target_size = target_size\n", + " self.pad_token_box = [0, 0, 0, 0]\n", + " self.train = train\n", + "\n", + " def __len__(self):\n", + " return len(self.image_file_names)\n", + "\n", + " def __getitem__(self, idx):\n", + " item = self.image_file_names[idx]\n", + " base_path = \"data/training_data\" if self.train else \"data/testing_data\"\n", + " original_image=iio.imread(f\"{base_path}/images/{item}\")\n", + " original_image=Image.fromarray(original_image).convert(\"RGB\")\n", + " #original_image = Image.open(f\"{base_path}/images/{item}\").convert(\"RGB\")\n", + " resized_image = original_image.resize((self.target_size, self.target_size))\n", + " with open(f\"{base_path}/annotations/{item[:-4]}.json\") as f:\n", + " data = json.load(f)\n", + " words = []\n", + " unnormalized_word_boxes = []\n", + " word_labels = []\n", + " for annotation in data['form']:\n", + " label = annotation['label']\n", + " for annotated_word in annotation['words']:\n", + " if annotated_word['text'] == '':\n", + " continue\n", + " words.append(annotated_word['text'])\n", + " unnormalized_word_boxes.append(annotated_word['box'])\n", + " word_labels.append(label)\n", + " width, height = original_image.size\n", + " normalized_word_boxes = [normalize_box(bbox, width, height) for bbox in unnormalized_word_boxes]\n", + " assert len(words) == len(normalized_word_boxes)\n", + " token_boxes = []\n", + " unnormalized_token_boxes = []\n", + " token_labels = []\n", + " for word, unnormalized_box, box, label in zip(words, unnormalized_word_boxes, normalized_word_boxes, word_labels):\n", + " word_tokens = self.tokenizer.tokenize(word)\n", + " unnormalized_token_boxes.extend([unnormalized_box for _ in range(len(word_tokens))])\n", + " token_boxes.extend([box for _ in range(len(word_tokens))])\n", + " for i in range(len(word_tokens)):\n", + " if i == 0:\n", + " token_labels.append('B-' + label)\n", + " else:\n", + " token_labels.append('I-' + label)\n", + " special_tokens_count = 2\n", + " if len(token_boxes) > self.max_seq_length - special_tokens_count:\n", + " token_boxes = token_boxes[:self.max_seq_length - special_tokens_count]\n", + " unnormalized_token_boxes = unnormalized_token_boxes[:self.max_seq_length - special_tokens_count]\n", + " token_labels = token_labels[:self.max_seq_length - special_tokens_count]\n", + " token_boxes = [[0, 0, 0, 0]] + token_boxes + [[1000, 1000, 1000, 1000]]\n", + " unnormalized_token_boxes = [[0, 0, 0, 0]] + unnormalized_token_boxes + [[1000, 1000, 1000, 1000]]\n", + " token_labels = [-100] + token_labels + [-100]\n", + " encoding = self.tokenizer(' '.join(words), padding='max_length', truncation=True)\n", + " input_ids = self.tokenizer(' '.join(words), truncation=True)[\"input_ids\"]\n", + " padding_length = self.max_seq_length - len(input_ids)\n", + " token_boxes += [self.pad_token_box] * padding_length\n", + " unnormalized_token_boxes += [self.pad_token_box] * padding_length\n", + " token_labels += [-100] * padding_length\n", + " encoding.update({\n", + " 'bbox': token_boxes,\n", + " 'labels': token_labels\n", + " })\n", + "# assert len(encoding['input_ids']) == self.max_seq_length\n", + "# assert len(encoding['attention_mask']) == self.max_seq_length\n", + "# assert len(encoding['token_type_ids']) == self.max_seq_length\n", + "# assert len(encoding['bbox']) == self.max_seq_length\n", + "# assert len(encoding['labels']) == self.max_seq_length\n", + " encoding['resized_image'] = np.array(resized_image)\n", + " encoding['resized_and_aligned_bounding_boxes'] = [\n", + " [i] + resize_and_align_bounding_box(bbox, original_image, self.target_size)\n", + " for i, bbox in enumerate(unnormalized_token_boxes)\n", + " ]\n", + " encoding['unnormalized_token_boxes'] = unnormalized_token_boxes\n", + " # Convert labels to indices\n", + " label_indices = []\n", + " for label in encoding['labels']:\n", + " if label != -100:\n", + " label_indices.append(label2idx[label])\n", + " else:\n", + " label_indices.append(label)\n", + " encoding['labels'] = label_indices\n", + " # Convert to MindSpore Tensors\n", + "# for key in ['input_ids', 'attention_mask', 'token_type_ids', 'bbox', 'labels']:\n", + "# encoding[key] = Tensor(encoding[key], dtype=mstype.int64)\n", + " #encoding['resized_image'] = Tensor(encoding['resized_image'], dtype=mstype.float32)\n", + "# encoding['resized_image'] = Tensor.from_numpy(ToTensor()(encoding['resized_image']))\n", + "# input_ids = Tensor(encoding['input_ids'], dtype=mstype.int64)\n", + "# attention_mask = Tensor(encoding['attention_mask'], dtype=mstype.int64)\n", + "# token_type_ids = Tensor(encoding['token_type_ids'], dtype=mstype.int64)\n", + "# bbox = Tensor(encoding['bbox'], dtype=mstype.int64)\n", + "# labels = Tensor(encoding['labels'], dtype=mstype.int32)\n", + "# resized_image = Tensor(encoding['resized_image'], dtype=mstype.float32)\n", + "# resized_and_aligned_bounding_boxes = Tensor(encoding['resized_and_aligned_bounding_boxes'], dtype=mstype.float32)\n", + "# unnormalized_token_boxes = Tensor(encoding['unnormalized_token_boxes'], dtype=mstype.int64)\n", + " return (\n", + " encoding['input_ids'],\n", + " encoding['attention_mask'],\n", + " encoding['token_type_ids'],\n", + " encoding['bbox'],\n", + " encoding['labels'],\n", + " ToTensor()(encoding['resized_image']),\n", + " encoding['resized_and_aligned_bounding_boxes'],\n", + " encoding['unnormalized_token_boxes']\n", + " )\n", + "\n", + "# Example usage\n", + "# Assuming datasets and loaders are properly defined\n", + "# train_dataset = FUNSDDataset(...)\n", + "# train_loader = DataLoader(train_dataset, batch_size=32)" + ] + }, + { + "cell_type": "markdown", + "id": "6208ff61", + "metadata": {}, + "source": [ + "调用bert作为分词器" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "3c17f087", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BertTokenizer(name_or_path='bert-base-uncased', vocab_size=30522, model_max_length=512, is_fast=False, padding_side='right', truncation_side='right', special_tokens={'unk_token': '[UNK]', 'sep_token': '[SEP]', 'pad_token': '[PAD]', 'cls_token': '[CLS]', 'mask_token': '[MASK]'}, clean_up_tokenization_spaces=True), added_tokens_decoder={\n", + "\t0: AddedToken(\"[PAD]\", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),\n", + "\t100: AddedToken(\"[UNK]\", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),\n", + "\t101: AddedToken(\"[CLS]\", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),\n", + "\t102: AddedToken(\"[SEP]\", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),\n", + "\t103: AddedToken(\"[MASK]\", rstrip=False, lstrip=False, single_word=False, normalized=False, special=True),\n", + "}\n" + ] + } + ], + "source": [ + "from mindnlp.transformers import BertTokenizer\n", + "tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\n", + "train_dataset = FUNSDDataset(image_file_names=image_files_train, tokenizer=tokenizer, max_length=512, target_size=224)\n", + "print(tokenizer)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6ddba1ca", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "([101,\n", + " 3295,\n", + " 2128,\n", + " 15549,\n", + " 28032,\n", + " 3258,\n", + " 2121,\n", + " 17024,\n", + " 3408,\n", + " 1042,\n", + " 2080,\n", + " 11712,\n", + " 6412,\n", + " 3976,\n", + " 2012,\n", + " 2102,\n", + " 2078,\n", + " 1024,\n", + " 3058,\n", + " 3058,\n", + " 3058,\n", + " 2011,\n", + " 3058,\n", + " 2060,\n", + " 23290,\n", + " 22610,\n", + " 2620,\n", + " 2683,\n", + " 100,\n", + " 17634,\n", + " 3058,\n", + " 6226,\n", + " 1996,\n", + " 2137,\n", + " 9098,\n", + " 2194,\n", + " 5309,\n", + " 2128,\n", + " 15549,\n", + " 28032,\n", + " 3258,\n", + " 2012,\n", + " 11502,\n", + " 22469,\n", + " 1010,\n", + " 14931,\n", + " 20104,\n", + " 2053,\n", + " 1012,\n", + " 5166,\n", + " 2053,\n", + " 1012,\n", + " 2720,\n", + " 1012,\n", + " 1043,\n", + " 1012,\n", + " 22253,\n", + " 2254,\n", + " 1017,\n", + " 1010,\n", + " 2786,\n", + " 3058,\n", + " 1997,\n", + " 2128,\n", + " 15549,\n", + " 28032,\n", + " 3258,\n", + " 4773,\n", + " 10419,\n", + " 6786,\n", + " 4297,\n", + " 2720,\n", + " 1012,\n", + " 7112,\n", + " 20729,\n", + " 2799,\n", + " 1018,\n", + " 1998,\n", + " 5922,\n", + " 2276,\n", + " 2167,\n", + " 9192,\n", + " 1010,\n", + " 19193,\n", + " 5511,\n", + " 21057,\n", + " 2487,\n", + " 1011,\n", + " 5757,\n", + " 21926,\n", + " 2053,\n", + " 7829,\n", + " 3223,\n", + " 2911,\n", + " 2000,\n", + " 22613,\n", + " 2000,\n", + " 7180,\n", + " 2025,\n", + " 2101,\n", + " 2084,\n", + " 2053,\n", + " 7829,\n", + " 3223,\n", + " 1012,\n", + " 5658,\n", + " 2382,\n", + " 2420,\n", + " 12989,\n", + " 1000,\n", + " 2489,\n", + " 1000,\n", + " 11122,\n", + " 2239,\n", + " 1000,\n", + " 3622,\n", + " 5653,\n", + " 3538,\n", + " 2023,\n", + " 5309,\n", + " 2344,\n", + " 2003,\n", + " 2000,\n", + " 3104,\n", + " 2035,\n", + " 5366,\n", + " 22667,\n", + " 2000,\n", + " 1011,\n", + " 3058,\n", + " 3205,\n", + " 2917,\n", + " 1012,\n", + " 4413,\n", + " 1010,\n", + " 2199,\n", + " 20702,\n", + " 1012,\n", + " 1997,\n", + " 3770,\n", + " 6053,\n", + " 10933,\n", + " 1039,\n", + " 1013,\n", + " 1016,\n", + " 1013,\n", + " 1055,\n", + " 1011,\n", + " 4029,\n", + " 1011,\n", + " 1015,\n", + " 1013,\n", + " 1016,\n", + " 1000,\n", + " 4897,\n", + " 2861,\n", + " 1010,\n", + " 2199,\n", + " 20702,\n", + " 1012,\n", + " 1997,\n", + " 3770,\n", + " 6053,\n", + " 1012,\n", + " 10933,\n", + " 1039,\n", + " 1013,\n", + " 1016,\n", + " 1013,\n", + " 1055,\n", + " 1011,\n", + " 2656,\n", + " 1011,\n", + " 1015,\n", + " 1013,\n", + " 1016,\n", + " 1000,\n", + " 4897,\n", + " 17463,\n", + " 1012,\n", + " 1006,\n", + " 2240,\n", + " 4997,\n", + " 2015,\n", + " 1010,\n", + " 3259,\n", + " 11204,\n", + " 1010,\n", + " 4950,\n", + " 1013,\n", + " 23987,\n", + " 1007,\n", + " 2976,\n", + " 4671,\n", + " 5571,\n", + " 2035,\n", + " 4475,\n", + " 2031,\n", + " 2042,\n", + " 8014,\n", + " 1012,\n", + " 5571,\n", + " 2000,\n", + " 1015,\n", + " 1013,\n", + " 1018,\n", + " 1013,\n", + " 5345,\n", + " 1002,\n", + " 2322,\n", + " 1010,\n", + " 23712,\n", + " 1012,\n", + " 4002,\n", + " 1002,\n", + " 2321,\n", + " 1010,\n", + " 11827,\n", + " 1012,\n", + " 4002,\n", + " 1002,\n", + " 4724,\n", + " 2487,\n", + " 1012,\n", + " 2423,\n", + " 1002,\n", + " 4466,\n", + " 1012,\n", + " 4293,\n", + " 2533,\n", + " 5338,\n", + " 9529,\n", + " 3715,\n", + " 2053,\n", + " 1012,\n", + " 4469,\n", + " 4809,\n", + " 2000,\n", + " 1024,\n", + " 1040,\n", + " 1012,\n", + " 3347,\n", + " 7405,\n", + " 4748,\n", + " 2615,\n", + " 1012,\n", + " 10961,\n", + " 4435,\n", + " 3136,\n", + " 2110,\n", + " 4171,\n", + " 3570,\n", + " 2025,\n", + " 2000,\n", + " 2022,\n", + " 5338,\n", + " 2011,\n", + " 17024,\n", + " 100,\n", + " 2000,\n", + " 2022,\n", + " 5338,\n", + " 2334,\n", + " 6226,\n", + " 4748,\n", + " 10020,\n", + " 14931,\n", + " 2099,\n", + " 1013,\n", + " 15418,\n", + " 2102,\n", + " 14931,\n", + " 2099,\n", + " 1012,\n", + " 1006,\n", + " 2004,\n", + " 3223,\n", + " 1007,\n", + " 2334,\n", + " 1052,\n", + " 1013,\n", + " 10848,\n", + " 19738,\n", + " 3366,\n", + " 2053,\n", + " 1012,\n", + " 4748,\n", + " 10020,\n", + " 14931,\n", + " 2099,\n", + " 1013,\n", + " 15418,\n", + " 2102,\n", + " 14931,\n", + " 2099,\n", + " 5309,\n", + " 2344,\n", + " 2053,\n", + " 1012,\n", + " 2254,\n", + " 1017,\n", + " 1010,\n", + " 2786,\n", + " 1049,\n", + " 1012,\n", + " 4518,\n", + " 1013,\n", + " 15488,\n", + " 2213,\n", + " 102,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0],\n", + " [1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0],\n", + " [0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0],\n", + " [[0, 0, 0, 0],\n", + " [345, 80, 398, 93],\n", + " [345, 108, 423, 122],\n", + " [345, 108, 423, 122],\n", + " [345, 108, 423, 122],\n", + " [345, 108, 423, 122],\n", + " [345, 108, 423, 122],\n", + " [53, 134, 103, 147],\n", + " [488, 278, 520, 286],\n", + " [51, 275, 82, 283],\n", + " [51, 275, 82, 283],\n", + " [97, 303, 183, 317],\n", + " [429, 306, 539, 319],\n", + " [795, 306, 850, 321],\n", + " [83, 169, 129, 182],\n", + " [83, 169, 129, 182],\n", + " [83, 169, 129, 182],\n", + " [83, 169, 129, 182],\n", + " [295, 820, 324, 831],\n", + " [296, 849, 328, 857],\n", + " [296, 877, 325, 884],\n", + " [398, 877, 416, 887],\n", + " [398, 849, 427, 860],\n", + " [61, 877, 98, 885],\n", + " [615, 834, 675, 849],\n", + " [615, 834, 675, 849],\n", + " [615, 834, 675, 849],\n", + " [615, 834, 675, 849],\n", + " [291, 795, 311, 816],\n", + " [581, 878, 612, 888],\n", + " [581, 852, 608, 860],\n", + " [44, 818, 57, 893],\n", + " [132, 39, 177, 53],\n", + " [133, 53, 244, 67],\n", + " [129, 67, 232, 80],\n", + " [129, 81, 232, 96],\n", + " [645, 56, 766, 77],\n", + " [772, 57, 921, 78],\n", + " [772, 57, 921, 78],\n", + " [772, 57, 921, 78],\n", + " [772, 57, 921, 78],\n", + " [845, 36, 859, 46],\n", + " [863, 38, 880, 46],\n", + " [426, 85, 519, 102],\n", + " [426, 85, 519, 102],\n", + " [522, 88, 551, 101],\n", + " [633, 81, 712, 91],\n", + " [712, 82, 732, 90],\n", + " [712, 82, 732, 90],\n", + " [632, 110, 673, 120],\n", + " [675, 110, 694, 120],\n", + " [675, 110, 694, 120],\n", + " [347, 123, 371, 136],\n", + " [347, 123, 371, 136],\n", + " [375, 124, 397, 134],\n", + " [375, 124, 397, 134],\n", + " [402, 122, 503, 135],\n", + " [86, 122, 154, 136],\n", + " [160, 123, 174, 136],\n", + " [160, 123, 174, 136],\n", + " [179, 123, 217, 137],\n", + " [53, 106, 81, 117],\n", + " [82, 108, 97, 116],\n", + " [98, 108, 164, 118],\n", + " [98, 108, 164, 118],\n", + " [98, 108, 164, 118],\n", + " [98, 108, 164, 118],\n", + " [83, 151, 182, 165],\n", + " [83, 151, 182, 165],\n", + " [190, 151, 332, 166],\n", + " [335, 154, 367, 165],\n", + " [132, 168, 158, 182],\n", + " [132, 168, 158, 182],\n", + " [162, 168, 216, 182],\n", + " [223, 169, 261, 180],\n", + " [86, 182, 132, 197],\n", + " [139, 183, 149, 194],\n", + " [156, 184, 188, 197],\n", + " [192, 184, 248, 197],\n", + " [249, 183, 311, 197],\n", + " [83, 198, 131, 213],\n", + " [137, 198, 229, 212],\n", + " [137, 198, 229, 212],\n", + " [232, 200, 255, 211],\n", + " [262, 200, 316, 211],\n", + " [262, 200, 316, 211],\n", + " [262, 200, 316, 211],\n", + " [262, 200, 316, 211],\n", + " [317, 198, 354, 212],\n", + " [317, 198, 354, 212],\n", + " [509, 151, 536, 168],\n", + " [541, 154, 619, 167],\n", + " [624, 152, 716, 167],\n", + " [489, 137, 513, 148],\n", + " [514, 138, 528, 146],\n", + " [51, 246, 102, 257],\n", + " [104, 247, 118, 257],\n", + " [120, 247, 156, 257],\n", + " [160, 247, 179, 258],\n", + " [181, 247, 213, 258],\n", + " [213, 247, 245, 255],\n", + " [83, 258, 110, 272],\n", + " [115, 260, 199, 274],\n", + " [203, 260, 301, 275],\n", + " [203, 260, 301, 275],\n", + " [505, 279, 538, 293],\n", + " [541, 282, 561, 293],\n", + " [566, 282, 611, 295],\n", + " [234, 318, 318, 338],\n", + " [322, 318, 370, 338],\n", + " [322, 318, 370, 338],\n", + " [322, 318, 370, 338],\n", + " [374, 321, 438, 338],\n", + " [374, 321, 438, 338],\n", + " [374, 321, 438, 338],\n", + " [442, 321, 489, 336],\n", + " [493, 323, 528, 337],\n", + " [532, 323, 580, 336],\n", + " [234, 352, 270, 366],\n", + " [274, 353, 349, 367],\n", + " [359, 352, 405, 367],\n", + " [408, 355, 422, 365],\n", + " [429, 355, 447, 365],\n", + " [451, 355, 497, 368],\n", + " [500, 353, 519, 366],\n", + " [523, 353, 569, 366],\n", + " [576, 353, 641, 366],\n", + " [648, 353, 661, 366],\n", + " [648, 353, 661, 366],\n", + " [664, 352, 706, 367],\n", + " [234, 367, 280, 381],\n", + " [283, 369, 338, 382],\n", + " [283, 369, 338, 382],\n", + " [234, 398, 290, 412],\n", + " [234, 398, 290, 412],\n", + " [234, 398, 290, 412],\n", + " [292, 399, 324, 412],\n", + " [292, 399, 324, 412],\n", + " [328, 398, 345, 411],\n", + " [350, 399, 370, 412],\n", + " [374, 399, 393, 412],\n", + " [401, 399, 461, 412],\n", + " [465, 399, 480, 410],\n", + " [465, 399, 480, 410],\n", + " [479, 399, 493, 410],\n", + " [479, 399, 493, 410],\n", + " [493, 399, 510, 412],\n", + " [513, 401, 523, 409],\n", + " [527, 399, 551, 412],\n", + " [527, 399, 551, 412],\n", + " [551, 399, 564, 410],\n", + " [551, 399, 564, 410],\n", + " [564, 399, 581, 412],\n", + " [564, 399, 581, 412],\n", + " [586, 401, 615, 412],\n", + " [232, 413, 287, 427],\n", + " [232, 413, 287, 427],\n", + " [232, 413, 287, 427],\n", + " [291, 413, 322, 427],\n", + " [291, 413, 322, 427],\n", + " [328, 415, 346, 426],\n", + " [350, 415, 368, 426],\n", + " [374, 416, 392, 427],\n", + " [374, 416, 392, 427],\n", + " [398, 415, 460, 429],\n", + " [465, 415, 480, 426],\n", + " [465, 415, 480, 426],\n", + " [480, 415, 494, 426],\n", + " [480, 415, 494, 426],\n", + " [493, 415, 510, 428],\n", + " [513, 418, 523, 426],\n", + " [527, 413, 551, 428],\n", + " [527, 413, 551, 428],\n", + " [549, 415, 564, 426],\n", + " [549, 415, 564, 426],\n", + " [564, 415, 582, 428],\n", + " [564, 415, 582, 428],\n", + " [587, 416, 615, 427],\n", + " [234, 444, 279, 458],\n", + " [234, 444, 279, 458],\n", + " [282, 444, 317, 458],\n", + " [282, 444, 317, 458],\n", + " [324, 446, 406, 460],\n", + " [324, 446, 406, 460],\n", + " [324, 446, 406, 460],\n", + " [410, 444, 460, 459],\n", + " [463, 444, 514, 459],\n", + " [463, 444, 514, 459],\n", + " [520, 444, 585, 457],\n", + " [520, 444, 585, 457],\n", + " [585, 444, 664, 459],\n", + " [585, 444, 664, 459],\n", + " [234, 473, 299, 488],\n", + " [301, 473, 366, 488],\n", + " [374, 472, 439, 489],\n", + " [234, 504, 270, 518],\n", + " [272, 504, 371, 517],\n", + " [375, 504, 422, 517],\n", + " [429, 504, 476, 517],\n", + " [480, 504, 587, 518],\n", + " [480, 504, 587, 518],\n", + " [549, 542, 641, 580],\n", + " [660, 543, 686, 572],\n", + " [762, 634, 779, 656],\n", + " [772, 623, 811, 672],\n", + " [772, 623, 811, 672],\n", + " [813, 613, 858, 658],\n", + " [813, 613, 858, 658],\n", + " [754, 398, 783, 412],\n", + " [754, 398, 783, 412],\n", + " [754, 398, 783, 412],\n", + " [784, 398, 820, 412],\n", + " [784, 398, 820, 412],\n", + " [818, 398, 842, 411],\n", + " [753, 415, 782, 429],\n", + " [753, 415, 782, 429],\n", + " [753, 415, 782, 429],\n", + " [784, 415, 820, 428],\n", + " [784, 415, 820, 428],\n", + " [818, 415, 842, 428],\n", + " [776, 444, 814, 458],\n", + " [776, 444, 814, 458],\n", + " [776, 444, 814, 458],\n", + " [817, 446, 843, 459],\n", + " [817, 446, 843, 459],\n", + " [786, 473, 817, 486],\n", + " [786, 473, 817, 486],\n", + " [818, 473, 842, 488],\n", + " [818, 473, 842, 488],\n", + " [45, 764, 114, 775],\n", + " [115, 765, 166, 772],\n", + " [335, 764, 405, 774],\n", + " [405, 765, 450, 775],\n", + " [451, 765, 469, 775],\n", + " [451, 765, 469, 775],\n", + " [496, 763, 531, 776],\n", + " [535, 765, 570, 776],\n", + " [573, 765, 587, 775],\n", + " [573, 765, 587, 775],\n", + " [505, 778, 523, 791],\n", + " [505, 778, 523, 791],\n", + " [527, 777, 581, 791],\n", + " [527, 777, 581, 791],\n", + " [342, 777, 380, 792],\n", + " [342, 777, 380, 792],\n", + " [342, 777, 380, 792],\n", + " [384, 777, 454, 792],\n", + " [78, 778, 133, 789],\n", + " [137, 778, 229, 789],\n", + " [45, 792, 78, 802],\n", + " [78, 792, 98, 802],\n", + " [101, 792, 143, 802],\n", + " [309, 804, 329, 815],\n", + " [335, 806, 346, 814],\n", + " [350, 806, 360, 816],\n", + " [364, 804, 412, 817],\n", + " [416, 806, 429, 816],\n", + " [426, 806, 477, 817],\n", + " [566, 804, 577, 814],\n", + " [578, 806, 591, 816],\n", + " [594, 807, 608, 815],\n", + " [608, 807, 656, 815],\n", + " [61, 820, 97, 828],\n", + " [98, 820, 154, 830],\n", + " [61, 846, 97, 859],\n", + " [61, 846, 97, 859],\n", + " [101, 846, 156, 859],\n", + " [101, 846, 156, 859],\n", + " [101, 846, 156, 859],\n", + " [101, 846, 156, 859],\n", + " [101, 846, 156, 859],\n", + " [161, 848, 185, 859],\n", + " [161, 848, 185, 859],\n", + " [161, 848, 185, 859],\n", + " [186, 849, 259, 860],\n", + " [186, 849, 259, 860],\n", + " [186, 849, 259, 860],\n", + " [186, 849, 259, 860],\n", + " [401, 821, 433, 829],\n", + " [435, 821, 500, 831],\n", + " [435, 821, 500, 831],\n", + " [435, 821, 500, 831],\n", + " [435, 821, 500, 831],\n", + " [435, 821, 500, 831],\n", + " [502, 823, 522, 831],\n", + " [502, 823, 522, 831],\n", + " [581, 821, 610, 832],\n", + " [581, 821, 610, 832],\n", + " [615, 823, 674, 833],\n", + " [615, 823, 674, 833],\n", + " [615, 823, 674, 833],\n", + " [615, 823, 674, 833],\n", + " [615, 823, 674, 833],\n", + " [675, 821, 695, 832],\n", + " [675, 821, 695, 832],\n", + " [700, 824, 754, 832],\n", + " [757, 824, 790, 832],\n", + " [791, 824, 809, 832],\n", + " [791, 824, 809, 832],\n", + " [615, 855, 681, 870],\n", + " [687, 856, 700, 871],\n", + " [687, 856, 700, 871],\n", + " [707, 855, 745, 870],\n", + " [614, 878, 637, 892],\n", + " [614, 878, 637, 892],\n", + " [637, 878, 685, 892],\n", + " [637, 878, 685, 892],\n", + " [683, 880, 721, 891],\n", + " [683, 880, 721, 891],\n", + " [1000, 1000, 1000, 1000],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0]],\n", + " [-100,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 4,\n", + " 4,\n", + " 6,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 3,\n", + " 3,\n", + " 3,\n", + " 6,\n", + " 6,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 6,\n", + " 6,\n", + " 6,\n", + " 6,\n", + " 7,\n", + " 6,\n", + " 7,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 0,\n", + " 2,\n", + " 2,\n", + " 2,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 4,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 4,\n", + " 5,\n", + " 5,\n", + " 4,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 4,\n", + " 5,\n", + " 4,\n", + " 5,\n", + " 4,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 5,\n", + " 4,\n", + " 5,\n", + " 4,\n", + " 4,\n", + " 4,\n", + " 5,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " 0,\n", + " 1,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100,\n", + " -100],\n", + " array([[[0. , 0. , 0.15294118, ..., 1. ,\n", + " 1. , 1. ],\n", + " [0. , 0. , 0.23137257, ..., 1. ,\n", + " 1. , 1. ],\n", + " [0. , 0. , 0.227451 , ..., 1. ,\n", + " 1. , 1. ],\n", + " ...,\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ],\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ],\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ]],\n", + " \n", + " [[0. , 0. , 0.15294118, ..., 1. ,\n", + " 1. , 1. ],\n", + " [0. , 0. , 0.23137257, ..., 1. ,\n", + " 1. , 1. ],\n", + " [0. , 0. , 0.227451 , ..., 1. ,\n", + " 1. , 1. ],\n", + " ...,\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ],\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ],\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ]],\n", + " \n", + " [[0. , 0. , 0.15294118, ..., 1. ,\n", + " 1. , 1. ],\n", + " [0. , 0. , 0.23137257, ..., 1. ,\n", + " 1. , 1. ],\n", + " [0. , 0. , 0.227451 , ..., 1. ,\n", + " 1. , 1. ],\n", + " ...,\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ],\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ],\n", + " [1. , 1. , 1. , ..., 1. ,\n", + " 1. , 1. ]]], dtype=float32),\n", + " [[0, -0.5, -0.5, 0.5, 0.5],\n", + " [1, 76.5, 17.5, 89.5, 21.5],\n", + " [2, 76.5, 23.5, 95.5, 27.5],\n", + " [3, 76.5, 23.5, 95.5, 27.5],\n", + " [4, 76.5, 23.5, 95.5, 27.5],\n", + " [5, 76.5, 23.5, 95.5, 27.5],\n", + " [6, 76.5, 23.5, 95.5, 27.5],\n", + " [7, 11.5, 29.5, 23.5, 33.5],\n", + " [8, 108.5, 61.5, 117.5, 64.5],\n", + " [9, 10.5, 61.5, 19.5, 63.5],\n", + " [10, 10.5, 61.5, 19.5, 63.5],\n", + " [11, 21.5, 67.5, 41.5, 71.5],\n", + " [12, 95.5, 68.5, 121.5, 71.5],\n", + " [13, 177.5, 68.5, 190.5, 72.5],\n", + " [14, 18.5, 37.5, 29.5, 41.5],\n", + " [15, 18.5, 37.5, 29.5, 41.5],\n", + " [16, 18.5, 37.5, 29.5, 41.5],\n", + " [17, 18.5, 37.5, 29.5, 41.5],\n", + " [18, 65.5, 183.5, 73.5, 186.5],\n", + " [19, 65.5, 189.5, 73.5, 192.5],\n", + " [20, 65.5, 195.5, 73.5, 198.5],\n", + " [21, 88.5, 195.5, 93.5, 199.5],\n", + " [22, 88.5, 189.5, 96.5, 193.5],\n", + " [23, 13.5, 195.5, 22.5, 198.5],\n", + " [24, 137.5, 186.5, 151.5, 190.5],\n", + " [25, 137.5, 186.5, 151.5, 190.5],\n", + " [26, 137.5, 186.5, 151.5, 190.5],\n", + " [27, 137.5, 186.5, 151.5, 190.5],\n", + " [28, 64.5, 177.5, 70.5, 183.5],\n", + " [29, 129.5, 196.5, 137.5, 199.5],\n", + " [30, 129.5, 190.5, 136.5, 193.5],\n", + " [31, 9.5, 182.5, 13.5, 200.5],\n", + " [32, 29.5, 8.5, 40.5, 12.5],\n", + " [33, 29.5, 11.5, 55.5, 15.5],\n", + " [34, 28.5, 14.5, 52.5, 18.5],\n", + " [35, 28.5, 17.5, 52.5, 22.5],\n", + " [36, 144.5, 12.5, 172.5, 17.5],\n", + " [37, 172.5, 12.5, 206.5, 17.5],\n", + " [38, 172.5, 12.5, 206.5, 17.5],\n", + " [39, 172.5, 12.5, 206.5, 17.5],\n", + " [40, 172.5, 12.5, 206.5, 17.5],\n", + " [41, 188.5, 7.5, 193.5, 10.5],\n", + " [42, 192.5, 8.5, 197.5, 10.5],\n", + " [43, 95.5, 18.5, 116.5, 23.5],\n", + " [44, 95.5, 18.5, 116.5, 23.5],\n", + " [45, 116.5, 19.5, 123.5, 23.5],\n", + " [46, 141.5, 17.5, 160.5, 20.5],\n", + " [47, 159.5, 17.5, 164.5, 20.5],\n", + " [48, 159.5, 17.5, 164.5, 20.5],\n", + " [49, 141.5, 24.5, 151.5, 27.5],\n", + " [50, 150.5, 24.5, 156.5, 27.5],\n", + " [51, 150.5, 24.5, 156.5, 27.5],\n", + " [52, 77.5, 27.5, 83.5, 30.5],\n", + " [53, 77.5, 27.5, 83.5, 30.5],\n", + " [54, 83.5, 27.5, 89.5, 30.5],\n", + " [55, 83.5, 27.5, 89.5, 30.5],\n", + " [56, 89.5, 26.5, 113.5, 30.5],\n", + " [57, 18.5, 26.5, 35.5, 30.5],\n", + " [58, 35.5, 27.5, 39.5, 30.5],\n", + " [59, 35.5, 27.5, 39.5, 30.5],\n", + " [60, 39.5, 27.5, 49.5, 31.5],\n", + " [61, 11.5, 23.5, 18.5, 26.5],\n", + " [62, 18.5, 23.5, 22.5, 26.5],\n", + " [63, 21.5, 23.5, 37.5, 26.5],\n", + " [64, 21.5, 23.5, 37.5, 26.5],\n", + " [65, 21.5, 23.5, 37.5, 26.5],\n", + " [66, 21.5, 23.5, 37.5, 26.5],\n", + " [67, 18.5, 33.5, 41.5, 37.5],\n", + " [68, 18.5, 33.5, 41.5, 37.5],\n", + " [69, 42.5, 33.5, 74.5, 37.5],\n", + " [70, 74.5, 33.5, 82.5, 37.5],\n", + " [71, 29.5, 37.5, 36.5, 41.5],\n", + " [72, 29.5, 37.5, 36.5, 41.5],\n", + " [73, 35.5, 37.5, 49.5, 41.5],\n", + " [74, 49.5, 37.5, 58.5, 40.5],\n", + " [75, 18.5, 40.5, 30.5, 44.5],\n", + " [76, 30.5, 40.5, 34.5, 43.5],\n", + " [77, 34.5, 40.5, 42.5, 44.5],\n", + " [78, 42.5, 40.5, 56.5, 44.5],\n", + " [79, 55.5, 40.5, 70.5, 44.5],\n", + " [80, 18.5, 43.5, 29.5, 48.5],\n", + " [81, 30.5, 43.5, 51.5, 47.5],\n", + " [82, 30.5, 43.5, 51.5, 47.5],\n", + " [83, 51.5, 44.5, 57.5, 47.5],\n", + " [84, 58.5, 44.5, 71.5, 47.5],\n", + " [85, 58.5, 44.5, 71.5, 47.5],\n", + " [86, 58.5, 44.5, 71.5, 47.5],\n", + " [87, 58.5, 44.5, 71.5, 47.5],\n", + " [88, 70.5, 43.5, 79.5, 47.5],\n", + " [89, 70.5, 43.5, 79.5, 47.5],\n", + " [90, 113.5, 33.5, 120.5, 38.5],\n", + " [91, 120.5, 33.5, 139.5, 37.5],\n", + " [92, 139.5, 33.5, 161.5, 37.5],\n", + " [93, 109.5, 30.5, 115.5, 33.5],\n", + " [94, 114.5, 30.5, 118.5, 33.5],\n", + " [95, 10.5, 54.5, 23.5, 58.5],\n", + " [96, 23.5, 54.5, 26.5, 58.5],\n", + " [97, 26.5, 54.5, 35.5, 58.5],\n", + " [98, 35.5, 54.5, 40.5, 58.5],\n", + " [99, 40.5, 54.5, 48.5, 58.5],\n", + " [100, 47.5, 54.5, 55.5, 57.5],\n", + " [101, 18.5, 57.5, 25.5, 61.5],\n", + " [102, 25.5, 57.5, 45.5, 61.5],\n", + " [103, 45.5, 57.5, 68.5, 62.5],\n", + " [104, 45.5, 57.5, 68.5, 62.5],\n", + " [105, 112.5, 61.5, 121.5, 66.5],\n", + " [106, 120.5, 62.5, 126.5, 66.5],\n", + " [107, 126.5, 62.5, 137.5, 66.5],\n", + " [108, 52.5, 70.5, 71.5, 76.5],\n", + " [109, 71.5, 70.5, 83.5, 76.5],\n", + " [110, 71.5, 70.5, 83.5, 76.5],\n", + " [111, 71.5, 70.5, 83.5, 76.5],\n", + " [112, 83.5, 71.5, 98.5, 76.5],\n", + " [113, 83.5, 71.5, 98.5, 76.5],\n", + " [114, 83.5, 71.5, 98.5, 76.5],\n", + " [115, 98.5, 71.5, 110.5, 75.5],\n", + " [116, 110.5, 71.5, 118.5, 75.5],\n", + " [117, 118.5, 71.5, 130.5, 75.5],\n", + " [118, 52.5, 78.5, 61.5, 82.5],\n", + " [119, 60.5, 78.5, 78.5, 82.5],\n", + " [120, 80.5, 78.5, 91.5, 82.5],\n", + " [121, 90.5, 79.5, 95.5, 82.5],\n", + " [122, 95.5, 79.5, 100.5, 82.5],\n", + " [123, 100.5, 79.5, 111.5, 82.5],\n", + " [124, 111.5, 78.5, 116.5, 82.5],\n", + " [125, 116.5, 78.5, 128.5, 82.5],\n", + " [126, 128.5, 78.5, 144.5, 82.5],\n", + " [127, 144.5, 78.5, 148.5, 82.5],\n", + " [128, 144.5, 78.5, 148.5, 82.5],\n", + " [129, 148.5, 78.5, 158.5, 82.5],\n", + " [130, 52.5, 81.5, 63.5, 85.5],\n", + " [131, 62.5, 82.5, 76.5, 86.5],\n", + " [132, 62.5, 82.5, 76.5, 86.5],\n", + " [133, 52.5, 88.5, 65.5, 92.5],\n", + " [134, 52.5, 88.5, 65.5, 92.5],\n", + " [135, 52.5, 88.5, 65.5, 92.5],\n", + " [136, 65.5, 88.5, 73.5, 92.5],\n", + " [137, 65.5, 88.5, 73.5, 92.5],\n", + " [138, 72.5, 88.5, 77.5, 92.5],\n", + " [139, 77.5, 88.5, 83.5, 92.5],\n", + " [140, 83.5, 88.5, 88.5, 92.5],\n", + " [141, 89.5, 88.5, 103.5, 92.5],\n", + " [142, 103.5, 88.5, 108.5, 92.5],\n", + " [143, 103.5, 88.5, 108.5, 92.5],\n", + " [144, 106.5, 88.5, 111.5, 92.5],\n", + " [145, 106.5, 88.5, 111.5, 92.5],\n", + " [146, 110.5, 88.5, 114.5, 92.5],\n", + " [147, 114.5, 89.5, 117.5, 92.5],\n", + " [148, 117.5, 88.5, 123.5, 92.5],\n", + " [149, 117.5, 88.5, 123.5, 92.5],\n", + " [150, 122.5, 88.5, 126.5, 92.5],\n", + " [151, 122.5, 88.5, 126.5, 92.5],\n", + " [152, 125.5, 88.5, 130.5, 92.5],\n", + " [153, 125.5, 88.5, 130.5, 92.5],\n", + " [154, 130.5, 89.5, 138.5, 92.5],\n", + " [155, 51.5, 92.5, 64.5, 96.5],\n", + " [156, 51.5, 92.5, 64.5, 96.5],\n", + " [157, 51.5, 92.5, 64.5, 96.5],\n", + " [158, 64.5, 92.5, 72.5, 96.5],\n", + " [159, 64.5, 92.5, 72.5, 96.5],\n", + " [160, 72.5, 92.5, 78.5, 95.5],\n", + " [161, 77.5, 92.5, 83.5, 95.5],\n", + " [162, 83.5, 92.5, 88.5, 96.5],\n", + " [163, 83.5, 92.5, 88.5, 96.5],\n", + " [164, 88.5, 92.5, 103.5, 96.5],\n", + " [165, 103.5, 92.5, 108.5, 95.5],\n", + " [166, 103.5, 92.5, 108.5, 95.5],\n", + " [167, 107.5, 92.5, 111.5, 95.5],\n", + " [168, 107.5, 92.5, 111.5, 95.5],\n", + " [169, 110.5, 92.5, 114.5, 96.5],\n", + " [170, 114.5, 93.5, 117.5, 95.5],\n", + " [171, 117.5, 92.5, 123.5, 96.5],\n", + " [172, 117.5, 92.5, 123.5, 96.5],\n", + " [173, 122.5, 92.5, 126.5, 95.5],\n", + " [174, 122.5, 92.5, 126.5, 95.5],\n", + " [175, 125.5, 92.5, 131.5, 96.5],\n", + " [176, 125.5, 92.5, 131.5, 96.5],\n", + " [177, 131.5, 92.5, 138.5, 96.5],\n", + " [178, 52.5, 98.5, 63.5, 103.5],\n", + " [179, 52.5, 98.5, 63.5, 103.5],\n", + " [180, 62.5, 98.5, 71.5, 103.5],\n", + " [181, 62.5, 98.5, 71.5, 103.5],\n", + " [182, 72.5, 99.5, 91.5, 103.5],\n", + " [183, 72.5, 99.5, 91.5, 103.5],\n", + " [184, 72.5, 99.5, 91.5, 103.5],\n", + " [185, 91.5, 98.5, 103.5, 103.5],\n", + " [186, 103.5, 98.5, 115.5, 103.5],\n", + " [187, 103.5, 98.5, 115.5, 103.5],\n", + " [188, 116.5, 98.5, 131.5, 102.5],\n", + " [189, 116.5, 98.5, 131.5, 102.5],\n", + " [190, 130.5, 98.5, 149.5, 103.5],\n", + " [191, 130.5, 98.5, 149.5, 103.5],\n", + " [192, 52.5, 105.5, 67.5, 109.5],\n", + " [193, 67.5, 105.5, 82.5, 109.5],\n", + " [194, 83.5, 105.5, 98.5, 110.5],\n", + " [195, 52.5, 112.5, 61.5, 116.5],\n", + " [196, 60.5, 112.5, 83.5, 116.5],\n", + " [197, 83.5, 112.5, 95.5, 116.5],\n", + " [198, 95.5, 112.5, 107.5, 116.5],\n", + " [199, 107.5, 112.5, 132.5, 116.5],\n", + " [200, 107.5, 112.5, 132.5, 116.5],\n", + " [201, 122.5, 120.5, 144.5, 130.5],\n", + " [202, 147.5, 121.5, 154.5, 128.5],\n", + " [203, 170.5, 141.5, 175.5, 147.5],\n", + " [204, 172.5, 139.5, 182.5, 151.5],\n", + " [205, 172.5, 139.5, 182.5, 151.5],\n", + " [206, 181.5, 136.5, 192.5, 147.5],\n", + " [207, 181.5, 136.5, 192.5, 147.5],\n", + " [208, 168.5, 88.5, 175.5, 92.5],\n", + " [209, 168.5, 88.5, 175.5, 92.5],\n", + " [210, 168.5, 88.5, 175.5, 92.5],\n", + " [211, 175.5, 88.5, 184.5, 92.5],\n", + " [212, 175.5, 88.5, 184.5, 92.5],\n", + " [213, 182.5, 88.5, 189.5, 92.5],\n", + " [214, 168.5, 92.5, 175.5, 96.5],\n", + " [215, 168.5, 92.5, 175.5, 96.5],\n", + " [216, 168.5, 92.5, 175.5, 96.5],\n", + " [217, 175.5, 92.5, 184.5, 96.5],\n", + " [218, 175.5, 92.5, 184.5, 96.5],\n", + " [219, 182.5, 92.5, 189.5, 96.5],\n", + " [220, 173.5, 98.5, 183.5, 103.5],\n", + " [221, 173.5, 98.5, 183.5, 103.5],\n", + " [222, 173.5, 98.5, 183.5, 103.5],\n", + " [223, 182.5, 99.5, 189.5, 103.5],\n", + " [224, 182.5, 99.5, 189.5, 103.5],\n", + " [225, 175.5, 105.5, 183.5, 109.5],\n", + " [226, 175.5, 105.5, 183.5, 109.5],\n", + " [227, 182.5, 105.5, 189.5, 109.5],\n", + " [228, 182.5, 105.5, 189.5, 109.5],\n", + " [229, 9.5, 170.5, 26.5, 174.5],\n", + " [230, 25.5, 170.5, 37.5, 173.5],\n", + " [231, 74.5, 170.5, 91.5, 173.5],\n", + " [232, 90.5, 170.5, 101.5, 174.5],\n", + " [233, 100.5, 170.5, 105.5, 174.5],\n", + " [234, 100.5, 170.5, 105.5, 174.5],\n", + " [235, 110.5, 170.5, 119.5, 174.5],\n", + " [236, 119.5, 170.5, 128.5, 174.5],\n", + " [237, 127.5, 170.5, 132.5, 174.5],\n", + " [238, 127.5, 170.5, 132.5, 174.5],\n", + " [239, 112.5, 173.5, 117.5, 177.5],\n", + " [240, 112.5, 173.5, 117.5, 177.5],\n", + " [241, 117.5, 173.5, 130.5, 177.5],\n", + " [242, 117.5, 173.5, 130.5, 177.5],\n", + " [243, 76.5, 173.5, 85.5, 177.5],\n", + " [244, 76.5, 173.5, 85.5, 177.5],\n", + " [245, 76.5, 173.5, 85.5, 177.5],\n", + " [246, 85.5, 173.5, 102.5, 177.5],\n", + " [247, 17.5, 173.5, 30.5, 177.5],\n", + " [248, 30.5, 173.5, 51.5, 177.5],\n", + " [249, 9.5, 176.5, 18.5, 180.5],\n", + " [250, 17.5, 176.5, 22.5, 180.5],\n", + " [251, 22.5, 176.5, 32.5, 180.5],\n", + " [252, 68.5, 179.5, 74.5, 183.5],\n", + " [253, 74.5, 180.5, 78.5, 182.5],\n", + " [254, 77.5, 180.5, 81.5, 183.5],\n", + " [255, 81.5, 179.5, 92.5, 183.5],\n", + " [256, 92.5, 180.5, 96.5, 183.5],\n", + " [257, 95.5, 180.5, 107.5, 183.5],\n", + " [258, 126.5, 179.5, 129.5, 182.5],\n", + " [259, 129.5, 180.5, 133.5, 183.5],\n", + " [260, 132.5, 180.5, 136.5, 183.5],\n", + " [261, 135.5, 180.5, 147.5, 183.5],\n", + " [262, 13.5, 183.5, 22.5, 185.5],\n", + " [263, 21.5, 183.5, 35.5, 186.5],\n", + " [264, 13.5, 189.5, 22.5, 192.5],\n", + " [265, 13.5, 189.5, 22.5, 192.5],\n", + " [266, 22.5, 189.5, 35.5, 192.5],\n", + " [267, 22.5, 189.5, 35.5, 192.5],\n", + " [268, 22.5, 189.5, 35.5, 192.5],\n", + " [269, 22.5, 189.5, 35.5, 192.5],\n", + " [270, 22.5, 189.5, 35.5, 192.5],\n", + " [271, 35.5, 189.5, 41.5, 192.5],\n", + " [272, 35.5, 189.5, 41.5, 192.5],\n", + " [273, 35.5, 189.5, 41.5, 192.5],\n", + " [274, 41.5, 189.5, 58.5, 193.5],\n", + " [275, 41.5, 189.5, 58.5, 193.5],\n", + " [276, 41.5, 189.5, 58.5, 193.5],\n", + " [277, 41.5, 189.5, 58.5, 193.5],\n", + " [278, 89.5, 183.5, 97.5, 186.5],\n", + " [279, 97.5, 183.5, 112.5, 186.5],\n", + " [280, 97.5, 183.5, 112.5, 186.5],\n", + " [281, 97.5, 183.5, 112.5, 186.5],\n", + " [282, 97.5, 183.5, 112.5, 186.5],\n", + " [283, 97.5, 183.5, 112.5, 186.5],\n", + " [284, 112.5, 183.5, 117.5, 186.5],\n", + " [285, 112.5, 183.5, 117.5, 186.5],\n", + " [286, 129.5, 183.5, 137.5, 186.5],\n", + " [287, 129.5, 183.5, 137.5, 186.5],\n", + " [288, 137.5, 183.5, 151.5, 187.5],\n", + " [289, 137.5, 183.5, 151.5, 187.5],\n", + " [290, 137.5, 183.5, 151.5, 187.5],\n", + " [291, 137.5, 183.5, 151.5, 187.5],\n", + " [292, 137.5, 183.5, 151.5, 187.5],\n", + " [293, 150.5, 183.5, 156.5, 186.5],\n", + " [294, 150.5, 183.5, 156.5, 186.5],\n", + " [295, 156.5, 184.5, 169.5, 186.5],\n", + " [296, 169.5, 184.5, 177.5, 186.5],\n", + " [297, 176.5, 184.5, 181.5, 186.5],\n", + " [298, 176.5, 184.5, 181.5, 186.5],\n", + " [299, 137.5, 191.5, 153.5, 195.5],\n", + " [300, 153.5, 191.5, 157.5, 195.5],\n", + " [301, 153.5, 191.5, 157.5, 195.5],\n", + " [302, 157.5, 191.5, 167.5, 195.5],\n", + " [303, 137.5, 196.5, 143.5, 200.5],\n", + " [304, 137.5, 196.5, 143.5, 200.5],\n", + " [305, 142.5, 196.5, 153.5, 200.5],\n", + " [306, 142.5, 196.5, 153.5, 200.5],\n", + " [307, 152.5, 196.5, 162.5, 200.5],\n", + " [308, 152.5, 196.5, 162.5, 200.5],\n", + " [309, 293.5, 223.5, 294.5, 224.5],\n", + " [310, -0.5, -0.5, 0.5, 0.5],\n", + " [311, -0.5, -0.5, 0.5, 0.5],\n", + " [312, -0.5, -0.5, 0.5, 0.5],\n", + " [313, -0.5, -0.5, 0.5, 0.5],\n", + " [314, -0.5, -0.5, 0.5, 0.5],\n", + " [315, -0.5, -0.5, 0.5, 0.5],\n", + " [316, -0.5, -0.5, 0.5, 0.5],\n", + " [317, -0.5, -0.5, 0.5, 0.5],\n", + " [318, -0.5, -0.5, 0.5, 0.5],\n", + " [319, -0.5, -0.5, 0.5, 0.5],\n", + " [320, -0.5, -0.5, 0.5, 0.5],\n", + " [321, -0.5, -0.5, 0.5, 0.5],\n", + " [322, -0.5, -0.5, 0.5, 0.5],\n", + " [323, -0.5, -0.5, 0.5, 0.5],\n", + " [324, -0.5, -0.5, 0.5, 0.5],\n", + " [325, -0.5, -0.5, 0.5, 0.5],\n", + " [326, -0.5, -0.5, 0.5, 0.5],\n", + " [327, -0.5, -0.5, 0.5, 0.5],\n", + " [328, -0.5, -0.5, 0.5, 0.5],\n", + " [329, -0.5, -0.5, 0.5, 0.5],\n", + " [330, -0.5, -0.5, 0.5, 0.5],\n", + " [331, -0.5, -0.5, 0.5, 0.5],\n", + " [332, -0.5, -0.5, 0.5, 0.5],\n", + " [333, -0.5, -0.5, 0.5, 0.5],\n", + " [334, -0.5, -0.5, 0.5, 0.5],\n", + " [335, -0.5, -0.5, 0.5, 0.5],\n", + " [336, -0.5, -0.5, 0.5, 0.5],\n", + " [337, -0.5, -0.5, 0.5, 0.5],\n", + " [338, -0.5, -0.5, 0.5, 0.5],\n", + " [339, -0.5, -0.5, 0.5, 0.5],\n", + " [340, -0.5, -0.5, 0.5, 0.5],\n", + " [341, -0.5, -0.5, 0.5, 0.5],\n", + " [342, -0.5, -0.5, 0.5, 0.5],\n", + " [343, -0.5, -0.5, 0.5, 0.5],\n", + " [344, -0.5, -0.5, 0.5, 0.5],\n", + " [345, -0.5, -0.5, 0.5, 0.5],\n", + " [346, -0.5, -0.5, 0.5, 0.5],\n", + " [347, -0.5, -0.5, 0.5, 0.5],\n", + " [348, -0.5, -0.5, 0.5, 0.5],\n", + " [349, -0.5, -0.5, 0.5, 0.5],\n", + " [350, -0.5, -0.5, 0.5, 0.5],\n", + " [351, -0.5, -0.5, 0.5, 0.5],\n", + " [352, -0.5, -0.5, 0.5, 0.5],\n", + " [353, -0.5, -0.5, 0.5, 0.5],\n", + " [354, -0.5, -0.5, 0.5, 0.5],\n", + " [355, -0.5, -0.5, 0.5, 0.5],\n", + " [356, -0.5, -0.5, 0.5, 0.5],\n", + " [357, -0.5, -0.5, 0.5, 0.5],\n", + " [358, -0.5, -0.5, 0.5, 0.5],\n", + " [359, -0.5, -0.5, 0.5, 0.5],\n", + " [360, -0.5, -0.5, 0.5, 0.5],\n", + " [361, -0.5, -0.5, 0.5, 0.5],\n", + " [362, -0.5, -0.5, 0.5, 0.5],\n", + " [363, -0.5, -0.5, 0.5, 0.5],\n", + " [364, -0.5, -0.5, 0.5, 0.5],\n", + " [365, -0.5, -0.5, 0.5, 0.5],\n", + " [366, -0.5, -0.5, 0.5, 0.5],\n", + " [367, -0.5, -0.5, 0.5, 0.5],\n", + " [368, -0.5, -0.5, 0.5, 0.5],\n", + " [369, -0.5, -0.5, 0.5, 0.5],\n", + " [370, -0.5, -0.5, 0.5, 0.5],\n", + " [371, -0.5, -0.5, 0.5, 0.5],\n", + " [372, -0.5, -0.5, 0.5, 0.5],\n", + " [373, -0.5, -0.5, 0.5, 0.5],\n", + " [374, -0.5, -0.5, 0.5, 0.5],\n", + " [375, -0.5, -0.5, 0.5, 0.5],\n", + " [376, -0.5, -0.5, 0.5, 0.5],\n", + " [377, -0.5, -0.5, 0.5, 0.5],\n", + " [378, -0.5, -0.5, 0.5, 0.5],\n", + " [379, -0.5, -0.5, 0.5, 0.5],\n", + " [380, -0.5, -0.5, 0.5, 0.5],\n", + " [381, -0.5, -0.5, 0.5, 0.5],\n", + " [382, -0.5, -0.5, 0.5, 0.5],\n", + " [383, -0.5, -0.5, 0.5, 0.5],\n", + " [384, -0.5, -0.5, 0.5, 0.5],\n", + " [385, -0.5, -0.5, 0.5, 0.5],\n", + " [386, -0.5, -0.5, 0.5, 0.5],\n", + " [387, -0.5, -0.5, 0.5, 0.5],\n", + " [388, -0.5, -0.5, 0.5, 0.5],\n", + " [389, -0.5, -0.5, 0.5, 0.5],\n", + " [390, -0.5, -0.5, 0.5, 0.5],\n", + " [391, -0.5, -0.5, 0.5, 0.5],\n", + " [392, -0.5, -0.5, 0.5, 0.5],\n", + " [393, -0.5, -0.5, 0.5, 0.5],\n", + " [394, -0.5, -0.5, 0.5, 0.5],\n", + " [395, -0.5, -0.5, 0.5, 0.5],\n", + " [396, -0.5, -0.5, 0.5, 0.5],\n", + " [397, -0.5, -0.5, 0.5, 0.5],\n", + " [398, -0.5, -0.5, 0.5, 0.5],\n", + " [399, -0.5, -0.5, 0.5, 0.5],\n", + " [400, -0.5, -0.5, 0.5, 0.5],\n", + " [401, -0.5, -0.5, 0.5, 0.5],\n", + " [402, -0.5, -0.5, 0.5, 0.5],\n", + " [403, -0.5, -0.5, 0.5, 0.5],\n", + " [404, -0.5, -0.5, 0.5, 0.5],\n", + " [405, -0.5, -0.5, 0.5, 0.5],\n", + " [406, -0.5, -0.5, 0.5, 0.5],\n", + " [407, -0.5, -0.5, 0.5, 0.5],\n", + " [408, -0.5, -0.5, 0.5, 0.5],\n", + " [409, -0.5, -0.5, 0.5, 0.5],\n", + " [410, -0.5, -0.5, 0.5, 0.5],\n", + " [411, -0.5, -0.5, 0.5, 0.5],\n", + " [412, -0.5, -0.5, 0.5, 0.5],\n", + " [413, -0.5, -0.5, 0.5, 0.5],\n", + " [414, -0.5, -0.5, 0.5, 0.5],\n", + " [415, -0.5, -0.5, 0.5, 0.5],\n", + " [416, -0.5, -0.5, 0.5, 0.5],\n", + " [417, -0.5, -0.5, 0.5, 0.5],\n", + " [418, -0.5, -0.5, 0.5, 0.5],\n", + " [419, -0.5, -0.5, 0.5, 0.5],\n", + " [420, -0.5, -0.5, 0.5, 0.5],\n", + " [421, -0.5, -0.5, 0.5, 0.5],\n", + " [422, -0.5, -0.5, 0.5, 0.5],\n", + " [423, -0.5, -0.5, 0.5, 0.5],\n", + " [424, -0.5, -0.5, 0.5, 0.5],\n", + " [425, -0.5, -0.5, 0.5, 0.5],\n", + " [426, -0.5, -0.5, 0.5, 0.5],\n", + " [427, -0.5, -0.5, 0.5, 0.5],\n", + " [428, -0.5, -0.5, 0.5, 0.5],\n", + " [429, -0.5, -0.5, 0.5, 0.5],\n", + " [430, -0.5, -0.5, 0.5, 0.5],\n", + " [431, -0.5, -0.5, 0.5, 0.5],\n", + " [432, -0.5, -0.5, 0.5, 0.5],\n", + " [433, -0.5, -0.5, 0.5, 0.5],\n", + " [434, -0.5, -0.5, 0.5, 0.5],\n", + " [435, -0.5, -0.5, 0.5, 0.5],\n", + " [436, -0.5, -0.5, 0.5, 0.5],\n", + " [437, -0.5, -0.5, 0.5, 0.5],\n", + " [438, -0.5, -0.5, 0.5, 0.5],\n", + " [439, -0.5, -0.5, 0.5, 0.5],\n", + " [440, -0.5, -0.5, 0.5, 0.5],\n", + " [441, -0.5, -0.5, 0.5, 0.5],\n", + " [442, -0.5, -0.5, 0.5, 0.5],\n", + " [443, -0.5, -0.5, 0.5, 0.5],\n", + " [444, -0.5, -0.5, 0.5, 0.5],\n", + " [445, -0.5, -0.5, 0.5, 0.5],\n", + " [446, -0.5, -0.5, 0.5, 0.5],\n", + " [447, -0.5, -0.5, 0.5, 0.5],\n", + " [448, -0.5, -0.5, 0.5, 0.5],\n", + " [449, -0.5, -0.5, 0.5, 0.5],\n", + " [450, -0.5, -0.5, 0.5, 0.5],\n", + " [451, -0.5, -0.5, 0.5, 0.5],\n", + " [452, -0.5, -0.5, 0.5, 0.5],\n", + " [453, -0.5, -0.5, 0.5, 0.5],\n", + " [454, -0.5, -0.5, 0.5, 0.5],\n", + " [455, -0.5, -0.5, 0.5, 0.5],\n", + " [456, -0.5, -0.5, 0.5, 0.5],\n", + " [457, -0.5, -0.5, 0.5, 0.5],\n", + " [458, -0.5, -0.5, 0.5, 0.5],\n", + " [459, -0.5, -0.5, 0.5, 0.5],\n", + " [460, -0.5, -0.5, 0.5, 0.5],\n", + " [461, -0.5, -0.5, 0.5, 0.5],\n", + " [462, -0.5, -0.5, 0.5, 0.5],\n", + " [463, -0.5, -0.5, 0.5, 0.5],\n", + " [464, -0.5, -0.5, 0.5, 0.5],\n", + " [465, -0.5, -0.5, 0.5, 0.5],\n", + " [466, -0.5, -0.5, 0.5, 0.5],\n", + " [467, -0.5, -0.5, 0.5, 0.5],\n", + " [468, -0.5, -0.5, 0.5, 0.5],\n", + " [469, -0.5, -0.5, 0.5, 0.5],\n", + " [470, -0.5, -0.5, 0.5, 0.5],\n", + " [471, -0.5, -0.5, 0.5, 0.5],\n", + " [472, -0.5, -0.5, 0.5, 0.5],\n", + " [473, -0.5, -0.5, 0.5, 0.5],\n", + " [474, -0.5, -0.5, 0.5, 0.5],\n", + " [475, -0.5, -0.5, 0.5, 0.5],\n", + " [476, -0.5, -0.5, 0.5, 0.5],\n", + " [477, -0.5, -0.5, 0.5, 0.5],\n", + " [478, -0.5, -0.5, 0.5, 0.5],\n", + " [479, -0.5, -0.5, 0.5, 0.5],\n", + " [480, -0.5, -0.5, 0.5, 0.5],\n", + " [481, -0.5, -0.5, 0.5, 0.5],\n", + " [482, -0.5, -0.5, 0.5, 0.5],\n", + " [483, -0.5, -0.5, 0.5, 0.5],\n", + " [484, -0.5, -0.5, 0.5, 0.5],\n", + " [485, -0.5, -0.5, 0.5, 0.5],\n", + " [486, -0.5, -0.5, 0.5, 0.5],\n", + " [487, -0.5, -0.5, 0.5, 0.5],\n", + " [488, -0.5, -0.5, 0.5, 0.5],\n", + " [489, -0.5, -0.5, 0.5, 0.5],\n", + " [490, -0.5, -0.5, 0.5, 0.5],\n", + " [491, -0.5, -0.5, 0.5, 0.5],\n", + " [492, -0.5, -0.5, 0.5, 0.5],\n", + " [493, -0.5, -0.5, 0.5, 0.5],\n", + " [494, -0.5, -0.5, 0.5, 0.5],\n", + " [495, -0.5, -0.5, 0.5, 0.5],\n", + " [496, -0.5, -0.5, 0.5, 0.5],\n", + " [497, -0.5, -0.5, 0.5, 0.5],\n", + " [498, -0.5, -0.5, 0.5, 0.5],\n", + " [499, -0.5, -0.5, 0.5, 0.5],\n", + " [500, -0.5, -0.5, 0.5, 0.5],\n", + " [501, -0.5, -0.5, 0.5, 0.5],\n", + " [502, -0.5, -0.5, 0.5, 0.5],\n", + " [503, -0.5, -0.5, 0.5, 0.5],\n", + " [504, -0.5, -0.5, 0.5, 0.5],\n", + " [505, -0.5, -0.5, 0.5, 0.5],\n", + " [506, -0.5, -0.5, 0.5, 0.5],\n", + " [507, -0.5, -0.5, 0.5, 0.5],\n", + " [508, -0.5, -0.5, 0.5, 0.5],\n", + " [509, -0.5, -0.5, 0.5, 0.5],\n", + " [510, -0.5, -0.5, 0.5, 0.5],\n", + " [511, -0.5, -0.5, 0.5, 0.5]],\n", + " [[0, 0, 0, 0],\n", + " [263, 80, 304, 93],\n", + " [263, 108, 323, 122],\n", + " [263, 108, 323, 122],\n", + " [263, 108, 323, 122],\n", + " [263, 108, 323, 122],\n", + " [263, 108, 323, 122],\n", + " [41, 134, 79, 147],\n", + " [372, 278, 397, 286],\n", + " [39, 275, 63, 283],\n", + " [39, 275, 63, 283],\n", + " [74, 303, 140, 317],\n", + " [327, 306, 411, 319],\n", + " [606, 306, 648, 321],\n", + " [64, 169, 99, 182],\n", + " [64, 169, 99, 182],\n", + " [64, 169, 99, 182],\n", + " [64, 169, 99, 182],\n", + " [225, 820, 247, 831],\n", + " [226, 849, 250, 857],\n", + " [226, 877, 248, 884],\n", + " [304, 877, 317, 887],\n", + " [304, 849, 326, 860],\n", + " [47, 877, 75, 885],\n", + " [469, 834, 515, 849],\n", + " [469, 834, 515, 849],\n", + " [469, 834, 515, 849],\n", + " [469, 834, 515, 849],\n", + " [222, 795, 237, 816],\n", + " [443, 878, 467, 888],\n", + " [443, 852, 464, 860],\n", + " [34, 818, 44, 893],\n", + " [101, 39, 135, 53],\n", + " [102, 53, 186, 67],\n", + " [99, 67, 177, 80],\n", + " [99, 81, 177, 96],\n", + " [492, 56, 584, 77],\n", + " [589, 57, 702, 78],\n", + " [589, 57, 702, 78],\n", + " [589, 57, 702, 78],\n", + " [589, 57, 702, 78],\n", + " [644, 36, 655, 46],\n", + " [658, 38, 671, 46],\n", + " [325, 85, 396, 102],\n", + " [325, 85, 396, 102],\n", + " [398, 88, 420, 101],\n", + " [483, 81, 543, 91],\n", + " [543, 82, 558, 90],\n", + " [543, 82, 558, 90],\n", + " [482, 110, 513, 120],\n", + " [515, 110, 529, 120],\n", + " [515, 110, 529, 120],\n", + " [265, 123, 283, 136],\n", + " [265, 123, 283, 136],\n", + " [286, 124, 303, 134],\n", + " [286, 124, 303, 134],\n", + " [307, 122, 384, 135],\n", + " [66, 122, 118, 136],\n", + " [122, 123, 133, 136],\n", + " [122, 123, 133, 136],\n", + " [137, 123, 166, 137],\n", + " [41, 106, 62, 117],\n", + " [63, 108, 74, 116],\n", + " [75, 108, 125, 118],\n", + " [75, 108, 125, 118],\n", + " [75, 108, 125, 118],\n", + " [75, 108, 125, 118],\n", + " [64, 151, 139, 165],\n", + " [64, 151, 139, 165],\n", + " [145, 151, 253, 166],\n", + " [256, 154, 280, 165],\n", + " [101, 168, 121, 182],\n", + " [101, 168, 121, 182],\n", + " [124, 168, 165, 182],\n", + " [170, 169, 199, 180],\n", + " [66, 182, 101, 197],\n", + " [106, 183, 114, 194],\n", + " [119, 184, 144, 197],\n", + " [147, 184, 189, 197],\n", + " [190, 183, 237, 197],\n", + " [64, 198, 100, 213],\n", + " [105, 198, 175, 212],\n", + " [105, 198, 175, 212],\n", + " [177, 200, 195, 211],\n", + " [200, 200, 241, 211],\n", + " [200, 200, 241, 211],\n", + " [200, 200, 241, 211],\n", + " [200, 200, 241, 211],\n", + " [242, 198, 270, 212],\n", + " [242, 198, 270, 212],\n", + " [388, 151, 409, 168],\n", + " [413, 154, 472, 167],\n", + " [476, 152, 546, 167],\n", + " [373, 137, 391, 148],\n", + " [392, 138, 403, 146],\n", + " [39, 246, 78, 257],\n", + " [80, 247, 90, 257],\n", + " [92, 247, 119, 257],\n", + " [122, 247, 137, 258],\n", + " [138, 247, 163, 258],\n", + " [163, 247, 187, 255],\n", + " [64, 258, 84, 272],\n", + " [88, 260, 152, 274],\n", + " [155, 260, 230, 275],\n", + " [155, 260, 230, 275],\n", + " [385, 279, 410, 293],\n", + " [413, 282, 428, 293],\n", + " [432, 282, 466, 295],\n", + " [179, 318, 243, 338],\n", + " [246, 318, 282, 338],\n", + " [246, 318, 282, 338],\n", + " [246, 318, 282, 338],\n", + " [285, 321, 334, 338],\n", + " [285, 321, 334, 338],\n", + " [285, 321, 334, 338],\n", + " [337, 321, 373, 336],\n", + " [376, 323, 403, 337],\n", + " [406, 323, 442, 336],\n", + " [179, 352, 206, 366],\n", + " [209, 353, 266, 367],\n", + " [274, 352, 309, 367],\n", + " [311, 355, 322, 365],\n", + " [327, 355, 341, 365],\n", + " [344, 355, 379, 368],\n", + " [381, 353, 396, 366],\n", + " [399, 353, 434, 366],\n", + " [439, 353, 489, 366],\n", + " [494, 353, 504, 366],\n", + " [494, 353, 504, 366],\n", + " [506, 352, 538, 367],\n", + " [179, 367, 214, 381],\n", + " [216, 369, 258, 382],\n", + " [216, 369, 258, 382],\n", + " [179, 398, 221, 412],\n", + " [179, 398, 221, 412],\n", + " [179, 398, 221, 412],\n", + " [223, 399, 247, 412],\n", + " [223, 399, 247, 412],\n", + " [250, 398, 263, 411],\n", + " [267, 399, 282, 412],\n", + " [285, 399, 300, 412],\n", + " [306, 399, 352, 412],\n", + " [355, 399, 366, 410],\n", + " [355, 399, 366, 410],\n", + " [365, 399, 376, 410],\n", + " [365, 399, 376, 410],\n", + " [376, 399, 389, 412],\n", + " [391, 401, 399, 409],\n", + " [402, 399, 420, 412],\n", + " [402, 399, 420, 412],\n", + " [420, 399, 430, 410],\n", + " [420, 399, 430, 410],\n", + " [430, 399, 443, 412],\n", + " [430, 399, 443, 412],\n", + " [447, 401, 469, 412],\n", + " [177, 413, 219, 427],\n", + " [177, 413, 219, 427],\n", + " [177, 413, 219, 427],\n", + " [222, 413, 246, 427],\n", + " [222, 413, 246, 427],\n", + " [250, 415, 264, 426],\n", + " [267, 415, 281, 426],\n", + " [285, 416, 299, 427],\n", + " [285, 416, 299, 427],\n", + " [304, 415, 351, 429],\n", + " [355, 415, 366, 426],\n", + " [355, 415, 366, 426],\n", + " [366, 415, 377, 426],\n", + " [366, 415, 377, 426],\n", + " [376, 415, 389, 428],\n", + " [391, 418, 399, 426],\n", + " [402, 413, 420, 428],\n", + " [402, 413, 420, 428],\n", + " [419, 415, 430, 426],\n", + " [419, 415, 430, 426],\n", + " [430, 415, 444, 428],\n", + " [430, 415, 444, 428],\n", + " [448, 416, 469, 427],\n", + " [179, 444, 213, 458],\n", + " [179, 444, 213, 458],\n", + " [215, 444, 242, 458],\n", + " [215, 444, 242, 458],\n", + " [247, 446, 310, 460],\n", + " [247, 446, 310, 460],\n", + " [247, 446, 310, 460],\n", + " [313, 444, 351, 459],\n", + " [353, 444, 392, 459],\n", + " [353, 444, 392, 459],\n", + " [397, 444, 446, 457],\n", + " [397, 444, 446, 457],\n", + " [446, 444, 506, 459],\n", + " [446, 444, 506, 459],\n", + " [179, 473, 228, 488],\n", + " [230, 473, 279, 488],\n", + " [285, 472, 335, 489],\n", + " [179, 504, 206, 518],\n", + " [208, 504, 283, 517],\n", + " [286, 504, 322, 517],\n", + " [327, 504, 363, 517],\n", + " [366, 504, 448, 518],\n", + " [366, 504, 448, 518],\n", + " [419, 542, 489, 580],\n", + " [503, 543, 523, 572],\n", + " [581, 634, 594, 656],\n", + " [589, 623, 618, 672],\n", + " [589, 623, 618, 672],\n", + " [620, 613, 654, 658],\n", + " [620, 613, 654, 658],\n", + " [575, 398, 597, 412],\n", + " [575, 398, 597, 412],\n", + " [575, 398, 597, 412],\n", + " [598, 398, 625, 412],\n", + " [598, 398, 625, 412],\n", + " [624, 398, 642, 411],\n", + " [574, 415, 596, 429],\n", + " [574, 415, 596, 429],\n", + " [574, 415, 596, 429],\n", + " [598, 415, 625, 428],\n", + " [598, 415, 625, 428],\n", + " [624, 415, 642, 428],\n", + " [592, 444, 621, 458],\n", + " [592, 444, 621, 458],\n", + " [592, 444, 621, 458],\n", + " [623, 446, 643, 459],\n", + " [623, 446, 643, 459],\n", + " [599, 473, 623, 486],\n", + " [599, 473, 623, 486],\n", + " [624, 473, 642, 488],\n", + " [624, 473, 642, 488],\n", + " [35, 764, 87, 775],\n", + " [88, 765, 127, 772],\n", + " [256, 764, 309, 774],\n", + " [309, 765, 343, 775],\n", + " [344, 765, 358, 775],\n", + " [344, 765, 358, 775],\n", + " [378, 763, 405, 776],\n", + " [408, 765, 435, 776],\n", + " [437, 765, 448, 775],\n", + " [437, 765, 448, 775],\n", + " [385, 778, 399, 791],\n", + " [385, 778, 399, 791],\n", + " [402, 777, 443, 791],\n", + " [402, 777, 443, 791],\n", + " [261, 777, 290, 792],\n", + " [261, 777, 290, 792],\n", + " [261, 777, 290, 792],\n", + " [293, 777, 346, 792],\n", + " [60, 778, 102, 789],\n", + " [105, 778, 175, 789],\n", + " [35, 792, 60, 802],\n", + " [60, 792, 75, 802],\n", + " [77, 792, 109, 802],\n", + " [236, 804, 251, 815],\n", + " [256, 806, 264, 814],\n", + " [267, 806, 275, 816],\n", + " [278, 804, 314, 817],\n", + " [317, 806, 327, 816],\n", + " [325, 806, 364, 817],\n", + " [432, 804, 440, 814],\n", + " [441, 806, 451, 816],\n", + " [453, 807, 464, 815],\n", + " [464, 807, 500, 815],\n", + " [47, 820, 74, 828],\n", + " [75, 820, 118, 830],\n", + " [47, 846, 74, 859],\n", + " [47, 846, 74, 859],\n", + " [77, 846, 119, 859],\n", + " [77, 846, 119, 859],\n", + " [77, 846, 119, 859],\n", + " [77, 846, 119, 859],\n", + " [77, 846, 119, 859],\n", + " [123, 848, 141, 859],\n", + " [123, 848, 141, 859],\n", + " [123, 848, 141, 859],\n", + " [142, 849, 198, 860],\n", + " [142, 849, 198, 860],\n", + " [142, 849, 198, 860],\n", + " [142, 849, 198, 860],\n", + " [306, 821, 330, 829],\n", + " [332, 821, 381, 831],\n", + " [332, 821, 381, 831],\n", + " [332, 821, 381, 831],\n", + " [332, 821, 381, 831],\n", + " [332, 821, 381, 831],\n", + " [383, 823, 398, 831],\n", + " [383, 823, 398, 831],\n", + " [443, 821, 465, 832],\n", + " [443, 821, 465, 832],\n", + " [469, 823, 514, 833],\n", + " [469, 823, 514, 833],\n", + " [469, 823, 514, 833],\n", + " [469, 823, 514, 833],\n", + " [469, 823, 514, 833],\n", + " [515, 821, 530, 832],\n", + " [515, 821, 530, 832],\n", + " [534, 824, 575, 832],\n", + " [577, 824, 602, 832],\n", + " [603, 824, 617, 832],\n", + " [603, 824, 617, 832],\n", + " [469, 855, 519, 870],\n", + " [524, 856, 534, 871],\n", + " [524, 856, 534, 871],\n", + " [539, 855, 568, 870],\n", + " [468, 878, 486, 892],\n", + " [468, 878, 486, 892],\n", + " [486, 878, 522, 892],\n", + " [486, 878, 522, 892],\n", + " [521, 880, 550, 891],\n", + " [521, 880, 550, 891],\n", + " [1000, 1000, 1000, 1000],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0],\n", + " [0, 0, 0, 0]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "encoding = train_dataset[2]\n", + "encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f5e36dd2", + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'[CLS] location requisitioner supplier terms fo quantity description price attn : date date date by date other m14789 [UNK] buyer date approval the american tobacco company purchase requisition at 135 stamford, ct authorization no. budget no. mr. g. schumacher january 3, 1995 date of requisition webcraft technologies inc mr. steven katz route 4 and adams station north brunswick, nj 08901 - 0623 no shipping required ship to shipment to arrive not later than no shipping required. net 30 days carlton \" free \" carton \" direct mail piece this purchase order is to cover all costs incurred to - date listed below. 42, 000 lbs. of 80 lb sterling c / 2 / s - 36 - 1 / 2 \" roll 31, 000 lbs. of 80 lb. sterling c / 2 / s - 26 - 1 / 2 \" roll prep. ( line negatives, paper prints, camera / stripping ) federal express charges all materials have been cancelled. charges to 1 / 4 / 95 $ 20, 580. 00 $ 15, 190. 00 $ 431. 25 $ 48. 75 department charged accounting charge no. extra copies to : d. barcia adv. expense brand operations state tax status not to be charged by supplier [UNK] to be charged local approval admin ctr / mgmt ctr. ( as required ) local p / orelease no. admin ctr / mgmt ctr purchase order no. january 3, 1995 m. stock / smm [SEP] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD] [PAD]'" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tokenizer.decode(encoding[0])" + ] + }, + { + "cell_type": "markdown", + "id": "f9ff6e4b", + "metadata": {}, + "source": [ + "再定义mindspore模型，包含layoutlm和visual embedding" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "c3589d42", + "metadata": {}, + "outputs": [], + "source": [ + "from mindspore import nn, Tensor, ops\n", + "from mindspore.common.initializer import TruncatedNormal, Normal, Zero\n", + "from mindnlp.transformers import LayoutLMModel, LayoutLMConfig ,ResNetBackbone\n", + "from mindspore.ops import ROIAlign\n", + "from mindnlp.transformers.modeling_outputs import TokenClassifierOutput\n", + "class LayoutLMForTokenClassification(nn.Cell):\n", + " def __init__(self, output_size=(3,3), \n", + " spatial_scale=14/224, \n", + " sampling_ratio=2\n", + " ): \n", + " super().__init__()\n", + " \n", + " # Initialize LayoutLM base model + token classifier\n", + " self.num_labels = len(label2idx)\n", + " #self.layoutlm_config = LayoutLMConfig.from_pretrained(\"microsoft/layoutlm-base-uncased\", num_labels=self.num_labels)\n", + " self.layoutlm = LayoutLMModel.from_pretrained(\"microsoft/layoutlm-base-uncased\",num_labels=self.num_labels)\n", + " self.dropout = nn.Dropout(p=self.layoutlm.config.hidden_dropout_prob)\n", + " self.classifier = nn.Dense(self.layoutlm.config.hidden_size, self.num_labels)\n", + " # Backbone + roi-align + projection layer\n", + " self.backbone = ResNetBackbone.from_pretrained(\"microsoft/resnet-101\", out_indices=[3])\n", + " self.roi_align = ops.ROIAlign(pooled_height =output_size[0],pooled_width=output_size[1],spatial_scale=spatial_scale,sample_num=sampling_ratio)\n", + " self.projection = nn.Dense(in_channels=1024*3*3, out_channels=self.layoutlm.config.hidden_size)\n", + "# for param in self.backbone.get_parameters():\n", + "# param.requires_grad = False\n", + "# for param in self.layoutlm.get_parameters():\n", + "# param.requires_grad = False\n", + " def convert_tensor_with_indices(self,tensor):\n", + " \"\"\"\n", + " 将形状为 (D, 512, 5) 的张量转换为 (512 * D, 5)，并将每个元素的第一个值改为原先第一维度的索引。\n", + "\n", + " 参数:\n", + " - tensor: 形状为 (D, 512, 5) 的 MindSpore 张量。\n", + "\n", + " 返回:\n", + " - 转换后的张量，形状为 (512 * D, 5)。\n", + " \"\"\"\n", + " # 获取第一维度的大小\n", + " D = tensor.shape[0]\n", + "\n", + " # 生成索引数组，形状为 (D, 512)\n", + " indices_d = np.arange(D).reshape(D, 1)\n", + " indices_d = np.tile(indices_d, (1, 512)) # 形状变为 (D, 512)\n", + " indices_d = Tensor(indices_d, ms.int32)\n", + "\n", + " indices_i = np.arange(512).reshape(1, 512)\n", + " indices_i = np.tile(indices_i, (D, 1)) # 形状变为 (D, 512)\n", + " indices_i = Tensor(indices_i, ms.int32)\n", + "\n", + " # 创建 indices 张量，形状为 (D*512, 3)\n", + " indices_d_flat = indices_d.reshape(-1)\n", + " indices_i_flat = indices_i.reshape(-1)\n", + " indices_r_flat = ops.zeros_like(indices_d_flat)\n", + " indices = ops.stack((indices_d_flat, indices_i_flat, indices_r_flat), axis=-1)\n", + "\n", + " # 创建 updates 张量，形状为 (D*512)\n", + " updates = indices_d_flat\n", + "\n", + " # 执行 scatter_nd_update 更新第一个值\n", + " tensor = ops.scatter_nd_update(tensor, indices, updates)\n", + "\n", + " # 展平张量，形状为 (512 * D, 5)\n", + " result = tensor.view(-1, 5)\n", + "\n", + " return result\n", + " def construct(\n", + " self,\n", + " input_ids,\n", + " bbox,\n", + " attention_mask,\n", + " token_type_ids,\n", + " position_ids=None,\n", + " head_mask=None,\n", + " inputs_embeds=None,\n", + " labels=None,\n", + " resized_images=None, # shape (N, C, H, W), with H = W = 224\n", + " resized_and_aligned_bounding_boxes=None, # list of tuples (x1, y1, x2, y2, batch_index), at image size 224\n", + " output_attentions=None,\n", + " output_hidden_states=None,\n", + " return_dict=None\n", + " ):\n", + " r\"\"\"\n", + " labels (:obj:`torch.Tensor` of shape :obj:`(batch_size, sequence_length)`, `optional`):\n", + " Labels for computing the token classification loss. Indices should be in ``[0, ..., config.num_labels -1]``.\n", + " \"\"\"\n", + " return_dict = return_dict if return_dict is not None else self.layoutlm.config.use_return_dict\n", + "\n", + " # Forward pass on LayoutLM\n", + " outputs = self.layoutlm(\n", + " input_ids=input_ids,\n", + " bbox=bbox,\n", + " attention_mask=attention_mask,\n", + " token_type_ids=token_type_ids,\n", + " position_ids=position_ids,\n", + " head_mask=head_mask,\n", + " output_attentions=output_attentions,\n", + " output_hidden_states=output_hidden_states,\n", + " return_dict=return_dict\n", + " )\n", + " sequence_output = outputs[0]\n", + " \n", + " # Obtain feature maps from the backbone\n", + " feature_maps = self.backbone(resized_images)[\"feature_maps\"][0]\n", + " # Use RoI Align to extract features from resized and aligned bounding boxes\n", + " # Assuming resized_and_aligned_bounding_boxes is a list of tensors with shape (num_bboxes, 5), where each entry is [batch_index, x1, y1, x2, y2]\n", + " batch_size = input_ids.shape[0]\n", + " seq_len = input_ids.shape[1]\n", + " #resized_bounding_boxes = resized_and_aligned_bounding_boxes.reshape((-1, 5)) # Flatten the list of bounding boxes\n", + " resized_and_aligned_bounding_boxes=self.convert_tensor_with_indices(resized_and_aligned_bounding_boxes)\n", + " feat_maps_bboxes = self.roi_align(feature_maps, resized_and_aligned_bounding_boxes) # Output shape: (num_bboxes, 1024, 3, 3)\n", + " # Reshape and project the extracted features to match LayoutLM's hidden size\n", + " feat_maps_bboxes = feat_maps_bboxes.view(batch_size, seq_len, -1) # Shape: (batch_size, seq_len, 1024*3*3)\n", + " projected_feat_maps_bboxes = self.projection(feat_maps_bboxes) # Shape: (batch_size, seq_len, hidden_size)\n", + " # Add the projected features to the sequence output from LayoutLM\n", + " sequence_output += projected_feat_maps_bboxes\n", + "\n", + " sequence_output = self.dropout(sequence_output)\n", + " logits = self.classifier(sequence_output)\n", + " loss = None\n", + " if labels is not None:\n", + " loss_fn = nn.CrossEntropyLoss()\n", + "\n", + " if attention_mask is not None:\n", + " active_loss = attention_mask.view(-1)==1\n", + " active_logits = logits.view(-1, self.num_labels)[active_loss]\n", + " active_labels = labels.view(-1)[active_loss]\n", + " loss = loss_fn(active_logits, active_labels)\n", + " else:\n", + " loss = loss_fn(logits.view(-1, self.num_labels), labels.view(-1))\n", + "\n", + " if not return_dict:\n", + " output = (logits,) + outputs[2:]\n", + " return (loss,) + output if loss is not None else output\n", + "\n", + " return TokenClassifierOutput(\n", + " loss=loss,\n", + " logits=logits,\n", + " hidden_states=outputs.hidden_states,\n", + " attentions=outputs.attentions\n", + " )\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "0169f251", + "metadata": {}, + "source": [ + "下来实例化model" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "6429240b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The following parameters in checkpoint files are not loaded:\n", + "['classifier.1.weight', 'classifier.1.bias']\n" + ] + } + ], + "source": [ + "model = LayoutLMForTokenClassification()" + ] + }, + { + "cell_type": "markdown", + "id": "74c9e7fd", + "metadata": {}, + "source": [ + "利用mindspore构建dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "248a8309", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import mindspore.dataset as ds\n", + "#print(train_dataset[0][0])\n", + "dataset = ds.GeneratorDataset(train_dataset, column_names=[\n", + " \"input_ids\",\n", + " \"attention_mask\",\n", + " \"token_type_ids\",\n", + " \"bbox\",\n", + " \"labels\",\n", + " \"resized_image\",\n", + " \"resized_and_aligned_bounding_boxes\",\n", + " \"unnormalized_token_boxes\",\n", + "], shuffle=False)\n", + "dataset = dataset.batch(batch_size=4, drop_remainder=True)" + ] + }, + { + "cell_type": "markdown", + "id": "6072835a", + "metadata": {}, + "source": [ + "下面进行训练" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "0c35e488", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/37 [00:00" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from PIL import Image, ImageDraw, ImageFont\n", + "\n", + "image = Image.open(\"data/testing_data/images/83443897.png\")\n", + "image = image.convert(\"RGB\")\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "075324ed", + "metadata": {}, + "outputs": [], + "source": [ + "import mindspore\n", + "inference_dataset = FUNSDDataset(image_file_names=[\"83443897.png\"], tokenizer=tokenizer, max_length=512, target_size=224, train=False)\n", + "test_encoding = inference_dataset[0]\n", + "input_ids=test_encoding[0]\n", + "attention_mask=test_encoding[1]\n", + "token_type_ids=test_encoding[2]\n", + "bbox=test_encoding[3]\n", + "labels=test_encoding[4]\n", + "resized_images = test_encoding[5]\n", + "resized_and_aligned_bounding_boxes = test_encoding[6]\n", + "input_ids = Tensor(input_ids, dtype=mstype.int64)\n", + "bbox = Tensor(bbox, dtype=mstype.int64)\n", + "attention_mask = Tensor(attention_mask, dtype=mstype.int64)\n", + "token_type_ids = Tensor(token_type_ids, dtype=mstype.int64)\n", + "labels = Tensor(labels, dtype=mstype.int32)\n", + "resized_images = Tensor(resized_images, dtype=mstype.float32)\n", + "resized_and_aligned_bounding_boxes = Tensor(resized_and_aligned_bounding_boxes, dtype=mstype.float32)\n", + "input_ids = mindspore.ops.ExpandDims()(input_ids, 0)\n", + "attention_mask = mindspore.ops.ExpandDims()(attention_mask, 0)\n", + "token_type_ids = mindspore.ops.ExpandDims()(token_type_ids, 0)\n", + "bbox = mindspore.ops.ExpandDims()(bbox, 0)\n", + "labels = mindspore.ops.ExpandDims()(labels, 0)\n", + "resized_images = mindspore.ops.ExpandDims()(resized_images, 0)\n", + "resized_and_aligned_bounding_boxes = mindspore.ops.ExpandDims()(resized_and_aligned_bounding_boxes, 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "b7fa2ea0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "TokenClassifierOutput(loss=Tensor(shape=[], dtype=Float32, value= 0.337794), logits=Tensor(shape=[1, 512, 8], dtype=Float32, value=\n", + "[[[-4.26953125e+00, 8.12011719e-01, -3.37109375e+00 ... 1.27636719e+00, 6.74804688e-01, 6.10937500e+00],\n", + " [-6.58203125e-01, -9.58984375e-01, -7.24487305e-02 ... 1.18457031e+00, -4.25781250e+00, -4.25781250e+00],\n", + " [-1.04785156e+00, -5.84472656e-01, -1.99121094e+00 ... 9.46875000e+00, -3.79687500e+00, -4.11718750e+00],\n", + " ...\n", + " [-1.79589844e+00, -3.11718750e+00, -1.66406250e+00 ... -1.32369995e-02, 9.54687500e+00, 2.45703125e+00],\n", + " [-1.82324219e+00, -3.06250000e+00, -2.03515625e+00 ... 1.58569336e-01, 1.02890625e+01, 2.34765625e+00],\n", + " [-1.35839844e+00, -3.12500000e+00, -1.50781250e+00 ... -1.03149414e-01, 9.67968750e+00, 2.09960938e+00]]]), hidden_states=None, attentions=None)\n" + ] + } + ], + "source": [ + "import mindspore\n", + "import mindspore as ms\n", + "#param_dict = mindspore.load_checkpoint(\"model.ckpt\")\n", + "#model = LayoutLMForTokenClassification()\n", + "#param_not_load, _ = mindspore.load_param_into_net(model, param_dict)\n", + "#print(_)\n", + "model.set_train(False)\n", + "outputs = model(input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids, \n", + " labels=labels, resized_images=resized_images, resized_and_aligned_bounding_boxes=resized_and_aligned_bounding_boxes)\n", + "print(outputs)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "daa3a365", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 4, 0, 0, 6, 6, 6, 6, 7, 6, 7, 6, 6, 6, 6, 6, 6, 7, 6, 0, 0, 0, 0, 2, 2, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 4, 4, 5, 5, 4, 4, 5, 4, 4, 5, 4, 4, 5, 4, 4, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 7, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 6, 6, 6, 7, 6, 6, 7, 6, 6, 6, 7, 6, 6, 6, 6, 7, 6, 6]\n", + "[[91, 223, 127, 238], [91, 223, 127, 238], [89, 313, 153, 330], [89, 313, 153, 330], [91, 366, 134, 384], [91, 366, 134, 384], [88, 402, 129, 417], [88, 402, 129, 417], [91, 432, 136, 446], [91, 432, 136, 446], [87, 483, 150, 497], [87, 483, 150, 497], [486, 461, 513, 475], [571, 462, 592, 475], [278, 459, 292, 472], [547, 461, 562, 475], [670, 782, 694, 891], [89, 67, 113, 78], [117, 67, 131, 77], [137, 67, 158, 77], [137, 67, 158, 77], [161, 64, 178, 77], [161, 64, 178, 77], [179, 64, 197, 77], [200, 63, 215, 77], [219, 64, 248, 77], [434, 61, 448, 72], [453, 60, 556, 74], [560, 60, 574, 73], [560, 60, 574, 73], [574, 60, 588, 70], [511, 126, 591, 146], [511, 144, 589, 166], [511, 163, 591, 184], [513, 182, 591, 200], [94, 110, 139, 131], [142, 108, 315, 130], [177, 222, 224, 240], [228, 221, 249, 239], [228, 221, 249, 239], [250, 222, 282, 239], [179, 249, 224, 264], [223, 249, 247, 266], [179, 285, 221, 302], [221, 284, 268, 304], [179, 313, 232, 330], [233, 311, 285, 328], [286, 313, 343, 331], [179, 341, 213, 355], [179, 341, 213, 355], [212, 339, 240, 357], [212, 339, 240, 357], [239, 341, 270, 355], [177, 367, 211, 385], [177, 367, 211, 385], [209, 369, 238, 382], [209, 369, 238, 382], [239, 367, 270, 384], [175, 404, 211, 421], [212, 405, 261, 419], [263, 405, 285, 420], [288, 402, 313, 420], [316, 405, 361, 420], [175, 433, 211, 447], [175, 433, 211, 447], [211, 433, 239, 447], [211, 433, 239, 447], [237, 432, 269, 447], [270, 432, 294, 447], [295, 430, 327, 447], [295, 430, 327, 447], [325, 430, 353, 447], [352, 433, 380, 448], [89, 250, 132, 265], [134, 251, 162, 265], [134, 251, 162, 265], [134, 251, 162, 265], [89, 285, 149, 303], [151, 288, 171, 301], [151, 288, 171, 301], [89, 342, 114, 355], [117, 342, 171, 357], [117, 342, 171, 357], [88, 459, 129, 472], [133, 461, 187, 475], [133, 461, 187, 475], [189, 459, 224, 474], [225, 461, 264, 474], [225, 461, 264, 474], [225, 461, 264, 474], [307, 461, 342, 474], [344, 461, 375, 475], [376, 461, 394, 474], [395, 462, 451, 475], [451, 568, 472, 585], [479, 567, 486, 581], [489, 567, 497, 584], [501, 570, 526, 584], [156, 486, 180, 499], [182, 485, 234, 500], [233, 486, 244, 499], [246, 486, 264, 500], [264, 487, 289, 502], [292, 487, 331, 500], [154, 700, 168, 714], [168, 703, 195, 716], [196, 701, 235, 715], [235, 703, 249, 714], [250, 701, 270, 716], [271, 701, 335, 714], [339, 703, 347, 714], [349, 703, 360, 714], [362, 705, 393, 715], [362, 705, 393, 715], [394, 703, 428, 716], [429, 703, 461, 716], [462, 703, 482, 716], [483, 701, 507, 714], [508, 701, 575, 715], [577, 701, 591, 715], [155, 716, 190, 729], [193, 715, 214, 729], [214, 718, 228, 729], [229, 719, 249, 730], [250, 716, 300, 730], [302, 715, 366, 732], [366, 719, 379, 729], [381, 716, 405, 729], [381, 716, 405, 729], [406, 718, 430, 729], [406, 718, 430, 729], [430, 715, 462, 730], [430, 715, 462, 730], [465, 718, 485, 731], [486, 718, 513, 729], [514, 716, 532, 729], [534, 716, 576, 733], [156, 732, 223, 746], [225, 733, 238, 744], [239, 735, 253, 745], [254, 733, 268, 747], [271, 735, 306, 745], [306, 732, 328, 746], [331, 735, 342, 745], [342, 732, 362, 745], [363, 733, 402, 746], [402, 732, 440, 745], [402, 732, 440, 745], [156, 758, 176, 771], [179, 760, 232, 771], [235, 760, 243, 770], [244, 758, 283, 771], [286, 758, 315, 771], [286, 758, 315, 771], [318, 760, 335, 771], [338, 763, 351, 771], [355, 760, 365, 770], [366, 760, 379, 770], [381, 760, 423, 770], [427, 760, 442, 770], [446, 760, 471, 771], [473, 761, 483, 769], [485, 760, 514, 771], [515, 758, 522, 771], [525, 760, 532, 770], [535, 757, 581, 772], [535, 757, 581, 772], [584, 760, 599, 771], [156, 774, 173, 784], [177, 774, 211, 782], [214, 772, 266, 783], [268, 772, 286, 783], [289, 772, 296, 782], [300, 772, 346, 785], [300, 772, 346, 785], [348, 772, 400, 782], [401, 774, 418, 784], [420, 772, 452, 783], [454, 772, 476, 783], [479, 772, 524, 783], [527, 771, 554, 785], [556, 774, 601, 785], [154, 785, 175, 795], [154, 785, 175, 795], [179, 785, 197, 795], [201, 786, 214, 794], [215, 785, 246, 796], [249, 785, 284, 796], [285, 785, 303, 795], [304, 786, 321, 796], [323, 785, 383, 796], [323, 785, 383, 796], [385, 785, 437, 795], [437, 786, 448, 794], [450, 784, 499, 797], [500, 784, 511, 795], [513, 784, 531, 797], [532, 785, 586, 795], [587, 785, 601, 795], [156, 797, 195, 807], [197, 797, 222, 808], [223, 797, 243, 807], [246, 797, 260, 807], [263, 797, 301, 808], [303, 797, 342, 807], [345, 799, 353, 807], [356, 797, 367, 807], [369, 797, 414, 808], [416, 797, 443, 808], [444, 797, 451, 807], [453, 797, 482, 808], [483, 797, 530, 810], [483, 797, 530, 810], [144, 926, 168, 937], [169, 925, 177, 935], [177, 925, 206, 936], [208, 925, 228, 935], [235, 925, 295, 938], [235, 925, 295, 938], [295, 923, 312, 936], [314, 926, 349, 934], [314, 926, 349, 934], [348, 925, 370, 936], [378, 925, 395, 935], [395, 923, 417, 936], [395, 923, 417, 936], [416, 923, 436, 937], [434, 923, 459, 936], [468, 925, 488, 938], [490, 925, 511, 936], [490, 925, 511, 936], [511, 923, 531, 937], [531, 923, 555, 934]]\n" + ] + } + ], + "source": [ + "token_predictions = outputs.logits.argmax(-1).squeeze().tolist() # the predictions are at the token level\n", + "#print(token_predictions)\n", + "#print(test_encoding[7])\n", + "#test_encoding[7]=Tensor(test_encoding[7],dtype=mstype.float32)\n", + "#print(test_encoding[7])\n", + "token_actual_boxes = test_encoding[7]\n", + "\n", + "word_level_predictions = [] # let's turn them into word level predictions\n", + "final_boxes = []\n", + "for id, token_pred, box in zip(input_ids.squeeze().tolist(), token_predictions, token_actual_boxes):\n", + " if (tokenizer.decode([id]).startswith(\"##\")) or (id in [tokenizer.cls_token_id, \n", + " tokenizer.sep_token_id, \n", + " tokenizer.pad_token_id]):\n", + " continue\n", + " else:\n", + " word_level_predictions.append(token_pred)\n", + " final_boxes.append(box)\n", + "\n", + "print(word_level_predictions)\n", + "print(final_boxes)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "fa0f08a9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw = ImageDraw.Draw(image)\n", + "\n", + "font = ImageFont.load_default()\n", + "\n", + "def iob_to_label(label):\n", + " return label[2:]\n", + "\n", + "label2color = {'question':'blue', 'answer':'green', 'header':'orange', 'other':'violet'}\n", + "\n", + "for prediction, box in zip(word_level_predictions, final_boxes):\n", + " predicted_label = iob_to_label(idx2label[prediction]).lower()\n", + " draw.rectangle(box, outline=label2color[predicted_label])\n", + " draw.text((box[0] + 10, box[1] - 10), text=predicted_label, fill=label2color[predicted_label], font=font)\n", + "\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43147be6", + "metadata": {}, + "outputs": [], + "source": [ + "和真实结果相比" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "1c136653", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "image = Image.open(\"data/testing_data/images/83443897.png\")\n", + "image = image.convert('RGB')\n", + "\n", + "draw = ImageDraw.Draw(image)\n", + "\n", + "label2color = {'question':'blue', 'answer':'green', 'header':'orange', 'other':'violet'}\n", + "\n", + "with open('data/testing_data/annotations/83443897.json') as f:\n", + " data = json.load(f)\n", + "\n", + "for annotation in data['form']:\n", + " label = annotation['label']\n", + " general_box = annotation['box']\n", + " draw.rectangle(general_box, outline=label2color[label], width=2)\n", + " draw.text((general_box[0] + 10, general_box[1] - 10), label, fill=label2color[label], font=font)\n", + " words = annotation['words']\n", + " for word in words:\n", + " box = word['box']\n", + " draw.rectangle(box, outline=label2color[label], width=1)\n", + "\n", + "image" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecb04ec5", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "AIGalleryInfo": { + "item_id": "346d8403-ee68-49a2-b79e-83f578c568bd" + }, + "flavorInfo": { + "architecture": "X86_64", + "category": "ASCEND" + }, + "imageInfo": { + "id": "278e88d1-5b71-4766-8502-b3ba72e824d9", + "name": "pytorch1.8-cuda10.2-cudnn7-ubuntu18.04" + }, + "kernelspec": { + "display_name": "python-3.7.10", + "language": "python", + "name": "python-3.7.10" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 0b9533ff1435b7d3fc43926253a9cda826e8a9af Mon Sep 17 00:00:00 2001 From: MQN-80 <3218290253@qq.com> Date: Mon, 24 Feb 2025 19:43:00 +0800 Subject: [PATCH 2/2] =?UTF-8?q?fix:=20=E5=BC=80=E6=BA=90=E5=AE=9E=E4=B9=A0?= =?UTF-8?q?-LayoutLM=E6=A8=A1=E5=9E=8B=E5=BA=94=E7=94=A8=E5=BC=80=E5=8F=91?= =?UTF-8?q?-=E9=87=91=E9=80=B8-ipynb=E5=86=85=E5=AE=B9=E6=A0=BC=E5=BC=8F?= =?UTF-8?q?=E4=BF=AE=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- applications/LayoutLM/layoutlm.ipynb | 129 ++++++--------------------- 1 file changed, 29 insertions(+), 100 deletions(-) diff --git a/applications/LayoutLM/layoutlm.ipynb b/applications/LayoutLM/layoutlm.ipynb index 75fc3b373..810a6a97a 100644 --- a/applications/LayoutLM/layoutlm.ipynb +++ b/applications/LayoutLM/layoutlm.ipynb @@ -103,6 +103,10 @@ "execution_count": 1, "id": "7bf2dc4f", "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + }, "tags": [] }, "outputs": [ @@ -400,8 +404,7 @@ ], "source": [ "!wget https://guillaumejaume.github.io/FUNSD/dataset.zip\n", - "!unzip dataset.zip && mv dataset data && rm -rf dataset.zip __MACOSX\n", - "#!cd data && unzip testing_data.zip && unzip training_data.zip" + "!unzip dataset.zip && mv dataset data && rm -rf dataset.zip __MACOSX" ] }, { @@ -423,11 +426,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "160b7069", + "cell_type": "markdown", + "id": "dc991026-a1d1-4a9c-ba3f-1023a24339d2", "metadata": {}, - "outputs": [], "source": [ "首先来随机看数据集中的一个文档" ] @@ -465,13 +466,11 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "76d482a2", + "cell_type": "markdown", + "id": "5498b5be-75ac-4b3a-8662-99b791bf6afd", "metadata": { "tags": [] }, - "outputs": [], "source": [ "image的大小为" ] @@ -500,11 +499,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "b975442f", + "cell_type": "markdown", + "id": "4e3c251a-3f35-4bf9-b855-c1ab7e7fa5f0", "metadata": {}, - "outputs": [], "source": [ "再来看每张图片的标注(文本内容,文本框和标签)" ] @@ -557,11 +554,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "08676aa0", + "cell_type": "markdown", + "id": "88943ae1-a8be-4d44-a560-661e1accc72a", "metadata": {}, - "outputs": [], "source": [ "接下来让我们可视化bounding boxs" ] @@ -601,11 +596,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "5ca661f9", + "cell_type": "markdown", + "id": "0abdb3c4-607b-4075-99d0-704d68da16c0", "metadata": {}, - "outputs": [], "source": [ "接下来我们将image调整为(224,224)来适应模型输入," ] @@ -754,13 +747,6 @@ "import numpy as np\n", "import mindspore\n", "from mindspore import Tensor, ops\n", - "\n", - "# 输入特征图\n", - "# feature_map = Tensor(\n", - "# np.random.rand(1, 1024, 14, 14),\n", - "# dtype=mindspore.float32\n", - "# )\n", - "\n", "# 目标尺寸和输入特征图尺寸\n", "target_size = 224 # 假设目标尺寸为 224\n", "spatial_scale = feature_map.shape[2] / target_size # 14/224\n", @@ -776,14 +762,6 @@ " spatial_scale=spatial_scale,\n", " sample_num=sampling_ratio,\n", ")\n", - "\n", - "# 假设的边界框\n", - "# resized_bounding_boxes = [\n", - "# [2.0, 3.0, 5.0, 6.0], # 示例边界框\n", - "# [0.5, 1.0, 4.0, 5.0],\n", - "# [0.5, 1.0, 4.0, 5.0],\n", - "# ]\n", - "\n", "def align_bounding_boxes(bounding_boxes):\n", " aligned_bounding_boxes = []\n", " for bbox in bounding_boxes:\n", @@ -851,11 +829,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "24def09c", + "cell_type": "markdown", + "id": "c644b19c-7bbd-410f-95de-14652d08f421", "metadata": {}, - "outputs": [], "source": [ "## 定义pytorch数据集和dataloader\n", "之间我们示例了如何在单个文档上使用，现在我们定义基于mindspore的数据集和dataloaders \n", @@ -975,9 +951,6 @@ "from PIL import Image\n", "import json\n", "import numpy as np\n", - "# from mindspore import Tensor\n", - "# from mindspore import ops\n", - "# import mindspore.common.dtype as mstype\n", "from mindspore.dataset.vision import ToTensor\n", "import imageio.v3 as iio\n", "def normalize_box(box, width, height):\n", @@ -1064,11 +1037,6 @@ " 'bbox': token_boxes,\n", " 'labels': token_labels\n", " })\n", - "# assert len(encoding['input_ids']) == self.max_seq_length\n", - "# assert len(encoding['attention_mask']) == self.max_seq_length\n", - "# assert len(encoding['token_type_ids']) == self.max_seq_length\n", - "# assert len(encoding['bbox']) == self.max_seq_length\n", - "# assert len(encoding['labels']) == self.max_seq_length\n", " encoding['resized_image'] = np.array(resized_image)\n", " encoding['resized_and_aligned_bounding_boxes'] = [\n", " [i] + resize_and_align_bounding_box(bbox, original_image, self.target_size)\n", @@ -1083,19 +1051,6 @@ " else:\n", " label_indices.append(label)\n", " encoding['labels'] = label_indices\n", - " # Convert to MindSpore Tensors\n", - "# for key in ['input_ids', 'attention_mask', 'token_type_ids', 'bbox', 'labels']:\n", - "# encoding[key] = Tensor(encoding[key], dtype=mstype.int64)\n", - " #encoding['resized_image'] = Tensor(encoding['resized_image'], dtype=mstype.float32)\n", - "# encoding['resized_image'] = Tensor.from_numpy(ToTensor()(encoding['resized_image']))\n", - "# input_ids = Tensor(encoding['input_ids'], dtype=mstype.int64)\n", - "# attention_mask = Tensor(encoding['attention_mask'], dtype=mstype.int64)\n", - "# token_type_ids = Tensor(encoding['token_type_ids'], dtype=mstype.int64)\n", - "# bbox = Tensor(encoding['bbox'], dtype=mstype.int64)\n", - "# labels = Tensor(encoding['labels'], dtype=mstype.int32)\n", - "# resized_image = Tensor(encoding['resized_image'], dtype=mstype.float32)\n", - "# resized_and_aligned_bounding_boxes = Tensor(encoding['resized_and_aligned_bounding_boxes'], dtype=mstype.float32)\n", - "# unnormalized_token_boxes = Tensor(encoding['unnormalized_token_boxes'], dtype=mstype.int64)\n", " return (\n", " encoding['input_ids'],\n", " encoding['attention_mask'],\n", @@ -1105,12 +1060,7 @@ " ToTensor()(encoding['resized_image']),\n", " encoding['resized_and_aligned_bounding_boxes'],\n", " encoding['unnormalized_token_boxes']\n", - " )\n", - "\n", - "# Example usage\n", - "# Assuming datasets and loaders are properly defined\n", - "# train_dataset = FUNSDDataset(...)\n", - "# train_loader = DataLoader(train_dataset, batch_size=32)" + " )" ] }, { @@ -4866,10 +4816,6 @@ " self.backbone = ResNetBackbone.from_pretrained(\"microsoft/resnet-101\", out_indices=[3])\n", " self.roi_align = ops.ROIAlign(pooled_height =output_size[0],pooled_width=output_size[1],spatial_scale=spatial_scale,sample_num=sampling_ratio)\n", " self.projection = nn.Dense(in_channels=1024*3*3, out_channels=self.layoutlm.config.hidden_size)\n", - "# for param in self.backbone.get_parameters():\n", - "# param.requires_grad = False\n", - "# for param in self.layoutlm.get_parameters():\n", - "# param.requires_grad = False\n", " def convert_tensor_with_indices(self,tensor):\n", " \"\"\"\n", " 将形状为 (D, 512, 5) 的张量转换为 (512 * D, 5)，并将每个元素的第一个值改为原先第一维度的索引。\n", @@ -5307,11 +5253,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "25552b25", + "cell_type": "markdown", + "id": "3f526fb0-8452-4f9f-8867-9a6da5d0387a", "metadata": {}, - "outputs": [], "source": [ "下面进行测试和验证，首先生成测试集数据集" ] @@ -5338,11 +5282,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "973e6099", + "cell_type": "markdown", + "id": "7993d6d7-d030-4003-93f7-77b824c0e22a", "metadata": {}, - "outputs": [], "source": [ "在测试集上进行验证" ] @@ -5387,7 +5329,6 @@ " attention_mask = Tensor(batch['attention_mask'], dtype=mstype.int64)\n", " token_type_ids = Tensor(batch['token_type_ids'], dtype=mstype.int64)\n", " labels = Tensor(batch['labels'], dtype=mstype.int32)\n", - " #resized_images =Tensor.from_numpy(ToTensor()(batch['resized_image']))\n", " resized_images = Tensor(batch['resized_image'], dtype=mstype.float32)\n", " resized_and_aligned_bounding_boxes = Tensor(batch['resized_and_aligned_bounding_boxes'], dtype=mstype.float32)\n", " outputs = model(input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids, \n", @@ -5430,11 +5371,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "f2a15fc9", + "cell_type": "markdown", + "id": "b19bf93f-ee5b-4873-8d37-aad0df5908a5", "metadata": {}, - "outputs": [], "source": [ "下面展示模型在测试集图片上的效果" ] @@ -5522,10 +5461,6 @@ "source": [ "import mindspore\n", "import mindspore as ms\n", - "#param_dict = mindspore.load_checkpoint(\"model.ckpt\")\n", - "#model = LayoutLMForTokenClassification()\n", - "#param_not_load, _ = mindspore.load_param_into_net(model, param_dict)\n", - "#print(_)\n", "model.set_train(False)\n", "outputs = model(input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids, \n", " labels=labels, resized_images=resized_images, resized_and_aligned_bounding_boxes=resized_and_aligned_bounding_boxes)\n", @@ -5549,10 +5484,6 @@ ], "source": [ "token_predictions = outputs.logits.argmax(-1).squeeze().tolist() # the predictions are at the token level\n", - "#print(token_predictions)\n", - "#print(test_encoding[7])\n", - "#test_encoding[7]=Tensor(test_encoding[7],dtype=mstype.float32)\n", - "#print(test_encoding[7])\n", "token_actual_boxes = test_encoding[7]\n", "\n", "word_level_predictions = [] # let's turn them into word level predictions\n", @@ -5607,11 +5538,9 @@ ] }, { - "cell_type": "code", - "execution_count": null, - "id": "43147be6", + "cell_type": "markdown", + "id": "3419cf50-703c-4510-8561-fcbd15e76bbe", "metadata": {}, - "outputs": [], "source": [ "和真实结果相比" ] @@ -5680,9 +5609,9 @@ "name": "pytorch1.8-cuda10.2-cudnn7-ubuntu18.04" }, "kernelspec": { - "display_name": "python-3.7.10", + "display_name": "base", "language": "python", - "name": "python-3.7.10" + "name": "base" }, "language_info": { "codemirror_mode": { @@ -5694,7 +5623,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.9.7" } }, "nbformat": 4,