Notebook di esempio

Per ulteriori informazioni sui passaggi da seguire, vedere Taccuino di esempio: Utilizzare watsonx per gestire le risorse dei modelli di prompt e creare una distribuzione.

Inferenza di un foundation model con un modello di prompt distribuito

L'invio di una richiesta di inferenza a un foundation model distribuito comporta i seguenti passaggi:

1. Configurare l'APIClient. Quando si deduce un template di prompt distribuito, è necessario specificare lo spazio di distribuzione per la distribuzione in cui è ospitato il template di prompt.

   from ibm_watsonx_ai import APIClient, Credentials
   from ibm_watsonx_ai.metanames import GenTextParamsMetaNames
   
   credentials=Credentials(
     url=<URL>,
     api_key=<API-KEY>,
   )
   
   client = APIClient(credentials)
   client.set.default_space(space_id)
   

2. Inoltrare una richiesta di inferenza al modello distribuito.

   In questo esempio viene utilizzato un metodo generate_text e viene specificato il valore della variabile di prompt question .

   
   generated_response = client.deployments.generate_text(
     deployment_id={deployment-id},
     params={
        GenTextParamsMetaNames.PROMPT_VARIABLES: {
            "question": "What plans do you offer?"
        }
     }
     )
   

Distribuzione e deduzione di un modello di prompt

Si può usare la libreria Python per distribuire un modello di prompt e poi fare l'inferenza di un foundation model usando il modello di prompt distribuito. Sono coinvolti i seguenti passi di alto livello. Per i passi completi e per ulteriori opzioni, consultare il blocco note di esempio.

1. Importare e istanziare l'oggetto PromptTemplateManager.

   prompt_mgr = PromptTemplateManager(
     credentials=Credentials(
       api_key=<API-KEY>,
       url=<URL>
     ),
     space_id=<SPACE_ID>
   )
   

2. Definire il modello di richiesta.

   from ibm_watsonx_ai import APIClient
   from ibm_watsonx_ai.foundation_models.prompts import PromptTemplate
   from ibm_watsonx_ai.foundation_models.utils.enums import DecodingMethods
   from ibm_watsonx_ai.metanames import GenTextParamsMetaNames as GenParams
   
   my_credentials = {
     "url": "https://{region}.ml.cloud.ibm.com",
     "apikey": {my-IBM-Cloud-API-key},
   }
   
   client = APIClient(my_credentials)
   
   prompt_template = PromptTemplate(
     name="New prompt",
     model_id=client.foundation_models.TextModels.FLAN_T5_XXL,
     model_params = {GenParams.DECODING_METHOD: DecodingMethods.SAMPLE},
     description="My example",
     task_ids=["generation"],
     input_variables=["object"],
     instruction="Answer the following question",
     input_prefix="Human",
     output_prefix="Assistant",
     input_text="What is {object} and how does it work?",
     examples=[
       ["What is a loan and how does it work?", 
       "A loan is a debt that is repaid with interest over time."]
     ]
   )   
   

3. Memorizzare il modello di prompt nel progetto per generare un ID del modello di prompt.

   stored_prompt_template = prompt_mgr.store_prompt(prompt_template=prompt_template)
   print(f"Asset id: {stored_prompt_template.prompt_id}")
   

4. Caricare il testo nel modello di prompt.

   from ibm_watsonx_ai.foundation_models.utils.enums import PromptTemplateFormats
   
   prompt_input_text = prompt_mgr.load_prompt(
     prompt_id=stored_prompt_template.prompt_id, 
     astype=PromptTemplateFormats.STRING)
   print(prompt_input_text)
   

5. Creare una distribuzione modello di prompt e generare un ID distribuzione.

   meta_props = {
     client.deployments.ConfigurationMetaNames.NAME: "SAMPLE DEPLOYMENT PROMPT TEMPLATE",
     client.deployments.ConfigurationMetaNames.ONLINE: {},
     client.deployments.ConfigurationMetaNames.BASE_MODEL_ID: "ibm/granite-13b-chat-v2"
   }
   
   deployment_details = client.deployments.create(
     artifact_id=stored_prompt_template.prompt_id, 
     meta_props=meta_props
   )
   

6. Importare e istanziare l'oggetto ModelInference da usare per l'inferenza del foundation model, usando il modello di prompt distribuito.

   from ibm_watsonx_ai.foundation_models import ModelInference
   
   deployment_id = deployment_details.get("metadata", {}).get("id")
   
   model_inference = ModelInference(
     deployment_id=deployment_id,
     api_client=client
   )
   

7. Inferenza del foundation model. Assicurarsi di specificare i valori per tutte le variabili di prompt definite nel modello di prompt.

   from ibm_watsonx_ai.foundation_models.utils.enums import DecodingMethods
   
   model_inference.generate_text(
     params={
       "prompt_variables": {"object": "a mortgage"},
       GenParams.DECODING_METHOD: DecodingMethods.GREEDY,
       GenParams.STOP_SEQUENCES: ['\n\n'],
       GenParams.MAX_NEW_TOKENS: 50
     }
   )
   

Utilizzare un modello di prompt per bozzare il testo di prompt per una richiesta di inferenza

L'inferenza di un foundation model utilizzando un modello di prompt non distribuito comporta i seguenti passaggi. Per i passi completi e per ulteriori opzioni, consultare il blocco note di esempio.

1. Elencare tutti i template di prompt disponibili.

   Per ulteriori informazioni, vedere Elenco di tutti i modelli di prompt.

2. Caricare il modello di prompt che si desidera utilizzare. Non è necessario distribuire il modello di prompt. Convertire il template in testo di richiesta.

   Per ulteriori informazioni, vedere Richiesta di caricamento.

   prompt_text = prompt_mgr.load_prompt(prompt_id=stored_prompt_template.prompt_id, astype=PromptTemplateFormats.STRING)
   print(prompt_text)
   

3. Sostituire le variabili di prompt con i valori che si desidera utilizzare.

   filled_prompt_text = prompt_text.format(object='credit card')
   

4. Inviare il testo del prompt compilato a un foundation model per l'inferenza.

   generated_response = model.generate_text(prompt=filled_prompt_input, ...)
   

Argomento principale: Python Python