Probando el código generado por distintos modelos de AI

12/11/2024 - 10:30:00 por Fabio Baccaglioni - 1377 - 11 - En Programación

Acababa de leer de un nuevo modelo que permite, supuestamente, mejores resultados que ChatGPT 4o para código y dije "vamos a probarlo", es un modelo abierto, Qwen 2.5, pero en mi PC no hay memoria para usar la versión full, así que opté por una versión "recortada".

El resultado fue patético, no funcionaba ni podía corregirlo 😁🤷, pero vamos, en vez de usar el modelo con 30 billones de parámetros estaba con el de 3 billones, como que era una décima parte, me dije ¿y si le hago la misma pregunta a todos?

Le tiré algo fácil: 

"I need a complete script in PHP that loads a JPG, PNG or WebP image and converts it to a dithered two colour degraded picture of the same size"

Porque es algo que ya hago en la versión TXT de mi sitio así que ¿Por qué no? Veamos los resultados...

Está claro que un pedido de código en una sola línea no es un test serio, pero no me importa, estaba divirtiéndome, así que tómenlo con pinzas como corresponde.

Les di esta imagen como input y me deberían devolver una imagen "procesada" con dithering, que sirve para convertir a dos colores (blanco y negro) al viejísimo estilo de una vieja TXT monocromo 😁 ¿podrán?

Casi todos tomarán el camino del algoritmo Floyd-Steinberg para crear una imagen dithered, pero no siempre lo entienden...

Qwen 2.5 3B Instruct

Usé la versión más pequeña aceptable para mi GPU, sin embargo el código que me devolvió fallaba y nunca dio ni un resultado.

Es curioso que llama en medio del código a la función imagesetpixel() y en un caso le tira tres parámetros y en otro cuatro, fallaba en uno, le avisé, nunca pudo corregir el error.

Pero ese no es el problema real, el código que me devolvió  entra en loop infinito y come todos los recursos de PHP, onda, no va, ni me puse a debuguear más, simplemente lo que devuelve es basura.

<?php
// Qwen 2.5 Coder 3B Instruct
// Q8 3.62Gb


// Function to load and convert an image to a dithered, two-color degraded version
function convertToDitheredTwoColor($inputPath, $outputPath) {
    // Load the input image
    $image = imagecreatefromjpeg($inputPath);
    if (!$image) {
        $image = imagecreatefrompng($inputPath);
        if (!$image) {
            $image = imagecreatefromwebp($inputPath);
        }
    }

    if (!$image) {
        die("Failed to load the input image.");
    }

    // Get the dimensions of the image
    $width = imagesx($image);
    $height = imagesy($image);

    // Create a new blank image with the same dimensions
    $outputImage = imagecreatetruecolor($width, $height);
    if (!$outputImage) {
        die("Failed to create a new output image.");
    }

    // Define the colors: black and white
    $blackColor = imagecolorallocate($outputImage, 0, 0, 0);
    $whiteColor = imagecolorallocate($outputImage, 255, 255, 255);

    // Dithering algorithm: Floyd-Steinberg dithering
    for ($y = 0; $y < $height; $y++) {
        for ($x = 0; $x < $width; $x++) {
            // Get the current pixel color in RGB
            list($red, $green, $blue) = imagecolorsforindex($image, imagesetpixel($image, $x, $y));

            // Calculate the average of red, green, and blue to determine the brightness level
            $brightness = round(($red + $green + $blue) / 3);

            // Assign the closest color (black or white)
            if ($brightness < 128) {
                imagefilledrectangle($outputImage, $x, $y, $x + 1, $y + 1, $whiteColor);
            } else {
                imagefilledrectangle($outputImage, $x, $y, $x + 1, $y + 1, $blackColor);
            }

            // Apply Floyd-Steinberg dithering
            $error = $brightness - (($brightness < 128) ? 0 : 255);

            // Distribute the error to neighboring pixels
            if ($x > 0 && $y > 0) {
                imagesetpixel($outputImage, $x - 1, $y - 1, imagecolorallocatealpha($outputImage, 0, 0, 0, (int)(255 * ($error / 16))));
            }
            if ($y > 0) {
                imagesetpixel($outputImage, $x, $y - 1, imagecolorallocatealpha($outputImage, 0, 0, 0, (int)(255 * ($error / 16))));
            }
            if ($x < $width - 1 && $y > 0) {
                imagesetpixel($outputImage, $x + 1, $y - 1, imagecolorallocatealpha($outputImage, 0, 0, 0, (int)(255 * ($error / 16))));
            }
            if ($x > 0) {
                imagesetpixel($outputImage, $x - 1, $y, imagecolorallocatealpha($outputImage, 0, 0, 0, (int)(255 * ($error / 16))));
            }
            if ($x < $width - 1) {
                imagesetpixel($outputImage, $x + 1, $y, imagecolorallocatealpha($outputImage, 0, 0, 0, (int)(255 * ($error / 16))));
            }
        }
    }

    // Save the output image
    if (!imagejpeg($outputImage, $outputPath)) {
        die("Failed to save the output image.");
    }

    echo "Dithered two-color image saved to: " . $outputFilePath;
}

// Example usage
$inputFilePath = 'input.jpg'; // Replace with your input image path
$outputFilePath = 'output-qwen.jpg'; // Specify the output file path

convertToDitheredTwoColor($inputFilePath, $outputFilePath);
?>

Qwen 2.5 Coder 14B Instruct

Le di powa a una versión mucho más grande a ver si me podía producir un código decente, el código resultante fue muy distinto, muy elegante, se nota que si vas subiendo en complejidad mejora mucho, pero era uno cuantizado en Q4 que es como sacarle unos cuantos ceros

<?php

function loadImage($filePath) {
    $imageInfo = getimagesize($filePath);
    $mimeType = $imageInfo['mime'];

    switch ($mimeType) {
        case 'image/jpeg':
            return imagecreatefromjpeg($filePath);
        case 'image/png':
            return imagecreatefrompng($filePath);
        case 'image/webp':
            return imagecreatefromwebp($filePath);
        default:
            throw new Exception("Unsupported file format");
    }
}

function saveImage($image, $outputPath) {
    if (file_exists($outputPath)) {
        unlink($outputPath); // Delete the existing file
    }

    imagepng($image, $outputPath); // Save as PNG
    imagedestroy($image);
}

function ditherImage($inputFilePath, $outputFilePath) {
    $originalImage = loadImage($inputFilePath);
    $width = imagesx($originalImage);
    $height = imagesy($originalImage);
	
    // Create a new blank image with the same size
    $ditheredImage = imagecreatetruecolor($width, $height);

    // Define colors (black and white)
    $black = imagecolorallocate($ditheredImage, 0, 0, 0);
    $white = imagecolorallocate($ditheredImage, 255, 255, 255);

    for ($y = 0; $y < $height; $y++) {
        for ($x = 0; $x < $width; $x++) {
			
            $rgb = imagecolorat($originalImage, $x, $y);
            $red = ($rgb >> 16) & 0xFF;
            $green = ($rgb >> 8) & 0xFF;
            $blue = $rgb & 0xFF;

            // Calculate luminance
            $luminance = (int)(0.299 * $red + 0.587 * $green + 0.114 * $blue);

            // Determine the pixel color based on luminance
            if ($luminance > 127) {
                imagesetpixel($ditheredImage, $x, $y, $white);
            } else {
                imagesetpixel($ditheredImage, $x, $y, $black);
            }
		

            // Calculate the error
            $error = $luminance - (imagesetpixel($ditheredImage, $x, $y, $white) ? 255 : 0);

            // Apply diffusion to neighboring pixels
            if ($x + 1 < $width) {
                imagesetpixel($originalImage, $x + 1, $y, imagecolorat($originalImage, $x + 1, $y) + (int)(7 / 16 * $error));
            }
            if ($x > 0 && $y + 1 < $height) {
                imagesetpixel($originalImage, $x - 1, $y + 1, imagecolorat($originalImage, $x - 1, $y + 1) + (int)(3 / 16 * $error));
            }
            if ($y + 1 < $height) {
                imagesetpixel($originalImage, $x, $y + 1, imagecolorat($originalImage, $x, $y + 1) + (int)(5 / 16 * $error));
            }
            if ($x + 1 < $width && $y + 1 < $height) {
                imagesetpixel($originalImage, $x + 1, $y + 1, imagecolorat($originalImage, $x + 1, $y + 1) + (int)(1 / 16 * $error));
            }
        }
    }

    saveImage($ditheredImage, $outputFilePath);
}

