Thanks again for your response and your proposal to translate the Torch model into pyTorch. It gives me some hope… 
Here’s the complete definition of the TorchNN/LUA network:
require 'torch'
require 'nn'

local mlp1 = nn.Sequential()
	mlp1:add(nn.SplitTable(1))

local c = nn.ParallelTable()
-- input data	
	for i = 1,12 do 
		c:add(nn.Linear(14,42))
	end	
	
mlp1:add(c)
mlp1:add(nn.JoinTable(1))

-- input extra data
local ex = nn.Sequential()	
	ex:add(nn.Linear(5,15))	

local rs1 = nn.ParallelTable()	
rs1:add(mlp1)
rs1:add(ex)

local mlp = nn.Sequential()	

mlp:add(rs1)
mlp:add(nn.JoinTable(1))

mlp:add(nn.Linear(519,780))
mlp:add(nn.PReLU())
mlp:add(nn.Linear(780,520))
mlp:add(nn.PReLU())
mlp:add(nn.Linear(520,160))
mlp:add(nn.Tanh())
-- output
mlp:add(nn.Linear(160,12))

print(mlp)

nn.Sequential {
  [input -> (1) -> (2) -> (3) -> (4) -> (5) -> (6) -> (7) -> (8) -> (9) -> output]
  (1): nn.ParallelTable {
    input
      |`-> (1): nn.Sequential {
      |      [input -> (1) -> (2) -> (3) -> output]
      |      (1): nn.SplitTable
      |      (2): nn.ParallelTable {
      |        input
      |          |`-> (1): nn.Linear(14 -> 42)
      |          |`-> (2): nn.Linear(14 -> 42)
      |          |`-> (3): nn.Linear(14 -> 42)
      |          |`-> (4): nn.Linear(14 -> 42)
      |          |`-> (5): nn.Linear(14 -> 42)
      |          |`-> (6): nn.Linear(14 -> 42)
      |          |`-> (7): nn.Linear(14 -> 42)
      |          |`-> (8): nn.Linear(14 -> 42)
      |          |`-> (9): nn.Linear(14 -> 42)
      |          |`-> (10): nn.Linear(14 -> 42)
      |          |`-> (11): nn.Linear(14 -> 42)
      |           `-> (12): nn.Linear(14 -> 42)
      |           ... -> output
      |      }
      |      (3): nn.JoinTable
      |    }
       `-> (2): nn.Sequential {
             [input -> (1) -> output]
             (1): nn.Linear(5 -> 15)
           }
       ... -> output
  }
  (2): nn.JoinTable
  (3): nn.Linear(519 -> 780)
  (4): nn.PReLU
  (5): nn.Linear(780 -> 520)
  (6): nn.PReLU
  (7): nn.Linear(520 -> 160)
  (8): nn.Tanh
  (9): nn.Linear(160 -> 12)
}


x1 = torch.rand(12, 14)
x2 = torch.rand(5)  
  	
			      					      	
local output = mlp:forward({x1,x2})     

print(output)

 0.0489
-0.0246
-0.0636
-0.0101
 0.0670
 0.0883
 0.1112
 0.0109
-0.1157
 0.0715
 0.0773
-0.0449
[torch.DoubleTensor of size 12]

In the Torch model we can easily make an nn.ParallelTable() of 12 nn.Linear(14,42) then add an input of the extra data: nn.Linear(5,15), do add() and nn.JoinTable().
I don’t know how to do the pyTorch equivalent. I used the nn.ModuleList() and the torch.cat(), but probably in the wrong way as you explained above, which causes very bad results.
I hope I have given you enough details to understand my problem.
Thank you for taking the time to answer me.
Sincerely
GP