Rekomendator wydarzeń SF za pomocą LLM

Feb 26 2023
Duże modele językowe mogą być używane na każdym etapie procesu tworzenia systemu rekomendacji. W tym projekcie wykorzystałem modele OpenAI do syntezy, formatowania, przechowywania i osadzania danych w celu dostosowania rekomendacji dla siebie.

Duże modele językowe mogą być używane na każdym etapie procesu tworzenia systemu rekomendacji. W tym projekcie wykorzystałem modele OpenAI do syntezy, formatowania, przechowywania i osadzania danych w celu dostosowania rekomendacji dla siebie.

W San Francisco odbywa się mnóstwo wydarzeń, ale niestety mieszkańcy muszą się bardzo starać, aby znaleźć wydarzenia co tydzień. Większość wydarzeń można znaleźć na stronach internetowych miejsc lub na stronach z bezpłatnymi ogłoszeniami o wydarzeniach. Jednak aby większość witryn mogła otrzymywać spersonalizowane rekomendacje, musisz zapłacić. Jako rezydent SF chciałem zmierzyć się z problemem stworzenia własnego systemu rekomendacji wydarzeń bez konieczności polegania na płatnych serwisach lub przeszukiwania wielu portali eventowych i stron na instagramie.

Zebrałem informacje o wydarzeniach z SF Fun Cheap, Eventbrite i 19hz (strona poświęcona muzyce SF poświęconej EDM i techno). Dodałem szybkie demo interfejsu frontendowego, które zrobiłem dla siebie.

Zrozummy, co dzieje się w zapleczu tego prostego interfejsu, aby lepiej zrozumieć, w jaki sposób te zdarzenia są dopasowywane do moich preferencji i dynamicznie aktualizowane.

Przetwarzanie danych za pomocą LLM

Pierwszym wyzwaniem związanym z tworzeniem tej aplikacji jest analizowanie zeskrobanych danych w znormalizowanym formacie. LLM może być bardzo pomocny nie tylko w formatowaniu danych, ale także w tworzeniu większej liczby funkcji dla modelu. Na przykład w każdym ze skrobaków zdarzeń użyłem GPT-3 do przetworzenia danych do formatu JSON.

def generate_prompt(event):
    prompt = """Extract information from the event below and store it into a 
JSON with the following structure 
{venue: venue_name, date: date_and_time, age: age_requirement, price: price, location: address}""" + 
' and enclose each key and value in the JSON structure with double quotes.' + 
'\n' + "Event: " + event
    return prompt


sf_events = pd.DataFrame()

for link,headline in zip(hrefs,headlines):
  headline = headline.strip()
  if link is not None and len(headline) > 0: 
    response = requests.get(link)
    html = response.content
    soup = BeautifulSoup(html, 'html.parser')
    p_tags = soup.find_all('p')
    event_name = soup.find('h1')
    event_name = event_name.get_text()
    text = ''
    div = soup.find('div', {'id': 'stats'})
    text += div.get_text()
    
    response = openai.Completion.create(
    model="text-davinci-003",
    prompt=generate_prompt(text),
    temperature=0.0,
    max_tokens = 200,
    )

    response_text = response['choices'][0]['text'].strip()
    response_dict = json.loads(response_text)

    sf_events = sf_events.append(response_dict, ignore_index=True)

def find_venue_type(venue):
    prompt = f'Provide a short description of the following venue in SF? 
Utilize the venues website or online search to find the answer.' + '\n' + 
'Venue: ' + venue
    return prompt

venue_description = {}
for index, row in sf_events.iterrows():
    if row['venue'] not in venue_description:
        response = openai.Completion.create(
            model="text-curie-001",
            prompt=find_venue_type(row['venue']),
            temperature=0.3,
            max_tokens = 100,
        )
        response_text = response['choices'][0]['text'].strip()
        venue_description[row['venue']] = response_text
        sf_events.loc[index, 'venue_description'] = response_text

    else:
        sf_events.loc[index, 'venue_description'] = venue_description[row['venue']]

