Բարձրացրեք Smart Store- ը: GPT- ը թույլ է տալիս ձեր արտադրանքի նամակել եւ նախընտրել, թե ինչ է վաճառում

Այս բլոգում մենք ստեղծում ենքknowledge graphԱպրանքների առաջարկման համար, օգտագործելով taxonomy եւ complementary taxonomy:CocoIndex- ըԱվելի հեշտ է ստեղծել եւ պահպանել գիտելիքի գրաֆիկները, որոնք անմիջապես նորարարված են սեղանների հետ:

Product taxonomy iԱպրանքի կատեգորիաների տեղադրման մեթոդը լոգիական եւ հիերխիկային կառուցվածքի մեջ: Լավ մանրամասներ կարող է գտնելԱյստեղԱպրանքը կարող է լինել մի քանի կատեգորիաների մաս, եւ մի կատեգորիան կարող է լինել մի քանի ծնողներ:

Մենք նաեւ կօգտագործենք LLM- ը յուրաքանչյուր արտադրանքի համար լրացուցիչ taksonomies- ի ցուցակը ստեղծելու համար - օրինակ, երբ մեկը գնում է գրասենյակը, նրանք կարող են նաեւ գնել պեն, որպես լրացուցիչ արտադրանքը: Մենք օգտագործենք Knowledge Graph- ը արտադրանքի միջեւ հարաբերությունները, որոնք կարող են ավելին օգտագործվել արտադրանքի խորհուրդների կամ մետաղադրամների համար:

Source code-ը հասանելի էCocoIndex Ապրանքներ - product_taxonomy.

Մենք միշտ բարելավում ենք, եւ ավելի առանձնահատկություններ եւ մանրամասներ ապրում են արագ. Տեսեք մեզ եւ հետեւեք մեր առաջադեմըstarringour GitHub Repo- ը.

Հիմնական պայմաններ

• Install PostgreSQL. CocoIndex օգտագործում է PostgreSQL- ը ինտեգրապես բաղադրիչի բաղադրիչների համար:
• Neo4j- ը տեղադրում է Graph Database- ը:
• Արդյոք, դուք կարող եք փոխել Ollama, որը գործում է LLM մոդելներ տեղականում.

Տեղադրություն

Դուք կարող եք կարդալ oficial CocoIndex Documentation for Property Graph Targets- ըԱյստեղ.

Data flow- ը ստեղծում է Knowledge Graph- ը

Հիմնական տեսություն

Core Flow-ի մասին100 գծի Python կոդը.

Մենք կգտնենք տվյալների թռիչք

1. Արդյունաբերական արտադրանքը (JSON)
2. for each product,
   • parse JSON
   • map & clean up data
   • extract taxonomy from the mapped data
3. Տեղադրություն
4. Արդյոք Neo4j- ը

Ապրանքներ, ինչպիսիք են սարքավորումներ

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

Այստեղflow_builder.add_sourceՀիմնական aKTableԱրդյոքfilenameԴա է Ktable- ի սխալը.

Ավելացնել Data Collectors

Ապրանքի, taxonomy- ի եւ komplementary taxonomy- ի հավաքման համար ավելացեք collectors- ում.

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

Ամեն արտադրանքը

Մենք կասկածենք JSON ֆայլը յուրաքանչյուր արտադրանքի համար, եւ փոխարինենք տվյալները այն ձեւով, որը մենք պետք է ներբեռնման համար:

Data Mapping- ը

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

Այսպիսով, մենք որոշում ենք մի գործառույթ համար data mapping, օրինակ,

• clean up the id field
• Գլխավոր էջ -> Title
• Պահպանեք գինը
• generate markdown string for the product detail based on all the fields (for LLM to extract taxonomy and complementary taxonomy, մենք գտնում ենք, որ markdown աշխատում է լավագույնը, որպես контекст համար LLM).

Flow

Ապրիշում, մենք մուտք գործում ենք տվյալների թարմացման փոխարինման յուրաքանչյուր արտադրանքի 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. Առաջին transform() ֆայլը է JSON ֆայլը.
2. The second transform() կատարում է defined data mapping.
3. Մենք կտրում ենք արտադրանքի կետը Neo4j- ում պահանջվող տարածքները:

Ավելացնել Taxonomy եւ Complementary Taxonomy օգտագործելով LLM

Ապրանքային Taxonomy Definitions

Քանի որ մենք օգտագործում ենք LLM- ում արտադրանքի տրանսպորտը, մենք պետք է ապահովենք մասնագիտացված դասընթացը դասընթացային մակարդակի 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

Ապրանքային Taxonomy Info

Հիմնականորեն, մենք ցանկանում ենք ստանալ բոլոր հնարավոր taxonomies մի արտադրանքի համար, եւ մտածել, թե ինչ այլ արտադրանքը կարող են գնել միասին current արտադրանքի.

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

Ամեն արտադրանքի համար, մենք ցանկանում ենք մի քանի հասկանալ իր taxonomy եւ komplementary taxonomy եւ մենք կարող ենք օգտագործել այն որպես նավթի գտնելու հետազոտական արտադրանքի օգտագործելով գիտելիքի գծի.

LLM արտադրություն

