Docs
...
Downloading a custom foundation model and setting up storage

Scaricare un foundation model personalizzato e impostare l'archiviazione

Ultimo aggiornamento: 28 nov 2024
Scaricare un foundation model personalizzato e impostare l'archiviazione

Per distribuire un foundation model personalizzato per l'inferenza con watsonx.ai, è necessario caricare il modello su un archivio di oggetti nel cloud. È possibile utilizzare il bucket nell'IBM Cloud Object Storage associato allo spazio di distribuzione o un cloud storage esterno.

Scaricare i modelli dai repository pubblici

È possibile utilizzare i repository pubblici dei modelli per scaricare i modelli di fondazione. I depositi di modelli pubblici potrebbero richiedere la creazione di un account prima di scaricare i modelli.

Ad esempio, è possibile utilizzare Hugging Face, un repository pubblico di modelli, per scaricare modelli di fondazione personalizzati per il proprio caso d'uso. È necessario creare un accountHugging Face per scaricare il modello da Hugging Face.

Download di un modello

Questi passaggi dimostrano come scaricare un foundation model personalizzato utilizzando un modello Hugging Face. Seguire questi passaggi per scaricare un foundation model personalizzato utilizzando l'interfaccia a riga di comando di Hugging Face:

  1. Installare il pacchetto huggingface-cli con pip:

    pip install -U "huggingface_hub[cli]"

  2. Verificare che huggingface-cli sia impostato correttamente:

    huggingface-cli --help

  3. Configurare le variabili d'ambiente necessarie:

    export HF_TOKEN="<your Hugging Face token>"
export MODEL_NAME="<name of the model>"
export MODEL_DIR="<directory to download the model to>"

  4. Impostare una directory sul disco locale in cui scaricare il modello:

    mkdir ${MODEL_DIR}

  5. Accedere all'interfaccia a riga di comando di Hugging Face e scaricare il modello:

    huggingface-cli login --token ${HF_TOKEN}
huggingface-cli download ${MODEL_NAME} --local-dir ${MODEL_DIR} --cache-dir ${MODEL_DIR}

Conversione di un modello nel formato richiesto

Prima di aggiungere un modello all'archiviazione a oggetti, è necessario assicurarsi che il modello sia compatibile con lo standard Text Generation Inference (TGI) e che sia costruito con un'architettura e un tipo di modello supportati. Per ulteriori informazioni, vedere Pianificazione della distribuzione di un foundation model personalizzato.

Se il modello è stato messo a punto con InstructLab, la conversione al formato safetensors potrebbe non essere possibile:

  • I modelli messi a punto in ambiente Linux richiedono una conversione.
  • I modelli messi a punto su Mac non possono essere convertiti.
  • I modelli che sono stati messi a punto e salvati nel formato .gguf (in qualsiasi ambiente) non possono essere convertiti.

Per convertire un modello messo a punto con InstructLab, utilizzare il codice in Questo repository per convertire il modello.

Per tutti gli altri modelli, se il vostro modello non è nel formato safetensors e non contiene il file tokenizer.json, seguite questi passaggi per convertire il vostro modello nel formato richiesto. Altrimenti, passare alla sezione Impostazione dell'archiviazione di oggetti nel cloud e aggiunta del modello.

  1. Installare podman Desktop sul computer locale.

  2. Estrarre l'immagine TGIS:

    export TGIS_IMAGE="quay.io/modh/text-generation-inference:rhoai-2.8-58cac74"
podman pull ${TGIS_IMAGE}

  3. Convertire il modello:

    container_id=$(podman run -itd --privileged -u 0 -v ${MODEL_DIR}:/tmp ${TGIS_IMAGE} tail -f /dev/null)
podman exec -it ${container_id} bash -c 'export MODEL_PATH=/tmp ; text-generation-server convert-to-safetensors ${MODEL_PATH} ; text-generation-server convert-to-fast-tokenizer ${MODEL_PATH}'

Caricamento del modello sul cloud object storage

È possibile caricare il modello in un bucket dell'IBM Cloud Object Storage o in qualsiasi altro bucket di archiviazione, come Amazon Simple Storage ServiceAmazon S3). Ecco alcuni degli archivi di oggetti in cloud offerti da IBM:

Caricare il modello su IBM Cloud Object Storage utilizzando l'IBM Aspera Transfer SDK

Prerequisiti:

  • Scaricare il IBM Aspera Transfer SDK. Fate clic su questo link.
  • Impostare queste variabili d'ambiente:
    • Percorso di IBM Aspera Transfer SDK come path-to-aspera
    • Percorso della cartella con il modello come path-to-model-folder
    • Nome del secchio in cui trasferire il modello come bucket-name
    • La chiave API per l'archiviazione degli oggetti nel cloud come api-key
    • L'ID dell'istanza del servizio di cloud object storage come cos-service-instance-id
    • L'endpoint del servizio di memorizzazione degli oggetti nel cloud come cos-service-endpoint

