DEV Community: Jessica Cardoso

🌩️ [pt-BR] Ray no k8s: Executando o ray localmente no k3d

Jessica Cardoso — Mon, 14 Aug 2023 23:05:00 +0000

Continuando, nessa seção iremos executar uma aplicação extremamente básica. Escrevemos um código que calcula o quadrado de números de 1 até 10, antes de computar o quadrado pausamos a execução por alguns segundos para simular um processo demorado.

2.1 Código sem paralelismo

Abaixo o código que usamos, colocamos ele em um arquivo com o nome script.py.

import time


def square(x):
    time.sleep(x * 0.5)
    return {
        "numero": x,
        "quadrado": x * x
    }

start = time.time()
print([square(x+1) for x in range(10)])
print(f"Tarefa executou em {time.time() - start:.2f} segundos")

Executamos o código que finalizou em 27.53 segundos, um tempo bem aceitável:

python script.py
# [{'numero': 1, 'quadrado': 1}, {'numero': 2, 'quadrado': 4}, {'numero': 3, 'quadrado': 9}, {'numero': 4, 'quadrado': 16}, {'numero': 5, 'quadrado': 25}, {'numero': 6, 'quadrado': 36}, {'numero': 7, 'quadrado': 49}, {'numero': 8, 'quadrado': 64}, {'numero': 9, 'quadrado': 81}, {'numero': 10, 'quadrado': 100}]
# Tarefa executou em 27.53 segundos

2.2 Usando múltiplas CPUs localmente

Colocar esse código para usar os processadores é bem fácil, basta alguns ajustes:

import time
import ray # importar módulo do ray


def square(x):
    time.sleep(x * 0.5)
    return {
        "numero": x,
        "quadrado": x * x
    }

# criar uma task para o ray
@ray.remote
def square_task(x): 
    return square(x)

ray.init() # inicializar o ray
start = time.time()
# print([square(x+1) for x in range(10)]) # antes era assim
print(ray.get([square_task.remote(x+1) for x in range(10)]))
print(f"Tarefa executou em {time.time() - start:.2f} segundos")

Fizemos poucas mudanças no código, mas conseguimos diminuir o tempo de execução (tempo poderá ser diferente pois varia de acordo com o equipamento). Abaixo podemos ver que o tempo de execução caiu para 5s, a máquina que executei tem mais de 6 cores.

python script_ray.py
# 2023-07-30 21:18:46,499 INFO worker.py:1612 -- Started a local Ray instance. View the dashboard at 127.0.0.1:8265
# [{'numero': 1, 'quadrado': 1}, {'numero': 2, 'quadrado': 4}, {'numero': 3, 'quadrado': 9}, {'numero': 4, 'quadrado': 16}, {'numero': 5, 'quadrado': 25}, {'numero': 6, 'quadrado': 36}, {'numero': 7, 'quadrado': 49}, {'numero': 8, 'quadrado': 64}, {'numero': 9, 'quadrado': 81}, {'numero': 10, 'quadrado': 100}]
# Tarefa executou em 5.06 segundos

2.3 Usando o cluster local do k3d

Primeiro prosseguimos com a instalação do KubeRay operator.

helm repo add kuberay https://ray-project.github.io/kuberay-helm/
helm install kuberay-operator kuberay/kuberay-operator --version 0.6.0

Para confirmar se o operador está em execução, verificamos se o pod está pronto.

kubectl get pods | grep kuberay-operator
# kuberay-operator-54f657c8cf-p2lh8           1/1     Running   2 (48s ago)   20h

Em seguida, criamos um cluster do ray copiando o yaml exemplo da documentação fazendo pequenas mudanças. Colocamos 5 pods e menos recursos de memória e cpu, além de atribuirmos o head e os workers a nós específicos.

apiVersion: ray.io/v1alpha1
kind: RayCluster
metadata:
  labels:
    controller-tools.k8s.io: "1.0"
  name: raycluster-teste
