基于统计与概率的学习模型

import random  # Импортируем модуль для работы со случайными числами

# Задаем параметры для генерации чисел
na, nb, n = 1, 100, 5  # 'na' и 'nb' определяют диапазон, 'n' - количество чисел

# Генерируем и выводим n случайных чисел в диапазоне от 'na' до 'nb'
for i in range(n):
    print(random.randint(na, nb), ' ', end='')  # Генерация и печать случайного числа

print('\n')  # Переход на новую строку после вывода всех чисел

# Повторяем процесс для демонстрации независимости генераций
for i in range(n):
    print(random.randint(na, nb), ' ', end='')

59  69  26  31  23

70  44  43  77  85

import random

# Задаем параметры для генерации чисел
na, nb, n = 1, 100, 5  # 'na' и 'nb' определяют диапазон, 'n' - количество чисел

random.seed(1)  # Инициализируем генератор случайных чисел с начальным значением 1

# Генерируем и выводим n случайных чисел с фиксированным начальным значением
for i in range(n):
    print(random.randint(na, nb), ' ', end='')

print('\n')  # Переход на новую строку

# Повторяем процесс с тем же начальным значением для демонстрации воспроизводимости
random.seed(1)  # Используем то же начальное значение
for i in range(n):
    print(random.randint(na, nb), ' ', end='')

18 73 98 9 33

18 73 98 9 33

import random  # Импорт модуля для работы со случайными числами

# Установка начального значения для генератора случайных чисел обеспечивает воспроизводимость результатов
random.seed(1)  # Можно изменить на любое другое число для получения другой последовательности

n = 5  # Количество генерируемых чисел
for i in range(n):  # Цикл для генерации n случайных вещественных чисел
    print(random.random())  # Выводит случайное вещественное число от 0 до 1

0.13436424411240122
0.8474337369372327
0.763774618976614
0.2550690257394217
0.49543508709194095

import tensorflow as tf  # Импорт библиотеки TensorFlow для машинного обучения
import numpy as np       # Импорт библиотеки NumPy для работы с массивами

# Пример кода, демонстрирующий расчет вероятности с использованием TensorFlow
probability_of_failure = tf.constant(0.1)  # Определение вероятности отказа как константы TensorFlow
probability_of_success = 1 - probability_of_failure  # Вычисление вероятности успешной работы

# Непосредственный расчет и вывод вероятностей без необходимости использования сессии
print(f"Вероятность отказа: {probability_of_failure.numpy()}")
print(f"Вероятность успеха: {probability_of_success.numpy()}")

Вероятность отказа: 0.10000000149011612
Вероятность успеха: 0.8999999761581421

import tensorflow as tf

# Установка начального значения для воспроизводимости результатов
tf.random.set_seed(123)

# Создаем тензор, представляющий равномерное распределение вероятностей для чисел на верхней грани кубика
pr = tf.fill([6], 1/6)  # Все значения равны 1/6, представляя равновероятные исходы

# Выводим вероятностное распределение
print('Вероятностное распределение для каждой грани:', pr.numpy())

# Выбираем одно значение из распределения, что соответствует броску кубика
n_top = tf.random.categorical(tf.math.log([pr]), 1)  # Используем tf.random.categorical для выборки

# Выводим результат броска кубика
print('Число на верхней грани =', n_top.numpy()[0][0] + 1)  # Добавляем 1, потому что индексы начинаются с 0

Вероятностное распределение для каждой грани: [0.16666667 0.16666667 0.16666667 0.16666667 0.16666667 0.16666667]

Число на верхней грани = 1

import tensorflow as tf

n_surfaces = 6  # количество возможных значений на гранях кубика
n_tosses = 18   # количество бросков

# Установка seed для воспроизводимости результатов
tf.random.set_seed(1)

# Логарифмы вероятностей для каждой грани кубика
logits = tf.math.log([1.0/n_surfaces] * n_surfaces)

# Получение результатов бросков
toss_results = tf.random.categorical(logits[tf.newaxis, :], n_tosses)

print("Бросок", n_tosses, "раз.")
print("Результаты бросков:", tf.squeeze(toss_results).numpy())  # Удаление лишних измерений и преобразование в numpy массив

Бросок 18 раз.

Результаты бросков: [1 0 2 4 1 0 0 1 3 0 1 3 0 4 0 1 5 1]

import tensorflow as tf

n_surfaces = 6  # количество возможных значений на гранях кубика
n_tosses = 18   # количество бросков

# Установка seed для воспроизводимости результатов
tf.random.set_seed(1)

# Логарифмы вероятностей для каждой грани кубика
logits = tf.math.log([1.0/n_surfaces] * n_surfaces)

# Получение результатов бросков
toss_results = tf.random.categorical(logits[tf.newaxis, :], n_tosses)

print("Бросок", n_tosses, "раз.")
print("Результаты бросков:", tf.squeeze(toss_results).numpy())  # Удаление лишних измерений и преобразование в numpy массив

n_t = 20  # Новое количество бросков

# Проведение новой серии бросков и вывод результатов
new_toss_results = tf.random.categorical(logits[tf.newaxis, :], n_t)
print("Новые результаты бросков:", tf.squeeze(new_toss_results).numpy())

Бросок 18 раз.

Результаты бросков: [1 0 2 4 1 0 0 1 3 0 1 3 0 4 0 1 5 1]

Новые результаты бросков: [0 1 3 2 3 3 2 1 0 1 2 5 2 2 4 5 1 2 5 2]

import tensorflow as tf
import numpy as np

n_surfaces = 6  # Количество возможных значений на гранях кубика
n_tosses = 2000 # Количество бросков

# Установка seed для воспроизводимости результатов
tf.random.set_seed(1)

# Логарифмы вероятностей для каждой грани кубика
logits = tf.math.log([1.0/n_surfaces] * n_surfaces)

# Получение результатов бросков
toss_results = tf.random.categorical(logits[tf.newaxis, :], n_tosses)
toss_results = tf.squeeze(toss_results)  # Удаление лишних измерений

# Подсчет количества каждой из цифр
counts = tf.math.bincount(toss_results, minlength=n_surfaces)

# Расчет вероятностей для каждой из граней
probabilities = counts / n_tosses

print('Всего бросков:', n_tosses)
print('Вероятность каждой из 6 граней:', probabilities.numpy())
print('Теоретические (истинные) вероятности:', [1.0/n_surfaces] * n_surfaces)

Всего бросков: 2000

Вероятность каждой из 6 граней: [0.1655 0.1495 0.1645 0.166  0.1675 0.187 ]

Теоретические (истинные) вероятности: [0.16666666666666666, 0.16666666666666666, 0.16666666666666666, 0.16666666666666666, 0.16666666666666666, 0.16666666666666666]

import tensorflow as tf
import numpy as np

np.set_printoptions(suppress=True)  # Предотвращаем использование научной нотации для больших чисел

n_surfaces = 6  # Количество граней кубика
n_tosses = 2000 # Количество бросков

# Установка seed для воспроизводимости результатов
tf.random.set_seed(1)

# Логарифмы вероятностей для каждой грани кубика
logits = tf.math.log([1.0/n_surfaces] * n_surfaces)

# Получение результатов бросков
toss_results = tf.random.categorical(logits[tf.newaxis, :], n_tosses)
toss_results = tf.squeeze(toss_results)  # Удаление лишних измерений

# Инициализация записей результатов
record = tf.Variable(tf.zeros((n_surfaces, n_tosses), dtype=tf.float32))

# Подсчет и запись результатов для каждого броска
for i in range(n_tosses):
    # Подсчет количества каждой грани до текущего броска включительно
    counts = tf.math.bincount(toss_results[:i+1], minlength=n_surfaces, maxlength=n_surfaces)
    record[:, i].assign(tf.cast(counts, tf.float32))

# Нормализация результатов
x = tf.range(1, n_tosses + 1, dtype=tf.float32)
observations = record / x

# Вывод результатов
print("Результаты после первого броска:\n", observations[:, 0].numpy())
print("Результаты после первых 10 бросков:\n", observations[:, 10].numpy())
print("Результаты после первых 1000 бросков:\n", observations[:, 999].numpy())

Результаты после первого броска:

 [0. 1. 0. 0. 0. 0.]

Результаты после первых 10 бросков:

 [0.36363637 0.36363637 0.09090909 0.09090909 0.09090909 0.        ]

Результаты после первых 1000 бросков:

 [0.157 0.155 0.163 0.17  0.18  0.175]

import tensorflow as tf
from matplotlib import pyplot as plt
import numpy as np

np.set_printoptions(suppress=True)  # Предотвращаем использование научной нотации для больших чисел

n_surfaces = 6  # Количество граней кубика
n_tosses = 2000 # Количество бросков

# Установка seed для воспроизводимости результатов
tf.random.set_seed(1)

# Логарифмы вероятностей для каждой грани кубика
logits = tf.math.log([1.0/n_surfaces] * n_surfaces)

# Получение результатов бросков
toss_results = tf.random.categorical(logits[tf.newaxis, :], n_tosses)
toss_results = tf.squeeze(toss_results)  # Удаление лишних измерений

# Инициализация записей результатов
record = tf.Variable(tf.zeros((n_surfaces, n_tosses), dtype=tf.float32))

# Подсчет и запись результатов для каждого броска
for i in range(n_tosses):
    # Подсчет количества каждой грани до текущего броска включительно
    counts = tf.math.bincount(toss_results[:i+1], minlength=n_surfaces, maxlength=n_surfaces)
    record[:, i].assign(tf.cast(counts, tf.float32))

# Нормализация результатов
x = tf.range(1, n_tosses + 1, dtype=tf.float32)
observations = record / x

# Вывод результатов
print("Результаты после первого броска:\n", observations[:, 0].numpy())
print("Результаты после первых 10 бросков:\n", observations[:, 10].numpy())
print("Результаты после первых 1000 бросков:\n", observations[:, 999].numpy())

# Предполагаем, что observations - это тензор с результатами эксперимента
# Например, observations = tf.random.uniform([6, 1000], minval=0, maxval=1)

# Отрисовываем графики наблюдаемых вероятностей для каждой из граней кости
for i in range(6):
    plt.plot(observations[i].numpy(), label=f"Наблюдаемая вероятность P(грань={i+1})")

# Добавляем горизонтальную линию для теоретической вероятности
plt.axhline(y=0.166667, color='black', linestyle='dashed', label="Теоретическая вероятность 1/6")

# Добавляем легенду и отображаем график
plt.legend()
plt.show()

import numpy as np  # Импортируем библиотеку для работы с массивами
import matplotlib.pyplot as plt  # Импортируем библиотеку для визуализации данных
import random  # Импортируем модуль для генерации случайных чисел

na, nb, n = 0, 99, 100  # Задаем начальное и конечное значения диапазона и количество чисел

counts = np.zeros(n)  # Создаем массив для подсчета количества каждого сгенерированного числа

# Создаем фигуру для отображения гистограмм
fig, axes = plt.subplots(2, 3, figsize=(15, 8), sharex=True)
axes = axes.reshape(6)  # Преобразуем массив осей для удобства обращения

n_samples = 1000001  # Задаем количество выборок

# Генерируем случайные числа и подсчитываем их
for i in range(1, n_samples):
    counts[random.randint(na, nb)] += 1  # Увеличиваем счетчик для сгенерированного числа

    # Визуализируем распределение чисел на разных этапах генерации
    if i in [10, 100, 1000, 10000, 100000, 1000000]:
        axes[int(np.log10(i)) - 1].bar(np.arange(na + 1, nb + 2), counts)  # Строим гистограмму

plt.show()  # Отображаем гистограммы

import numpy as np
import matplotlib.pyplot as plt
from random import gauss

mu, sigma, n = 0., 0.1, 10  # Среднее значение (mu), стандартное отклонение (sigma) и количество генерируемых чисел (n)

# Генерация n случайных чисел по нормальному распределению
for i in range(n):
    print(f'{gauss(mu, sigma):.4f} ', end='')

# Определение переменной x
x = np.arange(-0.5, 0.5, 0.001)

# Определение функции Гаусса
def gf(mu, sigma, x):
    return 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)

# Визуализация функции плотности
plt.figure(figsize=(6, 4))
plt.plot(x, gf(mu, sigma, x), label="Гауссова функция")
plt.title("Функция плотности нормального распределения")
plt.xlabel("Значение")
plt.ylabel("Плотность вероятности")
plt.legend()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# Задаем параметры нормального распределения
mu, sigma = 0, 0.1  # среднее значение и стандартное отклонение

# Количество генерируемых случайных выборок
n = 500

# Генерация n случайных выборок из нормального распределения
samples = np.random.normal(mu, sigma, n)

# Гистограмма выборок
count, bins, ignored = plt.hist(samples, 80, density=True, alpha=0.6, color='g', label='Гистограмма выборок')

# Функция Гаусса для "истинного" распределения
def gf(mu, sigma, x):
    return 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)

# Отрисовка теоретической кривой нормального распределения
plt.plot(bins, gf(mu, sigma, bins), linewidth=2, color='r', label='Теоретическое распределение')

plt.title("Сравнение гистограммы выборок с теоретическим нормальным распределением")
plt.xlabel("Значение")
plt.ylabel("Плотность вероятности")
plt.legend()
plt.show()

H(p) = - Σ p_i log(p_i)

import numpy as np
import matplotlib.pyplot as plt

p = np.arange(0.01, 1.0, .01)  # 创建从 0.01 到 1、步长为 0.01 的概率数组
logp = -np.log(p)  # 计算数组中每个值的负对数

# 绘制负对数图像
plt.plot(p, logp, color='blue')
plt.xlabel('概率 p')
plt.ylabel('p 的负对数')
plt.title('概率负对数的数值')
plt.show()

import numpy as np

# 用于计算熵的函数
def calculate_entropy(probabilities):
    # 对概率向量的每个元素应用负对数，并求和
    entropy = -np.sum(probabilities * np.log(probabilities))
    return entropy

# 第一次观察的概率向量
q1 = np.array([0.5, 0.5])  # 两种结果的概率示例
# 第二次观察的概率向量
q2 = np.array([0.9, 0.1])  # 显示概率差异的示例

# 计算并输出每个概率向量的熵
entropy_q1 = calculate_entropy(q1)
entropy_q2 = calculate_entropy(q2)

print(f'q1 的熵: {entropy_q1:.4f}')
print(f'q2 的熵: {entropy_q2:.4f}')

q1 的熵: 0.6931
q2 的熵: 0.3251

import numpy as np

# 第一次观察的概率向量，具有较低不确定性：
# 因为变量被观察到的概率要么非常高，要么非常低，
# 所以对事件是否发生具有较强信心。
q1 = np.array([0.999, 0.001])

# 第二次观察的概率向量，具有较高不确定性：
# 因为变量被观察到的概率既不高也不低，
# 所以对事件是否发生缺乏信心。
q2 = np.array([0.5, 0.5])

# 计算并输出概率的负对数，展示其对不确定性的影响
print('q1=', q1, ' -log(q1)=', -np.log(q1))
print('q2=', q2, ' -log(q2)=', -np.log(q2))

# 将熵作为系统不确定性的度量进行计算
H_q1 = -np.dot(q1, np.log(q1)) / len(q1)  # q1 的熵
H_q2 = -np.dot(q2, np.log(q2)) / len(q2)  # q2 的熵
print('H_q1=', H_q1, 'H_q2=', H_q2)

q1= [0.999 0.001]  -log(q1)= [1.00050033e-03 6.90775528e+00]
q2= [0.5 0.5]  -log(q2)= [0.69314718 0.69314718]
H_q1= 0.003953627556116044 H_q2= 0.34657359027997264

import numpy as np
import matplotlib.pyplot as plt

# 变量可以取两个值的事件
v1 = np.arange(0.01, 1.0, .05)  # 从 0.01 到 1.0，以 0.05 为步长初始化 v1
gap = (v1[1] - v1[0]) * len(v1) / 3.  # 计算直方图柱之间的宽度
v1 /= (v1[0] + v1[-1])  # 对 v1 归一化，使概率和保持为 1

v2 = v1[::-1]  # 创建 v2，作为 v1 的镜像

# 输出 v1 和 v2 的数值用于检查
print(v1, np.sum(v1))
print(v2, np.sum(v2))

# 检查每一对 v1 和 v2 的和是否等于 1
print(v1 + v2, np.sum(v1 + v2) / 2)

# 用直方图可视化概率
xtick = range(len(v1))  # x 轴刻度
plt.bar(range(len(v1)), v1, width=gap * 1.2, alpha=.9, color='blue')  # v1 的直方图
plt.bar(range(len(v2)), v2, width=gap, alpha=.9, color='red')  # v2 的直方图
plt.xlabel('事件 ID，蓝色：v1，红色：v2')
plt.ylabel('概率')
plt.xticks(xtick)
plt.show()

