Dự đoán những điều không thể đoán trước 🔮. Sự kỳ diệu của mạng mật độ hỗn hợp… | của Miguel Dias, Tiến sĩ | Tháng 5 năm 2024

MDN lấy mạng thần kinh cũ nhàm chán của bạn và biến nó thành một cỗ máy dự đoán mạnh mẽ. Tại sao phải chấp nhận một dự đoán khi bạn có thể có cả một loạt các kết quả tiềm năng?

Ý tưởng cốt lõi

Trong MDN, mật độ xác suất của biến mục tiêu t đưa ra đầu vào x được biểu diễn dưới dạng tổ hợp tuyến tính của các hàm hạt nhân, điển hình là các hàm Gaussian, mặc dù không giới hạn. Trong toán học nói:

Ở đâu 𝛼ᵢ(x) các hệ số trộn là gì và ai lại không thích một sự kết hợp tốt, phải không? 🎛️ Những điều này quyết định số tiền cân nặng mỗi thành phần 𝜙ᵢ(t|x) — mỗi Gaussian trong trường hợp của chúng ta – đều có trong mô hình.

Nấu bia Gaussian ☕

Mỗi thành phần Gaussian 𝜙ᵢ(t|x) có ý nghĩa riêng của nó 𝜇ᵢ(x) và phương sai 𝜎ᵢ².

Trộn nó lên 🎧 với các hệ số

Các hệ số trộn 𝛼ᵢ rất quan trọng vì chúng cân bằng ảnh hưởng của từng thành phần Gaussian, được điều chỉnh bởi một softmax để đảm bảo chúng có tổng bằng 1:

Thông Số Ma Thuật ✨ Phương tiện & Phương sai

Nghĩa là 𝜇ᵢ và phương sai 𝜎ᵢ² xác định từng Gaussian. Và đoán xem? Phương sai phải dương! Chúng tôi đạt được điều này bằng cách sử dụng hàm mũ của kết quả đầu ra mạng:

Được rồi, vậy chúng ta huấn luyện con thú này như thế nào? Chà, tất cả đều nhằm tối đa hóa khả năng dữ liệu được quan sát của chúng tôi. Những thuật ngữ ưa thích, tôi biết. Chúng ta hãy xem nó trong hành động.

Phép thuật khả năng đăng nhập ✨

Khả năng xảy ra của dữ liệu của chúng tôi theo mô hình MDN là tích của các xác suất được gán cho từng điểm dữ liệu. Trong toán học nói:

Điều này về cơ bản nói, “Này, khả năng chúng ta có được dữ liệu này dựa trên mô hình của chúng ta là gì?”. Nhưng tích số có thể trở nên lộn xộn, vì vậy chúng ta lấy nhật ký (vì toán học yêu thích nhật ký), biến kết quả của chúng ta thành tổng:

Bây giờ, mấu chốt là: chúng tôi thực sự muốn giảm thiểu khả năng xảy ra nhật ký tiêu cực vì các thuật toán tối ưu hóa của chúng tôi muốn giảm thiểu mọi thứ. Vì vậy, việc áp dụng định nghĩa của p(t|x)hàm lỗi mà chúng tôi thực sự giảm thiểu là:

Công thức này có thể trông đáng sợ, nhưng nó chỉ nói lên rằng chúng ta cộng các xác suất ghi nhật ký trên tất cả các điểm dữ liệu, sau đó đưa vào một dấu âm vì việc giảm thiểu là điểm yếu của chúng ta.

Bây giờ đây là cách dịch thuật sĩ của chúng tôi sang Python và bạn có thể tìm thấy mã đầy đủ đây:

Hàm mất mát

def mdn_loss(alpha, sigma, mu, goal, eps=1e-8):
goal = goal.unsqueeze(1).expand_as(mu)
m = torch.distributions.Regular(loc=mu, scale=sigma)
log_prob = m.log_prob(goal)
log_prob = log_prob.sum(dim=2)
log_alpha = torch.log(alpha + eps)  # Keep away from log(0) catastrophe
loss = -torch.logsumexp(log_alpha + log_prob, dim=1)
return loss.imply()

Đây là sự cố:

1. goal = goal.unsqueeze(1).expand_as(mu): Mở rộng mục tiêu để phù hợp với hình dạng của mu.
2. m = torch.distributions.Regular(loc=mu, scale=sigma): Tạo phân phối chuẩn.
3. log_prob = m.log_prob(goal): Tính xác suất log.
4. log_prob = log_prob.sum(dim=2): Nhật ký tổng xác suất.
5. log_alpha = torch.log(alpha + eps): Tính log các hệ số trộn.
6. loss = -torch.logsumexp(log_alpha + log_prob, dim=1): Kết hợp và log-sum-exp các xác suất.
7. return loss.imply(): Trả về tổn thất trung bình.

Mạng lưới thần kinh

Hãy tạo một mạng lưới thần kinh đã được thiết lập để xử lý thuật sĩ:

class MDN(nn.Module):
def __init__(self, input_dim, output_dim, num_hidden, num_mixtures):
tremendous(MDN, self).__init__()
self.hidden = nn.Sequential(
nn.Linear(input_dim, num_hidden),
nn.Tanh(),
nn.Linear(num_hidden, num_hidden),
nn.Tanh(),
)
self.z_alpha = nn.Linear(num_hidden, num_mixtures)
self.z_sigma = nn.Linear(num_hidden, num_mixtures * output_dim)
self.z_mu = nn.Linear(num_hidden, num_mixtures * output_dim)
self.num_mixtures = num_mixtures
self.output_dim = output_dim
def ahead(self, x):
hidden = self.hidden(x)
alpha = F.softmax(self.z_alpha(hidden), dim=-1)
sigma = torch.exp(self.z_sigma(hidden)).view(-1, self.num_mixtures, self.output_dim)
mu = self.z_mu(hidden).view(-1, self.num_mixtures, self.output_dim)
return alpha, sigma, mu

Chú ý softmax đang được áp dụng cho 𝛼ᵢ alpha = F.softmax(self.z_alpha(hidden), dim=-1)do đó chúng có tổng bằng 1, và hàm mũ là 𝜎ᵢ sigma = torch.exp(self.z_sigma(hidden)).view(-1, self.num_mixtures, self.output_dim)để đảm bảo chúng vẫn dương, như đã giải thích trước đó.

Dự đoán

Việc lấy dự đoán từ MDN là một điều khó khăn. Đây là cách bạn lấy mẫu từ mô hình hỗn hợp:

def get_sample_preds(alpha, sigma, mu, samples=10):
N, Okay, T = mu.form
sampled_preds = torch.zeros(N, samples, T)
uniform_samples = torch.rand(N, samples)
cum_alpha = alpha.cumsum(dim=1)
for i, j in itertools.product(vary(N), vary(samples)):
u = uniform_samples(i, j)
okay = torch.searchsorted(cum_alpha(i), u).merchandise()
sampled_preds(i, j) = torch.regular(mu(i, okay), sigma(i, okay))
return sampled_preds

Đây là sự cố:

1. N, Okay, T = mu.form: Lấy số lượng điểm dữ liệu, thành phần hỗn hợp và kích thước đầu ra.
2. sampled_preds = torch.zeros(N, samples, T): Khởi tạo tensor để lưu trữ các dự đoán được lấy mẫu.
3. uniform_samples = torch.rand(N, samples): Tạo số ngẫu nhiên thống nhất để lấy mẫu.
4. cum_alpha = alpha.cumsum(dim=1): Tính tổng tích lũy của các khối lượng hỗn hợp.
5. for i, j in itertools.product(vary(N), vary(samples)): Lặp lại từng tổ hợp điểm dữ liệu và mẫu.
6. u = uniform_samples(i, j): Lấy số ngẫu nhiên cho mẫu hiện tại.
7. okay = torch.searchsorted(cum_alpha(i), u).merchandise(): Tìm chỉ số thành phần hỗn hợp.
8. sampled_preds(i, j) = torch.regular(mu(i, okay), sigma(i, okay)): Mẫu từ thành phần Gaussian đã chọn.
9. return sampled_preds: Trả về tensor của các dự đoán được lấy mẫu.

Hãy áp dụng MDN để dự đoán ‘Nhiệt độ biểu kiến’ sử dụng một cách đơn giản Bộ dữ liệu thời tiết. Tôi đã đào tạo một MDN với mạng 50 lớp ẩn và đoán xem sao? Nó đá! 🎸

Tìm mã đầy đủ đây. Dưới đây là một số kết quả: