Наивный Байес

«Наивное» предположение неверно — и всё же метод работает. В этом и заключается его красота.

Тип: Сборка Язык: Python Предварительные требования: Фаза 2, уроки 01–07 (классификация, теорема Байеса) Время: ~75 минут

Цели обучения

• Реализовать Multinomial Naive Bayes с нуля со сглаживанием Лапласа для классификации текста
• Объяснить, почему наивное предположение о независимости математически неверно, но на практике даёт правильное ранжирование классов
• Сравнить варианты Multinomial, Bernoulli и Gaussian Naive Bayes и выбрать подходящий для заданного типа признаков
• Оценить Naive Bayes в сравнении с логистической регрессией на разреженных данных высокой размерности и объяснить действующий компромисс между смещением и дисперсией

Проблема

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

Большинство классификаторов здесь испытывают трудности. Логистической регрессии нужно достаточно образцов, чтобы надёжно оценить тысячи весов. Деревья решений разделяют по одному слову за раз и сильно переобучаются. KNN в 10 000 измерений бессмысленен, потому что каждая точка находится примерно на одинаковом расстоянии от любой другой.

Naive Bayes справляется с этим. Он делает математически неверное предположение (что каждый признак независим от остальных при известном классе), и всё же превосходит «более умные» модели в классификации текста, особенно на небольших обучающих наборах. Он обучается за один проход по данным, масштабируется до миллионов признаков и выдаёт оценки вероятностей (хотя из-за предположения о независимости они часто плохо откалиброваны).

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

Концепция

Теорема Байеса (краткое повторение)

Теорема Байеса обращает условные вероятности:

P(class | features) = P(features | class) * P(class) / P(features)

Нам нужна P(class | features) — вероятность того, что документ принадлежит классу при известных содержащихся в нём словах. Её можно вычислить из:

• P(features | class) — правдоподобия встретить эти слова в документах данного класса
• P(class) — априорной вероятности класса (насколько вообще распространён спам?)
• P(features) — свидетельства; оно одинаково для всех классов, поэтому при сравнении его можно игнорировать

Побеждает класс с наибольшей P(class | features).

Наивное предположение о независимости

Точное вычисление P(features | class) требует оценки совместной вероятности всех признаков одновременно. При словаре в 10 000 слов пришлось бы оценивать распределение для 2^10,000 возможных комбинаций. Это невозможно.

Наивное предположение: каждый признак условно независим при известном классе.

P(w1, w2, ..., wn | class) = P(w1 | class) * P(w2 | class) * ... * P(wn | class)

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

Это предположение очевидно неверно. Слова «machine» и «learning» не независимы ни в одном документе. Но классификатору не нужны правильные оценки вероятностей. Ему нужно правильное ранжирование — то есть класс с наибольшей вероятностью. Предположение о независимости вносит систематические ошибки, но они похожим образом влияют на все классы, поэтому ранжирование остаётся правильным.

Почему это всё же работает

Три причины:

1. Ранжирование важнее калибровки. Для классификации достаточно, чтобы был верно выбран класс с максимальным рангом. Даже если P(spam) = 0.99999 при истинной вероятности 0.7, классификатор всё равно правильно выбирает спам. Нам не нужны точные вероятности — нам нужен правильный победитель.

2. Высокое смещение, низкая дисперсия. Предположение о независимости — сильный априорный принцип. Оно жёстко ограничивает модель и тем самым предотвращает переобучение. При ограниченных обучающих данных слегка неверная, но стабильная модель лучше теоретически правильной, но крайне нестабильной. Это компромисс между смещением и дисперсией в действии.

3. Избыточность признаков взаимно компенсируется. Коррелированные признаки дают дублирующее свидетельство. Классификатор учитывает это свидетельство дважды, но дважды учитывает его и для правильного класса. Если «machine» и «learning» всегда встречаются вместе, оба слова свидетельствуют в пользу класса «tech». NB посчитает их дважды, но для правильного класса.

