### CSE 6040 Utilities
import cse6040_devkit.utils as utils

### Global Imports
from collections import Counter, defaultdict
from math import log
from pprint import pprint

### Run Me
GAMES = utils.serialization_utils.load_serialized_object('GAMES', 'preload')

### Solution - Exercise 0  
def dictionary_key_frequency(list_of_dictionaries):
    ### BEGIN SOLUTION
    keys = [key for element in list_of_dictionaries for key in element]
    key_counts = {}
    for key in keys:
        key_counts[key] = key_counts.get(key, 0) + 1
    num_elements = len(list_of_dictionaries)
    for key in key_counts:
        key_counts[key] = round(key_counts[key] / num_elements, 6)
    return key_counts
    ### END SOLUTION


### Exercise Demo
demo_list_of_dict = [
    {'a': 1, 'b': 2},
    {'a': 3, 'b': 11, 'c': 4},
    {'a': 5, 'b': 6, 'd': 7},
    {'b': 8, 'c': 9},
]
small_demo = dictionary_key_frequency(demo_list_of_dict)
games_demo = dictionary_key_frequency(GAMES)

print('Here is the desired output for `demo_list_of_dicts`:')
pprint(small_demo)
print('-------------------------------------------------')
print('Here are the keys in the dictionary and their frequencies for the demo output:')
pprint(games_demo)

### Check Cell - Exercise 0  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'dictionary_key_frequency_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=dictionary_key_frequency
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 0  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'dictionary_key_frequency_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=dictionary_key_frequency)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=dictionary_key_frequency,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

### Run Me
GAMES = utils.serialization_utils.load_serialized_object('GAMES', 'preload')
USERS = utils.serialization_utils.load_serialized_object('USERS', 'preload')
GAME_INFO_LOOKUP_DEMO = utils.serialization_utils.load_serialized_object('GAME_INFO_LOOKUP_DEMO', 'preload')

### Solution - Exercise 1  
def organize_game_info(games_list, attribute_map, game_info_lookup=None):
    ### BEGIN SOLUTION
    if not game_info_lookup:
        game_info_lookup = {}
    else:
        game_info_lookup = game_info_lookup.copy()

    id_attr = attribute_map['id']
    name_attr = attribute_map['name']
    tags_attr = attribute_map['tags']

    for game in games_list:
        if id_attr not in game or name_attr not in game:
            continue
        game_id = game[id_attr]
        name = game[name_attr]
        tags = game.get(tags_attr, [])
        if tags:
            tags = [tag.lower().strip() for tag in tags]
        if game_id not in game_info_lookup:
            game_info_lookup[game_id] = {'name': name, 'tags': tags}

    return game_info_lookup
    ### END SOLUTION


### Exercise Demo
attr_map_0 = {'id': 'game_id', 'name': 'game_name', 'tags': 'game_tags'}
attr_map_1 = {'id': 'id', 'name': 'app_name', 'tags': 'tags'}
attr_map_2 = {'id': 'item_id', 'name': 'item_name', 'tags': 'tags'}
all_user_games = [game for user in USERS for game in user.get('items', [])]
game_info_lookup_demo = organize_game_info(GAMES, attr_map_1)
game_info_lookup_demo = organize_game_info(all_user_games, attr_map_2, game_info_lookup_demo)
subset = {key: game_info_lookup_demo[key] for key in ('10', '1002', '100400', '10090') if key in game_info_lookup_demo}


# Example 0 (A small-scale demo)
print(f'Example 0 ------------------------------------------------------------')
print('This example is just to help you understand the logic of the problem.')
games_list = [
    {'name': 'Game A', 'game_tags': ['Action', 'Adventure']}, 
    {'game_id': 2, 'game_name': 'Game B', 'game_tags': ['RPG', 'Strategy']}, 
    {'id': 3, 'game_name': 'Game C', 'game_tags': ['RPG', 'Strategy']},
    {'game_id': 4, 'game_name': 'Game D', 'tags': ['FPS', 'Action']},
    {'game_id': 4, 'game_name': 'Game D', 'game_tags': ['FPS', 'Action']},
    {'game_id': 22, 'game_name': 'Game E', 'game_tags': []}
]
pprint(organize_game_info(games_list, attr_map_0))

# Example 1 (without existing dictionary)
print('\nExample 1 ------------------------------------------------------------')
print('`organize_game_info` will be called with the following attribute map:')
pprint(attr_map_1)
print('The full results are stored in `game_info_lookup_demo`. Here are the results for a subset of the full dictionary.')
pprint(subset)

