La inteligencia artificial utiliza funciones para convertir datos en decisiones. Una función puede asignar una puntuación, clasificar una entrada, medir un error, activar una neurona artificial o elegir la mejor acción posible.
Aunque los sistemas modernos pueden ser muy complejos, muchas ideas básicas se entienden mejor como funciones que reciben información y devuelven un resultado calculado.
Un modelo de IA puede verse como una función: recibe datos de entrada y produce una salida.
salida = modelo(entrada)
function clasificadorSimple(edad) {
return edad >= 18 ? "adulto" : "menor";
}
console.log(clasificadorSimple(16));
console.log(clasificadorSimple(22));Este ejemplo no aprende por sí solo, pero muestra la estructura básica de una función de decisión.
Una función de decisión transforma datos en una categoría o acción. Puede usar reglas simples o cálculos más elaborados.
function recomendarAccion(energia, peligro) {
if (peligro > 70) {
return "huir";
}
if (energia < 30) {
return "descansar";
}
return "explorar";
}
console.log(recomendarAccion(80, 20));
console.log(recomendarAccion(20, 10));
console.log(recomendarAccion(90, 90));En lugar de decidir directamente, una función puede asignar una puntuación a cada opción. Luego se elige la opción con mayor puntaje.
function puntuarProducto(producto) {
return producto.calidad * 0.7 - producto.precio * 0.3;
}
const productos = [
{ nombre: "A", calidad: 90, precio: 40 },
{ nombre: "B", calidad: 75, precio: 20 },
{ nombre: "C", calidad: 95, precio: 80 }
];
const ordenados = [...productos].sort((a, b) => puntuarProducto(b) - puntuarProducto(a));
console.log("Mejor opción:", ordenados[0]);Muchos modelos calculan una combinación ponderada de variables. El producto punto multiplica cada característica por un peso y suma los resultados.
function productoPunto(a, b) {
let total = 0;
for (let i = 0; i < a.length; i++) {
total += a[i] * b[i];
}
return total;
}
const caracteristicas = [0.8, 0.4, 0.9];
const pesos = [2.0, -1.0, 1.5];
console.log(productoPunto(caracteristicas, pesos));Un modelo lineal combina características con pesos y agrega un sesgo. Es una de las bases de muchos algoritmos de IA.
function modeloLineal(x, pesos, sesgo) {
let total = sesgo;
for (let i = 0; i < x.length; i++) {
total += x[i] * pesos[i];
}
return total;
}
const entrada = [5, 2];
const pesos = [1.2, -0.7];
const sesgo = 0.5;
console.log(modeloLineal(entrada, pesos, sesgo));La función escalón convierte un valor numérico en una decisión binaria. Fue una de las primeras ideas usadas en neuronas artificiales simples.
function escalon(valor) {
return valor >= 0 ? 1 : 0;
}
console.log(escalon(-2.5));
console.log(escalon(0.1));La sigmoide transforma cualquier número real en un valor entre 0 y 1. Puede interpretarse como una probabilidad aproximada.
function sigmoide(x) {
return 1 / (1 + Math.exp(-x));
}
for (const valor of [-3, -1, 0, 1, 3]) {
console.log(valor, sigmoide(valor).toFixed(4));
}Una clasificación binaria decide entre dos clases. Se puede usar una puntuación y un umbral.
function sigmoide(x) {
return 1 / (1 + Math.exp(-x));
}
function clasificar(probabilidad, umbral) {
return probabilidad >= umbral ? "positivo" : "negativo";
}
const puntuacion = 1.4;
const probabilidad = sigmoide(puntuacion);
console.log("Probabilidad:", probabilidad.toFixed(3));
console.log("Clase:", clasificar(probabilidad, 0.5));Una función de pérdida mide qué tan lejos está una predicción del valor real. Entrenar un modelo consiste en reducir esa pérdida.
function errorCuadratico(real, predicho) {
return (real - predicho) ** 2;
}
console.log(errorCuadratico(10, 8));
console.log(errorCuadratico(10, 9.5));Para evaluar varias predicciones se calcula el promedio de los errores individuales.
function errorCuadraticoMedio(reales, predichos) {
let total = 0;
for (let i = 0; i < reales.length; i++) {
total += (reales[i] - predichos[i]) ** 2;
}
return total / reales.length;
}
const reales = [3, 5, 7];
const predichos = [2.8, 5.4, 6.5];
console.log(errorCuadraticoMedio(reales, predichos));Un modelo aprende ajustando parámetros. En un ejemplo muy simple, un peso puede corregirse según el error de predicción.
function predecir(x, peso) {
return x * peso;
}
function ajustarPeso(peso, x, real, tasaAprendizaje) {
const predicho = predecir(x, peso);
const error = real - predicho;
return peso + tasaAprendizaje * error * x;
}
let peso = 0.5;
for (let i = 1; i <= 5; i++) {
peso = ajustarPeso(peso, 2, 10, 0.05);
console.log("Iteración", i, "peso:", peso.toFixed(4), "predicción:", predecir(2, peso).toFixed(4));
}Un método simple de clasificación es buscar el dato conocido más parecido al nuevo dato. La similitud puede medirse con distancia.
function distancia(a, b) {
const dx = a.x - b.x;
const dy = a.y - b.y;
return Math.sqrt(dx * dx + dy * dy);
}
function vecinoMasCercano(punto, ejemplos) {
return ejemplos.reduce((mejor, actual) => {
return distancia(punto, actual) < distancia(punto, mejor) ? actual : mejor;
});
}
const ejemplos = [
{ x: 1, y: 1, clase: "A" },
{ x: 8, y: 7, clase: "B" },
{ x: 2, y: 3, clase: "A" }
];
console.log(vecinoMasCercano({ x: 3, y: 2 }, ejemplos));Una función puede comparar textos contando palabras compartidas. Es una idea básica detrás de algunos sistemas de búsqueda y recomendación.
function palabras(texto) {
return texto.toLowerCase().split(/\s+/);
}
function similitudSimple(a, b) {
const conjuntoA = new Set(palabras(a));
const conjuntoB = new Set(palabras(b));
let comunes = 0;
for (const palabra of conjuntoA) {
if (conjuntoB.has(palabra)) {
comunes++;
}
}
return comunes / Math.max(conjuntoA.size, conjuntoB.size);
}
console.log(similitudSimple("modelo de datos", "datos para modelo"));Un recomendador simple puede calcular una puntuación según preferencias del usuario y características de cada elemento.
function puntuarPelicula(usuario, pelicula) {
return usuario.accion * pelicula.accion +
usuario.comedia * pelicula.comedia +
usuario.drama * pelicula.drama;
}
const usuario = { accion: 0.8, comedia: 0.2, drama: 0.5 };
const peliculas = [
{ titulo: "Rápida", accion: 1, comedia: 0, drama: 0.2 },
{ titulo: "Ligera", accion: 0.1, comedia: 1, drama: 0.1 },
{ titulo: "Intensa", accion: 0.4, comedia: 0, drama: 1 }
];
const recomendadas = [...peliculas].sort((a, b) => puntuarPelicula(usuario, b) - puntuarPelicula(usuario, a));
console.log(recomendadas[0]);Una heurística estima qué tan buena es una opción sin explorar todas las posibilidades. Se usa en juegos, planificación y búsqueda de caminos.
function distanciaManhattan(a, b) {
return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
}
const posicion = { x: 2, y: 3 };
const meta = { x: 8, y: 5 };
console.log("Estimación:", distanciaManhattan(posicion, meta));Un agente puede evaluar acciones posibles y elegir la que tenga mayor utilidad.
function utilidad(accion) {
return accion.recompensa - accion.riesgo * 2 - accion.costo;
}
const acciones = [
{ nombre: "atacar", recompensa: 10, riesgo: 4, costo: 1 },
{ nombre: "defender", recompensa: 5, riesgo: 1, costo: 1 },
{ nombre: "explorar", recompensa: 8, riesgo: 2, costo: 2 }
];
const mejor = [...acciones].sort((a, b) => utilidad(b) - utilidad(a))[0];
console.log(mejor.nombre, utilidad(mejor));Softmax convierte puntuaciones en una distribución de probabilidades. Las puntuaciones más altas reciben mayor probabilidad.
function softmax(valores) {
const max = Math.max(...valores);
const exponentes = valores.map(valor => Math.exp(valor - max));
const suma = exponentes.reduce((total, valor) => total + valor, 0);
return exponentes.map(valor => valor / suma);
}
console.log(softmax([1.2, 0.7, 2.1]));Para evaluar un clasificador binario se pueden contar aciertos y errores: verdaderos positivos, falsos positivos, verdaderos negativos y falsos negativos.
function matrizConfusion(reales, predichos) {
const matriz = { vp: 0, fp: 0, vn: 0, fn: 0 };
for (let i = 0; i < reales.length; i++) {
if (reales[i] === 1 && predichos[i] === 1) matriz.vp++;
if (reales[i] === 0 && predichos[i] === 1) matriz.fp++;
if (reales[i] === 0 && predichos[i] === 0) matriz.vn++;
if (reales[i] === 1 && predichos[i] === 0) matriz.fn++;
}
return matriz;
}
console.log(matrizConfusion([1, 0, 1, 0, 1], [1, 1, 1, 0, 0]));La exactitud indica qué proporción de predicciones fueron correctas.
function exactitud(reales, predichos) {
let aciertos = 0;
for (let i = 0; i < reales.length; i++) {
if (reales[i] === predichos[i]) {
aciertos++;
}
}
return aciertos / reales.length;
}
console.log(exactitud(["A", "B", "A"], ["A", "A", "A"]));Las funciones usadas en IA conviene que sean fáciles de probar. Una función pura devuelve siempre el mismo resultado para la misma entrada y no modifica datos externos.
function normalizar(valor, minimo, maximo) {
return (valor - minimo) / (maximo - minimo);
}
console.log(normalizar(50, 0, 100));
console.log(normalizar(50, 0, 100));Esta propiedad facilita depurar modelos, métricas y transformaciones de datos.
Las funciones en inteligencia artificial aparecen en:
Al programar funciones relacionadas con IA conviene evitar estos problemas:
La inteligencia artificial puede entenderse como una combinación de funciones: algunas transforman datos, otras calculan puntuaciones, otras miden errores y otras toman decisiones.
Dominar estas funciones básicas ayuda a comprender mejor modelos más avanzados y a construir programas que razonan, recomiendan, clasifican o predicen de forma controlada.