Есть и четвёртая практическая причина: Naive Bayes чрезвычайно быстр. Обучение — это один проход по данным с подсчётом частот. Предсказание — матричное умножение. На миллионе документов можно обучиться за секунды. Благодаря скорости вы быстрее итерируете, пробуете больше наборов признаков и запускаете больше экспериментов, чем с более медленными моделями.

Математика шаг за шагом

Рассмотрим конкретный пример. Предположим, у нас два класса: спам и не-спам. В словаре три слова: «free», «money», «meeting».

Обучающие данные:

• В спам-письмах «free» встречается 80 раз, «money» — 60 раз, «meeting» — 10 раз (всего 150 слов)
• В не-спаме «free» встречается 5 раз, «money» — 10 раз, «meeting» — 100 раз (всего 115 слов)
• 40% писем — спам, 60% — не-спам

Со сглаживанием Лапласа (alpha=1):

P(free | spam)    = (80 + 1) / (150 + 3) = 81/153 = 0.529
P(money | spam)   = (60 + 1) / (150 + 3) = 61/153 = 0.399
P(meeting | spam) = (10 + 1) / (150 + 3) = 11/153 = 0.072

P(free | not-spam)    = (5 + 1) / (115 + 3) = 6/118 = 0.051
P(money | not-spam)   = (10 + 1) / (115 + 3) = 11/118 = 0.093
P(meeting | not-spam) = (100 + 1) / (115 + 3) = 101/118 = 0.856

Новое письмо содержит: «free» (2 раза), «money» (1 раз), «meeting» (0 раз).

log P(spam | email) = log(0.4) + 2*log(0.529) + 1*log(0.399) + 0*log(0.072)
                    = -0.916 + 2*(-0.637) + (-0.919) + 0
                    = -3.109

log P(not-spam | email) = log(0.6) + 2*log(0.051) + 1*log(0.093) + 0*log(0.856)
                        = -0.511 + 2*(-2.976) + (-2.375) + 0
                        = -8.838

Спам выигрывает с большим отрывом. Слово «free», встретившееся дважды, — сильное свидетельство в пользу спама. Обратите внимание, что отсутствие «meeting» даёт ноль в обеих логарифмических суммах (0 * log(P)): в Multinomial NB отсутствующие слова не влияют на результат. Именно Bernoulli NB явно моделирует отсутствие слова.

Три варианта

Naive Bayes бывает трёх видов. Каждый по-разному моделирует P(feature | class).

Multinomial Naive Bayes

Моделирует каждый признак как счётчик. Лучше всего подходит для текстовых данных, где признаки — частоты слов или значения TF-IDF.

P(word_i | class) = (count of word_i in class + alpha) / (total words in class + alpha * vocab_size)

alpha — это сглаживание Лапласа (объяснено ниже). Этот вариант — рабочая лошадка классификации текста.

Gaussian Naive Bayes

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

P(x_i | class) = (1 / sqrt(2 * pi * var)) * exp(-(x_i - mean)^2 / (2 * var))

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

Bernoulli Naive Bayes

Моделирует каждый признак как бинарный (присутствует или отсутствует). Лучше всего подходит для коротких текстов или бинарных векторов признаков.

P(word_i | class) = (docs in class containing word_i + alpha) / (total docs in class + 2 * alpha)

В отличие от Multinomial, Bernoulli явно штрафует отсутствие слова. Если «free» обычно встречается в спаме, но отсутствует в этом письме, Bernoulli учитывает это как свидетельство против спама.

Когда использовать каждый вариант

Вариант	Тип признаков	Лучше всего для	Пример
Multinomial	Счётчики или частоты	Классификация текста, bag-of-words	Спам, классификация тем
Gaussian	Непрерывные значения	Табличные данные с примерно нормальными признаками	Классификация Iris, данные датчиков
Bernoulli	Бинарные (0/1)	Короткий текст, бинарные векторы признаков	SMS-спам, признаки присутствия/отсутствия