spec:
  rayVersion: '2.6.1'
  headGroupSpec:
    serviceType: ClusterIP
    rayStartParams:
      dashboard-host: '0.0.0.0'
      block: 'true'
    template:
      spec:
        nodeSelector:
          type: node1 # definimos o head no nó 1
        containers:
        - name: ray-head
          image: rayproject/ray:2.6.1
          imagePullPolicy: Always
          resources: # mudamos para usar menos recursos
            limits: 
              cpu: "1"
              memory: "1Gi"
              ephemeral-storage: "1Gi"
            requests:
              cpu: "1"
              memory: "1Gi"
              ephemeral-storage: "1Gi"
          lifecycle:
            preStop:
              exec:
                command: ["/bin/sh","-c","ray stop"]
  workerGroupSpecs: # definimos para criar 5 pods
  - replicas: 5
    minReplicas: 5
    maxReplicas: 5
    rayStartParams:
      block: 'true'
    template:
      spec:
        nodeSelector: 
          type: node2 # workers no nó 2
        containers:
        - name: ray-worker
          image: rayproject/ray:2.6.1
          resources: # mudamos para usar menos recursos
            limits:
              cpu: "1"
              memory: "1Gi"
              ephemeral-storage: "1Gi"
            requests:
              cpu: "1"
              memory: "1Gi"
              ephemeral-storage: "1Gi"
          lifecycle:
            preStop:
              exec:
                command: ["/bin/sh","-c","ray stop"]
        - name: init-myservice
          image: busybox:1.28
          command: ['sh', '-c', "until nslookup $RAY_IP.$(cat /var/run/secrets/kubernetes.io/serviceaccount/namespace).svc.cluster.local; do echo waiting for myservice; sleep 2; done"]

Após aplicar o comando kubectl apply -f ray-cluster.yaml, verificamos se todos os pods subiram com sucesso. Abaixo vemos os pods do ray em execução.

kubectl get pods
# NAME                                        READY   STATUS    RESTARTS   AGE
# kuberay-operator-54f657c8cf-52gsk           1/1     Running   0          7m46s
# raycluster-teste-head-mkzr5                 1/1     Running   0          4m6s
# raycluster-teste-worker-large-group-gns8w   1/1     Running   0          4m6s
# raycluster-teste-worker-large-group-cf2br   1/1     Running   0          4m6s
# raycluster-teste-worker-large-group-kl5ln   1/1     Running   0          4m6s
# raycluster-teste-worker-large-group-sslmb   1/1     Running   0          4m6s
# raycluster-teste-worker-large-group-ht64t   1/1     Running   0          4m6s

Conforme recomendação da documentação do k3d, expomos a aplicação do ray ao criar um Ingress.

# verificar nome do serviço do ray
kubectl get services | grep raycluster
# raycluster-teste-head-svc   ClusterIP   10.43.99.42    <none>        10001/TCP,8265/TCP,8080/TCP,6379/TCP,8000/TCP   25m

# criar ingress
kubectl apply -f - << END
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mycluster-ingress
  annotations:
    ingress.kubernetes.io/ssl-redirect: "false"
spec:
  rules:
  - http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: raycluster-teste-head-svc # serviço do ray
            port:
              number: 8265 # porta do serviço do ray
END

Por fim, vamos conectar nossa aplicação ao cluster. Na documentação do ray é recomendado utilizar Ray Jobs para executar uma aplicação em um cluster. Assim, utilizamos o seguinte comando no mesmo diretório do script.py, não precisamos alterar o código em si:

ray job submit --address http://localhost:8265 --working-dir . -- python script.py

Podemos notar que com 5 workers, conseguimos processar a aplicação em 7 segundos. Além disso, vimos que para executar o mesmo código local no cluster basta usar os Ray Jobs.

Limpeza

Deletar cluster do ray

Para apagar o cluster que criamos nesse exemplo, use o comando abaixo:

kubectl delete -f ray-cluster.yaml
# Pode levar um tempo para deletar, verifique com o `kubectl get pods`

Deletar o operator do kubernetes

Normalmente deixaríamos o operador executando para poder subir outros clusters do ray, mas para deletar o recurso usamos o comando abaixo:

# desinstalar o operator
helm uninstall kuberay-operator
# deletar o ingress que nomeamos como `mycluster-ingress`
kubectl delete ingress mycluster-ingress

Deletar o cluster local do k3d

Por fim, se não desejarmos mais fazer experimentos locais no kubernetes podemos deletar nosso cluster do k3d:

k3d cluster delete --config k3d-config.yml

Esse tutorial foi parte do meu estudo explorando as documentações do Ray e do k3d.

⛴️[pt-BR] Ray no k8s - Criando cluster com k3d

Jessica Cardoso — Mon, 14 Aug 2023 02:51:22 +0000

Foto de Growtika na Unsplash

Motivação

Recentemente, estive buscando meios de executar aplicações do python paralelamente. Eu costumava usar a biblioteca multiprocessing para paralelizar minhas aplicações. Entretanto, o multiprocessing é focado em paralelizar processos na máquina local e eu precisava executar no kubernetes, após algumas buscas encontrei o Ray.

Assim, nesse tutorial, apresento alguns dos passos que segui para configurar o Ray em um cluster local do kubernetes. A primeira parte é focada na configuração do cluster com o k3d e a segunda em usar esse cluster via Ray.

1. Preparando ambiente

Para começar, precisamos ter as seguintes ferramentas instaladas:

1.1 Configuração base

