lua - titulo - meta title wordpress

¿Hay un significado especial para la sintaxis()() en Lua?

Question

Veo mucho este tipo de sintaxis en un archivo fuente de Lua que estaba leyendo últimamente, ¿qué significa, especialmente el segundo par de paréntesis? Un ejemplo, la línea 8 en https://github.com/karpathy/char-rnn/blob/master/model/LSTM.lua

local LSTM = {}
function LSTM.lstm(input_size, rnn_size, n, dropout)
dropout = dropout or 0
-- there will be 2*n+1 inputs
local inputs = {}
table.insert(inputs, nn.Identity()()) -- line 8
-- ...

El código fuente de nn.Identity https://github.com/torch/nn/blob/master/Identity.lua

********** ACTUALIZACIÓN **************

El patrón () () se usa mucho en la biblioteca de la antorcha ''nn''. El primer par de corchetes crea un objeto del contenedor / nodo, y el segundo par de corchetes hace referencia al nodo dependiente.

Por ejemplo, y = nn. Lineal (2,4) (x) significa que x se conecta a y, y la transformación es lineal de 1 * 2 a 1 * 4. Simplemente entiendo el uso, cómo está cableado parece ser respondido por una de las respuestas a continuación.

De todos modos, el uso de la interfaz está bien documentado a continuación. https://github.com/torch/nngraph/blob/master/README.md

Answer 1

En complemento a la respuesta de Yu Hao, permítame darle algunas precisiones relacionadas con la Antorcha:

• nn.Identity() crea un módulo de identidad,
• () en este módulo se nn.Module __call__ (gracias al sistema de clase Torch que se conecta correctamente a lo metatable),
• por defecto este método __call__ realiza un avance / retroceso,
• pero aquí se usa torch/nngraph y nngraph anula este método como puede ver here .

En consecuencia, cada nn.Identity()() tiene aquí el efecto de devolver un nngraph.Node({module=self}) donde self se refiere a la instancia nn.Identity() actual.

-

Actualización : here se puede encontrar una ilustración de esta sintaxis en el contexto de LSTM-s :

local i2h = nn.Linear(input_size, 4 * rnn_size)(input) -- input to hidden

Si no está familiarizado con nngraph , probablemente parezca extraño que estemos construyendo un módulo y que ya lo estemos llamando una vez más con un nodo gráfico. Lo que realmente sucede es que la segunda llamada convierte el nn.Module a nngraph.gModule y el argumento especifica su padre en el gráfico .

Answer 2

No, ()() no tiene un significado especial en Lua, son solo dos operadores de llamadas () juntos.

El operando es posiblemente una función que devuelve una función (o una tabla que implementa el método de call ). Por ejemplo:

function foo()
return function() print(42) end
end
foo()() -- 42

Answer 3

• El primero () llama a la función de inicio y el segundo () llama a la función de llamada
• Si la clase no posee ninguna de estas funciones, se llama a las funciones principales.

• En el caso de nn.Identity () (), nn.Identity no tiene una función de inicio ni una función de llamada, por lo tanto, las funciones de inicio y de llamada del módulo de identidad nn.

  require ''torch''
  -- define some dummy A class
  local A = torch.class(''A'')
  function A:__init(stuff)
  self.stuff = stuff
  print(''inside __init of A'')
  end
  function A:__call__(arg1)
  print(''inside __call__ of A'')
  end
  -- define some dummy B class, inheriting from A
  local B,parent = torch.class(''B'', ''A'')
  function B:__init(stuff)
  self.stuff = stuff
  print(''inside __init of B'')
  end
  function B:__call__(arg1)
  print(''inside __call__ of B'')
  end
  a=A()()
  b=B()()

  Salida

  inside __init of A
  inside __call__ of A
  inside __init of B
  inside __call__ of B

Otro ejemplo de código

 require ''torch''
-- define some dummy A class
local A = torch.class(''A'')
function A:__init(stuff)
self.stuff = stuff
print(''inside __init of A'')
end
function A:__call__(arg1)
print(''inside __call__ of A'')
end
-- define some dummy B class, inheriting from A
local B,parent = torch.class(''B'', ''A'')
b=B()()

Salida

 inside __init of A
inside __call__ of A