Сглаживание Лапласа

Что произойдёт, если слово появляется в тестовых данных, но никогда не встречалось в обучающих данных для конкретного класса?

Без сглаживания: P(word | class) = 0/N = 0. Один ноль, умноженный на всё произведение, превращает P(class | features) = 0 независимо от всех остальных свидетельств. Одно невиданное слово разрушает предсказание, каким бы сильным ни было остальное свидетельство.

Сглаживание Лапласа добавляет небольшой счётчик alpha (обычно 1) к каждому счётчику признака:

P(word_i | class) = (count(word_i, class) + alpha) / (total_words_in_class + alpha * vocab_size)

При alpha=1 каждое слово получает хотя бы малую вероятность. Слово «discombobulate» в тестовом письме больше не уничтожает вероятность спама. У сглаживания есть байесовская интерпретация: оно эквивалентно равномерному априорному распределению Дирихле на распределения слов.

Большая alpha означает более сильное сглаживание (более равномерные распределения). Меньшая alpha означает, что модель сильнее доверяет данным. Alpha — гиперпараметр, который нужно настраивать.

Эффект alpha:

Alpha	Эффект	Когда использовать
0.001	Почти нет сглаживания, доверие данным	Очень большой обучающий набор, не ожидаются невиданные признаки
0.1	Лёгкое сглаживание	Большой обучающий набор
1.0	Стандартное сглаживание Лапласа	Начальная точка по умолчанию
10.0	Сильное сглаживание, выравнивает распределения	Очень маленький обучающий набор, ожидается много невиданных признаков

Вычисления в логарифмическом пространстве

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

Решение — работать в логарифмическом пространстве. Вместо умножения вероятностей складывайте их логарифмы:

log P(class | x1, x2, ..., xn) = log P(class) + sum_i log P(xi | class)

Это превращает предсказание в скалярное произведение:

log_scores = X @ log_feature_probs.T + log_class_priors
prediction = argmax(log_scores)

Матричное умножение. Поэтому предсказание Naive Bayes так быстро: это та же операция, что и в однослойной линейной модели.

Naive Bayes и логистическая регрессия

Оба метода — линейные классификаторы для текста. Разница в том, что именно они моделируют.

Аспект	Naive Bayes	Логистическая регрессия
Тип	Генеративная (моделирует P(X|Y))	Дискриминативная (моделирует P(Y|X))
Обучение	Подсчёт частот	Оптимизация функции потерь
Мало данных	Лучше (помогает сильный prior)	Хуже (недостаточно данных для оценки весов)
Много данных	Хуже (мешает неверное предположение)	Лучше (гибкая граница)
Признаки	Предполагает независимость	Обрабатывает корреляции
Скорость	Один проход, очень быстро	Итеративная оптимизация
Калибровка	Плохие вероятности	Более качественные вероятности

Практическое правило: начните с Naive Bayes. Если у вас достаточно данных и качество NB перестало расти, перейдите к логистической регрессии.

Конвейер классификации

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

log P(class | features) = log P(class) + sum_i log P(feature_i | class)

naive-bayes

Соберите это

Код в code/naive_bayes.py реализует с нуля и MultinomialNB, и GaussianNB.

MultinomialNB

Реализация с нуля:

1. fit(X, y): Для каждого класса подсчитать частоту каждого признака. Добавить сглаживание Лапласа. Вычислить логарифмы вероятностей. Сохранить априорные вероятности классов (логарифмы частот классов).

2. predict_log_proba(X): Для каждого образца вычислить log P(class) + сумму log P(feature_i | class) для всех классов. Это матричное умножение: X @ log_probs.T + log_priors.

3. predict(X): Вернуть класс с наибольшей логарифмической вероятностью.

