Forem: Wesley Teixeira

Apresentando o ZMatrix: Operações de tensor de alto desempenho para PHP

Wesley Teixeira — Wed, 25 Jun 2025 00:05:17 +0000

Explorando ZMatrix:

Operações de Tensor de Alto Desempenho em PHP

Operações com tensores—trabalhar com arrays multidimensionais—são a base da computação moderna, alimentando tudo, desde aprendizado de máquina até simulações científicas. Enquanto linguagens como Python e C++ dominam esse espaço com bibliotecas como NumPy e Eigen, o PHP historicamente ficou para trás. É aí que entra o ZMatrix, uma extensão PHP com suporte em C++. O ZMatrix traz operações de tensor incrivelmente rápidas diretamente para o PHP, combinando o desempenho do C++ com a simplicidade do ecossistema do PHP.

Inspirado pela necessidade de computação numérica eficiente em PHP, criei o ZMatrix para preencher essa lacuna. Esteja você construindo APIs orientadas a dados, prototipando algoritmos ou processando grandes conjuntos de dados, o ZMatrix permite fazer tudo isso sem sair do PHP.

A Fundação do ZMatrix

Em sua essência, o ZMatrix é uma extensão PHP que aproveita C++ para matemática de tensor de alto desempenho. Ele usa arrays sem cópia para mapear estruturas de dados PHP diretamente na memória C++, evitando sobrecarga desnecessária.

Aqui está um exemplo simples para entender como funciona:

use ZMatrix\ZTensor;

$t = ZTensor::arr([
    [1, 2, 3],
    [4, 5, 6],
]);
echo "Shape: ", json_encode($t->shape()), "\n"; // [2,3]

Isso cria um tensor 2x3 a partir de um array PHP, pronto para operações otimizadas—tudo alimentado por um backend C++.

Instalando ZMatrix

Colocar o ZMatrix para funcionar é simples. Veja como instalá-lo em um sistema Linux típico com PHP 8.4:

🚀 Instalação

git clone https://github.com/webtec3/zmatrix.git
cd zmatrix
phpize
./configure
make -j$(nproc)
sudo make install
echo "extension=zmatrix.so" | sudo tee /etc/php/8.4/cli/conf.d/20-zmatrix.ini

Uma vez instalado, você está pronto para começar a usar operações de tensor em seus scripts PHP.

Trabalhando com Tensores no ZMatrix

O ZMatrix oferece um conjunto rico de recursos para manipular tensores de forma eficiente. Aqui estão alguns exemplos do que é possível fazer:

Criando um Tensor

use ZMatrix\ZTensor;
$t = ZTensor::arr([
    [1, 2, 3],
    [4, 5, 6],
]);
echo "Shape: ", json_encode($t->shape()), "\n"; // [2,3]

Operações Elemento a Elemento

$a = ZTensor::arr([1, 2, 3]);
$b = ZTensor::ones([3])->multiply_scalar(5);
$c = $a->add($b);
echo $c, "\n"; // [6, 7, 8]

Aritmética Elemento a Elemento

$a = ZTensor::arr([1,2,3]);
$b = ZTensor::ones([3])->multiply_scalar(5);
$c = $a->add($b);
echo $c, "\n"; // [[6,7,8]]

Multiplicação de Matrizes

$A = ZTensor::arr([[1, 2, 3], [4, 5, 6]]);
$B = ZTensor::arr([[7, 8], [9, 10], [11, 12]]);
$C = $A->matmul($B);
echo $C, "\n"; // [[58, 64], [139, 154]]

Cálculos Estatísticos

$data = ZTensor::random([1000]);
echo "Mean: ", $data->mean(), ", Std: ", $data->std(), "\n";

Funções de Ativação

$x = ZTensor::arr([-1, 0, 1]);
echo "Sigmoid: ", $x->sigmoid(), "\n"; // [0.2689, 0.5, 0.7311]
echo "ReLU: ", $x->relu(), "\n";     // [0, 0, 1]

Operações Estatísticas

$data = ZTensor::random([1000]);
echo "Mean: ", $data->mean(), ", Std: ", $data->std(), "\n";

Ativações estilo Neural

$x = ZTensor::arr([-1,0,1]);
echo "Sigmoid: ", $x->sigmoid(), "\n";
echo "ReLU:     ", $x->relu(),    "\n";

🔍 Por Trás dos Panos

Essas operações são intuitivas e espelham a simplicidade do PHP, enquanto por trás dos panos aproveitam otimizações em C++ como BLAS, OpenMP e SIMD para desempenho máximo.

