Как сгруппировать признаки и написать пользовательскую “функцию расчета схожести”? Как к этому подойти?

Я пытаюсь разобраться, как мне следует разработать “функцию вычисления аналогии”, которая будет вычислять сходство между двумя согласными или согласными кластеров. Текущий вопрос, который вы читаете, не о том, как на практике решить эту задачу, а о общем подходе, который я должен выбрать для разработки функции вычисления сходства для такой задачи.

Один из подходов (после многих итераций обучения) заключается в следующем:

1. Группы признаков (не только бинарные 1/0 признаки), которые могут получать произвольные целые значения.
2. Глобальные веса для каждой группы признаков.
3. Функция weightedCosineSimilarity, которая вычисляет сходство, умножая на глобальные веса групп признаков.

Что-то вроде этого:

// Определение весов для каждого признака
const FEATURE_WEIGHTS = [
  0.4,  // Место артикуляции
  0.4,  // Способ артикуляции
  0.2   // Звонкость
];

function weightedCosineSimilarity(a: number[], b: number[]): number {
  let weightedDotProduct = 0;
  let weightedMagnitudeA = 0;
  let weightedMagnitudeB = 0;

  for (let i = 0; i < a.length; i++) {
    const weight = FEATURE_WEIGHTS[i];
    weightedDotProduct += weight * a[i] * b[i];
    weightedMagnitudeA += weight * a[i] * a[i];
    weightedMagnitudeB += weight * b[i] * b[i];
  }

  return weightedDotProduct / (Math.sqrt(weightedMagnitudeA) * Math.sqrt(weightedMagnitudeB));
}

// Пример использования
const consonants: Record<string, number[]> = {
  'p': [0, 0, 0],  // Билабиальный взрывной, беззвучный
  'b': [0, 0, 1],  // Билабиальный взрывной, звонкий
  'm': [0, 1, 1],  // Билабиальный носовой, звонкий
  't': [1, 0, 0],  // Альвеолярный взрывной, беззвучный
};

// Сравнение некоторых согласных
const pairs = [['p', 'b'], ['p', 'm'], ['p', 't']];
pairs.forEach(([c1, c2]) => {
  const similarity = weightedCosineSimilarity(consonants[c1], consonants[c2]);
  console.log(`Взвешенное сходство между ${c1} и ${c2}: ${similarity.toFixed(2)}`);
});

// Для сравнения, давайте также покажем невзвешенное сходство
function unweightedCosineSimilarity(a: number[], b: number[]): number {
  const dotProduct = a.reduce((sum, _, i) => sum + a[i] * b[i], 0);
  const magnitudeA = Math.sqrt(a.reduce((sum, val) => sum + val * val, 0));
  const magnitudeB = Math.sqrt(b.reduce((sum, val) => sum + val * val, 0));
  return dotProduct / (magnitudeA * magnitudeB);
}

pairs.forEach(([c1, c2]) => {
  const similarity = unweightedCosineSimilarity(consonants[c1], consonants[c2]);
  console.log(`Невзвешенное сходство между ${c1} и ${c2}: ${similarity.toFixed(2)}`);
});

Но быстро я могу увидеть случаи в своем воображении, где две несвязанные согласные получают одинаковое взвешенное значение. Это действительно не учитывает индекс, и просто вычисляет число вектора, и два вектора могут иметь одинаковое число, но быть несвязанными. Разве это не очевидная проблема с этим подходом? Мне так кажется, но я не уверен, что это так.

Другой подход заключается в создании совершенно пользовательской функции “сходства”, вроде этой:

// Определение более детализированных фонетических признаков
type PhoneticFeatures = {
  place: 'bilabial' | 'labiodental' | 'dental' | 'alveolar' | 'postalveolar' | 'palatal' | 'velar' | 'uvular' | 'glottal';
  manner: 'plosive' | 'nasal' | 'trill' | 'tap' | 'fricative' | 'lateral' | 'approximant' | 'affricate';
  voiced: boolean;
  aspirated: boolean;
};

