app.py

import gradio as gr
import pandas as pd
from fastai.collab import *
from fastai.tabular.all import *
from fastai.learner import load_learner

anime = pd.read_csv("animes_name.csv")
users = pd.read_csv("users.csv")
users = users["user_id"].unique()
options = list(map(str, users.tolist()))


class CollabNN(Module):
    def __init__(self, user_sz, item_sz, y_range=(0, 5.5), n_act=100):
        self.user_factors = Embedding(*user_sz)
        self.item_factors = Embedding(*item_sz)
        self.layers = nn.Sequential(
            nn.Linear(user_sz[1] + item_sz[1], n_act), nn.ReLU(), nn.Linear(n_act, 1)
        )
        self.y_range = y_range

    def forward(self, x):
        embs = self.user_factors(x[:, 0]), self.item_factors(x[:, 1])
        x = self.layers(torch.cat(embs, dim=1))
        return sigmoid_range(x, *self.y_range)


class DotProductBias(Module):
    def __init__(self, n_users, n_anime, n_factors, y_range=(0, 5.5)):
        self.user_factors = create_params([n_users, n_factors])
        self.user_bias = create_params([n_users])
        self.book_factors = create_params([n_anime, n_factors])
        self.book_bias = create_params([n_anime])
        self.y_range = y_range

    def forward(self, x):
        users = self.user_factors[x[:, 0]]
        anime = self.book_factors[x[:, 1]]
        res = (users * anime).sum(dim=1)
        res += self.user_bias[x[:, 0]] + self.book_bias[x[:, 1]]
        return sigmoid_range(res, *self.y_range)


learn = load_learner("deep_model.pkl", cpu=True)


def get_user_preds(user_id):
    rows = []
    anime_name = list(anime.drop_duplicates(subset="name", keep="first").book)
    for i in range(len(anime_name)):
        rows.append(dict({"user": user_id, "name": anime_name[i]}))
    data = pd.DataFrame(rows)
    dl = learn.dls.test_dl(data)
    preds, y = learn.get_preds(dl=dl)
    preds_df = pd.DataFrame(
        {"anime_name": anime_name, "prediction": preds.numpy().flatten()}
    ).sort_values("prediction", ascending=False)

    best_5_arr = preds_df[:5]

    formatted_parts = []

    # Loop sobre as linhas ordenadas
    for i, row in enumerate(best_5_arr.itertuples(), 1):
        anime_name = getattr(row, "anime_name")
        prediction = getattr(row, "prediction")

        # Adiciona a parte formatada à lista
        formatted_parts.append(f"{i}. {anime_name} - Prediction: {prediction}")

    # Combina as partes formatadas em uma única string, separadas por vírgula e espaço
    result_string = ", ".join(formatted_parts)

    return result_string


iface = gr.Interface(
    fn=get_user_preds,
    title="Anime Recomendation",
    allow_flagging="never",
    inputs=[
        gr.Dropdown(
            choices=options,
            label="user_id",
            info="Escolha o usuário para o modelo fazer as melhores recomendações",
        )
    ],
    outputs="text",
)
iface.launch()