Code accompanying the blog post "Fetching Better Beer Recommendations with Collie"

00_README.md

Code for Fetching Better Beer Recommendations with Collie Blog Post

This GitHub Gist is intended to accompany the blog posts below:

Part 1: https://medium.com/shoprunner/fetching-better-beer-recommendations-with-collie-part-1-18c73ab30fbd Part 2: https://medium.com/shoprunner/fetching-better-beer-recommendations-with-collie-part-2-27930a421459 Part 3: https://medium.com/shoprunner/fetching-better-beer-recommendations-with-collie-part-3-6aaae9bad169

Get the Data

Data for this blog post can be found here, specifically in the Beeradvocate.txt.gz and Ratebeer.txt.gz files. In total, these files should be 3.29 GB.

Run this Code

It is highly recommended you run this code on the GPU for the fastest execution time. If you have extra time and patience, all code below this will still work on the CPU.

I ran the code below using collie_recs==0.1.3 in the pytorch/pytorch:1.8.1-cuda11.1-cudnn8-devel base Docker image on a p3.2xlarge EC2 instance that is equipped with a single Tesla V100, 16GB GPU.

01_read_in_beer_data.py

from itertools import groupby, chain


def chunk_text_data_generator(filepath: str):
    with open(filepath, encoding='utf8', errors='ignore') as f:
        # luckily, both files start with the same pattern of ``beer/name``
        grps = groupby(f, key=lambda x: x.startswith('beer/name'))
        for k, v in grps:
            if k:
                try:
                    # remove the final ``\n`` line in each chunk
                    chunk = list(chain([next(v)], (next(grps)[1])))[:-1]

                    # convert the text chunk to a dictionary
                    chunk_dict = {}
                    for line in chunk:
                        formatted_line = line.strip()
                        key, value = formatted_line.split(':', maxsplit=1)
                        key = key.replace('/', '_')

                        chunk_dict[key] = value

                    yield chunk_dict
                except StopIteration:
                    return
                

beeradvocates_filepath = '../data/Beeradvocate.txt'
ratebeer_filepath = '../data/Ratebeer.txt'

beeradvocates_dicts = [x for x in chunk_text_data_generator(filepath=beeradvocates_filepath)]
ratebeer_dicts = [x for x in chunk_text_data_generator(filepath=ratebeer_filepath)]

02_format_beer_data.py

import pandas as pd


# list of dicts -> pandas DataFrame
beeradvocates_df = pd.DataFrame(data=beeradvocates_dicts)
ratebeer_df = pd.DataFrame(data=ratebeer_dicts)

# adjust ratings in ``ratebeer_df`` to match that of ``beeradvocates_df``
review_number_columns = ['review_appearance',
                         'review_aroma',
                         'review_palate',
                         'review_taste',
                         'review_overall']    

for col in review_number_columns:
    # set columns to float, which involves removing the denominator from ``ratebeer_df``
    beeradvocates_df[col] = beeradvocates_df[col].astype(float)
    ratebeer_df[col] = ratebeer_df[col].str.split('/').str[0].astype(float)

# turn a 10-point scale to a 5 point one
ratebeer_df['review_aroma'] /= 2
ratebeer_df['review_taste'] /= 2
ratebeer_df['review_overall'] /= 4

# combine our two datasets into one
beer_df = pd.concat([beeradvocates_df, ratebeer_df], ignore_index=True)

# convert string columns to integer IDs
beer_df['unique_beer_id'] = beer_df['beer_name'].astype('category').cat.codes
beer_df['unique_reviewer_id'] = beer_df['review_profileName'].astype('category').cat.codes

03_prep_data_for_collie.py

from collie_recs.utils import convert_to_implicit, remove_users_with_fewer_than_n_interactions


implicit_beer_df = convert_to_implicit(explicit_df=beer_df,
                                       min_rating_to_keep=3,
                                       user_col='unique_reviewer_id',
                                       item_col='unique_beer_id',
                                       ratings_col='review_overall')
implicit_beer_df = remove_users_with_fewer_than_n_interactions(df=implicit_beer_df,
                                                               min_num_of_interactions=2,
                                                               user_col='unique_reviewer_id')

print(
    f'Reduced shape from {len(beer_df)} to {len(implicit_beer_df)},'
    f' or {round((len(implicit_beer_df) / len(beer_df) * 100), 3)}% the size.'
)

04_create_interactions.py

from collie_recs.interactions import Interactions


beer_interactions = Interactions(users=implicit_beer_df['unique_reviewer_id'],
                                 items=implicit_beer_df['unique_beer_id'],
                                 num_negative_samples=15,
                                 allow_missing_ids=True,
                                 seed=42)