H_qf = np.array([])  # 初始化事件 q1 的熵数组

# 对每一对概率计算熵
for q1 in list(zip(v1, v2)):
    H_qf = np.append(H_qf, -(np.dot(q1, np.log(q1))) / 2)  # 计算并追加熵

# 可视化熵的变化
plt.plot(v1, H_qf)
plt.xlabel('概率，v1（v2=1-v1）')
plt.ylabel('事件熵')
plt.title('事件熵')
plt.show()

[0.01030928 0.06185567 0.11340206 0.16494845 0.21649485 0.26804124
 0.31958763 0.37113402 0.42268041 0.4742268  0.5257732  0.57731959
 0.62886598 0.68041237 0.73195876 0.78350515 0.83505155 0.88659794
 0.93814433 0.98969072] 10.0

[0.98969072 0.93814433 0.88659794 0.83505155 0.78350515 0.73195876
 0.68041237 0.62886598 0.57731959 0.5257732  0.4742268  0.42268041
 0.37113402 0.31958763 0.26804124 0.21649485 0.16494845 0.11340206
 0.06185567 0.01030928] 9.999999999999998

[1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1.] 10.0

import matplotlib.pyplot as plt
import numpy as np

# 初始化变量
N = 0  # 当前变量可能取值的数量
max_v = 100  # 最大可能取值数量
Ni = np.array([])  # 用于保存变量数量的数组
H_qf = np.array([])  # 用于保存熵值的数组

# 为每个 N 生成均匀分布并计算熵
while N < max_v:
    N += 1  # 增加变量可能取值的数量
    Ni = np.append(Ni, N)  # 记录当前变量数量
    qf = np.ones(N) / N  # 生成均匀分布
    H_qf = np.append(H_qf, -np.dot(qf, np.log(qf)) / len(qf))  # 计算并记录熵

# 输出结果
print('概率分布:', qf[0:max_v:10])
print('H_qf=', H_qf[0:max_v:10])

# 可视化结果
plt.plot(Ni, H_qf)
plt.xlabel('变量数量，所有变量概率相同')
plt.ylabel('熵')
plt.title('均匀分布变量的事件')
plt.show()

概率分布: [0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01 0.01]
H_qf= [-0.          0.21799048  0.14497726  0.11077378  0.09057493  0.07709462
0.06739137  0.06003774  0.05425246  0.04956988]

import numpy as np

# 真实分布：用户画的是猫
true_distribution = np.array([1, 0, 0])  # 猫、树、汽车

# 预测分布：程序认为这最可能是猫
predicted_distribution = np.array([0.7, 0.2, 0.1])

# 计算交叉熵
cross_entropy = -np.sum(true_distribution * np.log(predicted_distribution))

print(f"交叉熵: {cross_entropy}")

交叉熵: 0.35667494393873245

H(p, q) = - Σ p_i log(q_i)

import numpy as np

# 两种结果的预测概率
q_good = np.array([0.9, 0.1])  # 两个取值的预测概率
y = np.array([0.99, 0.01])  # 两个取值的真实概率

p = y  # 真实分布
q = q_good  # 预测分布

# 输出 p 和 q，以及它们的对数
print('p=', p, ' log(p)=', -np.log(p))
print('q=', q, ' log(q)=', -np.log(q))

# 计算并输出 p 和 q 的熵
print(' 熵: Hp=', -np.dot(p, np.log(p)) / len(p),
      ' Hq=', -np.dot(q, np.log(q)) / len(q))

# 计算并输出交叉熵
print('\n交叉熵: Hpq=', -np.dot(p, np.log(q)) / len(p),
      ' Hqp=', -np.dot(q, np.log(p)) / len(q))

p= [0.99 0.01]  log(p)= [0.01005034 4.60517019]
q= [0.9 0.1]  log(q)= [0.10536052 2.30258509]
熵: Hp= 0.028000767177423672  Hq= 0.1625414866957241
交叉熵: Hpq= 0.06366638071559423  Hqp= 0.2347811604334802

import numpy as np

# 给出预测概率和真实概率
q_bad = np.array([0.1, 0.9])  # 预测
y = np.array([0.99, 0.01])  # 真实情况

# 计算交叉熵
cross_entropy = -np.dot(y, np.log(q_bad))

print(f"交叉熵: {cross_entropy}")

交叉熵: 2.2806128472206835

import numpy as np

# 两个取值的预测概率（较差预测）
q_bad = np.array([0.1, 0.9])
# 两个取值的真实概率
y = np.array([0.99, 0.01])
p = y  # 真实情况
q = q_bad  # 预测

# 输出真实概率和预测概率及其对数
print('p=', p, ' log(p)=', -np.log(p))
print('q=', q, ' log(q)=', -np.log(q))

# 计算真实分布和预测分布的熵
print(' 熵: Hp=', -np.dot(p, np.log(p)) / len(p),
      ' Hq=', -np.dot(q, np.log(q)) / len(p))

# 计算交叉熵
print('\n交叉熵: Hpq=', -np.dot(p, np.log(q)) / len(p),
      ' Hqp=', -np.dot(q, np.log(p)) / len(q))

p= [0.99 0.01]  log(p)= [0.01005034 4.60517019]
q= [0.1 0.9]  log(q)= [2.30258509 0.10536052]
熵: Hp= 0.028000767177423672  Hq= 0.1625414866957241
交叉熵: Hpq= 1.1403064236103417  Hqp= 2.072829100487316

import numpy as np

