एक स्मार्ट स्टोर का निर्माण करें: जीपीटी को अपने उत्पादों को लेबल करें और भविष्यवाणी करें कि अगले में क्या बेचना है

इस ब्लॉग में हम एकknowledge graphटैक्सीनॉमी और पूरक टैक्सीनॉमी का उपयोग करके उत्पाद सिफारिशों के लिए।कोकोइंडेक्सयह आसान बनाता है और निरंतर स्रोत अद्यतन के साथ ज्ञान ग्राफ बनाए रखता है।

Product taxonomy iउत्पाद कैटलॉग को एक तार्किक और रीरेखिक संरचना में व्यवस्थित करने का एक तरीका; एक महान विस्तृत स्पष्टीकरण पाया जा सकता हैयहांअभ्यास में, यह एक जटिल समस्या है: एक उत्पाद कई श्रेणियों का हिस्सा हो सकता है, और एक श्रेणी में कई माता-पिता हो सकते हैं।

हम उत्पाद वर्णन से टैक्सोनिमों की एक सूची निकालने के लिए एलएलएम का उपयोग करेंगे. हम प्रत्येक उत्पाद के लिए पूरक टैक्सोनिमों की एक सूची उत्पन्न करने के लिए एलएलएम का भी उपयोग करेंगे - उदाहरण के लिए, जब कोई नोटबुक खरीदता है, तो वे एक पेंटिंग भी एक पूरक उत्पाद के रूप में खरीद सकते हैं. हम उत्पादों के बीच संबंधों का पता लगाने के लिए ज्ञान ग्राफ का उपयोग करेंगे जो उत्पाद सिफारिशों या लेबलिंग के लिए आगे इस्तेमाल किया जा सकता है.

स्रोत कोड उपलब्ध हैCocoIndex उदाहरण - product_taxonomy.

हम लगातार सुधार कर रहे हैं, और अधिक सुविधाएं और उदाहरण जल्द ही आ रहे हैं।starringour GitHub रीपो.

पूर्वानुमान

• PostgreSQL स्थापित करें. CocoIndex अंदरूनी रूप से PostgreSQL का उपयोग बढ़ती प्रसंस्करण के लिए करता है।
• Neo4j, एक ग्राफ़ डेटाबेस स्थापित करें।
• वैकल्पिक रूप से, आप Ollama पर स्विच कर सकते हैं, जो स्थानीय रूप से एलएलएम मॉडल चलाता है - गाइड।

दस्तावेज

आप संपत्ति ग्राफ लक्ष्यों के लिए आधिकारिक CocoIndex दस्तावेज़ पढ़ सकते हैंयहां.

ज्ञान ग्राफ बनाने के लिए डेटा प्रवाह

समीक्षा

मुख्य प्रवाह के बारे में हैPython कोड के 100 पंक्तियाँ.

हम एक डेटा प्रवाह घोषित करेंगे

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बनाता है Aकटवाना.filenameयह कुंजी की कुंजी है।

डेटा संग्रहकों को जोड़ें

उत्पाद, टैक्सीनॉमी और पूरक टैक्सीनॉमी को इकट्ठा करने के लिए जड़ सीमा में कलेक्टर जोड़ें।

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

प्रत्येक उत्पाद की प्रक्रिया

हम प्रत्येक उत्पाद के लिए JSON फ़ाइल का विश्लेषण करेंगे, और डेटा को उस प्रारूप में परिवर्तित करेंगे जो हमें बाद में प्रसंस्करण के लिए आवश्यक है।

डेटा मैप

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

यहाँ हम डेटा मानचित्रण के लिए एक कार्य परिभाषित करते हैं, उदाहरण के लिए,

• ID फ़ील्ड को साफ करें
• कागज का नाम - Title
• कीमत क्षेत्र को साफ करें
• सभी क्षेत्रों के आधार पर उत्पाद विवरण के लिए एक मार्कअप श्रृंखला उत्पन्न करें (एलएलएम के लिए टैक्सोनिम और पूरक टैक्सोनिम निकालने के लिए, हम पाते हैं कि मार्कअप एलएलएम के लिए संदर्भ के रूप में सबसे अच्छा काम करता है)।

फ्लो

प्रवाह के भीतर, हम प्रत्येक उत्पाद 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. पहला ट्रांसफार्म() JSON फ़ाइल को पारित करता है।
2. दूसरा ट्रांसफार्म() परिभाषित डेटा मैपिंग को पूरा करता है।
3. हम Neo4j में उत्पाद नोड के लिए आवश्यक क्षेत्रों को एकत्र करते हैं।

एलएलएम का उपयोग करके टैक्सोमिया और पूरक टैक्सोमिया निकालना

उत्पाद टैक्सी परिभाषा

चूंकि हम उत्पाद टैक्सीनॉमी निकालने के लिए एलएलएम का उपयोग कर रहे हैं, इसलिए हमें कक्षा स्तर के 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

Product Taxonomy के बारे में जानकारी

मूल रूप से हम एक उत्पाद के लिए सभी संभावित टैक्सोनॉमी निकालना चाहते हैं, और सोचते हैं कि वर्तमान उत्पाद के साथ किन अन्य उत्पादों को खरीदा जा सकता है।

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

