Vytvorte inteligentnejší obchod: nechajte GPT označiť vaše produkty a predpovedať, čo bude predávať ďalej

V tomto blogu budeme vytváraťknowledge graphpre odporúčania výrobkov s použitím taxonómie a doplnkovej taxonómie.CocoIndexUľahčuje vytváranie a údržbu znalostných grafov s nepretržitými zdrojovými aktualizáciami.

Product taxonomy ispôsob organizovania produktových katalógov v logickej a hierarchickej štruktúre; veľké podrobné vysvetlenie možno nájsťtuV praxi ide o komplikovaný problém: výrobok môže byť súčasťou viacerých kategórií a kategória môže mať viacerých rodičov.

Budeme tiež používať LLM vytvoriť zoznam komplementárnych taxonómie pre každý produkt - napríklad, keď niekto kúpi poznámkový blok, môžu tiež kúpiť pero ako komplementárny produkt. budeme používať Knowledge Graph preskúmať vzťahy medzi produktmi, ktoré môžu byť ďalej použité pre odporúčania produktov alebo označovanie.

Zdrojový kód je k dispozícii naCocoIndex Príklady - product_taxonomy.

Neustále sa zlepšujeme a čoskoro príde viac funkcií a príkladov.starring☀️our GitHub repo.

Predpoklady

• CocoIndex používa PostgreSQL interne pre inkrementálne spracovanie.
• Nainštalujte Neo4j, grafickú databázu.
• Prípadne môžete prepnúť na Ollama, ktorý spúšťa modely LLM lokálne - sprievodca.

dokumentácia

Môžete si prečítať oficiálnu dokumentáciu CocoIndex pre ciele grafu nehnuteľnostítu.

Prúd údajov na vytvorenie grafu vedomostí

Prehľad

Hlavným prúdom je okolo100 riadkov pythonového kódu.

Budeme deklarovať tok údajov

1. Zoznam produktov (v JSON)
2. for each product,
   • parse JSON
   • map & clean up data
   • extract taxonomy from the mapped data
3. Zbieranie dát
4. Export údajov do neo4j

Pridať dokumenty ako zdroj

@cocoindex.flow_def(name="StoreProduct")
def store_product_flow(flow_builder: cocoindex.FlowBuilder, data_scope: cocoindex.DataScope):
    data_scope["products"] = flow_builder.add_source(
        cocoindex.sources.LocalFile(path="products",
                                    included_patterns=["*.json"]),
        refresh_interval=datetime.timedelta(seconds=5))

tuflow_builder.add_sourceVytvorenie AŤažká→filenameTo je kľúč k Tebe.

Pridať dátové zberače

Pridajte zberače v koreňovom rozsahu na zhromažďovanie produktu, taxonómie a doplnkovej taxonómie.

product_node = data_scope.add_collector()
product_taxonomy = data_scope.add_collector()
product_complementary_taxonomy = data_scope.add_collector()

Proces každý produkt

Analyzujeme súbor JSON pre každý produkt a transformujeme údaje do formátu, ktorý potrebujeme na následné spracovanie.

dátové mapovanie

@cocoindex.op.function(behavior_version=2)
def extract_product_info(product: cocoindex.typing.Json, filename: str) -> ProductInfo:
    return ProductInfo(
        id=f"{filename.removesuffix('.json')}",
        url=product["source"],
        title=product["title"],
        price=float(product["price"].lstrip("$").replace(",", "")),
        detail=Template(PRODUCT_TEMPLATE).render(**product),
    )

Tu definujeme funkciu na mapovanie údajov, napr.

• Vyčistiť pole ID
• Názov mapy -> Názov
• Vyčistiť cenové pole
• generovať značkovací reťazec pre podrobnosti o produkte na základe všetkých oblastí (pre LLM na extrakciu taxonómie a komplementárnej taxonómie zistíme, že značkovanie funguje najlepšie ako kontext pre LLM).

prúdenie

V rámci toku zapojíme transformáciu mapovania údajov na spracovanie každého produktu JSON.

with data_scope["products"].row() as product:
    data = (product["content"]
            .transform(cocoindex.functions.ParseJson(), language="json")
            .transform(extract_product_info, filename=product["filename"]))
    product_node.collect(id=data["id"], url=data["url"], title=data["title"], price=data["price"])

1. Prvým transformom je súbor JSON.
2. Druhý transform() vykonáva definované mapovanie údajov.
3. Zhromažďujeme polia, ktoré potrebujeme pre produktový uzol v Neo4j.

Extrahovať taxonómiu a komplementárnu taxonómiu pomocou LLM

Definícia produktovej taxonómie

