Программирование искусственного интеллекта на JavaScript

Как восстановить зависимость между значениями с помощью линейной регрессии?

Модель обучается на паре массивов и предсказывает выходное значение для нового входа.

const tf = require('@tensorflow/tfjs');

const xs = tf.tensor2d([0, 1, 2, 3, 4], [5, 1]);
const ys = tf.tensor2d([-1, 1, 3, 5, 7], [5, 1]);

const model = tf.sequential();
model.add(tf.layers.dense({ units: 1, inputShape: [1] }));
model.compile({ optimizer: 'sgd', loss: 'meanSquaredError' });

async function trainAndPredict() {
  await model.fit(xs, ys, { epochs: 300 });
  const result = model.predict(tf.tensor2d([5, 6], [2, 1]));
  result.print();
}

trainAndPredict();

Пара xs содержит числа от нуля до четырёх, ys содержит значения, соответствующие формуле 2x - 1. После обучения модель выдаёт результат, близкий к девяти и одиннадцати.

Tensor
    [[9.0103 ],
     [10.9812]]

Числа после десятичной точки зависят от случайной инициализации весов.

Как сгруппировать точки без обучающей выборки?

Алгоритм k-means применяется для кластеризации и не требует размеченных данных. Каждая точка относится к ближайшему центру.

function kMeans(points, k, iterations = 100) {
  let centroids = points.slice(0, k);

  for (let iter = 0; iter < iterations; iter++) {
    const groups = Array.from({ length: k }, () => []);

    points.forEach((point) => {
      let minDistance = Infinity;
      let clusterIndex = 0;

      centroids.forEach((centroid, index) => {
        const distance = Math.hypot(
          point[0] - centroid[0],
          point[1] - centroid[1]
        );
        if (distance < minDistance) {
          minDistance = distance;
          clusterIndex = index;
        }
      });

      groups[clusterIndex].push(point);
    });

    centroids = centroids.map((centroid, index) => {
      const group = groups[index];
      if (group.length === 0) return centroid;
      const sumX = group.reduce((sum, point) => sum + point[0], 0);
      const sumY = group.reduce((sum, point) => sum + point[1], 0);
      return [sumX / group.length, sumY / group.length];
    });
  }

  return centroids;
}

const points = [
  [1, 1],
  [1.2, 1.4],
  [1.5, 1.1],
  [8, 8],
  [8.1, 7.9],
  [7.8, 8.2]
];

console.log(kMeans(points, 2));

[ [1.2333333333333334, 1.1666666666666667],
  [7.966666666666667, 8.033333333333333] ]

В результате две группы получают центры вблизи скоплений точек. Метод не требует предварительного обучения, поэтому подходит для анализа данных без меток.

Как найти маршрут в графе с эвристикой?

Алгоритм A* выбирает путь, используя стоимость перехода и эвристическую оценку расстояния до цели. Это классический метод планирования движения.

function aStar(graph, start, goal, heuristic) {
  const open = [{ id: start, g: 0, f: heuristic(start), path: [start] }];
  const closed = new Set();

  while (open.length > 0) {
    open.sort((a, b) => a.f - b.f);
    const current = open.shift();

    if (current.id === goal) return current.path;

    closed.add(current.id);

    graph[current.id].forEach((neighbor) => {
      if (closed.has(neighbor.id)) return;

      const gScore = current.g + neighbor.cost;
      const existing = open.find((node) => node.id === neighbor.id);

      if (!existing || gScore < existing.g) {
        const fScore = gScore + heuristic(neighbor.id);
        const newPath = current.path.concat(neighbor.id);

        if (existing) {
          existing.g = gScore;
          existing.f = fScore;
          existing.path = newPath;
        } else {
          open.push({ id: neighbor.id, g: gScore, f: fScore, path: newPath });
        }
      }
    });
  }

  return null;
}

const graph = {
  A: [{ id: 'B', cost: 1 }, { id: 'C', cost: 4 }],
  B: [{ id: 'C', cost: 1 }, { id: 'D', cost: 5 }],
  C: [{ id: 'D', cost: 1 }],
  D: []
};

const heuristic = (node) => ({ A: 3, B: 2, C: 1, D: 0 }[node]);

console.log(aStar(graph, 'A', 'D', heuristic));

[ 'A', 'B', 'C', 'D' ]

Путь из A в D через B и C оказывается короче прямого перехода из A в C из-за весов рёбер. Эвристика позволяет алгоритму проверять перспективные вершины раньше остальных.

Как применить генетический алгоритм для поиска строки?

Популяция кандидатов улучшается через отбор, скрещивание и мутацию. Такой подход применим к задачам оптимизации, где нет прямой функции обучения.

const target = 'hello';
const populationSize = 200;
const mutationRate = 0.05;
const symbols = 'abcdefghijklmnopqrstuvwxyz ';

function randomSymbol() {
  return symbols[Math.floor(Math.random() * symbols.length)];
}

function fitness(individual) {
  let score = 0;
  for (let i = 0; i < target.length; i++) {
    if (individual[i] === target[i]) score++;
  }
  return score;
}

function createChild(parent) {
  let child = '';
  for (let i = 0; i < target.length; i++) {
    if (Math.random() < mutationRate) child += randomSymbol();
    else child += parent[i];
  }
  return child;
}

let population = Array.from({ length: populationSize }, () =>
  Array.from({ length: target.length }, randomSymbol).join('')
);

let bestSolution = '';

for (let generation = 0; generation < 200; generation++) {
  population.sort((a, b) => fitness(b) - fitness(a));
  bestSolution = population[0];
  if (fitness(bestSolution) === target.length) break;

  const next = [];
  for (let i = 0; i < populationSize; i++) {
    const parent = population[Math.floor(Math.random() * 50)];
    next.push(createChild(parent));
  }
  population = next;
}

console.log(bestSolution);

hello

Каждое поколение сохраняет лучшие решения, а новые потомки получают мутации. Алгоритм находит целевую строку в большинстве запусков за несколько десятков поколений.