diff --git "a/CodeTrans Datasets/DLTrans/dl_test.json" "b/CodeTrans Datasets/DLTrans/dl_test.json"
new file mode 100644--- /dev/null
+++ "b/CodeTrans Datasets/DLTrans/dl_test.json"
@@ -0,0 +1,180 @@
+{"id": 637, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass MultiHeadAttention(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_v = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_o = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n    def call(self, queries, keys, values, valid_lens, **kwargs):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = tf.repeat(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens, **kwargs)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = tf.reshape(X, shape=(X.shape[0], X.shape[1], num_heads, -1))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = tf.reshape(X, shape=(-1, num_heads, X.shape[1], X.shape[2]))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens = 6, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nY = tf.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens, training=False).shape", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nclass MultiHeadAttention(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias_attr=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias_attr=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = paddle.repeat_interleave(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape((X.shape[0], X.shape[1], num_heads, -1))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = X.reshape((-1, num_heads, X.shape[1], X.shape[2]))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nY = paddle.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape"}
+{"id": 638, "tensorflow": "import numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries, valid_lens = 2, 4, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens, training=False).shape\nclass PositionalEncoding(tf.keras.layers.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super().__init__()\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len, dtype=np.float32).reshape(-1,1)/np.power(10000, np.arange(0, num_hiddens, 2, dtype=np.float32) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def call(self, X, **kwargs):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X, **kwargs)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\nX = pos_encoding(tf.zeros((1, num_steps, encoding_dim)), training=False)\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = tf.expand_dims(tf.expand_dims(P[0, :, :], axis=0), axis=0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries, valid_lens = 2, 4, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = paddle.zeros((1, max_len, num_hiddens))\n        X = paddle.arange(max_len, dtype=paddle.float32).reshape(\n            (-1, 1)) / paddle.pow(paddle.to_tensor([10000.0]), paddle.arange(\n            0, num_hiddens, 2, dtype=paddle.float32) / num_hiddens)\n        self.P[:, :, 0::2] = paddle.sin(X)\n        self.P[:, :, 1::2] = paddle.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(paddle.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(paddle.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in paddle.arange(6, 10)])\nP = P[0, :, :].unsqueeze(0).unsqueeze(0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 639, "tensorflow": "import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass PositionWiseFFN(tf.keras.layers.Layer):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super().__init__(*kwargs)\n        self.dense1 = tf.keras.layers.Dense(ffn_num_hiddens)\n        self.relu = tf.keras.layers.ReLU()\n        self.dense2 = tf.keras.layers.Dense(ffn_num_outputs)\n    def call(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 8)\nffn(tf.ones((2, 3, 4)))[0]\nln = tf.keras.layers.LayerNormalization()\nbn = tf.keras.layers.BatchNormalization()\nX = tf.constant([[1, 2], [2, 3]], dtype=tf.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(tf.keras.layers.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.ln = tf.keras.layers.LayerNormalization(normalized_shape)\n    def call(self, X, Y, **kwargs):\n        return self.ln(self.dropout(Y, **kwargs) + X)\nadd_norm = AddNorm([1, 2], 0.5)\nadd_norm(tf.ones((2, 3, 4)), tf.ones((2, 3, 4)), training=False).shape\nclass EncoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def call(self, X, valid_lens, **kwargs):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens, **kwargs), **kwargs)\n        return self.addnorm2(Y, self.ffn(Y), **kwargs)\nX = tf.ones((2, 100, 24))\nvalid_lens = tf.constant([3, 2])\nnorm_shape = [i for i in range(len(X.shape))][1:]\nencoder_blk = EncoderBlock(24, 24, 24, 24, norm_shape, 48, 8, 0.5)\nencoder_blk(X, valid_lens, training=False).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias) for _ in range(num_layers)]\n    def call(self, X, valid_lens, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens, **kwargs)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [1, 2], 48, 8, 2, 0.5)\nencoder(tf.ones((2, 100)), valid_lens, training=False).shape\nclass DecoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super().__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def call(self, X, state, **kwargs):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = tf.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if kwargs[\"training\"]:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = tf.repeat(tf.reshape(tf.range(1, num_steps + 1), shape=(-1, num_steps)), repeats=batch_size, axis=0)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens, **kwargs)\n        Y = self.addnorm1(X, X2, **kwargs)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n        Z = self.addnorm2(Y, Y2, **kwargs)\n        return self.addnorm3(Z, self.ffn(Z), **kwargs), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [1, 2], 48, 8, 0.5, 0)\nX = tf.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state, training=False)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hidens, num_heads, num_layers, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i) for i in range(num_layers)]\n        self.dense = tf.keras.layers.Dense(vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def call(self, X, state, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self._attention_weights = [[None] * len(self.blks) for _ in range(2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state, **kwargs)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [2]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = tf.reshape(tf.concat(net.encoder.attention_weights, 0), (num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights, xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0] for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = tf.convert_to_tensor(np.asarray(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values).astype(np.float32))\ndec_attention_weights = tf.reshape(dec_attention_weights_filled, shape=(-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = tf.transpose(dec_attention_weights, perm=(1, 2, 3, 0, 4))", "paddle": "import math\nimport warnings\nimport pandas as pd\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass PositionWiseFFN(nn.Layer):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(paddle.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1D(2)\nX = paddle.to_tensor([[1, 2], [2, 3]], dtype=paddle.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(paddle.ones((2, 3, 4)), paddle.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = paddle.ones((2, 100, 24))\nvalid_lens = paddle.to_tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(paddle.ones((2, 100), dtype=paddle.int64), valid_lens).shape\nclass DecoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(\n            key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = paddle.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = paddle.arange(1, num_steps + 1).tile((batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = paddle.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [32]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = paddle.concat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = paddle.to_tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose((1, 2, 3, 0, 4))\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 640, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x * tf.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * tf.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = tf.range(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = tf.range(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = tf.range(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = tf.meshgrid(tf.linspace(-1.0, 1.0, 101), tf.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = tf.range(-2.0, 5.0, 0.01)\nd2l.plot(x, [tf.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\ndef f(x):\n    return x * paddle.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * paddle.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = paddle.arange(0.5, 1.5, 0.01, dtype='float32')\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = paddle.arange(-1.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = paddle.arange(-2.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = paddle.meshgrid(paddle.linspace(-1.0, 1.0, 101), paddle.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = paddle.arange(-2.0, 5.0, 0.01, dtype='float32')\nd2l.plot(x, [paddle.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 641, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: tf.cos(np.pi * x)\nh = lambda x: tf.exp(0.5 * x)\nx, segment = tf.range(-2, 2, 0.01), tf.constant([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\nf = lambda x: 0.5 * x**2\ng = lambda x: paddle.cos(np.pi * x)\nh = lambda x: paddle.exp(0.5 * x)\nx, segment = paddle.arange(-2, 2, 0.01, dtype='float32'), paddle.to_tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 642, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = tf.range(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = paddle.arange(-n, n, 0.01, dtype='float32')\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 643, "tensorflow": "c = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = tf.meshgrid(tf.range(-5.5, 1.0, 0.1), tf.range(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = tf.constant(0.5)\ndef f(x):\n    return tf.cosh(c * x)\ndef f_grad(x):\n    return c * tf.sinh(c * x)\ndef f_hess(x):\n    return c**2 * tf.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * tf.sin(c * x) - x * c**2 * tf.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += tf.random.normal([1], 0.0, 1)\n    g2 += tf.random.normal([1], 0.0, 1)\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "paddle": "c = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = paddle.meshgrid(paddle.arange(-5.5, 1.0, 0.1, dtype='float32'), paddle.arange(-3.0, 1.0, 0.1, dtype='float32'))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = paddle.to_tensor(0.5)\ndef f(x):\n    return paddle.cosh(c * x)\ndef f_grad(x):\n    return c * paddle.sinh(c * x)\ndef f_hess(x):\n    return c**2 * paddle.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * paddle.sin(c * x) - x * c**2 * paddle.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += paddle.normal(0.0, 1, (1,))\n    g2 += paddle.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 644, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ntimer = d2l.Timer()\nA = tf.Variable(tf.zeros((256, 256)))\nB = tf.Variable(tf.random.normal([256, 256], 0, 1))\nC = tf.Variable(tf.random.normal([256, 256], 0, 1))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j].assign(tf.tensordot(B[i, :], C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j].assign(tf.tensordot(B, C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nA.assign(tf.tensordot(B, C, axes=1))\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64].assign(tf.tensordot(B, C[:, j:j+64], axes=1))\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, grads, states, hyperparams):\n    for param, grad in zip(params, grads):\n        param.assign_sub(hyperparams['lr']*grad)\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = tf.Variable(tf.random.normal(shape=(feature_dim, 1), mean=0, stddev=0.01),trainable=True)\n    b = tf.Variable(tf.zeros(1), trainable=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n            l = tf.math.reduce_mean(loss(net(X), y))\n            dw, db = g.gradient(l, [w, b])\n            trainer_fn([w, b], [dw, db], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss),)\n                animator.add(q, r)\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=2):\n    net = tf.keras.Sequential()\n    net.add(tf.keras.layers.Dense(1, kernel_initializer=tf.random_normal_initializer(stddev=0.01)))\n    optimizer = trainer_fn(**hyperparams)\n    loss = tf.keras.losses.MeanSquaredError()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n                out = net(X)\n                l = loss(y, out)\n                params = net.trainable_variables\n                grads = g.gradient(l, params)\n            optimizer.apply_gradients(zip(grads, params))\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss) / 2,)\n                animator.add(q, r)\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = tf.keras.optimizers.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.05}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom paddle import nn\ntimer = d2l.Timer()\nA = paddle.zeros((256, 256))\nB = paddle.randn((256, 256))\nC = paddle.randn((256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = paddle.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = paddle.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = paddle.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = paddle.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = paddle.to_tensor((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    a = []\n    with paddle.no_grad():\n        for p in params:\n            p = p - hyperparams['lr'] * p.grad\n            p.stop_gradient = False\n            a.append(p)\n        return a\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = paddle.to_tensor(paddle.normal(mean=0.0, std=0.01, shape=(feature_dim, 1)), stop_gradient=False)\n    b = paddle.to_tensor(paddle.zeros((1,)), stop_gradient=False)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            w, b = trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            paddle.nn.initializer.Normal(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(parameters=net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.clear_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = paddle.optimizer.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)"}
+{"id": 645, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(features_dim):\n    v_w = tf.Variable(tf.zeros((features_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    return (v_w, v_b)\ndef sgd_momentum(params, grads, states, hyperparams):\n    for p, v, g in zip(params, states, grads):\n        v[:].assign(hyperparams['momentum'] * v + g)\n        p[:].assign(p - hyperparams['lr'] * v)\ntrainer = tf.keras.optimizers.SGD\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = tf.range(20).numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = paddle.zeros((feature_dim, 1))\n    v_b = paddle.zeros([1])\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    a = []\n    for p, v in zip(params, states):\n        with paddle.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Momentum\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = paddle.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 646, "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef adagrad(params, grads, states, hyperparams):\n    eps = 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(s + tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate' : 0.1}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros(shape=(1, ))\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    a = []\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] += paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.1}, data_iter)"}
+{"id": 647, "tensorflow": "import math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef rmsprop(params, grads, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(gamma * s + (1 - gamma) * tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.RMSprop\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros([1])\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    a = []\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] = gamma * s + (1 - gamma) * paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.RMSProp\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)"}
+{"id": 648, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adadelta_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    delta_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    delta_b = tf.Variable(tf.zeros(1))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, grads, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta), grad in zip(params, states, grads):\n        s[:].assign(rho * s + (1 - rho) * tf.math.square(grad))\n        g = (tf.math.sqrt(delta + eps) / tf.math.sqrt(s + eps)) * grad\n        p[:].assign(p - g)\n        delta[:].assign(rho * delta + (1 - rho) * g * g)\ntrainer = tf.keras.optimizers.Adadelta\nd2l.train_concise_ch11(trainer, {'learning_rate':5.0, 'rho': 0.9}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    delta_w, delta_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    a = []\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with paddle.no_grad():\n            s[:] = rho * s + (1 - rho) * paddle.square(p.grad)\n            g = (paddle.sqrt(delta + eps) / paddle.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)"}
+{"id": 649, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adam_states(feature_dim):\n    v_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(beta2 * s + (1 - beta2) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\ntrainer = tf.keras.optimizers.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(s + (1 - beta2) * tf.math.sign(tf.math.square(grad) - s) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adam_states(feature_dim):\n    v_w, v_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    s_w, s_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    a = []\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ntrainer = paddle.optimizer.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    a=[]\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * paddle.sign(paddle.square(p.grad) - s) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 650, "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom tensorflow.keras.callbacks import LearningRateScheduler\nfrom d2l import tensorflow as d2l\ndef net():\n    return tf.keras.models.Sequential([\n        tf.keras.layers.Conv2D(filters=6, kernel_size=5, activation='relu', padding='same'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Conv2D(filters=16, kernel_size=5, activation='relu'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Flatten(),\n        tf.keras.layers.Dense(120, activation='relu'),\n        tf.keras.layers.Dense(84, activation='sigmoid'),\n        tf.keras.layers.Dense(10)])\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net_fn, train_iter, test_iter, num_epochs, lr, device=d2l.try_gpu(), custom_callback = False):\n    device_name = device._device_name\n    strategy = tf.distribute.OneDeviceStrategy(device_name)\n    with strategy.scope():\n        optimizer = tf.keras.optimizers.SGD(learning_rate=lr)\n        loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n        net = net_fn()\n        net.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n    callback = d2l.TrainCallback(net, train_iter, test_iter, num_epochs, device_name)\n    if custom_callback is False:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback])\n    else:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback, custom_callback])\n    return net\nlr, num_epochs = 0.3, 30\ntrain(net, train_iter, test_iter, num_epochs, lr)\nlr = 0.1\ndummy_model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)])\ndummy_model.compile(tf.keras.optimizers.SGD(learning_rate=lr), loss='mse')\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(tf.range(50), [scheduler(t) for t in range(50)])\nclass MultiFactorScheduler:\n    def __init__(self, step, factor, base_lr):\n        self.step = step\n        self.factor = factor\n        self.base_lr = base_lr\n    def __call__(self, epoch):\n        if epoch in self.step:\n            self.base_lr = self.base_lr * self.factor\n            return self.base_lr\n        else:\n            return self.base_lr\nscheduler = MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nfrom paddle.optimizer import lr as lr_scheduler\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2D(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Conv2D(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.clear_grad()\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with paddle.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat,y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                trainer.set_lr(scheduler(epoch))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.set_lr(lr)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr , parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(paddle.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\nscheduler =paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[15,30], gamma=0.5)\ntrainer = paddle.optimizer.SGD(learning_rate=scheduler, parameters=net.parameters())\ndef get_lr(trainer, scheduler):\n    lr=trainer.state_dict()['LR_Scheduler']['last_lr']\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(paddle.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)"}
+{"id": 651, "tensorflow": "import tensorflow as tf\nfrom tensorflow.keras.layers import Dense\nfrom d2l import tensorflow as d2l\ndef get_net():\n    net = tf.keras.Sequential()\n    net.add(Dense(256, input_shape = (512,), activation = \"relu\"))\n    net.add(Dense(128, activation = \"relu\"))\n    net.add(Dense(2, activation = \"linear\"))\n    return net\nx = tf.random.normal([1,512])\nnet = get_net()\nnet(x)\nnet = tf.function(net)\nnet(x)", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nfrom paddle.jit import to_static\nfrom paddle.static import InputSpec\ndef get_net():\n    blocks = [\n        nn.Linear(512, 256),\n        nn.ReLU(),\n        nn.Linear(256, 128),\n        nn.ReLU(),\n        nn.Linear(128, 2)\n    ]\n    net = nn.Sequential(*blocks)\n    return net\nx = paddle.randn((1, 512))\nnet = get_net()\nnet(x)\nnet = paddle.jit.to_static(net)\nnet(x)"}
+{"id": 652, "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass MultiHeadAttention(nn.Block):\n    def __init__(self, num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_k = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_v = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_o = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = valid_lens.repeat(self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nY = np.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nclass MultiHeadAttention(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias_attr=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias_attr=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = paddle.repeat_interleave(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape((X.shape[0], X.shape[1], num_heads, -1))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = X.reshape((-1, num_heads, X.shape[1], X.shape[2]))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nY = paddle.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape"}
+{"id": 653, "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries, valid_lens = 2, 4, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Block):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len).reshape(-1, 1) / np.power(10000, np.arange(0, num_hiddens, 2) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].as_in_ctx(X.ctx)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.initialize()\nX = pos_encoding(np.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = np.expand_dims(np.expand_dims(P[0, :, :], 0), 0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries, valid_lens = 2, 4, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = paddle.zeros((1, max_len, num_hiddens))\n        X = paddle.arange(max_len, dtype=paddle.float32).reshape(\n            (-1, 1)) / paddle.pow(paddle.to_tensor([10000.0]), paddle.arange(\n            0, num_hiddens, 2, dtype=paddle.float32) / num_hiddens)\n        self.P[:, :, 0::2] = paddle.sin(X)\n        self.P[:, :, 1::2] = paddle.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(paddle.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(paddle.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in paddle.arange(6, 10)])\nP = P[0, :, :].unsqueeze(0).unsqueeze(0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 654, "mxnet": "import math\nimport pandas as pd\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass PositionWiseFFN(nn.Block):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Dense(ffn_num_hiddens, flatten=False, activation='relu')\n        self.dense2 = nn.Dense(ffn_num_outputs, flatten=False)\n    def forward(self, X):\n        return self.dense2(self.dense1(X))\nffn = PositionWiseFFN(4, 8)\nffn.initialize()\nffn(np.ones((2, 3, 4)))[0]\nln = nn.LayerNorm()\nln.initialize()\nbn = nn.BatchNorm()\nbn.initialize()\nX = np.array([[1, 2], [2, 3]])\nwith autograd.record():\n    print('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Block):\n    def __init__(self, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm()\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm(0.5)\nadd_norm.initialize()\nadd_norm(np.ones((2, 3, 4)), np.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = np.ones((2, 100, 24))\nvalid_lens = np.array([3, 2])\nencoder_blk = EncoderBlock(24, 48, 8, 0.5)\nencoder_blk.initialize()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for _ in range(num_layers):\n            self.blks.add(EncoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 48, 8, 2, 0.5)\nencoder.initialize()\nencoder(np.ones((2, 100)), valid_lens).shape\nclass DecoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(dropout)\n        self.attention2 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = np.concatenate((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if autograd.is_training():\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = np.tile(np.arange(1, num_steps + 1, ctx=X.ctx), (batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 48, 8, 0.5, 0)\ndecoder_blk.initialize()\nX = np.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add(DecoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Dense(vocab_size, flatten=False)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nenc_attention_weights = np.concatenate(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights, xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [np.array(head[0]).tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = np.array(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "paddle": "import math\nimport warnings\nimport pandas as pd\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass PositionWiseFFN(nn.Layer):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(paddle.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1D(2)\nX = paddle.to_tensor([[1, 2], [2, 3]], dtype=paddle.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(paddle.ones((2, 3, 4)), paddle.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = paddle.ones((2, 100, 24))\nvalid_lens = paddle.to_tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(paddle.ones((2, 100), dtype=paddle.int64), valid_lens).shape\nclass DecoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(\n            key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = paddle.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = paddle.arange(1, num_steps + 1).tile((batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = paddle.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [32]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nenc_attention_weights = paddle.concat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = paddle.to_tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose((1, 2, 3, 0, 4))\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 655, "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x * np.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * np.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = np.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = np.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = np.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = np.meshgrid(np.linspace(-1.0, 1.0, 101), np.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(), **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = np.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [np.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\ndef f(x):\n    return x * paddle.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * paddle.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = paddle.arange(0.5, 1.5, 0.01, dtype='float32')\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = paddle.arange(-1.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = paddle.arange(-2.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = paddle.meshgrid(paddle.linspace(-1.0, 1.0, 101), paddle.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = paddle.arange(-2.0, 5.0, 0.01, dtype='float32')\nd2l.plot(x, [paddle.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 656, "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nf = lambda x: 0.5 * x**2\ng = lambda x: np.cos(np.pi * x)\nh = lambda x: np.exp(0.5 * x)\nx, segment = np.arange(-2, 2, 0.01), np.array([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\nf = lambda x: 0.5 * x**2\ng = lambda x: paddle.cos(np.pi * x)\nh = lambda x: paddle.exp(0.5 * x)\nx, segment = paddle.arange(-2, 2, 0.01, dtype='float32'), paddle.to_tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 657, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = np.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = paddle.arange(-n, n, 0.01, dtype='float32')\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 658, "mxnet": "c = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = np.array(0.5)\ndef f(x):\n    return np.cosh(c * x)\ndef f_grad(x):\n    return c * np.sinh(c * x)\ndef f_hess(x):\n    return c**2 * np.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * np.sin(c * x) - x * c**2 * np.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += np.random.normal(0.0, 1, (1,))\n    g2 += np.random.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "paddle": "c = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = paddle.meshgrid(paddle.arange(-5.5, 1.0, 0.1, dtype='float32'), paddle.arange(-3.0, 1.0, 0.1, dtype='float32'))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = paddle.to_tensor(0.5)\ndef f(x):\n    return paddle.cosh(c * x)\ndef f_grad(x):\n    return c * paddle.sinh(c * x)\ndef f_hess(x):\n    return c**2 * paddle.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * paddle.sin(c * x) - x * c**2 * paddle.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += paddle.normal(0.0, 1, (1,))\n    g2 += paddle.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 659, "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ntimer = d2l.Timer()\nA = np.zeros((256, 256))\nB = np.random.normal(0, 1, (256, 256))\nC = np.random.normal(0, 1, (256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = np.dot(B[i, :], C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = np.dot(B, C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nA = np.dot(B, C)\nA.wait_to_read()\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = np.dot(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p[:] -= hyperparams['lr'] * p.grad\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = np.random.normal(scale=0.01, size=(feature_dim, 1))\n    b = np.zeros(1)\n    w.attach_grad()\n    b.attach_grad()\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(tr_name, hyperparams, data_iter, num_epochs=2):\n    net = nn.Sequential()\n    net.add(nn.Dense(1))\n    net.initialize(init.Normal(sigma=0.01))\n    trainer = gluon.Trainer(net.collect_params(), tr_name, hyperparams)\n    loss = gluon.loss.L2Loss()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y)\n            l.backward()\n            trainer.step(X.shape[0])\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrain_concise_ch11('sgd', {'learning_rate': 0.05}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom paddle import nn\ntimer = d2l.Timer()\nA = paddle.zeros((256, 256))\nB = paddle.randn((256, 256))\nC = paddle.randn((256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = paddle.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = paddle.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = paddle.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = paddle.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = paddle.to_tensor((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    a = []\n    with paddle.no_grad():\n        for p in params:\n            p = p - hyperparams['lr'] * p.grad\n            p.stop_gradient = False\n            a.append(p)\n        return a\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = paddle.to_tensor(paddle.normal(mean=0.0, std=0.01, shape=(feature_dim, 1)), stop_gradient=False)\n    b = paddle.to_tensor(paddle.zeros((1,)), stop_gradient=False)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            w, b = trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            paddle.nn.initializer.Normal(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(parameters=net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.clear_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = paddle.optimizer.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)"}
+{"id": 660, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = np.zeros((feature_dim, 1))\n    v_b = np.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        v[:] = hyperparams['momentum'] * v + p.grad\n        p[:] -= hyperparams['lr'] * v\nd2l.train_concise_ch11('sgd', {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = np.arange(20).asnumpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = paddle.zeros((feature_dim, 1))\n    v_b = paddle.zeros([1])\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    a = []\n    for p, v in zip(params, states):\n        with paddle.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Momentum\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = paddle.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 661, "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        s[:] += np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('adagrad', {'learning_rate': 0.1}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros(shape=(1, ))\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    a = []\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] += paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.1}, data_iter)"}
+{"id": 662, "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        s[:] = gamma * s + (1 - gamma) * np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('rmsprop', {'learning_rate': 0.01, 'gamma1': 0.9}, data_iter)", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros([1])\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    a = []\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] = gamma * s + (1 - gamma) * paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.RMSProp\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)"}
+{"id": 663, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    delta_w, delta_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        s[:] = rho * s + (1 - rho) * np.square(p.grad)\n        g = (np.sqrt(delta + eps) / np.sqrt(s + eps)) * p.grad\n        p[:] -= g\n        delta[:] = rho * delta + (1 - rho) * g * g\nd2l.train_concise_ch11('adadelta', {'rho': 0.9}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    delta_w, delta_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    a = []\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with paddle.no_grad():\n            s[:] = rho * s + (1 - rho) * paddle.square(p.grad)\n            g = (paddle.sqrt(delta + eps) / paddle.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)"}
+{"id": 664, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adam_states(feature_dim):\n    v_w, v_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = beta2 * s + (1 - beta2) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\nd2l.train_concise_ch11('adam', {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = s + (1 - beta2) * np.sign(np.square(p.grad) - s) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adam_states(feature_dim):\n    v_w, v_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    s_w, s_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    a = []\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ntrainer = paddle.optimizer.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    a=[]\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * paddle.sign(paddle.square(p.grad) - s) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 665, "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, lr_scheduler, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnet = nn.HybridSequential()\nnet.add(nn.Conv2D(channels=6, kernel_size=5, padding=2, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Conv2D(channels=16, kernel_size=5, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Dense(120, activation='relu'),\n        nn.Dense(84, activation='relu'),\n        nn.Dense(10))\nnet.hybridize()\nloss = gluon.loss.SoftmaxCrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device):\n    net.initialize(force_reinit=True, ctx=device, init=init.Xavier())\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            X, y = X.as_in_ctx(device), y.as_in_ctx(device)\n            with autograd.record():\n                y_hat = net(X)\n                l = loss(y_hat, y)\n            l.backward()\n            trainer.step(X.shape[0])\n            metric.add(l.sum(), d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch + 1, (None, None, test_acc))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet.initialize(force_reinit=True, ctx=device, init=init.Xavier())\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\ntrainer.set_learning_rate(0.1)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(np.arange(50), [scheduler(t) for t in range(50)])\nscheduler = lr_scheduler.MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nfrom paddle.optimizer import lr as lr_scheduler\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2D(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Conv2D(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.clear_grad()\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with paddle.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat,y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                trainer.set_lr(scheduler(epoch))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.set_lr(lr)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr , parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(paddle.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\nscheduler =paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[15,30], gamma=0.5)\ntrainer = paddle.optimizer.SGD(learning_rate=scheduler, parameters=net.parameters())\ndef get_lr(trainer, scheduler):\n    lr=trainer.state_dict()['LR_Scheduler']['last_lr']\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(paddle.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)"}
+{"id": 666, "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef get_net():\n    net = nn.HybridSequential()\n    net.add(nn.Dense(256, activation='relu'),\n            nn.Dense(128, activation='relu'),\n            nn.Dense(2))\n    net.initialize()\n    return net\nx = np.random.normal(size=(1, 512))\nnet = get_net()\nnet(x)\nnet.hybridize()\nnet(x)", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nfrom paddle.jit import to_static\nfrom paddle.static import InputSpec\ndef get_net():\n    blocks = [\n        nn.Linear(512, 256),\n        nn.ReLU(),\n        nn.Linear(256, 128),\n        nn.ReLU(),\n        nn.Linear(128, 2)\n    ]\n    net = nn.Sequential(*blocks)\n    return net\nx = paddle.randn((1, 512))\nnet = get_net()\nnet(x)\nnet = paddle.jit.to_static(net)\nnet(x)"}
+{"id": 667, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass MultiHeadAttention(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = torch.repeat_interleave(valid_lens, repeats=self.num_heads, dim=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()", "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass MultiHeadAttention(nn.Block):\n    def __init__(self, num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_k = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_v = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_o = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = valid_lens.repeat(self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nY = np.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape"}
+{"id": 668, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nclass PositionalEncoding(nn.Module):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = torch.zeros((1, max_len, num_hiddens))\n        X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2, dtype=torch.float32) / num_hiddens)\n        self.P[:, :, 0::2] = torch.sin(X)\n        self.P[:, :, 1::2] = torch.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].to(X.device)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(torch.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in torch.arange(6, 10)])\nP = P[0, :, :].unsqueeze(0).unsqueeze(0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries, valid_lens = 2, 4, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Block):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len).reshape(-1, 1) / np.power(10000, np.arange(0, num_hiddens, 2) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].as_in_ctx(X.ctx)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.initialize()\nX = pos_encoding(np.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = np.expand_dims(np.expand_dims(P[0, :, :], 0), 0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 669, "pytorch": "import math\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass PositionWiseFFN(nn.Module):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(torch.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1d(2)\nX = torch.tensor([[1, 2], [2, 3]], dtype=torch.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Module):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(torch.ones((2, 3, 4)), torch.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = torch.ones((2, 100, 24))\nvalid_lens = torch.tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape\nclass DecoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = torch.cat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = torch.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [32]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nenc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = torch.tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.permute(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "mxnet": "import math\nimport pandas as pd\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass PositionWiseFFN(nn.Block):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Dense(ffn_num_hiddens, flatten=False, activation='relu')\n        self.dense2 = nn.Dense(ffn_num_outputs, flatten=False)\n    def forward(self, X):\n        return self.dense2(self.dense1(X))\nffn = PositionWiseFFN(4, 8)\nffn.initialize()\nffn(np.ones((2, 3, 4)))[0]\nln = nn.LayerNorm()\nln.initialize()\nbn = nn.BatchNorm()\nbn.initialize()\nX = np.array([[1, 2], [2, 3]])\nwith autograd.record():\n    print('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Block):\n    def __init__(self, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm()\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm(0.5)\nadd_norm.initialize()\nadd_norm(np.ones((2, 3, 4)), np.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = np.ones((2, 100, 24))\nvalid_lens = np.array([3, 2])\nencoder_blk = EncoderBlock(24, 48, 8, 0.5)\nencoder_blk.initialize()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for _ in range(num_layers):\n            self.blks.add(EncoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 48, 8, 2, 0.5)\nencoder.initialize()\nencoder(np.ones((2, 100)), valid_lens).shape\nclass DecoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(dropout)\n        self.attention2 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = np.concatenate((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if autograd.is_training():\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = np.tile(np.arange(1, num_steps + 1, ctx=X.ctx), (batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 48, 8, 0.5, 0)\ndecoder_blk.initialize()\nX = np.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add(DecoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Dense(vocab_size, flatten=False)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nenc_attention_weights = np.concatenate(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights, xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [np.array(head[0]).tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = np.array(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 670, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\ndef f(x):\n    return x * torch.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * torch.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = torch.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = torch.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = torch.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = torch.meshgrid(torch.linspace(-1.0, 1.0, 101), torch.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = torch.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [torch.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x * np.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * np.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = np.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = np.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = np.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = np.meshgrid(np.linspace(-1.0, 1.0, 101), np.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(), **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = np.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [np.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 671, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: torch.cos(np.pi * x)\nh = lambda x: torch.exp(0.5 * x)\nx, segment = torch.arange(-2, 2, 0.01), torch.tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nf = lambda x: 0.5 * x**2\ng = lambda x: np.cos(np.pi * x)\nh = lambda x: np.exp(0.5 * x)\nx, segment = np.arange(-2, 2, 0.01), np.array([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 672, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom d2l import torch as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = torch.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = np.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 673, "pytorch": "c = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = torch.meshgrid(torch.arange(-5.5, 1.0, 0.1), torch.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = torch.tensor(0.5)\ndef f(x):\n    return torch.cosh(c * x)\ndef f_grad(x):\n    return c * torch.sinh(c * x)\ndef f_hess(x):\n    return c**2 * torch.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * torch.sin(c * x) - x * c**2 * torch.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += torch.normal(0.0, 1, (1,))\n    g2 += torch.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "mxnet": "c = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = np.array(0.5)\ndef f(x):\n    return np.cosh(c * x)\ndef f_grad(x):\n    return c * np.sinh(c * x)\ndef f_hess(x):\n    return c**2 * np.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * np.sin(c * x) - x * c**2 * np.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += np.random.normal(0.0, 1, (1,))\n    g2 += np.random.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 674, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ntimer = d2l.Timer()\nA = torch.zeros(256, 256)\nB = torch.randn(256, 256)\nC = torch.randn(256, 256)\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = torch.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = torch.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = torch.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = torch.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = torch.from_numpy((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p.data.sub_(hyperparams['lr'] * p.grad)\n        p.grad.data.zero_()\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = torch.normal(mean=0.0, std=0.01, size=(feature_dim, 1), requires_grad=True)\n    b = torch.zeros((1), requires_grad=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            torch.nn.init.normal_(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.zero_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = torch.optim.SGD\ntrain_concise_ch11(trainer, {'lr': 0.01}, data_iter)", "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ntimer = d2l.Timer()\nA = np.zeros((256, 256))\nB = np.random.normal(0, 1, (256, 256))\nC = np.random.normal(0, 1, (256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = np.dot(B[i, :], C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = np.dot(B, C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nA = np.dot(B, C)\nA.wait_to_read()\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = np.dot(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p[:] -= hyperparams['lr'] * p.grad\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = np.random.normal(scale=0.01, size=(feature_dim, 1))\n    b = np.zeros(1)\n    w.attach_grad()\n    b.attach_grad()\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(tr_name, hyperparams, data_iter, num_epochs=2):\n    net = nn.Sequential()\n    net.add(nn.Dense(1))\n    net.initialize(init.Normal(sigma=0.01))\n    trainer = gluon.Trainer(net.collect_params(), tr_name, hyperparams)\n    loss = gluon.loss.L2Loss()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y)\n            l.backward()\n            trainer.step(X.shape[0])\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrain_concise_ch11('sgd', {'learning_rate': 0.05}, data_iter)"}
+{"id": 675, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = torch.zeros((feature_dim, 1))\n    v_b = torch.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        with torch.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.data.zero_()\ntrainer = torch.optim.SGD\nd2l.train_concise_ch11(trainer, {'lr': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = torch.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = np.zeros((feature_dim, 1))\n    v_b = np.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        v[:] = hyperparams['momentum'] * v + p.grad\n        p[:] -= hyperparams['lr'] * v\nd2l.train_concise_ch11('sgd', {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = np.arange(20).asnumpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 676, "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] += torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.Adagrad\nd2l.train_concise_ch11(trainer, {'lr': 0.1}, data_iter)", "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        s[:] += np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('adagrad', {'learning_rate': 0.1}, data_iter)"}
+{"id": 677, "pytorch": "import math\nimport torch\nfrom d2l import torch as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.RMSprop\nd2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9}, data_iter)", "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        s[:] = gamma * s + (1 - gamma) * np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('rmsprop', {'learning_rate': 0.01, 'gamma1': 0.9}, data_iter)"}
+{"id": 678, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    delta_w, delta_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with torch.no_grad():\n            s[:] = rho * s + (1 - rho) * torch.square(p.grad)\n            g = (torch.sqrt(delta + eps) / torch.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.data.zero_()\ntrainer = torch.optim.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    delta_w, delta_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        s[:] = rho * s + (1 - rho) * np.square(p.grad)\n        g = (np.sqrt(delta + eps) / np.sqrt(s + eps)) * p.grad\n        p[:] -= g\n        delta[:] = rho * delta + (1 - rho) * g * g\nd2l.train_concise_ch11('adadelta', {'rho': 0.9}, data_iter)"}
+{"id": 679, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adam_states(feature_dim):\n    v_w, v_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ntrainer = torch.optim.Adam\nd2l.train_concise_ch11(trainer, {'lr': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * torch.sign(torch.square(p.grad) - s) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adam_states(feature_dim):\n    v_w, v_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = beta2 * s + (1 - beta2) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\nd2l.train_concise_ch11('adam', {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = s + (1 - beta2) * np.sign(np.square(p.grad) - s) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 680, "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom torch import nn\nfrom torch.optim import lr_scheduler\nfrom d2l import torch as d2l\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    net.to(device)\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.zero_grad()\n            X, y = X.to(device), y.to(device)\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with torch.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                for param_group in trainer.param_groups:\n                    param_group['lr'] = scheduler(epoch)\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.param_groups[0][\"lr\"] = lr\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(torch.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nscheduler = lr_scheduler.MultiStepLR(trainer, milestones=[15, 30], gamma=0.5)\ndef get_lr(trainer, scheduler):\n    lr = scheduler.get_last_lr()[0]\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(torch.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)", "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, lr_scheduler, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnet = nn.HybridSequential()\nnet.add(nn.Conv2D(channels=6, kernel_size=5, padding=2, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Conv2D(channels=16, kernel_size=5, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Dense(120, activation='relu'),\n        nn.Dense(84, activation='relu'),\n        nn.Dense(10))\nnet.hybridize()\nloss = gluon.loss.SoftmaxCrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device):\n    net.initialize(force_reinit=True, ctx=device, init=init.Xavier())\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            X, y = X.as_in_ctx(device), y.as_in_ctx(device)\n            with autograd.record():\n                y_hat = net(X)\n                l = loss(y_hat, y)\n            l.backward()\n            trainer.step(X.shape[0])\n            metric.add(l.sum(), d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch + 1, (None, None, test_acc))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet.initialize(force_reinit=True, ctx=device, init=init.Xavier())\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\ntrainer.set_learning_rate(0.1)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(np.arange(50), [scheduler(t) for t in range(50)])\nscheduler = lr_scheduler.MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)"}
+{"id": 681, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef get_net():\n    net = nn.Sequential(nn.Linear(512, 256),\n            nn.ReLU(),\n            nn.Linear(256, 128),\n            nn.ReLU(),\n            nn.Linear(128, 2))\n    return net\nx = torch.randn(size=(1, 512))\nnet = get_net()\nnet(x)\nnet = torch.jit.script(net)\nnet(x)", "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef get_net():\n    net = nn.HybridSequential()\n    net.add(nn.Dense(256, activation='relu'),\n            nn.Dense(128, activation='relu'),\n            nn.Dense(2))\n    net.initialize()\n    return net\nx = np.random.normal(size=(1, 512))\nnet = get_net()\nnet(x)\nnet.hybridize()\nnet(x)"}
+{"id": 682, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass MultiHeadAttention(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = torch.repeat_interleave(valid_lens, repeats=self.num_heads, dim=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nclass MultiHeadAttention(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias_attr=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias_attr=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = paddle.repeat_interleave(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape((X.shape[0], X.shape[1], num_heads, -1))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = X.reshape((-1, num_heads, X.shape[1], X.shape[2]))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nY = paddle.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape"}
+{"id": 683, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nclass PositionalEncoding(nn.Module):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = torch.zeros((1, max_len, num_hiddens))\n        X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2, dtype=torch.float32) / num_hiddens)\n        self.P[:, :, 0::2] = torch.sin(X)\n        self.P[:, :, 1::2] = torch.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].to(X.device)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(torch.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in torch.arange(6, 10)])", "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries, valid_lens = 2, 4, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = paddle.zeros((1, max_len, num_hiddens))\n        X = paddle.arange(max_len, dtype=paddle.float32).reshape(\n            (-1, 1)) / paddle.pow(paddle.to_tensor([10000.0]), paddle.arange(\n            0, num_hiddens, 2, dtype=paddle.float32) / num_hiddens)\n        self.P[:, :, 0::2] = paddle.sin(X)\n        self.P[:, :, 1::2] = paddle.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(paddle.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(paddle.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in paddle.arange(6, 10)])"}
+{"id": 684, "pytorch": "import math\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass PositionWiseFFN(nn.Module):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(torch.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1d(2)\nX = torch.tensor([[1, 2], [2, 3]], dtype=torch.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Module):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(torch.ones((2, 3, 4)), torch.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = torch.ones((2, 100, 24))\nvalid_lens = torch.tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape\nclass DecoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = torch.cat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = torch.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nenc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = torch.tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.permute(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "paddle": "import math\nimport warnings\nimport pandas as pd\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass PositionWiseFFN(nn.Layer):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(paddle.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1D(2)\nX = paddle.to_tensor([[1, 2], [2, 3]], dtype=paddle.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(paddle.ones((2, 3, 4)), paddle.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = paddle.ones((2, 100, 24))\nvalid_lens = paddle.to_tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(paddle.ones((2, 100), dtype=paddle.int64), valid_lens).shape\nclass DecoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(\n            key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = paddle.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = paddle.arange(1, num_steps + 1).tile((batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = paddle.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nenc_attention_weights = paddle.concat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = paddle.to_tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose((1, 2, 3, 0, 4))\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 685, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\ndef f(x):\n    return x * torch.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * torch.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = torch.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = torch.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = torch.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = torch.meshgrid(torch.linspace(-1.0, 1.0, 101), torch.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = torch.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [torch.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\ndef f(x):\n    return x * paddle.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * paddle.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = paddle.arange(0.5, 1.5, 0.01, dtype='float32')\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = paddle.arange(-1.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = paddle.arange(-2.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = paddle.meshgrid(paddle.linspace(-1.0, 1.0, 101), paddle.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = paddle.arange(-2.0, 5.0, 0.01, dtype='float32')\nd2l.plot(x, [paddle.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 686, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: torch.cos(np.pi * x)\nh = lambda x: torch.exp(0.5 * x)\nx, segment = torch.arange(-2, 2, 0.01), torch.tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\nf = lambda x: 0.5 * x**2\ng = lambda x: paddle.cos(np.pi * x)\nh = lambda x: paddle.exp(0.5 * x)\nx, segment = paddle.arange(-2, 2, 0.01, dtype='float32'), paddle.to_tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 687, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom d2l import torch as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = torch.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = paddle.arange(-n, n, 0.01, dtype='float32')\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 688, "pytorch": "c = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = torch.meshgrid(torch.arange(-5.5, 1.0, 0.1), torch.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = torch.tensor(0.5)\ndef f(x):\n    return torch.cosh(c * x)\ndef f_grad(x):\n    return c * torch.sinh(c * x)\ndef f_hess(x):\n    return c**2 * torch.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * torch.sin(c * x) - x * c**2 * torch.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += torch.normal(0.0, 1, (1,))\n    g2 += torch.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "paddle": "c = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = paddle.meshgrid(paddle.arange(-5.5, 1.0, 0.1, dtype='float32'), paddle.arange(-3.0, 1.0, 0.1, dtype='float32'))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = paddle.to_tensor(0.5)\ndef f(x):\n    return paddle.cosh(c * x)\ndef f_grad(x):\n    return c * paddle.sinh(c * x)\ndef f_hess(x):\n    return c**2 * paddle.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * paddle.sin(c * x) - x * c**2 * paddle.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += paddle.normal(0.0, 1, (1,))\n    g2 += paddle.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 689, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ntimer = d2l.Timer()\nA = torch.zeros(256, 256)\nB = torch.randn(256, 256)\nC = torch.randn(256, 256)\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = torch.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = torch.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = torch.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = torch.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = torch.from_numpy((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p.data.sub_(hyperparams['lr'] * p.grad)\n        p.grad.data.zero_()\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = torch.normal(mean=0.0, std=0.01, size=(feature_dim, 1), requires_grad=True)\n    b = torch.zeros((1), requires_grad=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            torch.nn.init.normal_(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.zero_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = torch.optim.SGD\ntrain_concise_ch11(trainer, {'lr': 0.01}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom paddle import nn\ntimer = d2l.Timer()\nA = paddle.zeros((256, 256))\nB = paddle.randn((256, 256))\nC = paddle.randn((256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = paddle.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = paddle.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = paddle.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = paddle.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = paddle.to_tensor((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    a = []\n    with paddle.no_grad():\n        for p in params:\n            p = p - hyperparams['lr'] * p.grad\n            p.stop_gradient = False\n            a.append(p)\n        return a\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = paddle.to_tensor(paddle.normal(mean=0.0, std=0.01, shape=(feature_dim, 1)), stop_gradient=False)\n    b = paddle.to_tensor(paddle.zeros((1,)), stop_gradient=False)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            w, b = trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            paddle.nn.initializer.Normal(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(parameters=net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.clear_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = paddle.optimizer.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)"}
+{"id": 690, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = torch.zeros((feature_dim, 1))\n    v_b = torch.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        with torch.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.data.zero_()\ntrainer = torch.optim.SGD\nd2l.train_concise_ch11(trainer, {'lr': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = torch.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = paddle.zeros((feature_dim, 1))\n    v_b = paddle.zeros([1])\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    a = []\n    for p, v in zip(params, states):\n        with paddle.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Momentum\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = paddle.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 691, "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] += torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.Adagrad\nd2l.train_concise_ch11(trainer, {'lr': 0.1}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros(shape=(1, ))\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    a = []\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] += paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.1}, data_iter)"}
+{"id": 692, "pytorch": "import math\nimport torch\nfrom d2l import torch as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.RMSprop\nd2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9}, data_iter)", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros([1])\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    a = []\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] = gamma * s + (1 - gamma) * paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.RMSProp\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)"}
+{"id": 693, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    delta_w, delta_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with torch.no_grad():\n            s[:] = rho * s + (1 - rho) * torch.square(p.grad)\n            g = (torch.sqrt(delta + eps) / torch.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.data.zero_()\ntrainer = torch.optim.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    delta_w, delta_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    a = []\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with paddle.no_grad():\n            s[:] = rho * s + (1 - rho) * paddle.square(p.grad)\n            g = (paddle.sqrt(delta + eps) / paddle.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)"}
+{"id": 694, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adam_states(feature_dim):\n    v_w, v_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ntrainer = torch.optim.Adam\nd2l.train_concise_ch11(trainer, {'lr': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * torch.sign(torch.square(p.grad) - s) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adam_states(feature_dim):\n    v_w, v_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    s_w, s_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    a = []\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ntrainer = paddle.optimizer.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    a=[]\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * paddle.sign(paddle.square(p.grad) - s) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 695, "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom torch import nn\nfrom torch.optim import lr_scheduler\nfrom d2l import torch as d2l\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    net.to(device)\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.zero_grad()\n            X, y = X.to(device), y.to(device)\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with torch.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                for param_group in trainer.param_groups:\n                    param_group['lr'] = scheduler(epoch)\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.param_groups[0][\"lr\"] = lr\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(torch.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nscheduler = lr_scheduler.MultiStepLR(trainer, milestones=[15, 30], gamma=0.5)\ndef get_lr(trainer, scheduler):\n    lr = scheduler.get_last_lr()[0]\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(torch.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)", "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nfrom paddle.optimizer import lr as lr_scheduler\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2D(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Conv2D(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.clear_grad()\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with paddle.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat,y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                trainer.set_lr(scheduler(epoch))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.set_lr(lr)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr , parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(paddle.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\nscheduler =paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[15,30], gamma=0.5)\ntrainer = paddle.optimizer.SGD(learning_rate=scheduler, parameters=net.parameters())\ndef get_lr(trainer, scheduler):\n    lr=trainer.state_dict()['LR_Scheduler']['last_lr']\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(paddle.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)"}
+{"id": 696, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef get_net():\n    net = nn.Sequential(nn.Linear(512, 256),\n            nn.ReLU(),\n            nn.Linear(256, 128),\n            nn.ReLU(),\n            nn.Linear(128, 2))\n    return net\nx = torch.randn(size=(1, 512))\nnet = get_net()\nnet(x)\nnet = torch.jit.script(net)\nnet(x)", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nfrom paddle.jit import to_static\nfrom paddle.static import InputSpec\ndef get_net():\n    blocks = [\n        nn.Linear(512, 256),\n        nn.ReLU(),\n        nn.Linear(256, 128),\n        nn.ReLU(),\n        nn.Linear(128, 2)\n    ]\n    net = nn.Sequential(*blocks)\n    return net\nx = paddle.randn((1, 512))\nnet = get_net()\nnet(x)\nnet = paddle.jit.to_static(net)\nnet(x)"}
+{"id": 697, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass MultiHeadAttention(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = torch.repeat_interleave(valid_lens, repeats=self.num_heads, dim=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass MultiHeadAttention(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_v = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_o = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n    def call(self, queries, keys, values, valid_lens, **kwargs):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = tf.repeat(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens, **kwargs)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = tf.reshape(X, shape=(X.shape[0], X.shape[1], num_heads, -1))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = tf.reshape(X, shape=(-1, num_heads, X.shape[1], X.shape[2]))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens = 6, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nY = tf.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens, training=False).shape"}
+{"id": 698, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nclass PositionalEncoding(nn.Module):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = torch.zeros((1, max_len, num_hiddens))\n        X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2, dtype=torch.float32) / num_hiddens)\n        self.P[:, :, 0::2] = torch.sin(X)\n        self.P[:, :, 1::2] = torch.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].to(X.device)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(torch.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in torch.arange(6, 10)])\nP = P[0, :, :].unsqueeze(0).unsqueeze(0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "tensorflow": "import numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries, valid_lens = 2, 4, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens, training=False).shape\nclass PositionalEncoding(tf.keras.layers.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super().__init__()\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len, dtype=np.float32).reshape(-1,1)/np.power(10000, np.arange(0, num_hiddens, 2, dtype=np.float32) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def call(self, X, **kwargs):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X, **kwargs)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\nX = pos_encoding(tf.zeros((1, num_steps, encoding_dim)), training=False)\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = tf.expand_dims(tf.expand_dims(P[0, :, :], axis=0), axis=0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 699, "pytorch": "import math\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass PositionWiseFFN(nn.Module):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(torch.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1d(2)\nX = torch.tensor([[1, 2], [2, 3]], dtype=torch.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Module):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(torch.ones((2, 3, 4)), torch.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = torch.ones((2, 100, 24))\nvalid_lens = torch.tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape\nclass DecoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = torch.cat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = torch.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [32]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = torch.tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.permute(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "tensorflow": "import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass PositionWiseFFN(tf.keras.layers.Layer):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super().__init__(*kwargs)\n        self.dense1 = tf.keras.layers.Dense(ffn_num_hiddens)\n        self.relu = tf.keras.layers.ReLU()\n        self.dense2 = tf.keras.layers.Dense(ffn_num_outputs)\n    def call(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 8)\nffn(tf.ones((2, 3, 4)))[0]\nln = tf.keras.layers.LayerNormalization()\nbn = tf.keras.layers.BatchNormalization()\nX = tf.constant([[1, 2], [2, 3]], dtype=tf.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(tf.keras.layers.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.ln = tf.keras.layers.LayerNormalization(normalized_shape)\n    def call(self, X, Y, **kwargs):\n        return self.ln(self.dropout(Y, **kwargs) + X)\nadd_norm = AddNorm([1, 2], 0.5)\nadd_norm(tf.ones((2, 3, 4)), tf.ones((2, 3, 4)), training=False).shape\nclass EncoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def call(self, X, valid_lens, **kwargs):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens, **kwargs), **kwargs)\n        return self.addnorm2(Y, self.ffn(Y), **kwargs)\nX = tf.ones((2, 100, 24))\nvalid_lens = tf.constant([3, 2])\nnorm_shape = [i for i in range(len(X.shape))][1:]\nencoder_blk = EncoderBlock(24, 24, 24, 24, norm_shape, 48, 8, 0.5)\nencoder_blk(X, valid_lens, training=False).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias) for _ in range(num_layers)]\n    def call(self, X, valid_lens, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens, **kwargs)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [1, 2], 48, 8, 2, 0.5)\nencoder(tf.ones((2, 100)), valid_lens, training=False).shape\nclass DecoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super().__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def call(self, X, state, **kwargs):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = tf.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if kwargs[\"training\"]:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = tf.repeat(tf.reshape(tf.range(1, num_steps + 1), shape=(-1, num_steps)), repeats=batch_size, axis=0)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens, **kwargs)\n        Y = self.addnorm1(X, X2, **kwargs)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n        Z = self.addnorm2(Y, Y2, **kwargs)\n        return self.addnorm3(Z, self.ffn(Z), **kwargs), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [1, 2], 48, 8, 0.5, 0)\nX = tf.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state, training=False)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hidens, num_heads, num_layers, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i) for i in range(num_layers)]\n        self.dense = tf.keras.layers.Dense(vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def call(self, X, state, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self._attention_weights = [[None] * len(self.blks) for _ in range(2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state, **kwargs)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [2]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = tf.reshape(tf.concat(net.encoder.attention_weights, 0), (num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights, xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0] for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = tf.convert_to_tensor(np.asarray(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values).astype(np.float32))\ndec_attention_weights = tf.reshape(dec_attention_weights_filled, shape=(-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = tf.transpose(dec_attention_weights, perm=(1, 2, 3, 0, 4))"}
+{"id": 700, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\ndef f(x):\n    return x * torch.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * torch.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = torch.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = torch.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = torch.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = torch.meshgrid(torch.linspace(-1.0, 1.0, 101), torch.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = torch.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [torch.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x * tf.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * tf.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = tf.range(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = tf.range(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = tf.range(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = tf.meshgrid(tf.linspace(-1.0, 1.0, 101), tf.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = tf.range(-2.0, 5.0, 0.01)\nd2l.plot(x, [tf.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 701, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: torch.cos(np.pi * x)\nh = lambda x: torch.exp(0.5 * x)\nx, segment = torch.arange(-2, 2, 0.01), torch.tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: tf.cos(np.pi * x)\nh = lambda x: tf.exp(0.5 * x)\nx, segment = tf.range(-2, 2, 0.01), tf.constant([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 702, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom d2l import torch as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = torch.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = tf.range(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 703, "pytorch": "c = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = torch.meshgrid(torch.arange(-5.5, 1.0, 0.1), torch.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = torch.tensor(0.5)\ndef f(x):\n    return torch.cosh(c * x)\ndef f_grad(x):\n    return c * torch.sinh(c * x)\ndef f_hess(x):\n    return c**2 * torch.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * torch.sin(c * x) - x * c**2 * torch.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += torch.normal(0.0, 1, (1,))\n    g2 += torch.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "tensorflow": "c = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = tf.meshgrid(tf.range(-5.5, 1.0, 0.1), tf.range(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = tf.constant(0.5)\ndef f(x):\n    return tf.cosh(c * x)\ndef f_grad(x):\n    return c * tf.sinh(c * x)\ndef f_hess(x):\n    return c**2 * tf.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * tf.sin(c * x) - x * c**2 * tf.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += tf.random.normal([1], 0.0, 1)\n    g2 += tf.random.normal([1], 0.0, 1)\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 704, "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ntimer = d2l.Timer()\nA = torch.zeros(256, 256)\nB = torch.randn(256, 256)\nC = torch.randn(256, 256)\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = torch.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = torch.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = torch.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = torch.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = torch.from_numpy((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p.data.sub_(hyperparams['lr'] * p.grad)\n        p.grad.data.zero_()\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = torch.normal(mean=0.0, std=0.01, size=(feature_dim, 1), requires_grad=True)\n    b = torch.zeros((1), requires_grad=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            torch.nn.init.normal_(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.zero_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = torch.optim.SGD\ntrain_concise_ch11(trainer, {'lr': 0.01}, data_iter)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ntimer = d2l.Timer()\nA = tf.Variable(tf.zeros((256, 256)))\nB = tf.Variable(tf.random.normal([256, 256], 0, 1))\nC = tf.Variable(tf.random.normal([256, 256], 0, 1))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j].assign(tf.tensordot(B[i, :], C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j].assign(tf.tensordot(B, C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nA.assign(tf.tensordot(B, C, axes=1))\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64].assign(tf.tensordot(B, C[:, j:j+64], axes=1))\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, grads, states, hyperparams):\n    for param, grad in zip(params, grads):\n        param.assign_sub(hyperparams['lr']*grad)\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = tf.Variable(tf.random.normal(shape=(feature_dim, 1), mean=0, stddev=0.01),trainable=True)\n    b = tf.Variable(tf.zeros(1), trainable=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n            l = tf.math.reduce_mean(loss(net(X), y))\n            dw, db = g.gradient(l, [w, b])\n            trainer_fn([w, b], [dw, db], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss),)\n                animator.add(q, r)\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=2):\n    net = tf.keras.Sequential()\n    net.add(tf.keras.layers.Dense(1, kernel_initializer=tf.random_normal_initializer(stddev=0.01)))\n    optimizer = trainer_fn(**hyperparams)\n    loss = tf.keras.losses.MeanSquaredError()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n                out = net(X)\n                l = loss(y, out)\n                params = net.trainable_variables\n                grads = g.gradient(l, params)\n            optimizer.apply_gradients(zip(grads, params))\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss) / 2,)\n                animator.add(q, r)\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = tf.keras.optimizers.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.05}, data_iter)"}
+{"id": 705, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = torch.zeros((feature_dim, 1))\n    v_b = torch.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        with torch.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.data.zero_()\ntrainer = torch.optim.SGD\nd2l.train_concise_ch11(trainer, {'lr': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = torch.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(features_dim):\n    v_w = tf.Variable(tf.zeros((features_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    return (v_w, v_b)\ndef sgd_momentum(params, grads, states, hyperparams):\n    for p, v, g in zip(params, states, grads):\n        v[:].assign(hyperparams['momentum'] * v + g)\n        p[:].assign(p - hyperparams['lr'] * v)\ntrainer = tf.keras.optimizers.SGD\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = tf.range(20).numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 706, "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] += torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.Adagrad\nd2l.train_concise_ch11(trainer, {'lr': 0.1}, data_iter)", "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef adagrad(params, grads, states, hyperparams):\n    eps = 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(s + tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate' : 0.1}, data_iter)"}
+{"id": 707, "pytorch": "import math\nimport torch\nfrom d2l import torch as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.RMSprop\nd2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9}, data_iter)", "tensorflow": "import math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef rmsprop(params, grads, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(gamma * s + (1 - gamma) * tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.RMSprop\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)"}
+{"id": 708, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    delta_w, delta_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with torch.no_grad():\n            s[:] = rho * s + (1 - rho) * torch.square(p.grad)\n            g = (torch.sqrt(delta + eps) / torch.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.data.zero_()\ntrainer = torch.optim.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adadelta_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    delta_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    delta_b = tf.Variable(tf.zeros(1))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, grads, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta), grad in zip(params, states, grads):\n        s[:].assign(rho * s + (1 - rho) * tf.math.square(grad))\n        g = (tf.math.sqrt(delta + eps) / tf.math.sqrt(s + eps)) * grad\n        p[:].assign(p - g)\n        delta[:].assign(rho * delta + (1 - rho) * g * g)\ntrainer = tf.keras.optimizers.Adadelta\nd2l.train_concise_ch11(trainer, {'learning_rate':5.0, 'rho': 0.9}, data_iter)"}
+{"id": 709, "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adam_states(feature_dim):\n    v_w, v_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ntrainer = torch.optim.Adam\nd2l.train_concise_ch11(trainer, {'lr': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * torch.sign(torch.square(p.grad) - s) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adam_states(feature_dim):\n    v_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(beta2 * s + (1 - beta2) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\ntrainer = tf.keras.optimizers.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(s + (1 - beta2) * tf.math.sign(tf.math.square(grad) - s) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 710, "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom torch import nn\nfrom torch.optim import lr_scheduler\nfrom d2l import torch as d2l\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    net.to(device)\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.zero_grad()\n            X, y = X.to(device), y.to(device)\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with torch.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                for param_group in trainer.param_groups:\n                    param_group['lr'] = scheduler(epoch)\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.param_groups[0][\"lr\"] = lr\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(torch.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nscheduler = lr_scheduler.MultiStepLR(trainer, milestones=[15, 30], gamma=0.5)\ndef get_lr(trainer, scheduler):\n    lr = scheduler.get_last_lr()[0]\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(torch.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)", "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom tensorflow.keras.callbacks import LearningRateScheduler\nfrom d2l import tensorflow as d2l\ndef net():\n    return tf.keras.models.Sequential([\n        tf.keras.layers.Conv2D(filters=6, kernel_size=5, activation='relu', padding='same'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Conv2D(filters=16, kernel_size=5, activation='relu'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Flatten(),\n        tf.keras.layers.Dense(120, activation='relu'),\n        tf.keras.layers.Dense(84, activation='sigmoid'),\n        tf.keras.layers.Dense(10)])\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net_fn, train_iter, test_iter, num_epochs, lr, device=d2l.try_gpu(), custom_callback = False):\n    device_name = device._device_name\n    strategy = tf.distribute.OneDeviceStrategy(device_name)\n    with strategy.scope():\n        optimizer = tf.keras.optimizers.SGD(learning_rate=lr)\n        loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n        net = net_fn()\n        net.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n    callback = d2l.TrainCallback(net, train_iter, test_iter, num_epochs, device_name)\n    if custom_callback is False:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback])\n    else:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback, custom_callback])\n    return net\nlr, num_epochs = 0.3, 30\ntrain(net, train_iter, test_iter, num_epochs, lr)\nlr = 0.1\ndummy_model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)])\ndummy_model.compile(tf.keras.optimizers.SGD(learning_rate=lr), loss='mse')\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(tf.range(50), [scheduler(t) for t in range(50)])\nclass MultiFactorScheduler:\n    def __init__(self, step, factor, base_lr):\n        self.step = step\n        self.factor = factor\n        self.base_lr = base_lr\n    def __call__(self, epoch):\n        if epoch in self.step:\n            self.base_lr = self.base_lr * self.factor\n            return self.base_lr\n        else:\n            return self.base_lr\nscheduler = MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))"}
+{"id": 711, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef get_net():\n    net = nn.Sequential(nn.Linear(512, 256),\n            nn.ReLU(),\n            nn.Linear(256, 128),\n            nn.ReLU(),\n            nn.Linear(128, 2))\n    return net\nx = torch.randn(size=(1, 512))\nnet = get_net()\nnet(x)\nnet = torch.jit.script(net)\nnet(x)", "tensorflow": "import tensorflow as tf\nfrom tensorflow.keras.layers import Dense\nfrom d2l import tensorflow as d2l\ndef get_net():\n    net = tf.keras.Sequential()\n    net.add(Dense(256, input_shape = (512,), activation = \"relu\"))\n    net.add(Dense(128, activation = \"relu\"))\n    net.add(Dense(2, activation = \"linear\"))\n    return net\nx = tf.random.normal([1,512])\nnet = get_net()\nnet(x)\nnet = tf.function(net)\nnet(x)"}
+{"id": 712, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass MultiHeadAttention(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_v = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_o = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n    def call(self, queries, keys, values, valid_lens, **kwargs):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = tf.repeat(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens, **kwargs)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = tf.reshape(X, shape=(X.shape[0], X.shape[1], num_heads, -1))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = tf.reshape(X, shape=(-1, num_heads, X.shape[1], X.shape[2]))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens = 6, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nY = tf.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens, training=False).shape", "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass MultiHeadAttention(nn.Block):\n    def __init__(self, num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_k = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_v = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_o = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = valid_lens.repeat(self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nY = np.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape"}
+{"id": 713, "tensorflow": "import numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries, valid_lens = 2, 4, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens, training=False).shape\nclass PositionalEncoding(tf.keras.layers.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super().__init__()\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len, dtype=np.float32).reshape(-1,1)/np.power(10000, np.arange(0, num_hiddens, 2, dtype=np.float32) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def call(self, X, **kwargs):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X, **kwargs)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\nX = pos_encoding(tf.zeros((1, num_steps, encoding_dim)), training=False)\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = tf.expand_dims(tf.expand_dims(P[0, :, :], axis=0), axis=0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries, valid_lens = 2, 4, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Block):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len).reshape(-1, 1) / np.power(10000, np.arange(0, num_hiddens, 2) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].as_in_ctx(X.ctx)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.initialize()\nX = pos_encoding(np.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = np.expand_dims(np.expand_dims(P[0, :, :], 0), 0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 714, "tensorflow": "import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass PositionWiseFFN(tf.keras.layers.Layer):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super().__init__(*kwargs)\n        self.dense1 = tf.keras.layers.Dense(ffn_num_hiddens)\n        self.relu = tf.keras.layers.ReLU()\n        self.dense2 = tf.keras.layers.Dense(ffn_num_outputs)\n    def call(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 8)\nffn(tf.ones((2, 3, 4)))[0]\nln = tf.keras.layers.LayerNormalization()\nbn = tf.keras.layers.BatchNormalization()\nX = tf.constant([[1, 2], [2, 3]], dtype=tf.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(tf.keras.layers.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.ln = tf.keras.layers.LayerNormalization(normalized_shape)\n    def call(self, X, Y, **kwargs):\n        return self.ln(self.dropout(Y, **kwargs) + X)\nadd_norm = AddNorm([1, 2], 0.5)\nadd_norm(tf.ones((2, 3, 4)), tf.ones((2, 3, 4)), training=False).shape\nclass EncoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def call(self, X, valid_lens, **kwargs):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens, **kwargs), **kwargs)\n        return self.addnorm2(Y, self.ffn(Y), **kwargs)\nX = tf.ones((2, 100, 24))\nvalid_lens = tf.constant([3, 2])\nnorm_shape = [i for i in range(len(X.shape))][1:]\nencoder_blk = EncoderBlock(24, 24, 24, 24, norm_shape, 48, 8, 0.5)\nencoder_blk(X, valid_lens, training=False).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias) for _ in range(num_layers)]\n    def call(self, X, valid_lens, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens, **kwargs)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [1, 2], 48, 8, 2, 0.5)\nencoder(tf.ones((2, 100)), valid_lens, training=False).shape\nclass DecoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super().__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def call(self, X, state, **kwargs):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = tf.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if kwargs[\"training\"]:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = tf.repeat(tf.reshape(tf.range(1, num_steps + 1), shape=(-1, num_steps)), repeats=batch_size, axis=0)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens, **kwargs)\n        Y = self.addnorm1(X, X2, **kwargs)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n        Z = self.addnorm2(Y, Y2, **kwargs)\n        return self.addnorm3(Z, self.ffn(Z), **kwargs), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [1, 2], 48, 8, 0.5, 0)\nX = tf.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state, training=False)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hidens, num_heads, num_layers, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i) for i in range(num_layers)]\n        self.dense = tf.keras.layers.Dense(vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def call(self, X, state, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self._attention_weights = [[None] * len(self.blks) for _ in range(2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state, **kwargs)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [2]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = tf.reshape(tf.concat(net.encoder.attention_weights, 0), (num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\ndec_attention_weights_2d = [head[0] for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = tf.convert_to_tensor(np.asarray(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values).astype(np.float32))\ndec_attention_weights = tf.reshape(dec_attention_weights_filled, shape=(-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = tf.transpose(dec_attention_weights, perm=(1, 2, 3, 0, 4))", "mxnet": "import math\nimport pandas as pd\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass PositionWiseFFN(nn.Block):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Dense(ffn_num_hiddens, flatten=False, activation='relu')\n        self.dense2 = nn.Dense(ffn_num_outputs, flatten=False)\n    def forward(self, X):\n        return self.dense2(self.dense1(X))\nffn = PositionWiseFFN(4, 8)\nffn.initialize()\nffn(np.ones((2, 3, 4)))[0]\nln = nn.LayerNorm()\nln.initialize()\nbn = nn.BatchNorm()\nbn.initialize()\nX = np.array([[1, 2], [2, 3]])\nwith autograd.record():\n    print('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Block):\n    def __init__(self, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm()\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm(0.5)\nadd_norm.initialize()\nadd_norm(np.ones((2, 3, 4)), np.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = np.ones((2, 100, 24))\nvalid_lens = np.array([3, 2])\nencoder_blk = EncoderBlock(24, 48, 8, 0.5)\nencoder_blk.initialize()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for _ in range(num_layers):\n            self.blks.add(EncoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 48, 8, 2, 0.5)\nencoder.initialize()\nencoder(np.ones((2, 100)), valid_lens).shape\nclass DecoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(dropout)\n        self.attention2 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = np.concatenate((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if autograd.is_training():\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = np.tile(np.arange(1, num_steps + 1, ctx=X.ctx), (batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 48, 8, 0.5, 0)\ndecoder_blk.initialize()\nX = np.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add(DecoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Dense(vocab_size, flatten=False)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = np.concatenate(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\ndec_attention_weights_2d = [np.array(head[0]).tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = np.array(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 715, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x * tf.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * tf.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = tf.range(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = tf.range(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = tf.range(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = tf.meshgrid(tf.linspace(-1.0, 1.0, 101), tf.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = tf.range(-2.0, 5.0, 0.01)\nd2l.plot(x, [tf.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x * np.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * np.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = np.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = np.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = np.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = np.meshgrid(np.linspace(-1.0, 1.0, 101), np.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(), **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = np.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [np.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 716, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: tf.cos(np.pi * x)\nh = lambda x: tf.exp(0.5 * x)\nx, segment = tf.range(-2, 2, 0.01), tf.constant([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nf = lambda x: 0.5 * x**2\ng = lambda x: np.cos(np.pi * x)\nh = lambda x: np.exp(0.5 * x)\nx, segment = np.arange(-2, 2, 0.01), np.array([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 717, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = tf.range(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = np.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 718, "tensorflow": "c = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = tf.meshgrid(tf.range(-5.5, 1.0, 0.1), tf.range(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = tf.constant(0.5)\ndef f(x):\n    return tf.cosh(c * x)\ndef f_grad(x):\n    return c * tf.sinh(c * x)\ndef f_hess(x):\n    return c**2 * tf.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * tf.sin(c * x) - x * c**2 * tf.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += tf.random.normal([1], 0.0, 1)\n    g2 += tf.random.normal([1], 0.0, 1)\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "mxnet": "c = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = np.array(0.5)\ndef f(x):\n    return np.cosh(c * x)\ndef f_grad(x):\n    return c * np.sinh(c * x)\ndef f_hess(x):\n    return c**2 * np.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * np.sin(c * x) - x * c**2 * np.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += np.random.normal(0.0, 1, (1,))\n    g2 += np.random.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 719, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ntimer = d2l.Timer()\nA = tf.Variable(tf.zeros((256, 256)))\nB = tf.Variable(tf.random.normal([256, 256], 0, 1))\nC = tf.Variable(tf.random.normal([256, 256], 0, 1))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j].assign(tf.tensordot(B[i, :], C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j].assign(tf.tensordot(B, C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nA.assign(tf.tensordot(B, C, axes=1))\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64].assign(tf.tensordot(B, C[:, j:j+64], axes=1))\ntimer.stop()\ndef sgd(params, grads, states, hyperparams):\n    for param, grad in zip(params, grads):\n        param.assign_sub(hyperparams['lr']*grad)\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = tf.Variable(tf.random.normal(shape=(feature_dim, 1), mean=0, stddev=0.01),trainable=True)\n    b = tf.Variable(tf.zeros(1), trainable=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n            l = tf.math.reduce_mean(loss(net(X), y))\n            dw, db = g.gradient(l, [w, b])\n            trainer_fn([w, b], [dw, db], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss),)\n                animator.add(q, r)\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=2):\n    net = tf.keras.Sequential()\n    net.add(tf.keras.layers.Dense(1, kernel_initializer=tf.random_normal_initializer(stddev=0.01)))\n    optimizer = trainer_fn(**hyperparams)\n    loss = tf.keras.losses.MeanSquaredError()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n                out = net(X)\n                l = loss(y, out)\n                params = net.trainable_variables\n                grads = g.gradient(l, params)\n            optimizer.apply_gradients(zip(grads, params))\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss) / 2,)\n                animator.add(q, r)\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = tf.keras.optimizers.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.05}, data_iter)", "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ntimer = d2l.Timer()\nA = np.zeros((256, 256))\nB = np.random.normal(0, 1, (256, 256))\nC = np.random.normal(0, 1, (256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = np.dot(B[i, :], C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = np.dot(B, C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nA = np.dot(B, C)\nA.wait_to_read()\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = np.dot(B, C[:, j:j+64])\ntimer.stop()\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p[:] -= hyperparams['lr'] * p.grad\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = np.random.normal(scale=0.01, size=(feature_dim, 1))\n    b = np.zeros(1)\n    w.attach_grad()\n    b.attach_grad()\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(tr_name, hyperparams, data_iter, num_epochs=2):\n    net = nn.Sequential()\n    net.add(nn.Dense(1))\n    net.initialize(init.Normal(sigma=0.01))\n    trainer = gluon.Trainer(net.collect_params(), tr_name, hyperparams)\n    loss = gluon.loss.L2Loss()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y)\n            l.backward()\n            trainer.step(X.shape[0])\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrain_concise_ch11('sgd', {'learning_rate': 0.05}, data_iter)"}
+{"id": 720, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(features_dim):\n    v_w = tf.Variable(tf.zeros((features_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    return (v_w, v_b)\ndef sgd_momentum(params, grads, states, hyperparams):\n    for p, v, g in zip(params, states, grads):\n        v[:].assign(hyperparams['momentum'] * v + g)\n        p[:].assign(p - hyperparams['lr'] * v)\ntrainer = tf.keras.optimizers.SGD\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = tf.range(20).numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = np.zeros((feature_dim, 1))\n    v_b = np.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        v[:] = hyperparams['momentum'] * v + p.grad\n        p[:] -= hyperparams['lr'] * v\nd2l.train_concise_ch11('sgd', {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = np.arange(20).asnumpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 721, "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef adagrad(params, grads, states, hyperparams):\n    eps = 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(s + tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate' : 0.1}, data_iter)", "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        s[:] += np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('adagrad', {'learning_rate': 0.1}, data_iter)"}
+{"id": 722, "tensorflow": "import math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef rmsprop(params, grads, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(gamma * s + (1 - gamma) * tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.RMSprop\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)", "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        s[:] = gamma * s + (1 - gamma) * np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('rmsprop', {'learning_rate': 0.01, 'gamma1': 0.9}, data_iter)"}
+{"id": 723, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adadelta_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    delta_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    delta_b = tf.Variable(tf.zeros(1))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, grads, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta), grad in zip(params, states, grads):\n        s[:].assign(rho * s + (1 - rho) * tf.math.square(grad))\n        g = (tf.math.sqrt(delta + eps) / tf.math.sqrt(s + eps)) * grad\n        p[:].assign(p - g)\n        delta[:].assign(rho * delta + (1 - rho) * g * g)\ntrainer = tf.keras.optimizers.Adadelta\nd2l.train_concise_ch11(trainer, {'learning_rate':5.0, 'rho': 0.9}, data_iter)", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    delta_w, delta_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        s[:] = rho * s + (1 - rho) * np.square(p.grad)\n        g = (np.sqrt(delta + eps) / np.sqrt(s + eps)) * p.grad\n        p[:] -= g\n        delta[:] = rho * delta + (1 - rho) * g * g\nd2l.train_concise_ch11('adadelta', {'rho': 0.9}, data_iter)"}
+{"id": 724, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adam_states(feature_dim):\n    v_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(beta2 * s + (1 - beta2) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\ntrainer = tf.keras.optimizers.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(s + (1 - beta2) * tf.math.sign(tf.math.square(grad) - s) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adam_states(feature_dim):\n    v_w, v_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = beta2 * s + (1 - beta2) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\nd2l.train_concise_ch11('adam', {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = s + (1 - beta2) * np.sign(np.square(p.grad) - s) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 725, "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom tensorflow.keras.callbacks import LearningRateScheduler\nfrom d2l import tensorflow as d2l\ndef net():\n    return tf.keras.models.Sequential([\n        tf.keras.layers.Conv2D(filters=6, kernel_size=5, activation='relu', padding='same'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Conv2D(filters=16, kernel_size=5, activation='relu'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Flatten(),\n        tf.keras.layers.Dense(120, activation='relu'),\n        tf.keras.layers.Dense(84, activation='sigmoid'),\n        tf.keras.layers.Dense(10)])\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net_fn, train_iter, test_iter, num_epochs, lr, device=d2l.try_gpu(), custom_callback = False):\n    device_name = device._device_name\n    strategy = tf.distribute.OneDeviceStrategy(device_name)\n    with strategy.scope():\n        optimizer = tf.keras.optimizers.SGD(learning_rate=lr)\n        loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n        net = net_fn()\n        net.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n    callback = d2l.TrainCallback(net, train_iter, test_iter, num_epochs, device_name)\n    if custom_callback is False:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback])\n    else:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback, custom_callback])\n    return net\nlr, num_epochs = 0.3, 30\ntrain(net, train_iter, test_iter, num_epochs, lr)\nlr = 0.1\ndummy_model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)])\ndummy_model.compile(tf.keras.optimizers.SGD(learning_rate=lr), loss='mse')\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(tf.range(50), [scheduler(t) for t in range(50)])\nclass MultiFactorScheduler:\n    def __init__(self, step, factor, base_lr):\n        self.step = step\n        self.factor = factor\n        self.base_lr = base_lr\n    def __call__(self, epoch):\n        if epoch in self.step:\n            self.base_lr = self.base_lr * self.factor\n            return self.base_lr\n        else:\n            return self.base_lr\nscheduler = MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))", "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, lr_scheduler, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnet = nn.HybridSequential()\nnet.add(nn.Conv2D(channels=6, kernel_size=5, padding=2, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Conv2D(channels=16, kernel_size=5, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Dense(120, activation='relu'),\n        nn.Dense(84, activation='relu'),\n        nn.Dense(10))\nnet.hybridize()\nloss = gluon.loss.SoftmaxCrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device):\n    net.initialize(force_reinit=True, ctx=device, init=init.Xavier())\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            X, y = X.as_in_ctx(device), y.as_in_ctx(device)\n            with autograd.record():\n                y_hat = net(X)\n                l = loss(y_hat, y)\n            l.backward()\n            trainer.step(X.shape[0])\n            metric.add(l.sum(), d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch + 1, (None, None, test_acc))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet.initialize(force_reinit=True, ctx=device, init=init.Xavier())\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\ntrainer.set_learning_rate(0.1)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(np.arange(50), [scheduler(t) for t in range(50)])\nscheduler = lr_scheduler.MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)"}
+{"id": 726, "tensorflow": "import tensorflow as tf\nfrom tensorflow.keras.layers import Dense\nfrom d2l import tensorflow as d2l\ndef get_net():\n    net = tf.keras.Sequential()\n    net.add(Dense(256, input_shape = (512,), activation = \"relu\"))\n    net.add(Dense(128, activation = \"relu\"))\n    net.add(Dense(2, activation = \"linear\"))\n    return net\nx = tf.random.normal([1,512])\nnet = get_net()\nnet(x)\nnet = tf.function(net)\nnet(x)", "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef get_net():\n    net = nn.HybridSequential()\n    net.add(nn.Dense(256, activation='relu'),\n            nn.Dense(128, activation='relu'),\n            nn.Dense(2))\n    net.initialize()\n    return net\nx = np.random.normal(size=(1, 512))\nnet = get_net()\nnet(x)\nnet.hybridize()\nnet(x)"}
+{"id": 727, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nclass MultiHeadAttention(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias_attr=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias_attr=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = paddle.repeat_interleave(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape((X.shape[0], X.shape[1], num_heads, -1))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = X.reshape((-1, num_heads, X.shape[1], X.shape[2]))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nY = paddle.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass MultiHeadAttention(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_v = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_o = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n    def call(self, queries, keys, values, valid_lens, **kwargs):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = tf.repeat(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens, **kwargs)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = tf.reshape(X, shape=(X.shape[0], X.shape[1], num_heads, -1))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = tf.reshape(X, shape=(-1, num_heads, X.shape[1], X.shape[2]))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens = 6, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nY = tf.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens, training=False).shape"}
+{"id": 728, "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries, valid_lens = 2, 4, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = paddle.zeros((1, max_len, num_hiddens))\n        X = paddle.arange(max_len, dtype=paddle.float32).reshape(\n            (-1, 1)) / paddle.pow(paddle.to_tensor([10000.0]), paddle.arange(\n            0, num_hiddens, 2, dtype=paddle.float32) / num_hiddens)\n        self.P[:, :, 0::2] = paddle.sin(X)\n        self.P[:, :, 1::2] = paddle.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(paddle.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(paddle.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in paddle.arange(6, 10)])\nP = P[0, :, :].unsqueeze(0).unsqueeze(0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "tensorflow": "import numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries, valid_lens = 2, 4, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens, training=False).shape\nclass PositionalEncoding(tf.keras.layers.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super().__init__()\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len, dtype=np.float32).reshape(-1,1)/np.power(10000, np.arange(0, num_hiddens, 2, dtype=np.float32) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def call(self, X, **kwargs):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X, **kwargs)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\nX = pos_encoding(tf.zeros((1, num_steps, encoding_dim)), training=False)\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = tf.expand_dims(tf.expand_dims(P[0, :, :], axis=0), axis=0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 729, "paddle": "import math\nimport warnings\nimport pandas as pd\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass PositionWiseFFN(nn.Layer):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(paddle.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1D(2)\nX = paddle.to_tensor([[1, 2], [2, 3]], dtype=paddle.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(paddle.ones((2, 3, 4)), paddle.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = paddle.ones((2, 100, 24))\nvalid_lens = paddle.to_tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(paddle.ones((2, 100), dtype=paddle.int64), valid_lens).shape\nclass DecoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(\n            key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = paddle.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = paddle.arange(1, num_steps + 1).tile((batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = paddle.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [32]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = paddle.concat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = paddle.to_tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose((1, 2, 3, 0, 4))\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "tensorflow": "import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass PositionWiseFFN(tf.keras.layers.Layer):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super().__init__(*kwargs)\n        self.dense1 = tf.keras.layers.Dense(ffn_num_hiddens)\n        self.relu = tf.keras.layers.ReLU()\n        self.dense2 = tf.keras.layers.Dense(ffn_num_outputs)\n    def call(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 8)\nffn(tf.ones((2, 3, 4)))[0]\nln = tf.keras.layers.LayerNormalization()\nbn = tf.keras.layers.BatchNormalization()\nX = tf.constant([[1, 2], [2, 3]], dtype=tf.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(tf.keras.layers.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.ln = tf.keras.layers.LayerNormalization(normalized_shape)\n    def call(self, X, Y, **kwargs):\n        return self.ln(self.dropout(Y, **kwargs) + X)\nadd_norm = AddNorm([1, 2], 0.5)\nadd_norm(tf.ones((2, 3, 4)), tf.ones((2, 3, 4)), training=False).shape\nclass EncoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def call(self, X, valid_lens, **kwargs):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens, **kwargs), **kwargs)\n        return self.addnorm2(Y, self.ffn(Y), **kwargs)\nX = tf.ones((2, 100, 24))\nvalid_lens = tf.constant([3, 2])\nnorm_shape = [i for i in range(len(X.shape))][1:]\nencoder_blk = EncoderBlock(24, 24, 24, 24, norm_shape, 48, 8, 0.5)\nencoder_blk(X, valid_lens, training=False).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias) for _ in range(num_layers)]\n    def call(self, X, valid_lens, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens, **kwargs)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [1, 2], 48, 8, 2, 0.5)\nencoder(tf.ones((2, 100)), valid_lens, training=False).shape\nclass DecoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super().__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def call(self, X, state, **kwargs):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = tf.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if kwargs[\"training\"]:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = tf.repeat(tf.reshape(tf.range(1, num_steps + 1), shape=(-1, num_steps)), repeats=batch_size, axis=0)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens, **kwargs)\n        Y = self.addnorm1(X, X2, **kwargs)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n        Z = self.addnorm2(Y, Y2, **kwargs)\n        return self.addnorm3(Z, self.ffn(Z), **kwargs), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [1, 2], 48, 8, 0.5, 0)\nX = tf.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state, training=False)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hidens, num_heads, num_layers, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i) for i in range(num_layers)]\n        self.dense = tf.keras.layers.Dense(vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def call(self, X, state, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self._attention_weights = [[None] * len(self.blks) for _ in range(2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state, **kwargs)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [2]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = tf.reshape(tf.concat(net.encoder.attention_weights, 0), (num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights, xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0] for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = tf.convert_to_tensor(np.asarray(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values).astype(np.float32))\ndec_attention_weights = tf.reshape(dec_attention_weights_filled, shape=(-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = tf.transpose(dec_attention_weights, perm=(1, 2, 3, 0, 4))"}
+{"id": 730, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\ndef f(x):\n    return x * paddle.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * paddle.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = paddle.arange(0.5, 1.5, 0.01, dtype='float32')\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = paddle.arange(-1.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = paddle.arange(-2.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = paddle.meshgrid(paddle.linspace(-1.0, 1.0, 101), paddle.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = paddle.arange(-2.0, 5.0, 0.01, dtype='float32')\nd2l.plot(x, [paddle.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x * tf.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * tf.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = tf.range(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = tf.range(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = tf.range(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = tf.meshgrid(tf.linspace(-1.0, 1.0, 101), tf.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = tf.range(-2.0, 5.0, 0.01)\nd2l.plot(x, [tf.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 731, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\nf = lambda x: 0.5 * x**2\ng = lambda x: paddle.cos(np.pi * x)\nh = lambda x: paddle.exp(0.5 * x)\nx, segment = paddle.arange(-2, 2, 0.01, dtype='float32'), paddle.to_tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: tf.cos(np.pi * x)\nh = lambda x: tf.exp(0.5 * x)\nx, segment = tf.range(-2, 2, 0.01), tf.constant([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 732, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = paddle.arange(-n, n, 0.01, dtype='float32')\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = tf.range(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 733, "paddle": "c = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = paddle.meshgrid(paddle.arange(-5.5, 1.0, 0.1, dtype='float32'), paddle.arange(-3.0, 1.0, 0.1, dtype='float32'))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = paddle.to_tensor(0.5)\ndef f(x):\n    return paddle.cosh(c * x)\ndef f_grad(x):\n    return c * paddle.sinh(c * x)\ndef f_hess(x):\n    return c**2 * paddle.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * paddle.sin(c * x) - x * c**2 * paddle.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += paddle.normal(0.0, 1, (1,))\n    g2 += paddle.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "tensorflow": "c = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = tf.meshgrid(tf.range(-5.5, 1.0, 0.1), tf.range(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = tf.constant(0.5)\ndef f(x):\n    return tf.cosh(c * x)\ndef f_grad(x):\n    return c * tf.sinh(c * x)\ndef f_hess(x):\n    return c**2 * tf.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * tf.sin(c * x) - x * c**2 * tf.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += tf.random.normal([1], 0.0, 1)\n    g2 += tf.random.normal([1], 0.0, 1)\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 734, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom paddle import nn\ntimer = d2l.Timer()\nA = paddle.zeros((256, 256))\nB = paddle.randn((256, 256))\nC = paddle.randn((256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = paddle.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = paddle.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = paddle.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = paddle.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = paddle.to_tensor((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    a = []\n    with paddle.no_grad():\n        for p in params:\n            p = p - hyperparams['lr'] * p.grad\n            p.stop_gradient = False\n            a.append(p)\n        return a\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = paddle.to_tensor(paddle.normal(mean=0.0, std=0.01, shape=(feature_dim, 1)), stop_gradient=False)\n    b = paddle.to_tensor(paddle.zeros((1,)), stop_gradient=False)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            w, b = trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            paddle.nn.initializer.Normal(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(parameters=net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.clear_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = paddle.optimizer.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ntimer = d2l.Timer()\nA = tf.Variable(tf.zeros((256, 256)))\nB = tf.Variable(tf.random.normal([256, 256], 0, 1))\nC = tf.Variable(tf.random.normal([256, 256], 0, 1))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j].assign(tf.tensordot(B[i, :], C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j].assign(tf.tensordot(B, C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nA.assign(tf.tensordot(B, C, axes=1))\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64].assign(tf.tensordot(B, C[:, j:j+64], axes=1))\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, grads, states, hyperparams):\n    for param, grad in zip(params, grads):\n        param.assign_sub(hyperparams['lr']*grad)\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = tf.Variable(tf.random.normal(shape=(feature_dim, 1), mean=0, stddev=0.01),trainable=True)\n    b = tf.Variable(tf.zeros(1), trainable=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n            l = tf.math.reduce_mean(loss(net(X), y))\n            dw, db = g.gradient(l, [w, b])\n            trainer_fn([w, b], [dw, db], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss),)\n                animator.add(q, r)\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=2):\n    net = tf.keras.Sequential()\n    net.add(tf.keras.layers.Dense(1, kernel_initializer=tf.random_normal_initializer(stddev=0.01)))\n    optimizer = trainer_fn(**hyperparams)\n    loss = tf.keras.losses.MeanSquaredError()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n                out = net(X)\n                l = loss(y, out)\n                params = net.trainable_variables\n                grads = g.gradient(l, params)\n            optimizer.apply_gradients(zip(grads, params))\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss) / 2,)\n                animator.add(q, r)\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = tf.keras.optimizers.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.05}, data_iter)"}
+{"id": 735, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = paddle.zeros((feature_dim, 1))\n    v_b = paddle.zeros([1])\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    a = []\n    for p, v in zip(params, states):\n        with paddle.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Momentum\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = paddle.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(features_dim):\n    v_w = tf.Variable(tf.zeros((features_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    return (v_w, v_b)\ndef sgd_momentum(params, grads, states, hyperparams):\n    for p, v, g in zip(params, states, grads):\n        v[:].assign(hyperparams['momentum'] * v + g)\n        p[:].assign(p - hyperparams['lr'] * v)\ntrainer = tf.keras.optimizers.SGD\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = tf.range(20).numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 736, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros(shape=(1, ))\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    a = []\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] += paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.1}, data_iter)", "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef adagrad(params, grads, states, hyperparams):\n    eps = 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(s + tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate' : 0.1}, data_iter)"}
+{"id": 737, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros([1])\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    a = []\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] = gamma * s + (1 - gamma) * paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.RMSProp\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)", "tensorflow": "import math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef rmsprop(params, grads, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(gamma * s + (1 - gamma) * tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.RMSprop\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)"}
+{"id": 738, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    delta_w, delta_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    a = []\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with paddle.no_grad():\n            s[:] = rho * s + (1 - rho) * paddle.square(p.grad)\n            g = (paddle.sqrt(delta + eps) / paddle.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adadelta_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    delta_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    delta_b = tf.Variable(tf.zeros(1))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, grads, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta), grad in zip(params, states, grads):\n        s[:].assign(rho * s + (1 - rho) * tf.math.square(grad))\n        g = (tf.math.sqrt(delta + eps) / tf.math.sqrt(s + eps)) * grad\n        p[:].assign(p - g)\n        delta[:].assign(rho * delta + (1 - rho) * g * g)\ntrainer = tf.keras.optimizers.Adadelta\nd2l.train_concise_ch11(trainer, {'learning_rate':5.0, 'rho': 0.9}, data_iter)"}
+{"id": 739, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adam_states(feature_dim):\n    v_w, v_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    s_w, s_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    a = []\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ntrainer = paddle.optimizer.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    a=[]\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * paddle.sign(paddle.square(p.grad) - s) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adam_states(feature_dim):\n    v_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(beta2 * s + (1 - beta2) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\ntrainer = tf.keras.optimizers.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(s + (1 - beta2) * tf.math.sign(tf.math.square(grad) - s) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 740, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nfrom paddle.optimizer import lr as lr_scheduler\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2D(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Conv2D(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.clear_grad()\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with paddle.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat,y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                trainer.set_lr(scheduler(epoch))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.set_lr(lr)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr , parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(paddle.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\nscheduler =paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[15,30], gamma=0.5)\ntrainer = paddle.optimizer.SGD(learning_rate=scheduler, parameters=net.parameters())\ndef get_lr(trainer, scheduler):\n    lr=trainer.state_dict()['LR_Scheduler']['last_lr']\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(paddle.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)", "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom tensorflow.keras.callbacks import LearningRateScheduler\nfrom d2l import tensorflow as d2l\ndef net():\n    return tf.keras.models.Sequential([\n        tf.keras.layers.Conv2D(filters=6, kernel_size=5, activation='relu', padding='same'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Conv2D(filters=16, kernel_size=5, activation='relu'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Flatten(),\n        tf.keras.layers.Dense(120, activation='relu'),\n        tf.keras.layers.Dense(84, activation='sigmoid'),\n        tf.keras.layers.Dense(10)])\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net_fn, train_iter, test_iter, num_epochs, lr, device=d2l.try_gpu(), custom_callback = False):\n    device_name = device._device_name\n    strategy = tf.distribute.OneDeviceStrategy(device_name)\n    with strategy.scope():\n        optimizer = tf.keras.optimizers.SGD(learning_rate=lr)\n        loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n        net = net_fn()\n        net.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n    callback = d2l.TrainCallback(net, train_iter, test_iter, num_epochs, device_name)\n    if custom_callback is False:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback])\n    else:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback, custom_callback])\n    return net\nlr, num_epochs = 0.3, 30\ntrain(net, train_iter, test_iter, num_epochs, lr)\nlr = 0.1\ndummy_model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)])\ndummy_model.compile(tf.keras.optimizers.SGD(learning_rate=lr), loss='mse')\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(tf.range(50), [scheduler(t) for t in range(50)])\nclass MultiFactorScheduler:\n    def __init__(self, step, factor, base_lr):\n        self.step = step\n        self.factor = factor\n        self.base_lr = base_lr\n    def __call__(self, epoch):\n        if epoch in self.step:\n            self.base_lr = self.base_lr * self.factor\n            return self.base_lr\n        else:\n            return self.base_lr\nscheduler = MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))"}
+{"id": 741, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nfrom paddle.jit import to_static\nfrom paddle.static import InputSpec\ndef get_net():\n    blocks = [\n        nn.Linear(512, 256),\n        nn.ReLU(),\n        nn.Linear(256, 128),\n        nn.ReLU(),\n        nn.Linear(128, 2)\n    ]\n    net = nn.Sequential(*blocks)\n    return net\nx = paddle.randn((1, 512))\nnet = get_net()\nnet(x)\nnet = paddle.jit.to_static(net)\nnet(x)", "tensorflow": "import tensorflow as tf\nfrom tensorflow.keras.layers import Dense\nfrom d2l import tensorflow as d2l\ndef get_net():\n    net = tf.keras.Sequential()\n    net.add(Dense(256, input_shape = (512,), activation = \"relu\"))\n    net.add(Dense(128, activation = \"relu\"))\n    net.add(Dense(2, activation = \"linear\"))\n    return net\nx = tf.random.normal([1,512])\nnet = get_net()\nnet(x)\nnet = tf.function(net)\nnet(x)"}
+{"id": 742, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nclass MultiHeadAttention(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias_attr=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias_attr=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = paddle.repeat_interleave(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape((X.shape[0], X.shape[1], num_heads, -1))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = X.reshape((-1, num_heads, X.shape[1], X.shape[2]))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nY = paddle.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape", "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass MultiHeadAttention(nn.Block):\n    def __init__(self, num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_k = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_v = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_o = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = valid_lens.repeat(self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nY = np.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape"}
+{"id": 743, "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries, valid_lens = 2, 4, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = paddle.zeros((1, max_len, num_hiddens))\n        X = paddle.arange(max_len, dtype=paddle.float32).reshape(\n            (-1, 1)) / paddle.pow(paddle.to_tensor([10000.0]), paddle.arange(\n            0, num_hiddens, 2, dtype=paddle.float32) / num_hiddens)\n        self.P[:, :, 0::2] = paddle.sin(X)\n        self.P[:, :, 1::2] = paddle.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(paddle.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(paddle.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in paddle.arange(6, 10)])\nP = P[0, :, :].unsqueeze(0).unsqueeze(0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries, valid_lens = 2, 4, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Block):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len).reshape(-1, 1) / np.power(10000, np.arange(0, num_hiddens, 2) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].as_in_ctx(X.ctx)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.initialize()\nX = pos_encoding(np.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = np.expand_dims(np.expand_dims(P[0, :, :], 0), 0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 744, "paddle": "import math\nimport warnings\nimport pandas as pd\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass PositionWiseFFN(nn.Layer):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(paddle.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1D(2)\nX = paddle.to_tensor([[1, 2], [2, 3]], dtype=paddle.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(paddle.ones((2, 3, 4)), paddle.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = paddle.ones((2, 100, 24))\nvalid_lens = paddle.to_tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(paddle.ones((2, 100), dtype=paddle.int64), valid_lens).shape\nclass DecoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(\n            key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = paddle.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = paddle.arange(1, num_steps + 1).tile((batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = paddle.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [32]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nenc_attention_weights = paddle.concat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = paddle.to_tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose((1, 2, 3, 0, 4))\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "mxnet": "import math\nimport pandas as pd\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass PositionWiseFFN(nn.Block):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Dense(ffn_num_hiddens, flatten=False, activation='relu')\n        self.dense2 = nn.Dense(ffn_num_outputs, flatten=False)\n    def forward(self, X):\n        return self.dense2(self.dense1(X))\nffn = PositionWiseFFN(4, 8)\nffn.initialize()\nffn(np.ones((2, 3, 4)))[0]\nln = nn.LayerNorm()\nln.initialize()\nbn = nn.BatchNorm()\nbn.initialize()\nX = np.array([[1, 2], [2, 3]])\nwith autograd.record():\n    print('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Block):\n    def __init__(self, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm()\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm(0.5)\nadd_norm.initialize()\nadd_norm(np.ones((2, 3, 4)), np.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = np.ones((2, 100, 24))\nvalid_lens = np.array([3, 2])\nencoder_blk = EncoderBlock(24, 48, 8, 0.5)\nencoder_blk.initialize()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for _ in range(num_layers):\n            self.blks.add(EncoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 48, 8, 2, 0.5)\nencoder.initialize()\nencoder(np.ones((2, 100)), valid_lens).shape\nclass DecoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(dropout)\n        self.attention2 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = np.concatenate((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if autograd.is_training():\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = np.tile(np.arange(1, num_steps + 1, ctx=X.ctx), (batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 48, 8, 0.5, 0)\ndecoder_blk.initialize()\nX = np.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add(DecoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Dense(vocab_size, flatten=False)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nenc_attention_weights = np.concatenate(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights, xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [np.array(head[0]).tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = np.array(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 745, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\ndef f(x):\n    return x * paddle.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * paddle.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = paddle.arange(0.5, 1.5, 0.01, dtype='float32')\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = paddle.arange(-1.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = paddle.arange(-2.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = paddle.meshgrid(paddle.linspace(-1.0, 1.0, 101), paddle.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = paddle.arange(-2.0, 5.0, 0.01, dtype='float32')\nd2l.plot(x, [paddle.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x * np.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * np.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = np.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = np.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = np.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = np.meshgrid(np.linspace(-1.0, 1.0, 101), np.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(), **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = np.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [np.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 746, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\nf = lambda x: 0.5 * x**2\ng = lambda x: paddle.cos(np.pi * x)\nh = lambda x: paddle.exp(0.5 * x)\nx, segment = paddle.arange(-2, 2, 0.01, dtype='float32'), paddle.to_tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nf = lambda x: 0.5 * x**2\ng = lambda x: np.cos(np.pi * x)\nh = lambda x: np.exp(0.5 * x)\nx, segment = np.arange(-2, 2, 0.01), np.array([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 747, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = paddle.arange(-n, n, 0.01, dtype='float32')\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = np.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 748, "paddle": "c = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = paddle.meshgrid(paddle.arange(-5.5, 1.0, 0.1, dtype='float32'), paddle.arange(-3.0, 1.0, 0.1, dtype='float32'))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = paddle.to_tensor(0.5)\ndef f(x):\n    return paddle.cosh(c * x)\ndef f_grad(x):\n    return c * paddle.sinh(c * x)\ndef f_hess(x):\n    return c**2 * paddle.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * paddle.sin(c * x) - x * c**2 * paddle.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += paddle.normal(0.0, 1, (1,))\n    g2 += paddle.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "mxnet": "c = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = np.array(0.5)\ndef f(x):\n    return np.cosh(c * x)\ndef f_grad(x):\n    return c * np.sinh(c * x)\ndef f_hess(x):\n    return c**2 * np.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * np.sin(c * x) - x * c**2 * np.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += np.random.normal(0.0, 1, (1,))\n    g2 += np.random.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 749, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom paddle import nn\ntimer = d2l.Timer()\nA = paddle.zeros((256, 256))\nB = paddle.randn((256, 256))\nC = paddle.randn((256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = paddle.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = paddle.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = paddle.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = paddle.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = paddle.to_tensor((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    a = []\n    with paddle.no_grad():\n        for p in params:\n            p = p - hyperparams['lr'] * p.grad\n            p.stop_gradient = False\n            a.append(p)\n        return a\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = paddle.to_tensor(paddle.normal(mean=0.0, std=0.01, shape=(feature_dim, 1)), stop_gradient=False)\n    b = paddle.to_tensor(paddle.zeros((1,)), stop_gradient=False)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            w, b = trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            paddle.nn.initializer.Normal(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(parameters=net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.clear_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = paddle.optimizer.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)", "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ntimer = d2l.Timer()\nA = np.zeros((256, 256))\nB = np.random.normal(0, 1, (256, 256))\nC = np.random.normal(0, 1, (256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = np.dot(B[i, :], C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = np.dot(B, C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nA = np.dot(B, C)\nA.wait_to_read()\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = np.dot(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p[:] -= hyperparams['lr'] * p.grad\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = np.random.normal(scale=0.01, size=(feature_dim, 1))\n    b = np.zeros(1)\n    w.attach_grad()\n    b.attach_grad()\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(tr_name, hyperparams, data_iter, num_epochs=2):\n    net = nn.Sequential()\n    net.add(nn.Dense(1))\n    net.initialize(init.Normal(sigma=0.01))\n    trainer = gluon.Trainer(net.collect_params(), tr_name, hyperparams)\n    loss = gluon.loss.L2Loss()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y)\n            l.backward()\n            trainer.step(X.shape[0])\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrain_concise_ch11('sgd', {'learning_rate': 0.05}, data_iter)"}
+{"id": 750, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = paddle.zeros((feature_dim, 1))\n    v_b = paddle.zeros([1])\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    a = []\n    for p, v in zip(params, states):\n        with paddle.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Momentum\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = paddle.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = np.zeros((feature_dim, 1))\n    v_b = np.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        v[:] = hyperparams['momentum'] * v + p.grad\n        p[:] -= hyperparams['lr'] * v\nd2l.train_concise_ch11('sgd', {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = np.arange(20).asnumpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 751, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros(shape=(1, ))\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    a = []\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] += paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.1}, data_iter)", "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        s[:] += np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('adagrad', {'learning_rate': 0.1}, data_iter)"}
+{"id": 752, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros([1])\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    a = []\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] = gamma * s + (1 - gamma) * paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.RMSProp\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)", "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        s[:] = gamma * s + (1 - gamma) * np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('rmsprop', {'learning_rate': 0.01, 'gamma1': 0.9}, data_iter)"}
+{"id": 753, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    delta_w, delta_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    a = []\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with paddle.no_grad():\n            s[:] = rho * s + (1 - rho) * paddle.square(p.grad)\n            g = (paddle.sqrt(delta + eps) / paddle.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    delta_w, delta_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        s[:] = rho * s + (1 - rho) * np.square(p.grad)\n        g = (np.sqrt(delta + eps) / np.sqrt(s + eps)) * p.grad\n        p[:] -= g\n        delta[:] = rho * delta + (1 - rho) * g * g\nd2l.train_concise_ch11('adadelta', {'rho': 0.9}, data_iter)"}
+{"id": 754, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adam_states(feature_dim):\n    v_w, v_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    s_w, s_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    a = []\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ntrainer = paddle.optimizer.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    a=[]\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * paddle.sign(paddle.square(p.grad) - s) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adam_states(feature_dim):\n    v_w, v_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = beta2 * s + (1 - beta2) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\nd2l.train_concise_ch11('adam', {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = s + (1 - beta2) * np.sign(np.square(p.grad) - s) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 755, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nfrom paddle.optimizer import lr as lr_scheduler\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2D(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Conv2D(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.clear_grad()\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with paddle.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat,y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                trainer.set_lr(scheduler(epoch))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.set_lr(lr)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr , parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(paddle.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\nscheduler =paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[15,30], gamma=0.5)\ntrainer = paddle.optimizer.SGD(learning_rate=scheduler, parameters=net.parameters())\ndef get_lr(trainer, scheduler):\n    lr=trainer.state_dict()['LR_Scheduler']['last_lr']\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(paddle.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)", "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, lr_scheduler, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnet = nn.HybridSequential()\nnet.add(nn.Conv2D(channels=6, kernel_size=5, padding=2, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Conv2D(channels=16, kernel_size=5, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Dense(120, activation='relu'),\n        nn.Dense(84, activation='relu'),\n        nn.Dense(10))\nnet.hybridize()\nloss = gluon.loss.SoftmaxCrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device):\n    net.initialize(force_reinit=True, ctx=device, init=init.Xavier())\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            X, y = X.as_in_ctx(device), y.as_in_ctx(device)\n            with autograd.record():\n                y_hat = net(X)\n                l = loss(y_hat, y)\n            l.backward()\n            trainer.step(X.shape[0])\n            metric.add(l.sum(), d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch + 1, (None, None, test_acc))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet.initialize(force_reinit=True, ctx=device, init=init.Xavier())\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\ntrainer.set_learning_rate(0.1)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(np.arange(50), [scheduler(t) for t in range(50)])\nscheduler = lr_scheduler.MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)"}
+{"id": 756, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nfrom paddle.jit import to_static\nfrom paddle.static import InputSpec\ndef get_net():\n    blocks = [\n        nn.Linear(512, 256),\n        nn.ReLU(),\n        nn.Linear(256, 128),\n        nn.ReLU(),\n        nn.Linear(128, 2)\n    ]\n    net = nn.Sequential(*blocks)\n    return net\nx = paddle.randn((1, 512))\nnet = get_net()\nnet(x)\nnet = paddle.jit.to_static(net)\nnet(x)", "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef get_net():\n    net = nn.HybridSequential()\n    net.add(nn.Dense(256, activation='relu'),\n            nn.Dense(128, activation='relu'),\n            nn.Dense(2))\n    net.initialize()\n    return net\nx = np.random.normal(size=(1, 512))\nnet = get_net()\nnet(x)\nnet.hybridize()\nnet(x)"}
+{"id": 757, "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass MultiHeadAttention(nn.Block):\n    def __init__(self, num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_k = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_v = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_o = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = valid_lens.repeat(self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nY = np.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass MultiHeadAttention(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = torch.repeat_interleave(valid_lens, repeats=self.num_heads, dim=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()"}
+{"id": 758, "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries, valid_lens = 2, 4, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Block):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len).reshape(-1, 1) / np.power(10000, np.arange(0, num_hiddens, 2) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].as_in_ctx(X.ctx)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.initialize()\nX = pos_encoding(np.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = np.expand_dims(np.expand_dims(P[0, :, :], 0), 0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nclass PositionalEncoding(nn.Module):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = torch.zeros((1, max_len, num_hiddens))\n        X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2, dtype=torch.float32) / num_hiddens)\n        self.P[:, :, 0::2] = torch.sin(X)\n        self.P[:, :, 1::2] = torch.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].to(X.device)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(torch.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in torch.arange(6, 10)])\nP = P[0, :, :].unsqueeze(0).unsqueeze(0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 759, "mxnet": "import math\nimport pandas as pd\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass PositionWiseFFN(nn.Block):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Dense(ffn_num_hiddens, flatten=False, activation='relu')\n        self.dense2 = nn.Dense(ffn_num_outputs, flatten=False)\n    def forward(self, X):\n        return self.dense2(self.dense1(X))\nffn = PositionWiseFFN(4, 8)\nffn.initialize()\nffn(np.ones((2, 3, 4)))[0]\nln = nn.LayerNorm()\nln.initialize()\nbn = nn.BatchNorm()\nbn.initialize()\nX = np.array([[1, 2], [2, 3]])\nwith autograd.record():\n    print('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Block):\n    def __init__(self, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm()\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm(0.5)\nadd_norm.initialize()\nadd_norm(np.ones((2, 3, 4)), np.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = np.ones((2, 100, 24))\nvalid_lens = np.array([3, 2])\nencoder_blk = EncoderBlock(24, 48, 8, 0.5)\nencoder_blk.initialize()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for _ in range(num_layers):\n            self.blks.add(EncoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 48, 8, 2, 0.5)\nencoder.initialize()\nencoder(np.ones((2, 100)), valid_lens).shape\nclass DecoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(dropout)\n        self.attention2 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = np.concatenate((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if autograd.is_training():\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = np.tile(np.arange(1, num_steps + 1, ctx=X.ctx), (batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 48, 8, 0.5, 0)\ndecoder_blk.initialize()\nX = np.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add(DecoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Dense(vocab_size, flatten=False)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nenc_attention_weights = np.concatenate(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights, xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [np.array(head[0]).tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = np.array(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "pytorch": "import math\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass PositionWiseFFN(nn.Module):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(torch.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1d(2)\nX = torch.tensor([[1, 2], [2, 3]], dtype=torch.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Module):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(torch.ones((2, 3, 4)), torch.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = torch.ones((2, 100, 24))\nvalid_lens = torch.tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape\nclass DecoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = torch.cat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = torch.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [32]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nenc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = torch.tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.permute(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 760, "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x * np.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * np.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = np.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = np.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = np.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = np.meshgrid(np.linspace(-1.0, 1.0, 101), np.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(), **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = np.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [np.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\ndef f(x):\n    return x * torch.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * torch.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = torch.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = torch.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = torch.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = torch.meshgrid(torch.linspace(-1.0, 1.0, 101), torch.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = torch.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [torch.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 761, "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nf = lambda x: 0.5 * x**2\ng = lambda x: np.cos(np.pi * x)\nh = lambda x: np.exp(0.5 * x)\nx, segment = np.arange(-2, 2, 0.01), np.array([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: torch.cos(np.pi * x)\nh = lambda x: torch.exp(0.5 * x)\nx, segment = torch.arange(-2, 2, 0.01), torch.tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 762, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = np.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom d2l import torch as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = torch.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 763, "mxnet": "c = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = np.array(0.5)\ndef f(x):\n    return np.cosh(c * x)\ndef f_grad(x):\n    return c * np.sinh(c * x)\ndef f_hess(x):\n    return c**2 * np.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * np.sin(c * x) - x * c**2 * np.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += np.random.normal(0.0, 1, (1,))\n    g2 += np.random.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "pytorch": "c = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = torch.meshgrid(torch.arange(-5.5, 1.0, 0.1), torch.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = torch.tensor(0.5)\ndef f(x):\n    return torch.cosh(c * x)\ndef f_grad(x):\n    return c * torch.sinh(c * x)\ndef f_hess(x):\n    return c**2 * torch.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * torch.sin(c * x) - x * c**2 * torch.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += torch.normal(0.0, 1, (1,))\n    g2 += torch.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 764, "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ntimer = d2l.Timer()\nA = np.zeros((256, 256))\nB = np.random.normal(0, 1, (256, 256))\nC = np.random.normal(0, 1, (256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = np.dot(B[i, :], C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = np.dot(B, C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nA = np.dot(B, C)\nA.wait_to_read()\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = np.dot(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p[:] -= hyperparams['lr'] * p.grad\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = np.random.normal(scale=0.01, size=(feature_dim, 1))\n    b = np.zeros(1)\n    w.attach_grad()\n    b.attach_grad()\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(tr_name, hyperparams, data_iter, num_epochs=2):\n    net = nn.Sequential()\n    net.add(nn.Dense(1))\n    net.initialize(init.Normal(sigma=0.01))\n    trainer = gluon.Trainer(net.collect_params(), tr_name, hyperparams)\n    loss = gluon.loss.L2Loss()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y)\n            l.backward()\n            trainer.step(X.shape[0])\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrain_concise_ch11('sgd', {'learning_rate': 0.05}, data_iter)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ntimer = d2l.Timer()\nA = torch.zeros(256, 256)\nB = torch.randn(256, 256)\nC = torch.randn(256, 256)\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = torch.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = torch.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = torch.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = torch.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = torch.from_numpy((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p.data.sub_(hyperparams['lr'] * p.grad)\n        p.grad.data.zero_()\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = torch.normal(mean=0.0, std=0.01, size=(feature_dim, 1), requires_grad=True)\n    b = torch.zeros((1), requires_grad=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            torch.nn.init.normal_(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.zero_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = torch.optim.SGD\ntrain_concise_ch11(trainer, {'lr': 0.01}, data_iter)"}
+{"id": 765, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = np.zeros((feature_dim, 1))\n    v_b = np.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        v[:] = hyperparams['momentum'] * v + p.grad\n        p[:] -= hyperparams['lr'] * v\nd2l.train_concise_ch11('sgd', {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = np.arange(20).asnumpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = torch.zeros((feature_dim, 1))\n    v_b = torch.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        with torch.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.data.zero_()\ntrainer = torch.optim.SGD\nd2l.train_concise_ch11(trainer, {'lr': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = torch.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 766, "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        s[:] += np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('adagrad', {'learning_rate': 0.1}, data_iter)", "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] += torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.Adagrad\nd2l.train_concise_ch11(trainer, {'lr': 0.1}, data_iter)"}
+{"id": 767, "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        s[:] = gamma * s + (1 - gamma) * np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('rmsprop', {'learning_rate': 0.01, 'gamma1': 0.9}, data_iter)", "pytorch": "import math\nimport torch\nfrom d2l import torch as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.RMSprop\nd2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9}, data_iter)"}
+{"id": 768, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    delta_w, delta_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        s[:] = rho * s + (1 - rho) * np.square(p.grad)\n        g = (np.sqrt(delta + eps) / np.sqrt(s + eps)) * p.grad\n        p[:] -= g\n        delta[:] = rho * delta + (1 - rho) * g * g\nd2l.train_concise_ch11('adadelta', {'rho': 0.9}, data_iter)", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    delta_w, delta_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with torch.no_grad():\n            s[:] = rho * s + (1 - rho) * torch.square(p.grad)\n            g = (torch.sqrt(delta + eps) / torch.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.data.zero_()\ntrainer = torch.optim.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)"}
+{"id": 769, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adam_states(feature_dim):\n    v_w, v_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = beta2 * s + (1 - beta2) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\nd2l.train_concise_ch11('adam', {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = s + (1 - beta2) * np.sign(np.square(p.grad) - s) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adam_states(feature_dim):\n    v_w, v_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ntrainer = torch.optim.Adam\nd2l.train_concise_ch11(trainer, {'lr': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * torch.sign(torch.square(p.grad) - s) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 770, "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, lr_scheduler, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnet = nn.HybridSequential()\nnet.add(nn.Conv2D(channels=6, kernel_size=5, padding=2, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Conv2D(channels=16, kernel_size=5, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Dense(120, activation='relu'),\n        nn.Dense(84, activation='relu'),\n        nn.Dense(10))\nnet.hybridize()\nloss = gluon.loss.SoftmaxCrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device):\n    net.initialize(force_reinit=True, ctx=device, init=init.Xavier())\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            X, y = X.as_in_ctx(device), y.as_in_ctx(device)\n            with autograd.record():\n                y_hat = net(X)\n                l = loss(y_hat, y)\n            l.backward()\n            trainer.step(X.shape[0])\n            metric.add(l.sum(), d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch + 1, (None, None, test_acc))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet.initialize(force_reinit=True, ctx=device, init=init.Xavier())\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\ntrainer.set_learning_rate(0.1)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(np.arange(50), [scheduler(t) for t in range(50)])\nscheduler = lr_scheduler.MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)", "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom torch import nn\nfrom torch.optim import lr_scheduler\nfrom d2l import torch as d2l\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    net.to(device)\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.zero_grad()\n            X, y = X.to(device), y.to(device)\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with torch.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                for param_group in trainer.param_groups:\n                    param_group['lr'] = scheduler(epoch)\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.param_groups[0][\"lr\"] = lr\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(torch.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nscheduler = lr_scheduler.MultiStepLR(trainer, milestones=[15, 30], gamma=0.5)\ndef get_lr(trainer, scheduler):\n    lr = scheduler.get_last_lr()[0]\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(torch.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)"}
+{"id": 771, "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef get_net():\n    net = nn.HybridSequential()\n    net.add(nn.Dense(256, activation='relu'),\n            nn.Dense(128, activation='relu'),\n            nn.Dense(2))\n    net.initialize()\n    return net\nx = np.random.normal(size=(1, 512))\nnet = get_net()\nnet(x)\nnet.hybridize()\nnet(x)", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef get_net():\n    net = nn.Sequential(nn.Linear(512, 256),\n            nn.ReLU(),\n            nn.Linear(256, 128),\n            nn.ReLU(),\n            nn.Linear(128, 2))\n    return net\nx = torch.randn(size=(1, 512))\nnet = get_net()\nnet(x)\nnet = torch.jit.script(net)\nnet(x)"}
+{"id": 772, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nclass MultiHeadAttention(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias_attr=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias_attr=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = paddle.repeat_interleave(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape((X.shape[0], X.shape[1], num_heads, -1))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = X.reshape((-1, num_heads, X.shape[1], X.shape[2]))\n    X = X.transpose((0, 2, 1, 3))\n    return X.reshape((X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nY = paddle.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass MultiHeadAttention(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = torch.repeat_interleave(valid_lens, repeats=self.num_heads, dim=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()"}
+{"id": 773, "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nbatch_size, num_queries, valid_lens = 2, 4, paddle.to_tensor([3, 2])\nX = paddle.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = paddle.zeros((1, max_len, num_hiddens))\n        X = paddle.arange(max_len, dtype=paddle.float32).reshape(\n            (-1, 1)) / paddle.pow(paddle.to_tensor([10000.0]), paddle.arange(\n            0, num_hiddens, 2, dtype=paddle.float32) / num_hiddens)\n        self.P[:, :, 0::2] = paddle.sin(X)\n        self.P[:, :, 1::2] = paddle.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(paddle.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(paddle.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in paddle.arange(6, 10)])", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nclass PositionalEncoding(nn.Module):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = torch.zeros((1, max_len, num_hiddens))\n        X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2, dtype=torch.float32) / num_hiddens)\n        self.P[:, :, 0::2] = torch.sin(X)\n        self.P[:, :, 1::2] = torch.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].to(X.device)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(torch.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in torch.arange(6, 10)])"}
+{"id": 774, "paddle": "import math\nimport warnings\nimport pandas as pd\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass PositionWiseFFN(nn.Layer):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(paddle.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1D(2)\nX = paddle.to_tensor([[1, 2], [2, 3]], dtype=paddle.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(paddle.ones((2, 3, 4)), paddle.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = paddle.ones((2, 100, 24))\nvalid_lens = paddle.to_tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(paddle.ones((2, 100), dtype=paddle.int64), valid_lens).shape\nclass DecoderBlock(nn.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(\n            key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = paddle.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = paddle.arange(1, num_steps + 1).tile((batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = paddle.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_sublayer(str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nenc_attention_weights = paddle.concat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = paddle.to_tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose((1, 2, 3, 0, 4))\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "pytorch": "import math\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass PositionWiseFFN(nn.Module):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(torch.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1d(2)\nX = torch.tensor([[1, 2], [2, 3]], dtype=torch.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Module):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(torch.ones((2, 3, 4)), torch.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = torch.ones((2, 100, 24))\nvalid_lens = torch.tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape\nclass DecoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = torch.cat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = torch.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nenc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = torch.tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.permute(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 775, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\ndef f(x):\n    return x * paddle.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * paddle.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = paddle.arange(0.5, 1.5, 0.01, dtype='float32')\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = paddle.arange(-1.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = paddle.arange(-2.0, 2.0, 0.01, dtype='float32')\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = paddle.meshgrid(paddle.linspace(-1.0, 1.0, 101), paddle.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = paddle.arange(-2.0, 5.0, 0.01, dtype='float32')\nd2l.plot(x, [paddle.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\ndef f(x):\n    return x * torch.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * torch.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = torch.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = torch.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = torch.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = torch.meshgrid(torch.linspace(-1.0, 1.0, 101), torch.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = torch.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [torch.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 776, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom mpl_toolkits import mplot3d\nf = lambda x: 0.5 * x**2\ng = lambda x: paddle.cos(np.pi * x)\nh = lambda x: paddle.exp(0.5 * x)\nx, segment = paddle.arange(-2, 2, 0.01, dtype='float32'), paddle.to_tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: torch.cos(np.pi * x)\nh = lambda x: torch.exp(0.5 * x)\nx, segment = torch.arange(-2, 2, 0.01), torch.tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 777, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = paddle.arange(-n, n, 0.01, dtype='float32')\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom d2l import torch as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = torch.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 778, "paddle": "c = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = paddle.meshgrid(paddle.arange(-5.5, 1.0, 0.1, dtype='float32'), paddle.arange(-3.0, 1.0, 0.1, dtype='float32'))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = paddle.to_tensor(0.5)\ndef f(x):\n    return paddle.cosh(c * x)\ndef f_grad(x):\n    return c * paddle.sinh(c * x)\ndef f_hess(x):\n    return c**2 * paddle.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = paddle.to_tensor(0.15 * np.pi)\ndef f(x):\n    return x * paddle.cos(c * x)\ndef f_grad(x):\n    return paddle.cos(c * x) - c * x * paddle.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * paddle.sin(c * x) - x * c**2 * paddle.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += paddle.normal(0.0, 1, (1,))\n    g2 += paddle.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "pytorch": "c = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = torch.meshgrid(torch.arange(-5.5, 1.0, 0.1), torch.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = torch.tensor(0.5)\ndef f(x):\n    return torch.cosh(c * x)\ndef f_grad(x):\n    return c * torch.sinh(c * x)\ndef f_hess(x):\n    return c**2 * torch.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * torch.sin(c * x) - x * c**2 * torch.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += torch.normal(0.0, 1, (1,))\n    g2 += torch.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 779, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport numpy as np\nimport paddle\nfrom paddle import nn\ntimer = d2l.Timer()\nA = paddle.zeros((256, 256))\nB = paddle.randn((256, 256))\nC = paddle.randn((256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = paddle.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = paddle.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = paddle.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = paddle.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = paddle.to_tensor((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    a = []\n    with paddle.no_grad():\n        for p in params:\n            p = p - hyperparams['lr'] * p.grad\n            p.stop_gradient = False\n            a.append(p)\n        return a\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = paddle.to_tensor(paddle.normal(mean=0.0, std=0.01, shape=(feature_dim, 1)), stop_gradient=False)\n    b = paddle.to_tensor(paddle.zeros((1,)), stop_gradient=False)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            w, b = trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            paddle.nn.initializer.Normal(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(parameters=net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.clear_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = paddle.optimizer.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ntimer = d2l.Timer()\nA = torch.zeros(256, 256)\nB = torch.randn(256, 256)\nC = torch.randn(256, 256)\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = torch.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = torch.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = torch.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = torch.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = torch.from_numpy((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p.data.sub_(hyperparams['lr'] * p.grad)\n        p.grad.data.zero_()\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = torch.normal(mean=0.0, std=0.01, size=(feature_dim, 1), requires_grad=True)\n    b = torch.zeros((1), requires_grad=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            torch.nn.init.normal_(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.zero_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = torch.optim.SGD\ntrain_concise_ch11(trainer, {'lr': 0.01}, data_iter)"}
+{"id": 780, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = paddle.zeros((feature_dim, 1))\n    v_b = paddle.zeros([1])\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    a = []\n    for p, v in zip(params, states):\n        with paddle.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Momentum\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = paddle.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = torch.zeros((feature_dim, 1))\n    v_b = torch.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        with torch.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.data.zero_()\ntrainer = torch.optim.SGD\nd2l.train_concise_ch11(trainer, {'lr': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = torch.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 781, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros(shape=(1, ))\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    a = []\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] += paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.1}, data_iter)", "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] += torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.Adagrad\nd2l.train_concise_ch11(trainer, {'lr': 0.1}, data_iter)"}
+{"id": 782, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = paddle.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = paddle.zeros((feature_dim, 1))\n    s_b = paddle.zeros([1])\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    a = []\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with paddle.no_grad():\n            s[:] = gamma * s + (1 - gamma) * paddle.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / paddle.sqrt(s + eps)\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.RMSProp\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)", "pytorch": "import math\nimport torch\nfrom d2l import torch as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.RMSprop\nd2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9}, data_iter)"}
+{"id": 783, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    delta_w, delta_b = paddle.zeros(shape=(feature_dim, 1)), paddle.zeros(shape=(1, ))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    a = []\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with paddle.no_grad():\n            s[:] = rho * s + (1 - rho) * paddle.square(p.grad)\n            g = (paddle.sqrt(delta + eps) / paddle.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.zero_()\n        a.append(p)\n    return a\ntrainer = paddle.optimizer.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    delta_w, delta_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with torch.no_grad():\n            s[:] = rho * s + (1 - rho) * torch.square(p.grad)\n            g = (torch.sqrt(delta + eps) / torch.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.data.zero_()\ntrainer = torch.optim.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)"}
+{"id": 784, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef init_adam_states(feature_dim):\n    v_w, v_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    s_w, s_b = paddle.zeros((feature_dim, 1)), paddle.zeros((1, ))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    a = []\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ntrainer = paddle.optimizer.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    a=[]\n    for p, (v, s) in zip(params, states):\n        with paddle.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * paddle.sign(paddle.square(p.grad) - s) * paddle.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (paddle.sqrt(s_bias_corr) + eps)\n        p.grad.zero_()\n        a.append(p)\n    hyperparams['t'] += 1\n    return a\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adam_states(feature_dim):\n    v_w, v_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ntrainer = torch.optim.Adam\nd2l.train_concise_ch11(trainer, {'lr': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * torch.sign(torch.square(p.grad) - s) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 785, "paddle": "%matplotlib inline\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\nfrom paddle.optimizer import lr as lr_scheduler\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2D(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Conv2D(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2D(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.clear_grad()\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with paddle.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat,y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                trainer.set_lr(scheduler(epoch))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.set_lr(lr)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=lr , parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(paddle.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\nscheduler =paddle.optimizer.lr.MultiStepDecay(learning_rate=0.5, milestones=[15,30], gamma=0.5)\ntrainer = paddle.optimizer.SGD(learning_rate=scheduler, parameters=net.parameters())\ndef get_lr(trainer, scheduler):\n    lr=trainer.state_dict()['LR_Scheduler']['last_lr']\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(paddle.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(paddle.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = paddle.optimizer.SGD(learning_rate=0.3, parameters=net.parameters())\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)", "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom torch import nn\nfrom torch.optim import lr_scheduler\nfrom d2l import torch as d2l\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    net.to(device)\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.zero_grad()\n            X, y = X.to(device), y.to(device)\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with torch.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                for param_group in trainer.param_groups:\n                    param_group['lr'] = scheduler(epoch)\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.param_groups[0][\"lr\"] = lr\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(torch.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nscheduler = lr_scheduler.MultiStepLR(trainer, milestones=[15, 30], gamma=0.5)\ndef get_lr(trainer, scheduler):\n    lr = scheduler.get_last_lr()[0]\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(torch.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)"}
+{"id": 786, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nfrom paddle.jit import to_static\nfrom paddle.static import InputSpec\ndef get_net():\n    blocks = [\n        nn.Linear(512, 256),\n        nn.ReLU(),\n        nn.Linear(256, 128),\n        nn.ReLU(),\n        nn.Linear(128, 2)\n    ]\n    net = nn.Sequential(*blocks)\n    return net\nx = paddle.randn((1, 512))\nnet = get_net()\nnet(x)\nnet = paddle.jit.to_static(net)\nnet(x)", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef get_net():\n    net = nn.Sequential(nn.Linear(512, 256),\n            nn.ReLU(),\n            nn.Linear(256, 128),\n            nn.ReLU(),\n            nn.Linear(128, 2))\n    return net\nx = torch.randn(size=(1, 512))\nnet = get_net()\nnet(x)\nnet = torch.jit.script(net)\nnet(x)"}
+{"id": 787, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass MultiHeadAttention(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_v = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_o = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n    def call(self, queries, keys, values, valid_lens, **kwargs):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = tf.repeat(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens, **kwargs)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = tf.reshape(X, shape=(X.shape[0], X.shape[1], num_heads, -1))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = tf.reshape(X, shape=(-1, num_heads, X.shape[1], X.shape[2]))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens = 6, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nY = tf.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens, training=False).shape", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass MultiHeadAttention(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Linear(query_size, num_hiddens, bias=bias)\n        self.W_k = nn.Linear(key_size, num_hiddens, bias=bias)\n        self.W_v = nn.Linear(value_size, num_hiddens, bias=bias)\n        self.W_o = nn.Linear(num_hiddens, num_hiddens, bias=bias)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = torch.repeat_interleave(valid_lens, repeats=self.num_heads, dim=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.permute(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()"}
+{"id": 788, "tensorflow": "import numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries, valid_lens = 2, 4, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens, training=False).shape\nclass PositionalEncoding(tf.keras.layers.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super().__init__()\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len, dtype=np.float32).reshape(-1,1)/np.power(10000, np.arange(0, num_hiddens, 2, dtype=np.float32) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def call(self, X, **kwargs):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X, **kwargs)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\nX = pos_encoding(tf.zeros((1, num_steps, encoding_dim)), training=False)\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = tf.expand_dims(tf.expand_dims(P[0, :, :], axis=0), axis=0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nattention.eval()\nclass PositionalEncoding(nn.Module):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = torch.zeros((1, max_len, num_hiddens))\n        X = torch.arange(max_len, dtype=torch.float32).reshape(-1, 1) / torch.pow(10000, torch.arange(0, num_hiddens, 2, dtype=torch.float32) / num_hiddens)\n        self.P[:, :, 0::2] = torch.sin(X)\n        self.P[:, :, 1::2] = torch.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].to(X.device)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.eval()\nX = pos_encoding(torch.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(torch.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in torch.arange(6, 10)])\nP = P[0, :, :].unsqueeze(0).unsqueeze(0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 789, "tensorflow": "import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass PositionWiseFFN(tf.keras.layers.Layer):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super().__init__(*kwargs)\n        self.dense1 = tf.keras.layers.Dense(ffn_num_hiddens)\n        self.relu = tf.keras.layers.ReLU()\n        self.dense2 = tf.keras.layers.Dense(ffn_num_outputs)\n    def call(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 8)\nffn(tf.ones((2, 3, 4)))[0]\nln = tf.keras.layers.LayerNormalization()\nbn = tf.keras.layers.BatchNormalization()\nX = tf.constant([[1, 2], [2, 3]], dtype=tf.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(tf.keras.layers.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.ln = tf.keras.layers.LayerNormalization(normalized_shape)\n    def call(self, X, Y, **kwargs):\n        return self.ln(self.dropout(Y, **kwargs) + X)\nadd_norm = AddNorm([1, 2], 0.5)\nadd_norm(tf.ones((2, 3, 4)), tf.ones((2, 3, 4)), training=False).shape\nclass EncoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def call(self, X, valid_lens, **kwargs):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens, **kwargs), **kwargs)\n        return self.addnorm2(Y, self.ffn(Y), **kwargs)\nX = tf.ones((2, 100, 24))\nvalid_lens = tf.constant([3, 2])\nnorm_shape = [i for i in range(len(X.shape))][1:]\nencoder_blk = EncoderBlock(24, 24, 24, 24, norm_shape, 48, 8, 0.5)\nencoder_blk(X, valid_lens, training=False).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias) for _ in range(num_layers)]\n    def call(self, X, valid_lens, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens, **kwargs)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [1, 2], 48, 8, 2, 0.5)\nencoder(tf.ones((2, 100)), valid_lens, training=False).shape\nclass DecoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super().__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def call(self, X, state, **kwargs):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = tf.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if kwargs[\"training\"]:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = tf.repeat(tf.reshape(tf.range(1, num_steps + 1), shape=(-1, num_steps)), repeats=batch_size, axis=0)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens, **kwargs)\n        Y = self.addnorm1(X, X2, **kwargs)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n        Z = self.addnorm2(Y, Y2, **kwargs)\n        return self.addnorm3(Z, self.ffn(Z), **kwargs), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [1, 2], 48, 8, 0.5, 0)\nX = tf.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state, training=False)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hidens, num_heads, num_layers, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i) for i in range(num_layers)]\n        self.dense = tf.keras.layers.Dense(vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def call(self, X, state, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self._attention_weights = [[None] * len(self.blks) for _ in range(2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state, **kwargs)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [2]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = tf.reshape(tf.concat(net.encoder.attention_weights, 0), (num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights, xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0] for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = tf.convert_to_tensor(np.asarray(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values).astype(np.float32))\ndec_attention_weights = tf.reshape(dec_attention_weights_filled, shape=(-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = tf.transpose(dec_attention_weights, perm=(1, 2, 3, 0, 4))", "pytorch": "import math\nimport pandas as pd\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass PositionWiseFFN(nn.Module):\n    def __init__(self, ffn_num_input, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Linear(ffn_num_input, ffn_num_hiddens)\n        self.relu = nn.ReLU()\n        self.dense2 = nn.Linear(ffn_num_hiddens, ffn_num_outputs)\n    def forward(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 4, 8)\nffn.eval()\nffn(torch.ones((2, 3, 4)))[0]\nln = nn.LayerNorm(2)\nbn = nn.BatchNorm1d(2)\nX = torch.tensor([[1, 2], [2, 3]], dtype=torch.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Module):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm(normalized_shape)\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm([3, 4], 0.5)\nadd_norm.eval()\nadd_norm(torch.ones((2, 3, 4)), torch.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = torch.ones((2, 100, 24))\nvalid_lens = torch.tensor([3, 2])\nencoder_blk = EncoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5)\nencoder_blk.eval()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [100, 24], 24, 48, 8, 2, 0.5)\nencoder.eval()\nencoder(torch.ones((2, 100), dtype=torch.long), valid_lens).shape\nclass DecoderBlock(nn.Module):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_input, ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = torch.cat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if self.training:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = torch.arange(1, num_steps + 1, device=X.device).repeat(batch_size, 1)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [100, 24], 24, 48, 8, 0.5, 0)\ndecoder_blk.eval()\nX = torch.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add_module(\"block\"+str(i), DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Linear(num_hiddens, vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_input, ffn_num_hiddens, num_heads = 32, 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [32]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_input, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = torch.cat(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\nd2l.show_heatmaps(enc_attention_weights.cpu(), xlabel='Key positions', ylabel='Query positions', titles=['Head %d' % i for i in range(1, 5)], figsize=(7, 3.5))\ndec_attention_weights_2d = [head[0].tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = torch.tensor(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.permute(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape"}
+{"id": 790, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x * tf.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * tf.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = tf.range(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = tf.range(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = tf.range(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = tf.meshgrid(tf.linspace(-1.0, 1.0, 101), tf.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = tf.range(-2.0, 5.0, 0.01)\nd2l.plot(x, [tf.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\ndef f(x):\n    return x * torch.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * torch.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = torch.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = torch.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = torch.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = torch.meshgrid(torch.linspace(-1.0, 1.0, 101), torch.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = torch.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [torch.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 791, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: tf.cos(np.pi * x)\nh = lambda x: tf.exp(0.5 * x)\nx, segment = tf.range(-2, 2, 0.01), tf.constant([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom mpl_toolkits import mplot3d\nfrom d2l import torch as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: torch.cos(np.pi * x)\nh = lambda x: torch.exp(0.5 * x)\nx, segment = torch.arange(-2, 2, 0.01), torch.tensor([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 792, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = tf.range(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom d2l import torch as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = torch.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 793, "tensorflow": "c = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = tf.meshgrid(tf.range(-5.5, 1.0, 0.1), tf.range(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = tf.constant(0.5)\ndef f(x):\n    return tf.cosh(c * x)\ndef f_grad(x):\n    return c * tf.sinh(c * x)\ndef f_hess(x):\n    return c**2 * tf.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * tf.sin(c * x) - x * c**2 * tf.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += tf.random.normal([1], 0.0, 1)\n    g2 += tf.random.normal([1], 0.0, 1)\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "pytorch": "c = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = torch.meshgrid(torch.arange(-5.5, 1.0, 0.1), torch.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = torch.tensor(0.5)\ndef f(x):\n    return torch.cosh(c * x)\ndef f_grad(x):\n    return c * torch.sinh(c * x)\ndef f_hess(x):\n    return c**2 * torch.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = torch.tensor(0.15 * np.pi)\ndef f(x):\n    return x * torch.cos(c * x)\ndef f_grad(x):\n    return torch.cos(c * x) - c * x * torch.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * torch.sin(c * x) - x * c**2 * torch.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += torch.normal(0.0, 1, (1,))\n    g2 += torch.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 794, "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ntimer = d2l.Timer()\nA = tf.Variable(tf.zeros((256, 256)))\nB = tf.Variable(tf.random.normal([256, 256], 0, 1))\nC = tf.Variable(tf.random.normal([256, 256], 0, 1))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j].assign(tf.tensordot(B[i, :], C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j].assign(tf.tensordot(B, C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nA.assign(tf.tensordot(B, C, axes=1))\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64].assign(tf.tensordot(B, C[:, j:j+64], axes=1))\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = (data - data.mean(axis=0)) / data.std(axis=0)\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, grads, states, hyperparams):\n    for param, grad in zip(params, grads):\n        param.assign_sub(hyperparams['lr']*grad)\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = tf.Variable(tf.random.normal(shape=(feature_dim, 1), mean=0, stddev=0.01),trainable=True)\n    b = tf.Variable(tf.zeros(1), trainable=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n            l = tf.math.reduce_mean(loss(net(X), y))\n            dw, db = g.gradient(l, [w, b])\n            trainer_fn([w, b], [dw, db], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss),)\n                animator.add(q, r)\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=2):\n    net = tf.keras.Sequential()\n    net.add(tf.keras.layers.Dense(1, kernel_initializer=tf.random_normal_initializer(stddev=0.01)))\n    optimizer = trainer_fn(**hyperparams)\n    loss = tf.keras.losses.MeanSquaredError()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n                out = net(X)\n                l = loss(y, out)\n                params = net.trainable_variables\n                grads = g.gradient(l, params)\n            optimizer.apply_gradients(zip(grads, params))\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss) / 2,)\n                animator.add(q, r)\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = tf.keras.optimizers.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.05}, data_iter)", "pytorch": "%matplotlib inline\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ntimer = d2l.Timer()\nA = torch.zeros(256, 256)\nB = torch.randn(256, 256)\nC = torch.randn(256, 256)\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = torch.dot(B[i, :], C[:, j])\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = torch.mv(B, C[:, j])\ntimer.stop()\ntimer.start()\nA = torch.mm(B, C)\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = torch.mm(B, C[:, j:j+64])\ntimer.stop()\nd2l.DATA_HUB['airfoil'] = (d2l.DATA_URL + 'airfoil_self_noise.dat', '76e5be1548fd8222e5074cf0faae75edff8cf93f')\ndef get_data_ch11(batch_size=10, n=1500):\n    data = np.genfromtxt(d2l.download('airfoil'), dtype=np.float32, delimiter='\\t')\n    data = torch.from_numpy((data - data.mean(axis=0)) / data.std(axis=0))\n    data_iter = d2l.load_array((data[:n, :-1], data[:n, -1]), batch_size, is_train=True)\n    return data_iter, data.shape[1]-1\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p.data.sub_(hyperparams['lr'] * p.grad)\n        p.grad.data.zero_()\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = torch.normal(mean=0.0, std=0.01, size=(feature_dim, 1), requires_grad=True)\n    b = torch.zeros((1), requires_grad=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=4):\n    net = nn.Sequential(nn.Linear(5, 1))\n    def init_weights(m):\n        if type(m) == nn.Linear:\n            torch.nn.init.normal_(m.weight, std=0.01)\n    net.apply(init_weights)\n    optimizer = trainer_fn(net.parameters(), **hyperparams)\n    loss = nn.MSELoss(reduction='none')\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            optimizer.zero_grad()\n            out = net(X)\n            y = y.reshape(out.shape)\n            l = loss(out, y)\n            l.mean().backward()\n            optimizer.step()\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss) / 2,))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = torch.optim.SGD\ntrain_concise_ch11(trainer, {'lr': 0.01}, data_iter)"}
+{"id": 795, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(features_dim):\n    v_w = tf.Variable(tf.zeros((features_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    return (v_w, v_b)\ndef sgd_momentum(params, grads, states, hyperparams):\n    for p, v, g in zip(params, states, grads):\n        v[:].assign(hyperparams['momentum'] * v + g)\n        p[:].assign(p - hyperparams['lr'] * v)\ntrainer = tf.keras.optimizers.SGD\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = tf.range(20).numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = torch.zeros((feature_dim, 1))\n    v_b = torch.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        with torch.no_grad():\n            v[:] = hyperparams['momentum'] * v + p.grad\n            p[:] -= hyperparams['lr'] * v\n        p.grad.data.zero_()\ntrainer = torch.optim.SGD\nd2l.train_concise_ch11(trainer, {'lr': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = torch.arange(20).detach().numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 796, "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef adagrad(params, grads, states, hyperparams):\n    eps = 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(s + tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate' : 0.1}, data_iter)", "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom d2l import torch as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] += torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.Adagrad\nd2l.train_concise_ch11(trainer, {'lr': 0.1}, data_iter)"}
+{"id": 797, "tensorflow": "import math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef rmsprop(params, grads, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(gamma * s + (1 - gamma) * tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.RMSprop\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)", "pytorch": "import math\nimport torch\nfrom d2l import torch as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = torch.arange(40).detach().numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = torch.zeros((feature_dim, 1))\n    s_b = torch.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        with torch.no_grad():\n            s[:] = gamma * s + (1 - gamma) * torch.square(p.grad)\n            p[:] -= hyperparams['lr'] * p.grad / torch.sqrt(s + eps)\n        p.grad.data.zero_()\ntrainer = torch.optim.RMSprop\nd2l.train_concise_ch11(trainer, {'lr': 0.01, 'alpha': 0.9}, data_iter)"}
+{"id": 798, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adadelta_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    delta_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    delta_b = tf.Variable(tf.zeros(1))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, grads, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta), grad in zip(params, states, grads):\n        s[:].assign(rho * s + (1 - rho) * tf.math.square(grad))\n        g = (tf.math.sqrt(delta + eps) / tf.math.sqrt(s + eps)) * grad\n        p[:].assign(p - g)\n        delta[:].assign(rho * delta + (1 - rho) * g * g)\ntrainer = tf.keras.optimizers.Adadelta\nd2l.train_concise_ch11(trainer, {'learning_rate':5.0, 'rho': 0.9}, data_iter)", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    delta_w, delta_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        with torch.no_grad():\n            s[:] = rho * s + (1 - rho) * torch.square(p.grad)\n            g = (torch.sqrt(delta + eps) / torch.sqrt(s + eps)) * p.grad\n            p[:] -= g\n            delta[:] = rho * delta + (1 - rho) * g * g\n        p.grad.data.zero_()\ntrainer = torch.optim.Adadelta\nd2l.train_concise_ch11(trainer, {'rho': 0.9}, data_iter)"}
+{"id": 799, "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adam_states(feature_dim):\n    v_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(beta2 * s + (1 - beta2) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\ntrainer = tf.keras.optimizers.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(s + (1 - beta2) * tf.math.sign(tf.math.square(grad) - s) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "pytorch": "%matplotlib inline\nimport torch\nfrom d2l import torch as d2l\ndef init_adam_states(feature_dim):\n    v_w, v_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    s_w, s_b = torch.zeros((feature_dim, 1)), torch.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = beta2 * s + (1 - beta2) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ntrainer = torch.optim.Adam\nd2l.train_concise_ch11(trainer, {'lr': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        with torch.no_grad():\n            v[:] = beta1 * v + (1 - beta1) * p.grad\n            s[:] = s + (1 - beta2) * torch.sign(torch.square(p.grad) - s) * torch.square(p.grad)\n            v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n            s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n            p[:] -= hyperparams['lr'] * v_bias_corr / (torch.sqrt(s_bias_corr) + eps)\n        p.grad.data.zero_()\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 800, "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom tensorflow.keras.callbacks import LearningRateScheduler\nfrom d2l import tensorflow as d2l\ndef net():\n    return tf.keras.models.Sequential([\n        tf.keras.layers.Conv2D(filters=6, kernel_size=5, activation='relu', padding='same'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Conv2D(filters=16, kernel_size=5, activation='relu'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Flatten(),\n        tf.keras.layers.Dense(120, activation='relu'),\n        tf.keras.layers.Dense(84, activation='sigmoid'),\n        tf.keras.layers.Dense(10)])\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net_fn, train_iter, test_iter, num_epochs, lr, device=d2l.try_gpu(), custom_callback = False):\n    device_name = device._device_name\n    strategy = tf.distribute.OneDeviceStrategy(device_name)\n    with strategy.scope():\n        optimizer = tf.keras.optimizers.SGD(learning_rate=lr)\n        loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n        net = net_fn()\n        net.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n    callback = d2l.TrainCallback(net, train_iter, test_iter, num_epochs, device_name)\n    if custom_callback is False:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback])\n    else:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback, custom_callback])\n    return net\nlr, num_epochs = 0.3, 30\ntrain(net, train_iter, test_iter, num_epochs, lr)\nlr = 0.1\ndummy_model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)])\ndummy_model.compile(tf.keras.optimizers.SGD(learning_rate=lr), loss='mse')\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(tf.range(50), [scheduler(t) for t in range(50)])\nclass MultiFactorScheduler:\n    def __init__(self, step, factor, base_lr):\n        self.step = step\n        self.factor = factor\n        self.base_lr = base_lr\n    def __call__(self, epoch):\n        if epoch in self.step:\n            self.base_lr = self.base_lr * self.factor\n            return self.base_lr\n        else:\n            return self.base_lr\nscheduler = MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))", "pytorch": "%matplotlib inline\nimport math\nimport torch\nfrom torch import nn\nfrom torch.optim import lr_scheduler\nfrom d2l import torch as d2l\ndef net_fn():\n    model = nn.Sequential(\n        nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Conv2d(6, 16, kernel_size=5), nn.ReLU(),\n        nn.MaxPool2d(kernel_size=2, stride=2),\n        nn.Flatten(),\n        nn.Linear(16 * 5 * 5, 120), nn.ReLU(),\n        nn.Linear(120, 84), nn.ReLU(),\n        nn.Linear(84, 10))\n    return model\nloss = nn.CrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler=None):\n    net.to(device)\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            net.train()\n            trainer.zero_grad()\n            X, y = X.to(device), y.to(device)\n            y_hat = net(X)\n            l = loss(y_hat, y)\n            l.backward()\n            trainer.step()\n            with torch.no_grad():\n                metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch+1, (None, None, test_acc))\n        if scheduler:\n            if scheduler.__module__ == lr_scheduler.__name__:\n                scheduler.step()\n            else:\n                for param_group in trainer.param_groups:\n                    param_group['lr'] = scheduler(epoch)\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nlr = 0.1\ntrainer.param_groups[0][\"lr\"] = lr\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(torch.arange(50), [scheduler(t) for t in range(50)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nscheduler = lr_scheduler.MultiStepLR(trainer, milestones=[15, 30], gamma=0.5)\ndef get_lr(trainer, scheduler):\n    lr = scheduler.get_last_lr()[0]\n    trainer.step()\n    scheduler.step()\n    return lr\nd2l.plot(torch.arange(num_epochs), [get_lr(trainer, scheduler) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(torch.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\nnet = net_fn()\ntrainer = torch.optim.SGD(net.parameters(), lr=0.3)\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device, scheduler)"}
+{"id": 801, "tensorflow": "import tensorflow as tf\nfrom tensorflow.keras.layers import Dense\nfrom d2l import tensorflow as d2l\ndef get_net():\n    net = tf.keras.Sequential()\n    net.add(Dense(256, input_shape = (512,), activation = \"relu\"))\n    net.add(Dense(128, activation = \"relu\"))\n    net.add(Dense(2, activation = \"linear\"))\n    return net\nx = tf.random.normal([1,512])\nnet = get_net()\nnet(x)\nnet = tf.function(net)\nnet(x)", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef get_net():\n    net = nn.Sequential(nn.Linear(512, 256),\n            nn.ReLU(),\n            nn.Linear(256, 128),\n            nn.ReLU(),\n            nn.Linear(128, 2))\n    return net\nx = torch.randn(size=(1, 512))\nnet = get_net()\nnet(x)\nnet = torch.jit.script(net)\nnet(x)"}
+{"id": 802, "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass MultiHeadAttention(nn.Block):\n    def __init__(self, num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(MultiHeadAttention, self).__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_k = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_v = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n        self.W_o = nn.Dense(num_hiddens, use_bias=use_bias, flatten=False)\n    def forward(self, queries, keys, values, valid_lens):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = valid_lens.repeat(self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = X.reshape(X.shape[0], X.shape[1], num_heads, -1)\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(-1, X.shape[2], X.shape[3])\ndef transpose_output(X, num_heads):\n    X = X.reshape(-1, num_heads, X.shape[1], X.shape[2])\n    X = X.transpose(0, 2, 1, 3)\n    return X.reshape(X.shape[0], X.shape[1], -1)\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens =  6, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nY = np.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens).shape", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass MultiHeadAttention(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_heads = num_heads\n        self.attention = d2l.DotProductAttention(dropout)\n        self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_v = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n        self.W_o = tf.keras.layers.Dense(num_hiddens, use_bias=bias)\n    def call(self, queries, keys, values, valid_lens, **kwargs):\n\n        queries = transpose_qkv(self.W_q(queries), self.num_heads)\n        keys = transpose_qkv(self.W_k(keys), self.num_heads)\n        values = transpose_qkv(self.W_v(values), self.num_heads)\n        if valid_lens is not None:\n            valid_lens = tf.repeat(valid_lens, repeats=self.num_heads, axis=0)\n        output = self.attention(queries, keys, values, valid_lens, **kwargs)\n        output_concat = transpose_output(output, self.num_heads)\n        return self.W_o(output_concat)\ndef transpose_qkv(X, num_heads):\n    X = tf.reshape(X, shape=(X.shape[0], X.shape[1], num_heads, -1))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(-1, X.shape[2], X.shape[3]))\ndef transpose_output(X, num_heads):\n    X = tf.reshape(X, shape=(-1, num_heads, X.shape[1], X.shape[2]))\n    X = tf.transpose(X, perm=(0, 2, 1, 3))\n    return tf.reshape(X, shape=(X.shape[0], X.shape[1], -1))\nnum_hiddens, num_heads = 100, 5\nattention = MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries = 2, 4\nnum_kvpairs, valid_lens = 6, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nY = tf.ones((batch_size, num_kvpairs, num_hiddens))\nattention(X, Y, Y, valid_lens, training=False).shape"}
+{"id": 803, "mxnet": "import math\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_heads, 0.5)\nattention.initialize()\nbatch_size, num_queries, valid_lens = 2, 4, np.array([3, 2])\nX = np.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens).shape\nclass PositionalEncoding(nn.Block):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super(PositionalEncoding, self).__init__()\n        self.dropout = nn.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len).reshape(-1, 1) / np.power(10000, np.arange(0, num_hiddens, 2) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def forward(self, X):\n        X = X + self.P[:, :X.shape[1], :].as_in_ctx(X.ctx)\n        return self.dropout(X)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\npos_encoding.initialize()\nX = pos_encoding(np.zeros((1, num_steps, encoding_dim)))\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = np.expand_dims(np.expand_dims(P[0, :, :], 0), 0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')", "tensorflow": "import numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nnum_hiddens, num_heads = 100, 5\nattention = d2l.MultiHeadAttention(num_hiddens, num_hiddens, num_hiddens, num_hiddens, num_heads, 0.5)\nbatch_size, num_queries, valid_lens = 2, 4, tf.constant([3, 2])\nX = tf.ones((batch_size, num_queries, num_hiddens))\nattention(X, X, X, valid_lens, training=False).shape\nclass PositionalEncoding(tf.keras.layers.Layer):\n    def __init__(self, num_hiddens, dropout, max_len=1000):\n        super().__init__()\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.P = np.zeros((1, max_len, num_hiddens))\n        X = np.arange(max_len, dtype=np.float32).reshape(-1,1)/np.power(10000, np.arange(0, num_hiddens, 2, dtype=np.float32) / num_hiddens)\n        self.P[:, :, 0::2] = np.sin(X)\n        self.P[:, :, 1::2] = np.cos(X)\n    def call(self, X, **kwargs):\n        X = X + self.P[:, :X.shape[1], :]\n        return self.dropout(X, **kwargs)\nencoding_dim, num_steps = 32, 60\npos_encoding = PositionalEncoding(encoding_dim, 0)\nX = pos_encoding(tf.zeros((1, num_steps, encoding_dim)), training=False)\nP = pos_encoding.P[:, :X.shape[1], :]\nd2l.plot(np.arange(num_steps), P[0, :, 6:10].T, xlabel='Row (position)', figsize=(6, 2.5), legend=[\"Col %d\" % d for d in np.arange(6, 10)])\nP = tf.expand_dims(tf.expand_dims(P[0, :, :], axis=0), axis=0)\nd2l.show_heatmaps(P, xlabel='Column (encoding dimension)', ylabel='Row (position)', figsize=(3.5, 4), cmap='Blues')"}
+{"id": 804, "mxnet": "import math\nimport pandas as pd\nfrom mxnet import autograd, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass PositionWiseFFN(nn.Block):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super(PositionWiseFFN, self).__init__(**kwargs)\n        self.dense1 = nn.Dense(ffn_num_hiddens, flatten=False, activation='relu')\n        self.dense2 = nn.Dense(ffn_num_outputs, flatten=False)\n    def forward(self, X):\n        return self.dense2(self.dense1(X))\nffn = PositionWiseFFN(4, 8)\nffn.initialize()\nffn(np.ones((2, 3, 4)))[0]\nln = nn.LayerNorm()\nln.initialize()\nbn = nn.BatchNorm()\nbn.initialize()\nX = np.array([[1, 2], [2, 3]])\nwith autograd.record():\n    print('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(nn.Block):\n    def __init__(self, dropout, **kwargs):\n        super(AddNorm, self).__init__(**kwargs)\n        self.dropout = nn.Dropout(dropout)\n        self.ln = nn.LayerNorm()\n    def forward(self, X, Y):\n        return self.ln(self.dropout(Y) + X)\nadd_norm = AddNorm(0.5)\nadd_norm.initialize()\nadd_norm(np.ones((2, 3, 4)), np.ones((2, 3, 4))).shape\nclass EncoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias=False, **kwargs):\n        super(EncoderBlock, self).__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout, use_bias)\n        self.addnorm1 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(dropout)\n    def forward(self, X, valid_lens):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens))\n        return self.addnorm2(Y, self.ffn(Y))\nX = np.ones((2, 100, 24))\nvalid_lens = np.array([3, 2])\nencoder_blk = EncoderBlock(24, 48, 8, 0.5)\nencoder_blk.initialize()\nencoder_blk(X, valid_lens).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, use_bias=False, **kwargs):\n        super(TransformerEncoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for _ in range(num_layers):\n            self.blks.add(EncoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, use_bias))\n    def forward(self, X, valid_lens, *args):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 48, 8, 2, 0.5)\nencoder.initialize()\nencoder(np.ones((2, 100)), valid_lens).shape\nclass DecoderBlock(nn.Block):\n    def __init__(self, num_hiddens, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super(DecoderBlock, self).__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(dropout)\n        self.attention2 = d2l.MultiHeadAttention(num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(dropout)\n    def forward(self, X, state):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = np.concatenate((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if autograd.is_training():\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = np.tile(np.arange(1, num_steps + 1, ctx=X.ctx), (batch_size, 1))\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens)\n        Y = self.addnorm1(X, X2)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens)\n        Z = self.addnorm2(Y, Y2)\n        return self.addnorm3(Z, self.ffn(Z)), state\ndecoder_blk = DecoderBlock(24, 48, 8, 0.5, 0)\ndecoder_blk.initialize()\nX = np.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout, **kwargs):\n        super(TransformerDecoder, self).__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = nn.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = nn.Sequential()\n        for i in range(num_layers):\n            self.blks.add(DecoderBlock(num_hiddens, ffn_num_hiddens, num_heads, dropout, i))\n        self.dense = nn.Dense(vocab_size, flatten=False)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def forward(self, X, state):\n        X = self.pos_encoding(self.embedding(X) * math.sqrt(self.num_hiddens))\n        self._attention_weights = [[None] * len(self.blks) for _ in range (2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), num_hiddens, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = np.concatenate(net.encoder.attention_weights, 0).reshape((num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\ndec_attention_weights_2d = [np.array(head[0]).tolist() for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = np.array(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values)\ndec_attention_weights = dec_attention_weights_filled.reshape((-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = \\ dec_attention_weights.transpose(1, 2, 3, 0, 4)\ndec_self_attention_weights.shape, dec_inter_attention_weights.shape", "tensorflow": "import numpy as np\nimport pandas as pd\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass PositionWiseFFN(tf.keras.layers.Layer):\n    def __init__(self, ffn_num_hiddens, ffn_num_outputs, **kwargs):\n        super().__init__(*kwargs)\n        self.dense1 = tf.keras.layers.Dense(ffn_num_hiddens)\n        self.relu = tf.keras.layers.ReLU()\n        self.dense2 = tf.keras.layers.Dense(ffn_num_outputs)\n    def call(self, X):\n        return self.dense2(self.relu(self.dense1(X)))\nffn = PositionWiseFFN(4, 8)\nffn(tf.ones((2, 3, 4)))[0]\nln = tf.keras.layers.LayerNormalization()\nbn = tf.keras.layers.BatchNormalization()\nX = tf.constant([[1, 2], [2, 3]], dtype=tf.float32)\nprint('layer norm:', ln(X), '\nbatch norm:', bn(X))\nclass AddNorm(tf.keras.layers.Layer):\n    def __init__(self, normalized_shape, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.dropout = tf.keras.layers.Dropout(dropout)\n        self.ln = tf.keras.layers.LayerNormalization(normalized_shape)\n    def call(self, X, Y, **kwargs):\n        return self.ln(self.dropout(Y, **kwargs) + X)\nadd_norm = AddNorm([1, 2], 0.5)\nadd_norm(tf.ones((2, 3, 4)), tf.ones((2, 3, 4)), training=False).shape\nclass EncoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.attention = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout, bias)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n    def call(self, X, valid_lens, **kwargs):\n        Y = self.addnorm1(X, self.attention(X, X, X, valid_lens, **kwargs), **kwargs)\n        return self.addnorm2(Y, self.ffn(Y), **kwargs)\nX = tf.ones((2, 100, 24))\nvalid_lens = tf.constant([3, 2])\nnorm_shape = [i for i in range(len(X.shape))][1:]\nencoder_blk = EncoderBlock(24, 24, 24, 24, norm_shape, 48, 8, 0.5)\nencoder_blk(X, valid_lens, training=False).shape\nclass TransformerEncoder(d2l.Encoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout, bias=False, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [EncoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, bias) for _ in range(num_layers)]\n    def call(self, X, valid_lens, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self.attention_weights = [None] * len(self.blks)\n        for i, blk in enumerate(self.blks):\n            X = blk(X, valid_lens, **kwargs)\n            self.attention_weights[i] = blk.attention.attention.attention_weights\n        return X\nencoder = TransformerEncoder(200, 24, 24, 24, 24, [1, 2], 48, 8, 2, 0.5)\nencoder(tf.ones((2, 100)), valid_lens, training=False).shape\nclass DecoderBlock(tf.keras.layers.Layer):\n    def __init__(self, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i, **kwargs):\n        super().__init__(**kwargs)\n        self.i = i\n        self.attention1 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm1 = AddNorm(norm_shape, dropout)\n        self.attention2 = d2l.MultiHeadAttention(key_size, query_size, value_size, num_hiddens, num_heads, dropout)\n        self.addnorm2 = AddNorm(norm_shape, dropout)\n        self.ffn = PositionWiseFFN(ffn_num_hiddens, num_hiddens)\n        self.addnorm3 = AddNorm(norm_shape, dropout)\n    def call(self, X, state, **kwargs):\n        enc_outputs, enc_valid_lens = state[0], state[1]\n\n        if state[2][self.i] is None:\n            key_values = X\n        else:\n            key_values = tf.concat((state[2][self.i], X), axis=1)\n        state[2][self.i] = key_values\n        if kwargs[\"training\"]:\n            batch_size, num_steps, _ = X.shape\n            dec_valid_lens = tf.repeat(tf.reshape(tf.range(1, num_steps + 1), shape=(-1, num_steps)), repeats=batch_size, axis=0)\n        else:\n            dec_valid_lens = None\n        X2 = self.attention1(X, key_values, key_values, dec_valid_lens, **kwargs)\n        Y = self.addnorm1(X, X2, **kwargs)\n        Y2 = self.attention2(Y, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n        Z = self.addnorm2(Y, Y2, **kwargs)\n        return self.addnorm3(Z, self.ffn(Z), **kwargs), state\ndecoder_blk = DecoderBlock(24, 24, 24, 24, [1, 2], 48, 8, 0.5, 0)\nX = tf.ones((2, 100, 24))\nstate = [encoder_blk(X, valid_lens), valid_lens, [None]]\ndecoder_blk(X, state, training=False)[0].shape\nclass TransformerDecoder(d2l.AttentionDecoder):\n    def __init__(self, vocab_size, key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hidens, num_heads, num_layers, dropout, **kwargs):\n        super().__init__(**kwargs)\n        self.num_hiddens = num_hiddens\n        self.num_layers = num_layers\n        self.embedding = tf.keras.layers.Embedding(vocab_size, num_hiddens)\n        self.pos_encoding = d2l.PositionalEncoding(num_hiddens, dropout)\n        self.blks = [DecoderBlock(key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, dropout, i) for i in range(num_layers)]\n        self.dense = tf.keras.layers.Dense(vocab_size)\n    def init_state(self, enc_outputs, enc_valid_lens, *args):\n        return [enc_outputs, enc_valid_lens, [None] * self.num_layers]\n    def call(self, X, state, **kwargs):\n        X = self.pos_encoding(self.embedding(X) * tf.math.sqrt(tf.cast(self.num_hiddens, dtype=tf.float32)), **kwargs)\n        self._attention_weights = [[None] * len(self.blks) for _ in range(2)]\n        for i, blk in enumerate(self.blks):\n            X, state = blk(X, state, **kwargs)\n            self._attention_weights[0][i] = blk.attention1.attention.attention_weights\n            self._attention_weights[1][i] = blk.attention2.attention.attention_weights\n        return self.dense(X), state\n    @property\n    def attention_weights(self):\n        return self._attention_weights\nnum_hiddens, num_layers, dropout, batch_size, num_steps = 32, 2, 0.1, 64, 10\nlr, num_epochs, device = 0.005, 200, d2l.try_gpu()\nffn_num_hiddens, num_heads = 64, 4\nkey_size, query_size, value_size = 32, 32, 32\nnorm_shape = [2]\ntrain_iter, src_vocab, tgt_vocab = d2l.load_data_nmt(batch_size, num_steps)\nencoder = TransformerEncoder(len(src_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\ndecoder = TransformerDecoder(len(tgt_vocab), key_size, query_size, value_size, num_hiddens, norm_shape, ffn_num_hiddens, num_heads, num_layers, dropout)\nnet = d2l.EncoderDecoder(encoder, decoder)\nd2l.train_seq2seq(net, train_iter, lr, num_epochs, tgt_vocab, device)\nengs = ['go .', \"i lost .\", 'he\\'s calm .', 'i\\'m home .']\nfras = ['va !', 'j\\'ai perdu .', 'il est calme .', 'je suis chez moi .']\nfor eng, fra in zip(engs, fras):\n    translation, dec_attention_weight_seq = d2l.predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, True)\n    print(f'{eng} => {translation}, f'bleu {d2l.bleu(translation, fra, k=2):.3f}')\nenc_attention_weights = tf.reshape(tf.concat(net.encoder.attention_weights, 0), (num_layers, num_heads, -1, num_steps))\nenc_attention_weights.shape\ndec_attention_weights_2d = [head[0] for step in dec_attention_weight_seq for attn in step for blk in attn for head in blk]\ndec_attention_weights_filled = tf.convert_to_tensor(np.asarray(pd.DataFrame(dec_attention_weights_2d).fillna(0.0).values).astype(np.float32))\ndec_attention_weights = tf.reshape(dec_attention_weights_filled, shape=(-1, 2, num_layers, num_heads, num_steps))\ndec_self_attention_weights, dec_inter_attention_weights = tf.transpose(dec_attention_weights, perm=(1, 2, 3, 0, 4))"}
+{"id": 805, "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x * np.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * np.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = np.arange(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = np.arange(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = np.arange(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = np.meshgrid(np.linspace(-1.0, 1.0, 101), np.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x.asnumpy(), y.asnumpy(), z.asnumpy(), **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = np.arange(-2.0, 5.0, 0.01)\nd2l.plot(x, [np.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x * tf.cos(np.pi * x)\ndef g(x):\n    return f(x) + 0.2 * tf.cos(5 * np.pi * x)\ndef annotate(text, xy, xytext):\n    d2l.plt.gca().annotate(text, xy=xy, xytext=xytext, arrowprops=dict(arrowstyle='->'))\nx = tf.range(0.5, 1.5, 0.01)\nd2l.set_figsize((4.5, 2.5))\nd2l.plot(x, [f(x), g(x)], 'x', 'risk')\nannotate('min of\\nempirical risk', (1.0, -1.2), (0.5, -1.1))\nannotate('min of risk', (1.1, -1.05), (0.95, -0.5))\nx = tf.range(-1.0, 2.0, 0.01)\nd2l.plot(x, [f(x), ], 'x', 'f(x)')\nannotate('local minimum', (-0.3, -0.25), (-0.77, -1.0))\nannotate('global minimum', (1.1, -0.95), (0.6, 0.8))\nx = tf.range(-2.0, 2.0, 0.01)\nd2l.plot(x, [x**3], 'x', 'f(x)')\nannotate('saddle point', (0, -0.2), (-0.52, -5.0))\nx, y = tf.meshgrid(tf.linspace(-1.0, 1.0, 101), tf.linspace(-1.0, 1.0, 101))\nz = x**2 - y**2\nax = d2l.plt.figure().add_subplot(111, projection='3d')\nax.plot_wireframe(x, y, z, **{'rstride': 10, 'cstride': 10})\nax.plot([0], [0], [0], 'rx')\nticks = [-1, 0, 1]\nd2l.plt.xticks(ticks)\nd2l.plt.yticks(ticks)\nax.set_zticks(ticks)\nd2l.plt.xlabel('x')\nd2l.plt.ylabel('y');\nx = tf.range(-2.0, 5.0, 0.01)\nd2l.plot(x, [tf.tanh(x)], 'x', 'f(x)')\nannotate('vanishing gradient', (4, 1), (2, 0.0))"}
+{"id": 806, "mxnet": "%matplotlib inline\nfrom mpl_toolkits import mplot3d\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nf = lambda x: 0.5 * x**2\ng = lambda x: np.cos(np.pi * x)\nh = lambda x: np.exp(0.5 * x)\nx, segment = np.arange(-2, 2, 0.01), np.array([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom mpl_toolkits import mplot3d\nfrom d2l import tensorflow as d2l\nf = lambda x: 0.5 * x**2\ng = lambda x: tf.cos(np.pi * x)\nh = lambda x: tf.exp(0.5 * x)\nx, segment = tf.range(-2, 2, 0.01), tf.constant([-1.5, 1])\nd2l.use_svg_display()\n_, axes = d2l.plt.subplots(1, 3, figsize=(9, 3))\nfor ax, func in zip(axes, [f, g, h]):\n    d2l.plot([x, segment], [func(x), func(segment)], axes=ax)"}
+{"id": 807, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = np.arange(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x):\n    return x ** 2\ndef f_grad(x):\n    return 2 * x\ndef show_trace(results, f):\n    n = max(abs(min(results)), abs(max(results)))\n    f_line = tf.range(-n, n, 0.01)\n    d2l.set_figsize()\n    d2l.plot([f_line, results], [[f(x) for x in f_line], [f(x) for x in results]], 'x', 'f(x)', fmts=['-', '-o'])\nshow_trace(results, f)"}
+{"id": 808, "mxnet": "c = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = np.meshgrid(np.arange(-5.5, 1.0, 0.1), np.arange(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = np.array(0.5)\ndef f(x):\n    return np.cosh(c * x)\ndef f_grad(x):\n    return c * np.sinh(c * x)\ndef f_hess(x):\n    return c**2 * np.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = np.array(0.15 * np.pi)\ndef f(x):\n    return x * np.cos(c * x)\ndef f_grad(x):\n    return np.cos(c * x) - c * x * np.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * np.sin(c * x) - x * c**2 * np.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += np.random.normal(0.0, 1, (1,))\n    g2 += np.random.normal(0.0, 1, (1,))\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))", "tensorflow": "c = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\nshow_trace(gd(2, f_grad), f)\ndef show_trace_2d(f, results):\n    d2l.set_figsize()\n    d2l.plt.plot(*zip(*results), '-o', color='\n    x1, x2 = tf.meshgrid(tf.range(-5.5, 1.0, 0.1), tf.range(-3.0, 1.0, 0.1))\n    d2l.plt.contour(x1, x2, f(x1, x2), colors='\n    d2l.plt.xlabel('x1')\n    d2l.plt.ylabel('x2')\nc = tf.constant(0.5)\ndef f(x):\n    return tf.cosh(c * x)\ndef f_grad(x):\n    return c * tf.sinh(c * x)\ndef f_hess(x):\n    return c**2 * tf.cosh(c * x)\ndef newton(eta=1):\n    x = 10.0\n    results = [x]\n    for i in range(10):\n        x -= eta * f_grad(x) / f_hess(x)\n        results.append(float(x))\n    return results\nshow_trace(newton(), f)\nc = tf.constant(0.15 * np.pi)\ndef f(x):\n    return x * tf.cos(c * x)\ndef f_grad(x):\n    return tf.cos(c * x) - c * x * tf.sin(c * x)\ndef f_hess(x):\n    return - 2 * c * tf.sin(c * x) - x * c**2 * tf.cos(c * x)\nshow_trace(newton(), f)\n%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef f(x1, x2):\n    return x1 ** 2 + 2 * x2 ** 2\ndef f_grad(x1, x2):\n    return 2 * x1, 4 * x2\ndef sgd(x1, x2, s1, s2, f_grad):\n    g1, g2 = f_grad(x1, x2)\n    g1 += tf.random.normal([1], 0.0, 1)\n    g2 += tf.random.normal([1], 0.0, 1)\n    eta_t = eta * lr()\n    return (x1 - eta_t * g1, x2 - eta_t * g2, 0, 0)\ndef constant_lr():\n    return 1\neta = 0.1\nlr = constant_lr\nd2l.show_trace_2d(f, d2l.train_2d(sgd, steps=50, f_grad=f_grad))"}
+{"id": 809, "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ntimer = d2l.Timer()\nA = np.zeros((256, 256))\nB = np.random.normal(0, 1, (256, 256))\nC = np.random.normal(0, 1, (256, 256))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j] = np.dot(B[i, :], C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j] = np.dot(B, C[:, j])\nA.wait_to_read()\ntimer.stop()\ntimer.start()\nA = np.dot(B, C)\nA.wait_to_read()\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64] = np.dot(B, C[:, j:j+64])\ntimer.stop()\ndef sgd(params, states, hyperparams):\n    for p in params:\n        p[:] -= hyperparams['lr'] * p.grad\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = np.random.normal(scale=0.01, size=(feature_dim, 1))\n    b = np.zeros(1)\n    w.attach_grad()\n    b.attach_grad()\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y).mean()\n            l.backward()\n            trainer_fn([w, b], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(tr_name, hyperparams, data_iter, num_epochs=2):\n    net = nn.Sequential()\n    net.add(nn.Dense(1))\n    net.initialize(init.Normal(sigma=0.01))\n    trainer = gluon.Trainer(net.collect_params(), tr_name, hyperparams)\n    loss = gluon.loss.L2Loss()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with autograd.record():\n                l = loss(net(X), y)\n            l.backward()\n            trainer.step(X.shape[0])\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                animator.add(n/X.shape[0]/len(data_iter), (d2l.evaluate_loss(net, data_iter, loss),))\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrain_concise_ch11('sgd', {'learning_rate': 0.05}, data_iter)", "tensorflow": "%matplotlib inline\nimport numpy as np\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ntimer = d2l.Timer()\nA = tf.Variable(tf.zeros((256, 256)))\nB = tf.Variable(tf.random.normal([256, 256], 0, 1))\nC = tf.Variable(tf.random.normal([256, 256], 0, 1))\ntimer.start()\nfor i in range(256):\n    for j in range(256):\n        A[i, j].assign(tf.tensordot(B[i, :], C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nfor j in range(256):\n    A[:, j].assign(tf.tensordot(B, C[:, j], axes=1))\ntimer.stop()\ntimer.start()\nA.assign(tf.tensordot(B, C, axes=1))\ntimer.stop()\ngigaflops = [2/i for i in timer.times]\ntimer.start()\nfor j in range(0, 256, 64):\n    A[:, j:j+64].assign(tf.tensordot(B, C[:, j:j+64], axes=1))\ntimer.stop()\ndef sgd(params, grads, states, hyperparams):\n    for param, grad in zip(params, grads):\n        param.assign_sub(hyperparams['lr']*grad)\ndef train_ch11(trainer_fn, states, hyperparams, data_iter, feature_dim, num_epochs=2):\n    w = tf.Variable(tf.random.normal(shape=(feature_dim, 1), mean=0, stddev=0.01),trainable=True)\n    b = tf.Variable(tf.zeros(1), trainable=True)\n    net, loss = lambda X: d2l.linreg(X, w, b), d2l.squared_loss\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n            l = tf.math.reduce_mean(loss(net(X), y))\n            dw, db = g.gradient(l, [w, b])\n            trainer_fn([w, b], [dw, db], states, hyperparams)\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss),)\n                animator.add(q, r)\n                timer.start()\n    return timer.cumsum(), animator.Y[0]\ndef train_concise_ch11(trainer_fn, hyperparams, data_iter, num_epochs=2):\n    net = tf.keras.Sequential()\n    net.add(tf.keras.layers.Dense(1, kernel_initializer=tf.random_normal_initializer(stddev=0.01)))\n    optimizer = trainer_fn(**hyperparams)\n    loss = tf.keras.losses.MeanSquaredError()\n    animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[0, num_epochs], ylim=[0.22, 0.35])\n    n, timer = 0, d2l.Timer()\n    for _ in range(num_epochs):\n        for X, y in data_iter:\n            with tf.GradientTape() as g:\n                out = net(X)\n                l = loss(y, out)\n                params = net.trainable_variables\n                grads = g.gradient(l, params)\n            optimizer.apply_gradients(zip(grads, params))\n            n += X.shape[0]\n            if n % 200 == 0:\n                timer.stop()\n                p = n/X.shape[0]\n                q = p/tf.data.experimental.cardinality(data_iter).numpy()\n                r = (d2l.evaluate_loss(net, data_iter, loss) / 2,)\n                animator.add(q, r)\n                timer.start()\ndata_iter, _ = get_data_ch11(10)\ntrainer = tf.keras.optimizers.SGD\ntrain_concise_ch11(trainer, {'learning_rate': 0.05}, data_iter)"}
+{"id": 810, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(feature_dim):\n    v_w = np.zeros((feature_dim, 1))\n    v_b = np.zeros(1)\n    return (v_w, v_b)\ndef sgd_momentum(params, states, hyperparams):\n    for p, v in zip(params, states):\n        v[:] = hyperparams['momentum'] * v + p.grad\n        p[:] -= hyperparams['lr'] * v\nd2l.train_concise_ch11('sgd', {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = np.arange(20).asnumpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\neta = 0.4\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\ndef gd_2d(x1, x2, s1, s2):\n    return (x1 - eta * 0.2 * x1, x2 - eta * 4 * x2, 0, 0)\nd2l.show_trace_2d(f_2d, d2l.train_2d(gd_2d))\nd2l.set_figsize()\nbetas = [0.95, 0.9, 0.6, 0]\nfor beta in betas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, beta ** x, label=f'beta = {beta:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();\ndef init_momentum_states(features_dim):\n    v_w = tf.Variable(tf.zeros((features_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    return (v_w, v_b)\ndef sgd_momentum(params, grads, states, hyperparams):\n    for p, v, g in zip(params, states, grads):\n        v[:].assign(hyperparams['momentum'] * v + g)\n        p[:].assign(p - hyperparams['lr'] * v)\ntrainer = tf.keras.optimizers.SGD\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.005, 'momentum': 0.9}, data_iter)\nlambdas = [0.1, 1, 10, 19]\neta = 0.1\nd2l.set_figsize((6, 4))\nfor lam in lambdas:\n    t = tf.range(20).numpy()\n    d2l.plt.plot(t, (1 - eta * lam) ** t, label=f'lambda = {lam:.2f}')\nd2l.plt.xlabel('time')\nd2l.plt.legend();"}
+{"id": 811, "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef adagrad(params, states, hyperparams):\n    eps = 1e-6\n    for p, s in zip(params, states):\n        s[:] += np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('adagrad', {'learning_rate': 0.1}, data_iter)", "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef adagrad_2d(x1, x2, s1, s2):\n    eps = 1e-6\n    g1, g2 = 0.2 * x1, 4 * x2\n    s1 += g1 ** 2\n    s2 += g2 ** 2\n    x1 -= eta / math.sqrt(s1 + eps) * g1\n    x2 -= eta / math.sqrt(s2 + eps) * g2\n    return x1, x2, s1, s2\ndef f_2d(x1, x2):\n    return 0.1 * x1 ** 2 + 2 * x2 ** 2\neta = 0.4\nd2l.show_trace_2d(f_2d, d2l.train_2d(adagrad_2d))\ndef init_adagrad_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef adagrad(params, grads, states, hyperparams):\n    eps = 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(s + tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.Adagrad\nd2l.train_concise_ch11(trainer, {'learning_rate' : 0.1}, data_iter)"}
+{"id": 812, "mxnet": "%matplotlib inline\nimport math\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = np.arange(40).asnumpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = np.zeros((feature_dim, 1))\n    s_b = np.zeros(1)\n    return (s_w, s_b)\ndef rmsprop(params, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s in zip(params, states):\n        s[:] = gamma * s + (1 - gamma) * np.square(p.grad)\n        p[:] -= hyperparams['lr'] * p.grad / np.sqrt(s + eps)\nd2l.train_concise_ch11('rmsprop', {'learning_rate': 0.01, 'gamma1': 0.9}, data_iter)", "tensorflow": "import math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nd2l.set_figsize()\ngammas = [0.95, 0.9, 0.8, 0.7]\nfor gamma in gammas:\n    x = tf.range(40).numpy()\n    d2l.plt.plot(x, (1-gamma) * gamma ** x, label=f'gamma = {gamma:.2f}')\nd2l.plt.xlabel('time');\ndef init_rmsprop_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return (s_w, s_b)\ndef rmsprop(params, grads, states, hyperparams):\n    gamma, eps = hyperparams['gamma'], 1e-6\n    for p, s, g in zip(params, states, grads):\n        s[:].assign(gamma * s + (1 - gamma) * tf.math.square(g))\n        p[:].assign(p - hyperparams['lr'] * g / tf.math.sqrt(s + eps))\ntrainer = tf.keras.optimizers.RMSprop\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01, 'rho': 0.9}, data_iter)"}
+{"id": 813, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adadelta_states(feature_dim):\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    delta_w, delta_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta) in zip(params, states):\n        s[:] = rho * s + (1 - rho) * np.square(p.grad)\n        g = (np.sqrt(delta + eps) / np.sqrt(s + eps)) * p.grad\n        p[:] -= g\n        delta[:] = rho * delta + (1 - rho) * g * g\nd2l.train_concise_ch11('adadelta', {'rho': 0.9}, data_iter)", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adadelta_states(feature_dim):\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    delta_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    delta_b = tf.Variable(tf.zeros(1))\n    return ((s_w, delta_w), (s_b, delta_b))\ndef adadelta(params, grads, states, hyperparams):\n    rho, eps = hyperparams['rho'], 1e-5\n    for p, (s, delta), grad in zip(params, states, grads):\n        s[:].assign(rho * s + (1 - rho) * tf.math.square(grad))\n        g = (tf.math.sqrt(delta + eps) / tf.math.sqrt(s + eps)) * grad\n        p[:].assign(p - g)\n        delta[:].assign(rho * delta + (1 - rho) * g * g)\ntrainer = tf.keras.optimizers.Adadelta\nd2l.train_concise_ch11(trainer, {'learning_rate':5.0, 'rho': 0.9}, data_iter)"}
+{"id": 814, "mxnet": "%matplotlib inline\nfrom mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef init_adam_states(feature_dim):\n    v_w, v_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    s_w, s_b = np.zeros((feature_dim, 1)), np.zeros(1)\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = beta2 * s + (1 - beta2) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\nd2l.train_concise_ch11('adam', {'learning_rate': 0.01}, data_iter)\ndef yogi(params, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-3\n    for p, (v, s) in zip(params, states):\n        v[:] = beta1 * v + (1 - beta1) * p.grad\n        s[:] = s + (1 - beta2) * np.sign(np.square(p.grad) - s) * np.square(p.grad)\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:] -= hyperparams['lr'] * v_bias_corr / (np.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);", "tensorflow": "%matplotlib inline\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef init_adam_states(feature_dim):\n    v_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    v_b = tf.Variable(tf.zeros(1))\n    s_w = tf.Variable(tf.zeros((feature_dim, 1)))\n    s_b = tf.Variable(tf.zeros(1))\n    return ((v_w, s_w), (v_b, s_b))\ndef adam(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(beta2 * s + (1 - beta2) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\ntrainer = tf.keras.optimizers.Adam\nd2l.train_concise_ch11(trainer, {'learning_rate': 0.01}, data_iter)\ndef yogi(params, grads, states, hyperparams):\n    beta1, beta2, eps = 0.9, 0.999, 1e-6\n    for p, (v, s), grad in zip(params, states, grads):\n        v[:].assign(beta1 * v  + (1 - beta1) * grad)\n        s[:].assign(s + (1 - beta2) * tf.math.sign(tf.math.square(grad) - s) * tf.math.square(grad))\n        v_bias_corr = v / (1 - beta1 ** hyperparams['t'])\n        s_bias_corr = s / (1 - beta2 ** hyperparams['t'])\n        p[:].assign(p - hyperparams['lr'] * v_bias_corr / tf.math.sqrt(s_bias_corr) + eps)\n    hyperparams['t'] += 1\ndata_iter, feature_dim = d2l.get_data_ch11(batch_size=10)\nd2l.train_ch11(yogi, init_adam_states(feature_dim), {'lr': 0.01, 't': 1}, data_iter, feature_dim);"}
+{"id": 815, "mxnet": "%matplotlib inline\nfrom mxnet import autograd, gluon, init, lr_scheduler, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nnet = nn.HybridSequential()\nnet.add(nn.Conv2D(channels=6, kernel_size=5, padding=2, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Conv2D(channels=16, kernel_size=5, activation='relu'),\n        nn.MaxPool2D(pool_size=2, strides=2),\n        nn.Dense(120, activation='relu'),\n        nn.Dense(84, activation='relu'),\n        nn.Dense(10))\nnet.hybridize()\nloss = gluon.loss.SoftmaxCrossEntropyLoss()\ndevice = d2l.try_gpu()\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net, train_iter, test_iter, num_epochs, loss, trainer, device):\n    net.initialize(force_reinit=True, ctx=device, init=init.Xavier())\n    animator = d2l.Animator(xlabel='epoch', xlim=[0, num_epochs], legend=['train loss', 'train acc', 'test acc'])\n    for epoch in range(num_epochs):\n        metric = d2l.Accumulator(3)\n        for i, (X, y) in enumerate(train_iter):\n            X, y = X.as_in_ctx(device), y.as_in_ctx(device)\n            with autograd.record():\n                y_hat = net(X)\n                l = loss(y_hat, y)\n            l.backward()\n            trainer.step(X.shape[0])\n            metric.add(l.sum(), d2l.accuracy(y_hat, y), X.shape[0])\n            train_loss = metric[0] / metric[2]\n            train_acc = metric[1] / metric[2]\n            if (i + 1) % 50 == 0:\n                animator.add(epoch + i / len(train_iter), (train_loss, train_acc, None))\n        test_acc = d2l.evaluate_accuracy_gpu(net, test_iter)\n        animator.add(epoch + 1, (None, None, test_acc))\n    print(f'train loss {train_loss:.3f}, train acc {train_acc:.3f}, f'test acc {test_acc:.3f}')\nlr, num_epochs = 0.3, 30\nnet.initialize(force_reinit=True, ctx=device, init=init.Xavier())\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': lr})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\ntrainer.set_learning_rate(0.1)\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(np.arange(50), [scheduler(t) for t in range(50)])\nscheduler = lr_scheduler.MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)\nscheduler = lr_scheduler.CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(np.arange(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'lr_scheduler': scheduler})\ntrain(net, train_iter, test_iter, num_epochs, loss, trainer, device)", "tensorflow": "%matplotlib inline\nimport math\nimport tensorflow as tf\nfrom tensorflow.keras.callbacks import LearningRateScheduler\nfrom d2l import tensorflow as d2l\ndef net():\n    return tf.keras.models.Sequential([\n        tf.keras.layers.Conv2D(filters=6, kernel_size=5, activation='relu', padding='same'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Conv2D(filters=16, kernel_size=5, activation='relu'),\n        tf.keras.layers.AvgPool2D(pool_size=2, strides=2),\n        tf.keras.layers.Flatten(),\n        tf.keras.layers.Dense(120, activation='relu'),\n        tf.keras.layers.Dense(84, activation='sigmoid'),\n        tf.keras.layers.Dense(10)])\nbatch_size = 256\ntrain_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size)\ndef train(net_fn, train_iter, test_iter, num_epochs, lr, device=d2l.try_gpu(), custom_callback = False):\n    device_name = device._device_name\n    strategy = tf.distribute.OneDeviceStrategy(device_name)\n    with strategy.scope():\n        optimizer = tf.keras.optimizers.SGD(learning_rate=lr)\n        loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)\n        net = net_fn()\n        net.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])\n    callback = d2l.TrainCallback(net, train_iter, test_iter, num_epochs, device_name)\n    if custom_callback is False:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback])\n    else:\n        net.fit(train_iter, epochs=num_epochs, verbose=0, callbacks=[callback, custom_callback])\n    return net\nlr, num_epochs = 0.3, 30\ntrain(net, train_iter, test_iter, num_epochs, lr)\nlr = 0.1\ndummy_model = tf.keras.models.Sequential([tf.keras.layers.Dense(10)])\ndummy_model.compile(tf.keras.optimizers.SGD(learning_rate=lr), loss='mse')\nscheduler = SquareRootScheduler(lr=0.1)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nclass FactorScheduler:\n    def __init__(self, factor=1, stop_factor_lr=1e-7, base_lr=0.1):\n        self.factor = factor\n        self.stop_factor_lr = stop_factor_lr\n        self.base_lr = base_lr\n    def __call__(self, num_update):\n        self.base_lr = max(self.stop_factor_lr, self.base_lr * self.factor)\n        return self.base_lr\nscheduler = FactorScheduler(factor=0.9, stop_factor_lr=1e-2, base_lr=2.0)\nd2l.plot(tf.range(50), [scheduler(t) for t in range(50)])\nclass MultiFactorScheduler:\n    def __init__(self, step, factor, base_lr):\n        self.step = step\n        self.factor = factor\n        self.base_lr = base_lr\n    def __call__(self, epoch):\n        if epoch in self.step:\n            self.base_lr = self.base_lr * self.factor\n            return self.base_lr\n        else:\n            return self.base_lr\nscheduler = MultiFactorScheduler(step=[15, 30], factor=0.5, base_lr=0.5)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(max_update=20, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))\nscheduler = CosineScheduler(20, warmup_steps=5, base_lr=0.3, final_lr=0.01)\nd2l.plot(tf.range(num_epochs), [scheduler(t) for t in range(num_epochs)])\ntrain(net, train_iter, test_iter, num_epochs, lr, custom_callback=LearningRateScheduler(scheduler))"}
+{"id": 816, "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef get_net():\n    net = nn.HybridSequential()\n    net.add(nn.Dense(256, activation='relu'),\n            nn.Dense(128, activation='relu'),\n            nn.Dense(2))\n    net.initialize()\n    return net\nx = np.random.normal(size=(1, 512))\nnet = get_net()\nnet(x)\nnet.hybridize()\nnet(x)", "tensorflow": "import tensorflow as tf\nfrom tensorflow.keras.layers import Dense\nfrom d2l import tensorflow as d2l\ndef get_net():\n    net = tf.keras.Sequential()\n    net.add(Dense(256, input_shape = (512,), activation = \"relu\"))\n    net.add(Dense(128, activation = \"relu\"))\n    net.add(Dense(2, activation = \"linear\"))\n    return net\nx = tf.random.normal([1,512])\nnet = get_net()\nnet(x)\nnet = tf.function(net)\nnet(x)"}