Interoperability between cuDF and CuPy

This notebook provides introductory examples of how you can use cuDF and CuPy together to take advantage of CuPy array functionality (such as advanced linear algebra operations).

import timeit
from packaging import version

import cupy as cp
import cudf

if version.parse(cp.__version__) >= version.parse("10.0.0"):
    cupy_from_dlpack = cp.from_dlpack
else:
    cupy_from_dlpack = cp.fromDlpack

Converting a cuDF DataFrame to a CuPy Array

If we want to convert a cuDF DataFrame to a CuPy ndarray, There are multiple ways to do it:

1. We can use the dlpack interface.

2. We can also use DataFrame.values.

3. We can also convert via the CUDA array interface by using cuDF’s to_cupy functionality.

nelem = 10000
df = cudf.DataFrame({'a':range(nelem),
                     'b':range(500, nelem + 500),
                     'c':range(1000, nelem + 1000)}
                   )

%timeit arr_cupy = cupy_from_dlpack(df.to_dlpack())
%timeit arr_cupy = df.values
%timeit arr_cupy = df.to_cupy()

193 µs ± 2.3 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

621 µs ± 2.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

624 µs ± 3.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

arr_cupy = cupy_from_dlpack(df.to_dlpack())
arr_cupy

array([[    0,   500,  1000],
       [    1,   501,  1001],
       [    2,   502,  1002],
       ...,
       [ 9997, 10497, 10997],
       [ 9998, 10498, 10998],
       [ 9999, 10499, 10999]])

Converting a cuDF Series to a CuPy Array

There are also multiple ways to convert a cuDF Series to a CuPy array:

1. We can pass the Series to cupy.asarray as cuDF Series exposes __cuda_array_interface__.

2. We can leverage the dlpack interface to_dlpack().

3. We can also use Series.values

col = 'a'

%timeit cola_cupy = cp.asarray(df[col])
%timeit cola_cupy = cupy_from_dlpack(df[col].to_dlpack())
%timeit cola_cupy = df[col].values

92 µs ± 235 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

214 µs ± 855 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)

200 µs ± 445 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each)

cola_cupy = cp.asarray(df[col])
cola_cupy

array([   0,    1,    2, ..., 9997, 9998, 9999])

From here, we can proceed with normal CuPy workflows, such as reshaping the array, getting the diagonal, or calculating the norm.

reshaped_arr = cola_cupy.reshape(50, 200)
reshaped_arr

array([[   0,    1,    2, ...,  197,  198,  199],
       [ 200,  201,  202, ...,  397,  398,  399],
       [ 400,  401,  402, ...,  597,  598,  599],
       ...,
       [9400, 9401, 9402, ..., 9597, 9598, 9599],
       [9600, 9601, 9602, ..., 9797, 9798, 9799],
       [9800, 9801, 9802, ..., 9997, 9998, 9999]])

reshaped_arr.diagonal()

array([   0,  201,  402,  603,  804, 1005, 1206, 1407, 1608, 1809, 2010,
       2211, 2412, 2613, 2814, 3015, 3216, 3417, 3618, 3819, 4020, 4221,
       4422, 4623, 4824, 5025, 5226, 5427, 5628, 5829, 6030, 6231, 6432,
       6633, 6834, 7035, 7236, 7437, 7638, 7839, 8040, 8241, 8442, 8643,
       8844, 9045, 9246, 9447, 9648, 9849])

cp.linalg.norm(reshaped_arr)

array(577306.967739)

Converting a CuPy Array to a cuDF DataFrame

We can also convert a CuPy ndarray to a cuDF DataFrame. Like before, there are multiple ways to do it:

1. Easiest; We can directly use the DataFrame constructor.

2. We can use CUDA array interface with the DataFrame constructor.

3. We can also use the dlpack interface.

For the latter two cases, we’ll need to make sure that our CuPy array is Fortran contiguous in memory (if it’s not already). We can either transpose the array or simply coerce it to be Fortran contiguous beforehand.

%timeit reshaped_df = cudf.DataFrame(reshaped_arr)

30.3 ms ± 157 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

reshaped_df = cudf.DataFrame(reshaped_arr)
reshaped_df.head()

	0	1	2	3	4	5	6	7	8	9	...	190	191	192	193	194	195	196	197	198	199
0	0	1	2	3	4	5	6	7	8	9	...	190	191	192	193	194	195	196	197	198	199
1	200	201	202	203	204	205	206	207	208	209	...	390	391	392	393	394	395	396	397	398	399
2	400	401	402	403	404	405	406	407	408	409	...	590	591	592	593	594	595	596	597	598	599
3	600	601	602	603	604	605	606	607	608	609	...	790	791	792	793	794	795	796	797	798	799
4	800	801	802	803	804	805	806	807	808	809	...	990	991	992	993	994	995	996	997	998	999

