Gerando embeddings com PHP e ONNX
Published: 2024-07-15 21:13:56

# IA e PHP

No campo da inteligência artificial (IA) e processamento de linguagem natural (NLP), _embeddings_ são representações matemáticas de palavras, frases ou documentos que capturam seu significado semântico. Esses _embeddings_ são utilizados para aplicações que incluem busca semântica, análise de sentimentos, entre outros. A criação de _embeddings_ geralmente envolve técnicas de aprendizado de máquina que tradicionalmente são implementadas em linguagens como Python. No entanto, com a crescente popularidade da arquitetura [Open Neural Network Exchange](https://github.com/onnx/onnx) (ONNX), é possível integrar modelos pré-treinados em diferentes linguagens de programação, incluindo PHP.

# Transformers PHP
Para utilização dos modelos de inteligência artificial visando a geração de _embeddings_ no PHP, é possível utilizar a biblioteca [TransformersPHP](https://github.com/CodeWithKyrian/transformers-php), no qual foi projetada para ser funcionalmente equivalente à biblioteca [Transformers](https://pypi.org/project/transformers/) em Python, mantendo o mesmo nível de desempenho e facilidade de uso. O TransformersPHP utiliza o ONNX Runtime para executar os modelos pré-treinados.

# Arquitetura Exemplo
A seguir, é possível observar visualmente o funcionamento da geração de embeddings a partir da biblioteca TransformersPHP:
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q0cwdz4iv9mhsj62k2jc.png)

# Uso
Primeiramente, realize a configuração da imagem que será utilizada pelo container. Para utilização do TransformersPHP com suporte a geração de _embeddings_, é necessário o uso das extensões `FFI` e `Imagick`. A extensão `FFI`  é a interface de integração entre código binário e a linguagem PHP. Já o `Imagick` é utilizado para o processamento dos modelos pré-treinados.

```docker
FROM php:8.3

RUN apt-get update && apt-get install -y libffi-dev \
        git \
        unzip \
        libmagickwand-dev \
        libmagickcore-dev      

RUN docker-php-ext-configure ffi --with-ffi \
    && docker-php-ext-install ffi

RUN pecl install imagick \
    && docker-php-ext-enable imagick

RUN curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer

RUN mkdir /embeddings

WORKDIR /embeddings

CMD ["/bin/bash"]
```

Após isso, é possível realizar a criação da imagem:
```
docker build -t image-php-ffi .
```

Seguida da execução do container:
```
docker run -it --rm --name container-php-ffi image-php-ffi
```

Dentro do container, é necessário primeiramente adicionar a dependência `codewithkyrian/transformers`, logo deve-se executar:
```
composer require codewithkyrian/transformers
```

Com isso, o ambiente está configurado e pronto para receber o código que fará a geração do embedding. Abaixo, é possível verificar que o código PHP faz referência ao modelo `Xenova/bert-base-uncased`, disponibilizado pela iniciativa [Xenova](https://huggingface.co/Xenova), no qual oferece modelos pré-treinados a partir da arquitetura ONNX.

```php
<?php

declare(strict_types=1);

require_once './vendor/autoload.php';

use Codewithkyrian\Transformers\Transformers;
use function Codewithkyrian\Transformers\Pipelines\pipeline;
use function Codewithkyrian\Transformers\Utils\{memoryUsage, timeUsage};

Transformers::setup()
    ->apply();

$extractor = pipeline('feature-extraction', 'Xenova/bert-base-uncased');

$embeddings = $extractor('The quick brown fox jumps over the lazy dog.', normalize: true, pooling: 'mean');

var_dump($embeddings[0]);

dd(memoryUsage(), timeUsage(milliseconds: true), count($embeddings[0]));
```

Realize a criação de um novo arquivo PHP, copie o código acima e após isso, execute o arquivo com `php nome_arquivo.php`. A primeira execução pode requerer um tempo de processamento maior por conta do _download_ do modelo pré-treinado.

# Busca Semântica
A geração de _embeddings_ pode ser benéfica para produzir sistemas de busca ao nível semântico, como abordo mais especificamente na palestra [Palestra APIs e LLMs](https://www.youtube.com/watch?v=fpQDvcj5Fb4).

# Desvantagens
Utilizar PHP e a arquitetura ONNX para gerar _embeddings_ pode apresentar algumas desvantagens. A maioria dos modelos _transformers_ são desenvolvidos com a arquitetura `PyTorch`, que é fortemente integrada à linguagem Python, limitando a realização de testes e desenvolvimento em outras linguagens. A conversão de modelos `PyTorch` para ONNX pode ser complexa ou até inviável, dependendo do suporte e das atualizações fornecidas pelos mantenedores dos modelos.

# Conclusão
Integrar IA e NLP com PHP utilizando a arquitetura ONNX é uma abordagem promissora que permite a utilização de modelos pré-treinados em uma linguagem de programação amplamente usada no desenvolvimento web. A biblioteca TransformersPHP demonstra ser uma ferramenta funcionalmente equivalente à sua contraparte em Python, permitindo a geração de embeddings com facilidade e eficiência.

Embora existam desafios, como a complexidade na conversão de modelos e a necessidade de extensões específicas, a utilização de PHP para geração de embeddings pode abrir novas oportunidades para desenvolvedores web que desejam incorporar capacidades de NLP em suas aplicações sem a necessidade de migrar para outras linguagens.

Com a evolução contínua dessas tecnologias e o aumento do suporte da comunidade, espera-se que as barreiras atuais sejam progressivamente reduzidas, tornando essa abordagem cada vez mais acessível e eficaz para diversos desenvolvedores e aplicações.

## Referências

- [ONNX](https://github.com/onnx/onnx)
- [Transformers PHP](https://github.com/CodeWithKyrian/transformers-php)
- [Transformers PHP - DOC](https://codewithkyrian.github.io/transformers-php/)
- [Transformers](https://pypi.org/project/transformers/)
- [Transformers Hugging Face](https://huggingface.co/docs/transformers/index)
- [Docker PHP](https://hub.docker.com/_/php)
- [Xenova](https://huggingface.co/Xenova)