[BUG] pandas mismatch for `groupby(...).transform('size')`

[MarcoGorelli]

Describe the bug

There's a few issues here:

• the return type of transform('size') is DataFrame, whereas in pandas it would be Series
• transform('size') raises if there are string columns in the dataframe (even if they're not being grouped by)

Steps/Code to reproduce bug
Follow this guide http://matthewrocklin.com/blog/work/2018/02/28/minimal-bug-reports to craft a minimal bug report. This helps us reproduce the issue you're having and resolve the issue more quickly.

import cudf


df = cudf.DataFrame({"a": [1, 2, 2], "b": [4,5,6]})
print(df.groupby('a').transform('size'))

outputs

   b
0  1
1  2
2  2

Expected behavior
pandas does

0    1
1    2
2    2
dtype: int64

Environment overview (please complete the following information)

• Environment location: [Bare-metal, Docker, Cloud(specify cloud provider)]
• Method of cuDF install: [conda, Docker, or from source]
  • If method of install is [Docker], provide docker pull & docker run commands used

cudf version: '25.04.00'
pandas version: 2.2.3

Environment details
Please run and paste the output of the cudf/print_env.sh script here, to gather any other relevant environment details

Additional context

spotted in narwhals

[MarcoGorelli]

demo of the more problematic behaviour:

1. empty results when grouping by all columns:

import cudf


df = cudf.DataFrame({"a": [1, 2, 2]})
print(df.groupby('a').transform('size'))

Empty DataFrame
Columns: []
Index: [0, 1, 2]

2. raises when string columns just exist, even when we're not grouping by them

import cudf


df = cudf.DataFrame({"a": [1, 2, 2], "b": ['x','x','y']})
print(df.groupby('a').transform('size'))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/usr/local/lib/python3.11/dist-packages/cudf/core/groupby/groupby.py in transform(self, func, engine, engine_kwargs, *args, **kwargs)
   2243         try:
-> 2244             result = self.agg(func)
   2245         except TypeError as e:

/usr/local/lib/python3.11/dist-packages/cudf/utils/performance_tracking.py in wrapper(*args, **kwargs)
     50                 )
---> 51             return func(*args, **kwargs)
     52 

/usr/local/lib/python3.11/dist-packages/cudf/core/groupby/groupby.py in agg(self, func, engine, engine_kwargs, *args, **kwargs)
    993             included_aggregations,
--> 994         ) = self._aggregate(columns, normalized_aggs)
    995 

/usr/local/lib/python3.11/dist-packages/cudf/core/groupby/groupby.py in _aggregate(self, values, aggregations)
    806                 if _is_unsupported_agg_for_type(col.dtype, str_agg):
--> 807                     raise TypeError(
    808                         f"{col.dtype} type does not support {agg} operations"

TypeError: object type does not support size operations

The above exception was the direct cause of the following exception:

NotImplementedError                       Traceback (most recent call last)
/tmp/ipykernel_31/1609062042.py in <cell line: 0>()
      3 
      4 df = cudf.DataFrame({"a": [1, 2, 2], "b": ['x','x','y']})
----> 5 print(df.groupby('a').transform('size'))

/usr/local/lib/python3.11/dist-packages/cudf/utils/performance_tracking.py in wrapper(*args, **kwargs)
     49                     )
     50                 )
---> 51             return func(*args, **kwargs)
     52 
     53     return wrapper

/usr/local/lib/python3.11/dist-packages/cudf/core/groupby/groupby.py in transform(self, func, engine, engine_kwargs, *args, **kwargs)
   2244             result = self.agg(func)
   2245         except TypeError as e:
-> 2246             raise NotImplementedError(
   2247                 "Currently, `transform()` supports only aggregations."
   2248             ) from e

NotImplementedError: Currently, `transform()` supports only aggregations.

[mroeschke]

Thanks for the report!

Just noting for future readers that this will take some untangling to solve correctly:

transform and reduction methods, e.g. mean(), go through agg which always assumes the result is a DataFrame and has a lot of preprocessing logic. To match pandas' return behavior, transform, agg and reduction methods should each have individual logic to post processing logic instead instead of all going through agg.