Keďže používame LLM na extrakciu produktovej taxonómie, musíme poskytnúť podrobné pokyny na úrovni triedy.

@dataclasses.dataclass
class ProductTaxonomy:
    """
    Taxonomy for the product.
    
    A taxonomy is a concise noun (or short noun phrase), based on its core functionality, without specific details such as branding, style, etc.

    Always use the most common words in US English.

    Use lowercase without punctuation, unless it's a proper noun or acronym.

    A product may have multiple taxonomies. Avoid large categories like "office supplies" or "electronics". Use specific ones, like "pen" or "printer".
    """
    name: str

Definovať produkt Taxonomy Info

V podstate chceme extrahovať všetky možné taxonómie pre produkt a premýšľať o tom, aké ďalšie produkty sú pravdepodobne zakúpené spolu s aktuálnym produktom.

@dataclasses.dataclass
class ProductTaxonomyInfo:
    """
    Taxonomy information for the product.

    Fields:
    - taxonomies: Taxonomies for the current product.
    - complementary_taxonomies: Think about when customers buy this product, what else they might need as complementary products. Put labels for these complentary products.
    """
    taxonomies: list[ProductTaxonomy]
    complementary_taxonomies: list[ProductTaxonomy]

Pre každý produkt chceme nejaký pohľad na jeho taxonómiu a komplementárnu taxonómiu a mohli by sme to použiť ako mostík na nájdenie súvisiaceho produktu pomocou znalostného grafu.

LLM extrakcia

Nakoniec budeme používaťcocoindex.functions.ExtractByLlmextrahovať taxonómiu a komplementárnu taxonómiu z podrobností o výrobku.

taxonomy = data["detail"].transform(cocoindex.functions.ExtractByLlm(
            llm_spec=cocoindex.LlmSpec(
                api_type=cocoindex.LlmApiType.OPENAI, model="gpt-4.1"),
                output_type=ProductTaxonomyInfo))

Napríklad, LLM berie opisĽadový Pen, a extrakty taxonómie byťĽadový PenZ toho vyplýva, že keď ľudia kupujúĽadový PenMôžu mať záujem aj onotebookuTak ako v komplimentárnej taxonómii.

A potom budeme zhromažďovať taxonómiu a komplementárnu taxonómiu pre zberateľa.

with taxonomy['taxonomies'].row() as t:
    product_taxonomy.collect(id=cocoindex.GeneratedField.UUID, product_id=data["id"], taxonomy=t["name"])
with taxonomy['complementary_taxonomies'].row() as t:
    product_complementary_taxonomy.collect(id=cocoindex.GeneratedField.UUID, product_id=data["id"], taxonomy=t["name"])

Vytvorenie znalostného grafu

Základné pojmy

Všetky uzly pre Neo4j potrebujú dve veci:

1. Label: Typ uzla. Napríklad produkt, taxonómia.
2. Pole primárneho kľúča: Pole, ktoré jedinečne identifikuje uzol.

CocoIndex používa pole s primárnym kľúčom na zosúladenie uzlov a ich zdvojnásobenie.Ak máte viac uzlov s rovnakým primárnym kľúčom, CocoIndex si ponechá iba jeden z nich.

Existujú dva spôsoby mapovania uzlov:

1. Keď máte zberač len pre uzol, môžete ho priamo exportovať do Neo4j. Napríklad Produkt.
2. Keď máte zberač vzťahov, ktorý sa pripája k uzlu, môžete mapovať uzly z vybraných polí v zberači vzťahov. Musíte deklarovať označenie uzla a pole primárneho kľúča.

Napríklad

product_taxonomy.collect(id=cocoindex.GeneratedField.UUID, product_id=data["id"], taxonomy=t["name"])

Zhromažďuje vzťah a z tohto vzťahu sa vytvorí taxonomický uzol.

Konfigurácia pripojenia Neo4j:

conn_spec = cocoindex.add_auth_entry(
    "Neo4jConnection",
    cocoindex.storages.Neo4jConnection(
        uri="bolt://localhost:7687",
        user="neo4j",
        password="cocoindex",
))

ExportovaťproduktovPríslušenstvo pre Neo4j

product_node.export(
    "product_node",
    cocoindex.storages.Neo4j(
        connection=conn_spec,
        mapping=cocoindex.storages.Nodes(label="Product")
    ),
    primary_key_fields=["id"],
)

Toto exportuje uzly Neo4j s označenímProductZ tohoproduct_nodezberateľom .

• Vyhlasuje Neo4j uzol označenie produktu. Určuje id ako primárne kľúčové pole.
• Prináša všetky polia od kolektora product_node až po uzly Neo4j s označením Produkt.