# Example 2 (with existing dictionary)
print('\nExample 2 ------------------------------------------------------------')
print('`organize_game_info` will be called with the following attribute map:')
pprint(attr_map_2)
print('The full results are stored in `game_info_lookup_demo`. Here are the results for a subset of the full dictionary.')
pprint({key: game_info_lookup_demo[key] for key in ('10', '100', '10000') if key in game_info_lookup_demo})

### Check Cell - Exercise 1  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'organize_game_info_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=organize_game_info
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 1  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'organize_game_info_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=organize_game_info)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=organize_game_info,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

### Run Me
USERS = utils.serialization_utils.load_serialized_object('USERS', 'preload')
GAME_INFO_LOOKUP_DEMO = utils.serialization_utils.load_serialized_object('GAME_INFO_LOOKUP_DEMO', 'preload')
OWNED_DEMO = utils.serialization_utils.load_serialized_object('OWNED_DEMO', 'preload')
NOT_OWNED_DEMO = utils.serialization_utils.load_serialized_object('NOT_OWNED_DEMO', 'preload')

### Solution - Exercise 2  
def split_games_by_ownership(user, game_lookup):
    ### BEGIN SOLUTION
    user_games = user.get('items', [])
    owned = {game.get('item_id') for game in user_games}
    not_owned = set(game_lookup.keys()) - owned
    return owned, not_owned
    ### END SOLUTION


### Exercise Demo
# Example 0: Simple demo
demo_user = {
    'user_id': 123,
    'items': [{'item_id': 'game_a'}, {'item_id': 'game_c'}],
}
demo_game_lookup = {
    'game_a': {'name': 'Game A'},
    'game_b': {'name': 'Game B'},
    'game_c': {'name': 'Game C'},
    'game_d': {'name': 'Game D'},
}
owned, not_owned = split_games_by_ownership(demo_user, demo_game_lookup)
print('The following output is designed to help you understand the logic of the question:')
print((owned, not_owned))  

# Example 1: Expected output
owned_demo, not_owned_demo = split_games_by_ownership(USERS[0], GAME_INFO_LOOKUP_DEMO)
print('\nThe full output is contained in `owned_demo` and `not_owned_demo`.')
print('Here are the first 15 games owned by the first user, ordered by key:')
pprint(set(sorted([game for game in     owned_demo])[:15]))
print('Here are the first 15 games not owned by the first user, ordered by key:')
pprint(set(sorted([game for game in not_owned_demo])[:15]))

### Check Cell - Exercise 2  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'split_games_by_ownership_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=split_games_by_ownership
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 2  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'split_games_by_ownership_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=split_games_by_ownership)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=split_games_by_ownership,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

### Run Me
GAME_INFO_LOOKUP_DEMO = utils.serialization_utils.load_serialized_object('GAME_INFO_LOOKUP_DEMO', 'preload')
OWNED_DEMO = utils.serialization_utils.load_serialized_object('OWNED_DEMO', 'preload')
NOT_OWNED_DEMO = utils.serialization_utils.load_serialized_object('NOT_OWNED_DEMO', 'preload')
OWNED_PROBS_DEMO = utils.serialization_utils.load_serialized_object('OWNED_PROBS_DEMO', 'preload')
NOT_OWNED_PROBS_DEMO = utils.serialization_utils.load_serialized_object('NOT_OWNED_PROBS_DEMO', 'preload')

### Solution - Exercise 3  
def get_tag_probabilities(game_IDs, game_lookup, alpha):
    ### BEGIN SOLUTION
    tags_by_game = [game_lookup[game_id]['tags'] for game_id in game_IDs]
    total_games = len(tags_by_game)

    all_tags = {
        tag
        for game_id in game_lookup
        for tag in game_lookup[game_id]['tags']
    }
    n_tags = len(all_tags)

    tag_counts = {}
    for game_tags in tags_by_game:
        for tag in game_tags:
            tag_counts[tag] = tag_counts.get(tag, 0) + 1

    bign_i = tag_counts.copy()
    for tag in tag_counts:
        tag_counts[tag] += alpha
        tag_counts[tag] /= total_games + (alpha * n_tags)

    smoothed_default = alpha / (total_games + (alpha * n_tags))
    return {
        'tag_probabilities': dict(tag_counts),
        'smoothed_default': smoothed_default,
        'bign_i': dict(bign_i),
        'bign': total_games,
        'd': n_tags,
    }
    ### END SOLUTION


