エンドツーエンドのコードファースト生成AIエクスペリメント¶

import datarobot as dr
from datarobot.models.genai.vector_database import VectorDatabase
from datarobot.models.genai.vector_database import ChunkingParameters
from datarobot.enums import PromptType
from datarobot.enums import VectorDatabaseEmbeddingModel
from datarobot.enums import VectorDatabaseChunkingMethod
from datarobot.models.genai.playground import Playground
from datarobot.models.genai.llm import LLMDefinition
from datarobot.models.genai.llm_blueprint import LLMBlueprint
from datarobot.models.genai.llm_blueprint import VectorDatabaseSettings
from datarobot.models.genai.chat import Chat
from datarobot.models.genai.chat_prompt import ChatPrompt
from datarobot.models.genai.vector_database import CustomModelVectorDatabaseValidation
from datarobot.models.genai.comparison_chat import ComparisonChat
from datarobot.models.genai.comparison_prompt import ComparisonPrompt
from datarobot.models.genai.custom_model_llm_validation import CustomModelLLMValidation

endpoint="https://app.datarobot.com/api/v2"
token="<ADD_VALUE_HERE>"
dr.Client(endpoint=endpoint, token=token)

use_case = dr.UseCase.create()

# this can be updated with any public URL that is pointing to a .zip file
# in the expected format
dataset_url = "https://s3.amazonaws.com/datarobot_public_datasets/genai/pirate_resumes.zip"

# We will use a vector database with our GenAI models. Let's upload a dataset with our documents.
# If you wish to use a local file as dataset, change this to
# `dataset = dr.Dataset.create_from_file(local_file_path)`
dataset = dr.Dataset.create_from_url(dataset_url)

chunking_parameters = ChunkingParameters(
    embedding_model=VectorDatabaseEmbeddingModel.JINA_EMBEDDING_T_EN_V1,
    chunking_method=VectorDatabaseChunkingMethod.RECURSIVE,
    chunk_size=128,
    chunk_overlap_percentage=25,
    separators=[],
)
vdb = VectorDatabase.create(dataset.id, chunking_parameters, use_case)

vdb = VectorDatabase.get(vdb.id)
assert vdb.execution_status == "COMPLETED"

playground = Playground.create(name="New playground for example", use_case=use_case)

llms_dict = LLMDefinition.list(use_case=use_case)
print(llms_dict)

llms = LLMDefinition.list(use_case=use_case, as_dict=False)
gpt = llms[0]

print([setting.to_dict() for setting in gpt.settings])

llm_settings = {
    "system_prompt": (
        "You are a pirate who begins each response with 'Arrr' "
        "and ends each response with 'Matey!'"
    ),
    "max_completion_length": 256,  # Let's ask for short responses
    "temperature": 2.0,  # With a high degree of variability
}
# PromptType.ONE_TIME_PROMPT is an alternative if you don't wish
# for previous chat prompts (history) to be included in each subsequent prompt
prompting_strategy = PromptType.CHAT_HISTORY_AWARE

vector_database_settings = VectorDatabaseSettings(
    max_documents_retrieved_per_prompt=2,
    max_tokens=128,
)

llm_blueprint = LLMBlueprint.create(
    playground=playground,
    name="GPT",
    llm=gpt,
    prompt_type=prompting_strategy,
    llm_settings=llm_settings,
    vector_database=vdb,
    vector_database_settings=vector_database_settings,
)

chat = Chat.create(
    name="Resume review chat with a pirate",
    llm_blueprint=llm_blueprint
)

prompt1 = ChatPrompt.create(
    chat=chat,
    text="How can a pirate resume be evaluated?",
    wait_for_completion=True,
)
print(prompt1.result_text)

print(prompt1.result_metadata.error_message)

llm_settings["max_completion_length"] = 1024
prompt2 = ChatPrompt.create(
    text="Please answer the previous question again.",
    chat=chat,
    llm_settings=llm_settings,
    wait_for_completion=True,
)
print(prompt2.result_text)

llm_blueprint = LLMBlueprint.get(llm_blueprint.id)
print(llm_blueprint.llm_settings)

llm_settings["temperature"] = 0.8
prompt3 = ChatPrompt.create(
    text="Please summarize the best pirate resume.",
    chat=chat,
    llm_settings=llm_settings,
    wait_for_completion=True,
)
print(prompt3.result_text)

print([citation.text for citation in prompt3.citations])

new_llm_blueprint = LLMBlueprint.create_from_llm_blueprint(llm_blueprint, name="new blueprint")

llm_settings["system_prompt"] = "You are an AI assistant who helps to evaluate resumes."
new_llm_blueprint = new_llm_blueprint.update(
    llm_settings=llm_settings,
    remove_vector_database=True,
)

external_vdb_id = "<ADD_VALUE_HERE>"

# Now create a vector database
external_model_vdb = VectorDatabase.get(
    vector_database_id=external_vdb_id
)
assert external_model_vdb.execution_status == "COMPLETED"

external_llm_validation_id = "<ADD_VALUE_HERE>"

external_llm_validation = CustomModelLLMValidation.get(validation_id=external_llm_validation_id)
assert external_llm_validation.validation_status == "PASSED"

custom_model_llm_blueprint = LLMBlueprint.create(
    playground=playground,
    name="custom model LLM with custom model vdb",
    llm="custom-model",
    llm_settings={
        "validation_id": external_llm_validation.id,
        # NOTE - update this value based on the context size in tokens
        # of the external LLM that you are deploying
        "external_llm_context_size": 4096
    },
    vector_database=external_model_vdb,
)

comparison_chat = ComparisonChat.create(
    name="Resume review comparison chat with a pirate",
    playground=playground
)

comparison_prompt = ComparisonPrompt.create(
    llm_blueprints=[llm_blueprint, new_llm_blueprint, custom_model_llm_blueprint],
    text="Summarize the best resume",
    comparison_chat=comparison_chat,    
    wait_for_completion=True,
)
print([result.result_text for result in comparison_prompt.results])