5 rows × 200 columns

We can check whether our array is Fortran contiguous by using cupy.isfortran or looking at the flags of the array.

cp.isfortran(reshaped_arr)

False

In this case, we’ll need to convert it before going to a cuDF DataFrame. In the next two cells, we create the DataFrame by leveraging dlpack and the CUDA array interface, respectively.

%%timeit

fortran_arr = cp.asfortranarray(reshaped_arr)
reshaped_df = cudf.DataFrame(fortran_arr)

11.7 ms ± 99.1 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

%%timeit

fortran_arr = cp.asfortranarray(reshaped_arr)
reshaped_df = cudf.from_dlpack(fortran_arr.toDlpack())

7.35 ms ± 24.5 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

fortran_arr = cp.asfortranarray(reshaped_arr)
reshaped_df = cudf.DataFrame(fortran_arr)
reshaped_df.head()

	0	1	2	3	4	5	6	7	8	9	...	190	191	192	193	194	195	196	197	198	199
0	0	1	2	3	4	5	6	7	8	9	...	190	191	192	193	194	195	196	197	198	199
1	200	201	202	203	204	205	206	207	208	209	...	390	391	392	393	394	395	396	397	398	399
2	400	401	402	403	404	405	406	407	408	409	...	590	591	592	593	594	595	596	597	598	599
3	600	601	602	603	604	605	606	607	608	609	...	790	791	792	793	794	795	796	797	798	799
4	800	801	802	803	804	805	806	807	808	809	...	990	991	992	993	994	995	996	997	998	999

5 rows × 200 columns

Converting a CuPy Array to a cuDF Series

To convert an array to a Series, we can directly pass the array to the Series constructor.

cudf.Series(reshaped_arr.diagonal()).head()

0      0
1    201
2    402
3    603
4    804
dtype: int64

Interweaving CuDF and CuPy for Smooth PyData Workflows

RAPIDS libraries and the entire GPU PyData ecosystem are developing quickly, but sometimes a one library may not have the functionality you need. One example of this might be taking the row-wise sum (or mean) of a Pandas DataFrame. cuDF’s support for row-wise operations isn’t mature, so you’d need to either transpose the DataFrame or write a UDF and explicitly calculate the sum across each row. Transposing could lead to hundreds of thousands of columns (which cuDF wouldn’t perform well with) depending on your data’s shape, and writing a UDF can be time intensive.

By leveraging the interoperability of the GPU PyData ecosystem, this operation becomes very easy. Let’s take the row-wise sum of our previously reshaped cuDF DataFrame.

reshaped_df.head()

	0	1	2	3	4	5	6	7	8	9	...	190	191	192	193	194	195	196	197	198	199
0	0	1	2	3	4	5	6	7	8	9	...	190	191	192	193	194	195	196	197	198	199
1	200	201	202	203	204	205	206	207	208	209	...	390	391	392	393	394	395	396	397	398	399
2	400	401	402	403	404	405	406	407	408	409	...	590	591	592	593	594	595	596	597	598	599
3	600	601	602	603	604	605	606	607	608	609	...	790	791	792	793	794	795	796	797	798	799
4	800	801	802	803	804	805	806	807	808	809	...	990	991	992	993	994	995	996	997	998	999

5 rows × 200 columns

We can just transform it into a CuPy array and use the axis argument of sum.

new_arr = cupy_from_dlpack(reshaped_df.to_dlpack())
new_arr.sum(axis=1)

array([  19900,   59900,   99900,  139900,  179900,  219900,  259900,
        299900,  339900,  379900,  419900,  459900,  499900,  539900,
        579900,  619900,  659900,  699900,  739900,  779900,  819900,
        859900,  899900,  939900,  979900, 1019900, 1059900, 1099900,
       1139900, 1179900, 1219900, 1259900, 1299900, 1339900, 1379900,
       1419900, 1459900, 1499900, 1539900, 1579900, 1619900, 1659900,
       1699900, 1739900, 1779900, 1819900, 1859900, 1899900, 1939900,
       1979900])

With just that single line, we’re able to seamlessly move between data structures in this ecosystem, giving us enormous flexibility without sacrificing speed.

Converting a cuDF DataFrame to a CuPy Sparse Matrix

We can also convert a DataFrame or Series to a CuPy sparse matrix. We might want to do this if downstream processes expect CuPy sparse matrices as an input.