class MultinomialNB:
    def __init__(self, alpha=1.0):
        self.alpha = alpha

    def fit(self, X, y):
        classes = np.unique(y)
        n_classes = len(classes)
        n_features = X.shape[1]

        self.classes_ = classes
        self.class_log_prior_ = np.zeros(n_classes)
        self.feature_log_prob_ = np.zeros((n_classes, n_features))

        for i, c in enumerate(classes):
            X_c = X[y == c]
            self.class_log_prior_[i] = np.log(X_c.shape[0] / X.shape[0])
            counts = X_c.sum(axis=0) + self.alpha
            self.feature_log_prob_[i] = np.log(counts / counts.sum())

        return self

Главный вывод: после обучения предсказание — это лишь матричное умножение плюс смещение. Поэтому Naive Bayes так быстр.

GaussianNB

Для непрерывных признаков мы оцениваем среднее и дисперсию для каждого класса и признака:

class GaussianNB:
    def __init__(self):
        pass

    def fit(self, X, y):
        classes = np.unique(y)
        self.classes_ = classes
        self.means_ = np.zeros((len(classes), X.shape[1]))
        self.vars_ = np.zeros((len(classes), X.shape[1]))
        self.priors_ = np.zeros(len(classes))

        for i, c in enumerate(classes):
            X_c = X[y == c]
            self.means_[i] = X_c.mean(axis=0)
            self.vars_[i] = X_c.var(axis=0) + 1e-9
            self.priors_[i] = X_c.shape[0] / X.shape[0]

        return self

Предсказание использует Gaussian PDF для каждого признака, перемноженные по признакам (в логарифмическом пространстве — сложенные).

Демонстрация: классификация текста

Код создаёт синтетические данные bag-of-words, имитирующие два класса (технические статьи и спортивные статьи). У каждого класса своё распределение частот слов. MultinomialNB классифицирует их по количеству слов.

Синтетические данные устроены так: мы создаём 200 «слов» (столбцов признаков). Слова 0–39 часто встречаются в технических статьях и редко — в спортивных. Слова 80–119 часто встречаются в спортивных статьях и редко — в технических. Слова 40–79 имеют среднюю частоту в обоих классах. Это создаёт реалистичный сценарий, где одни слова — сильные индикаторы класса, а другие — шум.

Демонстрация: непрерывные признаки

Код создаёт данные, похожие на Iris (3 класса, 4 признака, гауссовские кластеры). GaussianNB классифицирует их по среднему и дисперсии каждого класса. У каждого класса свой центр (вектор среднего) и разброс (дисперсия), что имитирует реальные данные, где измерения систематически различаются между категориями.

Код также демонстрирует:

• Сравнение сглаживания: обучение MultinomialNB с разными alpha, чтобы показать влияние силы сглаживания на точность.
• Эксперимент с размером обучающего набора: как точность NB растёт, когда число обучающих образцов увеличивается от 20 до 1600. NB достигает приемлемой точности даже при очень малом числе образцов — в этом его главное преимущество.
• Матрицу ошибок: точность, полноту и F1-меру по классам, чтобы показать, где NB ошибается.

Скорость предсказания

Предсказание Naive Bayes — матричное умножение. Для n образцов с d признаками и k классами:

• MultinomialNB: одно матричное умножение (n x d) @ (d x k) = O(n * d * k)
• GaussianNB: n * k вычислений Gaussian PDF, каждое по d признакам = O(n * d * k)

Оба метода линейны по каждой размерности. Сравните с KNN (нужно вычислить расстояние до всех обучающих точек) или SVM с RBF-ядром (нужно вычислять ядро относительно всех опорных векторов). Во время предсказания NB быстрее на порядки.

Используйте это

В sklearn оба варианта реализуются одной строкой:

from sklearn.naive_bayes import GaussianNB, MultinomialNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
print(f"GaussianNB accuracy: {gnb.score(X_test, y_test):.3f}")

mnb = MultinomialNB(alpha=1.0)
mnb.fit(X_train_counts, y_train)
print(f"MultinomialNB accuracy: {mnb.score(X_test_counts, y_test):.3f}")

Для классификации текста со sklearn:

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline

text_clf = Pipeline([
    ("vectorizer", CountVectorizer()),
    ("classifier", MultinomialNB(alpha=1.0)),
])

text_clf.fit(train_texts, train_labels)
accuracy = text_clf.score(test_texts, test_labels)

Код в naive_bayes.py сравнивает реализации с нуля со sklearn на одних и тех же данных для проверки корректности.

TF-IDF с Naive Bayes

Необработанные счётчики слов придают каждому слову одинаковый вес на каждое появление. Но распространённые слова, такие как «the» и «is», часто встречаются в каждом классе и не несут информации. TF-IDF (Term Frequency — Inverse Document Frequency) понижает вес распространённых слов и повышает вес редких, различающих классы слов.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline

text_clf = Pipeline([
    ("tfidf", TfidfVectorizer()),
    ("classifier", MultinomialNB(alpha=0.1)),
])

Значения TF-IDF неотрицательны, поэтому совместимы с MultinomialNB. Сочетание TF-IDF + MultinomialNB — один из сильнейших базовых методов для классификации текста. Оно часто превосходит более сложные модели на наборах данных с менее чем 10 000 обучающих образцов.

BernoulliNB для короткого текста

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

from sklearn.naive_bayes import BernoulliNB
from sklearn.feature_extraction.text import CountVectorizer

text_clf = Pipeline([
    ("vectorizer", CountVectorizer(binary=True)),
    ("classifier", BernoulliNB(alpha=1.0)),
])

Флаг binary=True в CountVectorizer преобразует все счётчики в 0/1. Без него BernoulliNB всё равно работает, но получает счётчики, для которых он не предназначен.

Калибровка вероятностей NB

Вероятности NB плохо откалиброваны. Когда NB сообщает P(spam) = 0.95, истинная вероятность может быть 0.7. Если вам нужны надёжные оценки вероятностей (например, чтобы задать порог или объединить их с другими моделями), используйте CalibratedClassifierCV из sklearn:

from sklearn.calibration import CalibratedClassifierCV

calibrated_nb = CalibratedClassifierCV(MultinomialNB(), cv=5, method="sigmoid")
calibrated_nb.fit(X_train, y_train)
proba = calibrated_nb.predict_proba(X_test)

Это обучает логистическую регрессию поверх сырых оценок NB с использованием кросс-валидации. Полученные вероятности гораздо ближе к истинным частотам классов.

Распространённые подводные камни

1. Отрицательные значения признаков. MultinomialNB требует неотрицательных признаков. Если у вас есть отрицательные значения (например, TF-IDF с некоторыми настройками или стандартизованные признаки), используйте GaussianNB или сдвиньте признаки в положительную область.

2. Признаки с нулевой дисперсией. GaussianNB делит на дисперсию. Если у признака нулевая дисперсия для класса (все значения одинаковы), вычисление вероятности ломается. Код добавляет малый член сглаживания (1e-9) ко всем дисперсиям, чтобы этого избежать.

3. Дисбаланс классов. Если 99% писем — не-спам, prior P(not-spam) = 0.99 настолько силён, что подавляет свидетельство правдоподобия. Можно задать априорные вероятности классов вручную или использовать параметр class_prior в sklearn.

4. Масштабирование признаков. MultinomialNB не нуждается в масштабировании (он работает со счётчиками). GaussianNB тоже не нуждается (он оценивает статистики по каждому признаку). Это преимущество перед логистической регрессией и SVM, чувствительными к масштабам признаков.

Внедрите это

Этот урок создаёт:

• outputs/skill-naive-bayes-chooser.md — навык выбора подходящего варианта NB
• code/naive_bayes.py — реализации MultinomialNB и GaussianNB с нуля и сравнение со sklearn

Когда Naive Bayes не работает

NB терпит неудачу, когда предположение о независимости приводит к неверному ранжированию (а не только к неверным вероятностям). Это случается, когда:

1. Сильные взаимодействия признаков. Если класс зависит от комбинации двух признаков, но не от каждого по отдельности (XOR-подобные паттерны), NB полностью это упустит. Каждый признак по отдельности не даёт свидетельства, а NB не может объединять их нелинейно.

2. Сильно коррелированные признаки с противоположными свидетельствами. Если признак A говорит «спам», а признак B — «не-спам», но A и B идеально коррелированы (в реальности всегда согласуются), NB увидит противоречивые свидетельства там, где их нет.

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

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

Упражнения

1. Эксперимент со сглаживанием. Обучите MultinomialNB на текстовых данных со значениями alpha 0.01, 0.1, 1.0, 10.0 и 100.0. Постройте график точности в зависимости от alpha. Где достигается максимум? Почему очень большая alpha ухудшает качество?

2. Проверка независимости признаков. Возьмите реальный текстовый набор данных. Выберите два очевидно коррелированных слова («machine» и «learning»). Вычислите P(word1 | class) * P(word2 | class) и сравните с P(word1 AND word2 | class). Насколько неверно предположение о независимости? Влияет ли это на точность классификации?

3. Реализация Bernoulli. Расширьте код классом BernoulliNB. Преобразуйте bag-of-words в бинарный вид (присутствует/отсутствует) и сравните точность с MultinomialNB на текстовых данных. Когда побеждает Bernoulli?

4. NB и логистическая регрессия. Обучите оба метода на текстовых данных. Начните со 100 обучающих образцов и увеличьте их число до 10 000. Постройте график точности в зависимости от размера обучающего набора для обоих методов. В какой момент Logistic Regression обгоняет Naive Bayes?

5. Спам-фильтр. Постройте полноценный классификатор спама: токенизируйте исходный текст письма, соберите словарь, создайте признаки bag-of-words, обучите MultinomialNB, оцените точность и полноту (а не только accuracy — почему?).

Ключевые термины

Термин	Как обычно говорят	Что это действительно означает
Naive Bayes	«Простой вероятностный классификатор»	Классификатор, применяющий теорему Байеса с предположением, что признаки условно независимы при известном классе
Условная независимость	«Признаки не влияют друг на друга»	P(A, B | C) = P(A | C) * P(B | C): узнав B, вы не получаете новой информации об A при известном C
Сглаживание Лапласа	«Сглаживание с добавлением единицы»	Добавление малого счётчика к каждому признаку, чтобы нулевые вероятности не доминировали в предсказании
Априорная вероятность	«То, во что вы верили до данных»	P(class) — вероятность каждого класса до наблюдения признаков
Правдоподобие	«Насколько хорошо подходят данные»	P(features | class) — вероятность наблюдать эти признаки, если класс известен
Апостериорная вероятность	«То, во что вы верите после данных»	P(class | features) — обновлённая вероятность класса после наблюдения признаков
Генеративная модель	«Моделирует порождение данных»	Модель, изучающая P(X | Y) и P(Y), а затем использующая теорему Байеса для получения P(Y | X)
Дискриминативная модель	«Моделирует границу решений»	Модель, которая напрямую изучает P(Y | X), не моделируя порождение X
Логарифм вероятности	«Избежать underflow»	Работа с log P вместо P, чтобы произведение множества малых чисел не стало нулём в арифметике с плавающей точкой

Дополнительное чтение

• Документация scikit-learn по Naive Bayes — все три варианта с математическими подробностями
• McCallum и Nigam, «A Comparison of Event Models for Naive Bayes Text Classification» (1998) — классическое сравнение Multinomial и Bernoulli для текста
• Rennie и др., «Tackling the Poor Assumptions of Naive Bayes Text Classifiers» (2003) — улучшения NB для текста
• Ng и Jordan, «On Discriminative vs. Generative Classifiers» (2001) — доказывает, что NB сходится быстрее LR при меньшем объёме данных

---

Источник: Naive Bayes 02.13 — Конвейеры машинного обучения · Фаза 2 — Основы машинного обучения · Полный каталог · 02.15 — Основы временных рядов