基于 Amazon Bedrock 和 Llama2 构建智能导购解决方案

Customer: Hi, I'm looking to buy a new smartphone. Can you help recommend one based on my needs?  
Shopping Guide: Absolutely! I'd be happy to help you find the perfect smartphone. To get started, what are some of the key features you're looking for in your new phone?  
Customer: I need a phone with a really good camera and display since I watch a lot of videos and take tons of pictures. Long battery life is also pretty important to me.  
Shopping Guide: Okay, it sounds like you need a phone with a high-quality camera, a nice display and good battery life. Do you have any preferences for the brand or operating system?  
Customer: I'm open to either iOS or Android. As for brands, I like Samsung and Google Pixel phones. I also want a 6 inch screen.  

"get_recommds_by_sku": {
 "brand": "Samsung and Google Pixel phones", "category": "smartphone",
"screen size": "6 inch",
 "screen panel": "good display",
"camera": "good camera",
 "operating system": "iOS or Android", "battery": "long battery life"  
}  

You are a skilled shopping guider. Your task is to analyze the given chat text carefully and identify users’ purchasing intentions，What starts with "user" is the user's input, and what starts with "bot" is the output of ai bot.purchasing intentions are defined by category_and_description tag.
<category_and_description>

<category> random chat </category>
<category_description>In the user's conversation, there are no topics related to purchases, products or scenarios.</category_description>

<category> random shopping </category>
<category_description>maybe a shopping topic but not specific info</category_description>

<category> intended shopping </category>
<category_description>Users express their willingness to purchase or need</category_description>

<category> specific scenarios</category>
<category_description>The user mentioned an itinerary or other scenario that requires the use of some equipment, tools, etc.</category_description>

<category> specific needs </category>
<category_description>The user has specified specific names, attributes, functions, or decided purchase etc.</category_description>

<category> specific brand</category>
<category_description>The user(not bot) has specified a specific product name and brand</category_description>

</category_and_description>

<hints>
These above six intents build upon each other in a progressive manner.

* Random chat: First is casual chat, with no product,feature,function and shopping intent at all, so it is completely unable to recall any products.
* Random shopping: It's like coming to the mall and just browsing around, not specific products/feature/function info,not knowing what you need or what to buy.
* Intended shopping: There is a clear shopping intent, meaning they have come to shop. This already counts as having the "buy" need, so they are the target users.
* Specific scenarios: Compared to the previous one, there is a clear "buy" need, and it is also clear "where" this product is needed.
* Specific needs: This category is mainly about the user clearly needing a product for "what purpose" or needing a product for a certain use,or user has make a decision for purchase and ask buy program.
* Specific brand: Finally, this is when the user clearly states which brand of product they need  and user has not decided purchase, so we can directly recall products from that brand,If the bot provides brand information, we should classify it as "Specific needs".

</hints>
Here is the chat text for you:
<text>
{msg}
</text>

Before providing your response, please ** think step-by-step ** within <thinking></thinking> tags about which category best fits the text and your reasoning behind it.

Then, provide your final categorization and explanation within <response></response> tags, using the JSON format:
{{
  "category": "category name",
  "reason": "your reasoning"
}}

Make sure to follow the specified format exactly.

{
        "origin_cont": "I'm interested in a large, high-performance device. How's the battery life on this model?",
        "haiku_intent": "specific needs",
        "reason": "The chat text expresses a clear shopping intent, with the user inquiring about the details of a specific product (battery life of a large, high-performance device). This indicates a specific need for a product with those characteristics, rather than just random browsing or a general shopping intent."
    }

import time
from sagemaker.estimator import Estimator
from sagemaker.pytorch import PyTorch
from datetime import datetime

instance_count = 1
instance_type = 'ml.p4d.24xlarge'  ## 8*40G
max_time = 200000

# Get the current time
current_time = datetime.now()

# Format the current time as a string
formatted_time = current_time.strftime("%Y%m%d%H%M%S")
print(formatted_time)

environment = {
    'NODE_NUMBER':str(instance_count),
    'MODEL_S3_PATH': f's3://{sagemaker_default_bucket}/Foundation-Models/Llama-2-13b-chat-hf/*', # source model files
    'OUTPUT_MODEL_S3_PATH': f's3://{sagemaker_default_bucket}/Llama-2-13b-chat-hf/{formatted_time}/', # destination
}

estimator = PyTorch(entry_point='entry.py',
                            source_dir='LLaMA-Factory/',
                            role=role,
                            environment=environment,
                            framework_version='2.1.0',
                            py_version='py310',
                            script_mode=True,
                            instance_count=instance_count,
                            instance_type=instance_type,
                            max_run=max_time)

# # data in channel will be automatically copied to each node - /opt/ml/input/data/train1
estimator.fit()