05_split_beer_data.py

from collie_recs.cross_validation import stratified_split


train, val = stratified_split(interactions=beer_interactions, test_p=0.1, seed=42)

06_train_a_normal_model.py

from collie_recs.model import CollieTrainer, MatrixFactorizationModel
from pytorch_lightning.callbacks.early_stopping import EarlyStopping


train.num_negative_samples = 1
val.num_negative_samples = 1

model = MatrixFactorizationModel(train=train,
                                 val=val,
                                 embedding_dim=30,
                                 lr=1e-3,
                                 optimizer='adam',
                                 bias_optimizer=None,
                                 loss='hinge')
trainer = CollieTrainer(model=model,
                        max_epochs=30,
                        deterministic=True,
                        benchmark=True,
                        callbacks=[EarlyStopping(monitor='val_loss_epoch')])
trainer.fit(model)

07_evaluate_the_model.py

from collie_recs.metrics import evaluate_in_batches, mapk


mapk_score = evaluate_in_batches(metric_list=[mapk], test_interactions=val, model=model, k=10)

print(f'MAP@10: {mapk_score}')

08_look_at_a_users_recommendations.py

# sample a random member
random_user_id = implicit_beer_df['unique_reviewer_id'].sample(1).item()

print(f'Random user ID selected: {random_user_id}')

# get beers that user has previously interacted with
beers_user_interacted_with = (
    implicit_beer_df[implicit_beer_df['unique_reviewer_id'] == random_user_id]
    .drop_duplicates('unique_beer_id')
)

print(beers_user_interacted_with)

# finally (the actual work), get the top 5 recommended beers for the user...
recommended_beer_ids = model.get_item_predictions(user_id=random_user_id, unseen_items_only=True).index[:5]

# ... and display those beers in our DataFrame
implicit_beer_df[implicit_beer_df['unique_beer_id'].isin(recommended_beer_ids)].drop_duplicates('unique_beer_id')

09_neucf_model.py

from collie_recs.model import NeuralCollaborativeFiltering


neucf_model = NeuralCollaborativeFiltering(train=train,
                                           val=val,
                                           embedding_dim=8,
                                           num_layers=3,
                                           final_layer='sigmoid',
                                           dropout_p=0.2,
                                           lr=1e-3,
                                           optimizer='adam',
                                           loss='hinge')
neucf_trainer = CollieTrainer(model=neucf_model,
                              max_epochs=30,
                              deterministic=True,
                              benchmark=True,
                              callbacks=[EarlyStopping(monitor='val_loss_epoch')])
neucf_trainer.fit(neucf_model)

10_train_adaptive_model.py

train.num_negative_samples = 15
val.num_negative_samples = 15

model = MatrixFactorizationModel(train=train,
                                 val=val,
                                 embedding_dim=30,
                                 lr=1e-3,
                                 optimizer='adam',
                                 bias_optimizer=None,
                                 loss='hinge')
trainer = CollieTrainer(model=model,
                        max_epochs=30,
                        deterministic=True,
                        benchmark=True,
                        callbacks=[EarlyStopping(monitor='val_loss_epoch')])
trainer.fit(model)

11_use_multiple_optimizers.py

model = MatrixFactorizationModel(train=train,
                                 val=val,
                                 embedding_dim=30,
                                 lr=1e-3,
                                 bias_lr=1e-2,
                                 optimizer='adam',
                                 bias_optimizer='sgd',
                                 loss='hinge')
trainer = CollieTrainer(model=model,
                        max_epochs=30,
                        deterministic=True,
                        benchmark=True,
                        callbacks=[EarlyStopping(monitor='val_loss_epoch')])
trainer.fit(model)

12_metadata_model.py

from collie_recs.model import HybridPretrainedModel


# dummify our beer styles
beer_item_dummies = pd.get_dummies(beer_item_df['beer_style'], prefix='beer_style')

# we will apply two linear layers to the metadata with ``metadata_layers_dims`` and
# two linear layers to the combined embeddings + metadata data with ``combined_layers_dims``
hybrid_model = HybridPretrainedModel(train=train,
                                     val=val,
                                     item_metadata=beer_item_dummies,
                                     trained_model=model,
                                     metadata_layers_dims=[256, 16],
                                     combined_layers_dims=[32, 8],
                                     lr=1e-3,
                                     optimizer='adam',
                                     loss='hinge')
trainer = CollieTrainer(model=hybrid_model,
                        max_epochs=30,
                        deterministic=True,
                        benchmark=True,
                        callbacks=[EarlyStopping(monitor='val_loss_epoch')])

trainer.fit(hybrid_model)

