Вероятностное программирование – ключ к искусственному интеллекту?

Немного воды


Уже более полутора лет назад прошла новость о том, что «DARPA намерено совершить революцию в машинном обучении». Конечно, DARPA всего лишь выделила деньги на исследовательскую программу, связанную с вероятностным программированием. Само же вероятностное программирование существует и развивается без DARPA достаточно давно, причем исследования ведутся, как в ведущих университетах, таких как MIT, так и в крупных корпорациях, таких как Microsoft. И вовсе не зря DARPA, Microsoft, MIT и т.д. обращают пристальное внимание на эту область, ведь она по-настоящему перспективна для машинного обучения, а, может, и для искусственного интеллекта в целом. Говорят, что вероятностное программирование для машинного обучения будет играть ту же роль, что и высокоуровневые языки для обычного программирования. Мы бы привели другую параллель – с ролью Пролога, которую он сыграл для старого доброго ИИ. Вот только в Рунете по данной теме до сих пор можно найти лишь единичные ссылки, и то в основном содержащие лишь описания общих принципов. Возможно, это связано с тем, что потенциал вероятностного программирования еще только начал раскрываться и оно не стало основным трендом. Однако на что же способны или будут способны вероятностные языки?

Можно выделить два основных класса вероятностных языков программирования – это языки, допускающие задание генеративных моделей только в форме Байесовских сетей (или других графических вероятностных моделей), или Тьюринг-полные языки.

Типичным представителем первых является Infer.NET, разрабатываемый в Microsoft. В нем благодаря использованию в качестве генеративных моделей Байесовких сетей оказывается возможным применять известные для них эффективные методы вывода. Естественно, использование хорошо известного класса моделей с известными методами вывода не приводит к возможности решения каких-то принципиально новых задач (и даже такие генеративные модели, как сети глубокого обучения на основе ограниченных машинах Больцмана оказываются не представимы в таких языках), но дает вполне практичный инструмент. Как говорят разработчики, с использованием этого инструмента можно за пару часов реализовать нетривиальную вероятностную модель, такую как полная Байесовская версия анализа главных компонент, которая будет занимать всего пару десятков строк кода и для которой отдельная реализация эффективной процедуры вывода на обычном языке потребовала бы заметно большего объема знаний и нескольких недель работы. Таким образом, за счет вероятностного программирования использование графических моделей становится гораздо более простым и доступным.

Гораздо большим потенциалом, однако, обладают Тьюринг-полные вероятностные языки. Они позволяют выйти за рамки того класса задач, которые существующие методы машинного обучения уже умеют решать. Естественно, в таких языках возникает проблема эффективности вывода, которая пока далека от решения, что приводит к плохой масштабируемости на задачи реального мира. Однако это направление активно развивается, и существует ряд работ, показывающих как в вероятностных языках общего назначения достичь эффективного вывода для интересных практических задач. Можно надеяться, что в ближайшем будущем эти решения станут доступными для использования в конкретных языках. Кроме того, Тьюринг-полные вероятностные языки уже сейчас оказываются весьма полезными в исследованиях, связанных с когнитивным моделированием и общим искусственным интеллектом. По этим причинам мы и рассмотрим основные принципы вероятностного программирования именно на примере Тьюринг-полных языков, из которых мы выбрали Чёрч (Church), являющийся расширением языка Лисп (конкретнее, его диалекта – Scheme). Удобство этого языка (по крайней мере, в целях начального знакомства с ним) заключается в существовании для него web-реализации (web-church), с которой можно экспериментировать без установки дополнительного программного обеспечения.

Итак, к делу


Программа на вероятностном языке может, на первый взгляд, ничем не отличаться от программы на обычном языке. Именно так сделано в Чёрче. Как и в обычном Лиспе, в этом языке могут быть определены переменные, функции, выполнены детерминированные вычисления. Например, следующая программа задает функцию от одного аргумента, вычисляющую факториал по рекурсивной формуле n!=n*(n–1)!, и вызывает эту функцию для n=10

(define (f n)
  (if (= n 0) 1 (* n (f (– n 1)))))
(f 10)


