Update docs

Author: CodeWithKyrian

docs/configuration.md

@@ -37,6 +37,11 @@ The cache directory is where TransformersPHP stores the downloaded ONNX models.
 the `.transformers-cache/models` directory from the root of your project. Please ensure this directory is writable by
 your application.
 
+### `setLibsDir(?string $libsDir)`
+
+The libs directory is where TransformersPHP stores the shared libraries required for running the models. You typically
+don't need to change this setting unless you have a specific requirement to store the libraries in a different location.
+
 ### `setRemoteHost(string $remoteHost)`
 
 The remote host defines where TransformersPHP looks to download model files. The default host

docs/getting-started.md

@@ -22,14 +22,18 @@ You can install the library via Composer. This is the recommended way to install
 composer require codewithkyrian/transformers
 ```
 
-ONNX runtime will be installed automatically as well. For Windows users, it may take more time to install the ONNX
-library compared to Linux or macOS users (no shades 😅).
+All the shared libraries required by TransformersPHP will be installed automatically. If it fails for some reason, you
+can install them manually using the following command:
+
+```bash
+./vendor/bin/transformers install
+```
 
 > [!CAUTION]
-> The ONNX library is platform-specific, so it's important to run the composer require command on the target platform
-> where the code will be executed. In most cases, this will be your development machine or a server where you deploy
-> your
-> application, but if you're using a Docker container, run the `composer require` command inside that container.
+> The ONNX library is platform-specific, so it's important to run the `composer require`, or `transformers install`
+> command on the target platform where the code will be executed. In most cases, this will be your development machine
+> or a server where you deploy your application, but if you're using a Docker container, run the `composer require`
+> command inside that container.
 
 This command sets up everything you need to start using pre-trained ONNX models with TransformersPHP.
 

docs/utils/image.md

@@ -36,6 +36,14 @@ Transformers::setup()
     ->apply();
 ```
 
+If you're using the `Image` class directly, you can set the image driver using the `setImageDriver()` method.
+
+```php
+use Codewithkyrian\Transformers\Utils\Image;
+
+Image::setDriver(ImageDriver::GD);
+```
+
 ## Image Processing Operations
 
 The `Image` utility class provides a range of image processing operations that can be performed on images. These
@@ -101,6 +109,23 @@ operations include:
   ```php
   $resizedImage = $image->resize(300, 200);
   ```
+  
+- ### `thumbnail(int $width, int $height, int|Resample $resample = 2)`
+    Creates a thumbnail of the image with the specified width and height, using the specified resampling method. This
+    operation affects the instance it's called on, but still returns that instance for method chaining.
+    
+    Parameters:
+        - `$width` (int) The target width of the thumbnail.
+        - `$height` (int) The target height of the thumbnail.
+        - `$resample` (int|Resample) The resampling method to use. Default is `Resample::BICUBIC`.
+    
+    Returns:
+        - An image object representing the thumbnail.
+    
+    Example:
+    ```php
+    $thumbnailImage = $image->thumbnail(100, 100);
+    ```
 
 - ### `crop(int $xMin, int $yMin, int $xMax, int $yMax)`
   Crops the image to the specified bounding box defined by the top-left and bottom-right coordinates. This operation

docs/utils/tensor.md

@@ -39,6 +39,18 @@ Tensors have the following properties:
   each dimension. Strides are used to efficiently access elements in a tensor without the need for reshaping the
   underlying data.
 
+## Tensors in TransformersPHP
+
+The `Tensor` class in TransformersPHP provides a flexible and efficient way to work with tensors in PHP. By default, it
+uses a C-based buffer to store the tensor's data, which allows for fast element-wise operations and mathematical
+operations using OpenBLAS. The operations can further be accelerated if you installed OpenMP - allowing for parallel
+computation across multiple cores. TransformersPHP selects the best available backend for your system, depending on the
+installed libraries. OpenBLAS is already included in the package, so you don't need to install it separately. However,
+you can install OpenMP to enable parallel computation. Checkout the OpenMP installation guide for your operating system.
+
+There are few edge cases where OpenBLAS might not be installed properly. In such cases, TransformersPHP will fall back
+to using the PHP-based buffer, which is slower but still functional.
+
 ## Creating a Tensor
 
 You can create a tensor using the Tensor class constructor or by converting from a multidimensional array using the
