diff --git a/docs/source/JAX_transformer_text_classification.ipynb b/docs/source/JAX_transformer_text_classification.ipynb index 6ef22c6..5d78513 100644 --- a/docs/source/JAX_transformer_text_classification.ipynb +++ b/docs/source/JAX_transformer_text_classification.ipynb @@ -226,7 +226,6 @@ }, { "cell_type": "markdown", - "id": "deec4652", "metadata": {}, "source": [ "**Note:** We are using a single-device setup, so [device parallelism](https://docs.jax.dev/en/latest/notebooks/Distributed_arrays_and_automatic_parallelization.html) or sharding for [Single-Program Multi-Data](https://en.wikipedia.org/wiki/Single_program,_multiple_data) is not needed in this example. During sharding, the training data is run via multiple parts - batches - in parallel and simultaneously across different devices, such as GPUs and Google TPUs, and larger batch sizes can speed up training. You can learn more about it in the [miniGPT with JAX tutorial](https://jax-ai-stack.readthedocs.io/en/latest/JAX_for_LLM_pretraining.html) and JAX documentation's [tensor parallelism](https://docs.jax.dev/en/latest/notebooks/Distributed_arrays_and_automatic_parallelization.html) page." @@ -321,12 +320,12 @@ " # First linear transformation for the feed-forward network using `flax.nnx.Linear`.\n", " self.dense_1 = nnx.Linear(in_features=embed_dim, out_features=ff_dim, rngs=rngs)\n", " # Second linear transformation for the feed-forward network with `flax.nnx.Linear`.\n", - " self.dense_2 = nnx.Linear(in_features=ff_dim, out_features=ff_dim, rngs=rngs)\n", + " self.dense_2 = nnx.Linear(in_features=ff_dim, out_features=embed_dim, rngs=rngs)\n", "\n", " # First layer normalization using `flax.nnx.LayerNorm`.\n", " self.layer_norm_1 = nnx.LayerNorm(num_features=embed_dim, epsilon=1e-6, rngs=rngs)\n", " # Second layer normalization with `flax.nnx.LayerNorm`.\n", - " self.layer_norm_2 = nnx.LayerNorm(num_features=ff_dim, epsilon=1e-6, rngs=rngs)\n", + " self.layer_norm_2 = nnx.LayerNorm(num_features=embed_dim, epsilon=1e-6, rngs=rngs)\n", "\n", " # First dropout using `flax.nnx.Dropout`.\n", " self.dropout_1 = nnx.Dropout(rate, rngs=rngs)\n", @@ -357,7 +356,6 @@ }, { "cell_type": "markdown", - "id": "ff8b54d7", "metadata": {}, "source": [ "Next, let's create a class called `TokenAndPositionEmbedding()` that transforms tokens and positions into embeddings that will be fed into the transformer (via `TransformerBlock`) by subclassing `flax.nnx.Module`.\n", @@ -405,7 +403,6 @@ }, { "cell_type": "markdown", - "id": "1a82a1f5", "metadata": {}, "source": [ "Next, we'll construct the transformer model, `MyModel()`, subclassing `flax.nnx.Module`, which includes `TokenAndPositionEmbedding()` for transforming tokens and positions into embeddings, transformer blocks (`TransformerBlock()`) for processing the embedded sequences, and other layers." @@ -419,7 +416,7 @@ "source": [ "embed_dim = 32 # The embedding size for each token.\n", "num_heads = 2 # The number of attention heads.\n", - "ff_dim = 32 # The hidden layer size in the feed-forward network inside the transformer.\n", + "ff_dim = 64 # The hidden layer size in the feed-forward network inside the transformer.\n", "\n", "class MyModel(nnx.Module):\n", " def __init__(self, rngs: nnx.Rngs):\n", @@ -453,7 +450,6 @@ }, { "cell_type": "markdown", - "id": "0e8f7bae", "metadata": {}, "source": [ "Instantiate the model, `MyModel()`, as `model` and visualize it by calling `flax.nnx.display()`:" @@ -465,273 +461,28 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "MyModel(\n", - " embedding_layer=TokenAndPositionEmbedding(\n", - " token_emb=Embed(\n", - " embedding=Param(\n", - " value=Array(shape=(20000, 32), dtype=float32)\n", - " ),\n", - " num_embeddings=20000,\n", - " features=32,\n", - " dtype=dtype('float32'),\n", - " param_dtype=,\n", - " embedding_init=.init at 0x7f0cab141e10>\n", - " ),\n", - " pos_emb=Embed(\n", - " embedding=Param(\n", - " value=Array(shape=(200, 32), dtype=float32)\n", - " ),\n", - " num_embeddings=200,\n", - " features=32,\n", - " dtype=dtype('float32'),\n", - " param_dtype=,\n", - " embedding_init=.init at 0x7f0cab141e10>\n", - " )\n", - " ),\n", - " transformer_block=TransformerBlock(\n", - " attention=MultiHeadAttention(\n", - " num_heads=2,\n", - " in_features=32,\n", - " qkv_features=32,\n", - " out_features=32,\n", - " dtype=None,\n", - " param_dtype=,\n", - " broadcast_dropout=True,\n", - " dropout_rate=0.0,\n", - " deterministic=None,\n", - " precision=None,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " out_kernel_init=None,\n", - " bias_init=,\n", - " out_bias_init=None,\n", - " use_bias=True,\n", - " attention_fn=,\n", - " decode=False,\n", - " normalize_qk=False,\n", - " qkv_dot_general=None,\n", - " out_dot_general=None,\n", - " qkv_dot_general_cls=None,\n", - " out_dot_general_cls=None,\n", - " head_dim=16,\n", - " query=LinearGeneral(\n", - " in_features=(32,),\n", - " out_features=(2, 16),\n", - " axis=(-1,),\n", - " batch_axis=FrozenDict({}),\n", - " use_bias=True,\n", - " dtype=None,\n", - " param_dtype=,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " bias_init=,\n", - " precision=None,\n", - " dot_general=None,\n", - " dot_general_cls=None,\n", - " kernel=Param(\n", - " value=Array(shape=(32, 2, 16), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(2, 16), dtype=float32)\n", - " )\n", - " ),\n", - " key=LinearGeneral(\n", - " in_features=(32,),\n", - " out_features=(2, 16),\n", - " axis=(-1,),\n", - " batch_axis=FrozenDict({}),\n", - " use_bias=True,\n", - " dtype=None,\n", - " param_dtype=,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " bias_init=,\n", - " precision=None,\n", - " dot_general=None,\n", - " dot_general_cls=None,\n", - " kernel=Param(\n", - " value=Array(shape=(32, 2, 16), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(2, 16), dtype=float32)\n", - " )\n", - " ),\n", - " value=LinearGeneral(\n", - " in_features=(32,),\n", - " out_features=(2, 16),\n", - " axis=(-1,),\n", - " batch_axis=FrozenDict({}),\n", - " use_bias=True,\n", - " dtype=None,\n", - " param_dtype=,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " bias_init=,\n", - " precision=None,\n", - " dot_general=None,\n", - " dot_general_cls=None,\n", - " kernel=Param(\n", - " value=Array(shape=(32, 2, 16), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(2, 16), dtype=float32)\n", - " )\n", - " ),\n", - " query_ln=None,\n", - " key_ln=None,\n", - " out=LinearGeneral(\n", - " in_features=(2, 16),\n", - " out_features=(32,),\n", - " axis=(-2, -1),\n", - " batch_axis=FrozenDict({}),\n", - " use_bias=True,\n", - " dtype=None,\n", - " param_dtype=,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " bias_init=,\n", - " precision=None,\n", - " dot_general=None,\n", - " dot_general_cls=None,\n", - " kernel=Param(\n", - " value=Array(shape=(2, 16, 32), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(32,), dtype=float32)\n", - " )\n", - " ),\n", - " rngs=None,\n", - " cached_key=None,\n", - " cached_value=None,\n", - " cache_index=None\n", - " ),\n", - " dense_1=Linear(\n", - " kernel=Param(\n", - " value=Array(shape=(32, 32), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(32,), dtype=float32)\n", - " ),\n", - " in_features=32,\n", - " out_features=32,\n", - " use_bias=True,\n", - " dtype=None,\n", - " param_dtype=,\n", - " precision=None,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " bias_init=,\n", - " dot_general=\n", - " ),\n", - " dense_2=Linear(\n", - " kernel=Param(\n", - " value=Array(shape=(32, 32), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(32,), dtype=float32)\n", - " ),\n", - " in_features=32,\n", - " out_features=32,\n", - " use_bias=True,\n", - " dtype=None,\n", - " param_dtype=,\n", - " precision=None,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " bias_init=,\n", - " dot_general=\n", - " ),\n", - " layer_norm_1=LayerNorm(\n", - " scale=Param(\n", - " value=Array(shape=(32,), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(32,), dtype=float32)\n", - " ),\n", - " num_features=32,\n", - " epsilon=1e-06,\n", - " dtype=None,\n", - " param_dtype=,\n", - " use_bias=True,\n", - " use_scale=True,\n", - " bias_init=,\n", - " scale_init=,\n", - " reduction_axes=-1,\n", - " feature_axes=-1,\n", - " axis_name=None,\n", - " axis_index_groups=None,\n", - " use_fast_variance=True\n", - " ),\n", - " layer_norm_2=LayerNorm(\n", - " scale=Param(\n", - " value=Array(shape=(32,), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(32,), dtype=float32)\n", - " ),\n", - " num_features=32,\n", - " epsilon=1e-06,\n", - " dtype=None,\n", - " param_dtype=,\n", - " use_bias=True,\n", - " use_scale=True,\n", - " bias_init=,\n", - " scale_init=,\n", - " reduction_axes=-1,\n", - " feature_axes=-1,\n", - " axis_name=None,\n", - " axis_index_groups=None,\n", - " use_fast_variance=True\n", - " ),\n", - " dropout_1=Dropout(rate=0.1, broadcast_dims=(), deterministic=False, rng_collection='dropout', rngs=Rngs(\n", - " default=RngStream(\n", - " key=RngKey(\n", - " value=Array((), dtype=key) overlaying:\n", - " [0 0],\n", - " tag='default'\n", - " ),\n", - " count=RngCount(\n", - " value=Array(22, dtype=uint32),\n", - " tag='default'\n", - " )\n", - " )\n", - " )),\n", - " dropout_2=Dropout(rate=0.1, broadcast_dims=(), deterministic=False, rng_collection='dropout', rngs=Rngs(...))\n", - " ),\n", - " dropout1=Dropout(rate=0.1, broadcast_dims=(), deterministic=False, rng_collection='dropout', rngs=Rngs(...)),\n", - " dense1=Linear(\n", - " kernel=Param(\n", - " value=Array(shape=(32, 20), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(20,), dtype=float32)\n", - " ),\n", - " in_features=32,\n", - " out_features=20,\n", - " use_bias=True,\n", - " dtype=None,\n", - " param_dtype=,\n", - " precision=None,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " bias_init=,\n", - " dot_general=\n", - " ),\n", - " dropout2=Dropout(rate=0.1, broadcast_dims=(), deterministic=False, rng_collection='dropout', rngs=Rngs(...)),\n", - " dense2=Linear(\n", - " kernel=Param(\n", - " value=Array(shape=(20, 2), dtype=float32)\n", - " ),\n", - " bias=Param(\n", - " value=Array(shape=(2,), dtype=float32)\n", - " ),\n", - " in_features=20,\n", - " out_features=2,\n", - " use_bias=True,\n", - " dtype=None,\n", - " param_dtype=,\n", - " precision=None,\n", - " kernel_init=.init at 0x7f0cab141b40>,\n", - " bias_init=,\n", - " dot_general=\n", - " )\n", - ")\n" - ] + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -763,7 +514,6 @@ }, { "cell_type": "markdown", - "id": "8d800a1f", "metadata": {}, "source": [ "Next, we define the loss function - `compute_losses_and_logits()` - using `optax.softmax_cross_entropy_with_integer_labels`:" @@ -786,7 +536,6 @@ }, { "cell_type": "markdown", - "id": "e87e8385", "metadata": {}, "source": [ "Next, let's define the training step - `train_step()` - using the `flax.nnx.jit` transformation decorator. The function takes in `model` (our transformer model), `optimizer` (Adam, as defined earlier) and the `batch` size as arguments. Then, let's define the evaluation step function (`eval_step()`), which takes `model`, `batch` and `eval_metrics` (loss and accuracy - details further below) as arguments." @@ -829,7 +578,6 @@ }, { "cell_type": "markdown", - "id": "dce02f69", "metadata": {}, "source": [ "For metrics, let's set the evaluation metrics using `flax.nnx.MultiMetric`." @@ -858,7 +606,6 @@ }, { "cell_type": "markdown", - "id": "675e3be8", "metadata": {}, "source": [ "Next, set up a function called `train_one_epoch()` for training one epoch, and a function called `evaluate_model()` for computing metrics on the training and test sets:" @@ -906,7 +653,6 @@ }, { "cell_type": "markdown", - "id": "5ad13c38", "metadata": {}, "source": [ "## Training the model\n", @@ -923,7 +669,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 0/10, [192/195], loss=0.693 [00:36<00:00]\n" + "[train] epoch: 0/10, [192/195], loss=0.693 [00:20<00:00]\n" ] }, { @@ -931,15 +677,15 @@ "output_type": "stream", "text": [ "[test] epoch: 1/10\n", - "- total loss: 0.6879\n", - "- Accuracy: 0.5661\n" + "- total loss: 0.6898\n", + "- Accuracy: 0.5576\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 1/10, [192/195], loss=0.678 [00:35<00:00]\n" + "[train] epoch: 1/10, [192/195], loss=0.679 [00:20<00:00]\n" ] }, { @@ -947,15 +693,15 @@ "output_type": "stream", "text": [ "[test] epoch: 2/10\n", - "- total loss: 0.6734\n", - "- Accuracy: 0.6507\n" + "- total loss: 0.6794\n", + "- Accuracy: 0.6204\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 2/10, [192/195], loss=0.594 [00:35<00:00]\n" + "[train] epoch: 2/10, [192/195], loss=0.64 [00:19<00:00] \n" ] }, { @@ -963,15 +709,15 @@ "output_type": "stream", "text": [ "[test] epoch: 3/10\n", - "- total loss: 0.6177\n", - "- Accuracy: 0.7316\n" + "- total loss: 0.6371\n", + "- Accuracy: 0.7182\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 3/10, [192/195], loss=0.511 [00:35<00:00]\n" + "[train] epoch: 3/10, [192/195], loss=0.534 [00:20<00:00]\n" ] }, { @@ -979,15 +725,15 @@ "output_type": "stream", "text": [ "[test] epoch: 4/10\n", - "- total loss: 0.5404\n", - "- Accuracy: 0.7890\n" + "- total loss: 0.5517\n", + "- Accuracy: 0.7788\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 4/10, [192/195], loss=0.466 [00:35<00:00]\n" + "[train] epoch: 4/10, [192/195], loss=0.481 [00:19<00:00]\n" ] }, { @@ -995,15 +741,15 @@ "output_type": "stream", "text": [ "[test] epoch: 5/10\n", - "- total loss: 0.4995\n", - "- Accuracy: 0.8159\n" + "- total loss: 0.4971\n", + "- Accuracy: 0.8126\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 5/10, [192/195], loss=0.463 [00:35<00:00]\n" + "[train] epoch: 5/10, [192/195], loss=0.444 [00:21<00:00]\n" ] }, { @@ -1011,15 +757,15 @@ "output_type": "stream", "text": [ "[test] epoch: 6/10\n", - "- total loss: 0.4806\n", - "- Accuracy: 0.8280\n" + "- total loss: 0.4775\n", + "- Accuracy: 0.8290\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 6/10, [192/195], loss=0.435 [00:35<00:00]\n" + "[train] epoch: 6/10, [192/195], loss=0.429 [00:19<00:00]\n" ] }, { @@ -1027,15 +773,15 @@ "output_type": "stream", "text": [ "[test] epoch: 7/10\n", - "- total loss: 0.4714\n", - "- Accuracy: 0.8349\n" + "- total loss: 0.4680\n", + "- Accuracy: 0.8367\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 7/10, [192/195], loss=0.421 [00:35<00:00]\n" + "[train] epoch: 7/10, [192/195], loss=0.421 [00:20<00:00]\n" ] }, { @@ -1043,15 +789,15 @@ "output_type": "stream", "text": [ "[test] epoch: 8/10\n", - "- total loss: 0.4665\n", - "- Accuracy: 0.8394\n" + "- total loss: 0.4615\n", + "- Accuracy: 0.8433\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 8/10, [192/195], loss=0.409 [00:35<00:00]\n" + "[train] epoch: 8/10, [192/195], loss=0.408 [00:21<00:00]\n" ] }, { @@ -1059,15 +805,15 @@ "output_type": "stream", "text": [ "[test] epoch: 9/10\n", - "- total loss: 0.4602\n", - "- Accuracy: 0.8453\n" + "- total loss: 0.4587\n", + "- Accuracy: 0.8461\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "[train] epoch: 9/10, [192/195], loss=0.389 [00:35<00:00]\n" + "[train] epoch: 9/10, [192/195], loss=0.399 [00:21<00:00]\n" ] }, { @@ -1075,10 +821,10 @@ "output_type": "stream", "text": [ "[test] epoch: 10/10\n", - "- total loss: 0.4560\n", - "- Accuracy: 0.8486\n", - "CPU times: user 27min 44s, sys: 12min 14s, total: 39min 59s\n", - "Wall time: 8min 19s\n" + "- total loss: 0.4538\n", + "- Accuracy: 0.8508\n", + "CPU times: user 12min 48s, sys: 3min 38s, total: 16min 27s\n", + "Wall time: 4min 28s\n" ] } ], @@ -1091,7 +837,6 @@ }, { "cell_type": "markdown", - "id": "2d1f41c7", "metadata": {}, "source": [ "Let's visualize the training loss:" @@ -1105,7 +850,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 18, @@ -1114,7 +859,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1130,7 +875,6 @@ }, { "cell_type": "markdown", - "id": "d71891a9", "metadata": {}, "source": [ "We can also plot the accuracy and loss metrics on the test set:" @@ -1144,7 +888,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 19, @@ -1153,7 +897,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/source/JAX_transformer_text_classification.md b/docs/source/JAX_transformer_text_classification.md index b2294a1..9b0b02f 100644 --- a/docs/source/JAX_transformer_text_classification.md +++ b/docs/source/JAX_transformer_text_classification.md @@ -253,12 +253,12 @@ class TransformerBlock(nnx.Module): # First linear transformation for the feed-forward network using `flax.nnx.Linear`. self.dense_1 = nnx.Linear(in_features=embed_dim, out_features=ff_dim, rngs=rngs) # Second linear transformation for the feed-forward network with `flax.nnx.Linear`. - self.dense_2 = nnx.Linear(in_features=ff_dim, out_features=ff_dim, rngs=rngs) + self.dense_2 = nnx.Linear(in_features=ff_dim, out_features=embed_dim, rngs=rngs) # First layer normalization using `flax.nnx.LayerNorm`. self.layer_norm_1 = nnx.LayerNorm(num_features=embed_dim, epsilon=1e-6, rngs=rngs) # Second layer normalization with `flax.nnx.LayerNorm`. - self.layer_norm_2 = nnx.LayerNorm(num_features=ff_dim, epsilon=1e-6, rngs=rngs) + self.layer_norm_2 = nnx.LayerNorm(num_features=embed_dim, epsilon=1e-6, rngs=rngs) # First dropout using `flax.nnx.Dropout`. self.dropout_1 = nnx.Dropout(rate, rngs=rngs) @@ -329,7 +329,7 @@ Next, we'll construct the transformer model, `MyModel()`, subclassing `flax.nnx. ```{code-cell} ipython3 embed_dim = 32 # The embedding size for each token. num_heads = 2 # The number of attention heads. -ff_dim = 32 # The hidden layer size in the feed-forward network inside the transformer. +ff_dim = 64 # The hidden layer size in the feed-forward network inside the transformer. class MyModel(nnx.Module): def __init__(self, rngs: nnx.Rngs):