const consonants: Record<string, PhoneticFeatures> = {
  'p': { place: 'bilabial', manner: 'plosive', voiced: false, aspirated: false },
  'b': { place: 'bilabial', manner: 'plosive', voiced: true, aspirated: false },
  'm': { place: 'bilabial', manner: 'nasal', voiced: true, aspirated: false },
  't': { place: 'alveolar', manner: 'plosive', voiced: false, aspirated: false },
  'd': { place: 'alveolar', manner: 'plosive', voiced: true, aspirated: false },
  'n': { place: 'alveolar', manner: 'nasal', voiced: true, aspirated: false },
  // Добавьте больше согласных по мере необходимости
};

function advancedPhoneticSimilarity(a: PhoneticFeatures, b: PhoneticFeatures): number {
  let similarity = 0;

  // Сходство места артикуляции
  const placeOrder = ['bilabial', 'labiodental', 'dental', 'alveolar', 'postalveolar', 'palatal', 'velar', 'uvular', 'glottal'];
  const placeDifference = Math.abs(placeOrder.indexOf(a.place) - placeOrder.indexOf(b.place));
  const placeSimularity = 1 - (placeDifference / (placeOrder.length - 1));
  similarity += placeSimularity * 0.4; // Вес для места артикуляции

  // Сходство способа артикуляции
  const mannerGroups = [
    ['plosive', 'affricate'],
    ['fricative', 'approximant'],
    ['nasal', 'lateral'],
    ['trill', 'tap']
  ];
  let mannerSimilarity = a.manner === b.manner ? 1 : 0;
  if (mannerSimilarity === 0) {
    for (const group of mannerGroups) {
      if (group.includes(a.manner) && group.includes(b.manner)) {
        mannerSimilarity = 0.5;
        break;
      }
    }
  }
  similarity += mannerSimilarity * 0.3; // Вес для способа артикуляции

  // Сходство звонкости
  const voicingSimilarity = a.voiced === b.voiced ? 1 : 0;
  similarity += voicingSimilarity * 0.2; // Вес для звонкости

  // Сходство аспирации
  const aspirationSimilarity = a.aspirated === b.aspirated ? 1 : 0;
  similarity += aspirationSimilarity * 0.1; // Вес для аспирации

  return similarity;
}

// Сравнение некоторых согласных
const pairs = [['p', 'b'], ['p', 'm'], ['p', 't'], ['t', 'd'], ['m', 'n']];
pairs.forEach(([c1, c2]) => {
  const similarity = advancedPhoneticSimilarity(consonants[c1], consonants[c2]);
  console.log(`Расширенное сходство между ${c1} и ${c2}: ${similarity.toFixed(2)}`);
});

// Дополнительная функция, чтобы продемонстрировать, как это может быть использовано в подходах машинного обучения
function phoneticFeaturesToVector(features: PhoneticFeatures): number[] {
  const placeOrder = ['bilabial', 'labiodental', 'dental', 'alveolar', 'postalveolar', 'palatal', 'velar', 'uvular', 'glottal'];
  const mannerOrder = ['plosive', 'nasal', 'trill', 'tap', 'fricative', 'lateral', 'approximant', 'affricate'];

  return [
    placeOrder.indexOf(features.place) / (placeOrder.length - 1),
    mannerOrder.indexOf(features.manner) / (mannerOrder.length - 1),
    features.voiced ? 1 : 0,
    features.aspirated ? 1 : 0
  ];
}

Но это хоть что-то лучше? Разве это не столкнется с той же проблемой?

Основная суть моего вопроса/проблемы заключается в том, как должны быть распределены числа среди различных векторов согласных? Имеет ли значение, если два вектора несвязанных согласных в сумме или произведении дают одно и то же значение? Важно ли каким-то образом учитывать индекс признака? Такие вещи.

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

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

Я не обязательно ищу реальное практическое решение (которое, как я думаю, требует множества знаний по лингвистике и фонетике), но ищу общий или высокоуровневый подход к тому, как мне следует подходить к строительству такой функции сходства, и как знать, что важно, а что не важно в её построении.

Вот несколько других подходов, которые придумал ClaudeAI, даже один с использованием, казалось бы, сложных вещей tensorflow, а не просто базовых рукописных функций. Но, тем не менее, они, похоже, страдают от тех же проблем, на которые я указываю (в отношении чего я все еще не уверен, действительно ли это проблемы, о которых стоит беспокоиться, лол).