// Example usage
$inputPath = 'input.jpg';
$outputPath = 'output-qwen10.png';

try {
    ditherImage($inputPath, $outputPath);
    echo "Dithered image saved to: $outputPath";
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}

?>

Lamentablemente el resultado de este bello código es una imagen en blanco, no me sirve de nada 🤷 el error debe ser mínimo, pero si la idea era que el LLM produjera un resultado ejecutable de una, no funcionó

ChatGPT (free)

Creo que la versión libre de ChatGPT usa 3.5 o, cuando puede, 4o, no tengo idea porque tampoco te avisa, sin embargo me devolvió un código decente que funciona.

<?php

function loadImage($filename) {
    $image = null;
    $imageInfo = getimagesize($filename);

    switch ($imageInfo['mime']) {
        case 'image/jpeg':
            $image = imagecreatefromjpeg($filename);
            break;
        case 'image/png':
            $image = imagecreatefrompng($filename);
            break;
        case 'image/webp':
            $image = imagecreatefromwebp($filename);
            break;
        default:
            die("Unsupported image format. Please use JPG, PNG, or WebP.");
    }

    return $image;
}

function ditherImage($image) {
    $width = imagesx($image);
    $height = imagesy($image);

    // Create a black and white palette for the output
    $black = imagecolorallocate($image, 0, 0, 0);
    $white = imagecolorallocate($image, 255, 255, 255);

    // Convert the image to grayscale and apply Floyd-Steinberg dithering
    for ($y = 0; $y < $height; $y++) {
        for ($x = 0; $x < $width; $x++) {
            // Get the current pixel's color value
            $rgb = imagecolorat($image, $x, $y);
            $gray = (int)((($rgb >> 16) & 0xFF) * 0.3 + (($rgb >> 8) & 0xFF) * 0.59 + ($rgb & 0xFF) * 0.11);

            // Decide if the pixel should be black or white based on a threshold
            $newColor = ($gray < 128) ? 0 : 255;
            $error = $gray - $newColor;

            // Set the new color
            imagesetpixel($image, $x, $y, ($newColor == 0) ? $black : $white);

            // Apply error diffusion (Floyd-Steinberg)
            if ($x + 1 < $width) {
                $nextPixel = imagecolorat($image, $x + 1, $y);
                imagesetpixel($image, $x + 1, $y, $nextPixel + ($error * 7 / 16));
            }
            if ($x - 1 >= 0 && $y + 1 < $height) {
                $nextPixel = imagecolorat($image, $x - 1, $y + 1);
                imagesetpixel($image, $x - 1, $y + 1, $nextPixel + ($error * 3 / 16));
            }
            if ($y + 1 < $height) {
                $nextPixel = imagecolorat($image, $x, $y + 1);
                imagesetpixel($image, $x, $y + 1, $nextPixel + ($error * 5 / 16));
            }
            if ($x + 1 < $width && $y + 1 < $height) {
                $nextPixel = imagecolorat($image, $x + 1, $y + 1);
                imagesetpixel($image, $x + 1, $y + 1, $nextPixel + ($error * 1 / 16));
            }
        }
    }

    return $image;
}

