Tworzenie osadzeń [embeddings] dla wyszukiwania wektorowego Neo4j
Jeśli temat 'wyszukiwania wektorowego' jest dla Ciebie nowy, przejdź na wcześniejszą stronę tego bloga by zapoznać się z tym przedmiotem. W tym artykule dowiesz się jak tworzyć osadzenia - wektory w wielowymiarowej przestrzeni. Czyli zamiana słów, zdań i zapytań na wektory.
Odczytanie danych z pliku Excela
Tworzymy embeddings dla opisów produktów. Nasza baza produktów znajduje się w pliku Excela. Użyjemy modułu pandas który wykorzystuje openpyxl by odczytać plik Excela. Utworzone wektory zapiszemy w pliku emb_result.csv [kolumny sku;description;embedding]
from sentence_transformers import SentenceTransformer
import numpy as np
import pandas as pd
import re
#Model 50 jezykow w tym Polski
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')
#Sprawdzmy ile tokenów słów obsługuje model:
print("Max Sequence Length:", model.max_seq_length)
#Ustawienie maksymalnej długości kodowanych sekwencji
model.max_seq_length = 128
#Otwarcie pliku Excela, skoroszyt 0
file_name = "produkty.xlsx"
sheet = 0
#Otwarcie pliku, kolumny 0 i 19
df = pd.read_excel(io=file_name, sheet_name=sheet, usecols=[0, 19])
#Listuj 5 pierwszych linii pliku
#print(df.head(5))
#Testowy zapis do pliku:
#kolumna_do_zapisu = df[['sku', 'product description']]
#kolumna_do_zapisu.to_csv('test.csv', index=False)
file = open("emb_result.csv", "w", encoding='utf-8')
for index, row in df.iterrows():
emb = model.encode(row['product description'])
emb_str = np.array2string(emb, separator=',')
emb_str = emb_str.replace("\n","")
emb_str =emb_str.replace(" ","")
emb_str = re.sub(r'[\[\]]', '', emb_str)
file.write(str(row['sku']) + ';' + row['product description'] + ';' + emb_str)
file.write("\n")
file.close()
Wyszukiwanie wektorowe - algorytmy "Sztucznej Inteligencji"
Co to jest wyszukiwanie wektorowe?
Wektory to matematyczne reprezentacje danych w przestrzeni wielowymiarowej. W tej przestrzeni każde dane posiadają swoje koordynaty, a do reprezentowania skomplikowanych danych można użyć dziesiątek tysięcy wymiarów.. Słowa, frazy lub całe dokumenty, a także obrazy, pliki audio i inne typy danych można wektoryzować. Np. dla każdego opisu produktu obliczany jest wektor cech - tzw. "osadzenie" (po angielsku "embeddings"). Wyszukując informacji podobnych, używamy algorytmów które dostarczają nam informacje zapisane w podobnych lokalizacji przestrzeni wielowymiarowej co informacja referencyjna. Np. "pies" znajduje się niedaleko "pieska" czy "szczeniaka" (dla uproszczenia, bo jak napisaliśmy wyżej można umieścić tam całe dokumenty, obrazy, dźwięk).
Najpopularniejsze metody obliczania odległości miedzy informacjami umieszczonymi w przestrzenie (podobieństwo między wektorami) to metoda Euclidesa i Cosine. Sam Euclid żył 300 lat przed naszą erą więc dużo to mówi o haslach "nowoczesne algorytmy" i "sztuczna inteligencja".
Wyobraź sobie że wszystkie produkty sklepu internetowego znalazły się w takiej wielowymiarowej przestrzeni a każdy z nich jest opisany wektorami; ma swoje miejsce w tej przestrzeni. Dla uproszczenia tak mogłoby wyglądać miejsce gdzie przechowujemy opis dwóch filtrów (prawa strona obrazka) i dwóch olejów silnikowych (lewa strona obrazka):
Personalizowane rekomendacje produktów
Rekomendacje produktów na podstawie danych z poprzednich transakcji zakupowych klientów
Według XYZ aż 91% konsumentów uważa, że chętniej kupią od marek, których rekomendacje i oferta są do nich dopasowane.... bla, bla bla. Rekomendacje, jeśli nie zbyt nachalne, z pewnością pomagają zwiększyć sprzedaż i uczynić klienta bardziej usatysfakcjonowanym. Kiedy mówimy o 'rekomendacjach' to mamy na myśli nie tylko sklepy internetowe ale e-mailing, oferty, podpowiedzi sprzedażowe w CRM itd. Poniżej kilka przykładów jak można je uzyskać w grafowej bazie danych Neo4j.
Przykładowe dane zakupowe
Nasze przykładowe dane to ledwie pięciu klientów kupujących sześć produktów. Gotowe do wgrania dane [użyj czystej bazy danych Neo4j]:
CREATE (John:Client {clientid: 10, name:'John'}),
(Alice:Client {clientid: 20, name:'Alice'}),
(Mark:Client {clientid: 30, name:'Mark'}),
(Noah:Client {clientid: 40, name:'Noah'}),
(Olivier:Client {clientid: 50, name:'Olivier'}),
(Eggs:Product {name:'Eggs', productid: 310}),
(Bread:Product {name:'Bread', productid: 320}),
(Beer:Product {name:'Beer', productid: 330}),
(Sugar:Product {name:'Sugar', productid: 340}),
(Cookies:Product {name:'Cookies', productid: 350}),
(Apples:Product {name:'Apples', productid: 360}),
(Water:Product {name:'Water', productid: 370}),
(t501:Transaction {id: 501, pdate: '2023-02-01'}),
(t502:Transaction {id: 502, pdate: '2023-02-02'}),
(t503:Transaction {id: 503, pdate: '2023-02-01'}),
(t504:Transaction {id: 504, pdate: '2023-02-04'}),
(t505:Transaction {id: 505, pdate: '2023-02-06'}),
(John)-[:MADE_TRANSACTION]->(t501),
(Alice)-[:MADE_TRANSACTION]->(t502),
(Mark)-[:MADE_TRANSACTION]->(t503),
(Noah)-[:MADE_TRANSACTION]->(t504),
(Olivier)-[:MADE_TRANSACTION]->(t505),
(t501)-[:CONTAINS {quantity: 2}]->(Eggs),
(t501)-[:CONTAINS {quantity: 3}]->(Bread),
(t501)-[:CONTAINS {quantity: 5}]->(Beer),
(t501)-[:CONTAINS {quantity: 4}]->(Sugar),
(t502)-[:CONTAINS {quantity: 3}]->(Eggs),
(t502)-[:CONTAINS {quantity: 4}]->(Bread),
(t503)-[:CONTAINS {quantity: 5}]->(Bread),
(t503)-[:CONTAINS {quantity: 6}]->(Beer),
(t503)-[:CONTAINS {quantity: 2}]->(Water),
(t504)-[:CONTAINS {quantity: 12}]->(Eggs),
(t504)-[:CONTAINS {quantity: 7}]->(Cookies),
(t504)-[:CONTAINS {quantity: 14}]->(Apples),
(t505)-[:CONTAINS {quantity: 32}]->(Apples),
(t505)-[:CONTAINS {quantity: 1}]->(Cookies);
Model danych
W naszych danych mamy trzy typy węzłów: Client, Product i Transaction. Zakupy klienta znajdują się w transakcjach których dokonał - między klientem a transakcją mamy relację MADE_TRANSACTION a produkty powiązane są z transakcją relacjami CONTAINS. Możesz wykonać polecenie call db.schema.visualization by zobaczyć ten model danych.
Widok grafu
Nasze dane po załadowaniu do Neo4j będą mieć następująca postać:
Oracle Apex & Camunda BPM
How to use Camunda "workflow" in Oracle Apex application?
The vast majority of business applications have some sort of "wokflow". In every business, a group of people do their job to "deliver value". But we don't do everything together and we break the task into activities because we specialize and carry out tasks according to skills - role. We do our job and pass it on to the next person - like an assembly line. These activities are performed as part of a process that works according to: template - "wokflow". It has its stages, tasks and statuses.
Oracle Apex in the latest version has a built-in workflow building tool. If the workflow is only used for the needs of the application we are building, this approach may make sense. However, if our workflow is complex, changes frequently or the process is supported by different systems, it is a much better idea to use a dedicated system - a BPM platform.
Using a platform also makes great sense to manage change. We all know how "business" changes assumptions about applications - it starts with "something small" and evolves into quite a large, complex system. So the workflow that we use, e.g. for accepting invoices from one level, expands to several levels, new business conditions and exceptions are created (e.g. the flow depends on the type of invoice, the invoice amount, the supplier/customer category).
The BPM platform will simply handle processes better and give us more opportunities. Just imagine onboarding process where several actors and applications are involved:
Required components
The system that will allow us to build a workflow for Oracle Apex application without much effort is Camunda. Camunda not only allows you to build a flow diagram in BPM notation, but is also delivers a tool for creating decision models; business conditions (DMN). Camunda has two systems - Modeler for creating diagrams and Platform for running processes. Components were written in Java as open source model under the terms of the Apache license.
When building an application that requires workflow, we separate the management of information flow from the application itself. The application "has no idea" how the business logic of information flow is organized - it passes the acceptance task to Camunda, and the BPM platform takes care of the appropriate decision. Camunda itself does not do anything in the Oracle database, it does not provide forms, it does not manage data - it only deals with providing information. It is the external system/people who take specific action based on them.
In a nutshell; the flow of information is handled by the BPM platform and the role of the application is only to read the state of the process and provide information to the process that task was copleted.