@@ -47,11 +59,11 @@ fromArray method. Below are examples of how to create tensors:
 ### Using the Constructor
 
 ```php
-use Codewithkyrian\Transformers\Tensor\Tensor;use Interop\Polite\Math\Matrix\NDArray;
+use Codewithkyrian\Transformers\Tensor\Tensor;
 
 $data = [1, 2, 3, 4, 5, 6];
 $shape = [2, 3];
-$dtype = NDArray::int16;
+$dtype = Tensor::int16;
 $tensor = new Tensor($data, $dtype, $shape); // If dtype is not provided, it defaults to NDArray::float32
 ```
 
@@ -64,6 +76,16 @@ $data = [[1, 2, 3], [4, 5, 6]];
 $tensor = Tensor::fromArray($data);
 ```
 
+### Using fill Method
+
+```php
+use Codewithkyrian\Transformers\Tensor\Tensor;
+
+$shape = [2, 3];
+$value = 5;
+$tensor = Tensor::fill($shape, $value); // Creates a tensor filled with the specified value
+```
+
 ### Using zeros and ones methods
 
 ```php
@@ -280,6 +302,27 @@ matrix multiplication, reshaping, transposing, etc. Below are some common tensor
 
   $softmax->toArray(); // [[0.09003057317038, 0.2447284710548, 0.66524095577482], [0.09003057317038, 0.2447284710548, 0.66524095577482]]
   ```
+  
+- ### `topk(int $k = null, bool $sorted = true)`
+  Returns the top k elements and their indices along the specified axis.
+
+  Parameters:
+    - `$k`: The number of top elements to return. If not provided, all elements are returned.
+    - `$sorted`: Whether to return the elements in sorted order.
+
+  Returns:
+    - A tuple containing two tensors: the top k elements and their indices.
+
+  Example:
+  ```php
+  $data = [[1, 2, 3], [4, 5, 6]];
+  $tensor = Tensor::fromArray($data);
+  
+  [$values, $indices] = $tensor->topk(2);
+  
+  $values->toArray(); // [[3, 2], [6, 5]]
+  $indices->toArray(); // [[2, 1], [2, 1]]
+  ```
 
 - ### `max(int $axis = null)`
   Returns the maximum values along the specified axis.
@@ -437,7 +480,7 @@ matrix multiplication, reshaping, transposing, etc. Below are some common tensor
     $result = $tensor->add($tensor2); // [[6, 8], [10, 12]]
     ```
 
-- ### `multiply(float|int $value)`
+- ### `multiply(Tensor|float|int $value)`
   Multiplies the tensor by the specified scalar value.
 
   Parameters:

src/Tensor/Tensor.php

@@ -404,6 +404,11 @@ public function toArray()
         return $this->unflattenArray($this->buffer, $idx, $this->shape);
     }
 
+    public function toString(): string
+    {
+        return $this->buffer->dump();
+    }
+
     /**
      * Convert the tensor into a flat array of the buffer contents.
      */
@@ -629,18 +634,18 @@ public function sigmoid(): self
     /**
      * Return a new Tensor with every element multiplied by a constant.
      *
-     * @param float|int $scalar The constant to multiply by.
+     * @param float|int $value The constant to multiply by.
      *
      * @return self
      */
-    public function multiply(Tensor|float|int $scalar): self
+    public function multiply(Tensor|float|int $value): self
     {
         $mo = self::mo();
 
-        if ($scalar instanceof Tensor) {
-            $ndArray = $mo->la()->multiply($this, $scalar);
+        if ($value instanceof Tensor) {
+            $ndArray = $mo->la()->multiply($this, $value);
         } else {
-            $ndArray = $mo->la()->scal($scalar, $this);
+            $ndArray = $mo->la()->scal($value, $this);
         }
 
         return new static($ndArray->buffer(), $ndArray->dtype(), $ndArray->shape(), $ndArray->offset());