Consecutive 1x1 conv layers

[takekbys]

There are a few consecutive 1x1 conv pairs, I think.
Does it contribute to performance improvement?
Isn't it a wasteful calculation?

For example, yolov5l has consecutive 1x1 conv pairs.

• end of 8(C3) and beginning of 9(SPPF)
• end of 9(SPPF) and 10(1x1 Conv)
• End of 13(C3) and 14(1x1 Conv)

I'm sorry if I have a misunderstanding.

[glenn-jocher]

@takekbys this is normal. Sometimes 1d convolutions are used to reduce channel counts before going into expensive operations, or to match channel counts from other sources, etc.

There's nothing 'wrong' in general with sequential 1D convolutions. This is the basic structure of most smaller fully connected neural networks. Larger kernels like 3x3 are useful for drawing in additional spatial information from the surroundings, which is why they are so common in visual CNNs.

[takekbys]

@glenn-jocher Thank you for your comment.

Sometimes 1d convolutions are used to reduce channel counts before going into expensive operations, or to match channel counts from other sources, etc.

I know the method, and there is no wrong point in the current implementation.
In my understanding, 1D convolutions (beginning of 9 and 10, 14) are inserted in order to reduce channel.
Taking "End of 13(C3) and 14(1x1 Conv)" as an example,
the same effect can be achieved by reducing only the output channels in C3.cv3.
It costs less, however the difference is very small.

Is there any reason not to take this approach?

[glenn-jocher]

@takekbys oh I see what you mean. Yes we could customize the C3 module to separate out C3.cv3(c1,c2) c2 channel count, as right now c2 affects c_ which is used throughout the module:

yolov5/models/common.py

Lines 127 to 140 in 2d45de6

	class C3(nn.Module):
	# CSP Bottleneck with 3 convolutions
	def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5): # ch_in, ch_out, number, shortcut, groups, expansion
	super().__init__()
	c_ = int(c2 * e) # hidden channels
	self.cv1 = Conv(c1, c_, 1, 1)
	self.cv2 = Conv(c1, c_, 1, 1)
	self.cv3 = Conv(2 * c_, c2, 1) # act=FReLU(c2)
	self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))
	# self.m = nn.Sequential(*[CrossConv(c_, c_, 3, 1, g, 1.0, shortcut) for _ in range(n)])
	def forward(self, x):
	return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), dim=1))

If we don't modify C3, we could also just pass updated c2 values to it, but then the entire C3 module will be doing smaller channel count ops. This may or may not be a good tradeoff (would certainly be faster but mAP may drop), it would need some before and after trainings to quantify the results.

[glenn-jocher]

@takekbys I looked a little closer. SPPF() seems like a good candidate to start since c2 there only affects the very last convolution. I've put a TODO here to investigate a few alternatives.