Wie codiere ich ein neuronales Netzwerk, das eine Mischung aus Gaußschen unter Verwendung der isotropen Diffusion aus pr ⇐ Python

[Anonymous]

Ich versuche, ein neuronales Netzwerk zu codieren, das aus µ = p · n ((1 -p) a; in) + (1 - p) · n (–pa; in) unter Verwendung der isotropen Diffusion (y_t = t*x + w_t, mit (w_t) _t brauner Bewegung, verwenden. Ein differentes Modell
für die posterioren Erwartung m (y; t) und meldet das Histogramm von ⟨XT, A⟩ /∥A∥2
2, das durch 1000
unabhängige Läufe des Erzeugungsprozesses erhalten wurde. /> 2 unter x∼ & mgr; ◦LIN1 (x))
x2 ← Abflach (s⊗x1)
xout ← cos (α) x+ lin2 (x2) ∈Rn
return xout < /p>
Wir codieren T in der Winkelvariable α = Arctan (1 /√t). Parameter, bei denen wie folgt ausgewählt wird: n = 5.000, 500 Epochen, L = 3, M = 256; < /p>
Wir verwendeten stochastische Gradientenabstieg mit Stapelgröße 50 über eine Anzahl von Epochen und Proben, die abhängig von der Reihe der Abbildungen 1, 2, eine feste Anzahl von Proben, die eine fixierte Anzahl von Proben, auf deren Stamme-Aufstiegsanlagen abhängt. Bei jeder SGD -Probe. Bei
Trainingszeit probieren wir T = tan (α) –2 mit α∼unif ([0, π /2]) ab. Zum Zeitpunkt der Erzeugung verwenden wir eine Euler
-Diskretisierung mit käqui-aga-Werten von α, k ∈ {200.400} und überprüfen Sie, dass die Ergebnisse unempfindlich sind
dem Wert von k.

Code: Select all

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
from torch.utils.data import DataLoader, TensorDataset
import matplotlib.pyplot as plt
from scipy.stats import multivariate_normal

def density_function(x):
pdf1 = multivariate_normal.pdf(x, mu1, cov)
pdf2 = multivariate_normal.pdf(x, mu2, cov)
return p * pdf1 + (1 - p) * pdf2

class NN1(nn.Module):
def __init__(self, n, m, L):
super(NN1, self).__init__()
self.L0 = nn.Linear(40, L)
self.L1 = nn.Sequential(nn.Linear(n, m), nn.ReLU())
self.L2 = nn.Linear(m * L, n)

def forward(self, x, alpha):
phi = torch.zeros(40, device=x.device)
for i in range(40):
if i % 2 == 0:
phi[i] = torch.cos(alpha * i)
else:
phi[i] = torch.sin(alpha * i)
s = self.L0(phi)
x_1 = self.L1(x)
kron_list = []
for i in range(x_1.size(0)):
kron_prod = torch.kron(s, x_1[i]).flatten()
kron_list.append(kron_prod)
x_2 = torch.stack(kron_list)  # shape: (batch_size, L*m)
x_out = torch.cos(alpha) * x + self.L2(x_2)  # shape: (batch_size, n)
return x_out

def sample_from_mu(N, p, mu1, mu2, cov, n):
samples = torch.empty((N, n))
for i in range(N):
x = np.random.rand()
if x < p:
sample = np.random.multivariate_normal(mu1, cov)
else:
sample = np.random.multivariate_normal(mu2, cov)
samples[i] = torch.from_numpy(sample).float()
return samples

# Numbers for Figure 1
n = 128
a = np.ones(n)
p = 0.7
mu1 = (1 - p) * a
mu2 = -p * a
cov = np.eye(n)
N = 5000
m = 256
L = 3
epochs = 500
batch_size = 50

x_train = sample_from_mu(N, p, mu1, mu2, cov, n)
train_dataset = TensorDataset(x_train)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)

loss_fn = nn.MSELoss()
model = NN1(n, m, L)
optimizer = optim.SGD(model.parameters(), lr=0.1)

losses = []
for epoch in range(epochs):
for batch in train_loader:
x_batch = batch[0]
alpha = torch.empty(1).uniform_(0, torch.pi/2)
t = 1 / (torch.tan(alpha) ** 2)
W_t = torch.randn(x_batch.size(0), n) * torch.sqrt(t)
Y = t * x_batch + W_t
y_pred = model(Y, alpha)
loss = loss_fn(y_pred, x_batch)
losses.append(loss.item())
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
optimizer.step()

# Now use the trained NN to predict Xt
t1 = torch.tensor(0.21)
alpha_1 = torch.atan(1 / torch.sqrt(t1))

x_samples = sample_from_mu(1000, p, mu1, mu2, cov, n)
a_tensor = torch.ones(n, dtype=torch.float32)

X_hat = []
for i in range(1000):
W_1 = torch.randn(n) * torch.sqrt(t1)
Y_sample = t1 * x_samples[i] + W_1
x_pred = model(Y_sample.unsqueeze(0), alpha_1)
projection = (x_pred.squeeze(0) @ a_tensor) / n
X_hat.append(projection.item())
< /code>
Ich habe auch versucht, mein Training mit: < /p>
zu ändernfor epoch in range(epochs):
for batch in train_loader:
x_batch = batch[0]  # shape: (batch_size, n)
# Sample a separate alpha for each sample in the batch.
alpha = torch.empty(x_batch.size(0)).uniform_(0, torch.pi/2)
t = 1 / (torch.tan(alpha) ** 2)
W_t = torch.randn(x_batch.size(0), n) * torch.sqrt(t).unsqueeze(1)
Y = t.unsqueeze(1) * x_batch + W_t
y_pred = model(Y, alpha)
loss = loss_fn(y_pred, x_batch)
losses.append(loss.item())
optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
optimizer.step()

, um mehr andere Zeit zu bekommen, aber es funktioniert immer noch nicht. Ich habe meine Verlustfunktion gedruckt und sie konvergiert nicht. Ich habe auch viele verschiedene Lernrate ausprobiert, aber es funktioniert einfach nicht.
Hat jemand eine Idee?
Danke!