function saveImage($image, $outputFilename) {
    // Save the dithered image as a PNG to avoid further quality loss
    imagepng($image, $outputFilename);
    imagedestroy($image);
}

// Main execution
$inputFile = 'input.jpg'; // Path to your input image
$outputFile = 'output-chatgpt.png'; // Path to save the dithered image

$image = loadImage($inputFile);
$ditheredImage = ditherImage($image);
saveImage($ditheredImage, $outputFile);

echo "Dithered image saved as " . $outputFile;

?>

El resultado no está mal en sí, es un dither, pero el fondo lo mandó todo a negro sin efectos, de hecho, tiene muchas cosas mejorables para que no quede todo blanco y negro y emule una escala de grises, el que yo uso en mi blog txt es mejor que este.

Meta AI (Llama 3.2?)

En teoría Meta.ai utiliza Llama 3.2 en su versión más grande 405B, que es una barbaridad de tamaño, el código también funciona:

<?php

/**
 * Dither an image to two colors.
 *
 * @param string $inputFile  Input image file path.
 * @param string $outputFile Output image file path.
 * @param int    $threshold  Threshold value (0-255) for dithering.
 * @param int    $color1     RGB value for first color (e.g., 0x000000 for black).
 * @param int    $color2     RGB value for second color (e.g., 0xFFFFFF for white).
 */
function ditherImage($inputFile, $outputFile, $threshold = 127, $color1 = 0x000000, $color2 = 0xFFFFFF) {
    // Load image
    $image = loadImage($inputFile);

    // Convert image to grayscale
    imagefilter($image, IMG_FILTER_GRAYSCALE);

    // Apply dithering algorithm
    for ($y = 0; $y < imagesy($image); $y++) {
        for ($x = 0; $x < imagesx($image); $x++) {
            $pixelColor = imagecolorat($image, $x, $y);
            $grayLevel = ($pixelColor >> 16) & 0xFF; // Get gray level from RGB

            // Apply threshold
            $newColor = ($grayLevel > $threshold) ? $color2 : $color1;

            // Set new pixel color
            imagesetpixel($image, $x, $y, $newColor);
        }
    }

    // Save output image
    saveImage($image, $outputFile);
}

/**
 * Load image from file.
 *
 * @param string $file Image file path.
 *
 * @return resource GD image resource.
 */
function loadImage($file) {
    $ext = pathinfo($file, PATHINFO_EXTENSION);
    switch ($ext) {
        case 'jpg':
        case 'jpeg':
            return imagecreatefromjpeg($file);
        case 'png':
            return imagecreatefrompng($file);
        case 'webp':
            return imagecreatefromwebp($file);
        default:
            throw new Exception("Unsupported image format.");
    }
}

/**
 * Save image to file.
 *
 * @param resource $image GD image resource.
 * @param string   $file  Output image file path.
 */
function saveImage($image, $file) {
    $ext = pathinfo($file, PATHINFO_EXTENSION);
    switch ($ext) {
        case 'jpg':
        case 'jpeg':
            imagejpeg($image, $file);
            break;
        case 'png':
            imagepng($image, $file);
            break;
        case 'webp':
            imagewebp($image, $file);
            break;
        default:
            throw new Exception("Unsupported output format.");
    }

    imagedestroy($image);
}

// Example usage:
$inputFile = 'input.jpg';
$outputFile = 'output-metaai.png';
ditherImage($inputFile, $outputFile);

El resultado es similar al de ChatGPT aunque se nota un poco más croto, no está mal, no sé cuánta diferencia hay en lo que hace, pero esto dio

Copilot (ChatGPT?)

En teoría Copilot de Microsoft utiliza ChatGPT de backend, el resultado es muy distinto en el código, menos detallado en los comentarios también.

<?php
function ditherImage($inputPath, $outputPath, $color1, $color2)
{
    // Load the image
    $info = getimagesize($inputPath);
    $mime = $info['mime'];

    switch ($mime) {
        case 'image/jpeg':
            $image = imagecreatefromjpeg($inputPath);
            break;
        case 'image/png':
            $image = imagecreatefrompng($inputPath);
            break;
        case 'image/webp':
            $image = imagecreatefromwebp($inputPath);
            break;
        default:
            die('Unsupported image type');
    }

    $width = imagesx($image);
    $height = imagesy($image);

    // Create the output image
    $output = imagecreatetruecolor($width, $height);
    $color1 = imagecolorallocate($output, $color1[0], $color1[1], $color1[2]);
    $color2 = imagecolorallocate($output, $color2[0], $color2[1], $color2[2]);

    // Convert to dithered two-color image
    for ($y = 0; $y < $height; $y++) {
        for ($x = 0; $x < $width; $x++) {
            $rgb = imagecolorat($image, $x, $y);
            $r = ($rgb >> 16) & 0xFF;
            $g = ($rgb >> 8) & 0xFF;
            $b = $rgb & 0xFF;
            $gray = ($r + $g + $b) / 3;

            if ($gray < 128) {
                imagesetpixel($output, $x, $y, $color1);
            } else {
                imagesetpixel($output, $x, $y, $color2);
            }
        }
    }

    // Save the output image
    imagepng($output, $outputPath);

    // Free memory
    imagedestroy($image);
    imagedestroy($output);
}

// Example usage
$inputPath = 'input.jpg'; // Path to the input image
$outputPath = 'output-copilot.png'; // Path to the output image
$color1 = [0, 0, 0]; // First color (black)
$color2 = [255, 255, 255]; // Second color (white)
ditherImage($inputPath, $outputPath, $color1, $color2);

El resultado es más bajo que el de Meta inclusive, aunque en términos generales se "entiende", pero la imagen es todo y no alcanza

Qwen 2.5 72B Instruct

Fuck it! dije! me busqué un servidor donde corrieran este nuevo modelo para ver si en su versión full era tan potente como decían, vamos, en algún lado debía estar y dónde mejor que en Hugginface, así que me decidí a probarlo allí y me dio esto:

<?php
function load_image($filename) {
    $info = getimagesize($filename);
    if ($info === false) {
        die("Failed to get image information");
    }

    switch ($info[2]) {
        case IMAGETYPE_JPEG:
            return imagecreatefromjpeg($filename);
        case IMAGETYPE_PNG:
            return imagecreatefrompng($filename);
        case IMAGETYPE_WEBP:
            return imagecreatefromwebp($filename);
        default:
            die("Unsupported image type");
    }
}

function save_image($image, $filename, $type) {
    switch ($type) {
        case IMAGETYPE_JPEG:
            imagejpeg($image, $filename);
            break;
        case IMAGETYPE_PNG:
            imagepng($image, $filename);
            break;
        case IMAGETYPE_WEBP:
            imagewebp($image, $filename);
            break;
        default:
            die("Unsupported image type");
    }
}

function dither_image($image) {
    $width = imagesx($image);
    $height = imagesy($image);

    // Create a new image with the same dimensions
    $new_image = imagecreatetruecolor($width, $height);

    // Allocate colors
    $black = imagecolorallocate($new_image, 0, 0, 0);
    $white = imagecolorallocate($new_image, 255, 255, 255);

    for ($y = 0; $y < $height; $y++) {
        for ($x = 0; $x < $width; $x++) {
            $rgb = imagecolorat($image, $x, $y);
            $r = ($rgb >> 16) & 0xFF;
            $g = ($rgb >> 8) & 0xFF;
            $b = $rgb & 0xFF;

            // Calculate the average color intensity
            $intensity = ($r + $g + $b) / 3;

            // Dithering using a simple threshold
            if ($intensity > 127) {
                imagesetpixel($new_image, $x, $y, $white);
            } else {
                imagesetpixel($new_image, $x, $y, $black);
            }
        }
    }

    return $new_image;
}