# now we can unfreeze our embeddings and fine-tune
hybrid_model_unfrozen = HybridPretrainedModel(train=train,
                                              val=val,
                                              item_metadata=beer_item_dummies,
                                              trained_model=model,
                                              metadata_layers_dims=[256, 16],
                                              combined_layers_dims=[32, 8],
                                              lr=1e-5,
                                              optimizer='adam',
                                              loss='hinge')
hybrid_model_unfrozen.load_from_hybrid_model(hybrid_model)
hybrid_model_unfrozen.unfreeze_embeddings()

trainer_unfrozen = CollieTrainer(model=hybrid_model,
                                 max_epochs=30,
                                 deterministic=True,
                                 benchmark=True,
                                 callbacks=[EarlyStopping(monitor='val_loss_epoch')])

trainer_unfrozen.fit(hybrid_model_unfrozen)

13_model_with_metadata_loss.py

import torch


# create a DataFrame with each item appearing only once, sorted by item ID
beer_item_df = (
    beer_df
    .drop_duplicates(subset=['unique_beer_id'], ignore_index=True)
    .sort_values(by='unique_beer_id', ignore_index=True)
)

# create an integer ID for ``beer_style``
beer_item_df['beer_style'] = beer_item_df['beer_style'].str.strip()
beer_item_df['beer_style_id'] = beer_item_df['beer_style'].astype('category').cat.codes

# convert the ``pd.Series`` to a ``torch.tensor``
beer_styles_tensor = torch.tensor(beer_item_df['beer_style_id'])

model = MatrixFactorizationModel(train=train,
                                 val=val,
                                 embedding_dim=30,
                                 lr=1e-3,
                                 bias_lr=1e-2,
                                 optimizer='adam',
                                 bias_optimizer='sgd',
                                 loss='hinge',
                                 metadata_for_loss={'beer_style': beer_styles_tensor},
                                 metadata_for_loss_weights={'beer_style': 0.15})
trainer = CollieTrainer(model=model,
                        max_epochs=30,
                        deterministic=True,
                        benchmark=True,
                        callbacks=[EarlyStopping(monitor='val_loss_epoch')])
trainer.fit(model)

14_get_beer_recommendations_from_item.py

stella_artois_beer_id = 136889

# get the top 5 most similar beers
similar_beer_ids = model.item_item_similarity(stella_artois_beer_id).index[1:6]
beer_item_df[beer_item_df['unique_beer_id'].isin(similar_beer_ids)]

15_fine_tune_model_with_new_data.py

from collie_recs.utils import _create_sparse_ratings_matrix_helper
import numpy as np


# Stella Artois, Corona Light, and PBR (of course)
beers_ids_I_like = [136889, 8200, 108327]

# put these items into a very small ``Interactions`` object
new_mat = _create_sparse_ratings_matrix_helper(users=np.zeros_like(beers_ids_I_like),
                                               items=beers_ids_I_like,
                                               num_users=train.num_users,
                                               num_items=train.num_items)
new_interactions = Interactions(mat=new_mat,
                                num_negative_samples=5,
                                allow_missing_ids=True,
                                check_num_negative_samples_is_valid=False,
                                seed=42)

fine_tune_model = MatrixFactorizationModel(train=new_interactions,
                                           embedding_dim=model.hparams.embedding_dim,
                                           lr=1e-2,
                                           bias_lr=1e-1)

# copy over the previously-trained model's embeddings...
fine_tune_model.item_embeddings.weight.data.copy_(model.item_embeddings.weight.data)
fine_tune_model.item_biases.weight.data.copy_(model.item_biases.weight.data)
# ... and freeze them so we keep that model's item information intact
fine_tune_model.item_embeddings.weight.requires_grad = False
fine_tune_model.item_biases.weight.requires_grad = False

fine_tune_trainer = CollieTrainer(model=model,
                                  max_epochs=30,
                                  deterministic=True,
                                  benchmark=True,
                                  callbacks=[EarlyStopping(monitor='train_loss_epoch')])
fine_tune_trainer.fit(fine_tune_model)

16_get_beer_recommendations_from_user.py

# get the top 5 recommended beers for me
recommended_beer_ids = fine_tune_model.get_item_predictions(user_id=0, unseen_items_only=True).index[:5]
beer_item_df[beer_item_df['unique_beer_id'].isin(recommended_beer_ids)]

17_get_beer_recommendations_mass_appeal.py

# get the top 5 beers with the highest appeal
mass_appeal_beer_ids = model.item_biases.weight.data.flatten().argsort(descending=True).cpu().numpy()[:5]
beer_item_df[beer_item_df['unique_beer_id'].isin(mass_appeal_beer_ids)]