DEV Community: 🦄 Maris Botero✨

✨ Cuando los circuitos no funcionaban (y lo que me enseñaron sobre la inteligencia artificial)

🦄 Maris Botero✨ — Fri, 10 Apr 2026 01:02:06 +0000

Cuando estaba en la universidad estudiando ingeniería electrónica, había algo que me desconcertaba mucho.
Habían circuitos que simplemente… no funcionaban.
Yo revisaba todo: los cables, las resistencias, el diseño.
Todo parecía correcto.
Y aún así, nada.
Pero luego pasaba algo extraño.
Sin cambiar nada importante, sin rediseñar nada…
de repente el circuito funcionaba.
Y yo pensaba:
¿Qué acaba de pasar?

🔌 El misterio del circuito que “decide” funcionar

Con el tiempo entendí que no era magia (aunque lo parecía).
Eran cosas pequeñas:
un contacto flojo
ruido eléctrico
una variación mínima en el voltaje
temperatura
estados internos que yo no veía
Pequeñas cosas invisibles… que cambiaban todo.
Y ahí aprendí algo sin darme cuenta:
Los sistemas complejos no siempre son completamente predecibles.

🤖 Años después: los LLMs

Mucho tiempo después, trabajando con modelos de inteligencia artificial, volví a sentir esa misma sensación.
Le escribes un prompt a un modelo…
y responde increíble.
Le cambias una palabra…
y responde algo totalmente distinto.
A veces brillante.
A veces extraño.
A veces completamente fuera de lugar.
Y otra vez aparece la misma pregunta:
¿Qué acaba de pasar?
🧠 No es un error… es la naturaleza del sistema
Así como los circuitos:
los LLMs también son sistemas sensibles.
Cambios pequeños → resultados grandes
Condiciones iniciales → importan mucho
Estados internos → invisibles
Comportamiento → no siempre determinista
No es que estén “mal hechos”.
Es que están vivos en su complejidad.

🌫️ Lo invisible también cuenta

En un circuito, no ves:
el ruido
la micro variación de voltaje
la calidad del contacto
En un modelo, no ves:
los pesos internos
las probabilidades
el proceso de decisión palabra por palabra
Pero todo eso está ahí, influyendo.

🔄 El pasado siempre importa

Algo que también comparten:
👉 el contexto cambia el resultado
En circuitos:
la carga previa de un capacitor cambia el comportamiento
En LLMs:
las palabras anteriores cambian completamente la respuesta
Nada empieza desde cero.

✨ La lección que me llevo

Hoy entiendo esos momentos de la universidad con más cariño.
No eran errores frustrantes.
Eran una invitación a entender algo más profundo:
Que no todo sistema está hecho para ser perfectamente predecible.
Y que aprender a trabajar con eso… también es ingeniería.

A veces siento que no he cambiado tanto de mundo.
Antes trabajaba con cables, voltajes y señales.
Ahora trabajo con palabras, prompts y modelos.
Pero en el fondo…
sigo hablando con sistemas sensibles,
complejos,
y un poco misteriosos.

Docker for Data People: Simplifying Development with Containers

🦄 Maris Botero✨ — Thu, 18 Sep 2025 01:07:24 +0000

Have you ever worked on a data project that worked perfectly on your laptop… but broke as soon as you shared it with someone else? That’s where Docker shines.

In this article, we’ll explore what Docker is, why it matters for data analysts and developers, and how to containerize a simple data project with one command.

🐳 What is Docker?

Docker is a platform built on open-source technology that lets you package your code, dependencies, and environment into a container — a lightweight, standalone unit that runs anywhere.

Think of it like a magical box that holds everything your project needs to run, no matter where you open it.

💡 Why Should Data Analysts Care?

Reproducibility: Ensure your analysis runs the same on any machine.
Isolation: Avoid dependency conflicts between projects.
Portability: Easily share your code with coworkers or deploy to the cloud.
Speed: Run tools like Jupyter, PostgreSQL, or Python scripts in seconds.

📦 Basic Docker Concepts

Concept	What it means
Image	The recipe for your container (like a blueprint).
Container	A running instance of that image.
Dockerfile	A file that tells Docker how to build the image.

🧪 Example: Containerizing a Python Script

Let’s say you have a Python script called analyze.py that reads a CSV and outputs a summary.

🗂️ Your project folder:

my-analysis/
├── analyze.py
├── requirements.txt
└── Dockerfile

🐍 `analyze.py`

import pandas as pd

df = pd.read_csv('data.csv')
print(df.describe())

📋 `requirements.txt`

pandas

🐳 `Dockerfile`

FROM python:3.10-slim

WORKDIR /app

COPY . .

RUN pip install -r requirements.txt

CMD ["python", "analyze.py"]

🚀 Build and Run the Container

# Build the Docker image
docker build -t my-analysis .

# Run the container
docker run -v $(pwd)/data.csv:/app/data.csv my-analysis

Now your script runs inside a container with everything it needs — and it will work on any machine with Docker installed.

🔒 Bonus: Running Jupyter in Docker

Want to run a Jupyter Notebook inside a container?

docker run -p 8888:8888 jupyter/base-notebook

Then go to http://localhost:8888 in your browser — your notebooks, inside a container!

🧽 Conclusion

Docker is like a magic backpack for your data projects. Whether you're working with Python, SQL, or machine learning models, Docker helps you keep your environment clean, consistent, and ready to scale.

Start small — containerize one script or notebook. You’ll be amazed at how much smoother your workflow becomes.

✨Corre tu propio ChatGPT local con Docker y sin complicaciones ✨

🦄 Maris Botero✨ — Sat, 21 Jun 2025 18:20:46 +0000

✨ Introducción

¿Te imaginas tener una IA que entienda lenguaje natural funcionando completamente local en tu computador, sin conexión a internet ni claves de API?
En este artículo te guiaré paso a paso para que lo logres usando Docker Model Runner y Open WebUI, dos herramientas que hacen que la inteligencia artificial sea accesible para todos.

⚙️ ¿Qué tecnología estamos usando?

Antes de comenzar, vamos a entender qué hace cada parte:

🐳 Docker

Es una plataforma que te permite crear, correr y compartir aplicaciones dentro de contenedores. En este caso, nos permite ejecutar un modelo de lenguaje sin necesidad de instalar librerías complicadas.

🧠 Docker Model Runner

Es una funcionalidad reciente de Docker que automatiza la descarga, ejecución y exposición de modelos de IA como servicios, usando un archivo docker-compose.yaml.

Piensa en esto como tener una pequeña fábrica de modelos: tú le dices cuál quieres usar y Docker se encarga de traerlo y ponerlo a trabajar.

🖥️ Open WebUI

Es una interfaz gráfica amigable (como un mini ChatGPT) que se conecta al modelo que corre dentro del contenedor. Te permite escribirle al modelo y recibir respuestas sin tener que tocar código.

🧰 ¿Qué necesitas?

Docker Desktop (versión 4.40 o superior)
Un computador con al menos 8 GB de RAM (preferiblemente con GPU)
Conexión a internet solo para descargar el modelo
Ganas de experimentar 🌟

🔧 Paso 1: Activa Docker Model Runner

docker desktop enable model-runner --no-tcp

📦 Paso 2: Descarga tu primer modelo de lenguaje

docker model pull ai/gemma3-qat:1B-Q4_K_M

🧬 Paso 3: Crea tu archivo docker-compose.yaml

services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OPENAI_API_BASE_URL=http://model-runner.docker.internal:80/engines/llama.cpp/v1
      - OPENAI_API_KEY=na
    volumes:
      - open-webui-data:/app/backend/data
    depends_on:
      - ai-runner

  ai-runner:
    provider:
      type: model
      options:
        model: ai/gemma3-qat:1B-Q4_K_M

volumes:
  open-webui-data:

▶️ Paso 4: Levanta el entorno▶️ Paso 4: Levanta el entorno

docker compose up

