Enhancing Recommender Systems with Co-Visitation Matrices and RAPIDS cuDF

Recommender
systems
are
crucial
for
personalizing
user
experiences
across
various
platforms.
These
systems
predict
and
suggest
items
that
users
are
likely
to
interact
with,
based
on
their
past
behavior
and
preferences.
Building
an
effective
recommender
system
involves
leveraging
large,
complex
datasets
that
capture
user-item
interactions.

Recommender
Systems
and
Co-Visitation
Matrices

Recommender
systems
are
machine
learning
algorithms
designed
to
deliver
personalized
suggestions
to
users.
They
are
widely
used
in
e-commerce,
content
streaming,
and
social
media
to
help
users
discover
products,
services,
or
content
aligned
with
their
interests.

Datasets
for
recommender
systems
typically
include:

• Items
  to
  recommend,
  which
  can
  number
  in
  the
  millions.
• Interactions
  between
  users
  and
  items,
  forming
  sessions
  that
  help
  infer
  future
  user
  interactions.

A
co-visitation
matrix
counts
items
that
appear
together
in
a
session,
making
it
easier
to
recommend
items
that
frequently
co-occur
with
those
in
a
user’s
session.

Challenges
in
Building
Co-Visitation
Matrices

Computing
co-visitation
matrices
involves
processing
numerous
sessions
and
counting
all
co-occurrences,
which
can
be
computationally
expensive.
Traditional
methods
using
libraries
like
pandas
can
be
inefficient
and
slow
for
large
datasets,
necessitating
heavy
optimization
for
practical
use.

RAPIDS
cuDF,
a
GPU
DataFrame
library,
addresses
these
issues
by
providing
a
pandas-like
API
for
faster
data
manipulation.
It
accelerates
computations
by
up
to
40x
without
requiring
code
changes.

RAPIDS
cuDF
Pandas
Accelerator
Mode

RAPIDS
cuDF
is
designed
to
speed
up
operations
like
loading,
joining,
aggregating,
and
filtering
on
large
datasets.
Its
new
pandas
accelerator
mode
allows
for
accelerated
computing
in
pandas
workflows,
delivering
50x
to
150x
faster
performance
for
tabular
data
processing.

The
Data

The
data
for
this
tutorial
comes
from
the
OTTO
–
Multi-Objective
Recommender
System
Kaggle
competition,
which
includes
one
month
of
sessions.
The
dataset
contains
1.86
million
items
and
around
500
million
user-item
interactions,
stored
in
chunked
parquet
files
for
easier
handling.

Implementing
Co-Visitation
Matrices

To
build
co-visitation
matrices
efficiently,
the
data
is
split
into
parts
to
manage
memory
usage.
Sessions
are
loaded,
and
transformations
are
applied
to
save
memory.
Interactions
are
restricted
to
a
manageable
number,
and
co-occurrences
are
computed
by
merging
the
data
with
itself
on
the
session
column.

Weights
are
assigned
to
pairs
of
items,
and
the
matrix
is
updated
by
adding
new
weights
to
previous
ones.
Finally,
the
matrix
is
reduced
to
keep
only
the
best
candidates
per
item,
ensuring
that
the
most
relevant
information
is
retained.

Generating
Candidates

Co-visitation
matrices
can
be
used
to
generate
recommendation
candidates
by
aggregating
weights
over
session
items.
The
items
with
the
highest
weights
are
recommended.
This
process
benefits
significantly
from
the
GPU
accelerator,
making
it
faster
and
more
efficient.

Performance
Assessment

The
recall
metric
is
used
to
evaluate
the
strength
of
the
candidates.
In
this
case,
the
recall@20
metric
showed
a
strong
baseline
performance,
with
an
achieved
recall
of
0.5868.
This
means
that
out
of
20
items
recommended,
on
average,
11
were
purchased
by
the
user.

Going
Further

Improving
candidate
recall
involves
giving
more
history
to
the
matrices,
refining
the
matrices
by
considering
interaction
types,
and
adjusting
weights
based
on
the
importance
of
session
items.
These
changes
can
significantly
enhance
the
performance
of
recommender
systems.

Summary

This
tutorial
demonstrates
how
to
build
and
optimize
co-visitation
matrices
using
RAPIDS
cuDF.
Leveraging
GPU
acceleration,
co-visitation
matrix
computation
becomes
up
to
50x
faster,
enabling
quick
iterations
and
improvements
in
recommender
systems.

For
more
details,
visit
the

NVIDIA
Technical
Blog.

Image
source:
Shutterstock