O sistema operacional usado foi o Ubuntu 22.04 com um ambiente virtual python na versão 3.10. Já a versão do kubectl usada foi a v1.27.3.

docker --version
# Docker version 24.0.3, build 3713ee1

helm version --short
# v3.12.1+gf32a527

kubectl version --client --output=yaml
# clientVersion:
#   buildDate: "2023-06-14T09:53:42Z"
#   compiler: gc
#   gitCommit: 25b4e43193bcda6c7328a6d147b1fb73a33f1598
#   gitTreeState: clean
#   gitVersion: v1.27.3
#   goVersion: go1.20.5
#   major: "1"
#   minor: "27"
#   platform: linux/amd64
# kustomizeVersion: v5.0.1

k3d --version
# k3d version v5.5.1
# k3s version v1.26.4-k3s1 (default)

python --version
# Python 3.10.12

ray --version
# ray, version 2.6.1

1.2 Criando cluster local do kubernetes

Nós definimos um arquivo de configuração para subir o cluster com o k3d. Segundo a documentação, os atributos apiVersion e kind são os únicos obrigatórios, ambos se referem as características do arquivo de configuração em si.

apiVersion: k3d.io/v1alpha5 # versão mais recente no momento
kind: Simple 
metadata:
    name: mycluster # nome do nosso cluster (k3d-mycluster)
servers: 1  # quantidade de servidores
agents: 2  # quantidade de nós que serão criados
image: rancher/k3s:v1.26.4-k3s1 # versão do k3s a ser usada
ports: # mapear as portas dos nós do container para o host (https://k3d.io/v5.5.1/usage/exposing_services/)
  - port: 8265:80
    nodeFilters: 
      - loadbalancer
options:
  k3s:
    nodeLabels: # adiciona rótulos aos nós do cluster
      - label: type=node1
        nodeFilters:
          - agent:0
      - label: type=node2
        nodeFilters:
          - agent:1

1.3 Criando cluster local

Para criar um cluster local, usamos o comando a seguir:

k3d cluster create --config k3d-config.yml

Se tudo correr como esperado, no final do comando é exibida a mensagem que o cluster foi criado com sucesso:

Rotulamos os nós para facilitar no gerenciamento desses nós, por exemplo, podemos buscar um nó específico com o comando abaixo:

# label de interesse (type=node1)
kubectl get nodes --selector type=node1 
# NAME                    STATUS   ROLES    AGE   VERSION
# k3d-mycluster-agent-0   Ready    <none>   21m   v1.26.4+k3s1

1.3.1 Labels e selectors

Os rótulos atribuídos em cada nó podem ser usados para definir qual nó um recurso do kubernetes usará, nessa subseção fazemos isso em um pod.

Especificamos no campo nodeSelector o rótulo do nó de interesse a ser vinculad ao pod. No arquivo yaml abaixo, definimos o rótulo do nó k3d-mycluster-agent-1. Para subir a aplicação usamos o comando kubectl apply -f pod.yaml.

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  nodeSelector: 
    type: node2 # atribuir esse pod ao nó de interesse
  containers:
  - name: nginx
    image: nginx
    imagePullPolicy: IfNotPresent

Em seguida, podemos verificar que o recurso foi atribuído ao nó designado ao consultar o campo NODE da mensagem:

kubectl get pods --output=wide
# NAME    READY   STATUS    RESTARTS   AGE   IP          NODE                    NOMINATED NODE   READINESS GATES
# nginx   1/1     Running   0          18s   10.42.0.5   k3d-mycluster-agent-1   <none>           <none>

Como essa aplicação do nginx foi criada apenas para mostrar o uso de labels, podemos removê-la do nosso cluster com o seguinte comando.

kubectl delete -f pod.yaml

Para compreender melhor o conceito de labels e selectors, a documentação do kubernetes pode ser consultada.

🌳 Utilizando Neural edit-tree lemmatization no português

Jessica Cardoso — Sat, 26 Mar 2022 23:31:54 +0000

Os desenvolvedores do spaCy lançaram um modelo de lematização experimental que conseguiu aumentar a acurácia de lematização do português de 0.75 para 0.97. As versões tradicionais dos lematizadores do spaCy são baseadas em lookup tables e rule sets [1]. Os autores disponibilizaram um template de projeto do spaCy para facilitar a edição dos parâmetros e configurações de treinamento.

Abordamos aqui duas formas de utilizar o edit tree lemmatizer: Por meio do modelo pré-treinado transformer e treinando a pipeline do zero com componentes específicos.

1. Abordagem Transformer

A primeira abordagem já tem tudo pronto para utilização. A desvantagem dela é que o o modelo transformer ocupa bastante espaço na memória, e o tempo de inferência na cpu pode ser bastante lento, dependendo dos requisitos.

