Esta página se ha traducido con Cloud Translation API.

Desplegar TimesFM en GDC Sandbox

El modelo TimesFM de Google Research es un modelo fundacional para la previsión de series temporales que se ha preentrenado con miles de millones de puntos temporales de muchos conjuntos de datos del mundo real, por lo que puedes aplicarlo a nuevos conjuntos de datos de previsión en muchos dominios.

En esta guía se muestra cómo desplegar TimesFM en el sandbox de GDC y se describen los siguientes objetivos.

Crea un contenedor Docker que ejecute TimesFM.
Despliega el contenedor con las GPUs proporcionadas por la SKU optimizada para IA de GDC Sandbox.
Invoca funciones de TimesFM mediante solicitudes HTTP sencillas.

Antes de empezar

Las GPUs de GDC Sandbox se incluyen en el clúster org-infra.

Para ejecutar comandos en el clúster de infraestructura de la organización, asegúrate de tener el archivo kubeconfig del clúster org-1-infra, tal como se describe en Trabajar con clústeres:
- Configurar y autenticar con la línea de comandos gdcloud
- Genera el archivo kubeconfig del clúster de infraestructura de la organización y asigna su ruta a la variable de entorno KUBECONFIG.
Asegúrate de que el usuario tenga asignado el rol sandbox-gpu-admin en el proyecto sandbox-gpu-project. De forma predeterminada, el rol se asigna al usuario platform-admin. Para asignar el rol a otros usuarios, inicia sesión como platform-admin y ejecuta el siguiente comando:
```
kubectl --kubeconfig ${KUBECONFIG} create rolebinding ${NAME} --role=sandbox-gpu-admin \
--user=${USER} --namespace=sandbox-gpu-project
```
Configura el repositorio de Artifact Registry tal como se describe en el artículo Usar Artifact Registry e inicia sesión para poder enviar y extraer imágenes del registro de artefactos.

Desplegar el modelo TimesFM

El despliegue se coordina mediante un conjunto de archivos de configuración de Kubernetes (manifiestos YAML), cada uno de los cuales define un componente o servicio específico.

Crea una secuencia de comandos de Python basada en Flask app.py con funciones predict para hacer previsiones de series temporales y timeseries para generar una visualización basada en los datos de prueba.

  from flask import Flask, jsonify, request
  import numpy as np
  import pandas as pd
  from sklearn.preprocessing import StandardScaler

  # Initialize Flask application
  app = Flask(__name__)

  # Sample route to display a welcome message
  @app.route('/')
  def home():
      return "Welcome to TimesFM! Use the API to interact with the app."

  # Example route for predictions (TimesFM might do time-series forecasting or music recommendations)
  @app.route('/predict', methods=['POST'])
  def predict():
      data = request.get_json()

      # Ensure the data is in the right format
      if 'features' not in data:
          return jsonify({'error': 'No features provided'}), 400

      # For this example, assume 'features' is a list of numbers that need to be scaled
      features = data['features']
      features = np.array(features).reshape(1, -1)

      # Dummy model: Apply standard scaling (you would use an actual model here)
      scaler = StandardScaler()
      scaled_features = scaler.fit_transform(features)

      # You would normally load your model here (e.g., using pickle or joblib)
      # For simplicity, let's just return the scaled features as a placeholder for prediction
      result = scaled_features.tolist()

      return jsonify({'scaled_features': result})

  # Example of a route for data visualization or analysis
  @app.route('/timeseries', methods=['GET'])
  def timeseries_analysis():
      # Generate a dummy time series data (replace with actual data)
      time_series_data = pd.Series(np.random.randn(100), name="Random Data")

      # Example analysis: compute simple moving average
      moving_avg = time_series_data.rolling(window=10).mean()

      return jsonify({
          'time_series': time_series_data.tolist(),
          'moving_average': moving_avg.tolist()
      })

  # Run the app
  if __name__ == '__main__':
      app.run(debug=True, host='0.0.0.0', port=5000)

Crea un Dockerfile con timesfm instalado invocando la aplicación.

 # Use a base image with Python installed
 FROM python:3.11-slim
 # Set the working directory inside the container
 WORKDIR /app
 # Copy the requirements.txt (if any) and install dependencies
 COPY requirements.txt .
 RUN pip install --no-cache-dir numpy pandas timesfm huggingface_hub jax pytest flask scikit-learn

 # Copy the rest of the code into the container
 COPY . .

 # Expose the necessary port (default 5000 or whatever your app uses)
 EXPOSE 5000

 # Define the entrypoint for the container
 CMD ["python", "app.py"] # Replace with the correct entry script for TimesFM

Crea la imagen de Docker y súbela al repositorio de Artifact Registry.

