Какие алгоритмы подходят для этой простой проблемы машинного обучения?

У меня есть то, что я считаю простым вопросом машинного обучения.

Вот основная проблема: мне неоднократно дается новый объект и список описаний объекта. Например: new_object: 'bob' new_object_descriptions: ['tall','old','funny']. Затем мне нужно использовать какое-то машинное обучение для поиска ранее обработанных объектов, которые имеют 10 или менее похожих описаний, например past_similar_objects: ['frank','steve','joe']. Затем у меня есть алгоритм, который может непосредственно измерить, действительно ли эти объекты похожи на bob, например, correct_objects: ['steve','joe']. Затем классификатору дается эта тренировка успешных матчей с обратной связью. Затем этот цикл повторяется с новым объектом. Здесь псевдокод:

Classifier=new_classifier()

while True:
    new_object,new_object_descriptions = get_new_object_and_descriptions()
    past_similar_objects = Classifier.classify(new_object,new_object_descriptions)
    correct_objects = calc_successful_matches(new_object,past_similar_objects)
    Classifier.train_successful_matches(object,correct_objects)

Но есть некоторые положения, которые могут ограничить использование классификатора:

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

  • Опять же, я предпочитаю скорость, когда миллионы объектов классифицируются по точности.

  • Обновление: классификатор должен вернуть 10 (или меньше) наиболее похожих объектов на основе отзывов прошлой тренировки. Без этого ограничения очевидный чит был бы для классификатора, который мог бы просто вернуть все прошлые объекты:)

Каковы приемлемые, быстрые алгоритмы машинного обучения для этой цели?

Примечание. Показатель расстояния calc_successful_matches чрезвычайно дорог для вычисления, и поэтому я использую быстрый алгоритм машинного обучения, чтобы попытаться угадать, какие объекты будут закрыты, прежде чем я действительно сделаю дорогостоящий расчет.

ОТВЕТЫ

Ответ 1

Алгоритм, который, по-видимому, соответствует вашим требованиям (и, возможно, похож на то, что предлагает Джон Статистик), Семантическое хеширование. Основная идея заключается в том, что он обучает глубокую сеть убеждений (тип нейронной сети, которую некоторые называют "нейронными сетями 2.0" и которая сейчас является очень активной областью исследований), чтобы создать хэш списка описаний объекта в двоичное число такое, что расстояние Хэмминга между числами соответствует подобным объектам. Поскольку это просто требует побитовых операций, это может быть довольно быстро, и поскольку вы можете использовать его для создания алгоритма ближайшего соседа, он, естественно, обобщается на очень большое количество классов. Это очень хорошее состояние. Даунсайд: это не тривиально, чтобы понимать и реализовывать, и требует некоторой настройки параметров. Автор предоставляет некоторый код Matlab здесь. Несколько более простой алгоритм для реализации и тесно связан с этим - это локальная чувствительная хеширование.

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

Ответ 2

Вы можете использовать модель векторного пространства (http://en.wikipedia.org/wiki/Vector_space_model). Я думаю, что вы пытаетесь научиться - как взвешивать термины при рассмотрении того, насколько близки два вектора описания объектов друг к другу, скажем, например, с точки зрения упрощенной взаимной информации. Это может быть очень эффективным, поскольку вы можете хэшировать от терминов к векторам, а это значит, что вам не придется сравнивать объекты без общих функций. Тогда наивная модель будет иметь регулируемый вес на один семестр (это может быть либо на один член на вектор, на весь срок, либо на оба), а также на порог. Модель векторного пространства является широко используемой техникой (например, в Apache Lucene, которую вы, возможно, сможете использовать для этой проблемы), так что вы сможете много узнать об этом в ходе дальнейших поисков.

Позвольте мне дать очень простую формулировку этого с точки зрения вашего примера. Учитывая bob: ['tall', 'old', 'funny'], я извлекаю

frank: ['young', 'short,' funny '] steve: ['tall', 'old', 'grumpy'] joe: ['tall', 'old']

поскольку я поддерживаю хеш из смешного → {frank,...}, tall → {steve, joe,...}, а старый → {steve, joe,...}

Я вычисляю что-то вроде общей взаимной информации: вес общих тегов/вес тегов bob. Если этот вес превышает пороговое значение, я включаю их в список.

Когда я тренируюсь, если я ошибаюсь, я изменяю общие теги. Если моя ошибка включала в себя откровенность, я уменьшаю вес для смешного, а если ошибаюсь, не считая Стива или Джо, я увеличиваю вес для высоких и старых.

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

Ответ 3

Вам действительно нужен алгоритм машинного обучения? Каков ваш показатель сходства? Вы упомянули размерность количества объектов, как насчет размера набора признаков для каждого человека? Существует ли максимальное количество типов признаков? Я мог бы попробовать что-то вроде этого:

1) Содержит атрибут отображения словаря в списке имен с именем map

для каждого человека p

для каждого признака t в p

карта [т].add(р);

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

имя сопоставления словаря для count cnt

для каждого признака t в моем лице, представляющем интерес

для каждого человека p на карте [t]

CNT [р] ++;

то запись с наивысшим счетом ближе всего

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

Ответ 4

SVM довольно быстро. LIBSVM для Python, в частности, обеспечивает очень приличную реализацию Vector Vector Machine для классификации.

Ответ 5

Этот проект отходит от типичных приложений классификации двумя заметными способами:

  • Вместо того, чтобы выводить класс, к которому, как считается, принадлежит новый объект (или, возможно, выводит массив из этих классов, каждый с вероятностью/доверительным уровнем), "классификатор" предоставляет список "соседей", которые "закрыты" достаточно "для нового объекта.
  • С каждой новой классификацией объектная функция, независимая от классификатора, предоставляет список правильных "соседей"; в свою очередь, скорректированный список (подмножество списка, предоставленного классификатором?) затем используется для обучения классификатора

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

Эти две характеристики вводят различные проблемы.
 - Тот факт, что вывод представляет собой список объектов, а не "prototype" (или идентификатор категории), затрудняет масштабирование по мере того, как число объектов, которые до сих пор растут, приближается к миллионам экземпляров, как это предлагается в вопросе. < ш >  - Тот факт, что обучение проводится на основе подмножества совпадений, найденных классификатором, может привести к переустановке, в результате чего классификатор может стать "слепым" к функциям (размерам), которые он, случайно, не имел веса как важный/актуальный, в ранних этапах обучения. (Я могу предположить слишком много в отношении целевой функции, ответственной за создание списка "правильных" объектов)

Возможно, проблема масштабирования может быть решена путем двухэтапного процесса с первым классификатором на основе алгоритма K-Means или чего-то подобного, что приведет к подмножеству общей коллекции объектов (ранее обнаруженных объектов) как правдоподобные совпадения для текущего объекта (эффективная фильтрация, например, 70% или более). Эти возможные совпадения затем будут оцениваться на основе векторной космической модели (особенно актуальной, если размеры объектов основаны на факторах, а не на значениях) или некоторых других моделях. Основополагающее предположение для этого двухэтапного процесса состоит в том, что сбор объектов эффективно выставляет кластеры (он может быть просто равномерно распределен по различным размерам).

Другой способ дальнейшего ограничения количества кандидатов для оценки, поскольку размер ранее увиденных объектов растет, заключается в удалении около дубликатов и только в сравнении с одним из них (но для предоставления полного дублированного списка в результате, предполагая, что если новый объект близок к "представителю" этого близкого дубликата, все члены класса также будут соответствовать)

Проблема переустановки более сложна для обработки. Возможным подходом было бы [иногда] случайным образом добавлять объекты в список соответствия, который обычно не включал классификатор. Дополнительные объекты могут быть добавлены на основе их относительного расстояния относительно нового объекта (т.е. Сделать более вероятным добавление относительно близкого объекта).

Ответ 6

То, что вы описываете, несколько похоже на алгоритм Locally Weighted Learning, который задает экземпляр запроса, он моделирует модель локально вокруг соседних экземпляров, взвешенных их расстояниями до запроса.

У Weka (Java) есть реализация этого в weka.classifiers.lazy.LWL

Ответ 8

Возможно, вы захотите взглянуть на Google AutoML, который абстрагирует архитектуру модели и просто даст вам окончательный результат.

https://www.youtube.com/watch?v=Kfg62KTH9W0