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

Question

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!

Answer 1

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.

Answer 2

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 (ie 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.