Verás que Docker descarga y prepara todo. Cuando veas el mensaje:

Model loaded in Xs
Listening on 0.0.0.0:8080

¡Todo está listo!

🌐 Paso 5: Abre tu interfaz mágica

Abre tu navegador en:

👉 http://localhost:3000

1. Crea un usuario

2. Selecciona el modelo

3. ¡Pregunta lo que quieras! 🎉

📚 Recursos útiles

🐳 Docker

💻 Repositorio del taller

🔗 Repositorio en GitHub con todo el paso a paso

Supercharge Your Data Analysis with BigQuery ML

🦄 Maris Botero✨ — Fri, 28 Mar 2025 14:23:00 +0000

Have you ever wanted to build machine learning models without leaving your data warehouse? With BigQuery ML (BQML), you can create, train, and deploy machine learning models directly using SQL — no need to export data or become a Python expert.

In this article, we’ll explore what BigQuery ML is, why it matters, and walk through a practical example so you can get started right away.

🔍 What is BigQuery ML?

BigQuery ML is a feature in Google BigQuery that allows users to build and operationalize machine learning models using standard SQL queries. It brings the power of machine learning closer to analysts and BI professionals by enabling model training and prediction directly inside BigQuery.

⚡ Why Use BigQuery ML?

No data movement: Models are built and run on your existing BigQuery tables.
Scalability: Built on top of Google’s infrastructure.
Familiar syntax: If you know SQL, you can start using ML.
Integration: Works seamlessly with Looker, Data Studio, and other GCP tools.

🧠 What Kind of Models Can You Build?

BigQuery ML supports several model types, including:

Model Type	Use Case
`linear_reg`	Predicting numeric values (e.g. prices)
`logistic_reg`	Binary classification (e.g. churn)
`kmeans`	Clustering
`time_series`	Forecasting
`xgboost`, `dnn`	Advanced classification & regression

🧪 Hands-on Example: Predicting Customer Churn

Let’s build a logistic regression model to predict customer churn using public data.

📦 Step 1: Prepare the Dataset

We’ll use a mock dataset of customers with basic features like age, tenure, and contract type.

-- Preview the data
SELECT * FROM `your_project.your_dataset.customers` LIMIT 10;

🏗️ Step 2: Create the Model

We’ll split the data into training and evaluation using a column called data_split.

CREATE OR REPLACE MODEL `your_project.your_dataset.churn_model`
OPTIONS(model_type='logistic_reg') AS
SELECT
  age,
  tenure,
  contract_type,
  monthly_charges,
  churned AS label
FROM
  `your_project.your_dataset.customers`
WHERE data_split = 'train';

📊 Step 3: Evaluate the Model

Use built-in evaluation metrics to understand the model’s performance.

SELECT *
FROM ML.EVALUATE(MODEL `your_project.your_dataset.churn_model`,
                 (SELECT
                    age,
                    tenure,
                    contract_type,
                    monthly_charges,
                    churned AS label
                  FROM `your_project.your_dataset.customers`
                  WHERE data_split = 'eval'));

🔮 Step 4: Make Predictions

Now use the model to predict the likelihood of churn for new users.

SELECT
  customer_id,
  predicted_label,
  predicted_probability
FROM ML.PREDICT(MODEL `your_project.your_dataset.churn_model`,
                (SELECT
                   customer_id,
                   age,
                   tenure,
                   contract_type,
                   monthly_charges
                 FROM `your_project.your_dataset.customers`
                 WHERE data_split = 'test'));

💡 Tips and Best Practices

Clean and normalize your data beforehand.
Use ML.FEATURE_INFO() to explore feature importance.
Try other model types like boosted_tree_classifier for more complex tasks.
Store model metadata in a tracking table.

🧽 Conclusion

BigQuery ML opens the doors to machine learning for data analysts. By leveraging SQL and your existing BigQuery environment, you can explore predictive analytics faster and more efficiently than ever before.

So why wait? Start experimenting today and turn your data into actionable insights with just a few lines of SQL.

Simplify Your Development with DevContainers in Docker and VS Code

🦄 Maris Botero✨ — Thu, 16 Jan 2025 20:21:10 +0000

Overview

Modern development environments often require consistent setups to ensure smooth collaboration and efficient workflows. However, achieving this can be a daunting task when dealing with diverse operating systems, dependencies, and tools. Enter DevContainers, a powerful feature of Docker and Visual Studio Code (VS Code) that simplifies and streamlines the development process.

In this guide, we’ll explore how DevContainers can revolutionize your workflow, making development faster, more consistent, and easier to manage.

What Are DevContainers?

DevContainers, short for Development Containers, are a feature that allows you to run your development environment inside a Docker container. This means you can define a consistent environment, complete with all dependencies, configurations, and tools, in a version-controlled file. VS Code seamlessly integrates with Docker to spin up these environments, ensuring you and your team work in identical setups regardless of the host machine.

Why Use DevContainers?

Key Benefits

Consistency Across Environments: Say goodbye to the dreaded "it works on my machine" issue. DevContainers ensure that every developer works in an identical environment.
Simplified Onboarding: New team members can get started quickly without spending hours installing dependencies or troubleshooting environment issues. All they need is Docker, VS Code, and your repository.
Isolation: Keep your development environment isolated from your host machine to avoid conflicts between project dependencies.
Version Control for Environments: Your DevContainer configuration file (devcontainer.json) lives in your repository, making your development setup version-controlled and reproducible.
Portability: Work on your project from any machine with Docker and VS Code installed, regardless of the underlying operating system.

Setting Up a DevContainer

Prerequisites

Install Docker.
Install Visual Studio Code.
Install the Remote - Containers extension in VS Code.

Step-by-Step Guide

Adding DevContainer Support

Open your project in VS Code.
Press Ctrl+Shift+P (or Cmd+Shift+P on macOS) and type Add Development Container Configuration Files. Select the appropriate configuration for your project. For Node.js, choose "Node.js."
This will create a .devcontainer folder in your project, containing:
- devcontainer.json: The configuration file for your container.
- A Dockerfile (optional): Defines the container’s base image and setup.

Customizing the DevContainer

Modify the devcontainer.json file to include additional settings, dependencies, or extensions. Example:

{
  "name": "Node.js DevContainer",
  "image": "mcr.microsoft.com/vscode/devcontainers/javascript-node:latest",
  "settings": {
    "terminal.integrated.defaultProfile.linux": "bash"
  },
  "extensions": [
    "dbaeumer.vscode-eslint",
    "esbenp.prettier-vscode"
  ],
  "postCreateCommand": "npm install"
}

Starting the DevContainer

Open the Command Palette (Ctrl+Shift+P) and type Reopen in Container.

VS Code will build and open your project inside the DevContainer.

Working Inside a DevContainer

Once the container is up and running, you can:

Access the terminal inside the container.
Use extensions installed via devcontainer.json.
Debug and run your application as if you were on your host machine.

VS Code seamlessly connects to the container, making it feel like a local development environment.

Conclusion

DevContainers combine the power of Docker and VS Code to create a robust, consistent, and flexible development environment. Whether you’re working solo or as part of a team, they simplify setup, reduce errors, and enhance productivity. By leveraging DevContainers, you’ll spend less time configuring environments and more time building great software.

Ready to transform your workflow? Start using DevContainers today and experience the difference they make!

🍲 Enchanted Recipe for a Machine Learning Model on Google Cloud 🍲

🦄 Maris Botero✨ — Thu, 14 Nov 2024 18:26:13 +0000

Ingredients:

1 cup of Clean Data (extracted and transformed in BigQuery)
2 tablespoons of Data Visualization (prepared in Data Studio)
3 teaspoons of Preprocessing (normalization, standardization, and feature selection in AI Platform Notebooks)
A pinch of Adjusted Hyperparameters (slow-cooked in Vertex AI)
A touch of Evaluation and Testing (for that “final seasoning”)

Magic Preparation Instructions:

