# Batch-wise processing is quite slow

Suppose I have three vectors A, B, C

``````A vector size of 256
B vector size of 256
C vector size of 256
``````

Now I want to do concatenation in the following way:

``````AB= vector size will be 512
AC = vector size will be 512
BC = vector size will be 512
``````

However, I need to restrict all the concatenated vectors to 256, like:

``````AB= vector size will be 256
AC = vector size will be 256
BC = vector size will be 256
``````

One way is to take the mean of each two values of the two vectors like `A first index value` and `B first index value`, `A second index value` and `B second index value` … etc. Similarly, in the concatenation of other vectors.

How I implement this:

``````x # torch.Size([32, 3, 256]) # 32 is Batch size, 3 is vector A, vector B, vector C and 256 is each vector dimension

def my_fun(self, x):
iter = x.shape
counter = 0
new_x = torch.zeros((10, x.shape), dtype=torch.float32, device=torch.device('cuda'))
for i in range(0, x.shape - 1):
iter -= 1
for j in range(0, iter):
mean = (x[i, :] + x[i+j, :])/2
new_x[counter, :] = torch.unsqueeze(mean, 0)
counter += 1
final_T = torch.cat((x, new_x), dim=0)
return final_T

ref = torch.zeros((x.shape, 15, x.shape), dtype=torch.float32, device=torch.device('cuda'))
for i in range (x.shape):
ref[i, :, :] = self.my_fun(x[i, :, :])
``````

But this implementation is computationally expensive. One reason is I am iterating batch-wise which makes it computationally expensive. Is there any efficient way to implement this task?