Rekomendator wydarzeń SF za pomocą LLM
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)
- Następnie kod tworzy kopię tablicy
event_embeddingsi przypisuje ją domasked_event_embeddingszmiennej. - Kod ustawia osadzenie wszystkich zdarzeń, które zostały polubione przez użytkownika (jak wskazuje tablica
liked_events_mask) na zero wmasked_event_embeddingstablicy. To skutecznie „maskuje” osadzenie tych wydarzeń, aby nie brały one udziału w obliczeniach podobieństwa. - Następnie kod przekształca
user_embeddingtablicę w 1-wierszową macierz i przypisuje ją douser_embedding_reshapedzmiennej. - Na koniec kod łączy przekształconą
user_embedding_reshapedmacierz imasked_event_embeddingsmacierz (która zawiera teraz zamaskowane osadzenie zdarzeń), tworząc nową macierzall_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/

![Czym w ogóle jest lista połączona? [Część 1]](https://post.nghiatu.com/assets/images/m/max/724/1*Xokk6XOjWyIGCBujkJsCzQ.jpeg)



