# 定义两个分布 P 和 Q
P = np.array([0.1, 0.2, 0.7])  # 分布 P
Q = np.array([0.1, 0.3, 0.6])  # 分布 Q

# 计算从 Q 到 P 的 KL 散度
KL_divergence = np.sum(P * np.log(P / Q))

# 输出结果
print(f"Kullback–Leibler 散度（从 Q 到 P）: {KL_divergence}")

Kullback–Leibler 散度（从 Q 到 P）: 0.026812454257447993

D_KL(p || q) = Σ p_i log(p_i / q_i)

D_KL(p || q) = H(p, q) - H(p)

D_KL(p || q) ≥ 0

p = q

import numpy as np

# 真实或参考分布
p = np.array([0.99, 0.01])  # 两个可能结果的概率

# 预测分布
q_good = np.array([0.9, 0.1])  # 较好的预测分布

# 计算两个分布中每个元素的负对数
log_p = -np.log(p)
log_q_good = -np.log(q_good)

# 输出真实分布和预测分布的数值
print(f'p={p}, log(p)={log_p}')
print(f'q={q_good}, log(q)={log_q_good}')

# 计算从 p 到 q 以及从 q 到 p 的 KL 散度
Dpq = np.sum(p * (log_p - log_q_good)) / len(p)
Dqp = np.sum(q_good * (log_q_good - log_p)) / len(p)

# 输出 KL 散度的数值
print(f'Dpq={Dpq}, Dqp={Dqp}')

# 输出：可以看到两个 KL 散度都很小，这表明预测 q 的质量较好。

p=[0.99 0.01], log(p)=[0.01005034 4.60517019]
q=[0.9 0.1], log(q)=[0.10536052 2.30258509]
Dpq=-0.035665613538170556, Dqp=-0.07223967373775611

import numpy as np

# 我们对硬币不同面朝上的频率所作的假设
# 真实概率：99% 为“正面”，1% 为“反面”
p = np.array([0.99, 0.01])

# 错误预测：10% 为“正面”，90% 为“反面”
q = np.array([0.1, 0.9])

# 计算并显示我们认为硬币各面朝上的频率
print('我们认为“正面”出现于', q[0] * 100, '% 的情况')
print('我们认为“反面”出现于', q[1] * 100, '% 的情况')

# 计算预测中的误差
# 假设“正面”出现频率与真实情况不符时的误差
Dpq = np.sum(p * (np.log(p) - np.log(q)))

# 假设“反面”出现频率与真实情况不符时的误差
Dqp = np.sum(q * (np.log(q) - np.log(p)))

# 显示错误有多大
print('当我们认为“正面”出现得更多时的误差:', Dpq)
print('当我们认为“反面”出现得更多时的误差:', Dqp)

我们认为“正面”出现于 10.0 % 的情况

我们认为“反面”出现于 90.0 % 的情况

当我们认为“正面”出现得更多时的误差: 2.224611312865836

当我们认为“反面”出现得更多时的误差: 3.8205752275831846

import numpy as np

# 较差预测
p = np.array([0.99, 0.01])  # 真实分布
q = np.array([0.1, 0.9])    # 预测分布

# 输出分布及其负对数
print('p=', p, ' log(p)=', -np.log(p))
print('q=', q, ' log(q)=', -np.log(q))

# 计算从 p 到 q 以及从 q 到 p 的 KL 散度
Dpq = np.dot(p, (np.log(p) - np.log(q))) / len(p)
Dqp = np.dot(q, (np.log(q) - np.log(p))) / len(p)

# 输出 KL 散度的数值
print('从 p 到 q 的 KL 散度 (Dpq)=', Dpq)
print('从 q 到 p 的 KL 散度 (Dqp)=', Dqp)

p= [0.99 0.01]  log(p)= [0.01005034 4.60517019]
q= [0.1 0.9]  log(q)= [2.30258509 0.10536052]

从 p 到 q 的 KL 散度 (Dpq)= 1.112305656432918

从 q 到 p 的 KL 散度 (Dqp)= 1.910287613791592

import numpy as np


def binary_cross_entropy(true_labels, predicted_probs):
    """
    计算真实标签与预测概率之间的二元交叉熵。

    参数：
    true_labels (numpy array): 真实标签数组（0 或 1）。
    predicted_probs (numpy array): 属于类别 1 的预测概率数组。

    返回：
    float: 二元交叉熵的值。
    """

    # 为防止对零取对数而加入的最小值
    epsilon = 1e-15

    # 修正预测概率，避免对数计算错误
    predicted_probs = np.clip(predicted_probs, epsilon, 1 - epsilon)

    # 计算二元交叉熵
    bce = -np.mean(
        true_labels * np.log(predicted_probs)
        + (1 - true_labels) * np.log(1 - predicted_probs)
    )

    return bce


# 使用示例
true_labels = np.array([1, 0, 1, 1, 0])  # 真实标签（1 - 狗，0 - 猫）
predicted_probs = np.array([0.9, 0.2, 0.8, 0.95, 0.1])  # 图像中是狗的预测概率

bce = binary_cross_entropy(true_labels, predicted_probs)
print(f"二元交叉熵: {bce}")

二元交叉熵: 0.14166028566632455

import numpy as np

# 真实概率分布
p = np.array([1.0, 0.0, 0.0, 0.0])  # 真实值

# 预测概率分布
q = np.array([0.9, 0.04, 0.03, 0.03])  # 预测值

# 真实分布和预测分布的反向概率
p_conv = 1.0 - p  # 真实值的反面
q_conv = 1.0 - q  # 预测值的反面

# 输出真实概率、预测概率及其反向值
print(p, q, ' 反向值:', p_conv, q_conv)

