import math

import torch

import torch.nn as nn

import torch.nn$.$functional as F

:class TransformerBlock $($nn$.$Module$)$

:def $($self$,$ heads, d$,$ k$,$ m$,$ dropout$=0.)$

$()\_\_$super$($TransformerBlock$,$ self$).\_\_$init

self.k $=$ k

self.heads $=$ heads

self.wq $=$ nn$.$Linear$($d$,$ heads$**,$ bias$=$Ealse$)$

self.wk $=$ nn$.$Linear$($d$,$ heads$*$k$,$ bias$=$Ealse$)$

self.wy $=$ nn$.$Linear$($d$,$ heads$**$k$,$ bias$=$Ealse$)$

self.wc $=$ nn$.$Linear$($heads$*$k$,$ d$,$ bias$=$Ealse$)$

self.dropoutatt $=$ nn$.$ Dropout $($dropout$)$

self.wl $=$ nn$.$Linear$($d$,$ m$)$

self.dropoutfc $=$ nn$.$Dropout $($dropout$)$

self.w$2=$ nn$.$ Linear$($m$,$ d$)$

task define the dropout #

task define the layer normalixation $

nn$.$init.normal$\_($self$.$wq$.$weight, $0,\mathrm{.}02)$

nn$.$init.normal$\_($self$.$wk$.$weight, $0,\mathrm{.}02)$

nn$.$init.normal$\_($self$.$wv$.$weight, $0,\mathrm{.}02)$

nn$.$init.normal$\_($self$.$wc$.$weight, $0,\mathrm{.}02)$

nn$.$init.normal$\_($self$.$ml$.$weight, $0,\mathrm{.}02)$

nn$.$init.constant$\_($self$.$wl$.$bias, $0\mathrm{.}0)$

nn$.$init.normal$\_($self$.$w$2.$weight, $0,\mathrm{.}02)$

nn$.$init.constant$\_($self$.$w$2.$bias, $0\mathrm{.}0)$

:def forward$($self$,*,$ mask$)$

seq$\_$len, batch$\_$sixe, embed$\_$dim $=$ x$.$shape

task implement scaled dot$-$product attention $

task implement residual connection #

task implement the dropout $

task implement the layer normalimation #

task implement the posiion$-$mise feed formard network $

Hint: Kriting efficient code is almost as important $

$-$as writing correct code in ML

Avoid writing for$-$loops! Consider using the #

batch matrix multiplication operator torch.bmm

raise Not ImplementedError$("$Implement a trans former

block"$)$

return out

Complate task