def generate(message, history):
    history = history[-10:]
    status_messages = [status_sys_message]
    dialog_messages = [dialog_sys_message]
    api_messages = [api_sys_message]
    chosen_api_output = []
    text_message = ''
    if len(history) > 0:
        for h in history:
            q, a = h[0], h[1]
            api_output, a = a.split(splitter)
            a = a.strip()
            api_output = api_output.split("api返回(部分信息)：\n")[-1].strip() if "api返回(部分信息)：\n" in api_output else "[]"
            text_message += f"User: {q}\n"
            text_message += f"Shopping Guide: {a}\n"
            dialog_messages.append({"role": "user", "content": f"User: {q}\n[API Return]:\n{api_output}"})
            dialog_messages.append({"role": "assistant", "content": f"Shopping Guide: {a}"})
    text_message += f"User: {message}"

    #1. extract status
    display_output = "后台进程：\n1. 用户status:\n"
    yield display_output
    user_prompt = '''意图识别Prompt'''
    user_prompt += f"<conversation>\n{text_message}\n</conversation>"
    stream = invoke_model(user_prompt)
    status = ''
    if stream:
        for event in stream:
            # Use chaining of .get() to simplify access to nested data
            delta_content = event.get("chunk", {}).get("bytes")
            if not delta_content:
                continue  # Skip to the next iteration if delta_content is None or empty

            text_segment = json.loads(delta_content.decode()).get('delta', {}).get('text', '')
            if not text_segment:
                continue  # Skip to the next iteration if text_segment is empty

            status += text_segment
            display_output += text_segment
            yield display_output
            
    #2. extract scene
    display_output += "\n\n2. scene信息提取:\n"
    yield display_output
    scene_prompt = '''
    You task is to determine the aim and scene of the User in the last round of the conversation. The aim in scenario information means how would the user use the product, and it should not include the scenario location. If the user does not mention the aim or the scene, the answer should be empty string. You should format the output as a json string, whose keys are "aim" and "scene", without any extra content when answering.
    '''
    scene_prompt += f"<conversation>\n{text_message}\n</conversation>"
    stream = invoke_model(scene_prompt)
    if stream:
        for event in stream:
            # Use chaining of .get() to simplify access to nested data
            delta_content = event.get("chunk", {}).get("bytes")
            if not delta_content:
                continue  # Skip to the next iteration if delta_content is None or empty

            text_segment = json.loads(delta_content.decode()).get('delta', {}).get('text', '')
            if not text_segment:
                continue  # Skip to the next iteration if text_segment is empty

            display_output += text_segment
            yield display_output
        
    # check whether need extract api
    if 'Random Chat' not in status and 'Random Shopping' not in status:
        display_output += "\n\n3. 抽取api:\n"
        yield display_output
        api_messages.append({"role": "user", "content": text_message})
        result = llama_inference(api_messages, 0.3)
        api = ''
        for new_tokens in result:
            api += new_tokens
            display_output += new_tokens
            yield display_output

        api = api.strip()
        print(text_message)
        print(api_messages)
        print(api)

        display_output += "\n\n4. api返回(部分信息)：\n"
        yield display_output
        api_output = request_api(api)
        api_output = MessageToJson(api_output)
        api_output = json.loads(api_output)

        for api in api_output['adList']:
            info = {k: v for k, v in api['skuInfo'].items() if k in used_field}
            if len(api['skuInfo']['skuCommentList'])>0:
                info['User_Comment'] = api['skuInfo']['skuCommentList'][0].get('commentContent','')
            chosen_api_output.append(info)

        display_output += str(chosen_api_output)
        yield display_output
    
        display_output += "\n\n"+splitter+'\n'
        yield display_output

        dialog_messages.append({"role": "user", "content": f"User: {message}\n[API Return]:\n{chosen_api_output}"})
        print(dialog_messages)
        response = llama_inference(dialog_messages, 1, ' Shopping Guide: ')
        for new_tokens in response:
            display_output += new_tokens
            yield display_output
    else:
        display_output += "\n\n"+splitter+'\n'
        yield display_output
        user_prompt = '''You are an intelligent shopping guide. The following is a conversation history between the user and you. Please respond to user's last utterance without any preamble or "Shopping Guide:" in front. '''
        user_prompt += f"<conversation>\n{text_message}\n</conversation>"
        stream = invoke_model(user_prompt, temperature=0.8)
        if stream:
            for event in stream:
                # Use chaining of .get() to simplify access to nested data
                delta_content = event.get("chunk", {}).get("bytes")
                if not delta_content:
                    continue  # Skip to the next iteration if delta_content is None or empty

                text_segment = json.loads(delta_content.decode()).get('delta', {}).get('text', '')
                if not text_segment:
                    continue  # Skip to the next iteration if text_segment is empty

                status += text_segment
                display_output += text_segment
                yield display_output