Ponieważ mam do czynienia tylko z jednym użytkownikiem, system rekomendacji jest przetwarzany poprzez wyszukiwanie podobieństw. Aby przeprowadzić wyszukiwanie podobieństw, zdarzenie i dane użytkownika muszą zostać przekonwertowane na format numeryczny, czyli osadzenie. Dla każdego ze źródeł danych wykonuję następujący proces osadzania.

import pandas as pd
import tiktoken
from openai.embeddings_utils import get_embedding
import os
import openai

openai.apikey = os.getenv("OPENAI_API_KEY")
# embedding model parameters
embedding_model = "text-embedding-ada-002"
embedding_encoding = "cl100k_base"  # this the encoding for text-embedding-ada-002
max_tokens = 5000  # the maximum for text-embedding-ada-002 is 8191

fc_df_embeddings = sf_events.applymap(str)
encoding = tiktoken.get_encoding(embedding_encoding)
sf_events["combined"] = (
    "Venue: " + fc_df_embeddings.venue.str.strip() + "; Venue Description: " + fc_df_embeddings.venue_description.str.strip() + 
    "; Event: " + fc_df_embeddings.event_name.str.strip() +  "; Event Description: " + fc_df_embeddings.event_description.str.strip() + 
    "; Price: " + fc_df_embeddings.price.str.strip() + "; Neighborhood: " + fc_df_embeddings.neighborhood.str.strip()
)

sf_events["n_tokens"] = sf_events.combined.apply(lambda x: len(encoding.encode(x)))
sf_events["embedding"] = sf_events.combined.apply(lambda x: get_embedding(x, engine=embedding_model))

event_embeddings = sf_events.embedding.apply(eval).apply(np.array)
event_embeddings = np.array(list(event_embeddings))
# User Embeddings

interests = ['Live music', 'DJ performances', 'Dancing', 'Karaoke', 'Comedy shows', 'Trivia nights', 'Art exhibits', 'Film screenings', 'Wine tasting', 'Craft beer tasting', 'Mixology classes', 'Food events', 'Sports viewing parties', 'Networking events', 'Tech events']
venue_types = ['Speakeasy Bar', 'Dive Bar', 'Nightclubs', 'Music Venue', 'Comedy Club', 'Theaters', 'Art Gallery', 'Film theaters', 'Wineries', 'Breweries', 'Cocktail Bars', 'Sports Bars', 'Restaurants with Live Music', 'Rooftop bars', 'Convention Centers']
price_range_pref = ['free', '$10-$20', '$20-$50', '$50-$100', 'over $100']
time_of_day_pref = ['daytime', 'evening', 'night']
neighborhoods_of_interest = ['Financial District', 'Nob Hill', 'Pacific Heights', 'Russian Hill', 'North Beach', 'The Mission', 'Castro', 'Haight-Ashbury', 'SoMa', 'Marina']

user_interests = ['Live music', 'DJ performances', 'Comedy shows', 'Food events', 'Networking events', 'Tech events']
user_venues = ['Speakeasy Bar', 'Dive Bar','Music Venue', 'Comedy Club', 'Cocktail Bars', 'Theaters']
user_prices = ['free', '$10-$20', '$20-$50']
user_time = ['evening', 'night']
user_neighborhoods = ['Nob Hill', 'Pacific Heights', 'Russian Hill', 'North Beach', 'The Mission', 'Castro', 'Haight-Ashbury']
encoding = tiktoken.get_encoding(embedding_encoding)
combined = ("Event Preferences: " + str(user_interests) +  "; Venue Preferences: " + str(user_venues) + 
    "; Price Range Preferences: " + str(user_prices) +  "; Time of Day Preferences: " + str(user_time) + 
     "; Neighborhoods of Interest: " + str(user_neighborhoods))

user_embedding = get_embedding(combined, engine=embedding_model)
user_embedding = np.array(user_embedding)

Po połączeniu preferencji użytkownika i osadzeniu ich wraz z każdym wydarzeniem ze zeskrobanych stron wydarzeń. Następnie mogę zastosować formułę podobieństwa cosinusów do osadzeń. Podobieństwo cosinusowe mierzy podobieństwo między dwoma wektorami przy użyciu następującego wzoru:

cosinus_podobieństwo(a, b) = (a · b) / (||a|| ||b||)

Wyniki podobieństwa mieszczą się w przedziale [-1, 1], gdzie 1 oznacza, że ​​wektory są takie same. Obliczyłem macierz podobieństw za pomocą następującej funkcji, a następnie zapisałem dane zdarzeń wraz z podobieństwem i odległością od zdarzenia do bazy danych MySQL.

Co 2 tygodnie uruchamiam skrypt automatyzacji, aby zeskrobać dane i odtworzyć tabelę zdarzeń w mojej bazie danych.

from sklearn.metrics.pairwise import cosine_similarity
similarity_matrix = cosine_similarity(user_embedding.reshape(1, -1), event_embeddings)


conn = pymysql.connect(host='localhost', user='root', password=mysql_pass, db='mysfevents')
cursor = conn.cursor()

create_table_query = """CREATE TABLE events (
                        id INT AUTO_INCREMENT PRIMARY KEY,
                        venue VARCHAR(150),
                        event VARCHAR(150),
                        date VARCHAR(150),
                        age VARCHAR(150),
                        price VARCHAR(150),
                        location VARCHAR(150),
                        venue_desc VARCHAR(3000),
                        event_desc VARCHAR(5000),
                        neighborhood VARCHAR(200),
                        distance FLOAT,
                        similarity FLOAT
                        );"""


cursor.execute(create_table_query)
conn.commit()

sql_query = "INSERT INTO events (venue, event, date, age, price, location, venue_desc, event_desc, neighborhood, distance, similarity) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"

data = database_df.to_records(index=False).tolist()


cursor.close()
conn.close()


from math import radians, sin, cos, sqrt, atan2
from shapely.geometry import Point
from shapely.wkt import loads


my_loc = Point(37.7652844,-122.4329059)


def distance_in_miles(loc1, loc2):

    loc2 = loads(loc2)
    """Calculate the distance in miles between two geolocation points using the Haversine formula."""
    # Convert coordinates to radians
    lon1, lat1 = radians(loc1.x), radians(loc1.y)
    lon2, lat2 = radians(loc2.x), radians(loc2.y)


    # Haversine formula
    dlon = lon2 - lon1
    dlat = lat2 - lat1
    a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
    c = 2 * atan2(sqrt(a), sqrt(1 - a))
    distance_miles = 3963.0 * c # Radius of Earth in miles

    return float(round(distance_miles,3))

df['distance_miles'] = df.apply(lambda row: distance_in_miles(my_loc, row['geolocation']), axis=1)

Po załadowaniu danych do bazy danych stworzyłem framework frontendowy i backendowy przy użyciu Node.js i Javascript, aby wyświetlić zdarzenia uszeregowane według wyników podobieństwa. Chciałem, aby moje rekomendacje uczyły się dynamicznie i dostosowywały w miarę interakcji z frontendem (podobnie jak w przypadku większości systemów rekomendacji). Większość firm, takich jak Netflix i Tiktok, wykorzystuje tę koncepcję niewidzialnej sztucznej inteligencji , która uwzględnia interakcje użytkownika z ich widocznym interfejsem użytkownika w celu dostosowania rekomendacji. Tiktok wykorzystuje historię oglądania i wyszukiwania, aby polecać następny film, podczas gdy Netflix korzysta z historii oglądania, list ulubionych użytkowników i wspólnego filtrowania, aby polecać filmy i programy w czasie rzeczywistym.

W mojej aplikacji utworzyłem przycisk polubienia, który za każdym razem, gdy podoba mi się wydarzenie na mojej stronie głównej, dodaje identyfikator zdarzenia do tabeli polubionych zdarzeń i równolegle uruchamia osobny skrypt, który włącza polubione zdarzenia do moich osadzeń w celu ponownego obliczenia wyszukiwanie podobieństw. Celem jest dopasowanie rekomendacji do moich preferencji i wydarzeń, które do tej pory mi się podobały. Oto jak dynamicznie dokonuję tych zmian.

