diff --git "a/CodeTrans Datasets/DLTrans/dl_valid.json" "b/CodeTrans Datasets/DLTrans/dl_valid.json" new file mode 100644--- /dev/null +++ "b/CodeTrans Datasets/DLTrans/dl_valid.json" @@ -0,0 +1,72 @@ +{"id": 565, "tensorflow": "import tensorflow as tf\nclass Encoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def call(self, X, *args, **kwargs):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def call(self, X, state, **kwargs):\n raise NotImplementedError\nclass EncoderDecoder(tf.keras.Model):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def call(self, enc_X, dec_X, *args, **kwargs):\n enc_outputs = self.encoder(enc_X, *args, **kwargs)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state, **kwargs)", "paddle": "import warnings\nwarnings.filterwarnings(\"ignore\")\nfrom paddle import nn\nclass Encoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Layer):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 566, "tensorflow": "import collections\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(*kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n def call(self, X, *args, **kwargs):\n X = self.embedding(X)\n output = self.rnn(X, **kwargs)\n state = output[1:]\n return output[0], state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\noutput, state = encoder(X, training=False)\noutput.shape\nlen(state), [element.shape for element in state]\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def call(self, X, state, **kwargs):\n X = self.embedding(X)\n context = tf.repeat(tf.expand_dims(state[-1], axis=1), repeats=X.shape[1], axis=1)\n X_and_context = tf.concat((X, context), axis=2)\n rnn_output = self.rnn(X_and_context, state, **kwargs)\n output = self.dense(rnn_output[0])\n return output, rnn_output[1:]\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = tf.range(start=0, limit=maxlen, dtype=tf.float32)[None, :] < tf.cast(valid_len[:, None], dtype=tf.float32)\n if len(X.shape) == 3:\n return tf.where(tf.expand_dims(mask, axis=-1), X, value)\n else:\n return tf.where(mask, X, value)\nX = tf.constant([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, tf.constant([1, 2]))\nX = tf.ones((2,3,4))\nsequence_mask(X, tf.constant([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(tf.keras.losses.Loss):\n def __init__(self, valid_len):\n super().__init__(reduction='none')\n self.valid_len = valid_len\n\n def call(self, label, pred):\n weights = tf.ones_like(label, dtype=tf.float32)\n weights = sequence_mask(weights, self.valid_len)\n label_one_hot = tf.one_hot(label, depth=pred.shape[-1])\n unweighted_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, reduction='none')(label_one_hot, pred)\n weighted_loss = tf.reduce_mean((unweighted_loss*weights), axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss(tf.constant([4, 2, 0]))\nloss(tf.ones((3,4), dtype = tf.int32), tf.ones((3, 4, 10))).numpy()\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = tf.keras.optimizers.Adam(learning_rate=lr)\n animator = d2l.Animator(xlabel=\"epoch\", ylabel=\"loss\", xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [x for x in batch]\n bos = tf.reshape(tf.constant([tgt_vocab['']] * Y.shape[0]), shape=(-1, 1))\n dec_input = tf.concat([bos, Y[:, :-1]], 1)\n with tf.GradientTape() as tape:\n Y_hat, _ = net(X, dec_input, X_valid_len, training=True)\n l = MaskedSoftmaxCELoss(Y_valid_len)(Y, Y_hat)\n gradients = tape.gradient(l, net.trainable_variables)\n gradients = d2l.grad_clipping(gradients, 1)\n optimizer.apply_gradients(zip(gradients, net.trainable_variables))\n num_tokens = tf.reduce_sum(Y_valid_len).numpy()\n metric.add(tf.reduce_sum(l), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = tf.constant([len(src_tokens)])\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = tf.expand_dims(src_tokens, axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len, training=False)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = tf.expand_dims(tf.constant([tgt_vocab['']]), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state, training=False)\n dec_X = tf.argmax(Y, axis=2)\n pred = tf.squeeze(dec_X, axis=0)\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred.numpy())\n return ' '.join(tgt_vocab.to_tokens(tf.reshape(output_seq, shape = -1).numpy().tolist())), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')", "paddle": "import collections\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr, weight_hh_attr=weight_hh_attr)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.transpose([1, 0, 2])\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = paddle.zeros((4, 7), dtype=paddle.int64)\noutput, state = encoder(X)\noutput.shape\nstate.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n weight_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr,weight_hh_attr=weight_hh_attr)\n self.dense = nn.Linear(num_hiddens, vocab_size,weight_attr=weight_attr)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).transpose([1, 0, 2])\n context = state[-1].tile([X.shape[0], 1, 1])\n X_and_context = paddle.concat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).transpose([1, 0, 2])\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, state.shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = paddle.arange((maxlen), dtype=paddle.float32)[None, :] < valid_len[:, None]\n Xtype = X.dtype\n X = X.astype(paddle.float32)\n X[~mask] = float(value)\n return X.astype(Xtype)\nX = paddle.to_tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, paddle.to_tensor([1, 2]))\nX = paddle.ones([2, 3, 4])\nsequence_mask(X, paddle.to_tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = paddle.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred, label)\n weighted_loss = (unweighted_loss * weights).mean(axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(paddle.ones([3, 4, 10]), paddle.ones((3, 4), dtype=paddle.int64), paddle.to_tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = paddle.optimizer.Adam(learning_rate=lr, parameters=net.parameters())\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.clear_grad()\n X, X_valid_len, Y, Y_valid_len = [paddle.to_tensor(x, place=device) for x in batch]\n bos = paddle.to_tensor([tgt_vocab['']] * Y.shape[0]).reshape([-1, 1])\n dec_input = paddle.concat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len.squeeze())\n l = loss(Y_hat, Y, Y_valid_len.squeeze())\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with paddle.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = paddle.to_tensor([len(src_tokens)], place=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = paddle.unsqueeze(paddle.to_tensor(src_tokens, dtype=paddle.int64, place=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = paddle.unsqueeze(paddle.to_tensor([tgt_vocab['']], dtype=paddle.int64, place=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype(paddle.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')"} +{"id": 567, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = tf.reshape(tf.eye(10), (1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = paddle.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 568, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ntf.random.set_seed(seed=1322)\nn_train = 50\nx_train = tf.sort(tf.random.uniform(shape=(n_train,), maxval=5))\ndef f(x):\n return 2 * tf.sin(x) + x**0.8\ny_train = f(x_train) + tf.random.normal((n_train,), 0.0, 0.5)\nx_test = tf.range(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = tf.repeat(tf.reduce_mean(y_train), repeats=n_test)\nplot_kernel_reg(y_hat)\nX_repeat = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nattention_weights = tf.nn.softmax(-(X_repeat - tf.expand_dims(x_train, axis=1))**2/2, axis=1)\ny_hat = tf.matmul(attention_weights, tf.expand_dims(y_train, axis=1))\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = tf.ones((2, 1, 4))\nY = tf.ones((2, 4, 6))\ntf.matmul(X, Y).shape\nweights = tf.ones((2, 10)) * 0.1\nvalues = tf.reshape(tf.range(20.0), shape = (2, 10))\ntf.matmul(tf.expand_dims(weights, axis=1), tf.expand_dims(values, axis=-1)).numpy()\nclass NWKernelRegression(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = tf.Variable(initial_value=tf.random.uniform(shape=(1,)))\n def call(self, queries, keys, values, **kwargs):\n queries = tf.repeat(tf.expand_dims(queries, axis=1), repeats=keys.shape[1], axis=1)\n self.attention_weights = tf.nn.softmax(-((queries - keys) * self.w)**2 /2, axis =1)\n return tf.squeeze(tf.matmul(tf.expand_dims(self.attention_weights, axis=1), tf.expand_dims(values, axis=-1)))\nX_tile = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nY_tile = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_train, axis=0)\nkeys = tf.reshape(X_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nvalues = tf.reshape(Y_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nnet = NWKernelRegression()\nloss_object = tf.keras.losses.MeanSquaredError()\noptimizer = tf.keras.optimizers.SGD(learning_rate=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with tf.GradientTape() as t:\n loss = loss_object(y_train, net(x_train, keys, values)) * len(y_train)\n grads = t.gradient(loss, net.trainable_variables)\n optimizer.apply_gradients(zip(grads, net.trainable_variables))\n animator.add(epoch + 1, float(loss))\nkeys = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_test, axis=0)\nvalues = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_test, axis=0)\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(net.attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nn_train = 50\nx_train = paddle.sort(paddle.rand([n_train]) * 5)\ndef f(x):\n return 2 * paddle.sin(x) + x**0.8\ny_train = f(x_train) + paddle.normal(0.0, 0.5, (n_train,))\nx_test = paddle.arange(0, 5, 0.1, dtype='float32')\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = paddle.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, axis=1)\ny_hat = paddle.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = paddle.ones((2, 1, 4))\nY = paddle.ones((2, 4, 6))\npaddle.bmm(X, Y).shape\nweights = paddle.ones((2, 10)) * 0.1\nvalues = paddle.arange(20, dtype='float32').reshape((2, 10))\npaddle.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = paddle.create_parameter((1,), dtype='float32')\n def forward(self, queries, keys, values):\n queries = queries.reshape((queries.shape[0], 1)).tile([keys.shape[1]]).reshape((-1, keys.shape[1]))\n self.attention_weight = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, axis=1)\n return paddle.bmm(self.attention_weight.unsqueeze(1), values.unsqueeze(-1)).reshape((-1, ))\nX_tile = x_train.tile([n_train, 1])\nY_tile = y_train.tile([n_train, 1])\nkeys = X_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = paddle.optimizer.SGD(learning_rate=0.5, parameters=net.parameters())\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.clear_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.tile([n_test, 1])\nvalues = y_train.tile([n_test, 1])\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weight.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorter testing, inputs')"} +{"id": 569, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return tf.nn.softmax(X, axis=-1)\n else:\n shape = X.shape\n if len(valid_lens.shape) == 1:\n valid_lens = tf.repeat(valid_lens, repeats=shape[1])\n else:\n valid_lens = tf.reshape(valid_lens, shape=-1)\n X = d2l.sequence_mask(tf.reshape(X, shape=(-1, shape[-1])), valid_lens, value=-1e6)\n return tf.nn.softmax(tf.reshape(X, shape=shape), axis=-1)\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([2, 3]))\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([[1, 3], [2, 4]]))\nclass AdditiveAttention(tf.keras.layers.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super().__init__(**kwargs)\n self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.w_v = tf.keras.layers.Dense(1, use_bias=False)\n self.dropout = tf.keras.layers.Dropout(dropout)\n def call(self, queries, keys, values, valid_lens, **kwargs):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = tf.expand_dims(queries, axis=2) + tf.expand_dims(keys, axis=1)\n features = tf.nn.tanh(features)\n scores = tf.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries, keys = tf.random.normal(shape=(2, 1, 20)), tf.ones((2, 10, 2))\nvalues = tf.repeat(tf.reshape(tf.range(40, dtype=tf.float32), shape=(1, 10, 4)), repeats=2, axis=0)\nvalid_lens = tf.constant([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(tf.keras.layers.Layer):\n def __init__(self, dropout, **kwargs):\n super().__init__(**kwargs)\n self.dropout = tf.keras.layers.Dropout(dropout)\n\n def call(self, queries, keys, values, valid_lens, **kwargs):\n d = queries.shape[-1]\n scores = tf.matmul(queries, keys, transpose_b=True)/tf.math.sqrt(tf.cast(d, dtype=tf.float32))\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries = tf.random.normal(shape=(2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')", "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, axis=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = paddle.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape((-1,))\n X = d2l.sequence_mask(X.reshape((-1, shape[-1])), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), axis=-1)\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([2, 3]))\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias_attr=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = paddle.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = paddle.normal(0, 1, (2, 1, 20)), paddle.ones((2, 10, 2))\nvalues = paddle.arange(40, dtype=paddle.float32).reshape((1, 10, 4)).tile([2, 1, 1])\nvalid_lens = paddle.to_tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(nn.Layer):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = paddle.bmm(queries, keys.transpose((0,2,1))) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries = paddle.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')"} +{"id": 570, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs, hidden_state, enc_valid_lens)\n def call(self, X, state, **kwargs):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X)\n X = tf.transpose(X, perm=(1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = tf.expand_dims(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n x = tf.concat((context, tf.expand_dims(x, axis=1)), axis=-1)\n out = self.rnn(x, hidden_state, **kwargs)\n hidden_state = out[1:]\n outputs.append(out[0])\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(tf.concat(outputs, axis=1))\n return outputs, [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\nstate = decoder.init_state(encoder(X, training=False), None)\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = tf.reshape(tf.concat([step[0][0][0] for step in dec_attention_weight_seq], 0), (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key posistions', ylabel='Query posistions')", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, bias_ih_attr=True, time_major=True, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.transpose((1, 0, 2)), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).transpose((1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = paddle.unsqueeze(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = paddle.concat((context, paddle.unsqueeze(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.transpose((1, 0, 2)), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(paddle.concat(outputs, axis=0))\n return outputs.transpose((1, 0, 2)), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = paddle.zeros((4, 7), dtype='int64')\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = paddle.concat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape(\n (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(), xlabel='Key positions', ylabel='Query positions')"} +{"id": 571, "mxnet": "from mxnet.gluon import nn\nclass Encoder(nn.Block):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Block):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "paddle": "import warnings\nwarnings.filterwarnings(\"ignore\")\nfrom paddle import nn\nclass Encoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Layer):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 572, "mxnet": "import collections\nimport math\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.swapaxes(0, 1)\n state = self.rnn.begin_state(batch_size=X.shape[1], ctx=X.ctx)\n output, state = self.rnn(X, state)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\nX = np.zeros((4, 7))\noutput, state = encoder(X)\noutput.shape\nlen(state), state[0].shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).swapaxes(0, 1)\n context = state[0][-1]\n context = np.broadcast_to(context, (X.shape[0], context.shape[0], context.shape[1]))\n X_and_context = np.concatenate((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).swapaxes(0, 1)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape\nX = np.array([[1, 2, 3], [4, 5, 6]])\nnpx.sequence_mask(X, np.array([1, 2]), True, axis=1)\nX = np.ones((2, 3, 4))\nnpx.sequence_mask(X, np.array([1, 2]), True, value=-1, axis=1)\nclass MaskedSoftmaxCELoss(gluon.loss.SoftmaxCELoss):\n def forward(self, pred, label, valid_len):\n weights = np.expand_dims(np.ones_like(label), axis=-1)\n weights = npx.sequence_mask(weights, valid_len, True, axis=1)\n return super(MaskedSoftmaxCELoss, self).forward(pred, label, weights)\nloss = MaskedSoftmaxCELoss()\nloss(np.ones((3, 4, 10)), np.ones((3, 4)), np.array([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n net.initialize(init.Xavier(), force_reinit=True, ctx=device)\n trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr})\n loss = MaskedSoftmaxCELoss()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [\n x.as_in_ctx(device) for x in batch]\n bos = np.array([tgt_vocab['']] * Y.shape[0], ctx=device).reshape(-1, 1)\n dec_input = np.concatenate([bos, Y[:, :-1]], 1)\n with autograd.record():\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n trainer.step(num_tokens)\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [\n src_vocab['']]\n enc_valid_len = np.array([len(src_tokens)], ctx=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = np.expand_dims(np.array(src_tokens, ctx=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = np.expand_dims(np.array([tgt_vocab['']], ctx=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype('int32').item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq", "paddle": "import collections\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr, weight_hh_attr=weight_hh_attr)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.transpose([1, 0, 2])\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = paddle.zeros((4, 7), dtype=paddle.int64)\noutput, state = encoder(X)\noutput.shape\nstate.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n weight_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr,weight_hh_attr=weight_hh_attr)\n self.dense = nn.Linear(num_hiddens, vocab_size,weight_attr=weight_attr)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).transpose([1, 0, 2])\n context = state[-1].tile([X.shape[0], 1, 1])\n X_and_context = paddle.concat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).transpose([1, 0, 2])\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, state.shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = paddle.arange((maxlen), dtype=paddle.float32)[None, :] < valid_len[:, None]\n Xtype = X.dtype\n X = X.astype(paddle.float32)\n X[~mask] = float(value)\n return X.astype(Xtype)\nX = paddle.to_tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, paddle.to_tensor([1, 2]))\nX = paddle.ones([2, 3, 4])\nsequence_mask(X, paddle.to_tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = paddle.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred, label)\n weighted_loss = (unweighted_loss * weights).mean(axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(paddle.ones([3, 4, 10]), paddle.ones((3, 4), dtype=paddle.int64), paddle.to_tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = paddle.optimizer.Adam(learning_rate=lr, parameters=net.parameters())\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.clear_grad()\n X, X_valid_len, Y, Y_valid_len = [paddle.to_tensor(x, place=device) for x in batch]\n bos = paddle.to_tensor([tgt_vocab['']] * Y.shape[0]).reshape([-1, 1])\n dec_input = paddle.concat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len.squeeze())\n l = loss(Y_hat, Y, Y_valid_len.squeeze())\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with paddle.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = paddle.to_tensor([len(src_tokens)], place=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = paddle.unsqueeze(paddle.to_tensor(src_tokens, dtype=paddle.int64, place=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = paddle.unsqueeze(paddle.to_tensor([tgt_vocab['']], dtype=paddle.int64, place=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype(paddle.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq"} +{"id": 573, "mxnet": "from mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.asnumpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = np.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = paddle.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 574, "mxnet": "from mxnet import autograd, gluon, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nn_train = 50\nx_train = np.sort(np.random.rand(n_train) * 5)\ndef f(x):\n return 2 * np.sin(x) + x**0.8\ny_train = f(x_train) + np.random.normal(0.0, 0.5, (n_train,))\nx_test = np.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = y_train.mean().repeat(n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat(n_train).reshape((-1, n_train))\nattention_weights = npx.softmax(-(X_repeat - x_train)**2 / 2)\ny_hat = np.dot(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = np.ones((2, 1, 4))\nY = np.ones((2, 4, 6))\nnpx.batch_dot(X, Y).shape\nweights = np.ones((2, 10)) * 0.1\nvalues = np.arange(20).reshape((2, 10))\nnpx.batch_dot(np.expand_dims(weights, 1), np.expand_dims(values, -1))\nclass NWKernelRegression(nn.Block):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = self.params.get('w', shape=(1,))\n def forward(self, queries, keys, values):\n queries = queries.repeat(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = npx.softmax(-((queries - keys) * self.w.data())**2 / 2)\n return npx.batch_dot(np.expand_dims(self.attention_weights, 1), np.expand_dims(values, -1)).reshape(-1)\nX_tile = np.tile(x_train, (n_train, 1))\nY_tile = np.tile(y_train, (n_train, 1))\nkeys = X_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nvalues = Y_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nnet = NWKernelRegression()\nnet.initialize()\nloss = gluon.loss.L2Loss()\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.5})\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with autograd.record():\n l = loss(net(x_train, keys, values), y_train)\n l.backward()\n trainer.step(1)\n animator.add(epoch + 1, float(l.sum()))\nkeys = np.tile(x_train, (n_test, 1))\nvalues = np.tile(y_train, (n_test, 1))\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(net.attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nn_train = 50\nx_train = paddle.sort(paddle.rand([n_train]) * 5)\ndef f(x):\n return 2 * paddle.sin(x) + x**0.8\ny_train = f(x_train) + paddle.normal(0.0, 0.5, (n_train,))\nx_test = paddle.arange(0, 5, 0.1, dtype='float32')\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = paddle.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, axis=1)\ny_hat = paddle.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = paddle.ones((2, 1, 4))\nY = paddle.ones((2, 4, 6))\npaddle.bmm(X, Y).shape\nweights = paddle.ones((2, 10)) * 0.1\nvalues = paddle.arange(20, dtype='float32').reshape((2, 10))\npaddle.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = paddle.create_parameter((1,), dtype='float32')\n def forward(self, queries, keys, values):\n queries = queries.reshape((queries.shape[0], 1)).tile([keys.shape[1]]).reshape((-1, keys.shape[1]))\n self.attention_weight = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, axis=1)\n return paddle.bmm(self.attention_weight.unsqueeze(1), values.unsqueeze(-1)).reshape((-1, ))\nX_tile = x_train.tile([n_train, 1])\nY_tile = y_train.tile([n_train, 1])\nkeys = X_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = paddle.optimizer.SGD(learning_rate=0.5, parameters=net.parameters())\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.clear_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.tile([n_test, 1])\nvalues = y_train.tile([n_test, 1])\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weight.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorter testing, inputs')"} +{"id": 575, "mxnet": "import math\nfrom mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return npx.softmax(X)\n else:\n shape = X.shape\n if valid_lens.ndim == 1:\n valid_lens = valid_lens.repeat(shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = npx.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, True, value=-1e6, axis=1)\n return npx.softmax(X).reshape(shape)\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([2, 3]))\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Block):\n def __init__(self, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.W_q = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.w_v = nn.Dense(1, use_bias=False, flatten=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = np.expand_dims(queries, axis=2) + np.expand_dims(keys, axis=1)\n features = np.tanh(features)\n scores = np.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries, keys = np.random.normal(0, 1, (2, 1, 20)), np.ones((2, 10, 2))\nvalues = np.arange(40).reshape(1, 10, 4).repeat(2, axis=0)\nvalid_lens = np.array([2, 6])\nattention = AdditiveAttention(num_hiddens=8, dropout=0.1)\nattention.initialize()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Block):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = npx.batch_dot(queries, keys, transpose_b=True) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries = np.random.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.initialize()\nattention(queries, keys, values, valid_lens)", "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, axis=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = paddle.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape((-1,))\n X = d2l.sequence_mask(X.reshape((-1, shape[-1])), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), axis=-1)\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([2, 3]))\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias_attr=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = paddle.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = paddle.normal(0, 1, (2, 1, 20)), paddle.ones((2, 10, 2))\nvalues = paddle.arange(40, dtype=paddle.float32).reshape((1, 10, 4)).tile([2, 1, 1])\nvalid_lens = paddle.to_tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Layer):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = paddle.bmm(queries, keys.transpose((0,2,1))) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries = paddle.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)"} +{"id": 576, "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.swapaxes(0, 1), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).swapaxes(0, 1)\n outputs, self._attention_weights = [], []\n for x in X:\n query = np.expand_dims(hidden_state[0][-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = np.concatenate((context, np.expand_dims(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.swapaxes(0, 1), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(np.concatenate(outputs, axis=0))\n return outputs.swapaxes(0, 1), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nX = np.zeros((4, 7))\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = np.concatenate([step[0][0][0] for step in dec_attention_weight_seq], 0\n ).reshape((1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key positions', ylabel='Query positions')", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, bias_ih_attr=True, time_major=True, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.transpose((1, 0, 2)), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).transpose((1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = paddle.unsqueeze(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = paddle.concat((context, paddle.unsqueeze(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.transpose((1, 0, 2)), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(paddle.concat(outputs, axis=0))\n return outputs.transpose((1, 0, 2)), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = paddle.zeros((4, 7), dtype='int64')\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = paddle.concat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape(\n (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(), xlabel='Key positions', ylabel='Query positions')"} +{"id": 577, "pytorch": "from torch import nn\nclass Encoder(nn.Module):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Module):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Module):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "mxnet": "from mxnet.gluon import nn\nclass Encoder(nn.Block):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Block):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 578, "pytorch": "import collections\nimport math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.permute(1, 0, 2)\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\noutput, state = encoder(X)\noutput.shape\nstate.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).permute(1, 0, 2)\n context = state[-1].repeat(X.shape[0], 1, 1)\n X_and_context = torch.cat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).permute(1, 0, 2)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, state.shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.size(1)\n mask = torch.arange((maxlen), dtype=torch.float32, device=X.device)[None, :] < valid_len[:, None]\n X[~mask] = value\n return X\nX = torch.tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, torch.tensor([1, 2]))\nX = torch.ones(2, 3, 4)\nsequence_mask(X, torch.tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = torch.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred.permute(0, 2, 1), label)\n weighted_loss = (unweighted_loss * weights).mean(dim=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long), torch.tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n def xavier_init_weights(m):\n if type(m) == nn.Linear:\n nn.init.xavier_uniform_(m.weight)\n if type(m) == nn.GRU:\n for param in m._flat_weights_names:\n if \"weight\" in param:\n nn.init.xavier_uniform_(m._parameters[param])\n net.apply(xavier_init_weights)\n net.to(device)\n optimizer = torch.optim.Adam(net.parameters(), lr=lr)\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.zero_grad()\n X, X_valid_len, Y, Y_valid_len = [x.to(device) for x in batch]\n bos = torch.tensor([tgt_vocab['']] * Y.shape[0], device=device).reshape(-1, 1)\n dec_input = torch.cat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.sum().backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with torch.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = torch.tensor([len(src_tokens)], device=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = torch.unsqueeze(torch.tensor(src_tokens, dtype=torch.long, device=device), dim=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = torch.unsqueeze(torch.tensor([tgt_vocab['']], dtype=torch.long, device=device), dim=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(dim=2)\n pred = dec_X.squeeze(dim=0).type(torch.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq", "mxnet": "import collections\nimport math\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.swapaxes(0, 1)\n state = self.rnn.begin_state(batch_size=X.shape[1], ctx=X.ctx)\n output, state = self.rnn(X, state)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\nX = np.zeros((4, 7))\noutput, state = encoder(X)\noutput.shape\nlen(state), state[0].shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).swapaxes(0, 1)\n context = state[0][-1]\n context = np.broadcast_to(context, (X.shape[0], context.shape[0], context.shape[1]))\n X_and_context = np.concatenate((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).swapaxes(0, 1)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape\nX = np.array([[1, 2, 3], [4, 5, 6]])\nnpx.sequence_mask(X, np.array([1, 2]), True, axis=1)\nX = np.ones((2, 3, 4))\nnpx.sequence_mask(X, np.array([1, 2]), True, value=-1, axis=1)\nclass MaskedSoftmaxCELoss(gluon.loss.SoftmaxCELoss):\n def forward(self, pred, label, valid_len):\n weights = np.expand_dims(np.ones_like(label), axis=-1)\n weights = npx.sequence_mask(weights, valid_len, True, axis=1)\n return super(MaskedSoftmaxCELoss, self).forward(pred, label, weights)\nloss = MaskedSoftmaxCELoss()\nloss(np.ones((3, 4, 10)), np.ones((3, 4)), np.array([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n net.initialize(init.Xavier(), force_reinit=True, ctx=device)\n trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr})\n loss = MaskedSoftmaxCELoss()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [\n x.as_in_ctx(device) for x in batch]\n bos = np.array([tgt_vocab['']] * Y.shape[0], ctx=device).reshape(-1, 1)\n dec_input = np.concatenate([bos, Y[:, :-1]], 1)\n with autograd.record():\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n trainer.step(num_tokens)\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [\n src_vocab['']]\n enc_valid_len = np.array([len(src_tokens)], ctx=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = np.expand_dims(np.array(src_tokens, ctx=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = np.expand_dims(np.array([tgt_vocab['']], ctx=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype('int32').item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq"} +{"id": 579, "pytorch": "import torch\nfrom d2l import torch as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = torch.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "mxnet": "from mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.asnumpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = np.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 580, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nn_train = 50\nx_train, _ = torch.sort(torch.rand(n_train) * 5)\ndef f(x):\n return 2 * torch.sin(x) + x**0.8\ny_train = f(x_train) + torch.normal(0.0, 0.5, (n_train,))\nx_test = torch.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = torch.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, dim=1)\ny_hat = torch.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = torch.ones((2, 1, 4))\nY = torch.ones((2, 4, 6))\ntorch.bmm(X, Y).shape\nweights = torch.ones((2, 10)) * 0.1\nvalues = torch.arange(20.0).reshape((2, 10))\ntorch.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Module):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = nn.Parameter(torch.rand((1,), requires_grad=True))\n def forward(self, queries, keys, values):\n queries = queries.repeat_interleave(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, dim=1)\n return torch.bmm(self.attention_weights.unsqueeze(1), values.unsqueeze(-1)).reshape(-1)\nX_tile = x_train.repeat((n_train, 1))\nY_tile = y_train.repeat((n_train, 1))\nkeys = X_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.zero_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.repeat((n_test, 1))\nvalues = y_train.repeat((n_test, 1))\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "mxnet": "from mxnet import autograd, gluon, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nn_train = 50\nx_train = np.sort(np.random.rand(n_train) * 5)\ndef f(x):\n return 2 * np.sin(x) + x**0.8\ny_train = f(x_train) + np.random.normal(0.0, 0.5, (n_train,))\nx_test = np.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = y_train.mean().repeat(n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat(n_train).reshape((-1, n_train))\nattention_weights = npx.softmax(-(X_repeat - x_train)**2 / 2)\ny_hat = np.dot(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = np.ones((2, 1, 4))\nY = np.ones((2, 4, 6))\nnpx.batch_dot(X, Y).shape\nweights = np.ones((2, 10)) * 0.1\nvalues = np.arange(20).reshape((2, 10))\nnpx.batch_dot(np.expand_dims(weights, 1), np.expand_dims(values, -1))\nclass NWKernelRegression(nn.Block):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = self.params.get('w', shape=(1,))\n def forward(self, queries, keys, values):\n queries = queries.repeat(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = npx.softmax(-((queries - keys) * self.w.data())**2 / 2)\n return npx.batch_dot(np.expand_dims(self.attention_weights, 1), np.expand_dims(values, -1)).reshape(-1)\nX_tile = np.tile(x_train, (n_train, 1))\nY_tile = np.tile(y_train, (n_train, 1))\nkeys = X_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nvalues = Y_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nnet = NWKernelRegression()\nnet.initialize()\nloss = gluon.loss.L2Loss()\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.5})\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with autograd.record():\n l = loss(net(x_train, keys, values), y_train)\n l.backward()\n trainer.step(1)\n animator.add(epoch + 1, float(l.sum()))\nkeys = np.tile(x_train, (n_test, 1))\nvalues = np.tile(y_train, (n_test, 1))\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(net.attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 581, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, dim=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = torch.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), dim=-1)\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([2, 3]))\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Module):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = torch.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))\nvalues = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2, 1, 1)\nvalid_lens = torch.tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Module):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = torch.bmm(queries, keys.transpose(1,2)) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries = torch.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)", "mxnet": "import math\nfrom mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return npx.softmax(X)\n else:\n shape = X.shape\n if valid_lens.ndim == 1:\n valid_lens = valid_lens.repeat(shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = npx.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, True, value=-1e6, axis=1)\n return npx.softmax(X).reshape(shape)\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([2, 3]))\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Block):\n def __init__(self, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.W_q = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.w_v = nn.Dense(1, use_bias=False, flatten=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = np.expand_dims(queries, axis=2) + np.expand_dims(keys, axis=1)\n features = np.tanh(features)\n scores = np.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries, keys = np.random.normal(0, 1, (2, 1, 20)), np.ones((2, 10, 2))\nvalues = np.arange(40).reshape(1, 10, 4).repeat(2, axis=0)\nvalid_lens = np.array([2, 6])\nattention = AdditiveAttention(num_hiddens=8, dropout=0.1)\nattention.initialize()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Block):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = npx.batch_dot(queries, keys, transpose_b=True) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries = np.random.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.initialize()\nattention(queries, keys, values, valid_lens)"} +{"id": 582, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).permute(1, 0, 2)\n outputs, self._attention_weights = [], []\n for x in X:\n query = torch.unsqueeze(hidden_state[-1], dim=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)\n out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(torch.cat(outputs, dim=0))\n return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((\n 1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(), xlabel='Key positions', ylabel='Query positions')", "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.swapaxes(0, 1), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).swapaxes(0, 1)\n outputs, self._attention_weights = [], []\n for x in X:\n query = np.expand_dims(hidden_state[0][-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = np.concatenate((context, np.expand_dims(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.swapaxes(0, 1), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(np.concatenate(outputs, axis=0))\n return outputs.swapaxes(0, 1), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nX = np.zeros((4, 7))\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = np.concatenate([step[0][0][0] for step in dec_attention_weight_seq], 0\n ).reshape((1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key positions', ylabel='Query positions')"} +{"id": 583, "pytorch": "from torch import nn\nclass Encoder(nn.Module):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Module):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Module):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "paddle": "import warnings\nwarnings.filterwarnings(\"ignore\")\nfrom paddle import nn\nclass Encoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Layer):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 584, "pytorch": "import collections\nimport math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.permute(1, 0, 2)\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\noutput, state = encoder(X)\noutput.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).permute(1, 0, 2)\n context = state[-1].repeat(X.shape[0], 1, 1)\n X_and_context = torch.cat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).permute(1, 0, 2)\n return output, state\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.size(1)\n mask = torch.arange((maxlen), dtype=torch.float32, device=X.device)[None, :] < valid_len[:, None]\n X[~mask] = value\n return X\nX = torch.tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, torch.tensor([1, 2]))\nX = torch.ones(2, 3, 4)\nsequence_mask(X, torch.tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = torch.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred.permute(0, 2, 1), label)\n weighted_loss = (unweighted_loss * weights).mean(dim=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long), torch.tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n def xavier_init_weights(m):\n if type(m) == nn.Linear:\n nn.init.xavier_uniform_(m.weight)\n if type(m) == nn.GRU:\n for param in m._flat_weights_names:\n if \"weight\" in param:\n nn.init.xavier_uniform_(m._parameters[param])\n net.apply(xavier_init_weights)\n net.to(device)\n optimizer = torch.optim.Adam(net.parameters(), lr=lr)\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.zero_grad()\n X, X_valid_len, Y, Y_valid_len = [x.to(device) for x in batch]\n bos = torch.tensor([tgt_vocab['']] * Y.shape[0], device=device).reshape(-1, 1)\n dec_input = torch.cat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.sum().backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with torch.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = torch.tensor([len(src_tokens)], device=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = torch.unsqueeze(torch.tensor(src_tokens, dtype=torch.long, device=device), dim=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = torch.unsqueeze(torch.tensor([tgt_vocab['']], dtype=torch.long, device=device), dim=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(dim=2)\n pred = dec_X.squeeze(dim=0).type(torch.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq", "paddle": "import collections\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr, weight_hh_attr=weight_hh_attr)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.transpose([1, 0, 2])\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = paddle.zeros((4, 7), dtype=paddle.int64)\noutput, state = encoder(X)\noutput.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n weight_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr,weight_hh_attr=weight_hh_attr)\n self.dense = nn.Linear(num_hiddens, vocab_size,weight_attr=weight_attr)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).transpose([1, 0, 2])\n context = state[-1].tile([X.shape[0], 1, 1])\n X_and_context = paddle.concat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).transpose([1, 0, 2])\n return output, state\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = paddle.arange((maxlen), dtype=paddle.float32)[None, :] < valid_len[:, None]\n Xtype = X.dtype\n X = X.astype(paddle.float32)\n X[~mask] = float(value)\n return X.astype(Xtype)\nX = paddle.to_tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, paddle.to_tensor([1, 2]))\nX = paddle.ones([2, 3, 4])\nsequence_mask(X, paddle.to_tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = paddle.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred, label)\n weighted_loss = (unweighted_loss * weights).mean(axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(paddle.ones([3, 4, 10]), paddle.ones((3, 4), dtype=paddle.int64), paddle.to_tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = paddle.optimizer.Adam(learning_rate=lr, parameters=net.parameters())\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.clear_grad()\n X, X_valid_len, Y, Y_valid_len = [paddle.to_tensor(x, place=device) for x in batch]\n bos = paddle.to_tensor([tgt_vocab['']] * Y.shape[0]).reshape([-1, 1])\n dec_input = paddle.concat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len.squeeze())\n l = loss(Y_hat, Y, Y_valid_len.squeeze())\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with paddle.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = paddle.to_tensor([len(src_tokens)], place=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = paddle.unsqueeze(paddle.to_tensor(src_tokens, dtype=paddle.int64, place=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = paddle.unsqueeze(paddle.to_tensor([tgt_vocab['']], dtype=paddle.int64, place=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype(paddle.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq"} +{"id": 585, "pytorch": "import torch\nfrom d2l import torch as d2l\nattention_weights = torch.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nattention_weights = paddle.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 586, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nn_train = 50\nx_train, _ = torch.sort(torch.rand(n_train) * 5)\ndef f(x):\n return 2 * torch.sin(x) + x**0.8\ny_train = f(x_train) + torch.normal(0.0, 0.5, (n_train,))\nx_test = torch.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = torch.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, dim=1)\ny_hat = torch.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nX = torch.ones((2, 1, 4))\nY = torch.ones((2, 4, 6))\ntorch.bmm(X, Y).shape\nweights = torch.ones((2, 10)) * 0.1\nvalues = torch.arange(20.0).reshape((2, 10))\ntorch.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Module):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = nn.Parameter(torch.rand((1,), requires_grad=True))\n def forward(self, queries, keys, values):\n queries = queries.repeat_interleave(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, dim=1)\n return torch.bmm(self.attention_weights.unsqueeze(1), values.unsqueeze(-1)).reshape(-1)\nX_tile = x_train.repeat((n_train, 1))\nY_tile = y_train.repeat((n_train, 1))\nkeys = X_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.zero_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.repeat((n_test, 1))\nvalues = y_train.repeat((n_test, 1))\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nn_train = 50\nx_train = paddle.sort(paddle.rand([n_train]) * 5)\ndef f(x):\n return 2 * paddle.sin(x) + x**0.8\ny_train = f(x_train) + paddle.normal(0.0, 0.5, (n_train,))\nx_test = paddle.arange(0, 5, 0.1, dtype='float32')\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = paddle.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, axis=1)\ny_hat = paddle.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nX = paddle.ones((2, 1, 4))\nY = paddle.ones((2, 4, 6))\npaddle.bmm(X, Y).shape\nweights = paddle.ones((2, 10)) * 0.1\nvalues = paddle.arange(20, dtype='float32').reshape((2, 10))\npaddle.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = paddle.create_parameter((1,), dtype='float32')\n def forward(self, queries, keys, values):\n queries = queries.reshape((queries.shape[0], 1)).tile([keys.shape[1]]).reshape((-1, keys.shape[1]))\n self.attention_weight = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, axis=1)\n return paddle.bmm(self.attention_weight.unsqueeze(1), values.unsqueeze(-1)).reshape((-1, ))\nX_tile = x_train.tile([n_train, 1])\nY_tile = y_train.tile([n_train, 1])\nkeys = X_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = paddle.optimizer.SGD(learning_rate=0.5, parameters=net.parameters())\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.clear_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.tile([n_test, 1])\nvalues = y_train.tile([n_test, 1])\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weight.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorter testing, inputs')"} +{"id": 587, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, dim=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = torch.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), dim=-1)\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([2, 3]))\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Module):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = torch.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))\nvalues = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2, 1, 1)\nvalid_lens = torch.tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Module):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = torch.bmm(queries, keys.transpose(1,2)) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries = torch.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)", "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, axis=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = paddle.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape((-1,))\n X = d2l.sequence_mask(X.reshape((-1, shape[-1])), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), axis=-1)\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([2, 3]))\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias_attr=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = paddle.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = paddle.normal(0, 1, (2, 1, 20)), paddle.ones((2, 10, 2))\nvalues = paddle.arange(40, dtype=paddle.float32).reshape((1, 10, 4)).tile([2, 1, 1])\nvalid_lens = paddle.to_tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Layer):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = paddle.bmm(queries, keys.transpose((0,2,1))) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries = paddle.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)"} +{"id": 588, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).permute(1, 0, 2)\n outputs, self._attention_weights = [], []\n for x in X:\n query = torch.unsqueeze(hidden_state[-1], dim=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)\n out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(torch.cat(outputs, dim=0))\n return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((\n 1, 1, -1, num_steps))", "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, bias_ih_attr=True, time_major=True, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.transpose((1, 0, 2)), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).transpose((1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = paddle.unsqueeze(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = paddle.concat((context, paddle.unsqueeze(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.transpose((1, 0, 2)), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(paddle.concat(outputs, axis=0))\n return outputs.transpose((1, 0, 2)), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = paddle.zeros((4, 7), dtype='int64')\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = paddle.concat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape(\n (1, 1, -1, num_steps))"} +{"id": 589, "pytorch": "from torch import nn\nclass Encoder(nn.Module):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Module):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Module):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "tensorflow": "import tensorflow as tf\nclass Encoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def call(self, X, *args, **kwargs):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def call(self, X, state, **kwargs):\n raise NotImplementedError\nclass EncoderDecoder(tf.keras.Model):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def call(self, enc_X, dec_X, *args, **kwargs):\n enc_outputs = self.encoder(enc_X, *args, **kwargs)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state, **kwargs)"} +{"id": 590, "pytorch": "import collections\nimport math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.permute(1, 0, 2)\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\noutput, state = encoder(X)\noutput.shape\nstate.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).permute(1, 0, 2)\n context = state[-1].repeat(X.shape[0], 1, 1)\n X_and_context = torch.cat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).permute(1, 0, 2)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, state.shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.size(1)\n mask = torch.arange((maxlen), dtype=torch.float32, device=X.device)[None, :] < valid_len[:, None]\n X[~mask] = value\n return X\nX = torch.tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, torch.tensor([1, 2]))\nX = torch.ones(2, 3, 4)\nsequence_mask(X, torch.tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = torch.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred.permute(0, 2, 1), label)\n weighted_loss = (unweighted_loss * weights).mean(dim=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long), torch.tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n def xavier_init_weights(m):\n if type(m) == nn.Linear:\n nn.init.xavier_uniform_(m.weight)\n if type(m) == nn.GRU:\n for param in m._flat_weights_names:\n if \"weight\" in param:\n nn.init.xavier_uniform_(m._parameters[param])\n net.apply(xavier_init_weights)\n net.to(device)\n optimizer = torch.optim.Adam(net.parameters(), lr=lr)\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.zero_grad()\n X, X_valid_len, Y, Y_valid_len = [x.to(device) for x in batch]\n bos = torch.tensor([tgt_vocab['']] * Y.shape[0], device=device).reshape(-1, 1)\n dec_input = torch.cat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.sum().backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with torch.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = torch.tensor([len(src_tokens)], device=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = torch.unsqueeze(torch.tensor(src_tokens, dtype=torch.long, device=device), dim=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = torch.unsqueeze(torch.tensor([tgt_vocab['']], dtype=torch.long, device=device), dim=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(dim=2)\n pred = dec_X.squeeze(dim=0).type(torch.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')", "tensorflow": "import collections\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(*kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n def call(self, X, *args, **kwargs):\n X = self.embedding(X)\n output = self.rnn(X, **kwargs)\n state = output[1:]\n return output[0], state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\noutput, state = encoder(X, training=False)\noutput.shape\nlen(state), [element.shape for element in state]\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def call(self, X, state, **kwargs):\n X = self.embedding(X)\n context = tf.repeat(tf.expand_dims(state[-1], axis=1), repeats=X.shape[1], axis=1)\n X_and_context = tf.concat((X, context), axis=2)\n rnn_output = self.rnn(X_and_context, state, **kwargs)\n output = self.dense(rnn_output[0])\n return output, rnn_output[1:]\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = tf.range(start=0, limit=maxlen, dtype=tf.float32)[None, :] < tf.cast(valid_len[:, None], dtype=tf.float32)\n if len(X.shape) == 3:\n return tf.where(tf.expand_dims(mask, axis=-1), X, value)\n else:\n return tf.where(mask, X, value)\nX = tf.constant([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, tf.constant([1, 2]))\nX = tf.ones((2,3,4))\nsequence_mask(X, tf.constant([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(tf.keras.losses.Loss):\n def __init__(self, valid_len):\n super().__init__(reduction='none')\n self.valid_len = valid_len\n\n def call(self, label, pred):\n weights = tf.ones_like(label, dtype=tf.float32)\n weights = sequence_mask(weights, self.valid_len)\n label_one_hot = tf.one_hot(label, depth=pred.shape[-1])\n unweighted_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, reduction='none')(label_one_hot, pred)\n weighted_loss = tf.reduce_mean((unweighted_loss*weights), axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss(tf.constant([4, 2, 0]))\nloss(tf.ones((3,4), dtype = tf.int32), tf.ones((3, 4, 10))).numpy()\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = tf.keras.optimizers.Adam(learning_rate=lr)\n animator = d2l.Animator(xlabel=\"epoch\", ylabel=\"loss\", xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [x for x in batch]\n bos = tf.reshape(tf.constant([tgt_vocab['']] * Y.shape[0]), shape=(-1, 1))\n dec_input = tf.concat([bos, Y[:, :-1]], 1)\n with tf.GradientTape() as tape:\n Y_hat, _ = net(X, dec_input, X_valid_len, training=True)\n l = MaskedSoftmaxCELoss(Y_valid_len)(Y, Y_hat)\n gradients = tape.gradient(l, net.trainable_variables)\n gradients = d2l.grad_clipping(gradients, 1)\n optimizer.apply_gradients(zip(gradients, net.trainable_variables))\n num_tokens = tf.reduce_sum(Y_valid_len).numpy()\n metric.add(tf.reduce_sum(l), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = tf.constant([len(src_tokens)])\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = tf.expand_dims(src_tokens, axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len, training=False)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = tf.expand_dims(tf.constant([tgt_vocab['']]), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state, training=False)\n dec_X = tf.argmax(Y, axis=2)\n pred = tf.squeeze(dec_X, axis=0)\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred.numpy())\n return ' '.join(tgt_vocab.to_tokens(tf.reshape(output_seq, shape = -1).numpy().tolist())), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')"} +{"id": 591, "pytorch": "import torch\nfrom d2l import torch as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = torch.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = tf.reshape(tf.eye(10), (1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 592, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nn_train = 50\nx_train, _ = torch.sort(torch.rand(n_train) * 5)\ndef f(x):\n return 2 * torch.sin(x) + x**0.8\ny_train = f(x_train) + torch.normal(0.0, 0.5, (n_train,))\nx_test = torch.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = torch.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, dim=1)\ny_hat = torch.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = torch.ones((2, 1, 4))\nY = torch.ones((2, 4, 6))\ntorch.bmm(X, Y).shape\nweights = torch.ones((2, 10)) * 0.1\nvalues = torch.arange(20.0).reshape((2, 10))\ntorch.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Module):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = nn.Parameter(torch.rand((1,), requires_grad=True))\n def forward(self, queries, keys, values):\n queries = queries.repeat_interleave(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, dim=1)\n return torch.bmm(self.attention_weights.unsqueeze(1), values.unsqueeze(-1)).reshape(-1)\nX_tile = x_train.repeat((n_train, 1))\nY_tile = y_train.repeat((n_train, 1))\nkeys = X_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.zero_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.repeat((n_test, 1))\nvalues = y_train.repeat((n_test, 1))\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ntf.random.set_seed(seed=1322)\nn_train = 50\nx_train = tf.sort(tf.random.uniform(shape=(n_train,), maxval=5))\ndef f(x):\n return 2 * tf.sin(x) + x**0.8\ny_train = f(x_train) + tf.random.normal((n_train,), 0.0, 0.5)\nx_test = tf.range(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = tf.repeat(tf.reduce_mean(y_train), repeats=n_test)\nplot_kernel_reg(y_hat)\nX_repeat = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nattention_weights = tf.nn.softmax(-(X_repeat - tf.expand_dims(x_train, axis=1))**2/2, axis=1)\ny_hat = tf.matmul(attention_weights, tf.expand_dims(y_train, axis=1))\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = tf.ones((2, 1, 4))\nY = tf.ones((2, 4, 6))\ntf.matmul(X, Y).shape\nweights = tf.ones((2, 10)) * 0.1\nvalues = tf.reshape(tf.range(20.0), shape = (2, 10))\ntf.matmul(tf.expand_dims(weights, axis=1), tf.expand_dims(values, axis=-1)).numpy()\nclass NWKernelRegression(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = tf.Variable(initial_value=tf.random.uniform(shape=(1,)))\n def call(self, queries, keys, values, **kwargs):\n queries = tf.repeat(tf.expand_dims(queries, axis=1), repeats=keys.shape[1], axis=1)\n self.attention_weights = tf.nn.softmax(-((queries - keys) * self.w)**2 /2, axis =1)\n return tf.squeeze(tf.matmul(tf.expand_dims(self.attention_weights, axis=1), tf.expand_dims(values, axis=-1)))\nX_tile = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nY_tile = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_train, axis=0)\nkeys = tf.reshape(X_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nvalues = tf.reshape(Y_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nnet = NWKernelRegression()\nloss_object = tf.keras.losses.MeanSquaredError()\noptimizer = tf.keras.optimizers.SGD(learning_rate=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with tf.GradientTape() as t:\n loss = loss_object(y_train, net(x_train, keys, values)) * len(y_train)\n grads = t.gradient(loss, net.trainable_variables)\n optimizer.apply_gradients(zip(grads, net.trainable_variables))\n animator.add(epoch + 1, float(loss))\nkeys = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_test, axis=0)\nvalues = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_test, axis=0)\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(net.attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 593, "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, dim=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = torch.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), dim=-1)\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([2, 3]))\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Module):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = torch.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))\nvalues = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2, 1, 1)\nvalid_lens = torch.tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(nn.Module):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = torch.bmm(queries, keys.transpose(1,2)) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries = torch.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return tf.nn.softmax(X, axis=-1)\n else:\n shape = X.shape\n if len(valid_lens.shape) == 1:\n valid_lens = tf.repeat(valid_lens, repeats=shape[1])\n else:\n valid_lens = tf.reshape(valid_lens, shape=-1)\n X = d2l.sequence_mask(tf.reshape(X, shape=(-1, shape[-1])), valid_lens, value=-1e6)\n return tf.nn.softmax(tf.reshape(X, shape=shape), axis=-1)\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([2, 3]))\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([[1, 3], [2, 4]]))\nclass AdditiveAttention(tf.keras.layers.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super().__init__(**kwargs)\n self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.w_v = tf.keras.layers.Dense(1, use_bias=False)\n self.dropout = tf.keras.layers.Dropout(dropout)\n def call(self, queries, keys, values, valid_lens, **kwargs):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = tf.expand_dims(queries, axis=2) + tf.expand_dims(keys, axis=1)\n features = tf.nn.tanh(features)\n scores = tf.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries, keys = tf.random.normal(shape=(2, 1, 20)), tf.ones((2, 10, 2))\nvalues = tf.repeat(tf.reshape(tf.range(40, dtype=tf.float32), shape=(1, 10, 4)), repeats=2, axis=0)\nvalid_lens = tf.constant([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(tf.keras.layers.Layer):\n def __init__(self, dropout, **kwargs):\n super().__init__(**kwargs)\n self.dropout = tf.keras.layers.Dropout(dropout)\n\n def call(self, queries, keys, values, valid_lens, **kwargs):\n d = queries.shape[-1]\n scores = tf.matmul(queries, keys, transpose_b=True)/tf.math.sqrt(tf.cast(d, dtype=tf.float32))\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries = tf.random.normal(shape=(2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')"} +{"id": 594, "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).permute(1, 0, 2)\n outputs, self._attention_weights = [], []\n for x in X:\n query = torch.unsqueeze(hidden_state[-1], dim=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)\n out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(torch.cat(outputs, dim=0))\n return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((\n 1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(), xlabel='Key positions', ylabel='Query positions')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs, hidden_state, enc_valid_lens)\n def call(self, X, state, **kwargs):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X)\n X = tf.transpose(X, perm=(1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = tf.expand_dims(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n x = tf.concat((context, tf.expand_dims(x, axis=1)), axis=-1)\n out = self.rnn(x, hidden_state, **kwargs)\n hidden_state = out[1:]\n outputs.append(out[0])\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(tf.concat(outputs, axis=1))\n return outputs, [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\nstate = decoder.init_state(encoder(X, training=False), None)\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = tf.reshape(tf.concat([step[0][0][0] for step in dec_attention_weight_seq], 0), (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key posistions', ylabel='Query posistions')"} +{"id": 595, "tensorflow": "import tensorflow as tf\nclass Encoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def call(self, X, *args, **kwargs):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def call(self, X, state, **kwargs):\n raise NotImplementedError\nclass EncoderDecoder(tf.keras.Model):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def call(self, enc_X, dec_X, *args, **kwargs):\n enc_outputs = self.encoder(enc_X, *args, **kwargs)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state, **kwargs)", "mxnet": "from mxnet.gluon import nn\nclass Encoder(nn.Block):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Block):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 596, "tensorflow": "import collections\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(*kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n def call(self, X, *args, **kwargs):\n X = self.embedding(X)\n output = self.rnn(X, **kwargs)\n state = output[1:]\n return output[0], state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\noutput, state = encoder(X, training=False)\noutput.shape\nlen(state), [element.shape for element in state]\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def call(self, X, state, **kwargs):\n X = self.embedding(X)\n context = tf.repeat(tf.expand_dims(state[-1], axis=1), repeats=X.shape[1], axis=1)\n X_and_context = tf.concat((X, context), axis=2)\n rnn_output = self.rnn(X_and_context, state, **kwargs)\n output = self.dense(rnn_output[0])\n return output, rnn_output[1:]\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = tf.range(start=0, limit=maxlen, dtype=tf.float32)[None, :] < tf.cast(valid_len[:, None], dtype=tf.float32)\n if len(X.shape) == 3:\n return tf.where(tf.expand_dims(mask, axis=-1), X, value)\n else:\n return tf.where(mask, X, value)\nX = tf.constant([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, tf.constant([1, 2]))\nX = tf.ones((2,3,4))\nsequence_mask(X, tf.constant([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(tf.keras.losses.Loss):\n def __init__(self, valid_len):\n super().__init__(reduction='none')\n self.valid_len = valid_len\n\n def call(self, label, pred):\n weights = tf.ones_like(label, dtype=tf.float32)\n weights = sequence_mask(weights, self.valid_len)\n label_one_hot = tf.one_hot(label, depth=pred.shape[-1])\n unweighted_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, reduction='none')(label_one_hot, pred)\n weighted_loss = tf.reduce_mean((unweighted_loss*weights), axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss(tf.constant([4, 2, 0]))\nloss(tf.ones((3,4), dtype = tf.int32), tf.ones((3, 4, 10))).numpy()\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = tf.keras.optimizers.Adam(learning_rate=lr)\n animator = d2l.Animator(xlabel=\"epoch\", ylabel=\"loss\", xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [x for x in batch]\n bos = tf.reshape(tf.constant([tgt_vocab['']] * Y.shape[0]), shape=(-1, 1))\n dec_input = tf.concat([bos, Y[:, :-1]], 1)\n with tf.GradientTape() as tape:\n Y_hat, _ = net(X, dec_input, X_valid_len, training=True)\n l = MaskedSoftmaxCELoss(Y_valid_len)(Y, Y_hat)\n gradients = tape.gradient(l, net.trainable_variables)\n gradients = d2l.grad_clipping(gradients, 1)\n optimizer.apply_gradients(zip(gradients, net.trainable_variables))\n num_tokens = tf.reduce_sum(Y_valid_len).numpy()\n metric.add(tf.reduce_sum(l), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = tf.constant([len(src_tokens)])\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = tf.expand_dims(src_tokens, axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len, training=False)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = tf.expand_dims(tf.constant([tgt_vocab['']]), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state, training=False)\n dec_X = tf.argmax(Y, axis=2)\n pred = tf.squeeze(dec_X, axis=0)\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred.numpy())\n return ' '.join(tgt_vocab.to_tokens(tf.reshape(output_seq, shape = -1).numpy().tolist())), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')", "mxnet": "import collections\nimport math\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.swapaxes(0, 1)\n state = self.rnn.begin_state(batch_size=X.shape[1], ctx=X.ctx)\n output, state = self.rnn(X, state)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\nX = np.zeros((4, 7))\noutput, state = encoder(X)\noutput.shape\nlen(state), state[0].shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).swapaxes(0, 1)\n context = state[0][-1]\n context = np.broadcast_to(context, (X.shape[0], context.shape[0], context.shape[1]))\n X_and_context = np.concatenate((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).swapaxes(0, 1)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape\nX = np.array([[1, 2, 3], [4, 5, 6]])\nnpx.sequence_mask(X, np.array([1, 2]), True, axis=1)\nX = np.ones((2, 3, 4))\nnpx.sequence_mask(X, np.array([1, 2]), True, value=-1, axis=1)\nclass MaskedSoftmaxCELoss(gluon.loss.SoftmaxCELoss):\n def forward(self, pred, label, valid_len):\n weights = np.expand_dims(np.ones_like(label), axis=-1)\n weights = npx.sequence_mask(weights, valid_len, True, axis=1)\n return super(MaskedSoftmaxCELoss, self).forward(pred, label, weights)\nloss = MaskedSoftmaxCELoss()\nloss(np.ones((3, 4, 10)), np.ones((3, 4)), np.array([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n net.initialize(init.Xavier(), force_reinit=True, ctx=device)\n trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr})\n loss = MaskedSoftmaxCELoss()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [\n x.as_in_ctx(device) for x in batch]\n bos = np.array([tgt_vocab['']] * Y.shape[0], ctx=device).reshape(-1, 1)\n dec_input = np.concatenate([bos, Y[:, :-1]], 1)\n with autograd.record():\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n trainer.step(num_tokens)\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [\n src_vocab['']]\n enc_valid_len = np.array([len(src_tokens)], ctx=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = np.expand_dims(np.array(src_tokens, ctx=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = np.expand_dims(np.array([tgt_vocab['']], ctx=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype('int32').item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')"} +{"id": 597, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = tf.reshape(tf.eye(10), (1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "mxnet": "from mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.asnumpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = np.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 598, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ntf.random.set_seed(seed=1322)\nn_train = 50\nx_train = tf.sort(tf.random.uniform(shape=(n_train,), maxval=5))\ndef f(x):\n return 2 * tf.sin(x) + x**0.8\ny_train = f(x_train) + tf.random.normal((n_train,), 0.0, 0.5)\nx_test = tf.range(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = tf.repeat(tf.reduce_mean(y_train), repeats=n_test)\nplot_kernel_reg(y_hat)\nX_repeat = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nattention_weights = tf.nn.softmax(-(X_repeat - tf.expand_dims(x_train, axis=1))**2/2, axis=1)\ny_hat = tf.matmul(attention_weights, tf.expand_dims(y_train, axis=1))\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = tf.ones((2, 1, 4))\nY = tf.ones((2, 4, 6))\ntf.matmul(X, Y).shape\nweights = tf.ones((2, 10)) * 0.1\nvalues = tf.reshape(tf.range(20.0), shape = (2, 10))\ntf.matmul(tf.expand_dims(weights, axis=1), tf.expand_dims(values, axis=-1)).numpy()\nclass NWKernelRegression(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = tf.Variable(initial_value=tf.random.uniform(shape=(1,)))\n def call(self, queries, keys, values, **kwargs):\n queries = tf.repeat(tf.expand_dims(queries, axis=1), repeats=keys.shape[1], axis=1)\n self.attention_weights = tf.nn.softmax(-((queries - keys) * self.w)**2 /2, axis =1)\n return tf.squeeze(tf.matmul(tf.expand_dims(self.attention_weights, axis=1), tf.expand_dims(values, axis=-1)))\nX_tile = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nY_tile = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_train, axis=0)\nkeys = tf.reshape(X_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nvalues = tf.reshape(Y_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nnet = NWKernelRegression()\nloss_object = tf.keras.losses.MeanSquaredError()\noptimizer = tf.keras.optimizers.SGD(learning_rate=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with tf.GradientTape() as t:\n loss = loss_object(y_train, net(x_train, keys, values)) * len(y_train)\n grads = t.gradient(loss, net.trainable_variables)\n optimizer.apply_gradients(zip(grads, net.trainable_variables))\n animator.add(epoch + 1, float(loss))\nkeys = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_test, axis=0)\nvalues = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_test, axis=0)\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(net.attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "mxnet": "from mxnet import autograd, gluon, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nn_train = 50\nx_train = np.sort(np.random.rand(n_train) * 5)\ndef f(x):\n return 2 * np.sin(x) + x**0.8\ny_train = f(x_train) + np.random.normal(0.0, 0.5, (n_train,))\nx_test = np.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = y_train.mean().repeat(n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat(n_train).reshape((-1, n_train))\nattention_weights = npx.softmax(-(X_repeat - x_train)**2 / 2)\ny_hat = np.dot(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = np.ones((2, 1, 4))\nY = np.ones((2, 4, 6))\nnpx.batch_dot(X, Y).shape\nweights = np.ones((2, 10)) * 0.1\nvalues = np.arange(20).reshape((2, 10))\nnpx.batch_dot(np.expand_dims(weights, 1), np.expand_dims(values, -1))\nclass NWKernelRegression(nn.Block):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = self.params.get('w', shape=(1,))\n def forward(self, queries, keys, values):\n queries = queries.repeat(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = npx.softmax(-((queries - keys) * self.w.data())**2 / 2)\n return npx.batch_dot(np.expand_dims(self.attention_weights, 1), np.expand_dims(values, -1)).reshape(-1)\nX_tile = np.tile(x_train, (n_train, 1))\nY_tile = np.tile(y_train, (n_train, 1))\nkeys = X_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nvalues = Y_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nnet = NWKernelRegression()\nnet.initialize()\nloss = gluon.loss.L2Loss()\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.5})\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with autograd.record():\n l = loss(net(x_train, keys, values), y_train)\n l.backward()\n trainer.step(1)\n animator.add(epoch + 1, float(l.sum()))\nkeys = np.tile(x_train, (n_test, 1))\nvalues = np.tile(y_train, (n_test, 1))\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(net.attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 599, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return tf.nn.softmax(X, axis=-1)\n else:\n shape = X.shape\n if len(valid_lens.shape) == 1:\n valid_lens = tf.repeat(valid_lens, repeats=shape[1])\n else:\n valid_lens = tf.reshape(valid_lens, shape=-1)\n X = d2l.sequence_mask(tf.reshape(X, shape=(-1, shape[-1])), valid_lens, value=-1e6)\n return tf.nn.softmax(tf.reshape(X, shape=shape), axis=-1)\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([2, 3]))\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([[1, 3], [2, 4]]))\nclass AdditiveAttention(tf.keras.layers.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super().__init__(**kwargs)\n self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.w_v = tf.keras.layers.Dense(1, use_bias=False)\n self.dropout = tf.keras.layers.Dropout(dropout)\n def call(self, queries, keys, values, valid_lens, **kwargs):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = tf.expand_dims(queries, axis=2) + tf.expand_dims(keys, axis=1)\n features = tf.nn.tanh(features)\n scores = tf.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries, keys = tf.random.normal(shape=(2, 1, 20)), tf.ones((2, 10, 2))\nvalues = tf.repeat(tf.reshape(tf.range(40, dtype=tf.float32), shape=(1, 10, 4)), repeats=2, axis=0)\nvalid_lens = tf.constant([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(tf.keras.layers.Layer):\n def __init__(self, dropout, **kwargs):\n super().__init__(**kwargs)\n self.dropout = tf.keras.layers.Dropout(dropout)\n\n def call(self, queries, keys, values, valid_lens, **kwargs):\n d = queries.shape[-1]\n scores = tf.matmul(queries, keys, transpose_b=True)/tf.math.sqrt(tf.cast(d, dtype=tf.float32))\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries = tf.random.normal(shape=(2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')", "mxnet": "import math\nfrom mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return npx.softmax(X)\n else:\n shape = X.shape\n if valid_lens.ndim == 1:\n valid_lens = valid_lens.repeat(shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = npx.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, True, value=-1e6, axis=1)\n return npx.softmax(X).reshape(shape)\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([2, 3]))\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Block):\n def __init__(self, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.W_q = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.w_v = nn.Dense(1, use_bias=False, flatten=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = np.expand_dims(queries, axis=2) + np.expand_dims(keys, axis=1)\n features = np.tanh(features)\n scores = np.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries, keys = np.random.normal(0, 1, (2, 1, 20)), np.ones((2, 10, 2))\nvalues = np.arange(40).reshape(1, 10, 4).repeat(2, axis=0)\nvalid_lens = np.array([2, 6])\nattention = AdditiveAttention(num_hiddens=8, dropout=0.1)\nattention.initialize()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(nn.Block):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = npx.batch_dot(queries, keys, transpose_b=True) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries = np.random.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.initialize()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')"} +{"id": 600, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs, hidden_state, enc_valid_lens)\n def call(self, X, state, **kwargs):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X)\n X = tf.transpose(X, perm=(1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = tf.expand_dims(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n x = tf.concat((context, tf.expand_dims(x, axis=1)), axis=-1)\n out = self.rnn(x, hidden_state, **kwargs)\n hidden_state = out[1:]\n outputs.append(out[0])\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(tf.concat(outputs, axis=1))\n return outputs, [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\nstate = decoder.init_state(encoder(X, training=False), None)\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = tf.reshape(tf.concat([step[0][0][0] for step in dec_attention_weight_seq], 0), (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key posistions', ylabel='Query posistions')", "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.swapaxes(0, 1), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).swapaxes(0, 1)\n outputs, self._attention_weights = [], []\n for x in X:\n query = np.expand_dims(hidden_state[0][-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = np.concatenate((context, np.expand_dims(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.swapaxes(0, 1), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(np.concatenate(outputs, axis=0))\n return outputs.swapaxes(0, 1), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nX = np.zeros((4, 7))\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = np.concatenate([step[0][0][0] for step in dec_attention_weight_seq], 0\n ).reshape((1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key positions', ylabel='Query positions')"} +{"id": 601, "paddle": "import warnings\nwarnings.filterwarnings(\"ignore\")\nfrom paddle import nn\nclass Encoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Layer):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "tensorflow": "import tensorflow as tf\nclass Encoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def call(self, X, *args, **kwargs):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def call(self, X, state, **kwargs):\n raise NotImplementedError\nclass EncoderDecoder(tf.keras.Model):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def call(self, enc_X, dec_X, *args, **kwargs):\n enc_outputs = self.encoder(enc_X, *args, **kwargs)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state, **kwargs)"} +{"id": 602, "paddle": "import collections\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr, weight_hh_attr=weight_hh_attr)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.transpose([1, 0, 2])\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = paddle.zeros((4, 7), dtype=paddle.int64)\noutput, state = encoder(X)\noutput.shape\nstate.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n weight_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr,weight_hh_attr=weight_hh_attr)\n self.dense = nn.Linear(num_hiddens, vocab_size,weight_attr=weight_attr)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).transpose([1, 0, 2])\n context = state[-1].tile([X.shape[0], 1, 1])\n X_and_context = paddle.concat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).transpose([1, 0, 2])\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, state.shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = paddle.arange((maxlen), dtype=paddle.float32)[None, :] < valid_len[:, None]\n Xtype = X.dtype\n X = X.astype(paddle.float32)\n X[~mask] = float(value)\n return X.astype(Xtype)\nX = paddle.to_tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, paddle.to_tensor([1, 2]))\nX = paddle.ones([2, 3, 4])\nsequence_mask(X, paddle.to_tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = paddle.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred, label)\n weighted_loss = (unweighted_loss * weights).mean(axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(paddle.ones([3, 4, 10]), paddle.ones((3, 4), dtype=paddle.int64), paddle.to_tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = paddle.optimizer.Adam(learning_rate=lr, parameters=net.parameters())\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.clear_grad()\n X, X_valid_len, Y, Y_valid_len = [paddle.to_tensor(x, place=device) for x in batch]\n bos = paddle.to_tensor([tgt_vocab['']] * Y.shape[0]).reshape([-1, 1])\n dec_input = paddle.concat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len.squeeze())\n l = loss(Y_hat, Y, Y_valid_len.squeeze())\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with paddle.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = paddle.to_tensor([len(src_tokens)], place=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = paddle.unsqueeze(paddle.to_tensor(src_tokens, dtype=paddle.int64, place=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = paddle.unsqueeze(paddle.to_tensor([tgt_vocab['']], dtype=paddle.int64, place=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype(paddle.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')", "tensorflow": "import collections\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(*kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n def call(self, X, *args, **kwargs):\n X = self.embedding(X)\n output = self.rnn(X, **kwargs)\n state = output[1:]\n return output[0], state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\noutput, state = encoder(X, training=False)\noutput.shape\nlen(state), [element.shape for element in state]\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def call(self, X, state, **kwargs):\n X = self.embedding(X)\n context = tf.repeat(tf.expand_dims(state[-1], axis=1), repeats=X.shape[1], axis=1)\n X_and_context = tf.concat((X, context), axis=2)\n rnn_output = self.rnn(X_and_context, state, **kwargs)\n output = self.dense(rnn_output[0])\n return output, rnn_output[1:]\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = tf.range(start=0, limit=maxlen, dtype=tf.float32)[None, :] < tf.cast(valid_len[:, None], dtype=tf.float32)\n if len(X.shape) == 3:\n return tf.where(tf.expand_dims(mask, axis=-1), X, value)\n else:\n return tf.where(mask, X, value)\nX = tf.constant([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, tf.constant([1, 2]))\nX = tf.ones((2,3,4))\nsequence_mask(X, tf.constant([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(tf.keras.losses.Loss):\n def __init__(self, valid_len):\n super().__init__(reduction='none')\n self.valid_len = valid_len\n\n def call(self, label, pred):\n weights = tf.ones_like(label, dtype=tf.float32)\n weights = sequence_mask(weights, self.valid_len)\n label_one_hot = tf.one_hot(label, depth=pred.shape[-1])\n unweighted_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, reduction='none')(label_one_hot, pred)\n weighted_loss = tf.reduce_mean((unweighted_loss*weights), axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss(tf.constant([4, 2, 0]))\nloss(tf.ones((3,4), dtype = tf.int32), tf.ones((3, 4, 10))).numpy()\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = tf.keras.optimizers.Adam(learning_rate=lr)\n animator = d2l.Animator(xlabel=\"epoch\", ylabel=\"loss\", xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [x for x in batch]\n bos = tf.reshape(tf.constant([tgt_vocab['']] * Y.shape[0]), shape=(-1, 1))\n dec_input = tf.concat([bos, Y[:, :-1]], 1)\n with tf.GradientTape() as tape:\n Y_hat, _ = net(X, dec_input, X_valid_len, training=True)\n l = MaskedSoftmaxCELoss(Y_valid_len)(Y, Y_hat)\n gradients = tape.gradient(l, net.trainable_variables)\n gradients = d2l.grad_clipping(gradients, 1)\n optimizer.apply_gradients(zip(gradients, net.trainable_variables))\n num_tokens = tf.reduce_sum(Y_valid_len).numpy()\n metric.add(tf.reduce_sum(l), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = tf.constant([len(src_tokens)])\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = tf.expand_dims(src_tokens, axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len, training=False)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = tf.expand_dims(tf.constant([tgt_vocab['']]), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state, training=False)\n dec_X = tf.argmax(Y, axis=2)\n pred = tf.squeeze(dec_X, axis=0)\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred.numpy())\n return ' '.join(tgt_vocab.to_tokens(tf.reshape(output_seq, shape = -1).numpy().tolist())), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')"} +{"id": 603, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = paddle.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = tf.reshape(tf.eye(10), (1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 604, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nn_train = 50\nx_train = paddle.sort(paddle.rand([n_train]) * 5)\ndef f(x):\n return 2 * paddle.sin(x) + x**0.8\ny_train = f(x_train) + paddle.normal(0.0, 0.5, (n_train,))\nx_test = paddle.arange(0, 5, 0.1, dtype='float32')\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = paddle.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, axis=1)\ny_hat = paddle.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = paddle.ones((2, 1, 4))\nY = paddle.ones((2, 4, 6))\npaddle.bmm(X, Y).shape\nweights = paddle.ones((2, 10)) * 0.1\nvalues = paddle.arange(20, dtype='float32').reshape((2, 10))\npaddle.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = paddle.create_parameter((1,), dtype='float32')\n def forward(self, queries, keys, values):\n queries = queries.reshape((queries.shape[0], 1)).tile([keys.shape[1]]).reshape((-1, keys.shape[1]))\n self.attention_weight = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, axis=1)\n return paddle.bmm(self.attention_weight.unsqueeze(1), values.unsqueeze(-1)).reshape((-1, ))\nX_tile = x_train.tile([n_train, 1])\nY_tile = y_train.tile([n_train, 1])\nkeys = X_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = paddle.optimizer.SGD(learning_rate=0.5, parameters=net.parameters())\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.clear_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.tile([n_test, 1])\nvalues = y_train.tile([n_test, 1])\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weight.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorter testing, inputs')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ntf.random.set_seed(seed=1322)\nn_train = 50\nx_train = tf.sort(tf.random.uniform(shape=(n_train,), maxval=5))\ndef f(x):\n return 2 * tf.sin(x) + x**0.8\ny_train = f(x_train) + tf.random.normal((n_train,), 0.0, 0.5)\nx_test = tf.range(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = tf.repeat(tf.reduce_mean(y_train), repeats=n_test)\nplot_kernel_reg(y_hat)\nX_repeat = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nattention_weights = tf.nn.softmax(-(X_repeat - tf.expand_dims(x_train, axis=1))**2/2, axis=1)\ny_hat = tf.matmul(attention_weights, tf.expand_dims(y_train, axis=1))\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = tf.ones((2, 1, 4))\nY = tf.ones((2, 4, 6))\ntf.matmul(X, Y).shape\nweights = tf.ones((2, 10)) * 0.1\nvalues = tf.reshape(tf.range(20.0), shape = (2, 10))\ntf.matmul(tf.expand_dims(weights, axis=1), tf.expand_dims(values, axis=-1)).numpy()\nclass NWKernelRegression(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = tf.Variable(initial_value=tf.random.uniform(shape=(1,)))\n def call(self, queries, keys, values, **kwargs):\n queries = tf.repeat(tf.expand_dims(queries, axis=1), repeats=keys.shape[1], axis=1)\n self.attention_weights = tf.nn.softmax(-((queries - keys) * self.w)**2 /2, axis =1)\n return tf.squeeze(tf.matmul(tf.expand_dims(self.attention_weights, axis=1), tf.expand_dims(values, axis=-1)))\nX_tile = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nY_tile = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_train, axis=0)\nkeys = tf.reshape(X_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nvalues = tf.reshape(Y_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nnet = NWKernelRegression()\nloss_object = tf.keras.losses.MeanSquaredError()\noptimizer = tf.keras.optimizers.SGD(learning_rate=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with tf.GradientTape() as t:\n loss = loss_object(y_train, net(x_train, keys, values)) * len(y_train)\n grads = t.gradient(loss, net.trainable_variables)\n optimizer.apply_gradients(zip(grads, net.trainable_variables))\n animator.add(epoch + 1, float(loss))\nkeys = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_test, axis=0)\nvalues = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_test, axis=0)\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(net.attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 605, "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, axis=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = paddle.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape((-1,))\n X = d2l.sequence_mask(X.reshape((-1, shape[-1])), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), axis=-1)\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([2, 3]))\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias_attr=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = paddle.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = paddle.normal(0, 1, (2, 1, 20)), paddle.ones((2, 10, 2))\nvalues = paddle.arange(40, dtype=paddle.float32).reshape((1, 10, 4)).tile([2, 1, 1])\nvalid_lens = paddle.to_tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(nn.Layer):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = paddle.bmm(queries, keys.transpose((0,2,1))) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries = paddle.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return tf.nn.softmax(X, axis=-1)\n else:\n shape = X.shape\n if len(valid_lens.shape) == 1:\n valid_lens = tf.repeat(valid_lens, repeats=shape[1])\n else:\n valid_lens = tf.reshape(valid_lens, shape=-1)\n X = d2l.sequence_mask(tf.reshape(X, shape=(-1, shape[-1])), valid_lens, value=-1e6)\n return tf.nn.softmax(tf.reshape(X, shape=shape), axis=-1)\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([2, 3]))\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([[1, 3], [2, 4]]))\nclass AdditiveAttention(tf.keras.layers.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super().__init__(**kwargs)\n self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.w_v = tf.keras.layers.Dense(1, use_bias=False)\n self.dropout = tf.keras.layers.Dropout(dropout)\n def call(self, queries, keys, values, valid_lens, **kwargs):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = tf.expand_dims(queries, axis=2) + tf.expand_dims(keys, axis=1)\n features = tf.nn.tanh(features)\n scores = tf.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries, keys = tf.random.normal(shape=(2, 1, 20)), tf.ones((2, 10, 2))\nvalues = tf.repeat(tf.reshape(tf.range(40, dtype=tf.float32), shape=(1, 10, 4)), repeats=2, axis=0)\nvalid_lens = tf.constant([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(tf.keras.layers.Layer):\n def __init__(self, dropout, **kwargs):\n super().__init__(**kwargs)\n self.dropout = tf.keras.layers.Dropout(dropout)\n\n def call(self, queries, keys, values, valid_lens, **kwargs):\n d = queries.shape[-1]\n scores = tf.matmul(queries, keys, transpose_b=True)/tf.math.sqrt(tf.cast(d, dtype=tf.float32))\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries = tf.random.normal(shape=(2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')"} +{"id": 606, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, bias_ih_attr=True, time_major=True, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.transpose((1, 0, 2)), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).transpose((1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = paddle.unsqueeze(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = paddle.concat((context, paddle.unsqueeze(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.transpose((1, 0, 2)), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(paddle.concat(outputs, axis=0))\n return outputs.transpose((1, 0, 2)), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = paddle.zeros((4, 7), dtype='int64')\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = paddle.concat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape(\n (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(), xlabel='Key positions', ylabel='Query positions')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs, hidden_state, enc_valid_lens)\n def call(self, X, state, **kwargs):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X)\n X = tf.transpose(X, perm=(1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = tf.expand_dims(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n x = tf.concat((context, tf.expand_dims(x, axis=1)), axis=-1)\n out = self.rnn(x, hidden_state, **kwargs)\n hidden_state = out[1:]\n outputs.append(out[0])\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(tf.concat(outputs, axis=1))\n return outputs, [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\nstate = decoder.init_state(encoder(X, training=False), None)\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = tf.reshape(tf.concat([step[0][0][0] for step in dec_attention_weight_seq], 0), (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key posistions', ylabel='Query posistions')"} +{"id": 607, "paddle": "import warnings\nwarnings.filterwarnings(\"ignore\")\nfrom paddle import nn\nclass Encoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Layer):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "mxnet": "from mxnet.gluon import nn\nclass Encoder(nn.Block):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Block):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 608, "paddle": "import collections\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr, weight_hh_attr=weight_hh_attr)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.transpose([1, 0, 2])\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = paddle.zeros((4, 7), dtype=paddle.int64)\noutput, state = encoder(X)\noutput.shape\nstate.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n weight_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr,weight_hh_attr=weight_hh_attr)\n self.dense = nn.Linear(num_hiddens, vocab_size,weight_attr=weight_attr)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).transpose([1, 0, 2])\n context = state[-1].tile([X.shape[0], 1, 1])\n X_and_context = paddle.concat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).transpose([1, 0, 2])\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, state.shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = paddle.arange((maxlen), dtype=paddle.float32)[None, :] < valid_len[:, None]\n Xtype = X.dtype\n X = X.astype(paddle.float32)\n X[~mask] = float(value)\n return X.astype(Xtype)\nX = paddle.to_tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, paddle.to_tensor([1, 2]))\nX = paddle.ones([2, 3, 4])\nsequence_mask(X, paddle.to_tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = paddle.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred, label)\n weighted_loss = (unweighted_loss * weights).mean(axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(paddle.ones([3, 4, 10]), paddle.ones((3, 4), dtype=paddle.int64), paddle.to_tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = paddle.optimizer.Adam(learning_rate=lr, parameters=net.parameters())\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.clear_grad()\n X, X_valid_len, Y, Y_valid_len = [paddle.to_tensor(x, place=device) for x in batch]\n bos = paddle.to_tensor([tgt_vocab['']] * Y.shape[0]).reshape([-1, 1])\n dec_input = paddle.concat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len.squeeze())\n l = loss(Y_hat, Y, Y_valid_len.squeeze())\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with paddle.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = paddle.to_tensor([len(src_tokens)], place=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = paddle.unsqueeze(paddle.to_tensor(src_tokens, dtype=paddle.int64, place=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = paddle.unsqueeze(paddle.to_tensor([tgt_vocab['']], dtype=paddle.int64, place=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype(paddle.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq", "mxnet": "import collections\nimport math\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.swapaxes(0, 1)\n state = self.rnn.begin_state(batch_size=X.shape[1], ctx=X.ctx)\n output, state = self.rnn(X, state)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\nX = np.zeros((4, 7))\noutput, state = encoder(X)\noutput.shape\nlen(state), state[0].shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).swapaxes(0, 1)\n context = state[0][-1]\n context = np.broadcast_to(context, (X.shape[0], context.shape[0], context.shape[1]))\n X_and_context = np.concatenate((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).swapaxes(0, 1)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape\nX = np.array([[1, 2, 3], [4, 5, 6]])\nnpx.sequence_mask(X, np.array([1, 2]), True, axis=1)\nX = np.ones((2, 3, 4))\nnpx.sequence_mask(X, np.array([1, 2]), True, value=-1, axis=1)\nclass MaskedSoftmaxCELoss(gluon.loss.SoftmaxCELoss):\n def forward(self, pred, label, valid_len):\n weights = np.expand_dims(np.ones_like(label), axis=-1)\n weights = npx.sequence_mask(weights, valid_len, True, axis=1)\n return super(MaskedSoftmaxCELoss, self).forward(pred, label, weights)\nloss = MaskedSoftmaxCELoss()\nloss(np.ones((3, 4, 10)), np.ones((3, 4)), np.array([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n net.initialize(init.Xavier(), force_reinit=True, ctx=device)\n trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr})\n loss = MaskedSoftmaxCELoss()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [\n x.as_in_ctx(device) for x in batch]\n bos = np.array([tgt_vocab['']] * Y.shape[0], ctx=device).reshape(-1, 1)\n dec_input = np.concatenate([bos, Y[:, :-1]], 1)\n with autograd.record():\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n trainer.step(num_tokens)\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [\n src_vocab['']]\n enc_valid_len = np.array([len(src_tokens)], ctx=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = np.expand_dims(np.array(src_tokens, ctx=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = np.expand_dims(np.array([tgt_vocab['']], ctx=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype('int32').item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq"} +{"id": 609, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = paddle.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "mxnet": "from mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.asnumpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = np.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 610, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nn_train = 50\nx_train = paddle.sort(paddle.rand([n_train]) * 5)\ndef f(x):\n return 2 * paddle.sin(x) + x**0.8\ny_train = f(x_train) + paddle.normal(0.0, 0.5, (n_train,))\nx_test = paddle.arange(0, 5, 0.1, dtype='float32')\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = paddle.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, axis=1)\ny_hat = paddle.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = paddle.ones((2, 1, 4))\nY = paddle.ones((2, 4, 6))\npaddle.bmm(X, Y).shape\nweights = paddle.ones((2, 10)) * 0.1\nvalues = paddle.arange(20, dtype='float32').reshape((2, 10))\npaddle.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = paddle.create_parameter((1,), dtype='float32')\n def forward(self, queries, keys, values):\n queries = queries.reshape((queries.shape[0], 1)).tile([keys.shape[1]]).reshape((-1, keys.shape[1]))\n self.attention_weight = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, axis=1)\n return paddle.bmm(self.attention_weight.unsqueeze(1), values.unsqueeze(-1)).reshape((-1, ))\nX_tile = x_train.tile([n_train, 1])\nY_tile = y_train.tile([n_train, 1])\nkeys = X_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = paddle.optimizer.SGD(learning_rate=0.5, parameters=net.parameters())\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.clear_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.tile([n_test, 1])\nvalues = y_train.tile([n_test, 1])\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weight.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorter testing, inputs')", "mxnet": "from mxnet import autograd, gluon, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nn_train = 50\nx_train = np.sort(np.random.rand(n_train) * 5)\ndef f(x):\n return 2 * np.sin(x) + x**0.8\ny_train = f(x_train) + np.random.normal(0.0, 0.5, (n_train,))\nx_test = np.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = y_train.mean().repeat(n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat(n_train).reshape((-1, n_train))\nattention_weights = npx.softmax(-(X_repeat - x_train)**2 / 2)\ny_hat = np.dot(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = np.ones((2, 1, 4))\nY = np.ones((2, 4, 6))\nnpx.batch_dot(X, Y).shape\nweights = np.ones((2, 10)) * 0.1\nvalues = np.arange(20).reshape((2, 10))\nnpx.batch_dot(np.expand_dims(weights, 1), np.expand_dims(values, -1))\nclass NWKernelRegression(nn.Block):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = self.params.get('w', shape=(1,))\n def forward(self, queries, keys, values):\n queries = queries.repeat(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = npx.softmax(-((queries - keys) * self.w.data())**2 / 2)\n return npx.batch_dot(np.expand_dims(self.attention_weights, 1), np.expand_dims(values, -1)).reshape(-1)\nX_tile = np.tile(x_train, (n_train, 1))\nY_tile = np.tile(y_train, (n_train, 1))\nkeys = X_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nvalues = Y_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nnet = NWKernelRegression()\nnet.initialize()\nloss = gluon.loss.L2Loss()\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.5})\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with autograd.record():\n l = loss(net(x_train, keys, values), y_train)\n l.backward()\n trainer.step(1)\n animator.add(epoch + 1, float(l.sum()))\nkeys = np.tile(x_train, (n_test, 1))\nvalues = np.tile(y_train, (n_test, 1))\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(net.attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 611, "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, axis=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = paddle.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape((-1,))\n X = d2l.sequence_mask(X.reshape((-1, shape[-1])), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), axis=-1)\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([2, 3]))\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias_attr=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = paddle.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = paddle.normal(0, 1, (2, 1, 20)), paddle.ones((2, 10, 2))\nvalues = paddle.arange(40, dtype=paddle.float32).reshape((1, 10, 4)).tile([2, 1, 1])\nvalid_lens = paddle.to_tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Layer):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = paddle.bmm(queries, keys.transpose((0,2,1))) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries = paddle.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)", "mxnet": "import math\nfrom mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return npx.softmax(X)\n else:\n shape = X.shape\n if valid_lens.ndim == 1:\n valid_lens = valid_lens.repeat(shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = npx.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, True, value=-1e6, axis=1)\n return npx.softmax(X).reshape(shape)\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([2, 3]))\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Block):\n def __init__(self, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.W_q = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.w_v = nn.Dense(1, use_bias=False, flatten=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = np.expand_dims(queries, axis=2) + np.expand_dims(keys, axis=1)\n features = np.tanh(features)\n scores = np.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries, keys = np.random.normal(0, 1, (2, 1, 20)), np.ones((2, 10, 2))\nvalues = np.arange(40).reshape(1, 10, 4).repeat(2, axis=0)\nvalid_lens = np.array([2, 6])\nattention = AdditiveAttention(num_hiddens=8, dropout=0.1)\nattention.initialize()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Block):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = npx.batch_dot(queries, keys, transpose_b=True) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries = np.random.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.initialize()\nattention(queries, keys, values, valid_lens)"} +{"id": 612, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, bias_ih_attr=True, time_major=True, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.transpose((1, 0, 2)), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).transpose((1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = paddle.unsqueeze(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = paddle.concat((context, paddle.unsqueeze(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.transpose((1, 0, 2)), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(paddle.concat(outputs, axis=0))\n return outputs.transpose((1, 0, 2)), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = paddle.zeros((4, 7), dtype='int64')\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = paddle.concat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape(\n (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(), xlabel='Key positions', ylabel='Query positions')", "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.swapaxes(0, 1), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).swapaxes(0, 1)\n outputs, self._attention_weights = [], []\n for x in X:\n query = np.expand_dims(hidden_state[0][-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = np.concatenate((context, np.expand_dims(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.swapaxes(0, 1), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(np.concatenate(outputs, axis=0))\n return outputs.swapaxes(0, 1), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nX = np.zeros((4, 7))\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = np.concatenate([step[0][0][0] for step in dec_attention_weight_seq], 0\n ).reshape((1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key positions', ylabel='Query positions')"} +{"id": 613, "mxnet": "from mxnet.gluon import nn\nclass Encoder(nn.Block):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Block):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "pytorch": "from torch import nn\nclass Encoder(nn.Module):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Module):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Module):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 614, "mxnet": "import collections\nimport math\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.swapaxes(0, 1)\n state = self.rnn.begin_state(batch_size=X.shape[1], ctx=X.ctx)\n output, state = self.rnn(X, state)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\nX = np.zeros((4, 7))\noutput, state = encoder(X)\noutput.shape\nlen(state), state[0].shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).swapaxes(0, 1)\n context = state[0][-1]\n context = np.broadcast_to(context, (X.shape[0], context.shape[0], context.shape[1]))\n X_and_context = np.concatenate((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).swapaxes(0, 1)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape\nX = np.array([[1, 2, 3], [4, 5, 6]])\nnpx.sequence_mask(X, np.array([1, 2]), True, axis=1)\nX = np.ones((2, 3, 4))\nnpx.sequence_mask(X, np.array([1, 2]), True, value=-1, axis=1)\nclass MaskedSoftmaxCELoss(gluon.loss.SoftmaxCELoss):\n def forward(self, pred, label, valid_len):\n weights = np.expand_dims(np.ones_like(label), axis=-1)\n weights = npx.sequence_mask(weights, valid_len, True, axis=1)\n return super(MaskedSoftmaxCELoss, self).forward(pred, label, weights)\nloss = MaskedSoftmaxCELoss()\nloss(np.ones((3, 4, 10)), np.ones((3, 4)), np.array([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n net.initialize(init.Xavier(), force_reinit=True, ctx=device)\n trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr})\n loss = MaskedSoftmaxCELoss()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [\n x.as_in_ctx(device) for x in batch]\n bos = np.array([tgt_vocab['']] * Y.shape[0], ctx=device).reshape(-1, 1)\n dec_input = np.concatenate([bos, Y[:, :-1]], 1)\n with autograd.record():\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n trainer.step(num_tokens)\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [\n src_vocab['']]\n enc_valid_len = np.array([len(src_tokens)], ctx=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = np.expand_dims(np.array(src_tokens, ctx=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = np.expand_dims(np.array([tgt_vocab['']], ctx=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype('int32').item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq", "pytorch": "import collections\nimport math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.permute(1, 0, 2)\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\noutput, state = encoder(X)\noutput.shape\nstate.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).permute(1, 0, 2)\n context = state[-1].repeat(X.shape[0], 1, 1)\n X_and_context = torch.cat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).permute(1, 0, 2)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, state.shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.size(1)\n mask = torch.arange((maxlen), dtype=torch.float32, device=X.device)[None, :] < valid_len[:, None]\n X[~mask] = value\n return X\nX = torch.tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, torch.tensor([1, 2]))\nX = torch.ones(2, 3, 4)\nsequence_mask(X, torch.tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = torch.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred.permute(0, 2, 1), label)\n weighted_loss = (unweighted_loss * weights).mean(dim=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long), torch.tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n def xavier_init_weights(m):\n if type(m) == nn.Linear:\n nn.init.xavier_uniform_(m.weight)\n if type(m) == nn.GRU:\n for param in m._flat_weights_names:\n if \"weight\" in param:\n nn.init.xavier_uniform_(m._parameters[param])\n net.apply(xavier_init_weights)\n net.to(device)\n optimizer = torch.optim.Adam(net.parameters(), lr=lr)\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.zero_grad()\n X, X_valid_len, Y, Y_valid_len = [x.to(device) for x in batch]\n bos = torch.tensor([tgt_vocab['']] * Y.shape[0], device=device).reshape(-1, 1)\n dec_input = torch.cat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.sum().backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with torch.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = torch.tensor([len(src_tokens)], device=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = torch.unsqueeze(torch.tensor(src_tokens, dtype=torch.long, device=device), dim=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = torch.unsqueeze(torch.tensor([tgt_vocab['']], dtype=torch.long, device=device), dim=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(dim=2)\n pred = dec_X.squeeze(dim=0).type(torch.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq"} +{"id": 615, "mxnet": "from mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.asnumpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = np.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "pytorch": "import torch\nfrom d2l import torch as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = torch.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 616, "mxnet": "from mxnet import autograd, gluon, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nn_train = 50\nx_train = np.sort(np.random.rand(n_train) * 5)\ndef f(x):\n return 2 * np.sin(x) + x**0.8\ny_train = f(x_train) + np.random.normal(0.0, 0.5, (n_train,))\nx_test = np.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = y_train.mean().repeat(n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat(n_train).reshape((-1, n_train))\nattention_weights = npx.softmax(-(X_repeat - x_train)**2 / 2)\ny_hat = np.dot(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = np.ones((2, 1, 4))\nY = np.ones((2, 4, 6))\nnpx.batch_dot(X, Y).shape\nweights = np.ones((2, 10)) * 0.1\nvalues = np.arange(20).reshape((2, 10))\nnpx.batch_dot(np.expand_dims(weights, 1), np.expand_dims(values, -1))\nclass NWKernelRegression(nn.Block):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = self.params.get('w', shape=(1,))\n def forward(self, queries, keys, values):\n queries = queries.repeat(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = npx.softmax(-((queries - keys) * self.w.data())**2 / 2)\n return npx.batch_dot(np.expand_dims(self.attention_weights, 1), np.expand_dims(values, -1)).reshape(-1)\nX_tile = np.tile(x_train, (n_train, 1))\nY_tile = np.tile(y_train, (n_train, 1))\nkeys = X_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nvalues = Y_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nnet = NWKernelRegression()\nnet.initialize()\nloss = gluon.loss.L2Loss()\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.5})\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with autograd.record():\n l = loss(net(x_train, keys, values), y_train)\n l.backward()\n trainer.step(1)\n animator.add(epoch + 1, float(l.sum()))\nkeys = np.tile(x_train, (n_test, 1))\nvalues = np.tile(y_train, (n_test, 1))\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(net.attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nn_train = 50\nx_train, _ = torch.sort(torch.rand(n_train) * 5)\ndef f(x):\n return 2 * torch.sin(x) + x**0.8\ny_train = f(x_train) + torch.normal(0.0, 0.5, (n_train,))\nx_test = torch.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = torch.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, dim=1)\ny_hat = torch.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = torch.ones((2, 1, 4))\nY = torch.ones((2, 4, 6))\ntorch.bmm(X, Y).shape\nweights = torch.ones((2, 10)) * 0.1\nvalues = torch.arange(20.0).reshape((2, 10))\ntorch.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Module):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = nn.Parameter(torch.rand((1,), requires_grad=True))\n def forward(self, queries, keys, values):\n queries = queries.repeat_interleave(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, dim=1)\n return torch.bmm(self.attention_weights.unsqueeze(1), values.unsqueeze(-1)).reshape(-1)\nX_tile = x_train.repeat((n_train, 1))\nY_tile = y_train.repeat((n_train, 1))\nkeys = X_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.zero_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.repeat((n_test, 1))\nvalues = y_train.repeat((n_test, 1))\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 617, "mxnet": "import math\nfrom mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return npx.softmax(X)\n else:\n shape = X.shape\n if valid_lens.ndim == 1:\n valid_lens = valid_lens.repeat(shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = npx.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, True, value=-1e6, axis=1)\n return npx.softmax(X).reshape(shape)\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([2, 3]))\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Block):\n def __init__(self, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.W_q = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.w_v = nn.Dense(1, use_bias=False, flatten=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = np.expand_dims(queries, axis=2) + np.expand_dims(keys, axis=1)\n features = np.tanh(features)\n scores = np.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries, keys = np.random.normal(0, 1, (2, 1, 20)), np.ones((2, 10, 2))\nvalues = np.arange(40).reshape(1, 10, 4).repeat(2, axis=0)\nvalid_lens = np.array([2, 6])\nattention = AdditiveAttention(num_hiddens=8, dropout=0.1)\nattention.initialize()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Block):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = npx.batch_dot(queries, keys, transpose_b=True) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries = np.random.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.initialize()\nattention(queries, keys, values, valid_lens)", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, dim=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = torch.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), dim=-1)\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([2, 3]))\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Module):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = torch.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))\nvalues = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2, 1, 1)\nvalid_lens = torch.tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Module):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = torch.bmm(queries, keys.transpose(1,2)) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries = torch.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)"} +{"id": 618, "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.swapaxes(0, 1), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).swapaxes(0, 1)\n outputs, self._attention_weights = [], []\n for x in X:\n query = np.expand_dims(hidden_state[0][-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = np.concatenate((context, np.expand_dims(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.swapaxes(0, 1), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(np.concatenate(outputs, axis=0))\n return outputs.swapaxes(0, 1), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nX = np.zeros((4, 7))\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = np.concatenate([step[0][0][0] for step in dec_attention_weight_seq], 0\n ).reshape((1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key positions', ylabel='Query positions')", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).permute(1, 0, 2)\n outputs, self._attention_weights = [], []\n for x in X:\n query = torch.unsqueeze(hidden_state[-1], dim=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)\n out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(torch.cat(outputs, dim=0))\n return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((\n 1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(), xlabel='Key positions', ylabel='Query positions')"} +{"id": 619, "paddle": "import warnings\nwarnings.filterwarnings(\"ignore\")\nfrom paddle import nn\nclass Encoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Layer):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "pytorch": "from torch import nn\nclass Encoder(nn.Module):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Module):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Module):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 620, "paddle": "import collections\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport math\nimport paddle\nfrom paddle import nn\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr, weight_hh_attr=weight_hh_attr)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.transpose([1, 0, 2])\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = paddle.zeros((4, 7), dtype=paddle.int64)\noutput, state = encoder(X)\noutput.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n weight_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_ih_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n weight_hh_attr = paddle.ParamAttr(initializer=nn.initializer.XavierUniform())\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout, time_major=True, weight_ih_attr=weight_ih_attr,weight_hh_attr=weight_hh_attr)\n self.dense = nn.Linear(num_hiddens, vocab_size,weight_attr=weight_attr)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).transpose([1, 0, 2])\n context = state[-1].tile([X.shape[0], 1, 1])\n X_and_context = paddle.concat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).transpose([1, 0, 2])\n return output, state\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = paddle.arange((maxlen), dtype=paddle.float32)[None, :] < valid_len[:, None]\n Xtype = X.dtype\n X = X.astype(paddle.float32)\n X[~mask] = float(value)\n return X.astype(Xtype)\nX = paddle.to_tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, paddle.to_tensor([1, 2]))\nX = paddle.ones([2, 3, 4])\nsequence_mask(X, paddle.to_tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = paddle.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred, label)\n weighted_loss = (unweighted_loss * weights).mean(axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(paddle.ones([3, 4, 10]), paddle.ones((3, 4), dtype=paddle.int64), paddle.to_tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = paddle.optimizer.Adam(learning_rate=lr, parameters=net.parameters())\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.clear_grad()\n X, X_valid_len, Y, Y_valid_len = [paddle.to_tensor(x, place=device) for x in batch]\n bos = paddle.to_tensor([tgt_vocab['']] * Y.shape[0]).reshape([-1, 1])\n dec_input = paddle.concat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len.squeeze())\n l = loss(Y_hat, Y, Y_valid_len.squeeze())\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with paddle.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = paddle.to_tensor([len(src_tokens)], place=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = paddle.unsqueeze(paddle.to_tensor(src_tokens, dtype=paddle.int64, place=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = paddle.unsqueeze(paddle.to_tensor([tgt_vocab['']], dtype=paddle.int64, place=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype(paddle.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq", "pytorch": "import collections\nimport math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.permute(1, 0, 2)\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\noutput, state = encoder(X)\noutput.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).permute(1, 0, 2)\n context = state[-1].repeat(X.shape[0], 1, 1)\n X_and_context = torch.cat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).permute(1, 0, 2)\n return output, state\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.size(1)\n mask = torch.arange((maxlen), dtype=torch.float32, device=X.device)[None, :] < valid_len[:, None]\n X[~mask] = value\n return X\nX = torch.tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, torch.tensor([1, 2]))\nX = torch.ones(2, 3, 4)\nsequence_mask(X, torch.tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = torch.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred.permute(0, 2, 1), label)\n weighted_loss = (unweighted_loss * weights).mean(dim=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long), torch.tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n def xavier_init_weights(m):\n if type(m) == nn.Linear:\n nn.init.xavier_uniform_(m.weight)\n if type(m) == nn.GRU:\n for param in m._flat_weights_names:\n if \"weight\" in param:\n nn.init.xavier_uniform_(m._parameters[param])\n net.apply(xavier_init_weights)\n net.to(device)\n optimizer = torch.optim.Adam(net.parameters(), lr=lr)\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.zero_grad()\n X, X_valid_len, Y, Y_valid_len = [x.to(device) for x in batch]\n bos = torch.tensor([tgt_vocab['']] * Y.shape[0], device=device).reshape(-1, 1)\n dec_input = torch.cat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.sum().backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with torch.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = torch.tensor([len(src_tokens)], device=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = torch.unsqueeze(torch.tensor(src_tokens, dtype=torch.long, device=device), dim=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = torch.unsqueeze(torch.tensor([tgt_vocab['']], dtype=torch.long, device=device), dim=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(dim=2)\n pred = dec_X.squeeze(dim=0).type(torch.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq"} +{"id": 621, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nattention_weights = paddle.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "pytorch": "import torch\nfrom d2l import torch as d2l\nattention_weights = torch.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 622, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nn_train = 50\nx_train = paddle.sort(paddle.rand([n_train]) * 5)\ndef f(x):\n return 2 * paddle.sin(x) + x**0.8\ny_train = f(x_train) + paddle.normal(0.0, 0.5, (n_train,))\nx_test = paddle.arange(0, 5, 0.1, dtype='float32')\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = paddle.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, axis=1)\ny_hat = paddle.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nX = paddle.ones((2, 1, 4))\nY = paddle.ones((2, 4, 6))\npaddle.bmm(X, Y).shape\nweights = paddle.ones((2, 10)) * 0.1\nvalues = paddle.arange(20, dtype='float32').reshape((2, 10))\npaddle.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = paddle.create_parameter((1,), dtype='float32')\n def forward(self, queries, keys, values):\n queries = queries.reshape((queries.shape[0], 1)).tile([keys.shape[1]]).reshape((-1, keys.shape[1]))\n self.attention_weight = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, axis=1)\n return paddle.bmm(self.attention_weight.unsqueeze(1), values.unsqueeze(-1)).reshape((-1, ))\nX_tile = x_train.tile([n_train, 1])\nY_tile = y_train.tile([n_train, 1])\nkeys = X_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - paddle.eye(n_train)).astype(paddle.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = paddle.optimizer.SGD(learning_rate=0.5, parameters=net.parameters())\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.clear_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.tile([n_test, 1])\nvalues = y_train.tile([n_test, 1])\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weight.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorter testing, inputs')", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nn_train = 50\nx_train, _ = torch.sort(torch.rand(n_train) * 5)\ndef f(x):\n return 2 * torch.sin(x) + x**0.8\ny_train = f(x_train) + torch.normal(0.0, 0.5, (n_train,))\nx_test = torch.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = torch.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, dim=1)\ny_hat = torch.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nX = torch.ones((2, 1, 4))\nY = torch.ones((2, 4, 6))\ntorch.bmm(X, Y).shape\nweights = torch.ones((2, 10)) * 0.1\nvalues = torch.arange(20.0).reshape((2, 10))\ntorch.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Module):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = nn.Parameter(torch.rand((1,), requires_grad=True))\n def forward(self, queries, keys, values):\n queries = queries.repeat_interleave(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, dim=1)\n return torch.bmm(self.attention_weights.unsqueeze(1), values.unsqueeze(-1)).reshape(-1)\nX_tile = x_train.repeat((n_train, 1))\nY_tile = y_train.repeat((n_train, 1))\nkeys = X_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.zero_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.repeat((n_test, 1))\nvalues = y_train.repeat((n_test, 1))\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 623, "paddle": "import math\nimport warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, axis=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = paddle.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape((-1,))\n X = d2l.sequence_mask(X.reshape((-1, shape[-1])), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), axis=-1)\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([2, 3]))\nmasked_softmax(paddle.rand((2, 2, 4)), paddle.to_tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias_attr=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias_attr=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias_attr=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = paddle.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = paddle.normal(0, 1, (2, 1, 20)), paddle.ones((2, 10, 2))\nvalues = paddle.arange(40, dtype=paddle.float32).reshape((1, 10, 4)).tile([2, 1, 1])\nvalid_lens = paddle.to_tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Layer):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = paddle.bmm(queries, keys.transpose((0,2,1))) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return paddle.bmm(self.dropout(self.attention_weights), values)\nqueries = paddle.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, dim=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = torch.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), dim=-1)\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([2, 3]))\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Module):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = torch.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))\nvalues = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2, 1, 1)\nvalid_lens = torch.tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nclass DotProductAttention(nn.Module):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = torch.bmm(queries, keys.transpose(1,2)) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries = torch.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)"} +{"id": 624, "paddle": "import warnings\nfrom d2l import paddle as d2l\nwarnings.filterwarnings(\"ignore\")\nimport paddle\nfrom paddle import nn\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, bias_ih_attr=True, time_major=True, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.transpose((1, 0, 2)), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).transpose((1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = paddle.unsqueeze(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = paddle.concat((context, paddle.unsqueeze(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.transpose((1, 0, 2)), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(paddle.concat(outputs, axis=0))\n return outputs.transpose((1, 0, 2)), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = paddle.zeros((4, 7), dtype='int64')\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = paddle.concat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape(\n (1, 1, -1, num_steps))", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).permute(1, 0, 2)\n outputs, self._attention_weights = [], []\n for x in X:\n query = torch.unsqueeze(hidden_state[-1], dim=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)\n out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(torch.cat(outputs, dim=0))\n return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\nattention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((\n 1, 1, -1, num_steps))"} +{"id": 625, "tensorflow": "import tensorflow as tf\nclass Encoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def call(self, X, *args, **kwargs):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def call(self, X, state, **kwargs):\n raise NotImplementedError\nclass EncoderDecoder(tf.keras.Model):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def call(self, enc_X, dec_X, *args, **kwargs):\n enc_outputs = self.encoder(enc_X, *args, **kwargs)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state, **kwargs)", "pytorch": "from torch import nn\nclass Encoder(nn.Module):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(nn.Module):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Module):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)"} +{"id": 626, "tensorflow": "import collections\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(*kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n def call(self, X, *args, **kwargs):\n X = self.embedding(X)\n output = self.rnn(X, **kwargs)\n state = output[1:]\n return output[0], state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\noutput, state = encoder(X, training=False)\noutput.shape\nlen(state), [element.shape for element in state]\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def call(self, X, state, **kwargs):\n X = self.embedding(X)\n context = tf.repeat(tf.expand_dims(state[-1], axis=1), repeats=X.shape[1], axis=1)\n X_and_context = tf.concat((X, context), axis=2)\n rnn_output = self.rnn(X_and_context, state, **kwargs)\n output = self.dense(rnn_output[0])\n return output, rnn_output[1:]\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = tf.range(start=0, limit=maxlen, dtype=tf.float32)[None, :] < tf.cast(valid_len[:, None], dtype=tf.float32)\n if len(X.shape) == 3:\n return tf.where(tf.expand_dims(mask, axis=-1), X, value)\n else:\n return tf.where(mask, X, value)\nX = tf.constant([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, tf.constant([1, 2]))\nX = tf.ones((2,3,4))\nsequence_mask(X, tf.constant([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(tf.keras.losses.Loss):\n def __init__(self, valid_len):\n super().__init__(reduction='none')\n self.valid_len = valid_len\n\n def call(self, label, pred):\n weights = tf.ones_like(label, dtype=tf.float32)\n weights = sequence_mask(weights, self.valid_len)\n label_one_hot = tf.one_hot(label, depth=pred.shape[-1])\n unweighted_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, reduction='none')(label_one_hot, pred)\n weighted_loss = tf.reduce_mean((unweighted_loss*weights), axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss(tf.constant([4, 2, 0]))\nloss(tf.ones((3,4), dtype = tf.int32), tf.ones((3, 4, 10))).numpy()\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = tf.keras.optimizers.Adam(learning_rate=lr)\n animator = d2l.Animator(xlabel=\"epoch\", ylabel=\"loss\", xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [x for x in batch]\n bos = tf.reshape(tf.constant([tgt_vocab['']] * Y.shape[0]), shape=(-1, 1))\n dec_input = tf.concat([bos, Y[:, :-1]], 1)\n with tf.GradientTape() as tape:\n Y_hat, _ = net(X, dec_input, X_valid_len, training=True)\n l = MaskedSoftmaxCELoss(Y_valid_len)(Y, Y_hat)\n gradients = tape.gradient(l, net.trainable_variables)\n gradients = d2l.grad_clipping(gradients, 1)\n optimizer.apply_gradients(zip(gradients, net.trainable_variables))\n num_tokens = tf.reduce_sum(Y_valid_len).numpy()\n metric.add(tf.reduce_sum(l), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = tf.constant([len(src_tokens)])\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = tf.expand_dims(src_tokens, axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len, training=False)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = tf.expand_dims(tf.constant([tgt_vocab['']]), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state, training=False)\n dec_X = tf.argmax(Y, axis=2)\n pred = tf.squeeze(dec_X, axis=0)\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred.numpy())\n return ' '.join(tgt_vocab.to_tokens(tf.reshape(output_seq, shape = -1).numpy().tolist())), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')", "pytorch": "import collections\nimport math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size, num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.permute(1, 0, 2)\n output, state = self.rnn(X)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\noutput, state = encoder(X)\noutput.shape\nstate.shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).permute(1, 0, 2)\n context = state[-1].repeat(X.shape[0], 1, 1)\n X_and_context = torch.cat((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).permute(1, 0, 2)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, state.shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.size(1)\n mask = torch.arange((maxlen), dtype=torch.float32, device=X.device)[None, :] < valid_len[:, None]\n X[~mask] = value\n return X\nX = torch.tensor([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, torch.tensor([1, 2]))\nX = torch.ones(2, 3, 4)\nsequence_mask(X, torch.tensor([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(nn.CrossEntropyLoss):\n def forward(self, pred, label, valid_len):\n weights = torch.ones_like(label)\n weights = sequence_mask(weights, valid_len)\n self.reduction='none'\n unweighted_loss = super(MaskedSoftmaxCELoss, self).forward(pred.permute(0, 2, 1), label)\n weighted_loss = (unweighted_loss * weights).mean(dim=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss()\nloss(torch.ones(3, 4, 10), torch.ones((3, 4), dtype=torch.long), torch.tensor([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n def xavier_init_weights(m):\n if type(m) == nn.Linear:\n nn.init.xavier_uniform_(m.weight)\n if type(m) == nn.GRU:\n for param in m._flat_weights_names:\n if \"weight\" in param:\n nn.init.xavier_uniform_(m._parameters[param])\n net.apply(xavier_init_weights)\n net.to(device)\n optimizer = torch.optim.Adam(net.parameters(), lr=lr)\n loss = MaskedSoftmaxCELoss()\n net.train()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n optimizer.zero_grad()\n X, X_valid_len, Y, Y_valid_len = [x.to(device) for x in batch]\n bos = torch.tensor([tgt_vocab['']] * Y.shape[0], device=device).reshape(-1, 1)\n dec_input = torch.cat([bos, Y[:, :-1]], 1)\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.sum().backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n optimizer.step()\n with torch.no_grad():\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n net.eval()\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = torch.tensor([len(src_tokens)], device=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = torch.unsqueeze(torch.tensor(src_tokens, dtype=torch.long, device=device), dim=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = torch.unsqueeze(torch.tensor([tgt_vocab['']], dtype=torch.long, device=device), dim=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(dim=2)\n pred = dec_X.squeeze(dim=0).type(torch.int32).item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')"} +{"id": 627, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = tf.reshape(tf.eye(10), (1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "pytorch": "import torch\nfrom d2l import torch as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.detach().numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = torch.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 628, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ntf.random.set_seed(seed=1322)\nn_train = 50\nx_train = tf.sort(tf.random.uniform(shape=(n_train,), maxval=5))\ndef f(x):\n return 2 * tf.sin(x) + x**0.8\ny_train = f(x_train) + tf.random.normal((n_train,), 0.0, 0.5)\nx_test = tf.range(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = tf.repeat(tf.reduce_mean(y_train), repeats=n_test)\nplot_kernel_reg(y_hat)\nX_repeat = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nattention_weights = tf.nn.softmax(-(X_repeat - tf.expand_dims(x_train, axis=1))**2/2, axis=1)\ny_hat = tf.matmul(attention_weights, tf.expand_dims(y_train, axis=1))\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = tf.ones((2, 1, 4))\nY = tf.ones((2, 4, 6))\ntf.matmul(X, Y).shape\nweights = tf.ones((2, 10)) * 0.1\nvalues = tf.reshape(tf.range(20.0), shape = (2, 10))\ntf.matmul(tf.expand_dims(weights, axis=1), tf.expand_dims(values, axis=-1)).numpy()\nclass NWKernelRegression(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = tf.Variable(initial_value=tf.random.uniform(shape=(1,)))\n def call(self, queries, keys, values, **kwargs):\n queries = tf.repeat(tf.expand_dims(queries, axis=1), repeats=keys.shape[1], axis=1)\n self.attention_weights = tf.nn.softmax(-((queries - keys) * self.w)**2 /2, axis =1)\n return tf.squeeze(tf.matmul(tf.expand_dims(self.attention_weights, axis=1), tf.expand_dims(values, axis=-1)))\nX_tile = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nY_tile = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_train, axis=0)\nkeys = tf.reshape(X_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nvalues = tf.reshape(Y_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nnet = NWKernelRegression()\nloss_object = tf.keras.losses.MeanSquaredError()\noptimizer = tf.keras.optimizers.SGD(learning_rate=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with tf.GradientTape() as t:\n loss = loss_object(y_train, net(x_train, keys, values)) * len(y_train)\n grads = t.gradient(loss, net.trainable_variables)\n optimizer.apply_gradients(zip(grads, net.trainable_variables))\n animator.add(epoch + 1, float(loss))\nkeys = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_test, axis=0)\nvalues = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_test, axis=0)\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(net.attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nn_train = 50\nx_train, _ = torch.sort(torch.rand(n_train) * 5)\ndef f(x):\n return 2 * torch.sin(x) + x**0.8\ny_train = f(x_train) + torch.normal(0.0, 0.5, (n_train,))\nx_test = torch.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = torch.repeat_interleave(y_train.mean(), n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat_interleave(n_train).reshape((-1, n_train))\nattention_weights = nn.functional.softmax(-(X_repeat - x_train)**2 / 2, dim=1)\ny_hat = torch.matmul(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = torch.ones((2, 1, 4))\nY = torch.ones((2, 4, 6))\ntorch.bmm(X, Y).shape\nweights = torch.ones((2, 10)) * 0.1\nvalues = torch.arange(20.0).reshape((2, 10))\ntorch.bmm(weights.unsqueeze(1), values.unsqueeze(-1))\nclass NWKernelRegression(nn.Module):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = nn.Parameter(torch.rand((1,), requires_grad=True))\n def forward(self, queries, keys, values):\n queries = queries.repeat_interleave(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = nn.functional.softmax(-((queries - keys) * self.w)**2 / 2, dim=1)\n return torch.bmm(self.attention_weights.unsqueeze(1), values.unsqueeze(-1)).reshape(-1)\nX_tile = x_train.repeat((n_train, 1))\nY_tile = y_train.repeat((n_train, 1))\nkeys = X_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nvalues = Y_tile[(1 - torch.eye(n_train)).type(torch.bool)].reshape((n_train, -1))\nnet = NWKernelRegression()\nloss = nn.MSELoss(reduction='none')\ntrainer = torch.optim.SGD(net.parameters(), lr=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n trainer.zero_grad()\n l = loss(net(x_train, keys, values), y_train)\n l.sum().backward()\n trainer.step()\n animator.add(epoch + 1, float(l.sum()))\nkeys = x_train.repeat((n_test, 1))\nvalues = y_train.repeat((n_test, 1))\ny_hat = net(x_test, keys, values).unsqueeze(1).detach()\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(net.attention_weights.unsqueeze(0).unsqueeze(0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 629, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return tf.nn.softmax(X, axis=-1)\n else:\n shape = X.shape\n if len(valid_lens.shape) == 1:\n valid_lens = tf.repeat(valid_lens, repeats=shape[1])\n else:\n valid_lens = tf.reshape(valid_lens, shape=-1)\n X = d2l.sequence_mask(tf.reshape(X, shape=(-1, shape[-1])), valid_lens, value=-1e6)\n return tf.nn.softmax(tf.reshape(X, shape=shape), axis=-1)\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([2, 3]))\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([[1, 3], [2, 4]]))\nclass AdditiveAttention(tf.keras.layers.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super().__init__(**kwargs)\n self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.w_v = tf.keras.layers.Dense(1, use_bias=False)\n self.dropout = tf.keras.layers.Dropout(dropout)\n def call(self, queries, keys, values, valid_lens, **kwargs):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = tf.expand_dims(queries, axis=2) + tf.expand_dims(keys, axis=1)\n features = tf.nn.tanh(features)\n scores = tf.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries, keys = tf.random.normal(shape=(2, 1, 20)), tf.ones((2, 10, 2))\nvalues = tf.repeat(tf.reshape(tf.range(40, dtype=tf.float32), shape=(1, 10, 4)), repeats=2, axis=0)\nvalid_lens = tf.constant([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(tf.keras.layers.Layer):\n def __init__(self, dropout, **kwargs):\n super().__init__(**kwargs)\n self.dropout = tf.keras.layers.Dropout(dropout)\n\n def call(self, queries, keys, values, valid_lens, **kwargs):\n d = queries.shape[-1]\n scores = tf.matmul(queries, keys, transpose_b=True)/tf.math.sqrt(tf.cast(d, dtype=tf.float32))\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries = tf.random.normal(shape=(2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')", "pytorch": "import math\nimport torch\nfrom torch import nn\nfrom d2l import torch as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return nn.functional.softmax(X, dim=-1)\n else:\n shape = X.shape\n if valid_lens.dim() == 1:\n valid_lens = torch.repeat_interleave(valid_lens, shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = d2l.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, value=-1e6)\n return nn.functional.softmax(X.reshape(shape), dim=-1)\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([2, 3]))\nmasked_softmax(torch.rand(2, 2, 4), torch.tensor([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Module):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Linear(key_size, num_hiddens, bias=False)\n self.W_q = nn.Linear(query_size, num_hiddens, bias=False)\n self.w_v = nn.Linear(num_hiddens, 1, bias=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = queries.unsqueeze(2) + keys.unsqueeze(1)\n features = torch.tanh(features)\n scores = self.w_v(features).squeeze(-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries, keys = torch.normal(0, 1, (2, 1, 20)), torch.ones((2, 10, 2))\nvalues = torch.arange(40, dtype=torch.float32).reshape(1, 10, 4).repeat(2, 1, 1)\nvalid_lens = torch.tensor([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(nn.Module):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = torch.bmm(queries, keys.transpose(1,2)) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return torch.bmm(self.dropout(self.attention_weights), values)\nqueries = torch.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.eval()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')"} +{"id": 630, "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs, hidden_state, enc_valid_lens)\n def call(self, X, state, **kwargs):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X)\n X = tf.transpose(X, perm=(1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = tf.expand_dims(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n x = tf.concat((context, tf.expand_dims(x, axis=1)), axis=-1)\n out = self.rnn(x, hidden_state, **kwargs)\n hidden_state = out[1:]\n outputs.append(out[0])\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(tf.concat(outputs, axis=1))\n return outputs, [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\nstate = decoder.init_state(encoder(X, training=False), None)\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = tf.reshape(tf.concat([step[0][0][0] for step in dec_attention_weight_seq], 0), (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key posistions', ylabel='Query posistions')", "pytorch": "import torch\nfrom torch import nn\nfrom d2l import torch as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = nn.GRU(embed_size + num_hiddens, num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Linear(num_hiddens, vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.permute(1, 0, 2), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).permute(1, 0, 2)\n outputs, self._attention_weights = [], []\n for x in X:\n query = torch.unsqueeze(hidden_state[-1], dim=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = torch.cat((context, torch.unsqueeze(x, dim=1)), dim=-1)\n out, hidden_state = self.rnn(x.permute(1, 0, 2), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(torch.cat(outputs, dim=0))\n return outputs.permute(1, 0, 2), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.eval()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.eval()\nX = torch.zeros((4, 7), dtype=torch.long)\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = torch.cat([step[0][0][0] for step in dec_attention_weight_seq], 0).reshape((\n 1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1].cpu(), xlabel='Key positions', ylabel='Query positions')"} +{"id": 631, "mxnet": "from mxnet.gluon import nn\nclass Encoder(nn.Block):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def forward(self, X, *args):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def forward(self, X, state):\n raise NotImplementedError\nclass EncoderDecoder(nn.Block):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def forward(self, enc_X, dec_X, *args):\n enc_outputs = self.encoder(enc_X, *args)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state)", "tensorflow": "import tensorflow as tf\nclass Encoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Encoder, self).__init__(**kwargs)\n def call(self, X, *args, **kwargs):\n raise NotImplementedError\nclass Decoder(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super(Decoder, self).__init__(**kwargs)\n def init_state(self, enc_outputs, *args):\n raise NotImplementedError\n def call(self, X, state, **kwargs):\n raise NotImplementedError\nclass EncoderDecoder(tf.keras.Model):\n def __init__(self, encoder, decoder, **kwargs):\n super(EncoderDecoder, self).__init__(**kwargs)\n self.encoder = encoder\n self.decoder = decoder\n def call(self, enc_X, dec_X, *args, **kwargs):\n enc_outputs = self.encoder(enc_X, *args, **kwargs)\n dec_state = self.decoder.init_state(enc_outputs, *args)\n return self.decoder(dec_X, dec_state, **kwargs)"} +{"id": 632, "mxnet": "import collections\nimport math\nfrom mxnet import autograd, gluon, init, np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqEncoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n def forward(self, X, *args):\n X = self.embedding(X)\n X = X.swapaxes(0, 1)\n state = self.rnn.begin_state(batch_size=X.shape[1], ctx=X.ctx)\n output, state = self.rnn(X, state)\n return output, state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\nX = np.zeros((4, 7))\noutput, state = encoder(X)\noutput.shape\nlen(state), state[0].shape\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqDecoder, self).__init__(**kwargs)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def forward(self, X, state):\n X = self.embedding(X).swapaxes(0, 1)\n context = state[0][-1]\n context = np.broadcast_to(context, (X.shape[0], context.shape[0], context.shape[1]))\n X_and_context = np.concatenate((X, context), 2)\n output, state = self.rnn(X_and_context, state)\n output = self.dense(output).swapaxes(0, 1)\n return output, state\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape\nX = np.array([[1, 2, 3], [4, 5, 6]])\nnpx.sequence_mask(X, np.array([1, 2]), True, axis=1)\nX = np.ones((2, 3, 4))\nnpx.sequence_mask(X, np.array([1, 2]), True, value=-1, axis=1)\nclass MaskedSoftmaxCELoss(gluon.loss.SoftmaxCELoss):\n def forward(self, pred, label, valid_len):\n weights = np.expand_dims(np.ones_like(label), axis=-1)\n weights = npx.sequence_mask(weights, valid_len, True, axis=1)\n return super(MaskedSoftmaxCELoss, self).forward(pred, label, weights)\nloss = MaskedSoftmaxCELoss()\nloss(np.ones((3, 4, 10)), np.ones((3, 4)), np.array([4, 2, 0]))\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n net.initialize(init.Xavier(), force_reinit=True, ctx=device)\n trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr})\n loss = MaskedSoftmaxCELoss()\n animator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [\n x.as_in_ctx(device) for x in batch]\n bos = np.array([tgt_vocab['']] * Y.shape[0], ctx=device).reshape(-1, 1)\n dec_input = np.concatenate([bos, Y[:, :-1]], 1)\n with autograd.record():\n Y_hat, _ = net(X, dec_input, X_valid_len)\n l = loss(Y_hat, Y, Y_valid_len)\n l.backward()\n d2l.grad_clipping(net, 1)\n num_tokens = Y_valid_len.sum()\n trainer.step(num_tokens)\n metric.add(l.sum(), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, device, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [\n src_vocab['']]\n enc_valid_len = np.array([len(src_tokens)], ctx=device)\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = np.expand_dims(np.array(src_tokens, ctx=device), axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = np.expand_dims(np.array([tgt_vocab['']], ctx=device), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state)\n dec_X = Y.argmax(axis=2)\n pred = dec_X.squeeze(axis=0).astype('int32').item()\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred)\n return ' '.join(tgt_vocab.to_tokens(output_seq)), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps, device)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')", "tensorflow": "import collections\nimport math\nimport tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqEncoder(d2l.Encoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(*kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n def call(self, X, *args, **kwargs):\n X = self.embedding(X)\n output = self.rnn(X, **kwargs)\n state = output[1:]\n return output[0], state\nencoder = Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\noutput, state = encoder(X, training=False)\noutput.shape\nlen(state), [element.shape for element in state]\nclass Seq2SeqDecoder(d2l.Decoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, *args):\n return enc_outputs[1]\n def call(self, X, state, **kwargs):\n X = self.embedding(X)\n context = tf.repeat(tf.expand_dims(state[-1], axis=1), repeats=X.shape[1], axis=1)\n X_and_context = tf.concat((X, context), axis=2)\n rnn_output = self.rnn(X_and_context, state, **kwargs)\n output = self.dense(rnn_output[0])\n return output, rnn_output[1:]\ndecoder = Seq2SeqDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nstate = decoder.init_state(encoder(X))\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape\ndef sequence_mask(X, valid_len, value=0):\n maxlen = X.shape[1]\n mask = tf.range(start=0, limit=maxlen, dtype=tf.float32)[None, :] < tf.cast(valid_len[:, None], dtype=tf.float32)\n if len(X.shape) == 3:\n return tf.where(tf.expand_dims(mask, axis=-1), X, value)\n else:\n return tf.where(mask, X, value)\nX = tf.constant([[1, 2, 3], [4, 5, 6]])\nsequence_mask(X, tf.constant([1, 2]))\nX = tf.ones((2,3,4))\nsequence_mask(X, tf.constant([1, 2]), value=-1)\nclass MaskedSoftmaxCELoss(tf.keras.losses.Loss):\n def __init__(self, valid_len):\n super().__init__(reduction='none')\n self.valid_len = valid_len\n\n def call(self, label, pred):\n weights = tf.ones_like(label, dtype=tf.float32)\n weights = sequence_mask(weights, self.valid_len)\n label_one_hot = tf.one_hot(label, depth=pred.shape[-1])\n unweighted_loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True, reduction='none')(label_one_hot, pred)\n weighted_loss = tf.reduce_mean((unweighted_loss*weights), axis=1)\n return weighted_loss\nloss = MaskedSoftmaxCELoss(tf.constant([4, 2, 0]))\nloss(tf.ones((3,4), dtype = tf.int32), tf.ones((3, 4, 10))).numpy()\ndef train_seq2seq(net, data_iter, lr, num_epochs, tgt_vocab, device):\n optimizer = tf.keras.optimizers.Adam(learning_rate=lr)\n animator = d2l.Animator(xlabel=\"epoch\", ylabel=\"loss\", xlim=[10, num_epochs])\n for epoch in range(num_epochs):\n timer = d2l.Timer()\n metric = d2l.Accumulator(2)\n for batch in data_iter:\n X, X_valid_len, Y, Y_valid_len = [x for x in batch]\n bos = tf.reshape(tf.constant([tgt_vocab['']] * Y.shape[0]), shape=(-1, 1))\n dec_input = tf.concat([bos, Y[:, :-1]], 1)\n with tf.GradientTape() as tape:\n Y_hat, _ = net(X, dec_input, X_valid_len, training=True)\n l = MaskedSoftmaxCELoss(Y_valid_len)(Y, Y_hat)\n gradients = tape.gradient(l, net.trainable_variables)\n gradients = d2l.grad_clipping(gradients, 1)\n optimizer.apply_gradients(zip(gradients, net.trainable_variables))\n num_tokens = tf.reduce_sum(Y_valid_len).numpy()\n metric.add(tf.reduce_sum(l), num_tokens)\n if (epoch + 1) % 10 == 0:\n animator.add(epoch + 1, (metric[0] / metric[1],))\ndef predict_seq2seq(net, src_sentence, src_vocab, tgt_vocab, num_steps, save_attention_weights=False):\n src_tokens = src_vocab[src_sentence.lower().split(' ')] + [src_vocab['']]\n enc_valid_len = tf.constant([len(src_tokens)])\n src_tokens = d2l.truncate_pad(src_tokens, num_steps, src_vocab[''])\n enc_X = tf.expand_dims(src_tokens, axis=0)\n enc_outputs = net.encoder(enc_X, enc_valid_len, training=False)\n dec_state = net.decoder.init_state(enc_outputs, enc_valid_len)\n dec_X = tf.expand_dims(tf.constant([tgt_vocab['']]), axis=0)\n output_seq, attention_weight_seq = [], []\n for _ in range(num_steps):\n Y, dec_state = net.decoder(dec_X, dec_state, training=False)\n dec_X = tf.argmax(Y, axis=2)\n pred = tf.squeeze(dec_X, axis=0)\n if save_attention_weights:\n attention_weight_seq.append(net.decoder.attention_weights)\n if pred == tgt_vocab['']:\n break\n output_seq.append(pred.numpy())\n return ' '.join(tgt_vocab.to_tokens(tf.reshape(output_seq, shape = -1).numpy().tolist())), attention_weight_seq\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, attention_weight_seq = predict_seq2seq(net, eng, src_vocab, tgt_vocab, num_steps)\n print(f'{eng} => {translation}, bleu {bleu(translation, fra, k=2):.3f}')"} +{"id": 633, "mxnet": "from mxnet import np, npx\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.asnumpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = np.eye(10).reshape((1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef show_heatmaps(matrices, xlabel, ylabel, titles=None, figsize=(2.5, 2.5), cmap='Reds'):\n d2l.use_svg_display()\n num_rows, num_cols = matrices.shape[0], matrices.shape[1]\n fig, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize, sharex=True, sharey=True, squeeze=False)\n for i, (row_axes, row_matrices) in enumerate(zip(axes, matrices)):\n for j, (ax, matrix) in enumerate(zip(row_axes, row_matrices)):\n pcm = ax.imshow(matrix.numpy(), cmap=cmap)\n if i == num_rows - 1:\n ax.set_xlabel(xlabel)\n if j == 0:\n ax.set_ylabel(ylabel)\n if titles:\n ax.set_title(titles[j])\n fig.colorbar(pcm, ax=axes, shrink=0.6);\nattention_weights = tf.reshape(tf.eye(10), (1, 1, 10, 10))\nshow_heatmaps(attention_weights, xlabel='Keys', ylabel='Queries')"} +{"id": 634, "mxnet": "from mxnet import autograd, gluon, np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nn_train = 50\nx_train = np.sort(np.random.rand(n_train) * 5)\ndef f(x):\n return 2 * np.sin(x) + x**0.8\ny_train = f(x_train) + np.random.normal(0.0, 0.5, (n_train,))\nx_test = np.arange(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = y_train.mean().repeat(n_test)\nplot_kernel_reg(y_hat)\nX_repeat = x_test.repeat(n_train).reshape((-1, n_train))\nattention_weights = npx.softmax(-(X_repeat - x_train)**2 / 2)\ny_hat = np.dot(attention_weights, y_train)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = np.ones((2, 1, 4))\nY = np.ones((2, 4, 6))\nnpx.batch_dot(X, Y).shape\nweights = np.ones((2, 10)) * 0.1\nvalues = np.arange(20).reshape((2, 10))\nnpx.batch_dot(np.expand_dims(weights, 1), np.expand_dims(values, -1))\nclass NWKernelRegression(nn.Block):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = self.params.get('w', shape=(1,))\n def forward(self, queries, keys, values):\n queries = queries.repeat(keys.shape[1]).reshape((-1, keys.shape[1]))\n self.attention_weights = npx.softmax(-((queries - keys) * self.w.data())**2 / 2)\n return npx.batch_dot(np.expand_dims(self.attention_weights, 1), np.expand_dims(values, -1)).reshape(-1)\nX_tile = np.tile(x_train, (n_train, 1))\nY_tile = np.tile(y_train, (n_train, 1))\nkeys = X_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nvalues = Y_tile[(1 - np.eye(n_train)).astype('bool')].reshape((n_train, -1))\nnet = NWKernelRegression()\nnet.initialize()\nloss = gluon.loss.L2Loss()\ntrainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.5})\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with autograd.record():\n l = loss(net(x_train, keys, values), y_train)\n l.backward()\n trainer.step(1)\n animator.add(epoch + 1, float(l.sum()))\nkeys = np.tile(x_train, (n_test, 1))\nvalues = np.tile(y_train, (n_test, 1))\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(np.expand_dims(np.expand_dims(net.attention_weights, 0), 0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ntf.random.set_seed(seed=1322)\nn_train = 50\nx_train = tf.sort(tf.random.uniform(shape=(n_train,), maxval=5))\ndef f(x):\n return 2 * tf.sin(x) + x**0.8\ny_train = f(x_train) + tf.random.normal((n_train,), 0.0, 0.5)\nx_test = tf.range(0, 5, 0.1)\ny_truth = f(x_test)\nn_test = len(x_test)\nn_test\ny_hat = tf.repeat(tf.reduce_mean(y_train), repeats=n_test)\nplot_kernel_reg(y_hat)\nX_repeat = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nattention_weights = tf.nn.softmax(-(X_repeat - tf.expand_dims(x_train, axis=1))**2/2, axis=1)\ny_hat = tf.matmul(attention_weights, tf.expand_dims(y_train, axis=1))\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')\nX = tf.ones((2, 1, 4))\nY = tf.ones((2, 4, 6))\ntf.matmul(X, Y).shape\nweights = tf.ones((2, 10)) * 0.1\nvalues = tf.reshape(tf.range(20.0), shape = (2, 10))\ntf.matmul(tf.expand_dims(weights, axis=1), tf.expand_dims(values, axis=-1)).numpy()\nclass NWKernelRegression(tf.keras.layers.Layer):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.w = tf.Variable(initial_value=tf.random.uniform(shape=(1,)))\n def call(self, queries, keys, values, **kwargs):\n queries = tf.repeat(tf.expand_dims(queries, axis=1), repeats=keys.shape[1], axis=1)\n self.attention_weights = tf.nn.softmax(-((queries - keys) * self.w)**2 /2, axis =1)\n return tf.squeeze(tf.matmul(tf.expand_dims(self.attention_weights, axis=1), tf.expand_dims(values, axis=-1)))\nX_tile = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_train, axis=0)\nY_tile = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_train, axis=0)\nkeys = tf.reshape(X_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nvalues = tf.reshape(Y_tile[tf.cast(1 - tf.eye(n_train), dtype=tf.bool)], shape=(n_train, -1))\nnet = NWKernelRegression()\nloss_object = tf.keras.losses.MeanSquaredError()\noptimizer = tf.keras.optimizers.SGD(learning_rate=0.5)\nanimator = d2l.Animator(xlabel='epoch', ylabel='loss', xlim=[1, 5])\nfor epoch in range(5):\n with tf.GradientTape() as t:\n loss = loss_object(y_train, net(x_train, keys, values)) * len(y_train)\n grads = t.gradient(loss, net.trainable_variables)\n optimizer.apply_gradients(zip(grads, net.trainable_variables))\n animator.add(epoch + 1, float(loss))\nkeys = tf.repeat(tf.expand_dims(x_train, axis=0), repeats=n_test, axis=0)\nvalues = tf.repeat(tf.expand_dims(y_train, axis=0), repeats=n_test, axis=0)\ny_hat = net(x_test, keys, values)\nplot_kernel_reg(y_hat)\nd2l.show_heatmaps(tf.expand_dims(tf.expand_dims(net.attention_weights, axis=0), axis=0), xlabel='Sorted training inputs', ylabel='Sorted testing inputs')"} +{"id": 635, "mxnet": "import math\nfrom mxnet import np, npx\nfrom mxnet.gluon import nn\nfrom d2l import mxnet as d2l\nnpx.set_np()\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return npx.softmax(X)\n else:\n shape = X.shape\n if valid_lens.ndim == 1:\n valid_lens = valid_lens.repeat(shape[1])\n else:\n valid_lens = valid_lens.reshape(-1)\n X = npx.sequence_mask(X.reshape(-1, shape[-1]), valid_lens, True, value=-1e6, axis=1)\n return npx.softmax(X).reshape(shape)\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([2, 3]))\nmasked_softmax(np.random.uniform(size=(2, 2, 4)), np.array([[1, 3], [2, 4]]))\nclass AdditiveAttention(nn.Block):\n def __init__(self, num_hiddens, dropout, **kwargs):\n super(AdditiveAttention, self).__init__(**kwargs)\n self.W_k = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.W_q = nn.Dense(num_hiddens, use_bias=False, flatten=False)\n self.w_v = nn.Dense(1, use_bias=False, flatten=False)\n self.dropout = nn.Dropout(dropout)\n def forward(self, queries, keys, values, valid_lens):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = np.expand_dims(queries, axis=2) + np.expand_dims(keys, axis=1)\n features = np.tanh(features)\n scores = np.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries, keys = np.random.normal(0, 1, (2, 1, 20)), np.ones((2, 10, 2))\nvalues = np.arange(40).reshape(1, 10, 4).repeat(2, axis=0)\nvalid_lens = np.array([2, 6])\nattention = AdditiveAttention(num_hiddens=8, dropout=0.1)\nattention.initialize()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(nn.Block):\n def __init__(self, dropout, **kwargs):\n super(DotProductAttention, self).__init__(**kwargs)\n self.dropout = nn.Dropout(dropout)\n\n def forward(self, queries, keys, values, valid_lens=None):\n d = queries.shape[-1]\n scores = npx.batch_dot(queries, keys, transpose_b=True) / math.sqrt(d)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return npx.batch_dot(self.dropout(self.attention_weights), values)\nqueries = np.random.normal(0, 1, (2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention.initialize()\nattention(queries, keys, values, valid_lens)\nd2l.show_heatmaps(attention.attention_weights.reshape((1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\ndef masked_softmax(X, valid_lens):\n if valid_lens is None:\n return tf.nn.softmax(X, axis=-1)\n else:\n shape = X.shape\n if len(valid_lens.shape) == 1:\n valid_lens = tf.repeat(valid_lens, repeats=shape[1])\n else:\n valid_lens = tf.reshape(valid_lens, shape=-1)\n X = d2l.sequence_mask(tf.reshape(X, shape=(-1, shape[-1])), valid_lens, value=-1e6)\n return tf.nn.softmax(tf.reshape(X, shape=shape), axis=-1)\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([2, 3]))\nmasked_softmax(tf.random.uniform(shape=(2, 2, 4)), tf.constant([[1, 3], [2, 4]]))\nclass AdditiveAttention(tf.keras.layers.Layer):\n def __init__(self, key_size, query_size, num_hiddens, dropout, **kwargs):\n super().__init__(**kwargs)\n self.W_k = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.W_q = tf.keras.layers.Dense(num_hiddens, use_bias=False)\n self.w_v = tf.keras.layers.Dense(1, use_bias=False)\n self.dropout = tf.keras.layers.Dropout(dropout)\n def call(self, queries, keys, values, valid_lens, **kwargs):\n queries, keys = self.W_q(queries), self.W_k(keys)\n\n features = tf.expand_dims(queries, axis=2) + tf.expand_dims(keys, axis=1)\n features = tf.nn.tanh(features)\n scores = tf.squeeze(self.w_v(features), axis=-1)\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries, keys = tf.random.normal(shape=(2, 1, 20)), tf.ones((2, 10, 2))\nvalues = tf.repeat(tf.reshape(tf.range(40, dtype=tf.float32), shape=(1, 10, 4)), repeats=2, axis=0)\nvalid_lens = tf.constant([2, 6])\nattention = AdditiveAttention(key_size=2, query_size=20, num_hiddens=8, dropout=0.1)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')\nclass DotProductAttention(tf.keras.layers.Layer):\n def __init__(self, dropout, **kwargs):\n super().__init__(**kwargs)\n self.dropout = tf.keras.layers.Dropout(dropout)\n\n def call(self, queries, keys, values, valid_lens, **kwargs):\n d = queries.shape[-1]\n scores = tf.matmul(queries, keys, transpose_b=True)/tf.math.sqrt(tf.cast(d, dtype=tf.float32))\n self.attention_weights = masked_softmax(scores, valid_lens)\n return tf.matmul(self.dropout(self.attention_weights, **kwargs), values)\nqueries = tf.random.normal(shape=(2, 1, 2))\nattention = DotProductAttention(dropout=0.5)\nattention(queries, keys, values, valid_lens, training=False)\nd2l.show_heatmaps(tf.reshape(attention.attention_weights, (1, 1, 2, 10)), xlabel='Keys', ylabel='Queries')"} +{"id": 636, "mxnet": "from mxnet import np, npx\nfrom mxnet.gluon import nn, rnn\nfrom d2l import mxnet as d2l\nnpx.set_np()\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super(Seq2SeqAttentionDecoder, self).__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, dropout)\n self.embedding = nn.Embedding(vocab_size, embed_size)\n self.rnn = rnn.GRU(num_hiddens, num_layers, dropout=dropout)\n self.dense = nn.Dense(vocab_size, flatten=False)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs.swapaxes(0, 1), hidden_state, enc_valid_lens)\n def forward(self, X, state):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X).swapaxes(0, 1)\n outputs, self._attention_weights = [], []\n for x in X:\n query = np.expand_dims(hidden_state[0][-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens)\n x = np.concatenate((context, np.expand_dims(x, axis=1)), axis=-1)\n out, hidden_state = self.rnn(x.swapaxes(0, 1), hidden_state)\n outputs.append(out)\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(np.concatenate(outputs, axis=0))\n return outputs.swapaxes(0, 1), [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nencoder.initialize()\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder.initialize()\nX = np.zeros((4, 7))\nstate = decoder.init_state(encoder(X), None)\noutput, state = decoder(X, state)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = np.concatenate([step[0][0][0] for step in dec_attention_weight_seq], 0\n ).reshape((1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key positions', ylabel='Query positions')", "tensorflow": "import tensorflow as tf\nfrom d2l import tensorflow as d2l\nclass Seq2SeqAttentionDecoder(AttentionDecoder):\n def __init__(self, vocab_size, embed_size, num_hiddens, num_layers, dropout=0, **kwargs):\n super().__init__(**kwargs)\n self.attention = d2l.AdditiveAttention(num_hiddens, num_hiddens, num_hiddens, dropout)\n self.embedding = tf.keras.layers.Embedding(vocab_size, embed_size)\n self.rnn = tf.keras.layers.RNN(tf.keras.layers.StackedRNNCells([tf.keras.layers.GRUCell(num_hiddens, dropout=dropout) for _ in range(num_layers)]), return_sequences=True, return_state=True)\n self.dense = tf.keras.layers.Dense(vocab_size)\n def init_state(self, enc_outputs, enc_valid_lens, *args):\n outputs, hidden_state = enc_outputs\n return (outputs, hidden_state, enc_valid_lens)\n def call(self, X, state, **kwargs):\n enc_outputs, hidden_state, enc_valid_lens = state\n X = self.embedding(X)\n X = tf.transpose(X, perm=(1, 0, 2))\n outputs, self._attention_weights = [], []\n for x in X:\n query = tf.expand_dims(hidden_state[-1], axis=1)\n context = self.attention(query, enc_outputs, enc_outputs, enc_valid_lens, **kwargs)\n x = tf.concat((context, tf.expand_dims(x, axis=1)), axis=-1)\n out = self.rnn(x, hidden_state, **kwargs)\n hidden_state = out[1:]\n outputs.append(out[0])\n self._attention_weights.append(self.attention.attention_weights)\n outputs = self.dense(tf.concat(outputs, axis=1))\n return outputs, [enc_outputs, hidden_state, enc_valid_lens]\n @property\n def attention_weights(self):\n return self._attention_weights\nencoder = d2l.Seq2SeqEncoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\ndecoder = Seq2SeqAttentionDecoder(vocab_size=10, embed_size=8, num_hiddens=16, num_layers=2)\nX = tf.zeros((4, 7))\nstate = decoder.init_state(encoder(X, training=False), None)\noutput, state = decoder(X, state, training=False)\noutput.shape, len(state), state[0].shape, len(state[1]), state[1][0].shape\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}')\nattention_weights = tf.reshape(tf.concat([step[0][0][0] for step in dec_attention_weight_seq], 0), (1, 1, -1, num_steps))\nd2l.show_heatmaps(attention_weights[:, :, :, :len(engs[-1].split()) + 1], xlabel='Key posistions', ylabel='Query posistions')"}