// Main script
$filename = 'input.jpg'; // Change this to your input file
$output_filename = 'output-qwen72b.jpg'; // Change this to your desired output file

// Load the image
$image = load_image($filename);

// Dither the image
$dithered_image = dither_image($image);

// Save the dithered image
$save_type = exif_imagetype($filename);
save_image($dithered_image, $output_filename, $save_type);

// Free up memory
imagedestroy($image);
imagedestroy($dithered_image);

echo "Image processed and saved as $output_filename";
?>

Ahora sí funcionó! 

El resultado es similar a ChatGPT y otros, no me puedo quejar, podría ser mejor, pero al menos, cuando vamos a la versión full de Qwen 2.5 estamos al mismo nivel de esta simple prueba.

Codellama 13B Instruct

Con esta versión del modelo de Meta conseguí el resultado más falopa, no en el código que se ve perfectamente normal aunque extremadamente pequeño comparado con el resto, sino en el resultado final que no cumple un cuerno con lo pedido

<html>
<?php

// Codellama 13B Instruct
// Q4
// 7.37GB

$image_filename = "input.jpg"; // Input Image
$output_filename = "output-codellama.png"; // Output image

function dither($img) {
    $size = getimagesize($img);

    $width = $size[0];
    $height = $size[1];

    $img = imagecreatefromstring(file_get_contents($img));
    $img2 = imagecreatetruecolor($width, $height);

    for ($i=0; $i < $width; $i++) { 
        for ($j=0; $j < $height; $j++) {
            $rgb = imagecolorat($img, $i, $j);
            $r = (($rgb >> 16) & 0xFF) / 255.0;
            $g = (($rgb >> 8) & 0xFF) / 255.0;
            $b = ($rgb & 0xFF) / 255.0;

            // Dithering calculation:
            if(round($r*2)/2 > round($g*2)/2 && round($r*2)/2 > round($b*2)/2) { $color = imagecolorallocate($img2, 255, 0, 0); } // Red
            elseif (round($g*2)/2 > round($b*2)/2) { $color = imagecolorallocate($img2, 0, 255, 0); } // Green
            else { $color = imagecolorallocate($img2, 0, 0, 255); } // Blue
            
            imagesetpixel ($img2, $i, $j, $color);
        }
    }
    return $img2;
}

$ditheredImage = dither($image_filename);

imagepng($ditheredImage,$output_filename);
?>
<body>
  <p><img src="<?php echo $output_filename ?>"></p>
</body>
</html>

Vean tan sólo el delirio psicodélico que me regaló, genial resultado, ejjeej

Claude 3.5

Y por último el que, yo considero o creo, es el mejor de todos para código en este momento, el gallo claudio, tiene limitaciones de tokens si querés usarlo para mucho, pero si pagás da bastante más (algunos se quejan hasta de la versión paga).

Para una función simple como esta va perfecto:

<?php