Также в этом языке могут быть обращения к (псевдо)случайным функциям. Например, при выполнении вызова (flip 0.3) с вероятностью 0.3 будет возвращено значение #t, а с вероятностью 0.7 – #f. Такая функция элементарно реализуется и в Лиспе как
(define (flip p) (< (random) p))
Чёрч, как и другие вероятностные языки, включает много встроенных функций, которые возвращают случайные значения в соответствии с тем или иным распределением. Например, (gaussian x0 s) возвращает вещественную случайную величину, распределенную по гауссиане с заданными параметрами. В качестве других реализованных распределений вероятностей обычно присутствуют равномерное, мультиномиальное, Дирихле, бета, гамма. Все эти распределения не так сложно реализовать вручную в обычном языке, и здесь пока нет принципиального отличия между Чёрчем и Лиспом.

Однако помимо обычной семантики программа на Чёрче обладает вероятностной семантикой, в рамках которой полагается, что программа, содержащая вызовы случайных функций, не просто при своем запуске порождает какие-то конкретные значения случайных величин, но задает распределение вероятностей над ними. Так, (gaussian x0 s) – это не просто функция, возвращающая некоторое конкретное значение случайной величины, распределенной по гауссиане, но именно само Гауссово распределение.

Но как получать эти распределения вероятностей, задаваемые программой? Представим, например, программу
(if (flip 0.4) (flip 0.1) (flip 0.6))
То есть с вероятностью 0.4 значение этого выражения – это P(#t)=0.1 и P(#f)=0.9, а с вероятностью 0.6 – P(#t)=0.6 и P(#f)=0.4. Откуда возьмется итоговое распределение, задаваемое этим выражением: P(#t)=0.4 и P(#f)=0.6? Эта вероятностная семантика зачастую реализуется через процесс сэмплирования: мы можем просто много раз запустить программу и построить выборку результатов ее выполнения. Такую процедуру, конечно, также несложно реализовать на обычном языке (и, действительно, еще Симула-67 таким способом регулярно использовалась для моделирования стохастических процессов).

Однако современные вероятностные языки идут дальше и добавляют в процесс сэмплирования условие, накладываемое на результаты выполнения программы. Эта идея ведет к простейшему сэмплированию с отказами, которая в Чёрче реализуется функцией rejection-query. Эта функция на вход принимает вероятностную программу (как совокупность define), предпоследнее выражение в которой вычисляет возвращаемое значение, а последнее выражение – это условие (предикат), который в процессе выполнения должен оказаться истинным. Рассмотрим программу

(rejection-query
  (define A (flip 0.4))
  (define B (flip 0.6))
  B
  (or A B))


rejection-query выполняет поданную ей программу до тех пор, пока не будет выполнено последнее условие – здесь (or A B) – и возвращает (один раз) значение предпоследнего выражения – здесь B. Чтобы получить выборку значений, можно воспользоваться функцией repeat. Также Чёрч имеет встроенные функции для построения гистограмм. Рассмотрим немного расширенную программу:

(define (get-sample) (rejection-query
  (define A (flip 0.4))
  (define B (flip 0.6))
  B
  (or A B)))
(hist (repeat 1000 get-sample))


При запуске мы получим следующий результат: #f — 21%, #t — 79% (цифры от запуска к запуску могут немного меняться). Этот результат означает, что значение B равно #t с вероятностью чуть меньше 0.8. Откуда взялась эта вероятность, если в программе B – это бинарная случайная величина, для которой P(#t)=0.6? Очевидно, дело в наложении условия: (or A B). В процессе сэмплирования мы принимаем только такие значения B, что верно или A, или само B. Фактически, мы считаем апостериорную вероятность P(B|A+B). Можно было бы воспользоваться правилом Байеса для того, чтобы вычислить эту вероятность вручную:

        P(B|A+B) = P(A+B|B)P(B)/P(A+B) = 
        =(P(A|B)+P(B|B)–P(A|B)P(B|B))P(B)/(P(A)+P(B)–P(A)P(B))=
        =(P(A)+1–P(A))P(B)/(P(A)+P(B)–P(A)P(B))=0.6/(0.4+0.6–0.4*0.6)=0.789.

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

Итак, сэмплирование позволяет нам вычислять апостериорные вероятности интересующих нас случайных величин при наложении тех или иных условий. Оно заменяет правило Байеса, широко используемое в машинном обучении для выбора моделей или выполнения предсказаний. При этом запись программы на вероятностном языке для многих людей может оказаться гораздо понятнее, чем применение правила Байеса. Конечно, само режекторное сэмплирование весьма просто можно реализовать на обычном языке программирования, но вероятностные языки этим не ограничиваются.
В Чёрче, в частности, реализована другая функция для сэмплирования – enumeration-query. Запустим программу

(enumeration-query
  (define A (flip 0.4))
  (define B (flip 0.6))
  B
  (or A B))


На выходе мы получим: ((#t #f) (0.7894736842105263 0.2105263157894737)). Здесь выведены точные значения (конечно, со скидкой на конечную разрядную сетку) вероятностей P(B|A+B). enumeration-query уже не просто запускает много раз программу, но анализирует пути ее выполнения и перебирает все возможные значения случайных переменных с учетом их вероятностей. Конечно, такое «сэмплирование» будет работать, только когда множество возможных комбинаций значений случайных переменных не слишком велико.

Есть в Чёрче и более продвинутая замена режекторному сэмплированию на основе MCMC (Monte Carlo Markov Chains), а именно Metropolis Hastings алгоритм, откуда и название у процедуры – mh-query. Эта процедура запроса сразу формирует заданное число сэмплов (а также получает на вход один дополнительный параметр – лаг). Эта процедура также нетривиальна в реализации, так что использование готового вероятностного языка (а не собственная реализация простых процедур сэмплирования на обычном языке) приобретает смысл.

Однако главное, что дает вероятностное программирование, – это стиль мышления.

От азов к применению


Разные разработчики находят разные применения вероятностному программированию. Многие применяют его непосредственно для решения задач машинного обучения. Авторы же языка Чёрч, Noah D. Goodman and Joshua B. Tenenbaum, в своей web-книге «Probabilistic Models of Cognition» показывают применение вероятностного программирования для когнитивного моделирования. Также известно, как решение задач планирования удобно представлять в терминах вывода в вероятностных языках. Оно также оказывается применимым для представления знаний и вывода над ними, а также для задач машинного восприятия (в том числе, распознавания изображений). Все эти приложения пока более или менее разрозненные, но наличие общего фреймворка для всех них свидетельствует о том, что вероятностное программирование может стать «теорией великого объединения» для ИИ. Посмотрим на простейшие примеры возможного использования.

Одним из наиболее классических примеров применения экспертных систем является медицинская диагностика. В частности, система MYCIN была построена на системе правил вида:

Rule 52:
If
  1. THE SITE OF THE CULTURE IS BLOOD
  2. THE GRAM OF THE ORGANISM I S NEG
  3. THE MORPHOLOGY OF THE ORGANISM IS ROD
  4. THE BURN OF THE PATIENT IS SERIOUS

Then there is weakly suggestive evidence (0.4) that
  1. THE IDENTITY OF THE ORGANISM IS PSEUDOMONAS


Очевидно, правила такого вида хорошо описываются на языке типа Чёрч. При этом нет необходимости еще и реализовывать процедуру вывода – достаточно просто записать систему правил. Приведем пример из упомянутой книги «Probabilistic Models of Cognition»:

(define samples
  (mh-query 1000 100
    (define lung-cancer (flip 0.01))
    (define TB (flip 0.005))
    (define cold (flip 0.2))
    (define stomach-flu (flip 0.1))
    (define other (flip 0.1))

    (define cough (or (and cold (flip 0.5)) (and lung-cancer (flip 0.3)) (and TB (flip 0.7)) (and other (flip 0.01))))
    (define fever (or (and cold (flip 0.3)) (and stomach-flu (flip 0.5)) (and TB (flip 0.2)) (and other (flip 0.01))))
    (define chest-pain (or (and lung-cancer (flip 0.4)) (and TB (flip 0.5)) (and other( flip 0.01))))
    (define shortness-of-breath (or (and lung-cancer (flip 0.4)) (and TB (flip 0.5)) (and other (flip 0.01))))

    (list lung-cancer TB)
    (and cough fever chest-pain shortness-of-breath)))
(hist samples "Joint inferences for lung cancer and TB")


В этой программе определяются априорные вероятности появления у больного рака легких, туберкулеза, простуды и т.д. Далее определяются вероятности наблюдения кашля, жара, боли в груди и стесненного дыхания при тех или иных заболеваниях. Возвращаемая величина – это пара булевых значений, есть ли у пациента рак и/или туберкулез. И, наконец, условие – это совокупность наблюдаемых симптомов (то есть сэмплирование производится при условии, что значение всех переменных – cough fever chest-pain shortness-of-breath – #t).

Результат выполнения программы будет иметь следующий вид: (#f #f) — 4%, (#f #t) — 58%, (#t #f) — 37%, (#t #t) — 1%.
Несложно сделать, чтобы samples была функцией, в которую подается перечень симптомов, который далее в mh-query используется для сэмплирования, что даст возможность ставить диагнозы разным пациентам. Конечно, этот пример сильно упрощенный, но видно, что в стиле вероятностного программирования вполне можно представлять знания и делать вывод над ними.

Естественно, можно решать и задачи машинного обучения. Их отличие будет лишь в том, что неизвестными величинами будут параметры самой модели, а в качестве условия для сэмплирования будет выступать генерация этой моделью обучающей выборки. К примеру, в представленной выше программе мы бы числа в строках вида (define lung-cancer (flip 0.01)) могли бы заменить на переменные, которые сами бы задавались как случайные, например (define p-lung-cancer (uniform 0 1)), а далее для каждого пациента из обучающей выборки значение lung-cancer уже определялось бы с вероятностью p-lung-cancer.

Рассмотрим эту возможность на простом примере оценивания параметров многочлена по набору точек. В следующей программе функция calc-poly вычисляет значение многочлена с параметрами ws в точке x. Функция generate применяет calc-poly к каждому значению из заданного списка xs и возвращает список соответствующих ординат. Процедура noisy-equals? «приближенно» сравнивает два заданных значения (если эти значения равны, то функция возвращает #t с вероятностью 1; если же они не равны, то чем больше они отличаются, тем с меньшей вероятностью она вернет #t).

(define (calc-poly x ws)
  (if (null? ws) 0
      (+ (car ws) (* x (calc-poly x (cdr ws))))))

(define (generate xs ws)
  (map (lambda (x) (calc-poly x ws)) xs))

(define (noisy-equals? x y)
  (flip (exp (* -3 (expt (- x y) 2)))))

(define (samples xs ys)
  (mh-query 1 100
            (define n-coef 4)
            (define ws (repeat n-coef (lambda () (gaussian 0 3))))
            ws
            (all (map noisy-equals? (generate xs ws) ys))))
(samples '(0 1 2 3 4) '(0.01 1.95 6.03 12.01 20.00))


Внутри вызова mh-query параметр n-coef определяет число коэффициентов в многочлене (то есть его степень плюс один); ws – это список, состоящий из случайных величин, сгенерированных в соответствии с нормальным распределением. Возвращаемое значение – список параметров многочлена. Условие для сэмплирования – «приближенное» равенство всех заданных значений ys всем ординатам, порожденным многочленом при данных ws. Здесь мы запрашиваем всего одну реализацию, которая проходит по условию (поскольку строить гистограмму для вектора параметров не очень удобно). Результатом этого запроса может быть, к примеру, список (2.69 1.36 0.53 -0.10), задающий многочлен 2.69+1.36x+0.53x^2–0.10x^3.

Вообще, вывод на моделях с вещественными параметрами – не самая сильная сторона языка Чёрч (но не стоит это считать глобальным недостатком вероятностного программирования вообще). Тем не менее, на этом примере mh-query кое-как работает. Чтобы в этом убедиться, вместо определения значений параметров в запросе можно попросить возвращать предсказание в некоторой точке. Перепишем последний фрагмент кода так:

(define (samples xs ys)
  (mh-query 100 100
            (define n-coef 4)
            (define ws (repeat n-coef (lambda () (gaussian 0 3))))
            (calc-poly 5 ws)
            (all (map noisy-equals? (generate xs ws) ys))))
(hist (samples '(0 1 2 3 4) '(0.01 1.95 6.03 12.01 20.00)))


То есть мы запрашиваем наиболее вероятное (при имеющихся данных) значение в точке x=5. При разных запусках максимум гистограммы, к сожалению, будет приходиться на несколько различающиеся значения (метод MCMC, теоретически, гарантирует схождение к истинному распределению, но лишь в пределе), но обычно эти значения будут достаточно вразумительными. Стоит заметить, что здесь мы «бесплатно» (заменой одной строчки) получили полное байесовское предсказание: вместо выбора лучшей модели и предсказания лишь по ней, мы получили апостериорное распределение значений в точке x=5, усредненное сразу по множеству моделей с учетом их собственных вероятностей.
Но и это еще не все. Опять же, заменой одной строчки – (define n-coef 4) -> (define n-coef (random-integer 5)) мы можем сделать автоматический выбор между моделями с разным числом параметров. Причем сэмплирование величины n-coef показывает (хотя и не очень стабильно), что наиболее вероятным значением является n-coef=3 (то есть парабола, которая и заложена в заданный набор точек). При такой модификации более стабильным становится и предсказание. Иными словами, не возникает и эффекта переобучения! Почему же не выбираются многочлены более высокой степени, ведь они могут точнее проходить к заданным точкам? Дело в том, что при сэмплировании «угадать» подходящие значения параметров многочлена меньшей степени проще, чем многочлена более высокой степени, поэтому вероятность породить такие параметры, которые пройдут проверку, для многочлена второй степени выше, чем для третьей. В то же время, многочлен первой степени будет давать большие отклонения, для которых вероятность срабатывания noisy-equals? будет сильно понижаться.

Посмотрим еще на одно применение, которое в рамках вероятностного программирования может показаться неожиданным. Это решение «дедуктивных» задач. Возьмем приведенную в начале функцию вычисления факториала, но вместо вызова ее с фиксированным значением будем считать, что аргумент – случайная переменная, но на само значение факториала наложено ограничение:

(define (f n)
  (if (= n 0) 1 (* n (f (- n 1)))))
(enumeration-query
 (define n (random-integer 20))
 n
 (equal? (f n) 120))


В качестве ответа мы увидим n=5 с вероятностью 1. Если же мы вместо 120 зададим 100, то программа не зациклится (в отличие от случая использования rejection-query или mh-query, что можно считать их недостатком), а просто вернет пустое множество. Можно поставить в качестве условия и не строгое равенство, а какое-то другое ограничение.

Таким же образом можно решать и более сложные задачи. Допустим, мы хотим решить задачу о сумме подмножеств: в ней надо из заданного множества чисел найти такое подмножество, сумма в котором равна заданному числу (обычно в качестве этого числа берется 0 и требуется, чтобы подмножество было не пустым; но чтобы избавиться от проверки на нетривиальность решения, мы возьмем ненулевую сумму). Казалось бы, причем тут вероятностное программирование? Но случайные величины – это просто неизвестные величины (для которых заданы априорные вероятности). В любых задачах нам нужно найти что-то неизвестное, в том числе и в задаче о сумме подмножеств. Посмотрим на следующую элементарную программу (ее можно было бы даже еще упростить, записав summ через fold).

(define (solution xs v)
  (rejection-query
   (define ws (repeat (length xs) flip))
   (define (summ xs ws)
     (if (null? xs) 0
         (+ (if (car ws) (car xs) 0) (summ (cdr xs) (cdr ws)))))
   ws
   (equal? (summ xs ws) v)))
(solution '(-1 3 7 5 -9 -1) 1)


Здесь ws – список случайных булевых значений. Процедура summ вычисляет сумму элементов списка xs, для которых соответствующие элементы списка ws истинны. Далее запрашивается значения ws, для которых выполняется условие равенства полученной суммы заданному числу v. Запустив эту программу, можно получить такой результат: (#f #t #t #f #t #f), который, конечно, является правильным (так как 3+7-9=1).

Естественно, Чёрч не делает чуда и при повышении размерности этой задачи он с ней не справится. Однако не может не удивлять то, что столь разные задачи ИИ могут быть хотя бы поставлены (и отчасти решены) с использованием одного и того же языка. Ну, а проблема эффективного вывода как была, так и остается. В вероятностных языках она хотя бы выделяется в чистом виде.
Поделиться публикацией
Комментарии 25
    +1
    Спасибо за интересную статью.

    Хотелось-бы понять ограничения этого языка (последний абзац). Можно ли смелым движением сделать на Чёрче нейронную сеть, переписав весовые коэффициенты связей в вероятностный вид? И не покажет-ли такая ИНС новое качество, которого всё никак не удаётся добиться от обычных ИНС?
      0
      Пожалуйста!
      Как в статье сказано, работа с непрерывными вероятностными переменными — не самая сильная сторона Чёрча. То есть сделать-то ИНС можно, но общие механизмы вывода будут работать весьма неэффективно. Новое качество само не появится, но достичь его очень просто. В Тьюринг-полных вероятностных языках легко можно задать генеративную модель, не просто параметризованную связями сети, но порождающую нейронные сети с разной структурой. При этом, скорее всего, не будет эффекта переобучения. Но, опять же, все уткнется в проблему эффективного вывода.
      Вероятностные языки типа Infer.NET для частного вида ИНС могут подойти больше, так как вывод в них (для графических моделей) гораздо эффективнее прямого сэмплирования. Однако там не получится реализовать произвольные ИНС (опять же, как упоминалось в статье, машины Больцмана там не реализовать, но над реализацией автоэнкодеров мы сейчас немного работаем) и не получится автоматически формировать их архитектуру.
      Но эта область активно развивается. Я видел работы от Microsoft Research, посвященные Тьюринг-полным вероятностным языкам. Да и в новую версию Infer.NET уже добавлен Fun. Также видел ряд работ, где проводилась автоматическая генерация эффективных алгоритмов вывода для Чёрча для моделей частного вида (и есть даже доступные реализации типа cosh, но их возможности пока ограничены). Мы сами сделали экспериментальный язык, где процедуры сэмплирования типа mh-query в Чёрче заменены генетическим программированием, что для ряда задач катострафически поднимает производительность (и, кстати, надо попробовать нашу реализацию на нейронных сетях).
      В общем, с точки зрения пользователя вероятностные языки уже могут найти применение, но пока не глобальное. Однако в перспективе их роль будет продолжать расти.
        +1
        Спасибо за ответ. Про ИНС я спросил в качестве широко известного примера, поскольку сам интересуюсь вычислительной онтологией — совмещаю онтологические знания (верифицированные, с вероятностью близкой к единице) со знаниями, накопленными статистическим анализом больших корпусов текстов (неверифицированные, следовательно — вероятностные по своей природе).

        Эта задача в реализации похожа на ИНС именно огромным количеством взвешенных связей. Разумеется, просчёт такой сети задача вычислительно трудная, однако, если бы был шанс получить новое качество (за счёт замены одного действительного числа — вероятности, на распределение), было бы интересно попробовать. Возможно, совмещение нескольких распределений даст всплески в неожиданных местах (биения).

        Можно ли ожидать появления таких вот биений?
          0
          Один мой коллега как раз занимается проблемой совмещения онтологий. Когда он недавно познакомился с вероятностным программированием, у него возникла идея применить его к этой проблеме. К сожалению, пока идея не реализована, и не факт, что он этим займется. Но приложение, тем не менее, интересное. Если у Вас вдруг будут какие-то продвижения в этом направлении, пожалуйста, сообщите.
          Для совмещения онтологий, видимо, нужно строить для них общую генеративную модель, отдельные онтологии для которой будут ее реализациями. Вопрос в том, насколько произвольную структуру этой модели задавать. Чем произвольнее, тем интереснее результаты могут быть получены, но тем больше нужно будет данных, и тем сложнее будет задача вывода… В общем, это вопрос для исследования.

          На больших базах специализированные (но более общие, чем стандартные) методы могут работать. Вот, вроде, релевантный пример
          probcomp.csail.mit.edu/bayesdb/
            +1
            Мне кажется, объём/скорость не позволит. Говорят, MCMC весьма медленный (или неточный — сэмплирование же), ну а кортежи для каждой возможной комбинации переменных иметь — нафиг-нафиг.
            Если уж даже у классических (невероятностных) ontology inference engines рвёт крышу от миллиона концептов (со ссылкой на www.lektorium.tv/course/22781 ), то тут на тысяче систему нафиг переклинит.
            Я скорее верю во что-то типа подхода ProBase: если совместить много баз знаний, и оставить только данные, подтверждённые разными источниками, то крайне неплохой «всеобщий пониматель» получится.
            Но брать движок от вероятностных моделей — на мой взгляд, тупиковый путь.
            Подобным образом, Хинтоновские RBM, конечно, намного круче линейных, но для них тоже нужен sampling… Поэтому картинки сейчас распознают обычными Deep Network с обычным Хинтоновским BackPropagation, а не более совершенными методами…
            Хотя, надежда на возвращение к generative methods у ведущих исследователей остаётся.
              +1
              Что-то ссылки не те в итоге получились: research.microsoft.com/en-us/projects/probase/default.aspx — ProBase,
              www.reddit.com/r/MachineLearning/comments/2lmo0l/ama_geoffrey_hinton/clyjccv — в последнем абзаце, по слову «остаётся».
                0
                На MCMC свет клином не сошелся. Его ограничения вполне понятны. Но вероятностное программирование как подход применяют и в автоматическом анализе видео (конечно, при этом создают весьма специализированные механизмы вывода). Есть надежда, что такие механизмы вывода можно не хардкодить, а синтезировать средствами метавычислений. Да и то, что 10 лет назад казалось непрактичным из-за требований к вычислительным ресурсам, сейчас вполне используется. Те же сети глубокого обучения (которые также в своей нынешней форме лет через 5 отживут свое и заменятся более общими генеративными моделями). Ну, а конкретно нас интересует проблематика общего ИИ, что заставляет работать на перспективу.
          0
          Статья состоит из набора общих фраз и совершенно неинформативных примеров. В двух словах можно, в чём суть концепции?
            0
            А какие примеры были бы информативнее, а фразы конкретнее?
            Суть концепции в том, чтобы трактовать программы со случайными выборами как распределения вероятностей и реализовать данную вероятностную семантику языков на уровне интерпретаторов/компиляторов.
              0
              Чем-то напоминает fuzzy sets и fuzzy logic. Перечитаю статью после работы (голова занята рабочими моментами) — будет яснее.
                +1
                Да, это немного похоже на нечеткую логику. Но нечеткая логика гораздо ограниченнее (во многих аспектах).
                  0
                  Полез смотреть про эти языки и наткнулся на сравнение Bayesian programming versus possibility theories, а чуть ниже Bayesian programming versus probabilistic programming.
                    0
                    «Нечёткая логика», друг мой, ну НИЧЕМ не отличается от теории вероятности и является не более чем распиаренной обёрткой классической статистики! Доказательство элементарно: возьмите «функция принадлежности», на основе которой строится вся т.н. «нечёткая логика» и обратите внимание, что она НИЧЕМ не отличается от обыкновеннейшего распределения вероятности. Точка.
                      +1
                      Утверждение, что нечеткая логика ничем не отличается от теории вероятностей, формально неверно. В нечеткой логике есть несколько вариантов правил вычисления функций принадлежности от составных высказываний (например, дизъюнкций и конъюнкций), но во всех этих правилах функции принадлежности факторизуются, то есть для вычисления функции принадлежности составного высказывания нужны только значения функций принадлежности его частей. В теории вероятностей совместные вероятности событий в общем случае не факторизуются. Вывод очевиден: из функций принадлежности не могут быть в общем случае получены распределения вероятностей. Однако обратное возможно: для каждого типа нечеткой логики можно найти условия, при которых правила нечеткого вывода оказываются частным случаем расчета вероятностей. Самый простой случай — это статистическая независимость случайных величин (но есть и другие варианты, например, когда одна величина полностью зависит от другой). Так что, в лучшем случае, нечеткую логику можно рассматривать как совокупность частных случаев теории вероятностей, так что говорить, что «нечеткая логика ничем не отличается от теории вероятностей» — это все равно, что говорить «мужчина ничем не отличается от человека», или «физика ничем не отличается от науки» или «искусственная нейронная сеть ничем не отличается от алгоритма».
                      Стоит отметить, что, на самом деле, любители нечеткой логики отстаивают утверждение, что и такое сведение не вполне справедливо. На уровне математического формализма им спорить сложно, так что они спорят на уровне интерпретаций: по их мнению, смысл случайности и смысл нечеткости разный (например, приписывать статистический смысл лингвистическим переменным действительно может быть не очень комфортно). С точки зрения математики, конечно, это нерелевантный аспект. Однако в смысле практики использования отличия есть и существенные. Опять же — аналогия между ИНС и алгоритмами вообще. ИНС — это распиаренный класс алгоритмов. Да. Но это не «обыкновенные» (произвольные) алгоритмы, а конкретный класс, для которого есть своя терминология, свой инструментарий.
                      Когда я говорил, что нечеткая логика немного похожа на вероятностное программирование, я имел в виду не ту банальность, что и то, и другое как-то связано с вероятностями, а то, что способы использования у них могут быть похожи, но вероятностное программирование имеет гораздо более широкие возможности, чем нечеткая логика.
                        0
                        " но во всех этих правилах функции принадлежности факторизуются"

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

                        Но в остальном с вами не поспоришь. Взгляд на «нечёткую логику» как частный случай теории вероятностей весьма интересен. Пошёл осмысливать :)
                          0
                          Да, я упоминал случай независимых величин. Но существует как минимум 3 «стандартных» варианта нечеткой логики. Каждый получается в рамках своих предположений. Если бы совместные вероятности всегда и полностью выражались через маргинальные вероятности отдельных случайных переменных, то Байесовские сети не были бы столь популярными. Но, да, иногда лучше как можно сильнее все упростить, чтобы хоть как-то работало, чем иметь дело с неподъемной задачей. Поэтому нечеткая логика получила такую популярность — она давала практические рецепты. Однако, если бы этого было бы достаточно во всех случаях, то не было бы движения сначала к графическим моделям, а от них теперь — к вероятностному программированию.
                  0
                  Опять набор слов. Ну так и трактуйте себе распредления вероятностей как РАСПРЕДЕЛЕНИЯ ВЕРОЯТНОСТЕЙ, считайте от них характеристики (матожидания, дисперсии, моменты и т.д.), принимайте оптимальные решения. Это — понятно и это работает. А что здесь-то предлагается?
                  Что такое «вероятностная семантика»? Это как? Оператор типа case rnd? Ну и какой от него смысл? Или как один умник хотел провести эксперимент: в какой-нибудь стандартной проге типа блокнота менять один байт и запускать её, если программа «упала» — откат назад, если нет, менять случайным образом другой байт. Ну он в результате получил прогу, которая ни в каком родстве не лежала с иходной и жила своей жизнью. Это типа того же?
                    0
                    Честно — не знаю, как это описать понятнее. В статье, вроде, все сказано, и я просто буду повторять то, что там есть, разве что другими словами. Могу попробовать привести другие примеры, но хотелось бы знать, какие будут показательными. Может, имеет смысл Вам попробовать почитать другие источники — ту же упоминавшуюся книжку Probabilistic models of cognition…
                +5
                По заголовку показалось что речь будет о программировании где вероятность корректного выполнения команды не равна 1. А подумалось так потому что несколько лет назад читал статью про разработку нового типа CPU в котором использовались текущих технологий со значительно повышенной частотой и пониженным напряжением, но сделано это за счет того что вероятность ошибок становилась значительной. Причем вероятность достаточно высокая чтобы было бесполезно пытаться отлавливать и исправлять ошибки. В той статье был вывод вида «В рамках текущей парадигмы программирования смысла в таких процессорах нет, но возможно будут полезны для класса задач где требуется больше скорости и есть устойчивость к ошибкам, например искусственный интеллект».
                  0
                  Занятно. Однако для вероятностных программ такие процессоры, видимо, все же не подойдут, так как там основная часть вычислений детерминированная, а случайность черпается из контролируемого источника. Но, может, какие-то родственные приложения придумать можно…
                  +1
                  Идея звучит заманчиво, но стоит погуглить сам язык, и наступает разочарование. Куцая вики и полторы реализации — вот и всё, что есть. Печальненько…
                    +3
                    1. С куцей вики идет ссылка на целую книжку по языку (его использованию в когнитивном моделировании) Probabilistic models of cognition, о которой упоминалось в тексте, а также на 4 реализации (хотя можно их можно «редуцировать» до полутора при желании). Так что не надо грустить.
                    2. Статья была не про сам Чёрч, а про вероятностные языки как подход на примере Чёрча. И, да, прикладное использование пока ограничено, о чем тоже говорилось…
                      0
                      Слона-то я и не заметил… Спасибо за ссылку на книгу!
                    0
                    А си-образные случайные языки есть?
                      +1
                      Да, в частности, Probabilistic-C. Ну, и упоминавшийся Infer.NET также доступен с C++-сном варианте.

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

                    Самое читаемое