Step 1: Gathering Ingredients in BigQuery 🥄

Extract and transform your data in BigQuery. This is the first step to ensure fresh, clean data.
Use SQL queries to filter and clean your data, just like selecting the best fruits from the market.

Step 2: Visual Preparation in Data Studio 🍉

Bring your data into Data Studio to visualize and better understand its shape and content.
Create charts and tables to uncover hidden patterns, as if your ingredients are whispering to you about how to combine them.

Step 3: Mise en Place in AI Platform Notebooks 🍴

Preprocess the data in AI Platform Notebooks, where the ingredients are carefully portioned and prepared.
Normalize and standardize the data, and select the finest features as though picking the perfect spices to flavor the final dish.

Step 4: Hyperparameter Cooking in Vertex AI 🍲

Transfer your data into Vertex AI and start mixing! Adjust hyperparameters with precision, like calculating the exact cooking time.
Let the model cook patiently, training until it reaches its best version.

Step 5: Seasoning Test (Evaluation and Testing) 🌶️

Serve the model on a validation dataset to test its "flavor" (performance).
Adjust and evaluate metrics like precision and recall, aiming for a perfect balance.

Step 6: Serving the Dish in Cloud Run 🍛

Deploy the model in AI Platform Prediction or Cloud Run, creating an endpoint so every customer can enjoy it.
Set up API authentication so only authorized tasters get a sample.

Final Garnish ✨

Monitor and optimize the model in production with Cloud Monitoring, ensuring every prediction is well “seasoned.”
Scale and adjust so every customer, in real-time or batch, receives the best service.

And Voilà! 🎩

Your Machine Learning model on Google Cloud is ready and waiting to be enjoyed.

Exploring Generative Art with JavaScript

🦄 Maris Botero✨ — Tue, 24 Sep 2024 19:54:34 +0000

Generative art is a technique where the artist creates systems, usually in the form of algorithms, that autonomously generate artworks. These systems can produce infinite results from an initial set of rules, making the process fascinating and full of possibilities. In this article, we will delve into the world of generative art using JavaScript and, more specifically, the popular library p5.js.

What is Generative Art?

Generative art relies on creating systems that can generate an infinite number of variations of a work of art. These systems can be controlled by specific rules, mathematical algorithms, or even randomness. With each execution of the system, a new, unique, and visually interesting artwork can be produced.

This form of art is deeply connected to programming, as the rules and code define how the visual results are created. Generative artists use algorithms to define patterns, colors, shapes, and movement, making every work a process of discovery.

Why JavaScript?

JavaScript is a versatile and accessible language that runs directly in web browsers, allowing immediate visualization of generative art results. Moreover, thanks to libraries like p5.js, it’s possible to create complex graphics with just a few lines of code.

p5.js is a JavaScript library specifically designed for creating interactive and visual graphics. Its simplicity makes it an ideal tool to start exploring generative art.

Getting Started with p5.js

Setting up the Environment

To start creating generative art with JavaScript, all you need is a browser and a code editor. You can use the p5.js web editor or download the library and add it to your project.

The Basic Skeleton of a p5.js Sketch

Every p5.js sketch is structured into two main functions:

setup(): This function runs once at the beginning. It's where we set up the canvas, colors, and any initial parameters.
draw(): This function runs repeatedly in a loop. Here, we place the instructions to draw and create the visual elements.

Here’s a basic example:


function setup() {
  createCanvas(800, 800); // Create an 800x800 pixel canvas
  background(255); // White background
}

function draw() {
  noLoop(); // Prevent the draw function from looping
  for (let i = 0; i < 100; i++) {
    let x = random(width);
    let y = random(height);
    fill(random(255), random(255), random(255), 150); // Random colors with transparency
    noStroke();
    ellipse(x, y, random(50, 100)); // Draw random circles
  }
}

In this basic sketch, we create a blank canvas and draw 100 circles with random colors, each positioned randomly. The beauty of generative art lies in the variability of the results. With each run of the code, the circles will appear in different locations and with different colors.

Creating Patterns with Math

Generative art often combines randomness with precise mathematical structures. Let’s see an example where we generate a geometric pattern based on regular shapes and cyclical movements:


function setup() {
  createCanvas(800, 800);
  background(255);
  noFill();
  stroke(0, 50);
}

function draw() {
  translate(width / 2, height / 2); // Move the origin to the center
  let radius = 300;
  for (let i = 0; i < 100; i++) {
    let angle = map(i, 0, 100, 0, TWO_PI);
    let x = radius * cos(angle);
    let y = radius * sin(angle);
    ellipse(x, y, 50, 50); // Draw circles in a circular pattern
  }
  noLoop(); // Static drawing
}

In this example, we use trigonometric functions like cos() and sin() to distribute 100 circles around the canvas center in a circular pattern. The beauty of math in generative art is that you can use simple equations to create complex and surprising patterns.

Adding Interactivity

One of the great advantages of working with JavaScript and p5.js is how easily you can add interactivity to your creations. Below is an example where the colors of a pattern change according to the mouse position:

function setup() {
  createCanvas(800, 800);
}

function draw() {
  background(255);
  let numLines = 50;
  let spacing = width / numLines;

  for (let i = 0; i < numLines; i++) {
    let x = i * spacing;
    let colorValue = map(mouseX, 0, width, 0, 255); // Changes with mouse position
    stroke(colorValue, 100, 150);
    line(x, 0, width / 2, height);
  }
}

In this sketch, the color of the lines changes based on the mouse position. Interactivity is an essential component of generative art, as it allows the viewer to directly influence the artwork.

Conclusion

Generative art with JavaScript opens up a world of creative possibilities. Using p5.js, we can transform mathematical equations, random functions, and user interactions into dynamic and surprising visuals. The best part is that, thanks to the flexibility of this environment, the results are unique and always different with each execution.

Exploring generative art is a great way to blend programming and creativity. Experiment with different shapes, colors, and patterns to see how far you can push your own generative artwork!

Dibujando una Cara Sonriente con p5.js

🦄 Maris Botero✨ — Wed, 11 Sep 2024 16:12:22 +0000

Dibujando una Cara Sonriente con p5.js

En este artículo, exploraremos cómo utilizar la biblioteca p5.js para crear un simple pero encantador dibujo: una cara sonriente. p5.js es una biblioteca de JavaScript que facilita la creación de gráficos y animaciones interactivas. Es ideal para artistas, diseñadores y desarrolladores que desean crear proyectos visuales basados en código.

¿Qué es p5.js?

p5.js es una biblioteca orientada a hacer accesible el mundo de la programación visual. Ofrece un conjunto de funciones que permiten dibujar formas, crear animaciones, e interactuar con el usuario de manera sencilla. Aunque está escrita en JavaScript, los usuarios no necesitan ser expertos en este lenguaje para empezar a crear visuales llamativos.

Estructura básica de un sketch en p5.js

Un sketch en p5.js tiene dos funciones principales:

setup(): Se ejecuta una vez al principio. Aquí es donde inicializamos el lienzo, configuramos colores, y preparamos cualquier elemento necesario.
draw(): Se ejecuta en bucle, cuadro por cuadro. Aquí colocamos las instrucciones que queremos que se repitan continuamente (como una animación). En nuestro caso, no requerimos una animación, así que lo dejaremos vacío.

El proyecto: una cara sonriente

El objetivo es dibujar una cara sonriente utilizando formas simples: un círculo grande para la cara, dos círculos más pequeños para los ojos, y un arco para la boca.

Paso 1: Crear el lienzo

Lo primero que hacemos es definir el tamaño del lienzo. En este caso, usaremos un tamaño de 400x400 píxeles y estableceremos un fondo negro.

function setup() {
  createCanvas(400, 400);
  background(0); // Fondo negro
}

Paso 2: Dibujar la cara

La cara es simplemente un gran círculo. Para dibujar un círculo en p5.js, usamos la función ellipse(), que requiere las coordenadas de su centro, y su ancho y alto. En nuestro caso, dibujaremos el círculo en el centro del lienzo, con un diámetro de 200 píxeles.

stroke(255); // Color de línea blanco
strokeWeight(5); // Grosor de la línea
noFill(); // Sin relleno para el círculo
ellipse(200, 200, 200, 200); // Dibuja la cara

Paso 3: Dibujar los ojos

Los ojos son dos pequeños círculos blancos. Podemos usar la misma función ellipse(), pero esta vez les damos un relleno blanco y los colocamos ligeramente hacia arriba y a los lados del centro de la cara.

fill(255); // Relleno blanco para los ojos
noStroke(); // Sin borde para los ojos
ellipse(160, 170, 20, 20); // Ojo izquierdo
ellipse(240, 170, 20, 20); // Ojo derecho

Paso 4: Dibujar la sonrisa

Finalmente, para la sonrisa usamos la función arc(). Esta función permite dibujar un arco elíptico que, en este caso, se parece a una sonrisa. Ajustamos las coordenadas para que la curva esté centrada y se vea como una boca.

noFill(); // Sin relleno para la boca
stroke(255); // Líneas blancas de nuevo
arc(200, 220, 100, 80, 0, PI); // Dibuja la sonrisa

El código completo:

function setup() {
  createCanvas(400, 400);
  background(0); // Fondo negro

  stroke(255); // Color de línea blanco
  strokeWeight(5); // Grosor de la línea
  noFill(); // Sin relleno para el círculo

  // Dibuja la cara (un círculo grande)
  ellipse(200, 200, 200, 200);

  // Ojos (dos círculos pequeños)
  fill(255); // Relleno blanco para los ojos
  noStroke(); // Sin borde para los ojos
  ellipse(160, 170, 20, 20);
  ellipse(240, 170, 20, 20);

  // Boca sonriente
  noFill(); // Sin relleno para la boca
  stroke(255); // Líneas blancas de nuevo
  arc(200, 220, 100, 80, 0, PI); // Dibuja la sonrisa
}

function draw() {
  // No se requiere animación, por lo que dejamos el draw vacío
}

Conclusión

Este sencillo ejemplo muestra cómo, con unas pocas líneas de código, podemos crear gráficos atractivos utilizando p5.js. Aunque este proyecto es básico, los principios que se utilizan aquí pueden escalarse para crear visuales mucho más complejos y detallados. Si deseas experimentar más, puedes intentar cambiar el tamaño de los elementos, agregar color o incluso hacer una animación en el draw().

¡Anímate a crear tu propia versión de esta cara sonriente y explorar lo que p5.js tiene para ofrecer!

Data, ML, and AI in Google Cloud

🦄 Maris Botero✨ — Fri, 06 Sep 2024 20:32:10 +0000

In today's world, data has become one of the most valuable resources. The amount of data we produce, store, and process is growing exponentially, and with this, the need for advanced tools and platforms to handle such massive datasets becomes essential.

Have you ever wondered how big a petabyte of data is? Imagine a stack of floppy disks that would reach twelve times higher than the Empire State Building, or every tweet ever sent multiplied by 50. This is the magnitude of data we are dealing with in many industries today. Google Cloud offers solutions to manage this data efficiently, making it possible to not only store and analyze vast amounts of information but also to leverage this data for machine learning (ML) and artificial intelligence (AI) applications.

With tools like BigQuery, AutoML, and TensorFlow within Google Cloud, businesses and developers can harness the power of data in ways that were unimaginable just a few years ago.

Key Data Tools in Google Cloud: Dataproc, Dataflow, and BigQuery

Google Cloud provides a suite of tools to handle big data efficiently. Dataproc is designed to process large datasets using familiar frameworks like Hadoop and Spark, making it easier to manage and analyze data at scale. Dataflow offers a fully managed solution for real-time and batch data processing, allowing seamless ETL workflows. Lastly, BigQuery serves as Google’s enterprise data warehouse, offering fast, SQL-like queries to analyze vast amounts of data without the burden of infrastructure management. Together, these tools empower businesses to extract value from their data and make informed decisions powered by AI and ML.

Getting Started with Machine Learning and AI in Google Cloud

To effectively leverage machine learning (ML) and artificial intelligence (AI) within Google Cloud, follow these key steps:

Define machine learning (ML), understand the terminology used, and identify the value proposition.

Start by building a solid understanding of ML concepts and how they align with your business goals.
Explore Vertex AI, Google’s unified AI platform.

Vertex AI provides a powerful platform for developing, deploying, and managing ML models at scale, simplifying the AI workflow.
Use Google APIs to apply a range of pre-trained ML models.

Google offers a variety of APIs that allow you to use pre-trained models for tasks like image recognition, natural language processing, and more.

Exploring Vertex AI: Google’s Unified AI Platform

Vertex AI is Google Cloud's fully managed platform designed to streamline the process of building and deploying machine learning models. It brings together all the tools necessary to manage every aspect of the machine learning lifecycle—from data preparation to model training and monitoring.

With Vertex AI, you can:

Automate the creation of ML models with AutoML.
Train and deploy custom models using tools like TensorFlow or PyTorch.
Scale easily with managed services that eliminate infrastructure management.

This platform is perfect for both beginners who need end-to-end solutions, and experts looking for flexibility in creating and deploying advanced ML models.

Using Google’s Pre-trained Machine Learning APIs

Google Cloud offers a range of powerful APIs that allow developers to integrate machine learning capabilities into their applications without needing to train models from scratch. These pre-trained models are ready to use for tasks such as:

Vision API for image analysis.
Natural Language API for text and sentiment analysis.
Speech-to-Text API for converting spoken language into written text.
Translation API to automatically translate text between languages.

By using these APIs, businesses can quickly add machine learning functionality to their applications, improving user experiences and decision-making processes without needing in-depth ML expertise.

Conclusion

Google Cloud offers a wide variety of tools and platforms that empower businesses to harness the potential of data, machine learning (ML), and artificial intelligence (AI). From data processing with Dataproc and Dataflow, to storage and querying with BigQuery, and advanced ML development with Vertex AI and pre-trained APIs, Google Cloud provides a comprehensive ecosystem for driving innovation.

Whether you're just starting with ML or looking to scale your AI efforts, Google Cloud's suite of services offers everything needed to take your data and insights to the next level. As we continue to navigate the data-driven world, having access to these tools will be crucial for staying competitive and making informed, data-driven decisions.

Ready to begin your journey with Google Cloud's AI and ML tools? Explore the documentation, try out the APIs, or dive into Vertex AI to experience how easy it can be to transform data into actionable insights.

Creating a Dynamic Geometric Animation with p5.js

🦄 Maris Botero✨ — Tue, 27 Aug 2024 19:05:47 +0000

Introduction

In this tutorial, you will learn how to create a dynamic and colorful geometric animation using p5.js.The shapes will move randomly across the canvas, changing colors and creating a visually captivating effect.

Step 1: Setting Up Your Environment

Download p5.js:
- Go to the p5.js website and download the latest version of p5.js.
- Alternatively, you can use the online p5.js editor editor.p5js.org, which allows you to write and run your code directly in your browser.
Create a New Project:
- If you’re using the online editor, create a new sketch by clicking on "New" in the top left corner.
- If you’re coding locally, create a new HTML file and link the p5.js library.

Step 2: Writing the Basic Structure

Let’s start by setting up the basic structure of our p5.js sketch. This includes defining the setup() and draw() functions.

function setup() {
  createCanvas(windowWidth, windowHeight);
  noStroke();  // Disable stroke for the shapes
}

function draw() {
  background(30, 30, 60, 25);  // Dark background with transparency
}

Explanation:

createCanvas(windowWidth, windowHeight);: This sets the canvas size to match your browser window.
noStroke();: This removes the border from the shapes we will create.
background(30, 30, 60, 25);: This sets the background color to a dark blue with some transparency, creating a trailing effect for the shapes.