function ditherImage($inputPath, $outputPath) {
    // Validate input file existence
    if (!file_exists($inputPath)) {
        throw new Exception("Input file does not exist");
    }

    // Get image info and create appropriate image resource
    $imageInfo = getimagesize($inputPath);
    if ($imageInfo === false) {
        throw new Exception("Invalid image file");
    }

    switch ($imageInfo[2]) {
        case IMAGETYPE_JPEG:
            $source = imagecreatefromjpeg($inputPath);
            break;
        case IMAGETYPE_PNG:
            $source = imagecreatefrompng($inputPath);
            break;
        case IMAGETYPE_WEBP:
            $source = imagecreatefromwebp($inputPath);
            break;
        default:
            throw new Exception("Unsupported image format");
    }

    // Get dimensions
    $width = imagesx($source);
    $height = imagesy($source);

    // Create grayscale version
    $grayscale = imagecreatetruecolor($width, $height);
    imagefilter($source, IMG_FILTER_GRAYSCALE);

    // Create output image
    $output = imagecreatetruecolor($width, $height);
    
    // Define black and white colors
    $white = imagecolorallocate($output, 255, 255, 255);
    $black = imagecolorallocate($output, 0, 0, 0);

    // Array to store grayscale values
    $pixels = array();

    // Get grayscale values
    for ($y = 0; $y < $height; $y++) {
        for ($x = 0; $x < $width; $x++) {
            $rgb = imagecolorat($source, $x, $y);
            $r = ($rgb >> 16) & 0xFF;
            $pixels[$y][$x] = $r;  // Since it's grayscale, we only need one channel
        }
    }

    // Floyd-Steinberg dithering
    for ($y = 0; $y < $height; $y++) {
        for ($x = 0; $x < $width; $x++) {
            $oldPixel = $pixels[$y][$x];
            $newPixel = ($oldPixel < 128) ? 0 : 255;
            imagesetpixel($output, $x, $y, ($newPixel == 0) ? $black : $white);
            
            $error = $oldPixel - $newPixel;
            
            // Distribute error to neighboring pixels
            if ($x + 1 < $width) {
                $pixels[$y][$x + 1] += ($error * 7/16);
            }
            if ($y + 1 < $height) {
                if ($x > 0) {
                    $pixels[$y + 1][$x - 1] += ($error * 3/16);
                }
                $pixels[$y + 1][$x] += ($error * 5/16);
                if ($x + 1 < $width) {
                    $pixels[$y + 1][$x + 1] += ($error * 1/16);
                }
            }
        }
    }

    // Save the output image
    imagepng($output, $outputPath);

    // Clean up
    imagedestroy($source);
    imagedestroy($output);

    return true;
}

// Example usage
try {
    $inputPath = "input.jpg";  // Replace with your input image path
    $outputPath = "output-claude.png"; // Replace with your desired output path
    ditherImage($inputPath, $outputPath);
    echo "Image successfully dithered and saved!";
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}
?>

El resultado en imagen es realmente lo que esperaba, a diferencia de los otros Claude implementó bien el algoritmo Floyd-Steinberg y el resultado es notablemente superior:

Opinología

Probé Gemma de Google, nada, imagen vacía, al menos no tiró error, también Llama 3.2 instruct 3B (Q8 de 3.42GB) para probar, cero resultado de imagen, así que no culpo a las versiones pequeñas de Qwen, la realidad es que si vas a usar un modelo de LLM para programar, por más que den código como resultado, si el LLM es pequeño ese código será una porquería que no funciona.

Con un poco de debug lo sacás funcionando, sí, está bien, pero la idea es que justamente todo funcione como debe ser, de una, con poco trabajo, aquí sólo pedí una función muy simple, nada alocado.

De todos el único que implementó correctamente el algoritmo Floyd-Steinberg fue Claude, el resto se acercó bastante salvo los fallidos que también lo intentaron pero no pasaron el filtro. En tamaño de imagen la versión de Meta.ai y la de Copilot fueron las más eficientes (35Kb), la de Claude la menos, pesa tanto (170Kb) como la original en color (180Kb). En todos los casos respetaron el tamaño original de 1024x1024, por eso la de Claude pesa mucho, es un algoritmo ineficiente para imágenes grandes.

En todos los casos el LLM explicó el uso de la función y qué hacía cada parámetro, inclusive algunos se excusaron de no implementar en detalle el algoritmo, como diciendo que se podía mejorar (por qué cuernos no lo hiciste mejor???), esto es muy útil si se está aprendiendo un nuevo lenguaje o framework.

En fin, si quieren probar su propia versión o corregir/encontrarle el error a estos algoritmos, bienvenidos sean 😋