Para utilizar basta seguir os seguintes comandos:

Instalar as bibliotecas necessárias com o modelo

pip install https://huggingface.co/explosion/pt_udv25_portuguesebosque_trf/resolve/main/pt_udv25_portuguesebosque_trf-any-py3-none-any.whl

Agora é só carregar o modelo e utilizar

import spacy
nlp = spacy.load("pt_udv25_portuguesebosque_trf")

# processa o texto
doc = nlp("meu gato não é como os outros e não come ração")

print("original:", doc)
print("lematizado:", " ".join(token.lemma_ for token in doc))

Como ainda está em uma versão experimental, alguns erros podem acontecer. Em um deles é necessário fixar a versão thinc com o comando

pip install thinc==8.0.14

2. Treinamento da pipeline

Nessa parte do tutorial, faremos uso do template do edit_tree_lemmatizer que está disponível aqui. No exemplo, foi configurado para o alemão, nós modificaremos para treinar um modelo em português.

2.1 Pré requisito

Ambiente virtual do python
Biblioteca do spaCy

2.2 Configurando projeto

Primeiro começamos trazendo o projeto do Github para a nossa máquina através do comando spacy project clone.

python -m spacy project clone projects/edit_tree_lemmatizer --repo https://github.com/explosion/spacy-experimental
cd edit_tree_lemmatizer
python -m pip install -r requirements.txt

Vamos mudar o dataset utilizado de Dutch Alpino treebank para um treebank em nosso idioma. Para isso editamos o arquivo project.yml.

vars:
  lang: "pt"
  treebank: "UD_Portuguese-Bosque"
  train_name: "pt_bosque-ud-train"
  dev_name: "pt_bosque-ud-dev"
  test_name: "pt_bosque-ud-test"
  gpu: -1

Além de alterar essa parte do arquivo, também precisamos adicionar o parâmetro --merge-subtokens ao final do comando spacy convert na seção preprocess do nosso yaml.

commands:
  - name: "preprocess"
    help: "Convert data to spaCy format"
    script:
      - "mkdir -p corpus/${vars.treebank}"
      - "python -m spacy convert assets/${vars.treebank}/${vars.train_name}.conllu corpus/${vars.treebank}/ --n-sents 10 --merge-subtokens"
      - "mv corpus/${vars.treebank}/${vars.train_name}.spacy corpus/${vars.treebank}/train.spacy"
      - "python -m spacy convert assets/${vars.treebank}/${vars.dev_name}.conllu corpus/${vars.treebank}/ --n-sents 10 --merge-subtokens"
      - "mv corpus/${vars.treebank}/${vars.dev_name}.spacy corpus/${vars.treebank}/dev.spacy"
      - "python -m spacy convert assets/${vars.treebank}/${vars.test_name}.conllu corpus/${vars.treebank}/ --n-sents 10 --merge-subtokens"
      - "mv corpus/${vars.treebank}/${vars.test_name}.spacy corpus/${vars.treebank}/test.spacy"
    deps:
      - "assets/${vars.treebank}/"
    outputs:
      - "corpus/${vars.treebank}/train.spacy"
      - "corpus/${vars.treebank}/dev.spacy"
      - "corpus/${vars.treebank}/test.spacy"

Feito isso, vamos baixar o dataset definido acima, converter no formato do spaCy e criar o arquivo de configurações.

python -m spacy project assets
python -m spacy project run preprocess
python -m spacy project run create-config

Os dados do repositório UD_Portuguese-Bosque estão na pasta assets, já o arquivo de configuração usado no treinamento está na pasta config. Nesse tutorial, não modificamos o config.cfg, mas é possível ajustar os parâmetros do treinamento.

Treinamos o modelo com utilizando a configuração padrão através do comando abaixo.

python -m spacy project run train

Para avaliar o modelo, apenas trocamos a palavra train por evaluate,

python -m spacy project run evaluate

Conseguimos alcançar na avaliação com a configuração padrão, as seguintes métricas:

TOK     99.98
LEMMA   96.20
SPEED   21155

2.3 Usando o modelo treinado

O modelo treinado é gerado na pasta training e pode ser carregado em uma pipeline do spaCy, para isso basta apenas carregar o modelo treinado no script a seguir.

import spacy

# cria o objeto nlp ao carregar o lematizador
nlp = spacy.load(
    "edit_tree_lemmatizer/training/UD_Portuguese-Bosque/model-best"
)

# processa o texto
doc = nlp("meu gato não é como os outros e não come ração")

print("original:", doc)
print("lematizado:", " ".join(token.lemma_ for token in doc))

Nesse segundo caso, não editamos os valores no config.cfg, então a acurácia será menor que o informado no blog explosion e o modelo com transformers.