### Exercise Demo
owned_probs_demo = get_tag_probabilities(OWNED_DEMO, GAME_INFO_LOOKUP_DEMO, 1)
not_owned_probs_demo = get_tag_probabilities(NOT_OWNED_DEMO, GAME_INFO_LOOKUP_DEMO, 1)
print('The full results are in `owned_probs_demo`.')
# Results for owned games
print('Here are the probabilities of a subset tags within the games owned by the user:')
pprint({tag:     owned_probs_demo['tag_probabilities'][tag] for tag in ('comedy', 'fps', 'strategy', 'puzzle')})
print(f'Your `smoothed_default` value for the games owned by the user is: {owned_probs_demo["smoothed_default"]}')
print('Here are the counts for a subset tags for `bign_i`:')
pprint({tag:     owned_probs_demo['bign_i'][tag] for tag in ('comedy', 'fps', 'strategy', 'puzzle')})
print(f'Your `bign` value for the games owned by the user is: {owned_probs_demo["bign"]}')
print(f'Your `d` value for the games owned by the user is: {owned_probs_demo["d"]}')
# Results for non-owned games
print('------------------------------------------------------------------')
print('Here are the probabilities of a subset tags within the games not owned by the user:')
pprint({tag: not_owned_probs_demo['tag_probabilities'][tag] for tag in ('comedy', 'fps', 'strategy', 'puzzle')})
print(f'Your `smoothed_default` value for the games not owned by the user is: {not_owned_probs_demo["smoothed_default"]}')
print('Here are the counts for a subset tags for `bign_i`:')
pprint({tag:     not_owned_probs_demo['bign_i'][tag] for tag in ('comedy', 'fps', 'strategy', 'puzzle')})
print(f'Your `bign` value for the games not owned by the user is: {not_owned_probs_demo["bign"]}')
print(f'Your `d` value for the games not owned by the user is: {not_owned_probs_demo["d"]}')

### Check Cell - Exercise 3  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'get_tag_probabilities_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=get_tag_probabilities
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 3  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'get_tag_probabilities_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=get_tag_probabilities)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=get_tag_probabilities,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

### Run Me
OWNED_PROBS_DEMO = utils.serialization_utils.load_serialized_object('OWNED_PROBS_DEMO', 'preload')
NOT_OWNED_PROBS_DEMO = utils.serialization_utils.load_serialized_object('NOT_OWNED_PROBS_DEMO', 'preload')
OWNED_PROBS_DEFAULT_DEMO = utils.serialization_utils.load_serialized_object('OWNED_PROBS_DEFAULT_DEMO', 'preload')
NOT_OWNED_PROBS_DEFAULT_DEMO = utils.serialization_utils.load_serialized_object('NOT_OWNED_PROBS_DEFAULT_DEMO', 'preload')

### Solution - Exercise 4  
def tag_probability_with_default(tag_probabilities, smoothed_default):
    ### BEGIN SOLUTION
    return defaultdict(lambda: smoothed_default, tag_probabilities)
    ### END SOLUTION


### Exercise Demo
owned_probs_default_demo = tag_probability_with_default(
    **{key: value for key, value in OWNED_PROBS_DEMO.items() if key in ['tag_probabilities', 'smoothed_default']}
)
not_owned_probs_default_demo = tag_probability_with_default(
    **{key: value for key, value in NOT_OWNED_PROBS_DEMO.items() if key in ['tag_probabilities', 'smoothed_default']}
)
try:
    assert "A SUPER SPECIAL MYSTERY KEY" not in owned_probs_default_demo
except:
    print('Did you insert the random key into the dictionary before we checked for it?')
try:
    assert isinstance(owned_probs_default_demo, defaultdict), "Are you SURE you're returning a default dictionary?"
except:
    print('Are you sure your dictionary is a defaultdict?')
print(f'Default value of one of our dictionaries: {OWNED_PROBS_DEMO["smoothed_default"]}')
print(f'Value associated with absent key:         {owned_probs_default_demo["A SUPER SPECIAL MYSTERY KEY"]}')

### Check Cell - Exercise 4  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'tag_probability_with_default_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=tag_probability_with_default
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 4  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'tag_probability_with_default_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=tag_probability_with_default)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=tag_probability_with_default,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

