Yes but the grouped conv was contributed by the community in the end with:

  

      github.com/tensorflow/tensorflow
  

  
    
  
    
  

  
    
      Add support for cudnn's group convolution. 6
    

    
      tensorflow:master ← ppwwyyxx:master
    

    
      
        opened 
        
          
        
        Feb 18, 2019
      
      

      
        
          
          ppwwyyxx
        
      

      
        
          +251
          -65
        
      
    
  


  
    This PR enables group convolution in cudnn, a feature that's highly desired for …many years (#3332, https://github.com/tensorflow/tensorflow/issues/12052#issuecomment-320465264, #11662, #10482).

With this PR, now it's allowed to call `tf.nn.conv2d(inputs, filters)`, where the depth of `inputs` is not necessarily equal to `filters.shape[2]`, but be a multiple of `filters.shape[2]`.

The core of this PR is only two lines of code (https://github.com/tensorflow/tensorflow/issues/3332#issuecomment-464308902) which removes the shape check. Then I added some extra checks and tests.

This benchmark script:
```python
import tensorflow as tf
import time
import os

N = 64
C = 256
G = 32
H, W = 64, 64
print("N, C, H, W:", [N, C, H, W])


def benchmark_all(use_loop, format):
    shape4d = [N, C, H, W] if format == 'NCHW' else [N, H, W, C]

    tf.reset_default_graph()
    input = tf.get_variable('input', shape=shape4d, dtype=tf.float32)
    filter = tf.get_variable('filter', shape=[3, 3, C // G, C], dtype=tf.float32)

    if use_loop:
        inputs = tf.split(input, G, axis=1 if format == 'NCHW' else 3)
        filters = tf.split(filter, G, axis=3)
        output = tf.concat(
            [tf.nn.conv2d(i, f,
                strides=[1,1,1,1],
                padding='SAME',
                data_format=format) for i, f in zip(inputs, filters)], axis=1 if format == 'NCHW' else 3)
    else:
        output = tf.nn.conv2d(input, filter, strides=[1, 1, 1, 1], padding='SAME', data_format=format)


    forward_op = output.op
    cost = tf.reduce_sum(output)
    backward_op = tf.train.GradientDescentOptimizer(0.1).minimize(cost)

    def benchmark(op, nr_iter=200, nr_warmup=10):
        for k in range(nr_warmup):
            op.run()
        start = time.perf_counter()
        for k in range(nr_iter):
            op.run()
        end = time.perf_counter()
        itr_per_sec = nr_iter * 1. / (end - start)
        return itr_per_sec

    sess = tf.Session()
    with sess.as_default():
        sess.run(tf.global_variables_initializer())

        spd_forward = benchmark(forward_op)
        print("Loop={}, Format={}, Forward: {} itr/s".format(use_loop, format, spd_forward))
        spd_backward = benchmark(backward_op)
        print("Loop={}, Format={}, Backward: {} itr/s".format(use_loop, format, spd_backward))


formats = ['NHWC', 'NCHW']
for format in formats:
    for use_loop in [True, False]:
        benchmark_all(use_loop, format)
```
Executed on V100, cuda10, cudnn 7.4.2, it prints:
```
N, C, H, W: [64, 256, 64, 64]
Loop=True, Format=NHWC, Forward: 65.49446747235214 itr/s
Loop=True, Format=NHWC, Backward: 32.26484275606916 itr/s
Loop=False, Format=NHWC, Forward: 117.40288830454352 itr/s
Loop=False, Format=NHWC, Backward: 50.051492362319074 itr/s
Loop=True, Format=NCHW, Forward: 98.8428390274372 itr/s
Loop=True, Format=NCHW, Backward: 35.672312085388455 itr/s
Loop=False, Format=NCHW, Forward: 152.24726060851506 itr/s
Loop=False, Format=NCHW, Backward: 56.21414524041962 itr/s
```
which shows around 50~80% speed up over a naive loop-based implementation.
  

  

  
    
    
  

  


I could ask to @thea to check if it the transposed group conv ticket could be labeled as contribution welcome or it is already the internal roadmap.
Also that specific ticket has not so much community upvotes.