Exigences de la fonction de score

• Il existe deux façons d'ajouter l'objet de fonction score :
  • Explicitement, par l'utilisateur
  • implicitement, par la méthode utilisée pour sauvegarder la fonction Python en tant qu'actif dans le référentiel watsonx.ai Runtime
• La fonction " score peut accepter un seul paramètre d'entrée JSON ou deux paramètres : la charge utile et le jeton du porteur.
• La fonction score doit renvoyer un objet sérialisable JSON (par exemple, des dictionnaires ou des listes).

Évaluation des entrées d'évaluation

• Le contenu d'entrée de score doit inclure un tableau portant le nom values, comme indiqué dans cet exemple de schéma. Le paramètre input_data est obligatoire dans le contenu. Le paramètre input_data peut également inclure des paires nom-valeur supplémentaires.

  {"input_data": [{
     "values": [["Hello world!"]]
                 }]
  }
  

• La charge utile d'entrée de notation doit être transmise en tant que valeur de paramètre d'entrée pour " score. Ainsi, vous pouvez vous assurer que la valeur du paramètre d'entrée score est traitée en conséquence dans score.

• La charge d'entrée d'évaluation doit satisfaire les exigences d'entrée de la fonction Python concernée.

• La charge d'entrée de score doit inclure un tableau qui correspond à l'exemple de schéma de données d'entrée.

 {"input_data": [{
    "values": [["Hello, world!"]]
                }]
 }

Exemple de code Python (charge utile et jeton)

#wml_python_function
def my_deployable_function():

    def score(payload, token):

        message_from_input_payload = payload.get("input_data")[0].get("values")[0][0]
        response_message = "Received message - {0}".format(message_from_input_payload)

        # Score using the pre-defined model
        score_response = {
            'predictions': [{'fields': ['Response_message_field'],
                             'values': [[response_message]]
                            }]
        }
        return score_response

    return score

score = my_deployable_function()

Tester votre fonction Python

Voici comment vous pouvez tester votre fonction Python:

input_data = { "input_data": [{ "fields": [ "message" ],
                                "values": [[ "Hello, world!" ]]
                               }
                              ]
             }
function_result = score( input_data )
print( function_result )

Il renvoie le message "Hello, world !".

Création de fonctions déployables via l'API REST

Pour les API REST, la fonction Python étant téléchargée directement via un fichier, ce dernier doit déjà contenir la fonction score . Toute importation unique qui doit être effectuée pour être utilisée ultérieurement dans la fonction score peut être effectuée dans la portée globale du fichier. Lorsque ce fichier est déployé en tant que fonction Python, les importations uniques disponibles dans la portée globale sont exécutées au cours du déploiement et sont simplement réutilisées avec chaque demande de prévision.

Exemple de fichier de fonctionscore :

Score function.py
---------------------
def score(input_data):
    return {'predictions': [{'values': [['Just a test']]}]}

Exemple de fonction score avec d'importation unique :

import subprocess
subprocess.check_output('pip install gensim --user', shell=True)
import gensim

def score(input_data):
    return {'predictions': [{'fields': ['gensim_version'], 'values': [[gensim.__version__]]}]}

Création de fonctions déployables via le client Python

Pour conserver une fonction Python en tant qu'actif, le client Python utilise la méthode wml_client.repository.store_function. Vous pouvez persister une fonction Python de deux manières :

• Par le biais d'un fichier contenant la fonction Python
• Par le biais de l'objet fonctionnel

def my_deployable_function():

    import subprocess
    subprocess.check_output('pip install gensim', shell=True)
    import gensim

    def score(input_data):
        import
        message_from_input_payload = payload.get("input_data")[0].get("values")[0][0]
        response_message = "Received message - {0}".format(message_from_input_payload)

        # Score using the pre-defined model
        score_response = {
            'predictions': [{'fields': ['Response_message_field', 'installed_lib_version'],
                             'values': [[response_message, gensim.__version__]]
                            }]
        }
        return score_response

    return score

function_meta = {
    client.repository.FunctionMetaNames.NAME:"test_function",
    client.repository.FunctionMetaNames.SOFTWARE_SPEC_ID: sw_spec_id
}
func_details = client.repository.store_function(my_deployable_function, function_meta)

score = my_deployable_function()