### Run Me
OWNED_PROBS_DEFAULT_DEMO = utils.serialization_utils.load_serialized_object('OWNED_PROBS_DEFAULT_DEMO', 'preload')

### Solution - Exercise 5  
def bernoulli_conditional(x_tag, present, prob_lookup):
    ### BEGIN SOLUTION
    a_term = prob_lookup[x_tag] * present
    b_term = (1 - prob_lookup[x_tag]) * (1 - present)
    return a_term + b_term
    ### END SOLUTION


### Exercise Demo
# Example 0: Simple Case
prob_lookups = {"category_A": 0.7, "category_B": 0.3}

prob_given_A_present      = bernoulli_conditional("category_A", 1, prob_lookups)
prob_given_A_not_present  = bernoulli_conditional("category_A", 0, prob_lookups)

prob_given_B_present      = bernoulli_conditional("category_B", 1, prob_lookups)
prob_given_B_not_present  = bernoulli_conditional("category_B", 0, prob_lookups)
print(f"Category A has a {prob_given_A_present:.3} probability of being present and a {prob_given_A_not_present:.3} probability of not being present.")
print(f"Category B has a {prob_given_B_present:.3} probability of being present and a {prob_given_B_not_present:.3} probability of not being present.")
print("------------------------------------------------------------")

# Example 1: Demo Output
bernoulli_conditional_prob_demo = bernoulli_conditional('strategy', 0, OWNED_PROBS_DEFAULT_DEMO)
print(f'Your conditional function produced the following probability when the "strategy" tag is absent:\n{bernoulli_conditional_prob_demo}')
bernoulli_conditional_prob_demo = bernoulli_conditional('strategy', 1, OWNED_PROBS_DEFAULT_DEMO)
print(f'Your conditional function produced the following probability when the "strategy" tag is present:\n{bernoulli_conditional_prob_demo}')

### Check Cell - Exercise 5  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'bernoulli_conditional_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=bernoulli_conditional
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 5  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'bernoulli_conditional_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=bernoulli_conditional)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=bernoulli_conditional,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

### Run Me
GAME_INFO_LOOKUP_DEMO = utils.serialization_utils.load_serialized_object('GAME_INFO_LOOKUP_DEMO', 'preload')
OWNED_PROBS_DEFAULT_DEMO = utils.serialization_utils.load_serialized_object('OWNED_PROBS_DEFAULT_DEMO', 'preload')
NOT_OWNED_PROBS_DEFAULT_DEMO = utils.serialization_utils.load_serialized_object('NOT_OWNED_PROBS_DEFAULT_DEMO', 'preload')
ALL_TAGS = utils.serialization_utils.load_serialized_object('ALL_TAGS', 'preload')

### Solution - Exercise 6  
def bernoulli_bayes(b_cond, game, owned_probs, not_owned_probs, all_tags):
    ### BEGIN SOLUTION
    tags = set(game['tags'])
    if not tags:
        return 0

    owned_prob = 0
    not_owned_prob = 0
    for tag in all_tags:
        present = 1 if tag in tags else 0
        owned_prob += log(b_cond(tag, present, owned_probs))
        not_owned_prob += log(b_cond(tag, present, not_owned_probs))
    return owned_prob - not_owned_prob
    ### END SOLUTION


### Exercise Demo
game_items = GAME_INFO_LOOKUP_DEMO.values()
scored = sorted(
    (
        (
            game['name'],
            bernoulli_bayes(
                bernoulli_conditional,
                game,
                OWNED_PROBS_DEFAULT_DEMO,
                NOT_OWNED_PROBS_DEFAULT_DEMO,
                ALL_TAGS,
            ),
        )
        for game in game_items
    ),
    key=lambda item: item[1],
    reverse=True,
)[:10]
print('Here are the 10 highest rated games for our user, based on content filtering:')
print([name for name, _ in scored])

### Check Cell - Exercise 6  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'bernoulli_bayes_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=bernoulli_bayes
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 6  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'bernoulli_bayes_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=bernoulli_bayes)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=bernoulli_bayes,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

### Solution - Exercise 7  
def cosine_similarity(game_set_A, game_set_B, alpha, feature_size):
    # Nothing to implement here! The solution is already provided.
    a_mag = len(game_set_A) ** 0.5
    b_mag = len(game_set_B) ** 0.5
    a_dot_b = len(game_set_A & game_set_B)

    numerator = a_dot_b + alpha
    denominator = (a_mag * b_mag) + (alpha * feature_size)
    return numerator / denominator