Export TaxonómiaPríslušenstvo pre Neo4j

Nemáme výslovného zberateľa preTaxonomyNode.sk je súčasťouproduct_taxonomyaproduct_complementary_taxonomyKolektory a polia sa zhromažďujú počas taxonomickej extrakcie.

Aby sme ich mohli exportovať ako uzly Neo4j, musíme najprv deklarovaťTaxonomyNožnice

flow_builder.declare(
    cocoindex.storages.Neo4jDeclaration(
        connection=conn_spec,
        nodes_label="Taxonomy",
        primary_key_fields=["value"],
    )
)

a následne exportovaťproduct_taxonomySpojenie s Neo4j.

product_taxonomy.export(
    "product_taxonomy",
    cocoindex.storages.Neo4j(
        connection=conn_spec,
        mapping=cocoindex.storages.Relationships(
            rel_type="PRODUCT_TAXONOMY",
            source=cocoindex.storages.NodeFromFields(
                label="Product",
                fields=[
                    cocoindex.storages.TargetFieldMapping(
                        source="product_id", target="id"),
                ]
            ),
            target=cocoindex.storages.NodeFromFields(
                label="Taxonomy",
                fields=[
                    cocoindex.storages.TargetFieldMapping(
                        source="taxonomy", target="value"),
                ]
            ),
        ),
    ),
    primary_key_fields=["id"],
)

Môžeme tiež exportovaťproduct_complementary_taxonomySpojenie s Neo4j.

    product_complementary_taxonomy.export(
        "product_complementary_taxonomy",
        cocoindex.storages.Neo4j(
            connection=conn_spec,
            mapping=cocoindex.storages.Relationships(
                rel_type="PRODUCT_COMPLEMENTARY_TAXONOMY",
                source=cocoindex.storages.NodeFromFields(
                    label="Product",
                    fields=[
                        cocoindex.storages.TargetFieldMapping(
                            source="product_id", target="id"),
                    ]
                ),
                target=cocoindex.storages.NodeFromFields(
                    label="Taxonomy",
                    fields=[
                        cocoindex.storages.TargetFieldMapping(
                            source="taxonomy", target="value"),
                    ]
                ),
            ),
        ),
        primary_key_fields=["id"],
    )

nacocoindex.storages.RelationshipsAko vytvoriť mapu vzťahov v Neo4j

Vo vzťahu existuje:

1. Zdrojový uzol a cieľový uzol.
2. Vzťah, ktorý spája zdroj a cieľ. Všimnite si, že rôzne vzťahy môžu zdieľať rovnaké zdrojové a cieľové uzly.

NodeFromFieldsVezmite si polia zentity_relationshipZberateľ a tvorcaTaxonomyNožnice

Hlavná funkcia

Nakoniec hlavná funkcia pre tok inicializuje tok CocoIndex a spustí ho.

 @cocoindex.main_fn()
def _run():
    pass

if __name__ == "__main__":
    load_dotenv(override=True)
    _run()

Prečítajte si a otestujte svoj index

Teraz ste všetci nastavení!

1. Install the dependencies:

   pip install -e .
   

2. Run following commands to setup and update the index.

   python main.py cocoindex setup
   python main.py cocoindex update
   

   You'll see the index updates state in the terminal. For example, you'll see the following output:

   documents: 9 added, 0 removed, 0 updated
   

3. (Optional) I used CocoInsight to troubleshoot the index generation and understand the data lineage of the pipeline. It is in free beta now, you can give it a try. Run following command to start CocoInsight:

   python3 main.py cocoindex server -c https://cocoindex.io
   

   
   

4. And then open the url https://cocoindex.io/cocoinsight. It just connects to your local CocoIndex server, with Zero pipeline data retention.

Prehľadávať znalostný graf

Po vytvorení znalostného grafu môžete preskúmať znalostný graf, ktorý ste vytvorili v prehliadači Neo4j.

Pre vývojárske prostredie sa môžete pripojiť k prehliadaču Neo4j pomocou poverení:

• Užívateľské meno: Neo4j
• heslo: cocoindex, ktorý je vopred nakonfigurovaný v našom dokumente compose config.yaml.

Môžete ho otvoriť nahttp://localhost:7474, a spustite nasledujúci dotaz Cypher získať všetky vzťahy:

MATCH p=()-->() RETURN p

Podporte nás

Neustále sa zlepšujeme a čoskoro príde viac funkcií a príkladov.Ak sa vám tento článok páči, dajte nám hviezdu ⭐ naGitHub repoaby nám pomohol rásť.

Ďakujem za čítanie!