pytorch/test/expect/TestFuser.test_milstm_cuda-forward.expect at master · hyperscience/pytorch · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
graph(%x : Float(*, *)
      %hx : Float(*, *)
      %cx : Float(*, *)
      %w_ih : Float(*, *)
      %w_hh : Float(*, *)
      %alpha : Float(*)
      %beta_i : Float(*)
      %beta_h : Float(*)
      %bias : Float(*)) {
  %hy : Float(*, *), %cy : Float(*, *) = prim::DifferentiableGraph_0(%cx, %bias, %beta_h, %beta_i, %alpha, %hx, %w_hh, %x, %w_ih)
  %11 : (Float(*, *), Float(*, *)) = prim::TupleConstruct(%hy, %cy)
  return (%11);
}
with prim::DifferentiableGraph_0 = graph(%0 : Float(*, *)
      %1 : Float(*)
      %2 : Float(*)
      %3 : Float(*)
      %4 : Float(*)
      %5 : Float(*, *)
      %6 : Float(*, *)
      %7 : Float(*, *)
      %8 : Float(*, *)) {
  %9 : Float(*, *) = aten::t(%8)
  %Wx.1 : Float(*, *) = aten::mm(%7, %9)
  %11 : Float(*, *) = aten::t(%6)
  %Uz.1 : Float(*, *) = aten::mm(%5, %11)
  %13 : Float(*, *) = aten::mul(%4, %Wx.1)
  %14 : int[] = aten::size(%1)
  %15 : Tensor[] = prim::ListConstruct(%1, %2, %Uz.1, %13, %3, %Wx.1)
  %16 : Tensor[] = aten::broadcast_tensors(%15)
  %17 : Tensor, %18 : Tensor, %19 : Tensor, %20 : Tensor, %21 : Tensor, %22 : Tensor = prim::ListUnpack(%16)
  %23 : int[] = aten::size(%3)
  %24 : int[] = aten::size(%Wx.1)
  %25 : int[] = prim::BroadcastSizes(%23, %24)
  %26 : int[] = aten::size(%13)
  %27 : int[] = aten::size(%Uz.1)
  %28 : int[] = prim::BroadcastSizes(%26, %27)
  %29 : int[] = aten::size(%2)
  %30 : int[] = prim::BroadcastSizes(%29, %27)
  %31 : int[] = prim::BroadcastSizes(%28, %25)
  %32 : int[] = prim::BroadcastSizes(%31, %30)
  %hy : Float(*, *), %34 : Float(*, *), %cy : Float(*, *), %outgate.1 : Float(*, *), %cellgate.1 : Float(*, *), %forgetgate.1 : Float(*, *), %ingate.1 : Float(*, *) = prim::FusionGroup_0(%0, %22, %21, %20, %19, %18, %17)
  %40 : int[] = aten::size(%0)
  %41 : int[] = aten::size(%cellgate.1)
  %42 : int[] = aten::size(%forgetgate.1)
  %43 : int[] = aten::size(%ingate.1)
  %44 : int[] = prim::BroadcastSizes(%42, %40)
  %45 : int[] = prim::BroadcastSizes(%43, %41)
  return (%hy, %cy, %Wx.1, %Uz.1, %13, %28, %25, %31, %30, %32, %14, %ingate.1, %forgetgate.1, %cellgate.1, %outgate.1, %44, %45, %34);
}
with prim::FusionGroup_0 = graph(%0 : Float(*, *)
      %1 : Tensor
      %2 : Tensor
      %3 : Tensor
      %4 : Tensor
      %5 : Tensor
      %6 : Tensor) {
  %7 : Float(*, *), %8 : Float(*, *), %9 : Float(*, *), %10 : Float(*, *) = prim::ConstantChunk[chunks=4, dim=1](%6)
  %11 : Float(*, *), %12 : Float(*, *), %13 : Float(*, *), %14 : Float(*, *) = prim::ConstantChunk[chunks=4, dim=1](%5)
  %15 : Float(*, *), %16 : Float(*, *), %17 : Float(*, *), %18 : Float(*, *) = prim::ConstantChunk[chunks=4, dim=1](%4)
  %19 : Float(*, *), %20 : Float(*, *), %21 : Float(*, *), %22 : Float(*, *) = prim::ConstantChunk[chunks=4, dim=1](%3)
  %23 : Float(*, *), %24 : Float(*, *), %25 : Float(*, *), %26 : Float(*, *) = prim::ConstantChunk[chunks=4, dim=1](%2)
  %27 : Float(*, *), %28 : Float(*, *), %29 : Float(*, *), %30 : Float(*, *) = prim::ConstantChunk[chunks=4, dim=1](%1)
  %31 : int = prim::Constant[value=1]()
  %32 : Float(*, *) = aten::mul(%23, %27)
  %33 : Float(*, *) = aten::mul(%24, %28)
  %34 : Float(*, *) = aten::mul(%25, %29)
  %35 : Float(*, *) = aten::mul(%26, %30)
  %36 : Float(*, *) = aten::mul(%19, %15)
  %37 : Float(*, *) = aten::mul(%20, %16)
  %38 : Float(*, *) = aten::mul(%21, %17)
  %39 : Float(*, *) = aten::mul(%22, %18)
  %40 : Float(*, *) = aten::mul(%11, %15)
  %41 : Float(*, *) = aten::mul(%12, %16)
  %42 : Float(*, *) = aten::mul(%13, %17)
  %43 : Float(*, *) = aten::mul(%14, %18)
  %44 : Float(*, *) = aten::add(%36, %32, %31)
  %45 : Float(*, *) = aten::add(%37, %33, %31)
  %46 : Float(*, *) = aten::add(%38, %34, %31)
  %47 : Float(*, *) = aten::add(%39, %35, %31)
  %48 : Float(*, *) = aten::add(%44, %40, %31)
  %49 : Float(*, *) = aten::add(%45, %41, %31)
  %50 : Float(*, *) = aten::add(%46, %42, %31)
  %51 : Float(*, *) = aten::add(%47, %43, %31)
  %52 : Float(*, *) = aten::add(%48, %7, %31)
  %53 : Float(*, *) = aten::add(%49, %8, %31)
  %54 : Float(*, *) = aten::add(%50, %9, %31)
  %55 : Float(*, *) = aten::add(%51, %10, %31)
  %ingate.1 : Float(*, *) = aten::sigmoid(%52)
  %forgetgate.1 : Float(*, *) = aten::sigmoid(%53)
  %cellgate.1 : Float(*, *) = aten::tanh(%54)
  %outgate.1 : Float(*, *) = aten::sigmoid(%55)
  %60 : Float(*, *) = aten::mul(%forgetgate.1, %0)
  %61 : Float(*, *) = aten::mul(%ingate.1, %cellgate.1)
  %cy : Float(*, *) = aten::add(%60, %61, %31)
  %63 : Float(*, *) = aten::tanh(%cy)
  %hy : Float(*, *) = aten::mul(%outgate.1, %63)
  return (%hy, %63, %cy, %outgate.1, %cellgate.1, %forgetgate.1, %ingate.1);
}