# 计算交叉熵
cHpq = -np.sum(np.dot(p, np.log(q))) / len(p)

# 计算二元交叉熵
bcHpq = -np.sum(np.dot(p, np.log(q)) + np.dot(p_conv, np.log(q_conv))) / len(p)

# 输出交叉熵和二元交叉熵的值
print('交叉熵 cHpq:', cHpq)
print('二元交叉熵 bcHpq:', bcHpq)

[1. 0. 0. 0.] [0.9  0.04 0.03 0.03]  反向值: [0. 1. 1. 1.] [0.1  0.96 0.97 0.97]
交叉熵 cHpq: 0.02634012891445657
二元交叉熵 bcHpq: 0.05177523128687465

import numpy as np

# 初始化较差的预测和真实分布
q = np.array([0.4, 0.2, 0.3, 0.1])  # 预测
p = np.array([1.0, 0.0, 0.0, 0.0])  # 真实分布

# 计算预测分布和真实分布的反向值
p_conv = 1.0 - p  # 真实分布的反面
q_conv = 1.0 - q  # 预测分布的反面

# 输出真实分布、预测分布及其反向值
print(f"真实: {p}, 预测: {q}, 真实反向: {p_conv}, 预测反向: {q_conv}")

# 计算交叉熵
cHpq = -np.sum(p * np.log(q)) / len(p)

# 计算二元交叉熵
bcHpq = -np.sum(p * np.log(q) + p_conv * np.log(q_conv)) / len(p)

# 输出结果
print(f"交叉熵 cHpq: {cHpq}")
print(f"二元交叉熵 bcHpq: {bcHpq}")

真实: [1. 0. 0. 0.], 预测: [0.4 0.2 0.3 0.1], 真实反向: [0. 1. 1. 1.], 预测反向: [0.6 0.8 0.7 0.9]
交叉熵 cHpq: 0.22907268296853875
二元交叉熵 bcHpq: 0.4003674356962309

import numpy as np

# 预测分布
q = np.array([0.4, 0.2, 0.3, 0.1])  # 预测
# 真实分布
p = np.array([0.3, 0.3, 0.2, 0.2])  # 真实值，较均匀的分布

# 计算用于二元交叉熵的预测和真实反向值
p_conv = 1.0 - p  # 真实值的反面
q_conv = 1.0 - q  # 预测值的反面

# 输出真实分布、预测分布及其反向值
print("真实:", p, "预测:", q, ' 反向值: 真实:', p_conv, '预测:', q_conv)

# 计算普通交叉熵
cHpq = -np.sum(p * np.log(q)) / len(p)

# 计算二元交叉熵
bcHpq = -np.sum(p * np.log(q) + p_conv * np.log(q_conv)) / len(p)

# 输出交叉熵结果
print('交叉熵 cHpq:', cHpq)
print('二元交叉熵 bcHpq:', bcHpq)

真实: [0.3 0.3 0.2 0.2] 预测: [0.4 0.2 0.3 0.1]  反向值: 真实: [0.7 0.7 0.8 0.8] 预测: [0.6 0.8 0.7 0.9]
交叉熵 cHpq: 0.36475754318911824
二元交叉熵 bcHpq: 0.585609240747465

import numpy as np

# 预测分布
q = np.array([0.4, 0.2, 0.3, 0.1])  # 预测
# 真实分布
p = np.array([0.3, 0.3, 0.2, 0.2])  # 真实值，较均匀的分布

# 计算预测和真实分布的反向值
p_conv = 1.0 - p  # 真实值的反面
q_conv = 1.0 - q  # 预测值的反面

# 输出数值以便观察
print("真实:", p, "预测:", q, ' 反向值:', p_conv, q_conv)

# 计算交叉熵
cHpq = -np.sum(p * np.log(q)) / len(p)
# 计算二元交叉熵
bcHpq = -np.sum(p * np.log(q) + p_conv * np.log(q_conv)) / len(p)

# 输出结果
print('交叉熵 cHpq:', cHpq)
print('二元交叉熵 bcHpq:', bcHpq)

交叉熵 cHpq: 0.36475754318911824
二元交叉熵 bcHpq: 0.585609240747465

import random

# 每种颜色糖果的初始数量
red = 50
blue = 50

# 模拟选择糖果的函数
def choose_candy():
    global red, blue
    if random.random() < red / (red + blue):
        red -= 1
        return 'red'
    else:
        blue -= 1
        return 'blue'

# 模拟选择 10 颗糖果
for _ in range(10):
    print(choose_candy())

# 查看剩余糖果数量如何变化
print(f"剩余红色糖果数量: {red}")
print(f"剩余蓝色糖果数量: {blue}")

# 初始化概率
p_A = 0.3          # 事件 A 的概率
p_B_given_A = 0.6  # 在 A 发生条件下 B 发生的概率
p_B = 0.2          # 事件 B 的概率

# 根据贝叶斯定理计算在 B 发生条件下 A 发生的条件概率
p_A_given_B = (p_B_given_A * p_A) / p_B

# 输出结果
print(f"在 B 条件下 A 的条件概率: {p_A_given_B:.2f}")

在 B 条件下 A 的条件概率: 0.90

pip install scikit-learn

from sklearn.model_selection import train_test_split：scikit-learn 中用于将数据集划分为训练集和测试集的函数。它可以在模型未见过的数据上评估模型性能，从而检验模型的泛化能力。

from sklearn.feature_extraction.text import CountVectorizer：用于将文本数据转换为数值形式，生成所谓的“词袋”（bag of words）。它统计训练集中每个词在每篇文档中的出现次数，并把文本转换为可用于机器学习的特征向量。

from sklearn.naive_bayes import MultinomialNB：用于多项式特征的朴素贝叶斯算法，经常用于文本分类。该算法基于贝叶斯定理，并假设每个类别内部的特征彼此独立。它非常适合处理经过 CountVectorizer 转换后的向量化文本数据。

from sklearn.metrics import accuracy_score：用于评估机器学习模型质量的函数。accuracy_score 计算分类准确率，即正确预测的标签数在全部预测中的比例。准确率是最简单且最常用的分类模型性能指标之一。

# 导入必要的库
from sklearn.model_selection import train_test_split      # 用于将数据划分为训练集和测试集
from sklearn.feature_extraction.text import CountVectorizer  # 用于通过向量化把文本转换为数值形式
from sklearn.naive_bayes import MultinomialNB             # 用于创建和使用朴素贝叶斯分类器
from sklearn.metrics import accuracy_score                # 用于计算模型预测准确率

# 文本消息示例及其对应标签（1 表示垃圾邮件，0 表示非垃圾邮件）
messages = [
    "бесплатные билеты отправьте СМС",
    "встретимся на обеде",
    "специальное предложение купите сейчас",
    "привет как дела",
    "не упустите шанс получить скидку"
]
labels = [1, 0, 1, 0, 1]

# 将数据划分为训练集和测试集
messages_train, messages_test, labels_train, labels_test = train_test_split(
    messages, labels, test_size=0.4, random_state=42
)

# 文本数据向量化
vectorizer = CountVectorizer()
messages_train_vectorized = vectorizer.fit_transform(messages_train)
messages_test_vectorized = vectorizer.transform(messages_test)

# 训练朴素贝叶斯分类器
classifier = MultinomialNB()
classifier.fit(messages_train_vectorized, labels_train)

# 在测试数据上进行预测
predictions = classifier.predict(messages_test_vectorized)

# 评估模型准确率
accuracy = accuracy_score(labels_test, predictions)
print(f"模型准确率: {accuracy}")

模型准确率: 0.5

1. 打开 Finder，进入 Python 安装目录。如果你从 python.org 安装 Python，它可能位于类似 /Applications/Python 3.x 的目录中，其中 3.x 对应你安装的 Python 版本。

2. 在 Python 目录中找到名为 InstallCertificates.command 的文件。

3. 双击 InstallCertificates.command 文件运行脚本。这会打开终端窗口并为 Python 环境安装必要的 SSL 证书。

pip install certifi

1. 以管理员身份打开命令提示符（Command Prompt）或 PowerShell。可以点击“开始”，输入 “cmd” 或 “PowerShell”，然后右键相应程序并选择“以管理员身份运行”。

2. 找到 Python 安装目录。如果你从 python.org 官方网站安装 Python，目录通常类似：C:\Users\你的用户名\AppData\Local\Programs\Python\Python3X，其中 Python3X 是你安装的 Python 版本。如果不确定安装位置，可在命令行中执行 where python 查找。

3. 使用 cd 命令进入 Python 安装目录，例如：
   cd C:\Users\你的用户名\AppData\Local\Programs\Python\Python3X

4. 在该目录中运行证书安装或更新命令：
   .\Scripts\pip.exe install --upgrade certifi
   该命令会安装或更新 certifi 包，其中包含一组根证书。

5. 安装或更新 certifi 后，再次执行你的代码。

1. 打开终端。可以按 Ctrl + Alt + T。

2. 更新软件包列表并安装系统更新，确保系统包处于最新状态：

sudo apt update
sudo apt upgrade

3. 安装 ca-certificates 与 openssl 包（如果尚未安装）：

sudo apt install ca-certificates openssl

4. 如果使用通过 apt 包管理器安装的 Python，证书通常已经配置好。如果 Python 通过其他方式安装，可能需要手动安装证书。

5. 若要为 Python 环境安装或更新证书，可执行：

sudo /usr/local/bin/python3 -m pip install --upgrade certifi

pip install --upgrade certifi

import tensorflow as tf
import numpy as np

# 使用 TensorFlow 加载 MNIST 数据
mnist = tf.keras.datasets.mnist
(training_images, training_labels), _ = mnist.load_data()

# 图像归一化
training_images = training_images / 255.0

# 初始化概率计数器
num_labels = 10          # 标签数量（0 到 9）
pixel_count = 28 * 28    # MNIST 图像尺寸 28x28
p_y = np.zeros(num_labels)                    # 每个数字的概率
p_xi_given_y = np.zeros((num_labels, pixel_count))  # 每个数字下每个像素的概率

# 计数以估计概率
for label in training_labels:
    p_y[label] += 1

for i, image in enumerate(training_images):
    label = training_labels[i]
    # 将图像转换为二值向量
    binary_image = np.round(image).flatten()
    p_xi_given_y[label] += binary_image

# 归一化得到概率
p_y /= len(training_labels)
p_xi_given_y /= np.sum(p_xi_given_y, axis=1, keepdims=True)

# 在取对数前为概率添加小常数 epsilon
epsilon = 1e-9
p_y += epsilon
p_xi_given_y += epsilon

# 对新图像进行分类的函数
def classify(image):
    binary_image = np.round(image).flatten()
    # 计算给定图像下每个数字的对数概率
    log_prob_y = np.log(p_y) + np.dot(binary_image, np.log(p_xi_given_y.T))
    # 返回概率最大的数字
    return np.argmax(log_prob_y)

# 用一张图像测试分类器
test_image = training_images[0]
predicted_digit = classify(test_image)
print("预测数字:", predicted_digit)

预测数字: 5

# 导入必要的库
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

# 使用 TensorFlow Keras 加载 MNIST 数据集
(mnist_train_images, mnist_train_labels), (mnist_test_images, mnist_test_labels) = tf.keras.datasets.mnist.load_data()

# 图像转换函数
def transform(images, labels):
    # 数据转换：当像素值 >= 128 时认为像素“开启”
    transformed_images = np.floor(images / 128).astype(np.float32)
    return transformed_images, labels.astype(np.float32)

# 转换训练集和测试集
train_images, train_labels = transform(mnist_train_images, mnist_train_labels)
test_images, test_labels = transform(mnist_test_images, mnist_test_labels)

# 显示数据集中的一个图像示例
image_index = 8888
plt.imshow(train_images[image_index], cmap='Greys')
plt.title(f'Label: {train_labels[image_index]}')
plt.show()

# 初始化用于统计概率的数组
ycount = np.ones(10)        # 对应 10 个数字
xcount = np.ones((784, 10)) # 对应每个数字的 784 个像素

# 处理训练数据集
for image, label in zip(train_images, train_labels):
    x = image.reshape((784,))
    y = int(label)
    ycount[y] += 1
    xcount[:, y] += x

# 计算概率 p(xi|y)
for i in range(10):
    xcount[:, i] = xcount[:, i] / ycount[i]

# 计算 p(y)
py = ycount / np.sum(ycount)

# 显示“训练后”的模型
fig, figarr = plt.subplots(1, 10, figsize=(15, 15))

for i in range(10):
    figarr[i].imshow(xcount[:, i].reshape((28, 28)), cmap='hot')
    figarr[i].axes.get_xaxis().set_visible(False)
    figarr[i].axes.get_yaxis().set_visible(False)

plt.show()

# 输出每个数字的概率
print(py)

[0.09871688 0.11236461 0.09930012 0.10218297 0.09736711 0.09035161
 0.09863356 0.10441593 0.09751708 0.09915014]

# 导入用于数据处理和可视化的必要库
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

# 加载 MNIST 数据集，其中包含用于训练机器学习模型的手写数字
(mnist_train_images, mnist_train_labels), (mnist_test_images, mnist_test_labels) = tf.keras.datasets.mnist.load_data()

# 图像预处理函数
def transform(images, labels):
    """
    将原始图像转换为二值图像（0 或 1）。

    如果像素值 >= 128，则认为像素为“开启”（1）；否则为“关闭”（0）。
    输入图像和标签，返回转换后的图像和标签。
    """
    transformed_images = np.floor(images / 128).astype(np.float32)
    return transformed_images, labels.astype(np.float32)

# 对训练集和测试集应用转换函数
train_images, train_labels = transform(mnist_train_images, mnist_train_labels)
test_images, test_labels = transform(mnist_test_images, mnist_test_labels)

# 可视化转换后的一个图像示例
image_index = 8888
plt.imshow(train_images[image_index], cmap='Greys')
plt.title(f'标签: {int(train_labels[image_index])}')
plt.show()

# 初始化用于统计概率的数组
ycount = np.ones(10)        # 初始值 1 可避免除零（拉普拉斯平滑）
xcount = np.ones((784, 10)) # 同样用于避免除零

# 处理训练集以训练朴素贝叶斯分类器
for image, label in zip(train_images, train_labels):
    x = image.reshape((784,))
    y = int(label)
    ycount[y] += 1
    xcount[:, y] += x

# 归一化得到概率 p(xi|y)
for i in range(10):
    xcount[:, i] /= ycount[i]

# 计算每个数字的先验概率 p(y)
py = ycount / np.sum(ycount)

# 可视化“训练后”的模型：显示每个数字下每个像素“开启”的概率
fig, figarr = plt.subplots(1, 10, figsize=(15, 15))

for i in range(10):
    figarr[i].imshow(xcount[:, i].reshape((28, 28)), cmap='hot')
    figarr[i].axis('off')

plt.show()

# 在测试图像上计算并可视化每个数字的概率
logxcount = np.log(xcount)
logxcountneg = np.log(1 - xcount)
logpy = np.log(py)

fig, figarr = plt.subplots(2, 10, figsize=(15, 3))

ctr = 0
y_true = []
pxm = np.array([])
xi_pred = []

# 在测试图像上评估模型
for image, label in zip(test_images, test_labels):
    x = image.reshape((784,))
    y_true.append(int(label))
    logpx = logpy.copy()

    for i in range(10):
        # 计算联合概率 P(x|y)P(y) 的对数
        logpx[i] += np.dot(logxcount[:, i], x) + np.dot(logxcountneg[:, i], 1 - x)

    logpx -= np.max(logpx)  # 归一化以防止数值溢出
    px = np.exp(logpx)
    px *= py
    px /= np.sum(px)

    pxm = np.append(pxm, np.max(px))
    xi_pred.append(np.argmax(px))

    figarr[1, ctr].bar(range(10), px, color='blue')
    figarr[1, ctr].axis('off')
    figarr[0, ctr].imshow(x.reshape((28, 28)), cmap='hot')
    figarr[0, ctr].axis('off')

    ctr += 1
    if ctr == 10:
        break

plt.show()

# 输出分类结果
y_true = np.array(y_true)
xi_pred = np.array(xi_pred)
print('真实标签: ', y_true)
print('预测数字:', xi_pred)
print('是否正确?', np.equal(y_true, xi_pred))
print('最大概率:', pxm)

真实标签:  [7 2 1 0 4 1 4 9 5 9]
预测数字: [7 2 1 0 4 1 4 9 4 9]
是否正确? [ True  True  True  True  True  True  True  True False  True]
最大概率: [1.         1.         1.         1.         1.         1.
 0.99999999 0.9999996  0.99999758 0.99999899]