Utilizzate questo script per caricare il vostro modello su IBM Cloud Object Storage utilizzando il IBM Aspera Transfer SDK:

import grpc
import sys
import time, subprocess
import json
import os.path
import os.environ

import transfer_pb2 as transfer_manager
import transfer_pb2_grpc as transfer_manager_grpc

path_to_aspera = os.environ['path-to-aspera']
sys.path.append(f'{path_to_aspera}/connectors/python')

def start_aspera_daemon():
    config_path = f'/{path_to_aspera}/config/asperatransferd.json'
    daemon_path = f'/{path_to_aspera}/bin/asperatransferd'

    # Start the daemon
    process = subprocess.Popen([daemon_path, '--config', config_path])
    print(f"Started Aspera Transfer SDK daemon with PID {process.pid}")
    time.sleep(5)  # Increased wait time for the daemon to start properly

    return process

def run():
    try:
        # create a connection to the transfer manager daemon
        client = transfer_manager_grpc.TransferServiceStub(grpc.insecure_channel('localhost:55002'))

        # create transfer spec
        transfer_spec = {
            "session_initiation":{
                "icos":{
                    "bucket": os.environ['bucket-name'],
                    "api_key": os.environ['cos-api-key'],
                    "ibm_service_instance_id": os.environ['cos-service-instance-id'],
                    "ibm_service_endpoint": os.environ['cos-service-endpoint'] # example: https://s3.us-south.cloud-object-storage.appdomain.cloud
                }
            },
            "direction": "send",
            "title": "COS Upload",
            "assets": {
                "destination_root": "/model",
                "paths": [
                    {
                        "source": os.environ['path-to-model-folder']
                    }
                ]
            }
        }
        transfer_spec = json.dumps(transfer_spec)

        # create a transfer request
        transfer_request = transfer_manager.TransferRequest(
            transferType=transfer_manager.FILE_REGULAR,
            config=transfer_manager.TransferConfig(),
            transferSpec=transfer_spec
        )

        # send start transfer request to transfer manager daemon
        try:
            transfer_response = client.StartTransfer(transfer_request)
            transfer_id = transfer_response.transferId
            print(f"Transfer started with id {transfer_id}")
        except grpc.RpcError as e:
            print(f"Error starting transfer: {e.code()}: {e.details()}")
            return
        # monitor transfer status
        try:
            # Monitor transfer status
            while True:
                response = client.MonitorTransfers(
                    transfer_manager.RegistrationRequest(
                        filters=[transfer_manager.RegistrationFilter(
                            transferId=[transfer_id]
                        )]))
                for transfer_info in response:
                    print(f"Transfer info: {transfer_info}")

                    # Check transfer status in response
                    status = transfer_info.status
                    if status == transfer_manager.FAILED or status == transfer_manager.COMPLETED:
                        print(f"Transfer finished with status {status}")
                        return

                # Wait before polling again
                time.sleep(5)
        except grpc.RpcError as e:
            print(f"Error monitoring transfer: {e.code()}: {e.details()}")
    except Exception as e:
        print(f"Unexpected error: {str(e)}", file=sys.stderr)


if __name__ == '__main__':
    # Start the Aspera Transfer SDK daemon
    daemon_process = start_aspera_daemon()

    # Run the file transfer
    run()

    # Optionally, stop the Aspera daemon after transfer
    daemon_process.terminate()
    print("Aspera Transfer SDK daemon stopped")

Caricare il modello su IBM Cloud Object Storage utilizzando strumenti forniti da terze parti

È possibile utilizzare software di terze parti per caricare il modello su IBM Cloud Object Storage.

Seguite questi passi di esempio per caricare il vostro modello su IBM Cloud Object Storage usando l'interfaccia a riga di comando Amazon Web Services:

  1. Installare l'interfaccia a riga di comando Amazon Web Services con pip:

    pip install awscli

  2. Impostare le variabili d'ambiente richieste:

    export AWS_ACCESS_KEY_ID="<your access key>"
export AWS_SECRET_ACCESS_KEY="<your secret access key>"
export ENDPOINT="<s3 endpoint URL>"
export BUCKET_NAME="<name of the bucket to upload the model>"
MODEL_FOLDER=${MODEL_NAME//\//-} # The name of the created folder is based on model name.
export MODEL_FOLDER=${MODEL_FOLDER//./-} # Just in case, we're removing slashes and dots from it.

  3. Aggiungere il modello al bucket IBM Cloud Object Storage utilizzando l'interfaccia a riga di comando Amazon Web Services:

    aws --endpoint-url ${ENDPOINT} s3 cp ${MODEL_DIR} s3://${BUCKET_NAME}/${MODEL_FOLDER}/ --recursive --follow-symlinks

Passo successivo

Creazione di una risorsa modello

Argomento principale: Pianificazione della distribuzione di un foundation model personalizzato