Desempenho Interno

A velocidade do ZMatrix vem de sua base em C++:

BLAS: Acelera multiplicação de matrizes com cblas_sgemm.

OpenMP + SIMD: Paraleliza operações entre núcleos da CPU.

Visualizações sem cópia: Funções como reshape() e transpose() evitam duplicação de dados.

Armazenamento Float32: Otimizado para eficiência numérica.

Benchmarks mostram o ZMatrix realizando centenas de milhões de operações por segundo, tornando-o uma escolha viável para aplicações em tempo real e em larga escala.

Quem Pode se Beneficiar do ZMatrix?

ZMatrix é versátil e atende a diversos casos de uso:

Desenvolvedores Backend: Adicione aprendizado de máquina leve ou processamento de dados a APIs PHP.

Engenheiros de Dados: Construa pipelines eficientes dentro de microsserviços PHP.

Educadores: Ensine conceitos computacionais usando a sintaxe acessível do PHP.

Participe

ZMatrix é de código aberto (licença MIT) e aceita contribuições. Veja no GitHub: https://github.com/webtec3/zmatrix. Dê uma estrela no repositório, envie problemas ou pull requests para ajudar a moldar seu futuro!

Conclusão

ZMatrix traz operações de tensor de alto desempenho para o PHP, combinando a facilidade do PHP com o poder do C++. É leve, eficiente e abre novas possibilidades para computação numérica em aplicações PHP. Experimente no seu próximo projeto e veja como ele pode elevar seu trabalho!

Introducing ZMatrix: High-Performance Tensor Operations for PHP

Wesley Teixeira — Tue, 24 Jun 2025 23:33:22 +0000

Exploring ZMatrix:

High-Performance Tensor Operations in PHP
Tensor operations—working with multidimensional arrays—are a cornerstone of modern computing, powering everything from machine learning to scientific simulations. While languages like Python and C++ dominate this space with libraries like NumPy and Eigen, PHP has historically lagged behind. That’s where ZMatrix, a C++-powered PHP extension, comes in. ZMatrix brings blazing-fast tensor operations directly to PHP, blending the performance of C++ with the simplicity of PHP’s ecosystem.

Inspired by the need for efficient numerical computing in PHP, I created ZMatrix to bridge this gap. Whether you’re building data-driven APIs, prototyping algorithms, or processing large datasets, ZMatrix empowers you to do it all without leaving PHP.

The Foundation of ZMatrix

At its core, ZMatrix is a PHP extension that leverages C++ for high-performance tensor math. It uses zero-copy arrays to map PHP data structures directly to C++ memory, avoiding unnecessary overhead.

Here’s a simple example to get a feel for it:

use ZMatrix\ZTensor;

$t = ZTensor::arr([
    [1, 2, 3],
    [4, 5, 6],
]);
echo "Shape: ", json_encode($t->shape()), "\n"; // [2,3]

This creates a 2x3 tensor from a PHP array, ready for optimized operations—all powered by a C++ backend.
Installing ZMatrix
Getting ZMatrix up and running is straightforward. Here’s how to install it on a typical Linux system with PHP 8.4:

🚀 Installation

git clone https://github.com/webtec3/zmatrix.git
cd zmatrix
phpize
./configure
make -j$(nproc)
sudo make install
echo "extension=zmatrix.so" | sudo tee /etc/php/8.4/cli/conf.d/20-zmatrix.ini

Once installed, you’re ready to start using tensor operations in your PHP scripts.
Working with Tensors in ZMatrix
ZMatrix offers a rich set of features to manipulate tensors efficiently. Here are some examples of what you can do:

Creating a Tensor

use ZMatrix\ZTensor;
$t = ZTensor::arr([
    [1, 2, 3],
    [4, 5, 6],
]);
echo "Shape: ", json_encode($t->shape()), "\n"; // [2,3]

Element-wise Operations

$a = ZTensor::arr([1, 2, 3]);
$b = ZTensor::ones([3])->multiply_scalar(5);
$c = $a->add($b);
echo $c, "\n"; // [6, 7, 8]

Element-wise Arithmetic

$a = ZTensor::arr([1,2,3]);
$b = ZTensor::ones([3])->multiply_scalar(5);
$c = $a->add($b);
echo $c, "\n"; // [[6,7,8]]

Matrix Multiplication

$A = ZTensor::arr([[1, 2, 3], [4, 5, 6]]);
$B = ZTensor::arr([[7, 8], [9, 10], [11, 12]]);
$C = $A->matmul($B);
echo $C, "\n"; // [[58, 64], [139, 154]]

