{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "colab": { "provenance": [] }, "kernelspec": { "name": "python3", "display_name": "Python 3" }, "language_info": { "name": "python" }, "accelerator": "GPU", "gpuClass": "standard" }, "cells": [ { "cell_type": "code", "execution_count": null, "metadata": { "id": "c842TL-58KkF" }, "outputs": [], "source": [ "#|default_exp app" ] }, { "cell_type": "code", "source": [ "!pip install gradio" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "klgDeG338SU1", "outputId": "14f54a9d-467c-449d-b3e9-cc0954393737" }, "execution_count": 1, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting gradio\n", " Downloading gradio-3.9.1-py3-none-any.whl (11.6 MB)\n", "\u001b[K |████████████████████████████████| 11.6 MB 6.6 MB/s \n", "\u001b[?25hCollecting markdown-it-py[linkify,plugins]\n", " Downloading markdown_it_py-2.1.0-py3-none-any.whl (84 kB)\n", "\u001b[K |████████████████████████████████| 84 kB 3.8 MB/s \n", "\u001b[?25hCollecting websockets>=10.0\n", " Downloading websockets-10.4-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (106 kB)\n", "\u001b[K |████████████████████████████████| 106 kB 66.6 MB/s \n", "\u001b[?25hCollecting h11<0.13,>=0.11\n", " Downloading h11-0.12.0-py3-none-any.whl (54 kB)\n", "\u001b[K |████████████████████████████████| 54 kB 3.5 MB/s \n", "\u001b[?25hRequirement already satisfied: fsspec in /usr/local/lib/python3.7/dist-packages (from gradio) (2022.10.0)\n", "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from gradio) (2.23.0)\n", "Collecting fastapi\n", " Downloading fastapi-0.86.0-py3-none-any.whl (55 kB)\n", "\u001b[K |████████████████████████████████| 55 kB 4.1 MB/s \n", "\u001b[?25hCollecting ffmpy\n", " Downloading ffmpy-0.3.0.tar.gz (4.8 kB)\n", "Collecting pydub\n", " Downloading pydub-0.25.1-py2.py3-none-any.whl (32 kB)\n", "Requirement already satisfied: pydantic in /usr/local/lib/python3.7/dist-packages (from gradio) (1.10.2)\n", "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from gradio) (3.2.2)\n", "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from gradio) (2.11.3)\n", "Collecting paramiko\n", " Downloading paramiko-2.12.0-py2.py3-none-any.whl (213 kB)\n", "\u001b[K |████████████████████████████████| 213 kB 67.7 MB/s \n", "\u001b[?25hRequirement already satisfied: aiohttp in /usr/local/lib/python3.7/dist-packages (from gradio) (3.8.3)\n", "Collecting httpx\n", " Downloading httpx-0.23.0-py3-none-any.whl (84 kB)\n", "\u001b[K |████████████████████████████████| 84 kB 4.3 MB/s \n", "\u001b[?25hCollecting pycryptodome\n", " Downloading pycryptodome-3.15.0-cp35-abi3-manylinux2010_x86_64.whl (2.3 MB)\n", "\u001b[K |████████████████████████████████| 2.3 MB 42.0 MB/s \n", "\u001b[?25hRequirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from gradio) (1.3.5)\n", "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from gradio) (6.0)\n", "Collecting orjson\n", " Downloading orjson-3.8.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (272 kB)\n", "\u001b[K |████████████████████████████████| 272 kB 46.9 MB/s \n", "\u001b[?25hRequirement already satisfied: pillow in /usr/local/lib/python3.7/dist-packages (from gradio) (7.1.2)\n", "Collecting python-multipart\n", " Downloading python-multipart-0.0.5.tar.gz (32 kB)\n", "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from gradio) (1.21.6)\n", "Collecting uvicorn\n", " Downloading uvicorn-0.19.0-py3-none-any.whl (56 kB)\n", "\u001b[K |████████████████████████████████| 56 kB 5.5 MB/s \n", "\u001b[?25hRequirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (1.3.3)\n", "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (1.3.1)\n", "Requirement already satisfied: asynctest==0.13.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (0.13.0)\n", "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (4.0.2)\n", "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (6.0.2)\n", "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (22.1.0)\n", "Requirement already satisfied: typing-extensions>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (4.1.1)\n", "Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (2.1.1)\n", "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->gradio) (1.8.1)\n", "Requirement already satisfied: idna>=2.0 in /usr/local/lib/python3.7/dist-packages (from yarl<2.0,>=1.0->aiohttp->gradio) (2.10)\n", "Collecting starlette==0.20.4\n", " Downloading starlette-0.20.4-py3-none-any.whl (63 kB)\n", "\u001b[K |████████████████████████████████| 63 kB 2.5 MB/s \n", "\u001b[?25hCollecting anyio<5,>=3.4.0\n", " Downloading anyio-3.6.2-py3-none-any.whl (80 kB)\n", "\u001b[K |████████████████████████████████| 80 kB 10.7 MB/s \n", "\u001b[?25hCollecting sniffio>=1.1\n", " Downloading sniffio-1.3.0-py3-none-any.whl (10 kB)\n", "Collecting rfc3986[idna2008]<2,>=1.3\n", " Downloading rfc3986-1.5.0-py2.py3-none-any.whl (31 kB)\n", "Requirement already satisfied: certifi in /usr/local/lib/python3.7/dist-packages (from httpx->gradio) (2022.9.24)\n", "Collecting httpcore<0.16.0,>=0.15.0\n", " Downloading httpcore-0.15.0-py3-none-any.whl (68 kB)\n", "\u001b[K |████████████████████████████████| 68 kB 7.7 MB/s \n", "\u001b[?25hRequirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->gradio) (2.0.1)\n", "Collecting mdurl~=0.1\n", " Downloading mdurl-0.1.2-py3-none-any.whl (10.0 kB)\n", "Collecting linkify-it-py~=1.0\n", " Downloading linkify_it_py-1.0.3-py3-none-any.whl (19 kB)\n", "Collecting mdit-py-plugins\n", " Downloading mdit_py_plugins-0.3.1-py3-none-any.whl (46 kB)\n", "\u001b[K |████████████████████████████████| 46 kB 4.6 MB/s \n", "\u001b[?25hCollecting uc-micro-py\n", " Downloading uc_micro_py-1.0.1-py3-none-any.whl (6.2 kB)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->gradio) (3.0.9)\n", "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->gradio) (2.8.2)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->gradio) (1.4.4)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->gradio) (0.11.0)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->gradio) (1.15.0)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->gradio) (2022.6)\n", "Collecting cryptography>=2.5\n", " Downloading cryptography-38.0.3-cp36-abi3-manylinux_2_24_x86_64.whl (4.1 MB)\n", "\u001b[K |████████████████████████████████| 4.1 MB 49.9 MB/s \n", "\u001b[?25hCollecting bcrypt>=3.1.3\n", " Downloading bcrypt-4.0.1-cp36-abi3-manylinux_2_24_x86_64.whl (593 kB)\n", "\u001b[K |████████████████████████████████| 593 kB 74.5 MB/s \n", "\u001b[?25hCollecting pynacl>=1.0.1\n", " Downloading PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl (856 kB)\n", "\u001b[K |████████████████████████████████| 856 kB 65.6 MB/s \n", "\u001b[?25hRequirement already satisfied: cffi>=1.12 in /usr/local/lib/python3.7/dist-packages (from cryptography>=2.5->paramiko->gradio) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.12->cryptography>=2.5->paramiko->gradio) (2.21)\n", "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->gradio) (3.0.4)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->gradio) (1.24.3)\n", "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.7/dist-packages (from uvicorn->gradio) (7.1.2)\n", "Building wheels for collected packages: ffmpy, python-multipart\n", " Building wheel for ffmpy (setup.py) ... \u001b[?25l\u001b[?25hdone\n", " Created wheel for ffmpy: filename=ffmpy-0.3.0-py3-none-any.whl size=4709 sha256=8411ef457aa969082fe7c207006f76d63d79f5f99a213a94af821393f5c3ff8e\n", " Stored in directory: /root/.cache/pip/wheels/13/e4/6c/e8059816e86796a597c6e6b0d4c880630f51a1fcfa0befd5e6\n", " Building wheel for python-multipart (setup.py) ... \u001b[?25l\u001b[?25hdone\n", " Created wheel for python-multipart: filename=python_multipart-0.0.5-py3-none-any.whl size=31677 sha256=b7b72b831abe22d55b5ad3ed1f364b4987c6f033b61beafec7a309eeee1d3795\n", " Stored in directory: /root/.cache/pip/wheels/2c/41/7c/bfd1c180534ffdcc0972f78c5758f89881602175d48a8bcd2c\n", "Successfully built ffmpy python-multipart\n", "Installing collected packages: sniffio, mdurl, uc-micro-py, rfc3986, markdown-it-py, h11, anyio, starlette, pynacl, mdit-py-plugins, linkify-it-py, httpcore, cryptography, bcrypt, websockets, uvicorn, python-multipart, pydub, pycryptodome, paramiko, orjson, httpx, ffmpy, fastapi, gradio\n", "Successfully installed anyio-3.6.2 bcrypt-4.0.1 cryptography-38.0.3 fastapi-0.86.0 ffmpy-0.3.0 gradio-3.9.1 h11-0.12.0 httpcore-0.15.0 httpx-0.23.0 linkify-it-py-1.0.3 markdown-it-py-2.1.0 mdit-py-plugins-0.3.1 mdurl-0.1.2 orjson-3.8.1 paramiko-2.12.0 pycryptodome-3.15.0 pydub-0.25.1 pynacl-1.5.0 python-multipart-0.0.5 rfc3986-1.5.0 sniffio-1.3.0 starlette-0.20.4 uc-micro-py-1.0.1 uvicorn-0.19.0 websockets-10.4\n" ] } ] }, { "cell_type": "code", "source": [ "!pip install timm" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "KaYTPnRh8gXO", "outputId": "0b241b35-b0b6-4674-b97a-dd5224bbd9ba" }, "execution_count": 2, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting timm\n", " Downloading timm-0.6.11-py3-none-any.whl (548 kB)\n", "\u001b[K |████████████████████████████████| 548 kB 8.5 MB/s \n", "\u001b[?25hRequirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from timm) (6.0)\n", "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from timm) (0.13.1+cu113)\n", "Collecting huggingface-hub\n", " Downloading huggingface_hub-0.10.1-py3-none-any.whl (163 kB)\n", "\u001b[K |████████████████████████████████| 163 kB 60.9 MB/s \n", "\u001b[?25hRequirement already satisfied: torch>=1.7 in /usr/local/lib/python3.7/dist-packages (from timm) (1.12.1+cu113)\n", "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch>=1.7->timm) (4.1.1)\n", "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.7/dist-packages (from huggingface-hub->timm) (21.3)\n", "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from huggingface-hub->timm) (2.23.0)\n", "Requirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from huggingface-hub->timm) (4.64.1)\n", "Requirement already satisfied: filelock in /usr/local/lib/python3.7/dist-packages (from huggingface-hub->timm) (3.8.0)\n", "Requirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from huggingface-hub->timm) (4.13.0)\n", "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging>=20.9->huggingface-hub->timm) (3.0.9)\n", "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->huggingface-hub->timm) (3.10.0)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->huggingface-hub->timm) (1.24.3)\n", "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->huggingface-hub->timm) (2.10)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->huggingface-hub->timm) (2022.9.24)\n", "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->huggingface-hub->timm) (3.0.4)\n", "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->timm) (7.1.2)\n", "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from torchvision->timm) (1.21.6)\n", "Installing collected packages: huggingface-hub, timm\n", "Successfully installed huggingface-hub-0.10.1 timm-0.6.11\n" ] } ] }, { "cell_type": "markdown", "source": [ "# Gradio Tomatoes" ], "metadata": { "id": "OO2dYlRx8l8h" } }, { "cell_type": "code", "source": [ "#|export\n", "from fastai.vision.all import *\n", "import gradio as gr\n", "import timm" ], "metadata": { "id": "APu-Sa9U8o-_" }, "execution_count": 3, "outputs": [] }, { "cell_type": "code", "source": [ "im = PILImage.create('green.jpeg')\n", "im.thumbnail((224,224))\n", "im" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 166 }, "id": "3pQWIVBK8tVf", "outputId": "fec054c5-3dae-469c-afab-713b52cc18e0" }, "execution_count": 5, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "PILImage mode=RGB size=224x149" ], "image/png": "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\n" }, "metadata": {}, "execution_count": 5 } ] }, { "cell_type": "code", "source": [ "#export\n", "learn = load_learner('model.pkl')" ], "metadata": { "id": "aC-Wu_iQ8xUn" }, "execution_count": 6, "outputs": [] }, { "cell_type": "code", "source": [ "learn.predict(im)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 88 }, "id": "qtEQtOn1_bNq", "outputId": "bbf9fc8c-2735-49fc-b82b-783629e8221c" }, "execution_count": 7, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [] }, "metadata": {} }, { "output_type": "execute_result", "data": { "text/plain": [ "('Green tomato',\n", " TensorBase(3),\n", " TensorBase([1.2220e-05, 6.7626e-08, 1.3348e-08, 9.9922e-01, 2.3766e-05,\n", " 7.4120e-04, 7.9537e-08]))" ] }, "metadata": {}, "execution_count": 7 } ] }, { "cell_type": "code", "source": [ "#export\n", "categories = learn.dls.vocab\n", "\n", "def classify_image(img):\n", " pred,idx,probs = learn.predict(img)\n", " return dict(zip(categories, map(float,probs)))" ], "metadata": { "id": "9d9t_MQ-_drA" }, "execution_count": 8, "outputs": [] }, { "cell_type": "code", "source": [ "classify_image(im)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 140 }, "id": "2-VnBc7y_mHA", "outputId": "4b2890e4-c97b-4a04-d228-807c3b31f1f0" }, "execution_count": 9, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n" ] }, "metadata": {} }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [] }, "metadata": {} }, { "output_type": "execute_result", "data": { "text/plain": [ "{'Beefsteak Tomato': 1.2220280950714368e-05,\n", " 'Cherry Tomato': 6.762640936130992e-08,\n", " 'Grape Tomato': 1.3348394389822715e-08,\n", " 'Green tomato': 0.9992226362228394,\n", " 'Heirloom Tomato': 2.3766093363519758e-05,\n", " 'Kumato Tomato': 0.0007411989499814808,\n", " 'Roma Tomato': 7.953730829513006e-08}" ] }, "metadata": {}, "execution_count": 9 } ] }, { "cell_type": "code", "source": [ "#export\n", "image = gr.inputs.Image(shape=(192, 192))\n", "label = gr.outputs.Label()\n", "examples = ['green.jpeg']" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "sWF0fwTY_n1R", "outputId": "911c0d8d-426a-4830-f2d9-aa1e791ff0b2" }, "execution_count": 10, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ "/usr/local/lib/python3.7/dist-packages/gradio/inputs.py:257: UserWarning: Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components\n", " \"Usage of gradio.inputs is deprecated, and will not be supported in the future, please import your component from gradio.components\",\n", "/usr/local/lib/python3.7/dist-packages/gradio/deprecation.py:40: UserWarning: `optional` parameter is deprecated, and it has no effect\n", " warnings.warn(value)\n", "/usr/local/lib/python3.7/dist-packages/gradio/outputs.py:197: UserWarning: Usage of gradio.outputs is deprecated, and will not be supported in the future, please import your components from gradio.components\n", " \"Usage of gradio.outputs is deprecated, and will not be supported in the future, please import your components from gradio.components\",\n", "/usr/local/lib/python3.7/dist-packages/gradio/deprecation.py:40: UserWarning: The 'type' parameter has been deprecated. Use the Number component instead.\n", " warnings.warn(value)\n" ] } ] }, { "cell_type": "code", "source": [ "#export\n", "intf = gr.Interface(fn=classify_image, inputs=image, outputs=label,\n", "examples=examples)\n", "intf.launch(inline=False)" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "d3rgBhxP_u-V", "outputId": "413264a2-4a39-47ae-dbc5-6843b496754e" }, "execution_count": 11, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Colab notebook detected. To show errors in colab notebook, set `debug=True` in `launch()`\n", "\n", "Using Embedded Colab Mode (NEW). If you have issues, please use share=True and file an issue at https://github.com/gradio-app/gradio/\n", "Note: opening the browser inspector may crash Embedded Colab Mode.\n", "\n", "To create a public link, set `share=True` in `launch()`.\n" ] }, { "output_type": "execute_result", "data": { "text/plain": [ "(, 'http://127.0.0.1:7860/', None)" ] }, "metadata": {}, "execution_count": 11 } ] }, { "cell_type": "code", "source": [ "m = learn.model\n", "m" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "oTK7qxSj_7IH", "outputId": "9e02cc7f-30fa-4294-926c-4853b4a4c948" }, "execution_count": 12, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "Sequential(\n", " (0): TimmBody(\n", " (model): ConvNeXt(\n", " (stem): Sequential(\n", " (0): Conv2d(3, 96, kernel_size=(4, 4), stride=(4, 4))\n", " (1): LayerNorm2d((96,), eps=1e-06, elementwise_affine=True)\n", " )\n", " (stages): Sequential(\n", " (0): ConvNeXtStage(\n", " (downsample): Identity()\n", " (blocks): Sequential(\n", " (0): ConvNeXtBlock(\n", " (conv_dw): Conv2d(96, 96, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=96)\n", " (norm): LayerNorm((96,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=96, out_features=384, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=384, out_features=96, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (1): ConvNeXtBlock(\n", " (conv_dw): Conv2d(96, 96, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=96)\n", " (norm): LayerNorm((96,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=96, out_features=384, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=384, out_features=96, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (2): ConvNeXtBlock(\n", " (conv_dw): Conv2d(96, 96, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=96)\n", " (norm): LayerNorm((96,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=96, out_features=384, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=384, out_features=96, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " )\n", " )\n", " (1): ConvNeXtStage(\n", " (downsample): Sequential(\n", " (0): LayerNorm2d((96,), eps=1e-06, elementwise_affine=True)\n", " (1): Conv2d(96, 192, kernel_size=(2, 2), stride=(2, 2))\n", " )\n", " (blocks): Sequential(\n", " (0): ConvNeXtBlock(\n", " (conv_dw): Conv2d(192, 192, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=192)\n", " (norm): LayerNorm((192,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=192, out_features=768, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=768, out_features=192, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (1): ConvNeXtBlock(\n", " (conv_dw): Conv2d(192, 192, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=192)\n", " (norm): LayerNorm((192,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=192, out_features=768, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=768, out_features=192, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (2): ConvNeXtBlock(\n", " (conv_dw): Conv2d(192, 192, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=192)\n", " (norm): LayerNorm((192,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=192, out_features=768, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=768, out_features=192, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " )\n", " )\n", " (2): ConvNeXtStage(\n", " (downsample): Sequential(\n", " (0): LayerNorm2d((192,), eps=1e-06, elementwise_affine=True)\n", " (1): Conv2d(192, 384, kernel_size=(2, 2), stride=(2, 2))\n", " )\n", " (blocks): Sequential(\n", " (0): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (1): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (2): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (3): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (4): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (5): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (6): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (7): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (8): ConvNeXtBlock(\n", " (conv_dw): Conv2d(384, 384, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=384)\n", " (norm): LayerNorm((384,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=384, out_features=1536, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=1536, out_features=384, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " )\n", " )\n", " (3): ConvNeXtStage(\n", " (downsample): Sequential(\n", " (0): LayerNorm2d((384,), eps=1e-06, elementwise_affine=True)\n", " (1): Conv2d(384, 768, kernel_size=(2, 2), stride=(2, 2))\n", " )\n", " (blocks): Sequential(\n", " (0): ConvNeXtBlock(\n", " (conv_dw): Conv2d(768, 768, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=768)\n", " (norm): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=768, out_features=3072, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=3072, out_features=768, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (1): ConvNeXtBlock(\n", " (conv_dw): Conv2d(768, 768, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=768)\n", " (norm): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=768, out_features=3072, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=3072, out_features=768, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " (2): ConvNeXtBlock(\n", " (conv_dw): Conv2d(768, 768, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3), groups=768)\n", " (norm): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n", " (mlp): Mlp(\n", " (fc1): Linear(in_features=768, out_features=3072, bias=True)\n", " (act): GELU()\n", " (drop1): Dropout(p=0.0, inplace=False)\n", " (fc2): Linear(in_features=3072, out_features=768, bias=True)\n", " (drop2): Dropout(p=0.0, inplace=False)\n", " )\n", " (drop_path): Identity()\n", " )\n", " )\n", " )\n", " )\n", " (norm_pre): Identity()\n", " (head): Sequential(\n", " (global_pool): SelectAdaptivePool2d (pool_type=avg, flatten=Identity())\n", " (norm): LayerNorm2d((768,), eps=1e-06, elementwise_affine=True)\n", " (flatten): Flatten(start_dim=1, end_dim=-1)\n", " (drop): Dropout(p=0.0, inplace=False)\n", " (fc): Identity()\n", " )\n", " )\n", " )\n", " (1): Sequential(\n", " (0): AdaptiveConcatPool2d(\n", " (ap): AdaptiveAvgPool2d(output_size=1)\n", " (mp): AdaptiveMaxPool2d(output_size=1)\n", " )\n", " (1): fastai.layers.Flatten(full=False)\n", " (2): BatchNorm1d(1536, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (3): Dropout(p=0.25, inplace=False)\n", " (4): Linear(in_features=1536, out_features=512, bias=False)\n", " (5): ReLU(inplace=True)\n", " (6): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n", " (7): Dropout(p=0.5, inplace=False)\n", " (8): Linear(in_features=512, out_features=7, bias=False)\n", " )\n", ")" ] }, "metadata": {}, "execution_count": 12 } ] }, { "cell_type": "code", "source": [ "l = m.get_submodule('0.model.stem.1')\n", "list(l.parameters())" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "t18lFiNm__oF", "outputId": "8563015f-4fec-40ed-cb09-64bd8299258a" }, "execution_count": 13, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[Parameter containing:\n", " tensor([ 1.2549e+00, 1.9189e+00, 1.2197e+00, 1.0392e+00, -1.2360e-03,\n", " 7.6525e-01, 8.8736e-01, 1.6317e+00, 7.0513e-01, 3.2891e+00,\n", " 7.8623e-01, -1.7117e-03, 1.0005e+00, -1.7579e-03, 3.2969e+00,\n", " -8.2655e-04, 1.9838e+00, 1.0203e+00, 4.4528e+00, 2.5533e-01,\n", " 2.7247e+00, 9.2667e-01, 1.2364e+00, 4.2570e-03, 1.7866e+00,\n", " 5.4375e-01, 4.6258e+00, 1.2022e-02, -4.4923e-04, 3.4497e+00,\n", " 1.3513e+00, 4.1257e+00, 2.6876e+00, 4.1209e+00, 3.4001e+00,\n", " 8.4880e-01, 7.3676e-01, 3.9790e+00, 1.2861e+00, 6.4137e-01,\n", " 2.6897e+00, 1.1174e+00, 1.1701e+00, 5.5319e-01, 2.3345e+00,\n", " 8.1116e-04, 9.6876e-01, 1.8113e-03, 1.1979e+00, 1.7878e+00,\n", " 4.0192e-01, 4.5036e-01, 9.7266e-01, 3.9888e+00, 6.5893e-01,\n", " 6.8843e-01, 9.8540e-01, 2.7062e+00, 1.2161e+00, 7.6194e-01,\n", " 3.3010e+00, 1.6201e+00, 9.5488e-01, 2.1210e+00, 6.2934e-01,\n", " 4.0337e+00, 8.9223e-01, -2.6448e-03, 4.0867e+00, 1.0647e+00,\n", " 1.3970e+00, 1.6697e+00, 1.0553e-03, 7.6658e-01, 8.8612e-01,\n", " 6.4349e-01, 1.3443e+00, 7.1637e-01, 5.4679e-01, 2.0897e+00,\n", " 1.1949e+00, 3.0840e-01, 2.9724e-01, 1.4711e+00, 4.0833e+00,\n", " -1.1049e-03, 1.1466e+00, 3.8840e+00, 3.5997e+00, 4.8286e-01,\n", " 2.1848e-01, -2.0000e-04, 6.4905e-01, 3.0059e+00, 3.0460e+00,\n", " 5.8979e-03], requires_grad=True), Parameter containing:\n", " tensor([-9.7633e-02, -4.0912e-02, 4.1640e+00, -1.1034e-02, 3.2840e-03,\n", " -2.6498e-02, -3.1320e-02, -7.9657e-02, -1.4003e-01, -6.2544e-02,\n", " 3.2259e-01, -3.3996e-01, -5.7918e-02, -3.4297e-03, -4.7246e-02,\n", " -2.5746e-02, -4.0943e-02, -3.8924e-02, 9.6013e-03, -2.2978e-02,\n", " 9.4862e-03, -1.6334e-01, -4.0165e+00, 5.3108e-01, -5.3442e-01,\n", " 2.8037e+00, 3.6343e-02, -1.0307e-02, -1.1253e-03, -1.1683e-01,\n", " -1.3896e-01, 1.9857e-02, -9.6242e-02, -1.3032e-01, -1.9355e-01,\n", " -6.8573e-02, -3.6561e-02, -1.2932e-01, 1.5136e-01, 1.7539e-03,\n", " -6.5127e-02, 5.6944e-02, -9.3076e-02, -1.1453e+00, -5.3409e-02,\n", " -4.8856e-03, -1.8429e-01, 2.3664e-02, 3.9821e-02, -5.9836e-02,\n", " -4.1907e-02, -5.7592e-02, -4.3375e-02, -1.3508e-02, -1.1226e-01,\n", " 6.0285e-03, -3.8022e-02, -1.5735e-01, -9.7590e-02, -1.8567e-01,\n", " -1.1122e-01, -1.8241e-01, -3.3295e-02, -2.7655e-02, 1.4193e+00,\n", " -3.2569e-02, -4.3059e-02, -2.6929e-01, -4.7691e-02, -5.3386e-04,\n", " 2.6693e-01, 1.8760e-01, 6.9769e-01, -3.0811e-01, 8.2112e-02,\n", " -1.0840e+00, 1.5236e-02, -4.4423e-02, -7.8590e-02, -6.7279e-02,\n", " -1.3226e-01, -1.6913e-02, -1.8176e-02, -3.9016e-02, -7.1200e-02,\n", " 1.1973e-02, -5.8501e-02, -3.6200e-02, -8.0654e-02, -7.3571e-02,\n", " -9.7019e-03, -3.7845e-01, -1.2090e-02, -2.6502e-02, -6.2913e-02,\n", " -5.0892e-05], requires_grad=True)]" ] }, "metadata": {}, "execution_count": 13 } ] }, { "cell_type": "code", "source": [ "l = m.get_submodule('0.model.stages.0.blocks.1.mlp.fc1')\n", "list(l.parameters())" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Q_uG5lXRAFXS", "outputId": "5c7543f4-d89f-48ca-efc7-22154d5f9c8b" }, "execution_count": 14, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[Parameter containing:\n", " tensor([[ 2.2683e-02, -1.6102e-03, 4.0492e-02, ..., 1.7374e-03,\n", " -4.5132e-02, 8.0551e-03],\n", " [-1.4397e-01, 1.6831e-02, 2.6043e-02, ..., 1.2591e-02,\n", " -1.0449e-01, 5.6380e-02],\n", " [-6.5471e-02, -3.2765e-02, 5.6922e-03, ..., -4.1625e-02,\n", " 6.5853e-02, -4.0183e-02],\n", " ...,\n", " [-8.7938e-03, 6.9867e-02, 9.1769e-05, ..., 4.1501e-03,\n", " 4.1429e-02, -1.9181e-02],\n", " [ 1.9763e-03, 3.2100e-02, 2.9755e-02, ..., -2.9809e-02,\n", " -3.0328e-02, 5.5551e-02],\n", " [ 1.2105e-01, -3.5434e-02, -4.4713e-03, ..., -6.2710e-03,\n", " 2.3799e-02, -1.1432e-02]], requires_grad=True),\n", " Parameter containing:\n", " tensor([-0.4047, -0.7418, -0.4235, -0.1650, -0.3027, -0.1898, -0.5533, -0.6270,\n", " -0.3008, -0.4254, -0.5995, -0.4107, -0.2173, -1.7935, -0.3171, -0.1164,\n", " -0.4483, -0.2847, -0.4342, -0.4946, -0.4064, -1.1402, -0.6755, -1.7237,\n", " -0.2954, -0.2654, -0.2188, -0.3913, -0.4149, -0.4771, 0.2366, -0.7543,\n", " -0.5851, -0.1820, -1.5271, -0.3625, -2.4689, -2.3461, -0.6108, -0.4115,\n", " -0.6964, -0.5764, -0.5876, -0.0319, -2.0354, -0.2859, -0.3954, -0.8403,\n", " -2.2398, -1.0876, -0.2296, -0.9002, -0.7584, -0.8834, -0.3754, -0.4548,\n", " -0.3835, -0.4047, -2.0231, -1.0263, -0.4106, -1.1564, -0.2224, -0.4252,\n", " -0.2495, -0.4222, -0.0976, -1.4016, -0.6888, -0.4370, -0.2931, -0.4641,\n", " -0.4959, -1.2534, -1.0721, -1.2966, -0.6276, -1.4161, -2.3081, -2.4539,\n", " -0.4260, -0.9987, -0.4637, -0.3147, -0.2417, -0.8744, -0.2829, -1.4208,\n", " -0.3258, -0.3202, -0.0603, -0.1895, -0.2496, -0.6129, -0.2975, -2.1465,\n", " -0.4128, -0.3677, -1.9814, -0.3814, -0.3785, -0.2293, -0.3699, -0.3256,\n", " -0.5585, -2.4192, -0.4590, -1.7747, -0.3995, -0.4092, -0.3517, -0.5332,\n", " -1.6533, -1.8191, 0.6263, -0.4059, 0.5872, -2.2074, -0.2438, -2.4539,\n", " -0.2283, -0.6866, 0.6989, 0.6476, -0.6445, -0.3453, -0.3277, -0.5700,\n", " -0.5174, -0.2775, -0.4090, -0.3017, -0.4874, -0.4953, -0.4073, -0.4356,\n", " -0.5103, -0.4128, -2.0918, -0.2826, -0.5830, -1.5835, 0.6138, -0.8506,\n", " -0.4669, -2.1358, -0.3417, -0.3766, -0.3345, -0.3961, -0.3886, -0.5668,\n", " -0.2225, -1.3059, -0.4600, -0.3927, -0.4666, -0.4214, -0.4754, -0.2866,\n", " -1.5805, -0.1787, -0.4368, -0.3173, 1.5732, -0.4046, -0.4838, -0.2576,\n", " -0.5612, -0.4265, -0.2578, -0.3175, -0.4620, -1.9553, -1.9144, -0.3960,\n", " 0.3988, -2.3521, -0.9688, -0.2831, -1.9002, -0.4181, 0.0159, -1.1111,\n", " -0.4922, -0.3177, -1.8911, -0.3100, -0.8136, -2.3345, -0.3844, -0.3848,\n", " -0.1973, -0.4445, -1.6234, -2.5485, -0.3177, -1.2714, -1.1479, 0.6149,\n", " -0.3749, -0.3951, -2.0747, -0.4657, -0.3781, -0.4957, -0.3281, -1.9219,\n", " -2.0018, -0.5308, -0.2554, -1.1160, -0.3516, -2.2185, -1.1396, 0.5365,\n", " -0.3218, -2.0388, -0.4655, 0.1849, -0.5830, -0.3129, 0.6182, -0.2124,\n", " -2.3538, -0.9698, -0.9785, -0.3667, -0.4503, -1.9565, -0.2662, -1.1753,\n", " -0.4199, -0.9023, -0.3605, -0.5171, -1.1882, -0.4191, -0.4771, -1.5558,\n", " -0.4011, -0.6517, -0.4818, -0.2423, 0.6908, -0.5081, -0.4302, -0.6068,\n", " -0.4000, -0.3329, -0.3595, -1.6109, -0.2372, -0.2468, -0.4544, 0.1807,\n", " -0.3227, -0.3917, -0.3515, -0.3757, -1.2177, -0.3999, -0.3578, -0.2882,\n", " -1.7484, -0.2363, -0.1600, -0.2641, -0.9769, -1.3066, -0.4147, -0.2663,\n", " -0.3933, -0.4627, -0.2173, 0.2141, -0.5733, -0.2767, -0.3660, -0.5173,\n", " -0.3485, -0.3364, -0.6444, 0.6866, -0.3737, -0.2902, -2.0863, -0.4883,\n", " -0.2597, -1.0497, -1.6617, -0.3398, -0.5111, -0.5660, -0.3028, -0.5049,\n", " -0.2876, -0.2841, -0.1982, -0.6910, -0.2872, -2.1121, -0.8928, -0.2301,\n", " -1.5012, -0.4735, -2.2292, -0.4022, -0.2925, -0.4200, 0.6645, -0.3048,\n", " -0.1687, -0.3750, -0.6433, -2.3348, -0.3101, -1.2731, -0.8192, -1.0593,\n", " -0.0933, -1.6386, 0.3427, -0.8485, -0.4910, -0.5002, -1.0632, -0.3532,\n", " -1.1562, -0.3843, -0.3172, -0.6433, -0.9081, -0.6566, -0.6489, 0.6337,\n", " -0.2662, -1.3203, -1.1623, -1.2032, -2.0577, -0.3002, -1.3596, -0.4613,\n", " -0.5024, -0.4950, -0.3156, -0.3273, -0.2669, -0.4279, -0.3295, -0.3011,\n", " -1.6635, 0.6433, -0.9455, 0.6098, -0.4234, 0.3918, -0.4944, -0.4285,\n", " -0.2587, -0.4952, -2.1992, -0.2600, -0.3935, -0.4565, -0.5817, -0.3488,\n", " -0.7370, -0.3590, -0.4895, -2.0106, 0.4557, -0.8058, -1.7749, -0.3512,\n", " -0.5358, -0.2101, -0.3955, -0.4780, -1.1456, -0.3975, -2.2115, -0.2838],\n", " requires_grad=True)]" ] }, "metadata": {}, "execution_count": 14 } ] } ] }