Torch7 시작 속편 (4) --- Table layers를 이용한 유연한 네트워크 구축

총론

먼저 몇 가지 유용한 것을 부가하다.

replace(function)

이것은 function을 net의 모든 층에 응용할 수 있다.예를 들어 우리는 모델 중의 nn.Dropout 를 nn.Identity() 로 바꿀 수 있다. 분명히 전입된 매개 변수 module 는 임의로 어떤 변수로 쓰여도 어느 층을 가리킨다.

model:replace(function(module)
   if torch.typename(module) == 'nn.Dropout' then
      return nn.Identity()
   else
      return module
   end
end)

apply(function)

이것은 위의 것과 유사하며, 또한 모든 층을 조작한다.

local function weights_init(m)
   local name = torch.type(m)
   if name:find('Convolution') then
      m.weight:normal(0.0, 0.02)
      m.bias:fill(0)
   elseif name:find('BatchNormalization') then
      if m.weight then m.weight:normal(1.0, 0.02) end
      if m.bias then m.bias:fill(0) end
   end
end

-- define net
...
net:apply(weights_init)  -- net 

remove 및 insert

때때로 우리는 어떤 층을 직접 제거하거나 중간에 한 층을 추가하려고 한다.

model = nn.Sequential()
model:add(nn.Linear(10, 20))
model:add(nn.Linear(20, 20))
model:add(nn.Linear(20, 30))

--  index 
model:remove(2)
> model
nn.Sequential {
  [input -> (1) -> (2) -> output]
  (1): nn.Linear(10 -> 20)
  (2): nn.Linear(20 -> 30)
}

insert의 경우

model = nn.Sequential()
model:add(nn.Linear(10, 20))
model:add(nn.Linear(20, 30))
--  Linear(20,20) model 
model:insert(nn.Linear(20, 20), 2)
> model
nn.Sequential {
  [input -> (1) -> (2) -> (3) -> output]
  (1): nn.Linear(10 -> 20)
  (2): nn.Linear(20 -> 20)      -- The inserted layer
  (3): nn.Linear(20 -> 30)
}

training () 및 evaluate ()

Dropout이나 BN 같은 레이어에서는 훈련과 테스트가 다릅니다.이때 model:training() 또는 model:evaluate()로 진행할 수 있다.apply 함수는 위의 replace 함수와 유사하다.다음은 트레이닝 () 의 실현 방식입니다.

model:apply(function(module)
   module.train = true
end)

convolution

일반적으로 가장 많이 사용하는 것은 역시 Spatial Convolution과 반권적 Spatial Full Convolution이다.물론 너는 SpatialBatchNormalization 같은 것을 추가할 수 있다.우리도 convolution 방식으로 단독 패딩을 할 수 있다.0 padding,'반사패딩'과' padding로 나뉜다.module = nn.SpatialZeroPadding(padLeft, padRight, padTop, padBottom)module = nn.SpatialReflectionPadding(padLeft, padRight, padTop, padBottom)module = nn.SpatialReplicationPadding(padLeft, padRight, padTop, padBottom)은 이 세 가지 중 임의의 하나에 대해 우리는pad의 값을 음수로 직접 통해 재단 기능을 실현할 수 있다.예를 들어 module = nn.SpatialZeroPadding(-1,0,-1,0) 왼쪽과 위에서 각각 픽셀을 잘라낸다.

Table Layers

바로 table layers가 Torch가 매우 유연하고 강력한 네트워크를 구축할 수 있기 때문이다.

ConcatTable 및 ParrelTable

ConcatTable은 하나의 입력을 모든 구성원에게 먹이면 모든 구성원이 받는 내용이 똑같다는 것이다.n부를 복제한 셈이다.

                  +-----------+
             +----> {member1, |
+-------+    |    |           |
| input +----+---->  member2, |
+-------+    |    |           |
   or        +---->  member3} |
 {input}          +-----------+

mlp = nn.ConcatTable()
--  nn.Linear 5 ， 
--  member 。
mlp:add(nn.Linear(5, 2))
mlp:add(nn.Linear(5, 3))

pred = mlp:forward(torch.randn(5))
for i, k in ipairs(pred) do print(i, k) end
--  
1
-0.4073
 0.0110
[torch.Tensor of dimension 2]

2
 0.0027
-0.0598
-0.1189
[torch.Tensor of dimension 3]