Statistical Computations

$data = ZTensor::random([1000]);
echo "Mean: ", $data->mean(), ", Std: ", $data->std(), "\n";

Activation Functions

$x = ZTensor::arr([-1, 0, 1]);
echo "Sigmoid: ", $x->sigmoid(), "\n"; // [0.2689, 0.5, 0.7311]
echo "ReLU: ", $x->relu(), "\n";     // [0, 0, 1]

Statistical Ops

$data = ZTensor::random([1000]);
echo "Mean: ", $data->mean(), ", Std: ", $data->std(), "\n";

Neural-style Activations

$x = ZTensor::arr([-1,0,1]);
echo "Sigmoid: ", $x->sigmoid(), "\n";
echo "ReLU:     ", $x->relu(),    "\n";

🔍 Under the Hood

These operations are intuitive and mirror the simplicity of PHP, while under the hood, they leverage C++ optimizations like BLAS, OpenMP, and SIMD for maximum performance.
Performance Under the Hood
ZMatrix’s speed comes from its C++ foundation:

BLAS: Accelerates matrix multiplication with cblas_sgemm.
OpenMP + SIMD: Parallelizes operations across CPU cores.
Zero-copy Views: Functions like reshape() and transpose() avoid data duplication.
Float32 Storage: Optimized for numerical efficiency.

Benchmarks show ZMatrix performing hundreds of millions of operations per second, making it a viable choice for real-time and large-scale applications.
Who Can Benefit from ZMatrix?
ZMatrix is versatile and caters to various use cases:

Backend Developers: Add lightweight machine learning or data processing to PHP APIs.
Data Engineers: Build efficient pipelines within PHP microservices.
Educators: Teach computational concepts using PHP’s accessible syntax.

Get Involved

ZMatrix is open source (MIT license) and welcomes contributions. Check it out on GitHub: https://github.com/webtec3/zmatrix. Star the repo, file issues, or submit pull requests to help shape its future!
Conclusion
ZMatrix brings high-performance tensor operations to PHP, combining the ease of PHP with the power of C++. It’s lightweight, efficient, and opens up new possibilities for numerical computing in PHP applications. Give it a try in your next project and see how it can elevate your work!

Building a PSR-11 Compatible Dependency Injection Container with PHP 8.4 Lazy Objects

Wesley Teixeira — Thu, 02 Jan 2025 04:11:14 +0000

Exploring Dependency Injection with Lazy Objects in PHP 8.4

In the realm of modern PHP, the release of version 8.4 introduced a groundbreaking feature: Lazy Objects. These objects enable a new way to defer initialization until absolutely necessary, boosting performance and reducing resource usage. This functionality is deeply integrated into the language through enhancements to the ReflectionClass API, as outlined in the Lazy Initialization for Lazy Objects RFC.

Example from the RFC
To illustrate the potential of Lazy Objects, consider the following example directly the RFC:

class MyClass
{
    public function __construct(private int $foo)
    {
        // Heavy initialization logic here.
    }

    // ...
}

$initializer = static function (MyClass $ghost): void {
    $ghost->__construct(123);
};

$reflector = new ReflectionClass(MyClass::class);
$object = $reflector->newLazyGhost($initializer);

// At this point, $object is a lazy ghost object.

This mechanism allows developers to finely control the initialization process, ensuring that resources are only loaded when accessed.

Inspired by this RFC, I set out to build a PSR-11 compatible Dependency Injection Container, leveraging the Lazy Objects API for optimal performance.

The Foundation of the ContainerLazyObject

The core of our container lies in the ContainerLazyObject class. With it, you can register dependencies and initialize them lazily, meaning they are only instantiated when actually needed. Here is the main method that performs this task:

public function set(string $id, object|string $concrete): void
{
    $reflector = new ReflectionClass($id);
    $initializer = $concrete;

    if (is_string($concrete)) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete($this);
        };
    }

    if (is_object($concrete) && !$concrete instanceof Closure) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete;
        };
    }

    $this->instances[$id] = $reflector->newLazyProxy($initializer);
}

Registering Services in the Container

Our container supports various ways of registering services, offering flexibility to developers. Here are some examples:

$container = new ContainerLazyObject();
$containerer->set(DatabaseService::class, fn() => new DatabaseService(new LoggerService()));
$container->set(LoggerService::class, fn() => new LoggerService());

