Public/Chess_Probabilistic_Programming
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove pre-py38 type annotations

Browse Source
This commit is contained in:
Stefan Steininger
2024-01-31 11:47:40 +01:00
parent 2e3fdb62e9
commit a5393d793e
1 changed files with 24 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
chesspp/util_gaussian.py
View File

@@ -1,24 +1,27 @@
import math
from typing import Tuple, Dict
from functools import cache
import torch
import torch.distributions as dist
from torch import exp
F1: Dict[float, float] = {}
F2: Dict[float, float] = {}
CDF: Dict[float, float] = {}
lookup_count = 0
total_count = 0
calculation_count = 0
def get_lookup_count():
global lookup_count
return lookup_count
global total_count, calculation_count
return total_count - calculation_count
@cache
def calc_cdf(alpha: float) -> Tuple[float, float, float]:
def calc_cdf(alpha: float) -> tuple[float, float, float]:
"""
Returns the calculated CDF and parameters f1,f2 from the input alpha
"""
global calculation_count
calculation_count += 1
normal = dist.Normal(0, 1)
cdf_alpha = normal.cdf(torch.tensor(alpha)).item()
pdf_alpha = exp(normal.log_prob(torch.tensor(alpha))).item()
@@ -27,12 +30,8 @@ def calc_cdf(alpha: float) -> Tuple[float, float, float]:
1 - 2 * cdf_alpha) * alpha * pdf_alpha - pdf_alpha ** 2
return cdf_alpha, f1, f2
def max_gaussian(mu1, sigma1, mu2, sigma2) -> Tuple[float, float]:
global lookup_count
global F1
global F2
global CDF
def max_gaussian(mu1, sigma1, mu2, sigma2) -> tuple[float, float]:
"""
Returns the combined max gaussian of two Gaussians represented by mu1, sigma1, mu2, simga2
:param mu1: mu of the first Gaussian
@@ -41,17 +40,22 @@ def max_gaussian(mu1, sigma1, mu2, sigma2) -> Tuple[float, float]:
:param sigma2: sigma of the second Gaussian
:return: mu and sigma maximized
"""
global total_count
total_count += 1
# we assume independence of the two gaussians
#print(mu1, sigma1, mu2, sigma2)
#normal = dist.Normal(0, 1)
# print(mu1, sigma1, mu2, sigma2)
# normal = dist.Normal(0, 1)
sigma_m = math.sqrt(sigma1 ** 2 + sigma2 ** 2)
# round to two significant digits to enable float lookup
alpha = round((mu1 - mu2) / sigma_m, 2)
cdf_alpha, f1_alpha, f2_alpha = calc_cdf(alpha)
mu = mu2 + sigma_m * f1_alpha
sigma = math.sqrt(sigma2 ** 2 + (sigma1 ** 2 - sigma2 ** 2) * cdf_alpha + sigma_m ** 2 * f2_alpha)
#sigma = math.sqrt((mu1**2 + sigma1**2) * cdf_alpha + (mu2**2 + sigma2**2) * (1 - cdf_alpha) + (mu1 + mu2) * sigma_m * pdf_alpha - mu**2)
# sigma = math.sqrt((mu1**2 + sigma1**2) * cdf_alpha + (mu2**2 + sigma2**2) * (1 - cdf_alpha) + (mu1 + mu2) * sigma_m * pdf_alpha - mu**2)
return mu, sigma
@@ -75,20 +79,20 @@ def min_gaussian(mu1, sigma1, mu2, sigma2) -> tuple[float, float]:
pdf_alpha_neg = exp(normal.log_prob(torch.tensor(-alpha))).item()
mu = mu1 * (1 - cdf_alpha) + mu2 * cdf_alpha - pdf_alpha_neg * sigma_m
sigma = math.sqrt((mu1**2 + sigma1**2) * (1 - cdf_alpha) + (mu2**2 + sigma2**2) * cdf_alpha - (mu1 + mu2) * sigma_m * pdf_alpha - mu**2)
sigma = math.sqrt((mu1 ** 2 + sigma1 ** 2) * (1 - cdf_alpha) + (mu2 ** 2 + sigma2 ** 2) * cdf_alpha - (
mu1 + mu2) * sigma_m * pdf_alpha - mu ** 2)
return mu, sigma
except ValueError:
print(mu1, sigma1, mu2, sigma2)
def beta_mean(alpha, beta):
return alpha / (alpha + beta)
def beta_std(alpha, beta):
try:
return math.sqrt((alpha * beta) / ((alpha * beta)**2 * (alpha + beta + 1)))
return math.sqrt((alpha * beta) / ((alpha * beta) ** 2 * (alpha + beta + 1)))
except ZeroDivisionError:
print(alpha, beta)