# This is the front end component 
<tbody id="events-table">
      <% events.forEach(event => { %>
        <tr>
          <td><%= event.id %></td>
          <td><%= event.venue %></td>
          <td><%= event.event %></td>
          <td><%= event.event_desc %></td>
          <td><%= event.date %></td>
          <td><%= event.price %></td>
          <td><%= event.location %></td>
          <td><%= event.distance %></td>
          <td>
            <form action="/like" method="post" class="like-form">
              <input type="hidden" name="eventId" value="<%= event.id %>">
              <button type="submit" class="like-button">Like</button>
            </form>
          </td>
        </tr>
      <% }) %>
    </tbody>
# This is the backend component

const { spawn } = require('child_process');

app.post('/like', (req, res) => {
  console.log(req.body)
  const eventId = req.body.eventId;
  const query = 'INSERT INTO liked_events (event_id) VALUES (?)';
  connection.query(query, [eventId], (err, result) => {
    if (err) throw err;
    const pyScript = spawn('python', ['./update_recs.ipynb']);
    # This is where I call the python script to reassess similarity scores

    pyScript.stdout.on('data', (data) => {
      console.log(`stdout: ${data}`);
    });

    pyScript.stderr.on('data', (data) => {
      console.error(`stderr: ${data}`);
    });

    pyScript.on('close', (code) => {
      console.log(`child process exited with code ${code}`);
      res.redirect('/');
    });
  });
});
# Invisible AI Component

liked_events_mask = np.isin(event_ids, liked_event_ids)
masked_event_embeddings = np.copy(event_embeddings)
masked_event_embeddings[liked_events_mask] = 0.0
user_embedding_reshaped = np.reshape(user_embedding, (1, -1))

all_embeddings = np.concatenate([user_embedding_reshaped, masked_event_embeddings])

similarity_scores = cosine_similarity(all_embeddings)[0][1:]

for i, event_id in enumerate(event_ids):
    similarity = similarity_scores[i]
    sql = "UPDATE events SET similarity = %s WHERE id = %s"
    val = (similarity, event_id)
    cursor.execute(sql, val)

  1. Następnie kod tworzy kopię tablicy event_embeddingsi przypisuje ją do masked_event_embeddingszmiennej.
  2. Kod ustawia osadzenie wszystkich zdarzeń, które zostały polubione przez użytkownika (jak wskazuje tablica liked_events_mask) na zero w masked_event_embeddingstablicy. To skutecznie „maskuje” osadzenie tych wydarzeń, aby nie brały one udziału w obliczeniach podobieństwa.
  3. Następnie kod przekształca user_embeddingtablicę w 1-wierszową macierz i przypisuje ją do user_embedding_reshapedzmiennej.
  4. Na koniec kod łączy przekształconą user_embedding_reshapedmacierz i masked_event_embeddingsmacierz (która zawiera teraz zamaskowane osadzenie zdarzeń), tworząc nową macierz all_embeddingsreprezentującą preferencje użytkownika i osadzenia wszystkich zdarzeń, które nie spodobały się użytkownikowi.

Wnioski i dalsze kroki

Celem tego projektu było zbudowanie przydatnego silnika rekomendacji wydarzeń, abym mógł wyszukiwać lokalnie zarówno profesjonalne, jak i zabawne wydarzenia. Chciałem również zapewnić wgląd w rozwój modeli transformatorów i sposób, w jaki można je wykorzystać na każdym etapie kompleksowej aplikacji. Użyłem LLM do wstępnego przetwarzania zeskrobanych danych, przechowywania ich, tworzenia funkcji, osadzania ich i ostatecznie tworzenia rekomendacji z tymi osadzaniami. Chociaż korzystanie z tych modeli wiąże się z kosztami, ten projekt pokazuje, jak ważne mogą być te modele, jeśli zostaną one prawidłowo włączone do ogólnej architektury systemu.

Repozytorium GitHub:https://github.com/GauravMohan1/sfevents

LinkedIn:https://www.linkedin.com/in/gaurav-mohan/