The sparse matrix data structure is defined by three dense arrays. We’ll define a small helper function for cleanliness.

def cudf_to_cupy_sparse_matrix(data, sparseformat='column'):
    """Converts a cuDF object to a CuPy Sparse Column matrix.
    """
    if sparseformat not in ('row', 'column',):
        raise ValueError("Let's focus on column and row formats for now.")
    
    _sparse_constructor = cp.sparse.csc_matrix
    if sparseformat == 'row':
        _sparse_constructor = cp.sparse.csr_matrix

    return _sparse_constructor(cupy_from_dlpack(data.to_dlpack()))

We can define a sparsely populated DataFrame to illustrate this conversion to either sparse matrix format.

df = cudf.DataFrame()
nelem = 10000
nonzero = 1000
for i in range(20):
    arr = cp.random.normal(5, 5, nelem)
    arr[cp.random.choice(arr.shape[0], nelem-nonzero, replace=False)] = 0
    df['a' + str(i)] = arr

df.head()

	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15	a16	a17	a18	a19
0	0.0	0.0	0.000000	0.0	0.0	0.000000	0.0	0.0	0.0	0.000000	0.0	0.0	0.0	8.548592	0.0	0.0	0.0	0.0	0.000000	0.0
1	0.0	0.0	6.501127	0.0	0.0	12.224488	0.0	0.0	0.0	0.000000	0.0	0.0	0.0	0.000000	0.0	0.0	0.0	0.0	0.000000	0.0
2	0.0	0.0	0.000000	0.0	0.0	0.000000	0.0	0.0	0.0	7.589211	0.0	0.0	0.0	0.000000	0.0	0.0	0.0	0.0	0.000000	0.0
3	0.0	0.0	-0.761586	0.0	0.0	0.000000	0.0	0.0	0.0	0.000000	0.0	0.0	0.0	2.187749	0.0	0.0	0.0	0.0	0.000000	0.0
4	0.0	0.0	0.000000	0.0	0.0	0.000000	0.0	0.0	0.0	0.000000	0.0	0.0	0.0	0.000000	0.0	0.0	0.0	0.0	4.905935	0.0

sparse_data = cudf_to_cupy_sparse_matrix(df)
print(sparse_data)

  (898, 0)	2.4668119015132546
  (131, 0)	8.547345659265758
  (643, 0)	11.2448926084385
  (1284, 0)	13.044261391142314
  (6, 0)	3.5897830877708454
  (1159, 0)	5.175503420808092
  (1160, 0)	0.49352644833744685
  (138, 0)	13.508076418957103
  (906, 0)	6.46688900193911
  (1162, 0)	8.648077496549183
  (651, 0)	-0.3352431843528214
  (12, 0)	3.901104765516799
  (269, 0)	-3.2494988332596253
  (1294, 0)	11.183326046432091
  (1168, 0)	-1.9696739985892209
  (274, 0)	4.042767685275079
  (1298, 0)	11.487307206919766
  (20, 0)	12.360040596339129
  (660, 0)	2.4959809703296028
  (1044, 0)	0.6764645382676576
  (1300, 0)	8.578966911106827
  (1173, 0)	10.755412315477923
  (1302, 0)	11.309035846159736
  (151, 0)	-1.4877620241223222
  (409, 0)	7.911675857093238
  :	:
  (9958, 19)	2.926200379188113
  (8935, 19)	1.0843687899660726
  (9320, 19)	13.515680391162945
  (9704, 19)	7.298370408990558
  (9833, 19)	5.852759115535664
  (9578, 19)	5.883379514229941
  (9834, 19)	7.75622901624125
  (9836, 19)	0.7014920632316329
  (8813, 19)	5.829758567340508
  (9325, 19)	1.884461383951697
  (9453, 19)	7.197402475933533
  (9582, 19)	12.086616717175165
  (9071, 19)	-2.140016584938728
  (9584, 19)	-1.1984652652464867
  (9840, 19)	7.089811432339605
  (8948, 19)	11.878004955466997
  (9464, 19)	-3.1036854694782265
  (9848, 19)	4.089650291876788
  (9851, 19)	9.613530401895034
  (9212, 19)	2.2578680941076916
  (9852, 19)	-2.414466721931874
  (9085, 19)	10.785215426412083
  (9853, 19)	2.0016246296186813
  (8702, 19)	5.087774251463143
  (9343, 19)	11.892612736792666

From here, we could continue our workflow with a CuPy sparse matrix.

For a full list of the functionality built into these libraries, we encourage you to check out the API docs for cuDF and CuPy.