Paul semester project

.gitignore

@@ -4,3 +4,44 @@ sensepy/__pycache__
 *.txt
 *.png
 *.pdf
+*.pyo
+*.pyd
+*.pdb
+*.egg
+*.egg-info
+*.whl
+*.manifest
+*.spec
+*.log
+*.pot
+*.mo
+*.so
+*.dll
+*.dylib
+*.a
+*.lib
+*.swp
+*.swo
+*.tmp
+*.bak
+*.old
+*.orig
+*.rej
+*.sublime-project
+*.sublime-workspace
+*.project
+*.pydevproject
+*.idea/
+.vscode/
+__pycache__/
+*.coverage
+.coverage.*
+.cache
+.tox/
+.nox/
+.pytest_cache/
+htmlcov/
+dist/
+build/
+site/
+docs/_build/

setup.py

@@ -1,29 +1,35 @@
 from setuptools import setup
 
 packages = [
-    'numpy',
-    'scipy',
-    'matplotlib',
-    'sklearn',
-    'tensorflow',
-    'cvxpy',
-    'torch',
-    'pymanopt',
-    'pandas',
-    'mosek',
-    'quadprog',
-    'cvxpylayers',
-    'functorch',
-    'autograd_minimize'
+    "numpy",
+    "scipy",
+    "matplotlib",
+    "scikit-learn",
+    "tensorflow",
+    "cvxpy",
+    "torch",
+    "pymanopt",
+    "pandas",
+    "mosek",
+    "quadprog",
+    "cvxpylayers",
+    "autograd_minimize",
+    "torch-cluster",
+    "nmf-torch",
+    "fast-pytorch-kmeans",
+    "tqdm",
 ]
 #
-setup(name='stpy',
-      version='0.0.2',
-      description='Stochastic Process Library for Python',
-      url='',
-      author='Mojmir Mutny',
-      author_email='mojmir.mutny@inf.ethz.ch',
-      license='custom ',
-      packages=['stpy'],
-	    zip_safe=False,
-      install_requires=packages)
+setup(
+    name="stpy",
+    version="0.0.2",
+    description="Stochastic Process Library for Python",
+    url="",
+    author="Mojmir Mutny",
+    author_email="mojmir.mutny@inf.ethz.ch",
+    license="custom ",
+    packages=["stpy"],
+    zip_safe=False,
+    install_requires=packages,
+    setup_requires=["torch", "Cython"],
+)

stpy/approx_inference/expected-propagation.py

@@ -3,63 +3,67 @@
 from scipy.stats import multivariate_normal
 
 
-class ExpectedPropagationQuadratic():
+class ExpectedPropagationQuadratic:
 
-	def __init__(self, mu_prior, Sigma_prior, likelihood_single, data):
+    def __init__(self, mu_prior, Sigma_prior, likelihood_single, data):
 
-		# takes two arguments param, theta
-		self.likelihood_single = likelihood_single
+        # takes two arguments param, theta
+        self.likelihood_single = likelihood_single
 
-		# prior information
-		self.mu_prior = mu_prior
-		self.Sigma_prior = Sigma_prior
+        # prior information
+        self.mu_prior = mu_prior
+        self.Sigma_prior = Sigma_prior
 
-		self.d = mu_prior.size()[1]
+        self.d = mu_prior.size()[1]
 
-		self.n = len(self.data)
-		self.data = data
+        self.n = len(self.data)
+        self.data = data
 
-		self.approx = []
-		for i in range(self.n):
-			mu = torch.zeros(size=(1, self.d)).double()
-			Sigma = torch.eye(size=(self.d, self.d)).double()
-			self.approx.append((mu, Sigma))
+        self.approx = []
+        for i in range(self.n):
+            mu = torch.zeros(size=(1, self.d)).double()
+            Sigma = torch.eye(size=(self.d, self.d)).double()
+            self.approx.append((mu, Sigma))
 
-	def marginalized_version(self, j):
-		mu = torch.zeros(size=(1, self.d)).double()
-		Sigma = torch.zeros(size=(self.d, self.d)).double()
+    def marginalized_version(self, j):
+        mu = torch.zeros(size=(1, self.d)).double()
+        Sigma = torch.zeros(size=(self.d, self.d)).double()
 
-		for i in range(self.n):
-			if i != j:
-				Sigma_elem = self.approx[j][0]
-				mu_elem = self.approx[j][1]
-				Sigma_elem_inv = torch.inverse(Sigma_elem)
-				mu += Sigma_elem_inv @ mu_elem
-				Sigma += Sigma_elem_inv
-		Sigma = torch.inverse(Sigma)
-		mu = Sigma @ mu
-		return (mu, Sigma)
+        for i in range(self.n):
+            if i != j:
+                Sigma_elem = self.approx[j][0]
+                mu_elem = self.approx[j][1]
+                Sigma_elem_inv = torch.inverse(Sigma_elem)
+                mu += Sigma_elem_inv @ mu_elem
+                Sigma += Sigma_elem_inv
+        Sigma = torch.inverse(Sigma)
+        mu = Sigma @ mu
+        return (mu, Sigma)
 
