Sukurkite protingesnę parduotuvę: leiskite GPT ženklinti savo produktus ir nuspėti, kas bus parduodama toliau

Šiame tinklaraštyje mes sukursimeknowledge graphdėl produktų rekomendacijų naudojant taksonomiją ir papildomą taksonomiją.Kokosų indeksasleidžia lengvai kurti ir prižiūrėti žinių grafikus su nuolatiniais šaltinio atnaujinimais.

Product taxonomy iyra būdas organizuoti produktų katalogus logine ir hierarchine struktūra; galima rasti didelį išsamų paaiškinimąčiaPraktiškai tai sudėtinga problema: produktas gali būti kelių kategorijų dalis, o kategorija gali turėti kelis tėvus.

Mes taip pat naudosime LLM, kad sukurtume kiekvieno produkto papildomų taksonomijų sąrašą - pavyzdžiui, kai kas nors perka pieštuką, jie taip pat gali nusipirkti pieštuką kaip papildomą produktą.

Šaltinis yra prieinamasCocoIndex Pavyzdžiai - product_taxonomy.

Mes nuolat tobuliname, ir netrukus ateis daugiau funkcijų ir pavyzdžių.starringour „GitHub“ repo.

Išankstinės sąlygos

• Įdiekite PostgreSQL. „CocoIndex“ naudoja „PostgreSQL“ viduje.
• Įdiekite Neo4j, grafikos duomenų bazę.
• Arba galite pereiti prie Ollama, kuris veikia LLM modelius vietoje - vadovas.

dokumentacijos

Galite perskaityti oficialią „CocoIndex“ dokumentaciją dėl turto grafiko tikslųčia.

Duomenų srautas kuriant žinių grafiką

Apžvalga

Pagrindinis srautas yra apie100 Python kodo eilučių.

Mes deklaruosime duomenų srautą

1. Prekės aprašymas (JSON)
2. for each product,
   • parse JSON
   • map & clean up data
   • extract taxonomy from the mapped data
3. Duomenų rinkimas
4. Eksportuoti duomenis į neo4j

Pridėti dokumentus kaip šaltinį

@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))

čiaflow_builder.add_sourceSukūrė aKėdainiai•filenameTai yra raktas į kaktusą.

Pridėti duomenų rinkėjai

Pridėkite kolektorius prie šaknų, kad surinktumėte produktą, taksonomiją ir papildomą taksonomiją.

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

Kiekvieno produkto procesas

Mes analizuosime JSON failą kiekvienam produktui ir transformuosime duomenis į formatą, kurio mums reikia tolesnei apdorojimui.

Duomenų žemėlapiai

@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),
    )

Čia mes apibrėžiame duomenų kartografavimo funkciją, pvz.,

• Išvalykite ID lauką
• Žemėlapio pavadinimas -> pavadinimas
• clean up the price field
• sukurti žymėjimo eilutę produkto detalėms, pagrįstoms visomis sritimis (už LLM išgauti taksonomiją ir papildomą taksonomiją, mes nustatome, kad žymėjimas geriausiai veikia kaip LLM kontekstas).

srautas

Per srautą mes įjungiame duomenų kartografavimo transformaciją, kad apdorotume kiekvieną produktą 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. Pirmasis transformas parsetuoja JSON failą.
2. Antrasis transform() atlieka apibrėžtą duomenų kartografavimą.
3. Mes renkame laukus, kurių mums reikia produkto mazgui Neo4j.

Ištraukite taksonomiją ir papildomą taksonomiją naudojant LLM

Produkto taksonomijos apibrėžimas

Kadangi mes naudojame LLM išgauti produktų taksonomiją, mes turime pateikti išsamią instrukciją klasės lygio docstring.

@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

Apibrėžti produktų taksonomijos informaciją

Iš esmės mes norime išgauti visas galimas produkto taksonomijas ir galvoti apie tai, kokie kiti produktai greičiausiai bus įsigyti kartu su dabartiniu produktu.

@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]

Kiekvienam produktui norime įžvalgos apie jo taksonomiją ir papildomą taksonomiją ir galėtume tai panaudoti kaip tiltą, kad surastume susijusį produktą, naudodami žinių grafiką.

LLM Ekstrakcija