docker build -t timesfm .
docker tag timesfm "REGISTRY_REPOSITORY_URL"/timesfm:latest
docker push "REGISTRY_REPOSITORY_URL"/timesfm:latest

Haz los cambios siguientes:

REGISTRY_REPOSITORY_URL: URL del repositorio.

Crea un secreto para guardar las credenciales de Docker.


export SECRET="DOCKER_REGISTRY_SECRET"
export DOCKER_TEST_CONFIG=~/.docker/config.json 
kubectl --kubeconfig ${KUBECONFIG} create secret docker-registry ${SECRET} --from-file=.dockerconfigjson=${DOCKER_TEST_CONFIG} -n sandbox-gpu-project

Haz los cambios siguientes:

DOCKER_REGISTRY_SECRET Nombre del secreto.

Crea un archivo timesfm-deployment.yaml para implementar timesfm.

El despliegue del servidor timesfm solicita una GPU.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: timesfm-deployment
  namespace: sandbox-gpu-project
  labels:
    app: timesfm
spec:
  replicas: 1 # You can scale up depending on your needs
  selector:
    matchLabels:
      app: timesfm
  template:
    metadata:
      labels:
        app: timesfm
    spec:
      containers:
      - name: timesfm
        image: REGISTRY_REPOSITORY_URL/timesfm:latest
        ports:
        - containerPort: 5000
        resources:
          requests:
            nvidia.com/gpu-pod-NVIDIA_H100_80GB_HBM3: 1  # Request 1 GPU
          limits:
            nvidia.com/gpu-pod-NVIDIA_H100_80GB_HBM3: 1  # Limit to 1 GPU
        env:
        - name: ENV
          value: "production"
      imagePullSecrets:
      - name: docker-registry-secret

Haz los cambios siguientes:

REGISTRY_REPOSITORY_URL: URL del repositorio.
DOCKER_REGISTRY_SECRET: nombre del secreto de Docker.

Crea un archivo timesfm-service.yaml para exponer el servidor timesfm internamente.

apiVersion: v1
kind: Service
metadata:
  name: timesfm-service
spec:
  selector:
    app: timesfm
  ports:
    - protocol: TCP
      port: 80 # External port exposed
      targetPort: 5000 # Internal container port for Flask
  type: LoadBalancer # Use NodePort for internal access

Aplica los archivos de manifiesto.

kubectl --kubeconfig ${KUBECONFIG} apply -f timesfm-deployment.yaml
kubectl --kubeconfig ${KUBECONFIG} apply -f timesfm-service.yaml

Asegúrate de que los pods de TimesFM se estén ejecutando.

kubectl --kubeconfig ${KUBECONFIG} get deployments timesfm-deployment -n sandbox-gpu-project
kubectl --kubeconfig ${KUBECONFIG} get service timesfm-service -n sandbox-gpu-project

Crea una política de red de proyecto para permitir el tráfico entrante de direcciones IP externas.

kubectl --kubeconfig ${KUBECONFIG} apply -f - <<EOF
apiVersion: networking.global.gdc.goog/v1
kind: ProjectNetworkPolicy
metadata:
  namespace: sandbox-gpu-project
  name: allow-inbound-traffic-from-external
spec:
  policyType: Ingress
  subject:
    subjectType: UserWorkload
  ingress:
  - from:
    - ipBlock:
        cidr: 0.0.0.0/0
EOF

Identifica la IP externa del servicio TimesFM ejecutando el siguiente comando. Anota este valor para usarlo en pasos posteriores, donde lo sustituirás por TIMESFM_END_POINT.
```
  kubectl --kubeconfig ${KUBECONFIG} get service timesfm-service \
        -n sandbox-gpu-project -o jsonpath='{.status.loadBalancer.ingress[*].ip}'
```

Prueba el servicio.

Para obtener una predicción, envía datos al servicio mediante un comando curl. Sustituye TIMESFM_END_POINT por la dirección real del servicio y por los valores de entrada de las características. De esta forma, se invoca la función predict definida en app.py, que manipulará los datos de entrada y los devolverá en formato JSON.
```
curl -X POST http://TIMESFM_END_POINT/predict -H "Content-Type: application/json" -d '{"features": [1.2, 3.4, 5.6]}'
```
Envía una solicitud curl a /timeseries para ver un ejemplo de visualización de datos con datos generados aleatoriamente. De esta forma, se invoca la función de serie temporal definida en app.py, que genera una serie temporal aleatoria y realiza un análisis de media móvil en ella.
```
curl http://TIMESFM_END_POINT/timeseries
```

Desplegar TimesFM en GDC Sandbox Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Desplegar el modelo TimesFM

Prueba el servicio.

Desplegar TimesFM en GDC Sandbox