### Exercise Demo
demo_output = cosine_similarity({'a', 'b', 'c'}, {'b', 'c', 'd'}, 0.01, 10)

print('Our two chosen users have a cosine similarity of:')
print(demo_output)

### Check Cell - Exercise 7  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'cosine_similarity_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=cosine_similarity
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 7  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'cosine_similarity_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=cosine_similarity)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=cosine_similarity,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

### Run Me
USERS = utils.serialization_utils.load_serialized_object('USERS', 'preload')

### Solution - Exercise 8  
def create_collab_scores(user_key, ID_to_games, sim_func):
    ### BEGIN SOLUTION
    game_set_a = ID_to_games[user_key]
    cosine_similarities = {
        user_id: sim_func(game_set_a, ID_to_games[user_id])
        for user_id in ID_to_games
    }

    game_scores = defaultdict(int)
    for user_id in ID_to_games:
        if user_id == user_key:
            continue
        for game in ID_to_games[user_id]:
            game_scores[game] += cosine_similarities[user_id]

    return dict(game_scores)
    ### END SOLUTION


### Exercise Demo
user_id_to_games = {
    user.get('user_id', idx): {
        item.get('item_id', None)
        for item in user.get('items', [])
    }
    for idx, user in enumerate(USERS)
}
demo_user_key = next(iter(user_id_to_games))
sim_func = lambda game_set_a, game_set_b: cosine_similarity(game_set_a, game_set_b, alpha=0.01, feature_size=32000)
scores = create_collab_scores(demo_user_key, user_id_to_games, sim_func)
demo_output = sorted(scores.items(), key=lambda item: item[1], reverse=True)[:15]

print('Here are the top 15 recommended games for our user, based on collaborative filtering:')
print(demo_output)

### Check Cell - Exercise 8  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Check
test_name = 'create_collab_scores_sampler_0'
input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=create_collab_scores
)
if err:
    raise err


print('Check passed! Please submit.')

### BEGIN HIDDEN TESTS
### Test Cell - Exercise 8  
from cse6040_devkit.grading.test_cell import execute_test

# Execute Test
test_name = 'create_collab_scores_sampler_0'

input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'CC-Ls82xJuR6yYMripT10xuAAnKahZ1JGMQGZ-JkdNo=',
    func=create_collab_scores)
if err:
    raise err


input_vars, original_input_vars, returned_output_vars, true_output_vars, err = \
execute_test(
    test_name=test_name,
    key=b'6tdXG3_NbusnazU7LX8tibRUICE3rPCl3e_DpGj_BC0=',
    func=create_collab_scores,
    hidden=True)
if err:
    raise err

print('Passed! Please submit.')
### END HIDDEN TESTS

def hybrid_recommendations(content_recs: list, collaborative_recs: list, alpha: float) -> list:
    content_weights       = [(1/rank) * alpha       for rank in range(1, len(content_recs) + 1)]
    collaborative_weights = [(1/rank) * (1 - alpha) for rank in range(1, len(collaborative_recs) + 1)]

    recommendation_sort_weights = defaultdict(int)
    for rec, weight in zip(content_recs, content_weights):
        recommendation_sort_weights[rec] += weight
    for rec, weight in zip(collaborative_recs, collaborative_weights):
        recommendation_sort_weights[rec] += weight

    sorted_recs = sorted(recommendation_sort_weights.items(), key=lambda x: x[1], reverse=True)
    return sorted_recs

Spring 2025 Midterm 1: Game On!¶

The Problem: Creating a Recommender System¶

Part 0: Data Exploration and Cleaning¶

Exercise 0: dictionary_key_frequency (2 points)¶

Exercise 1: organize_game_info (3 points)¶

Part 1: Content Filtering¶

Exercise 2: split_games_by_ownership (2 points)¶

Exercise 3: get_tag_probabilities (3 points)¶

Exercise 4: tag_probability_with_default (1 points)¶

Exercise 5: bernoulli_conditional (2 points)¶

Aside: What IS a Naive Bayes Model?¶

Exercise 6: bernoulli_bayes (2 points)¶

Part 2: Collaborative Filtering¶

Exercise 7: cosine_similarity (1 points)¶

Exercise 8: create_collab_scores (2 points)¶

Fin¶