Step 3: Adding Dynamic Geometric Shapes

Now, let’s add the code to create random shapes with varying colors, positions, and sizes.

function draw() {
  background(30, 30, 60, 25); // Dark background with transparency

  for (let i = 0; i < 5; i++) {
    let x = random(width);
    let y = random(height);
    let size = random(20, 80);
    let colorR = random(255);
    let colorG = random(255);
    let colorB = random(255);
    let shapeType = random(['ellipse', 'rect', 'triangle']);

    fill(colorR, colorG, colorB, 150); // Set fill color with some transparency

    if (shapeType === 'ellipse') {
      ellipse(x, y, size, size);
    } else if (shapeType === 'rect') {
      rect(x, y, size, size);
    } else if (shapeType === 'triangle') {
      triangle(x, y, x + size, y, x + size / 2, y - size);
    }
  }
}

Explanation:

Randomized Variables:
- x and y determine the position of each shape on the canvas.
- size controls the size of each shape.
- colorR, colorG, colorB generate random values for the red, green, and blue components of the fill color.
- fill(colorR, colorG, colorB, 150);: This sets the fill color with a slight transparency.
Shape Types:
- ellipse(x, y, size, size);: Draws a circle or ellipse.
- rect(x, y, size, size);: Draws a square or rectangle.
- triangle(x, y, x + size, y, x + size / 2, y - size);: Draws a triangle.

Step 4: Making the Animation Responsive

To make sure the canvas resizes with the window, add the following function:

function windowResized() {
  resizeCanvas(windowWidth, windowHeight);
}

Step 5: Running Your Sketch

If you’re using the p5.js online editor, simply press the "Play" button to see your animation.
If you’re coding locally, open your HTML file in a web browser to view the animation.

Juguemos piedra, papel y tijera con redes neuronales💙

🦄 Maris Botero✨ — Sun, 24 May 2020 19:19:02 +0000

¿Alguna vez has escuchado el término de machine learning o aprendizaje automático? ¿Es algo que está de moda? ¿Realmente es útil? ¿se tiene que saber mucha matemáticas, estadística y programación? 🤔. El machine learning es una disciplina ligada a la inteligencia artificial y a la estadística que le permite a nuestros ordenadores aprender a resolver problemas sin ser explícitamente programados para ello. El resultado que obtenemos con machine learning son algoritmos capaces de hacer predicciones y tomar decisiones sin programación previa y con datos que no han visto nunca. 😮

Aunque el camino para aprender requiere conocer de SQL, bases de datos, matemáticas, estadística, programación entre otros. En este tutorial vamos a realizar un juego de piedra, papel o tijeras entrenando una red neuronal, la cual aprenderá a jugar y a ganar. Con este pequeño tutorial verás que con algunas herramientas ya estarás entrenado tu primer algoritmo de aprendizaje automático, el lenguaje de programación que utilizaremos será python, ya veras que muy pronto aprenderás a realizar tus increíbles proyectos de machine learning.
Siempre he pensado que es mejor disfrutar el camino, que pensar en la gran meta.😝 Divertirse mientras puedes aprender cosas nuevas es algo de lo más me gusta hacer, así que si me acompañas vamos a jugar un poco.🤗

comencemos🤓

1. Creamos una lista para las opciones de nuestro juego 🎲

Una lista es una estructura de datos usadas en python 🐍. Lo maravilloso de las listas es que puedes almacenar cualquier tipo de valor como un entero, una cadena de texto y hasta otras funciones.
La notación para lista es una secuencia de valores encerrados entre corchetes y separados por comas. Para nuestro caso tenemos una lista de opciones del juego.

`options = ["👊", "✌", "🖐"]`

💜Nuestras opciones:
- "👊" : piedra
- "🖐" : papel
- "✌" : tijera

Luego, hacemos una pequeña función donde escribimos las reglas del juego, Tenemos dos jugadores llamados p1 y p2 y vamos a ver cuáles son las opciones para ganar.

def search_winner(p1, p2):
    if p1 == p2:
        result = 0
    elif p1 == "👊" and p2 == "✌":
        result = 1
    elif p1 == "👊" and p2 == "🖐":
        result = 2
    elif p1 == "✌" and p2 == "👊":
        result = 2
    elif p1 == "✌" and p2 == "🖐":
        result = 1
    elif p1 == "🖐" and p2 == "👊":
        result = 1
    elif p1 == "🖐" and p2 == "✌":
        result = 2

    return result

Así podemos comprobar nuestra función:

`search_winner("🖐", "✌")`
`search_winner("✌","✌")`

Ahora vamos a crear un pequeño test, para seguir haciendo pruebas. Además hacemos una alternación y pintamos la validación del test. una iteración es repetir el proceso varias veces y algo muy útil en programación.

test = [
["👊", "👊", 0],
["👊", "✌", 1],
["👊", "🖐", 2]
]

for partida in test:
print("player1: %s player2: %s Winner: %s Validation: %s" % (
partida[0], partida[1], search_winner(partida[0], partida[1]), partida[2]
))


y estos son los resultados del test:






```
player1: 👊 player2: 👊 Winner: 0 Validation: 0
player1: 👊 player2: ✌ Winner: 1 Validation: 1
player1: 👊 player2: 🖐 Winner: 2 Validation: 2
```





💜Luego creamos una pequeña función que sea random, para el jugador 1 y el jugador 2. Importamos el modulo random con el cual podemos generar números aleatorios.




```
from random import choice
def get_choice():
    return choice(options)

```



💜Ahora una pequeña prueba, para ver nuestros resultados con la función random:



```
for i in range(10):
    player1 = get_choice()
    player2 = get_choice()
    print("player1: %s player2: %s Winner: %s " % (
        player1, player2, search_winner(player1, player2)
    ))

```


💜Después de ejecutar la función tenemos:



```
player1: 👊 player2: 👊 Winner: 0 
player1: 👊 player2: ✌ Winner: 1 
player1: 🖐 player2: ✌ Winner: 2 
player1: ✌ player2: 🖐 Winner: 1 
player1: 👊 player2: ✌ Winner: 1 
player1: ✌ player2: 🖐 Winner: 1 
player1: 🖐 player2: 👊 Winner: 1 
player1: 👊 player2: 🖐 Winner: 2 
player1: 🖐 player2: ✌ Winner: 2 
player1: 👊 player2: 👊 Winner: 0 

```



💜Muy bien!!!! Hemos avanzado mucho en la estructura general nuestro juego, estableciendo las reglas del mismo, cuando realizas algún proyecto de programación siempre es importante partir el problema en pasos más pequeños e ir aumentando el nivel de dificultad, no te preocupes si al principio te cuesta un poco, todos pasamos por eso, solamente permanece en el camino lo puedes lograr.

Ahora vamos a hablar de Redes Neuronales 💁‍♀

## 2. Red Neuronal 🧠
Empecemos con nuestra red neuronal, vamos a hacer una función que convierta los emojis a una lista de ceros y unos para que nuestra red neuronal entienda mejor. Donde la piedra "👊"es [1,0,0], si es tijeras "✌" es [0,1,0] y si es papel "🖐" es [0,0,1]. Imagínate que las máquinas se hablan entre ellas y a esto se le denomina lenguaje de máquina o código de máquina, este lenguaje es una serie de instrucciones en forma de ceros y unos las cuales se ejecutan de manera secuencial. 👩‍💻
Una red neuronal artificial es un sistema que compone de entradas en su interior se realizan funciones de activación para producir salida. Lo que se busca con estos sistemas es que nuestros algoritmos ganen cierta inteligencia de las entradas para realizar una predicción. En nuestro caso queremos que la red aprenda las reglas del juego y que aprenda a ganar.😜

Ahora definamos una nueva función para que nuestro sistema entienda el lenguaje de máquina:



```
def str_to_list(option):
    if option=="👊":
        res = [1,0,0]
    elif option=="✌":
        res = [0,1,0]
    else:
        res = [0,0,1]
    return res

data_X = list(map(str_to_list, ["👊", "✌", "🖐"]))
data_y = list(map(str_to_list, ["🖐", "👊", "✌"]))

print(data_X)
print(data_y)

```



Este es nuestro resultado:



```

[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
[[0, 0, 1], [1, 0, 0], [0, 1, 0]]

```



⚡Ahora vamos a empezar con la red neuronal. Importamos la librería scikit-learn.

Scikit-learn es una librería ideal para diseñar y entrenar redes neuronales, esta librería es usada por spotify, Evernote y utiliza algoritmos de clasificación, regresión ,agrupamiento entre otros. Es una libreria genial para comenzar a entrar tus modelos de machine learning

🧡Te dejo el link con la documentación oficial:(https://scikit-learn.org/stable/)

Ahora vamos a importar nuestra librería y utilizar uno de sus algoritmos de clasificación:




```
from sklearn.neural_network import MLPClassifier
clf = MLPClassifier(verbose=False, warm_start=True)

```



🧡Este es un clasificador perceptrón multicapa que tiene capacidad para resolver problemas que no son linealmente separables. 

<a href="http://google.com.au/" rel="some text">![Foo](https://upload.wikimedia.org/wikipedia/commons/6/64/RedNeuronalArtificial.png)</a>

Las capas pueden clasificarse en tres tipos 🤓:

- Capa de entrada: Constituida por aquellas neuronas que introducen los patrones de entrada en la red. En estas neuronas no se produce procesamiento.
- Capas ocultas: Formada por aquellas neuronas cuyas entradas provienen de capas anteriores y cuyas salidas pasan a neuronas de capas posteriores.
- Capa de salida: Neuronas cuyos valores de salida se corresponden con las salidas de toda la red.

💚Ahora vamos a crear nuestro modelo así:



```
model = clf.fit([data_X[0]], [data_y[0]])
print(model)
```




Luego, hacemos una función *jugar a aprender*. La idea es que nuestra red neuronal empiece a aprender a ganar por medio de la experiencia. En la función definimos la predicción que debe ser igual o superior al 95%.




```
def play_and_learn(iters=10, debug=False):
    score = {"win": 0, "loose": 0}

    data_X = []
    data_y = []

    for i in range(iters):
        player1 = get_choice()

        predict = model.predict_proba([str_to_list(player1)])[0]

        if predict[0] >= 0.95:
            player2 = options[0]
        elif predict[1] >= 0.95:
            player2 = options[1]
        elif predict[2] >= 0.95:
            player2 = options[2]
        else:
            player2 = get_choice()

        if debug==True:
            print("Player1: %s Player2 (modelo): %s --> %s" % (player1, predict, player2))

        winner = search_winner(player1, player2)
        if debug==True:
            print("Comprobamos: p1 VS p2: %s" % winner)

        if winner==2:
            data_X.append(str_to_list(player1))
            data_y.append(str_to_list(player2))

            score["win"]+=1
        else:
            score["loose"]+=1

    return score, data_X, data_y


```


Y lo ejecutamos así (Queremos ver si nuestro modelo ha aprendido algo):



```
score, data_X, data_y = play_and_learn(1, debug=True)
print(data_X)
print(data_y)
print("Score: %s %s %%" % (score, (score["win"]*100/(score["win"]+score["loose"]))))
if len(data_X):
    model = model.partial_fit(data_X, data_y)

```


Después de ejecutar:



```
Player1: ✌ Player2 (modelo): [0.17561242 0.16144559 0.83639906] --> 👊
Comprobamos: p1 VS p2: 2
[[0, 1, 0]]
[[1, 0, 0]]
Score: {'win': 1, 'loose': 0} 100.0 %
```




💚Y finalmente vamos a repetir este ejercicio un montón de veces, los algoritmos de inteligencia artificial funcionan gracias a la repetición que se hace y también debido al gran volumen de datos que tenemos hoy en día. por lo cual nuestro sistema debe entrenarse con un montón de iteraciones para que aprenda a ganar.




```
i = 0
historic_pct = []
while True:
    i+=1
    score, data_X, data_y = play_and_learn(1000, debug=False)
    pct = (score["win"]*100/(score["win"]+score["loose"]))
    historic_pct.append(pct)
    print("Iter: %s - score: %s %s %%" % (i, score, pct))

    if len(data_X):
        model = model.partial_fit(data_X, data_y)

    if sum(historic_pct[-9:])==900:
        break

```



Y después de ejecutar tenemos que:



```

Iter: 1 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 2 - score: {'win': 317, 'loose': 683} 31.7 %
Iter: 3 - score: {'win': 366, 'loose': 634} 36.6 %
Iter: 4 - score: {'win': 326, 'loose': 674} 32.6 %
Iter: 5 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 6 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 7 - score: {'win': 340, 'loose': 660} 34.0 %
Iter: 8 - score: {'win': 327, 'loose': 673} 32.7 %
Iter: 9 - score: {'win': 329, 'loose': 671} 32.9 %
Iter: 10 - score: {'win': 326, 'loose': 674} 32.6 %
Iter: 11 - score: {'win': 339, 'loose': 661} 33.9 %
Iter: 12 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 13 - score: {'win': 340, 'loose': 660} 34.0 %
Iter: 14 - score: {'win': 345, 'loose': 655} 34.5 %
Iter: 15 - score: {'win': 304, 'loose': 696} 30.4 %
Iter: 16 - score: {'win': 351, 'loose': 649} 35.1 %
Iter: 17 - score: {'win': 349, 'loose': 651} 34.9 %
Iter: 18 - score: {'win': 353, 'loose': 647} 35.3 %
Iter: 19 - score: {'win': 336, 'loose': 664} 33.6 %
Iter: 20 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 21 - score: {'win': 321, 'loose': 679} 32.1 %
Iter: 22 - score: {'win': 336, 'loose': 664} 33.6 %
Iter: 23 - score: {'win': 365, 'loose': 635} 36.5 %
Iter: 24 - score: {'win': 356, 'loose': 644} 35.6 %
Iter: 25 - score: {'win': 355, 'loose': 645} 35.5 %
Iter: 26 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 27 - score: {'win': 335, 'loose': 665} 33.5 %
Iter: 28 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 29 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 30 - score: {'win': 354, 'loose': 646} 35.4 %
Iter: 31 - score: {'win': 324, 'loose': 676} 32.4 %
Iter: 32 - score: {'win': 307, 'loose': 693} 30.7 %
Iter: 33 - score: {'win': 328, 'loose': 672} 32.8 %
Iter: 34 - score: {'win': 340, 'loose': 660} 34.0 %
Iter: 35 - score: {'win': 369, 'loose': 631} 36.9 %
Iter: 36 - score: {'win': 349, 'loose': 651} 34.9 %
Iter: 37 - score: {'win': 335, 'loose': 665} 33.5 %
Iter: 38 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 39 - score: {'win': 317, 'loose': 683} 31.7 %
Iter: 40 - score: {'win': 299, 'loose': 701} 29.9 %
Iter: 41 - score: {'win': 337, 'loose': 663} 33.7 %
Iter: 42 - score: {'win': 327, 'loose': 673} 32.7 %
Iter: 43 - score: {'win': 351, 'loose': 649} 35.1 %
Iter: 44 - score: {'win': 342, 'loose': 658} 34.2 %
Iter: 45 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 46 - score: {'win': 300, 'loose': 700} 30.0 %
Iter: 47 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 48 - score: {'win': 342, 'loose': 658} 34.2 %
Iter: 49 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 50 - score: {'win': 312, 'loose': 688} 31.2 %
Iter: 51 - score: {'win': 312, 'loose': 688} 31.2 %
Iter: 52 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 53 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 54 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 55 - score: {'win': 329, 'loose': 671} 32.9 %
Iter: 56 - score: {'win': 335, 'loose': 665} 33.5 %
Iter: 57 - score: {'win': 334, 'loose': 666} 33.4 %
Iter: 58 - score: {'win': 353, 'loose': 647} 35.3 %
Iter: 59 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 60 - score: {'win': 329, 'loose': 671} 32.9 %
Iter: 61 - score: {'win': 338, 'loose': 662} 33.8 %
Iter: 62 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 63 - score: {'win': 315, 'loose': 685} 31.5 %
Iter: 64 - score: {'win': 313, 'loose': 687} 31.3 %
Iter: 65 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 66 - score: {'win': 317, 'loose': 683} 31.7 %
Iter: 67 - score: {'win': 319, 'loose': 681} 31.9 %
Iter: 68 - score: {'win': 314, 'loose': 686} 31.4 %
Iter: 69 - score: {'win': 306, 'loose': 694} 30.6 %
Iter: 70 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 71 - score: {'win': 338, 'loose': 662} 33.8 %
Iter: 72 - score: {'win': 333, 'loose': 667} 33.3 %
Iter: 73 - score: {'win': 338, 'loose': 662} 33.8 %
Iter: 74 - score: {'win': 324, 'loose': 676} 32.4 %
Iter: 75 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 76 - score: {'win': 326, 'loose': 674} 32.6 %
Iter: 77 - score: {'win': 349, 'loose': 651} 34.9 %
Iter: 78 - score: {'win': 315, 'loose': 685} 31.5 %
Iter: 79 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 80 - score: {'win': 306, 'loose': 694} 30.6 %
Iter: 81 - score: {'win': 356, 'loose': 644} 35.6 %
Iter: 82 - score: {'win': 353, 'loose': 647} 35.3 %
Iter: 83 - score: {'win': 357, 'loose': 643} 35.7 %
Iter: 84 - score: {'win': 305, 'loose': 695} 30.5 %
Iter: 85 - score: {'win': 342, 'loose': 658} 34.2 %
Iter: 86 - score: {'win': 352, 'loose': 648} 35.2 %
Iter: 87 - score: {'win': 318, 'loose': 682} 31.8 %
Iter: 88 - score: {'win': 339, 'loose': 661} 33.9 %
Iter: 89 - score: {'win': 334, 'loose': 666} 33.4 %
Iter: 90 - score: {'win': 339, 'loose': 661} 33.9 %
Iter: 91 - score: {'win': 328, 'loose': 672} 32.8 %
Iter: 92 - score: {'win': 325, 'loose': 675} 32.5 %
Iter: 93 - score: {'win': 330, 'loose': 670} 33.0 %
Iter: 94 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 95 - score: {'win': 328, 'loose': 672} 32.8 %
Iter: 96 - score: {'win': 324, 'loose': 676} 32.4 %
Iter: 97 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 98 - score: {'win': 344, 'loose': 656} 34.4 %
Iter: 99 - score: {'win': 326, 'loose': 674} 32.6 %
Iter: 100 - score: {'win': 350, 'loose': 650} 35.0 %
Iter: 101 - score: {'win': 319, 'loose': 681} 31.9 %
Iter: 102 - score: {'win': 313, 'loose': 687} 31.3 %
Iter: 103 - score: {'win': 344, 'loose': 656} 34.4 %
Iter: 104 - score: {'win': 349, 'loose': 651} 34.9 %
Iter: 105 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 106 - score: {'win': 360, 'loose': 640} 36.0 %
Iter: 107 - score: {'win': 350, 'loose': 650} 35.0 %
Iter: 108 - score: {'win': 306, 'loose': 694} 30.6 %
Iter: 109 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 110 - score: {'win': 340, 'loose': 660} 34.0 %
Iter: 111 - score: {'win': 314, 'loose': 686} 31.4 %
Iter: 112 - score: {'win': 334, 'loose': 666} 33.4 %
Iter: 113 - score: {'win': 337, 'loose': 663} 33.7 %
Iter: 114 - score: {'win': 332, 'loose': 668} 33.2 %
Iter: 115 - score: {'win': 331, 'loose': 669} 33.1 %
Iter: 116 - score: {'win': 332, 'loose': 668} 33.2 %
Iter: 117 - score: {'win': 347, 'loose': 653} 34.7 %
Iter: 118 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 119 - score: {'win': 319, 'loose': 681} 31.9 %
Iter: 120 - score: {'win': 353, 'loose': 647} 35.3 %
Iter: 121 - score: {'win': 366, 'loose': 634} 36.6 %
Iter: 122 - score: {'win': 323, 'loose': 677} 32.3 %
Iter: 123 - score: {'win': 335, 'loose': 665} 33.5 %
Iter: 124 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 125 - score: {'win': 328, 'loose': 672} 32.8 %
Iter: 126 - score: {'win': 322, 'loose': 678} 32.2 %
Iter: 127 - score: {'win': 341, 'loose': 659} 34.1 %
Iter: 128 - score: {'win': 348, 'loose': 652} 34.8 %
Iter: 129 - score: {'win': 323, 'loose': 677} 32.3 %
Iter: 130 - score: {'win': 366, 'loose': 634} 36.6 %
Iter: 131 - score: {'win': 324, 'loose': 676} 32.4 %
Iter: 132 - score: {'win': 346, 'loose': 654} 34.6 %
Iter: 133 - score: {'win': 319, 'loose': 681} 31.9 %
Iter: 134 - score: {'win': 314, 'loose': 686} 31.4 %
Iter: 135 - score: {'win': 343, 'loose': 657} 34.3 %
Iter: 136 - score: {'win': 315, 'loose': 685} 31.5 %
Iter: 137 - score: {'win': 345, 'loose': 655} 34.5 %
Iter: 138 - score: {'win': 538, 'loose': 462} 53.8 %
Iter: 139 - score: {'win': 540, 'loose': 460} 54.0 %
Iter: 140 - score: {'win': 549, 'loose': 451} 54.9 %
Iter: 141 - score: {'win': 589, 'loose': 411} 58.9 %
Iter: 142 - score: {'win': 574, 'loose': 426} 57.4 %
Iter: 143 - score: {'win': 570, 'loose': 430} 57.0 %
Iter: 144 - score: {'win': 539, 'loose': 461} 53.9 %
Iter: 145 - score: {'win': 525, 'loose': 475} 52.5 %
Iter: 146 - score: {'win': 542, 'loose': 458} 54.2 %
Iter: 147 - score: {'win': 550, 'loose': 450} 55.0 %
Iter: 148 - score: {'win': 539, 'loose': 461} 53.9 %
Iter: 149 - score: {'win': 561, 'loose': 439} 56.1 %
Iter: 150 - score: {'win': 527, 'loose': 473} 52.7 %
Iter: 151 - score: {'win': 521, 'loose': 479} 52.1 %
Iter: 152 - score: {'win': 553, 'loose': 447} 55.3 %
Iter: 153 - score: {'win': 575, 'loose': 425} 57.5 %
Iter: 154 - score: {'win': 550, 'loose': 450} 55.0 %
Iter: 155 - score: {'win': 547, 'loose': 453} 54.7 %
Iter: 156 - score: {'win': 556, 'loose': 444} 55.6 %
Iter: 157 - score: {'win': 574, 'loose': 426} 57.4 %
Iter: 158 - score: {'win': 569, 'loose': 431} 56.9 %
Iter: 159 - score: {'win': 586, 'loose': 414} 58.6 %
Iter: 160 - score: {'win': 513, 'loose': 487} 51.3 %
Iter: 161 - score: {'win': 553, 'loose': 447} 55.3 %
Iter: 162 - score: {'win': 554, 'loose': 446} 55.4 %
Iter: 163 - score: {'win': 535, 'loose': 465} 53.5 %
Iter: 164 - score: {'win': 559, 'loose': 441} 55.9 %
Iter: 165 - score: {'win': 565, 'loose': 435} 56.5 %
Iter: 166 - score: {'win': 546, 'loose': 454} 54.6 %
Iter: 167 - score: {'win': 562, 'loose': 438} 56.2 %
Iter: 168 - score: {'win': 582, 'loose': 418} 58.2 %
Iter: 169 - score: {'win': 560, 'loose': 440} 56.0 %
Iter: 170 - score: {'win': 528, 'loose': 472} 52.8 %
Iter: 171 - score: {'win': 567, 'loose': 433} 56.7 %
Iter: 172 - score: {'win': 571, 'loose': 429} 57.1 %
Iter: 173 - score: {'win': 561, 'loose': 439} 56.1 %
Iter: 174 - score: {'win': 561, 'loose': 439} 56.1 %
Iter: 175 - score: {'win': 564, 'loose': 436} 56.4 %
Iter: 176 - score: {'win': 557, 'loose': 443} 55.7 %
Iter: 177 - score: {'win': 538, 'loose': 462} 53.8 %
Iter: 178 - score: {'win': 569, 'loose': 431} 56.9 %
Iter: 179 - score: {'win': 558, 'loose': 442} 55.8 %
Iter: 180 - score: {'win': 537, 'loose': 463} 53.7 %
Iter: 181 - score: {'win': 560, 'loose': 440} 56.0 %
Iter: 182 - score: {'win': 757, 'loose': 243} 75.7 %
Iter: 183 - score: {'win': 771, 'loose': 229} 77.1 %
Iter: 184 - score: {'win': 772, 'loose': 228} 77.2 %
Iter: 185 - score: {'win': 775, 'loose': 225} 77.5 %
Iter: 186 - score: {'win': 783, 'loose': 217} 78.3 %
Iter: 187 - score: {'win': 761, 'loose': 239} 76.1 %
Iter: 188 - score: {'win': 789, 'loose': 211} 78.9 %
Iter: 189 - score: {'win': 774, 'loose': 226} 77.4 %
Iter: 190 - score: {'win': 783, 'loose': 217} 78.3 %
Iter: 191 - score: {'win': 769, 'loose': 231} 76.9 %
Iter: 192 - score: {'win': 792, 'loose': 208} 79.2 %
Iter: 193 - score: {'win': 785, 'loose': 215} 78.5 %
Iter: 194 - score: {'win': 789, 'loose': 211} 78.9 %
Iter: 195 - score: {'win': 772, 'loose': 228} 77.2 %
Iter: 196 - score: {'win': 780, 'loose': 220} 78.0 %
Iter: 197 - score: {'win': 783, 'loose': 217} 78.3 %
Iter: 198 - score: {'win': 797, 'loose': 203} 79.7 %
Iter: 199 - score: {'win': 772, 'loose': 228} 77.2 %
Iter: 200 - score: {'win': 759, 'loose': 241} 75.9 %
Iter: 201 - score: {'win': 778, 'loose': 222} 77.8 %
Iter: 202 - score: {'win': 774, 'loose': 226} 77.4 %
Iter: 203 - score: {'win': 769, 'loose': 231} 76.9 %
Iter: 204 - score: {'win': 792, 'loose': 208} 79.2 %
Iter: 205 - score: {'win': 749, 'loose': 251} 74.9 %
Iter: 206 - score: {'win': 791, 'loose': 209} 79.1 %
Iter: 207 - score: {'win': 753, 'loose': 247} 75.3 %
Iter: 208 - score: {'win': 792, 'loose': 208} 79.2 %
Iter: 209 - score: {'win': 803, 'loose': 197} 80.3 %
Iter: 210 - score: {'win': 767, 'loose': 233} 76.7 %
Iter: 211 - score: {'win': 779, 'loose': 221} 77.9 %
Iter: 212 - score: {'win': 782, 'loose': 218} 78.2 %
Iter: 213 - score: {'win': 767, 'loose': 233} 76.7 %
Iter: 214 - score: {'win': 791, 'loose': 209} 79.1 %
Iter: 215 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 216 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 217 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 218 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 219 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 220 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 221 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 222 - score: {'win': 1000, 'loose': 0} 100.0 %
Iter: 223 - score: {'win': 1000, 'loose': 0} 100.0 %
```




💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜💜

Se puede ver el sistema se comporta igual que un niño que está aprendiendo algo nuevo, gracias a la experiencia y repetición finalmente alcanza un score del 100%. 😀 
Esto ha sido todo, aprendimos que podemos usar la programación para aprender cosas de manera divertida⭐, que las máquinas tiene un lenguaje especial y mediante una serie de instrucciones podemos enseñarles casi cualquier cosa.😮 Finalmente estudiamos un poco sobre redes neuronales y creamos un sistema de clasificación Perceptrón multicapa.😎 

Déjame en los comentarios si te gusto o si tienes alguna duda, yo estaría feliz de ayudarte y espero ver pronto tus divertidas creaciones de machine learning.

Muchas gracias💜

DEV Community: 🦄 Maris Botero✨

✨ Cuando los circuitos no funcionaban (y lo que me enseñaron sobre la inteligencia artificial)

Docker for Data People: Simplifying Development with Containers

🐳 What is Docker?

💡 Why Should Data Analysts Care?

📦 Basic Docker Concepts

🧪 Example: Containerizing a Python Script

🗂️ Your project folder:

🐍 analyze.py

📋 requirements.txt

🐳 Dockerfile

🚀 Build and Run the Container

🔒 Bonus: Running Jupyter in Docker

🧽 Conclusion

✨Corre tu propio ChatGPT local con Docker y sin complicaciones ✨

✨ Introducción

⚙️ ¿Qué tecnología estamos usando?

🐳 Docker

🧠 Docker Model Runner

🖥️ Open WebUI

🧰 ¿Qué necesitas?

📦 Paso 2: Descarga tu primer modelo de lenguaje

🧬 Paso 3: Crea tu archivo docker-compose.yaml

🌐 Paso 5: Abre tu interfaz mágica

📚 Recursos útiles

🐳 Docker

💻 Repositorio del taller

Supercharge Your Data Analysis with BigQuery ML

🔍 What is BigQuery ML?

⚡ Why Use BigQuery ML?

🧠 What Kind of Models Can You Build?

🧪 Hands-on Example: Predicting Customer Churn

📦 Step 1: Prepare the Dataset

🏗️ Step 2: Create the Model

📊 Step 3: Evaluate the Model

🔮 Step 4: Make Predictions

💡 Tips and Best Practices

🧽 Conclusion

Simplify Your Development with DevContainers in Docker and VS Code

Overview

What Are DevContainers?

Why Use DevContainers?

Key Benefits

Setting Up a DevContainer

Prerequisites

Step-by-Step Guide

Adding DevContainer Support

Customizing the DevContainer

Starting the DevContainer

Working Inside a DevContainer

Conclusion

🍲 Enchanted Recipe for a Machine Learning Model on Google Cloud 🍲

Ingredients:

Magic Preparation Instructions:

Step 1: Gathering Ingredients in BigQuery 🥄

Step 2: Visual Preparation in Data Studio 🍉

Step 3: Mise en Place in AI Platform Notebooks 🍴

Step 4: Hyperparameter Cooking in Vertex AI 🍲

Step 5: Seasoning Test (Evaluation and Testing) 🌶️

Step 6: Serving the Dish in Cloud Run 🍛

Final Garnish ✨

And Voilà! 🎩

Exploring Generative Art with JavaScript

What is Generative Art?

Why JavaScript?

Getting Started with p5.js

Setting up the Environment

The Basic Skeleton of a p5.js Sketch

Creating Patterns with Math

Adding Interactivity

Conclusion

Dibujando una Cara Sonriente con p5.js

Dibujando una Cara Sonriente con p5.js

¿Qué es p5.js?

Estructura básica de un sketch en p5.js

El proyecto: una cara sonriente

Paso 1: Crear el lienzo

Paso 2: Dibujar la cara

Paso 3: Dibujar los ojos

Paso 4: Dibujar la sonrisa

🐍 `analyze.py`

📋 `requirements.txt`

🐳 `Dockerfile`