What does [{n,{}}] do in lua?

2
votes

As you can tell I'm a beginner in lua. I am trying to understand a function I'm stuck at what the following code segment does?

It is used in the following code snippet in the last line:

function classify(txt_dir, img_dir, cls_list)
    local acc = 0.0
    local total = 0.0
    local fea_img = {}
    local fea_txt = {}
    for fname in io.lines(cls_list) do
        local imgpath = img_dir .. '/' .. fname .. '.t7'
        local txtpath = txt_dir .. '/' .. fname .. '.t7'
        fea_img[#fea_img + 1] = extract_img(imgpath) 
        fea_txt[#fea_txt + 1] = extract_txt(txtpath)
    end
    for i = 1,#fea_img do
        -- loop over individual images.
        for k = 1,fea_img[i]:size(1) do
            local best_match = 1
            local best_score = -math.huge
            for j = 1,#fea_txt do
                local cur_score = torch.dot(fea_img[i][{k,{}}], fea_txt[j])

From my understanding, fea_img is a lua table. Is the line fea_img[i][{k,{}}] some sort of slicing for the value for the key 'i' in the table fea_img?

I tried searching for more examples and found this being used here too (last line):

  for i = 1,nsamples,batchsize do
     -- indices
     local lasti = math.min(i+batchsize-1,nsamples)
     local m = lasti - i + 1

     -- k-means step, on minibatch
     local batch = x[{ {i,lasti},{} }]

Any help on this would be really appreciated. Thank you!

2
lualua-tabletorch
Odds are good that either there is something in the code you're not showing us or this code is broken yet just so happens to function. Because unless fea_img or x has some kind of metatable on it, there's no way that either of those expressions will result in anything other than nil. – Nicol Bolas
@NicolBolas I just pasted the section of the code that had the particular segment I was trying to understand. This is because I am not familiar with lua syntactically and just wanted to know what [{n,{}}]. I came across it in this code (line 169): link – SidharthM
It does have a meaning in Lua, but is only useful with an __index method and the specific implementation in [torch] would make the understanding complete. – Tom Blodget

2 Answers

3
votes

In lua you can access a specific index on a table in multiple ways. Like these two examples

local myValue = someTable.theIndex
-- or
local myOtherValue = someTable[2]

So the construct you see here is to access some values from a (nested) table.
Also in lua you can use anything except nil as a index, so even tables are possible.

The line

fea_img[i][{k,{}}]

Can be extended to this:

local index1 = i -- i in this case is your loop variable
local index2 = { k , { } } -- This creates a table with 2 values, the first one will be the vaule of the var k, the second one is an empty table

local value1 = fea_img[index1] -- This will get you a table
local value2 = value1[index2] -- This will get the same as: fea_img[i][{k,{}}]

Correction and Addition:

As Nicol Bolas already said in the comments: The index must be an exact match. Which means it literally has to be the same table, which is not the case for the presented code from you. Either you dropped code you thought is unnecessary or fea_img has some some kind of metatable on it.

In the case of

local k = 2
local table1 = {k, { } }
local table2 = {k, { } }

table2 and table1 do have the exact same content. But they are not the same table. Which will lead to nil always being retrieved if one is used to store data in a table and the other is used to get it back.

2
votes

Syntactically, t[k] is indexing a table with a key. Normally, if there is a record in the table with the key k, its value is returned. Nothing more, nothing less.

If fea_img[i] was a normal table, {k,{}} would always return nil, since table indices are resolved based on their identity ({k,{}} is always a new table). Based on your code, I have to conclude that the elements of fea_img (i.e. what extract_img returns) are not normal tables.

In Lua, you can override the indexing operation using a metatable. If you index a value that has a metatable with __index, it will be used if there is no matching record in the table:

local t = {}
setmetatable(t, {
    __index = function(t, k)
        return k
    end
})
print(t[{}])

This table has a metatable associated with it, which is used in the indexing operation. In this case __index returns the key, but whatever library you are using might provide more complex behaviour.

This is specific to the library you are using, not something related to the Lua syntax.