From ba02b5e57747069f39a6058caa287838ca26e2fc Mon Sep 17 00:00:00 2001 From: mmhamdy Date: Sun, 4 Feb 2024 08:06:34 +0200 Subject: [PATCH 1/4] remove TF dependency in reduce_on_plateau example --- examples/contrib/reduce_on_plateau.ipynb | 425 +++++++++++++++-------- 1 file changed, 286 insertions(+), 139 deletions(-) diff --git a/examples/contrib/reduce_on_plateau.ipynb b/examples/contrib/reduce_on_plateau.ipynb index 157601688..792fb265c 100644 --- a/examples/contrib/reduce_on_plateau.ipynb +++ b/examples/contrib/reduce_on_plateau.ipynb @@ -10,30 +10,153 @@ "\n", "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.sandbox.google.com/github/google-deepmind/optax/blob/main/examples/contrib/reduce_on_plateau.ipynb)\n", "\n", - "In this notebook, we explore the power of `reduce_on_plateau` scheduler, that reduces the learning rate when a metric has stopped improving. We will be solving a classification task by training a simple Multilayer Perceptron (MLP) on the fashion MNIST dataset." + "In this notebook, we explore the power of `reduce_on_plateau` scheduler, that reduces the learning rate when a metric has stopped improving. We will be solving a classification task by training a simple Multilayer Perceptron (MLP) on the fashion MNIST dataset.\n", + "\n", + "To run this example, you need Optax >= 0.1.9, grain for loading data, and the latest version of Orbax." ] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "%pip install optax==0.1.9 grain-nightly" + ], "metadata": { - "executionInfo": { - "elapsed": 11367, - "status": "ok", - "timestamp": 1703606966664, - "user": { - "displayName": "", - "userId": "" - }, - "user_tz": 0 + "colab": { + "base_uri": "https://localhost:8080/" }, - "id": "9cu0kFNrnJj7", - "outputId": "2ca5a895-3378-48d2-e33f-4d9495bbac47" + "id": "YQRCR21bKLja", + "outputId": "2fca6d18-3c32-4199-80f9-eb441f169c56" }, + "execution_count": 1, "outputs": [ { + "output_type": "stream", "name": "stdout", + "text": [ + "Collecting optax==0.1.9\n", + " Downloading optax-0.1.9-py3-none-any.whl (197 kB)\n", + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/197.2 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m197.2/197.2 kB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting grain-nightly\n", + " Downloading grain_nightly-0.0.4-py3-none-any.whl (367 kB)\n", + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/367.4 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m367.4/367.4 kB\u001b[0m \u001b[31m14.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: absl-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (1.4.0)\n", + "Requirement already satisfied: chex>=0.1.7 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (0.1.7)\n", + "Requirement already satisfied: jax>=0.1.55 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (0.4.23)\n", + "Requirement already satisfied: jaxlib>=0.1.37 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (0.4.23+cuda12.cudnn89)\n", + "Requirement already satisfied: numpy>=1.18.0 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (1.23.5)\n", + "Requirement already satisfied: array-record in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (0.5.0)\n", + "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (2.2.1)\n", + "Requirement already satisfied: dm-tree in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (0.1.8)\n", + "Requirement already satisfied: etils[epath] in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (1.6.0)\n", + "Collecting jaxtyping (from grain-nightly)\n", + " Downloading jaxtyping-0.2.25-py3-none-any.whl (39 kB)\n", + "Requirement already satisfied: more-itertools>=9.1.0 in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (10.1.0)\n", + "Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from chex>=0.1.7->optax==0.1.9) (0.12.1)\n", + "Requirement already satisfied: typing-extensions>=4.2.0 in /usr/local/lib/python3.10/dist-packages (from chex>=0.1.7->optax==0.1.9) (4.5.0)\n", + "Requirement already satisfied: ml-dtypes>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from jax>=0.1.55->optax==0.1.9) (0.2.0)\n", + "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.10/dist-packages (from jax>=0.1.55->optax==0.1.9) (3.3.0)\n", + "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.10/dist-packages (from jax>=0.1.55->optax==0.1.9) (1.11.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from etils[epath]->grain-nightly) (2023.6.0)\n", + "Requirement already satisfied: importlib_resources in /usr/local/lib/python3.10/dist-packages (from etils[epath]->grain-nightly) (6.1.1)\n", + "Requirement already satisfied: zipp in /usr/local/lib/python3.10/dist-packages (from etils[epath]->grain-nightly) (3.17.0)\n", + "Collecting typeguard<3,>=2.13.3 (from jaxtyping->grain-nightly)\n", + " Downloading typeguard-2.13.3-py3-none-any.whl (17 kB)\n", + "Installing collected packages: typeguard, jaxtyping, optax, grain-nightly\n", + " Attempting uninstall: optax\n", + " Found existing installation: optax 0.1.8\n", + " Uninstalling optax-0.1.8:\n", + " Successfully uninstalled optax-0.1.8\n", + "Successfully installed grain-nightly-0.0.4 jaxtyping-0.2.25 optax-0.1.9 typeguard-2.13.3\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "%pip install 'git+https://github.com/google/orbax/#subdirectory=checkpoint'" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "42L3h_aQKRsK", + "outputId": "2d7baa9b-8d3b-41ae-a3a1-7c12e5c73b7c" + }, + "execution_count": 2, + "outputs": [ + { "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/google/orbax/#subdirectory=checkpoint\n", + " Cloning https://github.com/google/orbax/ to /tmp/pip-req-build-8po1no69\n", + " Running command git clone --filter=blob:none --quiet https://github.com/google/orbax/ /tmp/pip-req-build-8po1no69\n", + " Resolved https://github.com/google/orbax/ to commit 9b37bfc105023eb62694fc4c6549cf9ea091e4e9\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: absl-py in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.4.0)\n", + "Requirement already satisfied: etils[epath,epy] in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.6.0)\n", + "Requirement already satisfied: typing_extensions in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (4.5.0)\n", + "Requirement already satisfied: msgpack in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.0.7)\n", + "Requirement already satisfied: jax>=0.4.9 in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (0.4.23)\n", + "Requirement already satisfied: jaxlib in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (0.4.23+cuda12.cudnn89)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.23.5)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (6.0.1)\n", + "Collecting tensorstore>=0.1.51 (from orbax-checkpoint==0.5.2)\n", + " Downloading tensorstore-0.1.52-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (14.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.1/14.1 MB\u001b[0m \u001b[31m51.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: nest_asyncio in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.6.0)\n", + "Requirement already satisfied: protobuf in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (3.20.3)\n", + "Requirement already satisfied: ml-dtypes>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.9->orbax-checkpoint==0.5.2) (0.2.0)\n", + "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.9->orbax-checkpoint==0.5.2) (3.3.0)\n", + "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.9->orbax-checkpoint==0.5.2) (1.11.4)\n", + "Collecting ml-dtypes>=0.2.0 (from jax>=0.4.9->orbax-checkpoint==0.5.2)\n", + " Downloading ml_dtypes-0.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.2/2.2 MB\u001b[0m \u001b[31m77.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from etils[epath,epy]->orbax-checkpoint==0.5.2) (2023.6.0)\n", + "Requirement already satisfied: importlib_resources in /usr/local/lib/python3.10/dist-packages (from etils[epath,epy]->orbax-checkpoint==0.5.2) (6.1.1)\n", + "Requirement already satisfied: zipp in /usr/local/lib/python3.10/dist-packages (from etils[epath,epy]->orbax-checkpoint==0.5.2) (3.17.0)\n", + "Building wheels for collected packages: orbax-checkpoint\n", + " Building wheel for orbax-checkpoint (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for orbax-checkpoint: filename=orbax_checkpoint-0.5.2-py3-none-any.whl size=143092 sha256=b00c41f92218b1ccc0509accbcc72cb79393f13428da96171251ff62dba50191\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-gus33a3u/wheels/9c/e5/6a/7b8445b9cd87b57a6797ade2ac0b43fb40b2d640b3207f41c8\n", + "Successfully built orbax-checkpoint\n", + "Installing collected packages: ml-dtypes, tensorstore, orbax-checkpoint\n", + " Attempting uninstall: ml-dtypes\n", + " Found existing installation: ml-dtypes 0.2.0\n", + " Uninstalling ml-dtypes-0.2.0:\n", + " Successfully uninstalled ml-dtypes-0.2.0\n", + " Attempting uninstall: tensorstore\n", + " Found existing installation: tensorstore 0.1.45\n", + " Uninstalling tensorstore-0.1.45:\n", + " Successfully uninstalled tensorstore-0.1.45\n", + " Attempting uninstall: orbax-checkpoint\n", + " Found existing installation: orbax-checkpoint 0.4.4\n", + " Uninstalling orbax-checkpoint-0.4.4:\n", + " Successfully uninstalled orbax-checkpoint-0.4.4\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "tensorflow 2.15.0 requires ml-dtypes~=0.2.0, but you have ml-dtypes 0.3.2 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed ml-dtypes-0.3.2 orbax-checkpoint-0.5.2 tensorstore-0.1.52\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "9cu0kFNrnJj7", + "outputId": "e8b0d571-ae16-4139-ebde-b447669e039b", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", "text": [ "JAX running on GPU\n" ] @@ -41,23 +164,24 @@ ], "source": [ "from typing import Sequence\n", - "from flax import linen as nn\n", + "\n", + "import numpy as np\n", "import jax\n", "import jax.numpy as jnp\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", + "from flax import linen as nn\n", "import optax\n", "from optax import contrib\n", - "import tensorflow as tf\n", + "import grain.python as grain\n", "import tensorflow_datasets as tfds\n", "\n", + "import matplotlib.pyplot as plt\n", "# Show on which platform JAX is running.\n", "print(\"JAX running on\", jax.devices()[0].platform.upper())" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "id": "2Adl_l_uZs1d" }, @@ -85,34 +209,71 @@ "id": "ZZej3FcOhuRE" }, "source": [ - "Fashion MNIST is a dataset of 28x28 grayscale image, associated with a label from 10 classes. We now load the dataset using `tensorflow_datasets`, apply min-max normalization to the images, shuffle the data in the train set and create batches of size `BATCH_SIZE`.\n" + "Fashion MNIST is a dataset of 28x28 grayscale images, associated with a label from 10 classes. We now download the dataset using `tensorflow_datasets`, create a transformation to apply min-max normalization to the images, and another transformation to group each (image, label) as a tuple. Then we use `grain` to shuffle the data in the train set, apply our transformations, create batches of size `BATCH_SIZE`, and create a data loader.\n" ] }, { "cell_type": "code", - "execution_count": null, + "source": [ + "fmnist_info = tfds.builder(\"fashion_mnist\").info\n", + "fmnist_ds = tfds.data_source(\"fashion_mnist\")" + ], "metadata": { - "id": "xPZ0paOehHWg" + "id": "3PWGuCIYLhmc" }, - "outputs": [], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", "source": [ - "(train_loader, test_loader), info = tfds.load(\n", - " \"fashion_mnist\", split=[\"train\", \"test\"], as_supervised=True, with_info=True\n", - ")\n", - "\n", - "min_max_norm = lambda image, label: (tf.cast(image, tf.float32) / 255., label)\n", - "train_loader = train_loader.map(min_max_norm)\n", - "test_loader = test_loader.map(min_max_norm)\n", + "class MinMaxNormTransform(grain.MapTransform):\n", + " \"\"\"Apply min-max normalization to the images\"\"\"\n", + " def map(self, element):\n", + " element[\"image\"] = element[\"image\"].astype(jnp.float32) / 255.\n", + " return element\n", "\n", - "NUM_CLASSES = info.features[\"label\"].num_classes\n", - "IMG_SIZE = info.features[\"image\"].shape\n", + "class AsSupervisedTransform(grain.MapTransform):\n", + " \"\"\"Transform the input from a dictionary of features into 2-tuple structure (image, label)\"\"\"\n", + " def map(self, element):\n", + " return (element[\"image\"], element[\"label\"])\n" + ], + "metadata": { + "id": "mdM8HopIac-G" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "train_loader_batched = grain.load(\n", + " source=fmnist_ds[\"train\"],\n", + " num_epochs=1,\n", + " shuffle=True,\n", + " transformations=[MinMaxNormTransform(), AsSupervisedTransform()],\n", + " batch_size=BATCH_SIZE,\n", + " drop_remainder=True,\n", + " seed=0\n", + ")\n", "\n", - "train_loader_batched = train_loader.shuffle(\n", - " buffer_size=10_000, reshuffle_each_iteration=True\n", - ").batch(BATCH_SIZE, drop_remainder=True)\n", + "test_loader_batched = grain.load(\n", + " source=fmnist_ds[\"test\"],\n", + " num_epochs=1,\n", + " transformations=[MinMaxNormTransform(), AsSupervisedTransform()],\n", + " batch_size=BATCH_SIZE,\n", + " drop_remainder=True,\n", + " seed=0\n", + ")\n", "\n", - "test_loader_batched = test_loader.batch(BATCH_SIZE, drop_remainder=True)" - ] + "NUM_CLASSES = fmnist_info.features[\"label\"].num_classes\n", + "IMG_SIZE = fmnist_info.features[\"image\"].shape" + ], + "metadata": { + "id": "cINVDSc9LzpM" + }, + "execution_count": 5, + "outputs": [] }, { "cell_type": "markdown", @@ -125,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "id": "RppusWrcaXzX" }, @@ -149,7 +310,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": { "id": "DKOi55MgdPyp" }, @@ -189,7 +350,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": { "id": "PBnbq7gui34L" }, @@ -204,7 +365,7 @@ " \"\"\"Computes loss and accuracy over the dataset `data_loader`.\"\"\"\n", " all_accuracy = []\n", " all_loss = []\n", - " for batch in data_loader.as_numpy_iterator():\n", + " for batch in data_loader:\n", " batch_loss, batch_aux = loss_accuracy(params, batch)\n", " all_loss.append(batch_loss)\n", " all_accuracy.append(batch_aux[\"accuracy\"])\n", @@ -222,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "id": "D1rU82drhaYM" }, @@ -245,31 +406,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": { - "executionInfo": { - "elapsed": 54, - "status": "ok", - "timestamp": 1703606977955, - "user": { - "displayName": "", - "userId": "" - }, - "user_tz": 0 - }, "id": "PDxQPVKA4iXC", - "outputId": "b142dbf1-b5ae-4d5e-ff5f-ba72ab1233c8" + "outputId": "62588a7c-f6fc-4db0-89f7-6224624e856b", + "colab": { + "base_uri": "https://localhost:8080/" + } }, "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "ReduceLROnPlateauState(lr=Array(1., dtype=float32), best_loss=Array(inf, dtype=float32), plateau_count=Array(0, dtype=int32), cooldown_counter=Array(0, dtype=int32))" ] }, - "execution_count": 8, "metadata": {}, - "output_type": "execute_result" + "execution_count": 10 } ], "source": [ @@ -292,76 +446,69 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { - "executionInfo": { - "elapsed": 40319, - "status": "ok", - "timestamp": 1703607018364, - "user": { - "displayName": "", - "userId": "" - }, - "user_tz": 0 - }, "id": "DeQr0urBjoDj", - "outputId": "f20603e6-cc36-4022-c5fb-a687ae833ad1" + "outputId": "9922cc78-1016-476d-fc26-06b89862c846", + "colab": { + "base_uri": "https://localhost:8080/" + } }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "Epoch 1/50, mean train accuracy: 0.7971587777137756\n", - "Epoch 2/50, mean train accuracy: 0.8521133661270142\n", - "Epoch 3/50, mean train accuracy: 0.8581897616386414\n", - "Epoch 4/50, mean train accuracy: 0.8647502660751343\n", - "Epoch 5/50, mean train accuracy: 0.8684561848640442\n", - "Epoch 6/50, mean train accuracy: 0.8729968070983887\n", - "Epoch 7/50, mean train accuracy: 0.8734809160232544\n", - "Epoch 8/50, mean train accuracy: 0.8754340410232544\n", - "Epoch 9/50, mean train accuracy: 0.8766025900840759\n", - "Epoch 10/50, mean train accuracy: 0.8775206804275513\n", - "Epoch 11/50, mean train accuracy: 0.8816773295402527\n", - "Epoch 12/50, mean train accuracy: 0.8807926177978516\n", - "Epoch 13/50, mean train accuracy: 0.8779213428497314\n", - "Epoch 14/50, mean train accuracy: 0.8931623697280884\n", - "Epoch 15/50, mean train accuracy: 0.8823450803756714\n", - "Epoch 16/50, mean train accuracy: 0.8841646909713745\n", - "Epoch 17/50, mean train accuracy: 0.8851495981216431\n", - "Epoch 18/50, mean train accuracy: 0.8850160241127014\n", - "Epoch 19/50, mean train accuracy: 0.8963341116905212\n", - "Epoch 20/50, mean train accuracy: 0.88671875\n", - "Epoch 21/50, mean train accuracy: 0.8832465410232544\n", - "Epoch 22/50, mean train accuracy: 0.8872028589248657\n", - "Epoch 23/50, mean train accuracy: 0.8886218070983887\n", - "Epoch 24/50, mean train accuracy: 0.8985877633094788\n", - "Epoch 25/50, mean train accuracy: 0.9000066518783569\n", - "Epoch 26/50, mean train accuracy: 0.9018930196762085\n", - "Epoch 27/50, mean train accuracy: 0.9013087749481201\n", - "Epoch 28/50, mean train accuracy: 0.9018930196762085\n", - "Epoch 29/50, mean train accuracy: 0.9086037874221802\n", - "Epoch 30/50, mean train accuracy: 0.9089877009391785\n", - "Epoch 31/50, mean train accuracy: 0.9101729393005371\n", - "Epoch 32/50, mean train accuracy: 0.910490095615387\n", - "Epoch 33/50, mean train accuracy: 0.9105736017227173\n", - "Epoch 34/50, mean train accuracy: 0.9151475429534912\n", - "Epoch 35/50, mean train accuracy: 0.9149973392486572\n", - "Epoch 36/50, mean train accuracy: 0.9160990715026855\n", - "Epoch 37/50, mean train accuracy: 0.9163995981216431\n", - "Epoch 38/50, mean train accuracy: 0.9170172214508057\n", - "Epoch 39/50, mean train accuracy: 0.9185696840286255\n", - "Epoch 40/50, mean train accuracy: 0.9187032580375671\n", - "Epoch 41/50, mean train accuracy: 0.9185529947280884\n", - "Epoch 42/50, mean train accuracy: 0.9193376302719116\n", - "Epoch 43/50, mean train accuracy: 0.9192207455635071\n", - "Epoch 44/50, mean train accuracy: 0.9198551177978516\n", - "Epoch 45/50, mean train accuracy: 0.9205729365348816\n", - "Epoch 46/50, mean train accuracy: 0.9203058481216431\n", - "Epoch 47/50, mean train accuracy: 0.9205061197280884\n", - "Epoch 48/50, mean train accuracy: 0.9216412901878357\n", - "Epoch 49/50, mean train accuracy: 0.9208900928497314\n", - "Epoch 50/50, mean train accuracy: 0.9213241338729858\n" + "Epoch 1/50, mean train accuracy: 0.801148533821106\n", + "Epoch 2/50, mean train accuracy: 0.8498764634132385\n", + "Epoch 3/50, mean train accuracy: 0.8592748641967773\n", + "Epoch 4/50, mean train accuracy: 0.8620960116386414\n", + "Epoch 5/50, mean train accuracy: 0.8668035268783569\n", + "Epoch 6/50, mean train accuracy: 0.8688401579856873\n", + "Epoch 7/50, mean train accuracy: 0.87109375\n", + "Epoch 8/50, mean train accuracy: 0.8743823170661926\n", + "Epoch 9/50, mean train accuracy: 0.8762853741645813\n", + "Epoch 10/50, mean train accuracy: 0.876769483089447\n", + "Epoch 11/50, mean train accuracy: 0.8752670884132385\n", + "Epoch 12/50, mean train accuracy: 0.8785557150840759\n", + "Epoch 13/50, mean train accuracy: 0.8797910213470459\n", + "Epoch 14/50, mean train accuracy: 0.8814436197280884\n", + "Epoch 15/50, mean train accuracy: 0.8785557150840759\n", + "Epoch 16/50, mean train accuracy: 0.8819444179534912\n", + "Epoch 17/50, mean train accuracy: 0.883713960647583\n", + "Epoch 18/50, mean train accuracy: 0.8919270634651184\n", + "Epoch 19/50, mean train accuracy: 0.8850327134132385\n", + "Epoch 20/50, mean train accuracy: 0.8842147588729858\n", + "Epoch 21/50, mean train accuracy: 0.8834468722343445\n", + "Epoch 22/50, mean train accuracy: 0.8852497339248657\n", + "Epoch 23/50, mean train accuracy: 0.8935797214508057\n", + "Epoch 24/50, mean train accuracy: 0.8960503339767456\n", + "Epoch 25/50, mean train accuracy: 0.8975694179534912\n", + "Epoch 26/50, mean train accuracy: 0.8974692821502686\n", + "Epoch 27/50, mean train accuracy: 0.8981537222862244\n", + "Epoch 28/50, mean train accuracy: 0.9024105072021484\n", + "Epoch 29/50, mean train accuracy: 0.9034622311592102\n", + "Epoch 30/50, mean train accuracy: 0.9042134284973145\n", + "Epoch 31/50, mean train accuracy: 0.9047976732254028\n", + "Epoch 32/50, mean train accuracy: 0.9055488705635071\n", + "Epoch 33/50, mean train accuracy: 0.90748530626297\n", + "Epoch 34/50, mean train accuracy: 0.907869279384613\n", + "Epoch 35/50, mean train accuracy: 0.9084034562110901\n", + "Epoch 36/50, mean train accuracy: 0.9088708758354187\n", + "Epoch 37/50, mean train accuracy: 0.9089042544364929\n", + "Epoch 38/50, mean train accuracy: 0.9105902910232544\n", + "Epoch 39/50, mean train accuracy: 0.9107238054275513\n", + "Epoch 40/50, mean train accuracy: 0.9112412929534912\n", + "Epoch 41/50, mean train accuracy: 0.9113081097602844\n", + "Epoch 42/50, mean train accuracy: 0.9117922186851501\n", + "Epoch 43/50, mean train accuracy: 0.9115251302719116\n", + "Epoch 44/50, mean train accuracy: 0.9118089079856873\n", + "Epoch 45/50, mean train accuracy: 0.9119758009910583\n", + "Epoch 46/50, mean train accuracy: 0.9122596383094788\n", + "Epoch 47/50, mean train accuracy: 0.9123931527137756\n", + "Epoch 48/50, mean train accuracy: 0.9132612347602844\n", + "Epoch 49/50, mean train accuracy: 0.91334468126297\n", + "Epoch 50/50, mean train accuracy: 0.9134782552719116\n" ] } ], @@ -396,7 +543,7 @@ " train_accuracy_epoch = []\n", " train_losses_epoch = []\n", "\n", - " for train_batch in train_loader_batched.as_numpy_iterator():\n", + " for train_batch in train_loader_batched:\n", " parameters, solver_state, train_loss, train_aux = train_step(\n", " parameters, solver_state, transform_state, train_batch\n", " )\n", @@ -420,34 +567,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": { "colab": { - "height": 425 - }, - "executionInfo": { - "elapsed": 792, - "status": "ok", - "timestamp": 1703607019246, - "user": { - "displayName": "", - "userId": "" - }, - "user_tz": 0 + "height": 525, + "base_uri": "https://localhost:8080/" }, "id": "LRdj9FORTNu3", - "outputId": "db6c3e46-e2e7-4e29-8635-584c3ab6ea90" + "outputId": "387f4c69-0fdd-4299-84ba-b2440dcb2db9" }, "outputs": [ { + "output_type": "display_data", "data": { - "image/png": "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", "text/plain": [ "
" - ] + ], + "image/png": "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\n" }, - "metadata": {}, - "output_type": "display_data" + "metadata": {} } ], "source": [ @@ -492,12 +630,21 @@ ], "metadata": { "colab": { - "provenance": [] + "provenance": [], + "gpuType": "T4" }, "execution": { "timeout": -1 - } + }, + "language_info": { + "name": "python" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "accelerator": "GPU" }, "nbformat": 4, "nbformat_minor": 0 -} +} \ No newline at end of file From fbecb26374b5905fb1370243c6ed8c2bc1295daa Mon Sep 17 00:00:00 2001 From: mmhamdy Date: Sun, 4 Feb 2024 15:57:50 +0200 Subject: [PATCH 2/4] add doc dependencies to pyproject.toml --- examples/contrib/reduce_on_plateau.ipynb | 220 +++++------------------ pyproject.toml | 2 + 2 files changed, 47 insertions(+), 175 deletions(-) diff --git a/examples/contrib/reduce_on_plateau.ipynb b/examples/contrib/reduce_on_plateau.ipynb index 792fb265c..65e8ddced 100644 --- a/examples/contrib/reduce_on_plateau.ipynb +++ b/examples/contrib/reduce_on_plateau.ipynb @@ -10,153 +10,23 @@ "\n", "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.sandbox.google.com/github/google-deepmind/optax/blob/main/examples/contrib/reduce_on_plateau.ipynb)\n", "\n", - "In this notebook, we explore the power of `reduce_on_plateau` scheduler, that reduces the learning rate when a metric has stopped improving. We will be solving a classification task by training a simple Multilayer Perceptron (MLP) on the fashion MNIST dataset.\n", - "\n", - "To run this example, you need Optax >= 0.1.9, grain for loading data, and the latest version of Orbax." + "In this notebook, we explore the power of `reduce_on_plateau` scheduler, that reduces the learning rate when a metric has stopped improving. We will be solving a classification task by training a simple Multilayer Perceptron (MLP) on the fashion MNIST dataset." ] }, { "cell_type": "code", - "source": [ - "%pip install optax==0.1.9 grain-nightly" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "YQRCR21bKLja", - "outputId": "2fca6d18-3c32-4199-80f9-eb441f169c56" - }, "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting optax==0.1.9\n", - " Downloading optax-0.1.9-py3-none-any.whl (197 kB)\n", - "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/197.2 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m197.2/197.2 kB\u001b[0m \u001b[31m6.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting grain-nightly\n", - " Downloading grain_nightly-0.0.4-py3-none-any.whl (367 kB)\n", - "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/367.4 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m367.4/367.4 kB\u001b[0m \u001b[31m14.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: absl-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (1.4.0)\n", - "Requirement already satisfied: chex>=0.1.7 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (0.1.7)\n", - "Requirement already satisfied: jax>=0.1.55 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (0.4.23)\n", - "Requirement already satisfied: jaxlib>=0.1.37 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (0.4.23+cuda12.cudnn89)\n", - "Requirement already satisfied: numpy>=1.18.0 in /usr/local/lib/python3.10/dist-packages (from optax==0.1.9) (1.23.5)\n", - "Requirement already satisfied: array-record in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (0.5.0)\n", - "Requirement already satisfied: cloudpickle in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (2.2.1)\n", - "Requirement already satisfied: dm-tree in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (0.1.8)\n", - "Requirement already satisfied: etils[epath] in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (1.6.0)\n", - "Collecting jaxtyping (from grain-nightly)\n", - " Downloading jaxtyping-0.2.25-py3-none-any.whl (39 kB)\n", - "Requirement already satisfied: more-itertools>=9.1.0 in /usr/local/lib/python3.10/dist-packages (from grain-nightly) (10.1.0)\n", - "Requirement already satisfied: toolz>=0.9.0 in /usr/local/lib/python3.10/dist-packages (from chex>=0.1.7->optax==0.1.9) (0.12.1)\n", - "Requirement already satisfied: typing-extensions>=4.2.0 in /usr/local/lib/python3.10/dist-packages (from chex>=0.1.7->optax==0.1.9) (4.5.0)\n", - "Requirement already satisfied: ml-dtypes>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from jax>=0.1.55->optax==0.1.9) (0.2.0)\n", - "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.10/dist-packages (from jax>=0.1.55->optax==0.1.9) (3.3.0)\n", - "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.10/dist-packages (from jax>=0.1.55->optax==0.1.9) (1.11.4)\n", - "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from etils[epath]->grain-nightly) (2023.6.0)\n", - "Requirement already satisfied: importlib_resources in /usr/local/lib/python3.10/dist-packages (from etils[epath]->grain-nightly) (6.1.1)\n", - "Requirement already satisfied: zipp in /usr/local/lib/python3.10/dist-packages (from etils[epath]->grain-nightly) (3.17.0)\n", - "Collecting typeguard<3,>=2.13.3 (from jaxtyping->grain-nightly)\n", - " Downloading typeguard-2.13.3-py3-none-any.whl (17 kB)\n", - "Installing collected packages: typeguard, jaxtyping, optax, grain-nightly\n", - " Attempting uninstall: optax\n", - " Found existing installation: optax 0.1.8\n", - " Uninstalling optax-0.1.8:\n", - " Successfully uninstalled optax-0.1.8\n", - "Successfully installed grain-nightly-0.0.4 jaxtyping-0.2.25 optax-0.1.9 typeguard-2.13.3\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "%pip install 'git+https://github.com/google/orbax/#subdirectory=checkpoint'" - ], "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, - "id": "42L3h_aQKRsK", - "outputId": "2d7baa9b-8d3b-41ae-a3a1-7c12e5c73b7c" - }, - "execution_count": 2, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/google/orbax/#subdirectory=checkpoint\n", - " Cloning https://github.com/google/orbax/ to /tmp/pip-req-build-8po1no69\n", - " Running command git clone --filter=blob:none --quiet https://github.com/google/orbax/ /tmp/pip-req-build-8po1no69\n", - " Resolved https://github.com/google/orbax/ to commit 9b37bfc105023eb62694fc4c6549cf9ea091e4e9\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: absl-py in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.4.0)\n", - "Requirement already satisfied: etils[epath,epy] in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.6.0)\n", - "Requirement already satisfied: typing_extensions in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (4.5.0)\n", - "Requirement already satisfied: msgpack in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.0.7)\n", - "Requirement already satisfied: jax>=0.4.9 in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (0.4.23)\n", - "Requirement already satisfied: jaxlib in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (0.4.23+cuda12.cudnn89)\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.23.5)\n", - "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (6.0.1)\n", - "Collecting tensorstore>=0.1.51 (from orbax-checkpoint==0.5.2)\n", - " Downloading tensorstore-0.1.52-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (14.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m14.1/14.1 MB\u001b[0m \u001b[31m51.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: nest_asyncio in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (1.6.0)\n", - "Requirement already satisfied: protobuf in /usr/local/lib/python3.10/dist-packages (from orbax-checkpoint==0.5.2) (3.20.3)\n", - "Requirement already satisfied: ml-dtypes>=0.2.0 in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.9->orbax-checkpoint==0.5.2) (0.2.0)\n", - "Requirement already satisfied: opt-einsum in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.9->orbax-checkpoint==0.5.2) (3.3.0)\n", - "Requirement already satisfied: scipy>=1.9 in /usr/local/lib/python3.10/dist-packages (from jax>=0.4.9->orbax-checkpoint==0.5.2) (1.11.4)\n", - "Collecting ml-dtypes>=0.2.0 (from jax>=0.4.9->orbax-checkpoint==0.5.2)\n", - " Downloading ml_dtypes-0.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.2 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.2/2.2 MB\u001b[0m \u001b[31m77.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from etils[epath,epy]->orbax-checkpoint==0.5.2) (2023.6.0)\n", - "Requirement already satisfied: importlib_resources in /usr/local/lib/python3.10/dist-packages (from etils[epath,epy]->orbax-checkpoint==0.5.2) (6.1.1)\n", - "Requirement already satisfied: zipp in /usr/local/lib/python3.10/dist-packages (from etils[epath,epy]->orbax-checkpoint==0.5.2) (3.17.0)\n", - "Building wheels for collected packages: orbax-checkpoint\n", - " Building wheel for orbax-checkpoint (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for orbax-checkpoint: filename=orbax_checkpoint-0.5.2-py3-none-any.whl size=143092 sha256=b00c41f92218b1ccc0509accbcc72cb79393f13428da96171251ff62dba50191\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-gus33a3u/wheels/9c/e5/6a/7b8445b9cd87b57a6797ade2ac0b43fb40b2d640b3207f41c8\n", - "Successfully built orbax-checkpoint\n", - "Installing collected packages: ml-dtypes, tensorstore, orbax-checkpoint\n", - " Attempting uninstall: ml-dtypes\n", - " Found existing installation: ml-dtypes 0.2.0\n", - " Uninstalling ml-dtypes-0.2.0:\n", - " Successfully uninstalled ml-dtypes-0.2.0\n", - " Attempting uninstall: tensorstore\n", - " Found existing installation: tensorstore 0.1.45\n", - " Uninstalling tensorstore-0.1.45:\n", - " Successfully uninstalled tensorstore-0.1.45\n", - " Attempting uninstall: orbax-checkpoint\n", - " Found existing installation: orbax-checkpoint 0.4.4\n", - " Uninstalling orbax-checkpoint-0.4.4:\n", - " Successfully uninstalled orbax-checkpoint-0.4.4\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "tensorflow 2.15.0 requires ml-dtypes~=0.2.0, but you have ml-dtypes 0.3.2 which is incompatible.\u001b[0m\u001b[31m\n", - "\u001b[0mSuccessfully installed ml-dtypes-0.3.2 orbax-checkpoint-0.5.2 tensorstore-0.1.52\n" - ] - } - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { "id": "9cu0kFNrnJj7", - "outputId": "e8b0d571-ae16-4139-ebde-b447669e039b", - "colab": { - "base_uri": "https://localhost:8080/" - } + "outputId": "e8b0d571-ae16-4139-ebde-b447669e039b" }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "JAX running on GPU\n" ] @@ -214,18 +84,23 @@ }, { "cell_type": "code", - "source": [ - "fmnist_info = tfds.builder(\"fashion_mnist\").info\n", - "fmnist_ds = tfds.data_source(\"fashion_mnist\")" - ], + "execution_count": 3, "metadata": { "id": "3PWGuCIYLhmc" }, - "execution_count": 3, - "outputs": [] + "outputs": [], + "source": [ + "fmnist_info = tfds.builder(\"fashion_mnist\").info\n", + "fmnist_ds = tfds.data_source(\"fashion_mnist\")" + ] }, { "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "mdM8HopIac-G" + }, + "outputs": [], "source": [ "class MinMaxNormTransform(grain.MapTransform):\n", " \"\"\"Apply min-max normalization to the images\"\"\"\n", @@ -237,15 +112,15 @@ " \"\"\"Transform the input from a dictionary of features into 2-tuple structure (image, label)\"\"\"\n", " def map(self, element):\n", " return (element[\"image\"], element[\"label\"])\n" - ], - "metadata": { - "id": "mdM8HopIac-G" - }, - "execution_count": 4, - "outputs": [] + ] }, { "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "cINVDSc9LzpM" + }, + "outputs": [], "source": [ "train_loader_batched = grain.load(\n", " source=fmnist_ds[\"train\"],\n", @@ -268,12 +143,7 @@ "\n", "NUM_CLASSES = fmnist_info.features[\"label\"].num_classes\n", "IMG_SIZE = fmnist_info.features[\"image\"].shape" - ], - "metadata": { - "id": "cINVDSc9LzpM" - }, - "execution_count": 5, - "outputs": [] + ] }, { "cell_type": "markdown", @@ -408,22 +278,22 @@ "cell_type": "code", "execution_count": 10, "metadata": { - "id": "PDxQPVKA4iXC", - "outputId": "62588a7c-f6fc-4db0-89f7-6224624e856b", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "PDxQPVKA4iXC", + "outputId": "62588a7c-f6fc-4db0-89f7-6224624e856b" }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "ReduceLROnPlateauState(lr=Array(1., dtype=float32), best_loss=Array(inf, dtype=float32), plateau_count=Array(0, dtype=int32), cooldown_counter=Array(0, dtype=int32))" ] }, + "execution_count": 10, "metadata": {}, - "execution_count": 10 + "output_type": "execute_result" } ], "source": [ @@ -448,16 +318,16 @@ "cell_type": "code", "execution_count": 11, "metadata": { - "id": "DeQr0urBjoDj", - "outputId": "9922cc78-1016-476d-fc26-06b89862c846", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "DeQr0urBjoDj", + "outputId": "9922cc78-1016-476d-fc26-06b89862c846" }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Epoch 1/50, mean train accuracy: 0.801148533821106\n", "Epoch 2/50, mean train accuracy: 0.8498764634132385\n", @@ -570,22 +440,22 @@ "execution_count": 12, "metadata": { "colab": { - "height": 525, - "base_uri": "https://localhost:8080/" + "base_uri": "https://localhost:8080/", + "height": 525 }, "id": "LRdj9FORTNu3", "outputId": "387f4c69-0fdd-4299-84ba-b2440dcb2db9" }, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -629,22 +499,22 @@ } ], "metadata": { + "accelerator": "GPU", "colab": { - "provenance": [], - "gpuType": "T4" + "gpuType": "T4", + "provenance": [] }, "execution": { "timeout": -1 }, - "language_info": { - "name": "python" - }, "kernelspec": { - "name": "python3", - "display_name": "Python 3" + "display_name": "Python 3", + "name": "python3" }, - "accelerator": "GPU" + "language_info": { + "name": "python" + } }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/pyproject.toml b/pyproject.toml index 3f8d8e6da..0af69e521 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -68,6 +68,8 @@ docs = [ "sphinx-collections>=0.0.1", "tensorflow>=2.4.0", "tensorflow-datasets>=4.2.0", + "grain-nightly>=0.0.4", + "orbax@git+https://github.com/google/orbax/#subdirectory=checkpoint" ] dp-accounting = [ From 4a37be622e193d1052056fd9c81908d74771a665 Mon Sep 17 00:00:00 2001 From: mmhamdy Date: Sun, 4 Feb 2024 16:10:34 +0200 Subject: [PATCH 3/4] correct orbax dependency in pyproject.toml --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index 0af69e521..d991f4beb 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -69,7 +69,7 @@ docs = [ "tensorflow>=2.4.0", "tensorflow-datasets>=4.2.0", "grain-nightly>=0.0.4", - "orbax@git+https://github.com/google/orbax/#subdirectory=checkpoint" + "orbax-checkpoint@git+https://github.com/google/orbax/#subdirectory=checkpoint" ] dp-accounting = [ From 0673d37c21f5d431acc572b113250e2dd198c1bc Mon Sep 17 00:00:00 2001 From: mmhamdy Date: Sun, 4 Feb 2024 16:24:47 +0200 Subject: [PATCH 4/4] fix doc dependencies in pyproject.toml --- pyproject.toml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index d991f4beb..3edb39c1f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -68,8 +68,8 @@ docs = [ "sphinx-collections>=0.0.1", "tensorflow>=2.4.0", "tensorflow-datasets>=4.2.0", - "grain-nightly>=0.0.4", - "orbax-checkpoint@git+https://github.com/google/orbax/#subdirectory=checkpoint" + "orbax-checkpoint", + "grain-nightly" ] dp-accounting = [