प्रत्येक उत्पाद के लिए, हम इसकी टैक्सोनिमिया और पूरक टैक्सोनिमिया के बारे में कुछ अंतर्दृष्टि चाहते हैं और हम ज्ञान ग्राफ का उपयोग करके संबंधित उत्पादों को खोजने के लिए पुल के रूप में इसका उपयोग कर सकते हैं।

एलएलएम निकासी

अंत में, हम उपयोग करेंगे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))

उदाहरण के लिए, एलएलएम वर्णन लेता हैपेन के लिए, और निकालें टैक्सोमिया होने के लिएपेन के लिएहालांकि, यह बताता है कि जब लोग खरीदते हैंपेन के लिएवे भी रुचि रख सकते हैंनोटबुकएक तारीफ टैक्सी के रूप में।

और फिर हम संग्रहकर्ता को टैक्सोनॉमी और पूरक टैक्सोनॉमी एकत्र करेंगे।

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

ज्ञान ग्राफ का निर्माण

बुनियादी अवधारणाएं

Neo4j के लिए सभी नोड्स को दो चीजों की आवश्यकता होती है:

1. लेबल: नोड का प्रकार. उदाहरण के लिए, उत्पाद, टैक्सोनॉमी।
2. प्राथमिक कुंजी फ़ील्ड: फ़ील्ड जो एकमात्र रूप से नोड की पहचान करता है. उदाहरण के लिए, उत्पाद नोड के लिए id।

यदि आपके पास एक ही प्राथमिक कुंजी के साथ कई नोड हैं, तो CocoIndex केवल उनमें से एक को रखता है।

नोड्स को नक्शे बनाने के दो तरीके हैं:

1. जब आपके पास केवल नोड के लिए एक संग्रहक है, तो आप इसे सीधे Neo4j में निर्यात कर सकते हैं. उदाहरण के लिए उत्पाद. हमने प्रत्येक उत्पाद को स्पष्ट रूप से एकत्र किया है.
2. जब आपके पास रिश्तों के लिए एक संग्रहक है जो नोड से जुड़ा हुआ है, तो आप रिश्तों के संग्रहक में चयनित क्षेत्रों से नोडों को नक्शे कर सकते हैं. आपको नोड लेबल और प्राथमिक कुंजी क्षेत्र की घोषणा करनी चाहिए.

उदाहरण के लिए,

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

एक रिश्ते को इकट्ठा करता है, और रिश्ते से टैक्सीनॉमी नोड बनाया जाता है।

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

यह लेबल के साथ Neo4j नोड्स निर्यात करता हैProductके सेproduct_nodeसंग्रहक

• यह Neo4j नोड लेबल उत्पाद की घोषणा करता है. यह पहचान को प्राथमिक कुंजी क्षेत्र के रूप में निर्दिष्ट करता है.
• यह उत्पाद लेबल के साथ Neo4j नोड्स के लिए product_node collector से सभी क्षेत्रों को ले जाता है।

निर्यातटैक्सीNeo4j के बारे में राय

हमारे पास स्पष्ट संग्रहक नहीं हैTaxonomyनक्सलियों का यह हिस्सा हैproduct_taxonomyऔरproduct_complementary_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.RelationshipsNeo4j में रिश्तों को नक्शे कैसे डालें

एक रिश्ते में, यह है:

1. एक स्रोत नोड और एक लक्ष्य नोड।
2. एक रिश्ता जो स्रोत और लक्ष्य को जोड़ता है ध्यान दें कि विभिन्न रिश्ते एक ही स्रोत और लक्ष्य नोड साझा कर सकते हैं।

NodeFromFieldsमैदानों से ले जाते हैंentity_relationshipसंग्रहक और बनाता हैTaxonomyनोड्स

मुख्य कार्य

अंत में, प्रवाह के लिए मुख्य कार्य CocoIndex प्रवाह को प्रारंभ करता है और इसे चलाता है।

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

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

जांचें और अपने इंडेक्स का परीक्षण करें

अब आप सभी सेट हैं!

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.

ज्ञान ग्राफ ब्राउज़ करें

ज्ञान ग्राफ का निर्माण करने के बाद, आप Neo4j ब्राउज़र में बनाए गए ज्ञान ग्राफ का पता लगा सकते हैं।

डेव वातावरण के लिए, आप क्रिप्टिकल का उपयोग करके Neo4j ब्राउज़र से कनेक्ट कर सकते हैं:

• उपयोगकर्ता नाम: Neo4j
• पासवर्ड: cocoindex जो हमारे दस्तावेज़ में अनुकूलित है compose config.yaml।

आप इसे खोल सकते हैंhttp://localhost:7474, और सभी रिश्तों को प्राप्त करने के लिए निम्नलिखित Cypher पूछताछ चलाएं:

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

हमें समर्थन

हम लगातार सुधार कर रहे हैं, और अधिक सुविधाएं और उदाहरण जल्द ही आ रहे हैं. यदि आप इस लेख को पसंद करते हैं, तो कृपया हमें एक स्टार दें ⭐ परGitHub रीपोहमें बढ़ने में मदद करें।

पढ़ने के लिए धन्यवाद!