Galiausiai naudosimecocoindex.functions.ExtractByLlmiš produkto detalių išgauti taksonomiją ir papildomą taksonomiją.

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

Pavyzdžiui, LLM imasi aprašymąGeležinė plytelė, ir išskiria taksonomiją, kad būtųGeležinė plytelėTai rodo, kad kai žmonės perkaGeležinė plytelėGalbūt jie taip pat domisiKnygynasPavyzdžiui, kaip apibūdintumėte komplimentinę taksonomiją.

Ir tada mes surinksime taksonomiją ir papildomą taksonomiją rinkėjui.

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"])

Žinių grafikas

Pagrindinės sąvokos

Visi Neo4j mazgai turi du dalykus:

1. Etiketė: mazgo tipas. pvz., produktas, taksonomija
2. Pirminio rakto laukas: laukas, unikaliai identifikuojantis mazgą, pvz., produkto mazgų id.

CocoIndex naudoja pirminio rakto lauką, kad atitiktų mazgus ir juos dedupliuotų. Jei turite kelis mazgus su tuo pačiu pirminio rakto, CocoIndex išlaiko tik vieną iš jų.

Yra du būdai, kaip išmatuoti mazgus:

1. Kai turite kolektorių tik mazgui, galite jį tiesiogiai eksportuoti į Neo4j. Pavyzdžiui, produktas.
2. Kai turite ryšių kolektorių, jungiantį prie mazgo, galite nukreipti mazgus iš pasirinktų laukų ryšių kolektoriuje.

Pavyzdžiui,

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

Surenka ryšį, o iš ryšio sukuriamas taksonomijos mazgas.

Neo4j ryšio konfigūracija:

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

eksportuotiProduktasŽymės: Neo4j

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

Tai eksportuoja Neo4j mazgus su etiketėmisProductIš Theproduct_nodeKolektyvinė

• Jis deklaruoja Neo4j mazgo etiketę Produktas. Jis nurodo id kaip pirminio rakto lauką.
• Jis perneša visus laukus nuo product_node kolektoriaus iki Neo4j mazgų su ženklu produktas.

eksportuotiTaxonomijosŽymės: Neo4j

Nėra aiškaus kolekcionieriausTaxonomyŠirvintų.lt yra dalisproduct_taxonomyirproduct_complementary_taxonomyKolektoriai ir laukai surenkami taksonomijos gavybos metu.

Norėdami juos eksportuoti kaip Neo4j mazgus, pirmiausia turime deklaruotiTaxonomyNaujovės

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

Toliau eksportuojameproduct_taxonomyKaip atpažinti 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"],
)

Taip pat galime eksportuotiproduct_complementary_taxonomyKaip atpažinti 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"],
    )

Tųcocoindex.storages.RelationshipsIšsiaiškinti, kaip naudoti Neo4j.

Santykiuose yra:

1. A source node and a target node.
2. Atkreipkite dėmesį, kad skirtingi ryšiai gali bendrinti tuos pačius šaltinio ir tikslo mazgus.

NodeFromFieldsPaimkite laukus išentity_relationshipKolektoriai ir kūrėjaiTaxonomyNaujovės

Pagrindinė funkcija

Galiausiai, pagrindinė srauto funkcija inicijuoja CocoIndex srautą ir paleidžia jį.

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

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

Patikrinkite ir išbandykite savo indeksą

Dabar jūs visi sutvarkyti!

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.

Browse the žinių grafikas

Po žinių grafiko sukūrimo galite ištirti žinias, kurias sukūrėte Neo4j naršyklėje.

Dėl kūrėjo aplinkos galite prisijungti prie Neo4j naršyklės naudodamiesi įgaliojimais:

• Žymė: Neo4j
• slaptažodis: cocoindex, kuris yra iš anksto sukonfigūruotas mūsų dokerio sudaryti config.yaml.

Galite jį atidarytihttp://localhost:7474, ir paleiskite šią Cifro užklausą, kad gautumėte visus santykius:

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

Palaikyk mus

Mes nuolat tobuliname, ir netrukus ateis daugiau funkcijų ir pavyzdžių. Jei jums patinka šis straipsnis, prašome suteikti mums žvaigždutę ⭐„GitHub“ repoPadėti mums augti.

Thanks for reading!