대응하는 것은 Parallel Table입니다. 입력이 몇 부인지 몇 명의 구성원이 있어야 합니다. 순서대로 하나하나 대응하는 것입니다!ConcatTable은 입력은 한 부이지만 구성원은 n개, 입력은'n부로 복사'하고 각 구성원에게 한 부씩 줍니다.

+----------+         +-----------+
| {input1, +---------> {member1, |
|          |         |           |
|  input2, +--------->  member2, |
|          |         |           |
|  input3} +--------->  member3} |
+----------+         +-----------+

mlp = nn.ParallelTable()
--  ，ParallelTable ， input 。
--  memberi inputi
mlp:add(nn.Linear(10, 2))
mlp:add(nn.Linear(5, 3))

x = torch.randn(10)
y = torch.rand(5)

-- parallelTable 2 member， 2 。 table {x,y}
pred = mlp:forward{x, y} 
for i, k in pairs(pred) do print(i, k) end

1
 0.0331
 0.7003
[torch.Tensor of dimension 2]

2
 0.0677
-0.1657
-0.7383
[torch.Tensor of dimension 3]

JoinTable

이것은 주로 여러 개의 출력을 연합하는 것이다. 그러면 자연히 연합의 차원을 지정해야 한다.

module = JoinTable(dimension, nInputDims)

첫 번째 매개 변수는 몇 번째 차원에서 연합하는 것이다. 두 번째 매개 변수는 입력된 차원 크기를 나타낸다. 주의해야 할 것은 연합된table는 반드시 제dimension의 차원을 제외하고 다른 차원은 같아야 한다는 것이다!이것은 명백하다.안 그러면 난리야.

x = torch.randn(5, 1)
y = torch.randn(5, 1)
z = torch.randn(2, 1)

print(nn.JoinTable(1):forward{x, y})
print(nn.JoinTable(2):forward{x, y})
print(nn.JoinTable(1):forward{x, z})

 1.3965
 0.5146
-1.5244
-0.9540
 0.4256
 0.1575
 0.4491
 0.6580
 0.1784
-1.7362
[torch.DoubleTensor of dimension 10x1]

 1.3965  0.1575
 0.5146  0.4491
-1.5244  0.6580
-0.9540  0.1784
 0.4256 -1.7362
[torch.DoubleTensor of dimension 5x2]

-- x,z  ， 。
 1.3965
 0.5146
-1.5244
-0.9540
 0.4256
-1.2660
 1.0869
[torch.Tensor of dimension 7x1]

자주 쓰는 것은 이 세 개일 것이다. 물론 다른 것도 많다.table과 tensor 간에 서로 변환되는 것은 JoinTable 외에는 없습니다.그리고 SplitTable 등.

입력당 유사도

CosineDistance

이것은 모듈 간에 서로 측정값을 계산하는 층에 속한다.

mlp = nn.CosineDistance()
x = torch.Tensor({{1,2,3},{1,2,-3}})
y = torch.Tensor({{4,5,6},{-4,5,6}})
print(mlp:forward({x,y}))

-- {1 2 3} {4 5 6}
-- {1 2 -3} {-4 5 6}
 0.9746
-0.3655
[torch.DoubleTensor of size 2]

이것은 Simple Layers의 Cosine의 사용법과 여전히 큰 차이가 있다.유사한 것은 PairewiseDistance과DotProduct도 있다.

입력마다element-wise 작업

가감 곱하기 및 최대 최소 6가지 연산이다.예를 들어 CAddTable,..., CDivTable(), CMaxTable과 CMinTable 등이 있습니다.

--  。
m = nn.CDivTable()
a = torch.randn(4,5):mul(4):floor()
b = torch.Tensor(a:size()):fill(2)

th> a
 1  2 -6  0  1
 5  0 -2  8 -8
-1 -1  4  9  7
-7 -5 -4  0  5
[torch.DoubleTensor of size 4x5]

 >th m:forward({a,b})
 0.5000  1.0000 -3.0000  0.0000  0.5000
 2.5000  0.0000 -1.0000  4.0000 -4.0000
-0.5000 -0.5000  2.0000  4.5000  3.5000
-3.5000 -2.5000 -2.0000  0.0000  2.5000
[torch.DoubleTensor of size 4x5]

CriterionTable

mlp = nn.CriterionTable(nn.MSECriterion())
x = torch.randn(5)
y = torch.randn(5)
print(mlp:forward{x, x})
print(mlp:forward{x, y})

0
1.9028918413199