// Alternative approach with class names
$container->set(DatabaseService::class, DatabaseService::class);
$containerr->set(LoggerService::class, LoggerService::class);

// Using already instantiated objects
$container->set(DatabaseService::class, new DatabaseService(new LoggerService()));
$container->set(LoggerService::class, new LoggerService());

This flexibility makes the ContainerLazyObject adaptable to various scenarios, whether dynamically building dependencies or reusing pre-configured objects.

Retrieving Services from the Container
Once services are registered in the container, you can retrieve them whenever needed. The container ensures that services are lazily instantiated, so they won’t be created until actually requested. Here is an example of how to retrieve the registered services:

// Retrieving the services from the container
$loggerService = $container->get(LoggerService::class);
$databaseService = $container->get(DatabaseService::class);

The Core of ContainerLazyObject The heart of our container lies in the ContainerLazyObject class. With it, you can register dependencies and initialize them lazily, meaning they are only created when they are actually used. Here is the main method that performs this task:

public function set(string $id, object|string $concrete): void
{
    $reflector = new ReflectionClass($id);
    $initializer = $concrete;

    if (is_string($concrete)) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete($this);
        };
    }

    if (is_object($concrete) && !$concrete instanceof Closure) {
        $initializer = function(object $instance) use ($concrete): void {
            $this->instances[$instance::class] = $concrete;
        };
    }

    $this->instances[$id] = $reflector->newLazyProxy($initializer);
}

PSR-11 Compatibility

An additional advantage of the ContainerLazyObject is its compatibility with PSR-11, the PHP standard for dependency injection containers. This ensures interoperability with libraries and frameworks following the specification, making it a lightweight and universal solution.

Performance Comparison with Other Containers

To measure the performance of our container, I used PhpBench in a controlled environment, comparing it to popular alternatives: Pimple, Illuminate, and PHP-DI. The results were encouraging:

ContainerLazyObject          Mo0.100μs (±33.33%)
benchPimple                  Mo0.297μs (±18.84%)
benchIlluminate              Mo0.503μs (±9.07%)
benchPhpDI                   Mo0.161μs (±41.57%)

Our container demonstrated excellent performance, being significantly faster than more robust alternatives like Illuminate Container and PHP-DI in simple dependency resolution scenarios.

The Complete Class

class ContainerLazyObject implements ContainerInterface
{

    /**
     * @var array
     */
    private array $instances;

    /**
     * @var array
     */
    protected static array $reflectionCache = [];


    /**
     * @param  string  $class
     *
     * @return ReflectionClass
     * @throws ReflectionException
     */
    protected function getReflectionClass(string $class): ReflectionClass
    {
        if(!isset(self::$reflectionCache[$class])) {
            self::$reflectionCache[$class] = new ReflectionClass($class);
        }

        return self::$reflectionCache[$class];
    }

    /**
     * @param  string         $class
     * @param  object|string  $concrete
     *
     * @return void
     * @throws ReflectionException
     */
    public function set(string $class, object|string $concrete): void
    {
        $initializer = $concrete;
        if(is_string($concrete)) {
            $initializer = function(object $instance) use ($concrete): void {
                $this->instances[$instance::class] = $concrete($this);
            };
        }

        if(is_object($concrete) && !$concrete instanceof Closure) {
            $initializer = function(object $instance) use ($concrete): void {
                $this->instances[$instance::class] = $concrete;
            };
        }

        $this->instances[$class] = $this->getReflectionClass($class)->newLazyProxy($initializer);
    }

    /**
     * @param  string  $id
     *
     * @return object
     */
    public function get(string $id): object
    {
        if(!isset($this->instances[$id])) {
            throw new \InvalidArgumentException("Reference '{$id}' not found in container.");
        }
        return $this->instances[$id];
    }

    /**
     * @param  string  $id
     *
     * @return bool
     */
    public function has(string $id): bool
    {
        return isset($this->instances[$id]);
    }

    /**
     * @return void
     */
    public function clear(): void
    {
        $this->instances = [];
    }

    /**
     * @param  string  $id
     *
     * @return void
     */
    public function remove(string $id): void
    {
        if($this->has($id)) {
            unset($this->instances[$id]);
        }
    }
}

Conclusion

PHP 8.4 and its Lazy Objects have opened new possibilities to simplify and optimize dependency injection. Our ContainerLazyObject, in addition to being lightweight, efficient, and flexible, is PSR-11 compliant, ensuring interoperability with other libraries and frameworks.

Try this approach and see how it can simplify dependency management in your next project!