Իհարկե, մենք օգտագործենքcocoindex.functions.ExtractByLlmԱպրանքի մանրամասից տրանսպորտային եւ լրացուցիչ տրանսպորտային մանրամասները արտադրելու համար:

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

LLM- ը օգտագործում է այն մասին, որԱղջիկ Pen, եւ extract taxonomy to beԱղջիկ PenՄիեւնույն ժամանակ, դա ցույց է տալիս, որ երբ մարդիկ գնում ենԱղջիկ PenՆրանք կարող են նաեւ հետաքրքիր լինելԳլխավորԱվելի լավ է, թե ինչպես է սեղմվում taxonomy.

Այսպիսով, մենք կտրում ենք Taxonomy եւ Complementary Taxonomy.

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

Տեղադրեք Knowledge Graph

Հիմնական գաղափարներ

Բոլոր կետերը Neo4j-ի համար անհրաժեշտ են երկու բաներ:

1. Ապրանքի տեսակը: Ապրանքի տեսակը, Ապրանքի տեսակը, Taxonomy.
2. Հիմնական սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմների սեղմման սեղմման սեղմման սեղմման սեղմման սեղմման սեղմ

CocoIndex- ը օգտագործում է առաջին սխալը սխալը, որպեսզի սխալները սխալ են, եւ այն deduplicate.If you have multiple nodes with the same primary key, CocoIndex beholds only one of them.

Երկու մեթոդներ կարող են տպագրել կետերը:

1. Երբ դուք ունեք մի բաղադրիչ միայն կոճի համար, դուք կարող եք ուղղակիորեն արտահանել այն Neo4j- ում: Օրինակ, արտադրանքը: Մենք բացահայտել ենք յուրաքանչյուր արտադրանքը:
2. Երբ դուք ունեք մի բաղադրիչ Relationships, որը միացվում է կետը, դուք կարող եք map կետներ ընտրված սարքերի մեջ Relationship Collector. Դուք պետք է հայտարարել մի կետ բաղադրիչ եւ primary key field.

Օրինակ՝

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

Տեղադրում է մի հարաբերություն, եւ taxonomy կետը ստեղծվում է հարաբերության.

Neo4j կապը տեղադրելու համար:

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

ԱպրանքներProductNeo4j Վիքիպահեստում

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

This exports Neo4j knots with label- ըProductՔանի որ Theproduct_nodeԿամակատոր

• Դա հայտարարում է Neo4j knot label Ապրանք. Դա նշում է id- ը որպես հիմնական սեղմիչը.
• Այն բեռնում է բոլոր տարածքները product_node collector- ից Neo4j- ի կետների հետ Product- ի նամակով:

ԱպրանքներTaxonomyNeo4j Վիքիպահեստում

Մենք չենք ունենք բացասական collector- ըTaxonomyՆշում են, որ նրանք մի մաս ենproduct_taxonomyեւproduct_complementary_taxonomyCollectors and fields- ը կտրված է Taxonomy- ի արտադրանքի ընթացքում:

Neo4j կետների համար, մենք պետք է առաջին անգամ հայտարարելTaxonomyՆշում են

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

Հետեւաբար, արտահանման համարproduct_taxonomyNeo4j-ի հետ միասին

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

Մենք կարող ենք արտադրելproduct_complementary_taxonomyNeo4j-ի հետ միասին

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

Դաcocoindex.storages.RelationshipsԻնչպե՞ս կարող եք փոխել Neo4j- ում.

Միջազգային հարաբերություններում, այն ունի:

1. Հյուրատետր սարքավորումներ եւ նպատակային սարքավորումներ.
2. Հասկածեք, որ տարբեր հարաբերություններ կարող են համատեղել նույն սեղանային եւ նպատակային կետեր:

NodeFromFieldsԱրդյոք, այդ տարածքները ստանում ենentity_relationshipԿարդալ եւ ստեղծելTaxonomyՆշում են

Հիմնական գործիքները

Իհարկե, հիմնական գործառույթը Flow- ի համար սկսում է CocoIndex Flow- ը եւ կատարում է այն:

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

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

Տեղադրեք եւ փորձեք ձեր index

Այժմ դուք բոլորը տեղադրված եք!

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 Knowledge Graph- ը

Երբ գիտելիքի դեղը կառուցված է, դուք կարող եք ուսումնասիրել գիտելիքի դեղը, որը ստեղծել եք Neo4j Browser- ում:

Օգտագործեք Neo4j բեռնելը, օգտագործելով հավելվածները:

• Հեղինակ՝ Neo4j
• Հասցե: cocoindex, որը նախընտրում է մեր docker compose config.yaml.

Դուք կարող եք բացել այնhttp://localhost:7474, եւ կատարեք հետեւյալ Cypher հարցը, որպեսզի ստանալ բոլոր հարաբերություններ:

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

Մենք աջակցում ենք

Մենք միշտ բարելավում ենք, եւ ավելի առանձնահատկություններ եւ օրինակներ կստանանան արագ. Եթե դուք սիրում եք այս հոդվածը, խնդրում ենք տալիս մեզ գլուխ ⭐GitHub Repo- ըՆրանք օգնում են մեզ աճել.

Շնորհակալություն կարդալից!