-	def match_likelihood(self, j):
-		mu, Sigma = self.marginalized_version(j)
-		lik = lambda x: self.likelihood_single(torch.from_numpy(x), self.data[j]).numpy()
-		prob = lambda x: multivariate_normal.pdf(x, mean=mu.view(-1).reshape.numpy(), cov=Sigma.numpy())
-		first_moment = integrate.quad(lambda x: x * lik(x) * prob(x), 0.0, 10e10)
-		second_moment = integrate.quad(lambda x: x * x * lik(x) * prob(x), 0.0, 10e10)
+    def match_likelihood(self, j):
+        mu, Sigma = self.marginalized_version(j)
+        lik = lambda x: self.likelihood_single(
+            torch.from_numpy(x), self.data[j]
+        ).numpy()
+        prob = lambda x: multivariate_normal.pdf(
+            x, mean=mu.view(-1).reshape.numpy(), cov=Sigma.numpy()
+        )
+        first_moment = integrate.quad(lambda x: x * lik(x) * prob(x), 0.0, 10e10)
+        second_moment = integrate.quad(lambda x: x * x * lik(x) * prob(x), 0.0, 10e10)
 
-		self.approx[j][0] = first_moment
-		self.approx[j][1] = second_moment
+        self.approx[j][0] = first_moment
+        self.approx[j][1] = second_moment
 
-		return (first_moment, second_moment - first_moment ** 2)
+        return (first_moment, second_moment - first_moment**2)
 
-	def finalize(self):
-		pass
+    def finalize(self):
+        pass
 
-	def fit_gp(self, iterations='auto'):
-		if iterations == 'auto':
-			T = 100
-		for i in range(T):
-			for j in range(self.n):
-				self.match_likelihood(j)
-		mu, Sigma = self.finalize()
-		return mu, Sigma
+    def fit_gp(self, iterations="auto"):
+        if iterations == "auto":
+            T = 100
+        for i in range(T):
+            for j in range(self.n):
+                self.match_likelihood(j)
+        mu, Sigma = self.finalize()
+        return mu, Sigma

stpy/approx_inference/hmc.py

@@ -1,5 +1,7 @@
-params_hmc = hamiltorch.sample(log_prob_func=log_prob_func,
-							   params_init=params_init,
-							   num_samples=num_samples,
-							   step_size=step_size,
-							   num_steps_per_sample=num_steps_per_sample)
+params_hmc = hamiltorch.sample(
+    log_prob_func=log_prob_func,
+    params_init=params_init,
+    num_samples=num_samples,
+    step_size=step_size,
+    num_steps_per_sample=num_steps_per_sample,
+)

stpy/approx_inference/langevin.py

@@ -3,25 +3,29 @@
 import torch
 
 
-class LangevinSampler():
+class LangevinSampler:
 
-	def __init__(self, verbose=False):
-		self.verbose = verbose
-		pass
+    def __init__(self, verbose=False):
+        self.verbose = verbose
+        pass
 
-	def calculate(self, HessianF, theta0):
-		W = HessianF(theta0)
-		L = float(scipy.sparse.linalg.eigsh(W.numpy(), k=1, which='LM', return_eigenvectors=False, tol=1e-3))
-		return L
+    def calculate(self, HessianF, theta0):
+        W = HessianF(theta0)
+        L = float(
+            scipy.sparse.linalg.eigsh(
+                W.numpy(), k=1, which="LM", return_eigenvectors=False, tol=1e-3
+            )
+        )
+        return L
 
-	def sample(self, F, nablaF, HessianF, theta0, steps=100):
-		L = self.calculate(HessianF, theta0)
-		eta = 0.5 / (L + 1)
-		m = theta0.size()[0]
-		theta = theta0
-		for k in range(steps):
-			w = torch.randn(size=(m, 1)).double()
-			theta = theta - eta * nablaF(theta) + np.sqrt(2 * eta) * w
-			if self.verbose == True:
-				print("Iter:", k, theta.T)
-		return theta
+    def sample(self, F, nablaF, HessianF, theta0, steps=100):
+        L = self.calculate(HessianF, theta0)
+        eta = 0.5 / (L + 1)
+        m = theta0.size()[0]
+        theta = theta0
+        for k in range(steps):
+            w = torch.randn(size=(m, 1)).double()
+            theta = theta - eta * nablaF(theta) + np.sqrt(2 * eta) * w
+            if self.verbose == True:
+                print("Iter:", k, theta.T)
+        return theta

stpy/approx_inference/proximal_langevin.py

@@ -3,18 +3,23 @@
 
 
 def ProximalLangevin(LangevinSampler):
-	def sample(self, F, nablaF, HessianF, theta0, prox, steps=100):
-		L = self.calculate(HessianF, theta0)
-		eta = 0.5 / (L + 1)
-		m = theta0.size()[0]
-		theta = theta0
-		for k in range(steps):
-			w = torch.randn(size=(m, 1)).double()
-			theta = (1 - eta) * theta - eta * nablaF(theta) + eta * prox(theta) + np.sqrt(2 * eta) * w
-			if self.verbose == True:
-				print("Iter:", k, theta.T)
-		return prox(theta)
+    def sample(self, F, nablaF, HessianF, theta0, prox, steps=100):
+        L = self.calculate(HessianF, theta0)
+        eta = 0.5 / (L + 1)
+        m = theta0.size()[0]
+        theta = theta0
+        for k in range(steps):
+            w = torch.randn(size=(m, 1)).double()
+            theta = (
+                (1 - eta) * theta
+                - eta * nablaF(theta)
+                + eta * prox(theta)
+                + np.sqrt(2 * eta) * w
+            )
+            if self.verbose == True:
+                print("Iter:", k, theta.T)
+        return prox(theta)
 
 
 def MirrorLangevin(LangvinSampler):
-	pass
+    pass