From 8389932e7a55f1bbe5bb40d84b4cd49e4f0823c8 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 2 Aug 2023 10:36:09 +0000 Subject: [PATCH 001/152] First attempt at sampling class --- .../cil/optimisation/algorithms/sampling.py | 101 +++++ .../algorithms/testing_sampling.ipynb | 419 ++++++++++++++++++ 2 files changed, 520 insertions(+) create mode 100644 Wrappers/Python/cil/optimisation/algorithms/sampling.py create mode 100644 Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampling.py b/Wrappers/Python/cil/optimisation/algorithms/sampling.py new file mode 100644 index 0000000000..b41b7032c8 --- /dev/null +++ b/Wrappers/Python/cil/optimisation/algorithms/sampling.py @@ -0,0 +1,101 @@ +# -*- coding: utf-8 -*- +# This work is part of the Core Imaging Library (CIL) developed by CCPi +# (Collaborative Computational Project in Tomographic Imaging), with +# substantial contributions by UKRI-STFC and University of Manchester. + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import numpy as np +import math +class Sampling(): + + def __init__(self, num_subsets, sampling_type='sequential', prob=None, seed=99): + self.type=sampling_type + self.num_subsets=num_subsets + self.seed=seed + + self.last_subset=-1 + if self.type=='sequential': + pass + elif self.type=='random': + if prob==None: + self.prob = [1/self.num_subsets] * self.num_subsets + else: + self.prob=prob + elif self.type=='herman_meyer': + + self.order=self.herman_meyer_order(self.num_subsets) + else: + raise NameError('Please choose from sequential, random, herman_meyer') + + + def herman_meyer_order(self, n): + # Assuming that the subsets are in geometrical order + n_variable = n + i = 2 + factors = [] + while i * i <= n_variable: + if n_variable % i: + i += 1 + else: + n_variable //= i + factors.append(i) + if n_variable > 1: + factors.append(n_variable) + n_factors = len(factors) + order = [0 for _ in range(n)] + value = 0 + for factor_n in range(n_factors): + n_rep_value = 0 + if factor_n == 0: + n_change_value = 1 + else: + n_change_value = math.prod(factors[:factor_n]) + for element in range(n): + mapping = value + n_rep_value += 1 + if n_rep_value >= n_change_value: + value = value + 1 + n_rep_value = 0 + if value == factors[factor_n]: + value = 0 + order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping + return order + + def next(self): + if self.type=='sequential': + self.last_subset= (self.last_subset+1)%self.num_subsets + return self.last_subset + elif self.type=='random': + if self.last_subset==-1: + np.random.seed(self.seed) + self.last_subset=0 + return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + elif self.type=='herman_meyer': + self.last_subset= (self.last_subset+1)%self.num_subsets + return(self.order[self.last_subset]) + + + def show_epochs(self, num_epochs=2): + if self.type=='sequential': + for i in range(num_epochs): + print('Epoch {}: '.format(i), [j for j in range(self.num_subsets)]) + elif self.type=='random': + np.random.seed(self.seed) + for i in range(num_epochs): + print('Epoch {}: '.format(i), np.random.choice(self.num_subsets, self.num_subsets, p=self.prob)) + elif self.type=='herman_meyer': + for i in range(num_epochs): + print('Epoch {}: '.format(i), self.order) + \ No newline at end of file diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb new file mode 100644 index 0000000000..f135686d3c --- /dev/null +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -0,0 +1,419 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + " \n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "from sampling import Sampling\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "sampler=Sampling(10,'sequential')\n", + "sampler.show_epochs(5)\n", + "for _ in range(100):\n", + " print(sampler.next())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: [ 7 5 9 0 8 6 3 0 10 0 8]\n", + "Epoch 1: [ 8 4 5 10 4 10 5 1 8 2 6]\n", + "Epoch 2: [3 8 9 2 7 1 4 1 1 2 5]\n", + "Epoch 3: [ 0 2 0 9 6 1 10 5 0 5 7]\n", + "Epoch 4: [ 8 9 2 10 5 2 6 4 2 10 10]\n", + "7\n", + "5\n", + "9\n", + "0\n", + "8\n", + "6\n", + "3\n", + "0\n", + "10\n", + "0\n", + "8\n", + "8\n", + "4\n", + "5\n", + "10\n", + "4\n", + "10\n", + "5\n", + "1\n", + "8\n", + "2\n", + "6\n", + "3\n", + "8\n", + "9\n", + "2\n", + "7\n", + "1\n", + "4\n", + "1\n", + "1\n", + "2\n", + "5\n", + "0\n", + "2\n", + "0\n", + "9\n", + "6\n", + "1\n", + "10\n", + "5\n", + "0\n", + "5\n", + "7\n", + "8\n", + "9\n", + "2\n", + "10\n", + "5\n", + "2\n", + "6\n", + "4\n", + "2\n", + "10\n", + "10\n", + "9\n", + "4\n", + "7\n", + "9\n", + "0\n", + "4\n", + "7\n", + "10\n", + "7\n", + "7\n", + "2\n", + "3\n", + "1\n", + "3\n", + "7\n", + "10\n", + "0\n", + "3\n", + "0\n", + "9\n", + "7\n", + "9\n", + "10\n", + "1\n", + "5\n", + "6\n", + "5\n", + "7\n", + "9\n", + "2\n", + "1\n", + "6\n", + "2\n", + "9\n", + "5\n", + "7\n", + "3\n", + "1\n", + "3\n", + "1\n", + "2\n", + "5\n", + "3\n", + "8\n", + "7\n" + ] + } + ], + "source": [ + "sampler=Sampling(11,'random')\n", + "sampler.show_epochs(5)\n", + "for _ in range(100):\n", + " print(sampler.next())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "Epoch 1: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "Epoch 2: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "Epoch 3: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "Epoch 4: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "0\n", + "30\n", + "15\n", + "45\n", + "5\n", + "35\n", + "20\n", + "50\n", + "10\n", + "40\n", + "25\n", + "55\n", + "1\n", + "31\n", + "16\n", + "46\n", + "6\n", + "36\n", + "21\n", + "51\n", + "11\n", + "41\n", + "26\n", + "56\n", + "2\n", + "32\n", + "17\n", + "47\n", + "7\n", + "37\n", + "22\n", + "52\n", + "12\n", + "42\n", + "27\n", + "57\n", + "3\n", + "33\n", + "18\n", + "48\n", + "8\n", + "38\n", + "23\n", + "53\n", + "13\n", + "43\n", + "28\n", + "58\n", + "4\n", + "34\n", + "19\n", + "49\n", + "9\n", + "39\n", + "24\n", + "54\n", + "14\n", + "44\n", + "29\n", + "59\n", + "0\n", + "30\n", + "15\n", + "45\n", + "5\n", + "35\n", + "20\n", + "50\n", + "10\n", + "40\n", + "25\n", + "55\n", + "1\n", + "31\n", + "16\n", + "46\n", + "6\n", + "36\n", + "21\n", + "51\n", + "11\n", + "41\n", + "26\n", + "56\n", + "2\n", + "32\n", + "17\n", + "47\n", + "7\n", + "37\n", + "22\n", + "52\n", + "12\n", + "42\n", + "27\n", + "57\n", + "3\n", + "33\n", + "18\n", + "48\n" + ] + } + ], + "source": [ + "sampler=Sampling(60,'herman_meyer')\n", + "sampler.show_epochs(5)\n", + "for _ in range(100):\n", + " print(sampler.next())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cil", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7331c73156493673daef201b6b26018a12f02583 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 2 Aug 2023 14:31:39 +0000 Subject: [PATCH 002/152] Changed how probabilities and samplers interact in SPDHG --- .../optimisation/algorithms/SPDHG_sampling.py | 259 +++++++++++++++ .../SPDHG_sampling.cpython-310.pyc | Bin 0 -> 7987 bytes .../__pycache__/sampling.cpython-310.pyc | Bin 0 -> 2552 bytes .../algorithms/testing_sampling_SPDHG.ipynb | 308 ++++++++++++++++++ .../TotalVariation.cpython-310.pyc | Bin 0 -> 7665 bytes .../TotalVariationNew.cpython-310.pyc | Bin 0 -> 9895 bytes .../__pycache__/utils.cpython-310.pyc | Bin 0 -> 1846 bytes 7 files changed, 567 insertions(+) create mode 100644 Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py create mode 100644 Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc create mode 100644 Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc create mode 100644 Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb create mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariation.cpython-310.pyc create mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc create mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/utils.cpython-310.pyc diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py new file mode 100644 index 0000000000..e860500b7e --- /dev/null +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py @@ -0,0 +1,259 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 United Kingdom Research and Innovation +# Copyright 2020 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt +# Claire Delplancke (University of Bath) + +from cil.optimisation.algorithms import Algorithm +import numpy as np +import warnings +import logging +from sampling import Sampling +class SPDHG(Algorithm): + r'''Stochastic Primal Dual Hybrid Gradient + + Problem: + + .. math:: + + \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) + + Parameters + ---------- + f : BlockFunction + Each must be a convex function with a "simple" proximal method of its conjugate + g : Function + A convex function with a "simple" proximal + operator : BlockOperator + BlockOperator must contain Linear Operators + tau : positive float, optional, default=None + Step size parameter for Primal problem + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + initial : DataContainer, optional, default=None + Initial point for the SPDHG algorithm + prob : list of floats, optional, default=None + List of probabilities. If None each subset will have probability = 1/number of subsets + gamma : float + parameter controlling the trade-off between the primal and dual step sizes + sampler: instnace of the Sampling class + Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets + **kwargs: + norms : list of floats + precalculated list of norms of the operators + + Example + ------- + + Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py + + + Note + ---- + + Convergence is guaranteed provided that [2, eq. (12)]: + + .. math:: + + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i + + Note + ---- + + Notation for primal and dual step-sizes are reversed with comparison + to PDHG.py + + Note + ---- + + this code implements serial sampling only, as presented in [2] + (to be extended to more general case of [1] as future work) + + References + ---------- + + [1]"Stochastic primal-dual hybrid gradient algorithm with arbitrary + sampling and imaging applications", + Chambolle, Antonin, Matthias J. Ehrhardt, Peter Richtárik, and Carola-Bibiane Schonlieb, + SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. + + [2]"Faster PET reconstruction with non-smooth priors by randomization and preconditioning", + Matthias J Ehrhardt, Pawel Markiewicz and Carola-Bibiane Schönlieb, + Physics in Medicine & Biology, Volume 64, Number 22, 2019. + ''' + + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, + initial=None, prob=None, gamma=1.,sampler=None,**kwargs): + + super(SPDHG, self).__init__(**kwargs) + + + + if f is not None and operator is not None and g is not None: + self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + initial=initial, prob=prob, gamma=gamma,sampler=sampler, norms=kwargs.get('norms', None)) + + + def set_up(self, f, g, operator, tau=None, sigma=None, \ + initial=None, prob=None, gamma=1.,sampler=None, norms=None): + + '''set-up of the algorithm + Parameters + ---------- + f : BlockFunction + Each must be a convex function with a "simple" proximal method of its conjugate + g : Function + A convex function with a "simple" proximal + operator : BlockOperator + BlockOperator must contain Linear Operators + tau : positive float, optional, default=None + Step size parameter for Primal problem + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + initial : DataContainer, optional, default=None + Initial point for the SPDHG algorithm + prob : list of floats, optional, default=None + List of probabilities. If None each subset will have probability = 1/number of subsets + gamma : float + parameter controlling the trade-off between the primal and dual step sizes + + **kwargs: + norms : list of floats + precalculated list of norms of the operators + ''' + logging.info("{} setting up".format(self.__class__.__name__, )) + + # algorithmic parameters + self.f = f + self.g = g + self.operator = operator + self.tau = tau + self.sigma = sigma + self.prob = prob + self.ndual_subsets = len(self.operator) + self.gamma = gamma + self.rho = .99 + self.sampler=sampler + + if self.sampler==None: + if self.prob != None: + self.sampler=Sampling(self.ndual_subsets, 'random', prob=self.prob) + else: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler=Sampling(self.ndual_subsets, 'random', prob=self.prob) + else: + if self.prob==None: + if self.sampler.type=='random': + self.prob=self.sampler.prob + else: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + else: + warnings.warn('You supplied both probabilites and a sampler. The sampler will be used for sampling and the probabilites for calculationg step sizes, if not explicitly set.') + + + + if self.sigma is None: + if norms is None: + # Compute norm of each sub-operator + norms = [operator.get_item(i,0).norm() for i in range(self.ndual_subsets)] + self.norms = norms + self.sigma = [self.gamma * self.rho / ni for ni in norms] + if self.tau is None: + self.tau = min( [ pi / ( si * ni**2 ) for pi, ni, si in zip(self.prob, norms, self.sigma)] ) + self.tau *= (self.rho / self.gamma) + + # initialize primal variable + if initial is None: + self.x = self.operator.domain_geometry().allocate(0) + else: + self.x = initial.copy() + + self.x_tmp = self.operator.domain_geometry().allocate(0) + + # initialize dual variable to 0 + self.y_old = operator.range_geometry().allocate(0) + + # initialize variable z corresponding to back-projected dual variable + self.z = operator.domain_geometry().allocate(0) + self.zbar= operator.domain_geometry().allocate(0) + # relaxation parameter + self.theta = 1 + self.configured = True + logging.info("{} configured".format(self.__class__.__name__, )) + + def update(self): + # Gradient descent for the primal variable + # x_tmp = x - tau * zbar + self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) + + self.g.proximal(self.x_tmp, self.tau, out=self.x) + + # Choose subset + i = int(self.sampler.next()) + + # Gradient ascent for the dual variable + # y_k = y_old[i] + sigma[i] * K[i] x + y_k = self.operator[i].direct(self.x) + + y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) + + y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) + + # Back-project + # x_tmp = K[i]^*(y_k - y_old[i]) + y_k.subtract(self.y_old[i], out=self.y_old[i]) + + self.operator[i].adjoint(self.y_old[i], out = self.x_tmp) + # Update backprojected dual variable and extrapolate + # zbar = z + (1 + theta/p[i]) x_tmp + + # z = z + x_tmp + self.z.add(self.x_tmp, out =self.z) + # zbar = z + (theta/p[i]) * x_tmp + + self.z.sapyb(1., self.x_tmp, self.theta / self.prob[i], out = self.zbar) + + # save previous iteration + self.save_previous_iteration(i, y_k) + + def update_objective(self): + # p1 = self.f(self.operator.direct(self.x)) + self.g(self.x) + p1 = 0. + for i,op in enumerate(self.operator.operators): + p1 += self.f[i](op.direct(self.x)) + p1 += self.g(self.x) + + d1 = - self.f.convex_conjugate(self.y_old) + tmp = self.operator.adjoint(self.y_old) + tmp *= -1 + d1 -= self.g.convex_conjugate(tmp) + + self.loss.append([p1, d1, p1-d1]) + + @property + def objective(self): + '''alias of loss''' + return [x[0] for x in self.loss] + @property + def dual_objective(self): + return [x[1] for x in self.loss] + + @property + def primal_dual_gap(self): + return [x[2] for x in self.loss] + def save_previous_iteration(self, index, y_current): + self.y_old[index].fill(y_current) diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af5025487fe715bfddba8e7e8c1b9d1ffd0f3e3a GIT binary patch literal 7987 zcmcIp%a0t#dGG3;_s%}FTvDV+TV+Z%ILht}xppFIEz73(kZ4J(m6oxS5$Q(Hbj?f; z`!TBSCU-}(2ZIE}iwqd>)xa)b1Yr)&E$0Bf<&Zz1Z-x(sPIjOKL1F{S@2j4kogtTy z7~8Yx>guZcp7quDs14@lD;j?9ZT_46^A|PkH}o<6%i-gDc)}}aY|Un_=CLMY)Yo0T zX{dLunN#n4Gmp377QAA!$h0>!J7?$bYj$3+dq%Tl>)Tqb@F_59HI|ewx!piIQP11N zS83bw2Cn0G+cZ7>BNpfv4$ug#$!x8u+pKAn^|EfSe5`etB2#YW)W~tWU>EN*uu`(i z_qArhuGn*U7e&dg+Vl6dd#qVTf5Bc<{R;X^_A{zKXD{2wu(tZKmeZQ^VE06l-`=|N z<{R-(%bK{Moyb=NyoEXekDfp=59+mHh)7}wj=zgQsMY*$)M#5Z-c8Z)zs_U zv!dR{#^Dg>H$BHUKib*jopW#P)c9ZV?m4`^b2xr8j6L2lopW!Q4xg-0D2R^gY+2Is zL?mRWKG!Bc_1WPY{B<{I-@X?6?Z^rI3Gh{`-Q!*yM!Y4s#oK{@N9^#b+hedJD29rpGPh}h zjt@y-f*bsb64`Gx#KnXZrF27%*83U$;ITvCjx z4!4GkKn5=P5>7%zIF@29=yYJ?(On^YH9APoujSj^rZXI7o178}$r}l|!5u%0e5);p z3#Fp5o8oQP3e&Yj{+-Ez2!$(f$i~Edu@iBeaA&P$MeW{11FKwubl`DCh*lFPe~MaO zdg=CEOLoK5x%h$f!pFAlP+L;8Ew>%JIJEY}T2r90pxF@&Q+IZCM`6xfxsA)$-(I^SydZ3}+@RI);8BHa+z7m& zE3H9qx3TSbDQoEYT~~a4{ru&g<@>^IkS{jxgr+jp`e3(`GO-zqy$`Xb#8eFq#2q2K z!p8dSW1|!GtcZWGzRJaib$;%`dhOPfd!BggDKCC=bWrDF1-QyT|0*>d0*xfp0ef#>Qclh^%SRxj2Si!r9 zOP(`KO=A7xD))mr{}w;De*VJ6+6G^L`QkU%)-RsFSce8@b%)(KdrciHzIF8mYz0m+ zjAX2$f2sjL@Yg~w2oT|+w?KxxwL5l78A;+8n+{kT{+p!jj`eUT^R&p;UEx9<^0p)H zI_=>TB>vUEOo_bJ+YOy|NEY>uu$?vnH~$8I-3i>F3#KC>6bQ#_W~Yzhc=o>i`YoJr}uT+aI{h77wjjDX(ObPF_Wt! zWU+YHN4k2SA8CDK#76qa80AL!QDIaZl}6=JWj|*F;y}0cPb!oFZ_hln+-8zjF0@uj zSSMlKq?9?)#DHr^^2%={#c|M1auo2Ayb5SZaU61F0sKDHYI!V=k@iT+f0L4F5|n8s z1;k7<9wbIrM76mjhj`PGMXZq}YLKOBl5`FlL%^ z2{ZqDtziuYjke=9eh5bl;$dTJ7nz=~#wbnloKTr#W0E9<4dsf>>H%Rs<-@M`pF1EqPCYhz`hm88 zW@`0U@I4Lv)knUcC+(Qro=5vNwQCEryJj0Gr53FhVaqVzwRn)FQxh|q_^+)j$39H1 zCe=(D+2QT@lS>+!{Y#WJg!jnOh9;h}ydjXxH6Tfwtz@QrIjx(W{BmUu!TrBV9RfU} z_)z)CR+=%B&&tXjTK*@NJcJ@E7LK6>CXA#$NQPOCN&0{-w(wT1_H9mP>zO2}F>Y zWQ5_*Tm}*Pqe~&0`7@S7lao1HVGxxss4^5IPg7|S0R4vZAMGIzjZ_&G54yj68zy9P|OBCDB@3w5U|##Qcgpo<6@FlCHR_Gde{voc)9x_R=H9aXI)|*Zwyd*~|$B14(pD+h% zQ1PCEw>*U=sl4jq4uPtH*Zu+DpAo?`+Ayu`>uKsxe-(E@mK(l?PPX_lE-C9cg3G@4 zKvSL-qpnpC?vy-+=_j(N#+nfAVYi{6`u(i)Mx>5hT@Y;|Xb2 zsb>DBvB&oGJ<7)n%Fm8zD_TbSA^Vi%OF77msSX_ZA_fyZbW*w#X;lRbto9CPn0)Q~)G7$L|D50XvUtJ9(0@A`kO%(}slUi76LlTZ!Qczd7$y zDPoQLq#DcUPz!Ffnj%kQhT}&|Jh#0q(WTt_X1R zCU=t(>PhTjBoelheJEiT<(TW2Y;7IS&Xq86so~Jh`P$`gN zT~O;6Q8bKK9q0;bDO;Vr0ii2C6ovjX**M-9oKStkpmZ!#2nP_wc&vBx7nz)&8 zv44WfmIL6R;-qG5$~=^U+jS#|quR6buknSl!Wy7B-atPs6kett6%Wl4Jf6DXO$=NM zrqx1@uCSDwNeZ?DZyu$U#YKW5n`tg*P$rBjy$DW9FnZM2?Ivzm1AjMb3EOswW-_^`3>5owe4bxO={J#!N~s2mSjijI9Z z_DT2o1Ekz9YkTa&611)DlQm(CM$j|%l_edpIc<+tv;8vK5^N|x%G>%Y8s0Qsz&b!( zOjlK4X$<3dPHJ6)N{;akcEOtZefl|mwQ5opxE3Wf3AHKBa+XMjsY|+q)oP>DEnUK% z;7^|2sQQ;ujhaELPnVr{ z#BTr*QrVZ&SJ)Z0#Fq30R>J!^eRv{0x{rd)YzGB8^2)^5XXLR_Y3uiCJ2a|s$e4%o zmP^+xxMw83XTS-R0tf|<&sNZ=;8DPipkP0hMJfuoN|J|Zh)UI@;=^o^_)kJZI9Igc z3n}*#Nso%2h;!Eo_t!H5slHT1E>9r;1G6ghz%Umd!8#+&v@+xtpm36B7EFsP-=hUg zo}SQtf6|+k>c456G&DSyQdiMw!roDW$r}W7lvoS1!2gAHN@Gj_>fi$eKekN3vrT zAjmyuhnsC8Rie|FHN;^uKfYXQ3)dZAFr|__OG{L$Ku7jDJSyKSX*s69sk4R8 z^{S5BqSAY%7xaY+(~b05($!U1t=v3~8>;&BZB%`7jSxyw3hv=z4>^(U4`hR=y+nhh kEWuZ)mqIqB+R0f-O0TBMc#X_dU13#MN^oW+Rz;5Tf2{XI0RR91 literal 0 HcmV?d00001 diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aebdc95d144e7b9b034882bb369e611ed685fd05 GIT binary patch literal 2552 zcmaJ?UvC>l5Z~SV>$9D^o1j7xZ{%!<(?1pJqGa1l&kW4&$*^k~{t1NG?EgH4m(##IWVOft4Mt*wmBn`8) zG}ADYWjzYgY$_|wu}YqltwmcuQ8HAeRSmUHFbW?im8iBw4x(K}u;@0^Y1Dn%M>Qc+ zb&wZKwJ`j7e=``5H+zF<^RWUKs&wIqoP9y*?jPv^dcAm_Y5 zwhLpA6=rVa2C^uga&;4!Fjknlgj|acSz*LAl3Ztn$juX$8_ziho$05ITmUI1utBSW zRx@Dfh!>VLqxNbEjzJHGQsHUdz3wmKx@c6qi}yXkQLc?5+|<744PVd3}{tKCutG+O5U@lvU?Q z)p{002VvK(gnrzu$G!^3FedR*?DzV#OEoW@FbYTLHKjAcNzi>>`(K5Y$=<`4Zh@G> z1ZEq+EN~0VHvV#LLU2nj1F+`!D$FX@_mor^!r+T_~*gy@w-Q4(x?8s$HM(Y=cU z4;QEh5dtuZ6;O0MNEW)=`&z?WG|dUq`jDiiT7Zf^!jVx79X#@ z0;K<}_?%Z2e-`DoP%8*W$%kh$MFp=Y-aEvsf=t%u0Z#kL*M3MFr*AB94U3y(sKHRL zz;GRc(i$tB``rZhW2Uj8Zjq+8A#kX5BKkJcpfEHj&;xJ{R(q;7(x5x4BDy)%7Y^0M zQcByQO!*CNzVyTrxLcZQ@MXZo" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reader = ZEISSDataReader()\n", + "filename = '../../../data/valnut_tomo-A.txrm'\n", + "reader.set_up(file_name=filename)\n", + "data3D = reader.read()\n", + "\n", + "# reorder data to match default order for Astra/Tigre operator\n", + "data3D.reorder('astra')\n", + "\n", + "# Get Image and Acquisition geometries\n", + "ag3D = data3D.geometry\n", + "ig3D = ag3D.get_ImageGeometry()\n", + "\n", + "# Extract vertical slice\n", + "data2D = data3D.get_slice(vertical='centre')\n", + "\n", + "# Select every 10 angles\n", + "sliced_data = Slicer(roi={'angle':(0,1601,10)})(data2D)\n", + "\n", + "# Reduce background regions\n", + "binned_data = Binner(roi={'horizontal':(120,-120,2)})(sliced_data)\n", + "\n", + "# Create absorption data \n", + "data = TransmissionAbsorptionConverter()(binned_data) \n", + "\n", + "# Remove circular artifacts\n", + "data -= np.mean(data.as_array()[80:100,0:30])\n", + "\n", + "# Get Image and Acquisition geometries for one slice\n", + "ag2D = data.geometry\n", + "ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian')\n", + "ig2D = ag2D.get_ImageGeometry()\n", + "\n", + "A = ProjectionOperator(ig2D, ag2D, device = \"gpu\")\n", + "\n", + "show2D(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define number of subsets\n", + "n_subsets = 10\n", + "\n", + "partitioned_data=data.partition(n_subsets, 'staggered')\n", + "show2D(partitioned_data)\n", + "\n", + "\n", + "# Initialize the lists containing the F_i's and A_i's\n", + "f_subsets = []\n", + "A_subsets = []\n", + "\n", + "# Define F_i's and A_i's\n", + "for i in range(n_subsets):\n", + " # Define F_i and put into list\n", + " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", + " f_subsets.append(fi)\n", + " # Define A_i and put into list \n", + " ageom_subset = partitioned_data[i].geometry\n", + " Ai = ProjectionOperator(ig2D, ageom_subset)\n", + " A_subsets.append(Ai)\n", + "\n", + "# Define F and K\n", + "F = BlockFunction(*f_subsets)\n", + "K = BlockOperator(*A_subsets)\n", + "\n", + "# Define G (by default the positivity constraint is on)\n", + "alpha = 0.025\n", + "G = alpha * FGP_TV()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 50 0.000 6.90194e+03\n", + " 10 50 3.976 1.59092e+02\n", + " 20 50 5.019 5.91546e+01\n", + " 30 50 5.163 4.56431e+01\n", + " 40 50 4.928 4.06590e+01\n", + " 50 50 4.903 3.73280e+01\n", + "-------------------------------------------------------\n", + " 50 50 4.903 3.73280e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "# Setup and run SPDHG for 50 iterations\n", + "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", + " update_objective_interval = 10, sampler=Sampling(n_subsets, 'sequential'))\n", + "spdhg.run()\n", + "\n", + "spdhg_recon = spdhg.solution " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 50 0.000 6.90194e+03\n", + " 10 50 4.855 1.61868e+02\n", + " 20 50 4.709 6.13522e+01\n", + " 30 50 4.840 3.85550e+01\n", + " 40 50 4.864 3.88311e+01\n", + " 50 50 4.832 3.46613e+01\n", + "-------------------------------------------------------\n", + " 50 50 4.832 3.46613e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "# Setup and run SPDHG for 50 iterations\n", + "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", + " update_objective_interval = 10, sampler=Sampling(n_subsets, 'random'))\n", + "spdhg.run()\n", + "\n", + "spdhg_recon = spdhg.solution " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 50 0.000 6.90194e+03\n", + " 10 50 5.370 1.61868e+02\n", + " 20 50 5.122 6.13522e+01\n", + " 30 50 5.079 3.85550e+01\n", + " 40 50 5.180 3.88311e+01\n", + " 50 50 5.169 3.46613e+01\n", + "-------------------------------------------------------\n", + " 50 50 5.169 3.46613e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "# Setup and run SPDHG for 50 iterations\n", + "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", + " update_objective_interval = 10)\n", + "spdhg.run()\n", + "\n", + "spdhg_recon = spdhg.solution " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 50 0.000 6.90194e+03\n", + " 10 50 4.708 1.56371e+02\n", + " 20 50 4.701 5.73612e+01\n", + " 30 50 4.564 4.46291e+01\n", + " 40 50 4.731 4.00863e+01\n", + " 50 50 4.812 3.69452e+01\n", + "-------------------------------------------------------\n", + " 50 50 4.812 3.69452e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", + " update_objective_interval = 10, sampler=Sampling(n_subsets, 'herman_meyer'))\n", + "spdhg.run()\n", + "\n", + "spdhg_recon = spdhg.solution " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cil", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariation.cpython-310.pyc b/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariation.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8230db2f152ec73973b6e3c4f698f61a81d77534 GIT binary patch literal 7665 zcmb_h%X8dDdPf5o%y9S+MN$vz<+hStYiw%xuwq-x=3&c}*HsF`TCudX46_i3#*i3c zfKdY@lOr&dTB)+RIF(bbOCELGbE=X`F8K#?!zoocq;yLzIpnhWeGOn{IHc`ORfdHR z{leG%y}$k#O;6V~{PwQ=v-tU$ce~c&I0uY*DfwoO=JzyPuTkja#2BW?a zn4QXYMYUOAZC5d72DQ$__CzsO->!eDiHfjZYr^vMSH||FV2`y%^(`=K8x1|HJ?w>U z;zwaN^;IZ**GVGzd34ZV+3c6n5xy5Df7C)GuKSd7);=c#*v~4D| zZC$W!L+HW~rl@#kyE3T}6qcycU#tF0t;Ix5OuU}hw!EsSi^Pa0f$d%Xb2Vuh{F@l&ALjd>QR~=+}%ynpQCBx;UDsy#OdugL3iKbTTkvBG!zy>SN_z%rX!t>mv}N>D;5;5 zwJyzI&jZ`Xv^vcib@`wh^Qgriez`fMs{A%N?0Vy$`eCxjh1YU=LBdy-m&>*JK1mc{ zlhF0n_~Rt%cKvXVyWo^3!P9c7LOZgu6-3Sm(x)3y=snHZ#d$%18%gN}#ql2uJABtm zzV^J3KYiSFTzuw)VhJ+IyASrAF!X}>sghH&?+v6`>h`HKo!TT$xU2JHi0x>FwRIt%K-mPp)zG;=55V z6a(~;O!lKaXmG&0Lye6>9F7>^M&S$ZfX80KAC%-MffOinLmyK9^lsQ~`eEy7xj3i2 z*M)Ofj;-~kO{ zY^Spu9lShswxi#6qjYqO6zGQoK%Wk9JK=!B1|MKQEzYHbuTZ>&umLDfL8~hAucMPXfewzzdeR}S8<+}9)r_&8QIL=~Z>k0n@I74!|ALPz` z=-W&G8%F^aZ9Qqi#t!_B6Wk$E7dgB&##frl10{ocgi+$b<3GjZQ|>w;oEGQ^RY>Jv z8Aco_ox>*I0uAtT@RwK@d)&v#eE5!J-$_86*S#D2eGe?~V8_CzNJXSW^PMiO6ir3L zPrSnGj70;^KWp;OJ@*;8N&Y9;&x7*_0&kJuJ{9clevaJ*|E!F2x%YYyg>XxbA7W}O z=#{+V{Hu<$=kYJRF!EzM8}0Okw;S{%x05h!Hy~vLY5? zP+`DAcuhjFSjdI*7g5mUE1xccqj;|@@@}`uSMROdzq@+xqkD^dBYJ`U^78$~;dw;l zuOU!1S5}tqFKvCb*`#@Z)lXM{Z#icd>7Cl+tw0*HkyVtp&zQUQ(48Dfcc^U?Py9D% zBwE5!?Umlvk%6&q7_u)t)odfhsBNayuB25!D>VSCsR>w1D}WQJ1z1le(X)VI3cYEe z0nR9RLBUxCFQyY1pG#|i^JyJ$A=TOoa$OMCOG0~$tPoj@xq(!TJ^GLQ$p86A4;z=W zO5B5|mKMgcnr%~9vhD2Z>HNf2c1HO_Rv+dC*~B17XA=V-l1+|;$*fugtgNEqM^;f@ zToRYET4@_uJ?V69^xF1=Y{K3v^2@Ahi>L#2$|~J1R%DiXtz;${JWftdDVzA(ksa8$ zOtSjE6RVad8k3nBdqFFkK9$+kT_{ z&-xOKXvy`1rJqW)kW4LY9wL~AYAos|ey7OimRd#f950}xb{zu=o!5a4tD7JVmFWuxK--{Cd@~B}!L*W#l21u$T?VL?)Ax~YG zGLo5vAc6ckGs*eO_c8lMSF~r97f#Ug&SSwZuu3truFpXhXQ(4SE9$n<=vygkla;cc zYGIW@8VvMO|7Ro&UA_wlt8AOcl@wGTTY_NqL|cHM&dlkJsIW^SRI&h za|&$56#(&wE&*?e>u*UD8nvvp=S9f<<)M5B1G%D;XfaV5nk9Thj0AQ@iBe`DPbvAr z4#s#wUcz;Pz_$MyNMgdI8&k|;H7M;3c0)f$RrB?(fwkq2+5^tvvirT9OPOG)F7$5< zcrv4ZZ@`QHLqbazTLV!xGooJ7FyspM&AD;~EevoP_=Lb3fzt+&O_7VruXy%@zr%u< z?zg&`Q$Nf4*T*bmbp0vniShyU89LvmH%Fv1#*vwtg5B5fh6c$^=vw6q?a$|qDrx1| zI?>uyL<`)lztN#}X1j){V&=W)x6q$ZJwze2>xd1-9Jp%sH2G!9jwe&|1a$!5MN4rT zn1o3q$5SV??|EN}@A|S)>8}oCMXEYv3g1LHN20cq?zkdKc2fK04qSV3c*G?sFZ_}c z1I5*i#`K7|u3kuSBA+p#cUt=b@||)WeK$+_Put4BOfIH+GMCJ^7w}wa8LxEtS1D>RZ92(i z!bupfYxgysD4IJxSB@8>`c1V8UtJN^9+Ur)PKerNWMI#9`H!^c@l{YeS**4`$ycMF z&)lRr>RoxpY6BNANEPS_Pq)UW53ZnbYw7FclC!YXzZHca#$S(GQXaU!%T#}r+x z6SDBy-!gfXX(4;QE-1sirXcOkF>@bp#TB$yllR2r@onUglPCHsd>d9VGDRa4m6g;1HFHLv z(-+tcb{QjeeF{!;27kzLnf{lv`ix$KqnyHX%a}E0F+QbRI_7>uS#b@C#vGdg9&)Jk z-I-(q(M8?2&!lOCyqGjd6}$C~Jv7xXr|M(0$LPyu5l&DLvjo~Uqu7fgL@ewFK%zg?1VB!m9EPlViK8(Za>QAkvh4k6ephj$nVDPzMu3Z zT^z>Fsr2P09gWh8I{0I;{_NQC9-UzdWnt<(WO4~kLD?wN5*<0Z(L$Ck7vR73XBB$G zi z8nA{$h13(GAt7By0GTI8jw?MSq8rLNDUXEwk^F~zLO>niJVCjb{h-vLt49C!n2^rl z(wVajE>t8orA7>DbO|j85TWi81c){sb=9Dx87D5(3(51ZP#J?t5pT;o0FQ7XqW|V_ zzeNQpR9}?n@b3;(a}K>^P-KCmBq~oaR&jTqibbmWM3R3&{~kg4h8GuiT1BP4J)m$} zRJ9snr3i4R&>Y%t*Haf6Dr+^6rw=dbjfx}@2QEDgkK*4bsUh4K4y zN%t9(81R;?@cS>TDQN*NtMA1SoP(10`nO+AM>JF^CwXQ`cOMlTKr=@>vvN#hT1(e1 ziG0?!KN-*lUueN^o}sN=nLCmN`ZUD9e^A${+jb`sy@1+Nw*9>41jS6%hRj@i`IydN zAPrZA3RR?mW+aE|j5wS})kpa$omxe+A5)8>fOH6`xJ5di+X8vmY`UnTxE@^_M+m!3 z>wZ9hycXs2F~$3uX6pK)&ghQ_%v(B}`EUJW1PTO{TBSZyuh)6)&vXP36GE<4^$G$_ zRbgsOWd`ar*)@RXXkn%~D9lK5#d#g-?5ffhVoCazRZxmW;YM+$nwMo`6}zP%By{!> dqLjBGqO#hLa%TS_B$nTlYZvK0P*cx>`M-GAy<-3X literal 0 HcmV?d00001 diff --git a/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc b/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..61876cc7f5fe76b9822b8ebc3f96907ef499010e GIT binary patch literal 9895 zcmd5?OK;p*b|zV@r%JLctL10AZ+Fj3RBpK}X(l~rrR{0Ar`2P?qcPfw2N5dGV%4Q2 zmRV%^l4ZSEo5;Wb0SpAQ%PP|BdNIEvn;^(yR$R;`i@>|dBAYCdeCP5}ReE@A>O+^?Z8Px1m)>qv{kgqs@kh%`Yo6$)cT4iFrbg3W3zOTH z8~mbY2^zA7#==^^+pE6*o*^`&yCZWOFSr^qMMJ3hrPyi`E@`+S;Te5r1fQJdkHP^<7+ z{vMu9@Hu`N-&M?VgI_sLj_R0!t(6{IwtUn#h_iJqBE^CAh*K9c^>o-E1ed2Z3w=K5P z_PDju9Oq1v&96TNf$_7H9ZhDo1D~1rXKkaA0s|1)j>*Kl1 z+ho+V(soSWUuo7y#jc4Nq--+N<>TE>%3qUti6kzZWZfnm37trG6br2JjlH!Um_m3v zY<{!RwnaNWuUg!Bb3Qq~T{(2@c;opWy4a8zu(s)23vzEg;qBU8)5&&1w5>m7+_QY< zdI8%uUs#}oS-W5t^F60e!X|0ku~^@i55YGml#QN}U8b|;2|L*CvcRJuFRYc5^rgZ_ z>ko{BMqu_w1#&RoiY2n|a!dGDaL^wdq+?96)wSKhfHgLS**;hr94yoL0hq;ZvsNSg z_F#FyJ{g@443ayO1qsSA!X?|(7pRHRhukSdP(P}Q7 z*=`QoH@5rBi%W~mdL?G~V^f%23#T)pEh8$^HFu5V>~N+lY{hGJR+_dOU`B3jntdmL z5H2k)O1_c#__+yjfkAMk)g%J4@qWg|)vq598C;iR1J8koxNT6Dtg`8N=J+~mo@-?b zJqf&C&vv(188?eta*~s=ah#A)Q zgs>cGP_v!-ff(aQ^GVNaTg_~}2P0!zR%#J3N&P1m&?A0{G^x6Fd1 zLY2BEoFLKEGTYBAn2{BhaP8Dy+D+;=Lj9M?5J()EtUgTIn5{asl3d8~b}W%m{3n0p zaPDJj7h5qQDh#?|xge+wG4K0yWMk`%I%u+uvEyD~R(-2Z@+=MZXs3C(mj%}E!8q0u zM#!80pZiOApE;>)mn{!MZ@Oc$vo88W8UJ%wPYZSuoF9&cWQ=$`QbXH?XNtYf`cr6j zeBh(5Jlu`tn!NRM5ghCqu!@NlM15J--{`by&Y|AO`K0#`JaY+6wYjFxD14Hr2Bpq*7fNEV~_R z8RKSPCfu?ipYO1(ha}E$pTu-XcTZqXBTm9UZJH85FlL$JgMyZL?v??4d139^!5-E8 zz=YnMZwQCx_CAZpJA0&Ym;r=~F59sP31CaDy+qlh7M;5m5YUQ5ea*&}+3lLm8tbK= zfhaUNANr^h__01TtZM)sv2LGi~|tcKTE_L|8q!ypn*gV zF*5)k2s$LNq4CJt3`7RB{##p#7a?eJu=Gj1m;@>bQi(UwI`Qxv_`>3y5b~7C9%Cfaf+;E!5aY6nScCf(sN7^uv~9w98wsT#0_s?X1wJSqTp`>%|LQ3 z7CYJ(7KGae1a*LXJi_B7Vm`J@@R_7NhDSTL<48nGIFwL3Kq%+ZGQtc9Ypd@d5`#d0?AvggNMNU4=C)6X^q7;5tIkmY~x_5zSwZA=Lkiq1OplaIvDa( z@4}hPuillOXMss@aTl{E0OKyEetY)O@(Hy5-{s+a;~e35lkrNpc^-eH=?8O{tlK}# z7%9amma|(Y#p)FE&UG+%<=k(>M{vFtbCJr|9NCq%C@&Fpq_)>rg^HGT6-D}?dM>&A ze?TQr0yR_)wT^~tk@`wS_DBmABNw98&_k-{!y?K;m_u0%b(Ezr&y~I+J`T#A%7ik= zhXr|mi|z-7FpoYHVF6_|n8aNH^H1UK0#{H@%kpAaMtvq!Iy2&D!KI^Fo;$|sVF|78 zg%c>}@N7=3b6W9oSV4IOEd|jGt{&1n*SPXT39b+8wLB%E)JOjkQ~QUX>@P6{V4Gf( zyePMN!a{b-s z%ov%|k1E5kEh=Y0P*l#2Jen8@g`#2-h(wy(i*ndsl$VMW*wjdb5~HlxY02v^MDnV6;GJu0qHag~ZoRD4LqO)9=e#YZT@c@2YX0kbI|#AE2|il@*^*4LL^TpK$paih{O(>+~+po3Twp(ht??u;i|2p+E`M zKt0s_sQ{VQqgY;j!>#tO)+t6TSKDD*|AD*|s3i4DGB>>HuNseNHZ6S?yFsKzE z^axK0e77x8#DYIAn133>15fkr~}J} z>3mXTO|L>DN@_*NrOm3kcHwhjMHj7uVki-WY%TKqD-AfMFepJfNYkHl9d%mw zLbksgo|l7Zv|c<^f2#cDUk@swJ^-%h=$#p0lUzJYnCn~uzEOEmw&3j=dd$+ixJpv; z%HnTT#qG$E?*RqnlaW9t*kkd!GN^`m;2V_56Cj`;gC2~yjQy$NAHxbS&p|q$X{hIq zu7KLfa55}V4LU$|^nHe&poBPbwQ~)aswiiK^m8q^esqItyb@0EiAz$Gj@8QwpTO!m zR(~I3N*EzI1L`KYc0~#G>k2fafctnq`2kQ^r-ZX3G*)`Pi@TeDqmu5$J4O9+@WIhd zUOi$!T$9HdVKTQQ+a{@vETgIfABM$46{U8lKGQI2DJ*tA!YuOCl3kS0{%Ht}kx#R@vES34{i-%$OcCFVw7Jo|9k#7+Mh{TVnz}sden!;;?Ez3y#PgH^f@CXx2fEH=JW$`if)7u_k z)g2l~zFoSVs3bFjJ!dbv5ChNQJb5{+MfsrHGoD8iFvx_^4Ao&&phi(Gr&VEK;9ETCf-uVv?gg!U34; z9Hu#GsqbSWC3pv4prVzA9#qdwYXx-%e+3|#0x(UbFa@7FgR7+K>NLLTei}Wfjux$o zmXbDy=T-FA)fxS!HjN(W53~vokgKY*=r@z2S)~W~-nbVdM10yUjiD(*AsK=t$&>o2 z?XQn{%?#xvxzg-(-VOO|VSf3Md`n=UAoqBJkZ@w(s3of|NS%QIF0;Hk&*!`T8IddZsih%?gWE71g~;jdqp9- zbkqop^E`J%E=Y+%KVa-{ve&KYn=y)u+Yord_%^+Mqy~CZ9YcG(HlQbaR#0c_WQJwD znF>HN3q_mpn|(5QqZ7uqyP4ul{73*<$Y!eVO$H3S?QtJTahXAp784SZ#gzO08LN&n zkk&gGj79Y1FVZFH?MAv@x*XfI1>QWjESxiCdL4&cMT(~DwPI{JDc%@vMclw`RC!9# zi;Quk0TO2&IZ4G19Xa8xN?}ed=+pmk7Enu zWz4-M=oe68f~srlt8tEMRV>i5(=@eA$Ie(;mQF=PGI`Uzw|1De;o76)Wm=RVI;YQ_(e~IqIV+je3^S5M<(H z(nn@qWX|P`{^_qMbSpC!!sUgjk}mpnGJjX3_*yYl-@JiE1rTH9)miQ0=4*sCbF`dWnjcs0dK; z4XP&D=^E7HCmq0q%h8=9tf~$pJJm?h5X~P*vMySp4ezdq#TvXfg!i2EI#<}M9<>`! z2j7lUotm`BKb6Hu8a07*I7l--80;VJOC8Wmw|QA^Lw(yX6nIkU?Pn8nQsgdIlqMaen&W=9kH`4{9lbp^X{NWziH)(wYOy{n z_7F>AU}CCJF)MY~A%RI(_n+VxqJ2T1gMjA5&#!g^2<$f50%8Jm20BMLevAR+G@#1HkZi|(R3 zBb7L21p2!uWoBM`%+kGRT15{;muNv4=qcF))(Ax%MQvr zxhuHah;6U5lsU=2 zJ0d{@cylCmBem)8e6jmfy$-9ZH^B6$dK3NSvHxEm9P$80=uI%UePFQ9h=!EW7&@cg z#fcu+HtOYA@sT_))Jw;^LJ`{_ACJn3!WongCJEd%mpH*W*KT}Xh;b(O3$s^@bKy?F zU6nSdhkK=4ZBtwy11M@VBDd6Cz8>p!m($Kn70 literal 0 HcmV?d00001 From 343509c8bd0c0cdae7cb05f09f79464b7bb8c109 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 7 Aug 2023 16:03:36 +0000 Subject: [PATCH 003/152] Initial playing --- .../functions/testing_TV_warmstart.ipynb | 2333 +++++++++++++++++ .../ApproximateGradientSumFunction.py | 161 ++ .../cil/optimisation/operators/test_SGD.ipynb | 223 ++ 3 files changed, 2717 insertions(+) create mode 100644 Wrappers/Python/cil/optimisation/functions/testing_TV_warmstart.ipynb create mode 100644 Wrappers/Python/cil/optimisation/operators/ApproximateGradientSumFunction.py create mode 100644 Wrappers/Python/cil/optimisation/operators/test_SGD.ipynb diff --git a/Wrappers/Python/cil/optimisation/functions/testing_TV_warmstart.ipynb b/Wrappers/Python/cil/optimisation/functions/testing_TV_warmstart.ipynb new file mode 100644 index 0000000000..3ff5241292 --- /dev/null +++ b/Wrappers/Python/cil/optimisation/functions/testing_TV_warmstart.ipynb @@ -0,0 +1,2333 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "d304d2b3", + "metadata": {}, + "outputs": [], + "source": [ + "# -*- coding: utf-8 -*-\n", + "# Copyright 2019 - 2022 United Kingdom Research and Innovation\n", + "# Copyright 2019 - 2022 The University of Manchester\n", + "#\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "#\n", + "# Authored by: Evangelos Papoutsellis (UKRI-STFC)\n", + "# Gemma Fardell (UKRI-STFC)\n", + "# Laura Murgatroyd (UKRI-STFC) " + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "c06fd185-0bbb-48c1-ba6c-ac61cad8266b", + "metadata": {}, + "source": [ + "# Primal Dual Hybrid Gradient Algorithm\n", + "\n", + "In this demo, we learn how to use the **Primal Dual Hybrid Algorithm (PDHG)** introduced by [Chambolle & Pock](https://hal.archives-ouvertes.fr/hal-00490826/document) for Tomography Reconstruction. We will solve the following minimisation problem under three different regularisation terms, i.e., \n", + "\n", + "* $\\|\\cdot\\|_{1}$ or\n", + "* Tikhonov regularisation or\n", + "* with $L=\\nabla$ and Total variation:\n", + "\n", + "\n", + "\n", + "$$\n", + "u^{*} =\\underset{u}{\\operatorname{argmin}} \\frac{1}{2} \\| \\mathcal{A} u - g\\|^{2} +\n", + "\\underbrace{\n", + "\\begin{cases}\n", + "\\alpha\\,\\|u\\|_{1}, & \\\\[10pt]\n", + "\\alpha\\,\\|\\nabla u\\|_{2}^{2}, & \\\\[10pt]\n", + "\\alpha\\,\\mathrm{TV}(u) + \\mathbb{I}_{\\{u\\geq 0\\}}(u).\n", + "\\end{cases}}_{Regularisers}\n", + "\\tag{all reg}\n", + "$$\n", + "\n", + "where,\n", + "\n", + "1. $g$ is the Acquisition data obtained from the detector.\n", + "\n", + "1. $\\mathcal{A}$ is the projection operator ( _Radon transform_ ) that maps from an image-space to an acquisition space, i.e., $\\mathcal{A} : \\mathbb{X} \\rightarrow \\mathbb{Y}, $ where $\\mathbb{X}$ is an __ImageGeometry__ and $\\mathbb{Y}$ is an __AcquisitionGeometry__.\n", + "\n", + "1. $\\alpha$: regularising parameter that measures the trade-off between the fidelity and the regulariser terms.\n", + "\n", + "1. The total variation (isotropic) is defined as $$\\mathrm{TV}(u) = \\|\\nabla u \\|_{2,1} = \\sum \\sqrt{ (\\partial_{y}u)^{2} + (\\partial_{x}u)^{2} }$$\n", + "\n", + "1. $\\mathbb{I}_{\\{u\\geq 0\\}}(u) : = \n", + "\\begin{cases}\n", + "0, & \\text{ if } u\\geq 0\\\\\n", + "\\infty , & \\text{ otherwise}\n", + "\\,\n", + "\\end{cases}\n", + "$, $\\quad$ a non-negativity constraint for the minimiser $u$." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "id": "385c848a-9d9a-48ff-b029-a42e90e4cb2c", + "metadata": {}, + "source": [ + "# Learning objectives\n", + "\n", + "- Load the data using the CIL reader: `ZEISSDataReader`.\n", + "- Preprocess the data using the CIL processors: `Binner`, `TransmissionAbsorptionConverter`.\n", + "- Run FBP and SIRT reconstructions.\n", + "- Setup PDHG for 3 different regularisers: $L^{1}$, Tikhonov and Total variation.\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "We first import all the necessary libraries for this notebook.\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f731d970-d6ce-489a-bf93-7888cc855a60", + "metadata": {}, + "outputs": [], + "source": [ + "# Import libraries\n", + "\n", + "from cil.framework import BlockDataContainer\n", + "\n", + "from cil.optimisation.functions import L2NormSquared, L1Norm, BlockFunction, MixedL21Norm, IndicatorBox\n", + "from TotalVariation import TotalVariation\n", + "\n", + "from cil.optimisation.operators import GradientOperator, BlockOperator\n", + "from cil.optimisation.algorithms import PDHG, SIRT\n", + "\n", + "from cil.plugins.astra.operators import ProjectionOperator\n", + "from cil.plugins.astra.processors import FBP\n", + "\n", + "from cil.plugins.ccpi_regularisation.functions import FGP_TV\n", + "\n", + "from cil.utilities.display import show2D, show1D, show_geometry\n", + "from cil.utilities.jupyter import islicer\n", + "\n", + "from cil.io import ZEISSDataReader\n", + "\n", + "from cil.processors import Binner, TransmissionAbsorptionConverter, Slicer\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import numpy as np\n", + "\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "id": "36dc5a6d-c4e9-4ece-9f37-cde82dc93964", + "metadata": {}, + "source": [ + "# Data information\n", + "\n", + "In this demo, we use the **Walnut** found in [Jørgensen_et_all](https://zenodo.org/record/4822516#.YLXyAJMzZp8). In total, there are 6 individual micro Computed Tomography datasets in the native Zeiss TXRM/TXM format. The six datasets were acquired at the 3D Imaging Center at Technical University of Denmark in 2014 (HDTomo3D in 2016) as part of the ERC-funded project High-Definition Tomography (HDTomo) headed by Prof. Per Christian Hansen. \n", + "\n", + "This example requires the dataset walnut.zip from https://zenodo.org/record/4822516 :\n", + "\n", + " - https://zenodo.org/record/4822516/files/walnut.zip\n", + "\n", + "If running locally please download the data and update the `path` variable below." + ] + }, + { + "cell_type": "markdown", + "id": "732c5f6b-6fd4-43ea-b5f6-796632f62528", + "metadata": {}, + "source": [ + "## Load walnut data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ce2c36aa-1231-4669-9486-197f9332fe2e", + "metadata": {}, + "outputs": [], + "source": [ + "path = '../../../data/'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d64a1b3a", + "metadata": {}, + "outputs": [], + "source": [ + "reader = ZEISSDataReader()\n", + "filename = os.path.join(path, \"valnut_tomo-A.txrm\")\n", + "data3D = ZEISSDataReader(file_name=filename).read()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0fd50459", + "metadata": {}, + "outputs": [], + "source": [ + "# reorder data to match default order for Astra/Tigre operator\n", + "data3D.reorder('astra')\n", + "\n", + "# Get Image and Acquisition geometries\n", + "ag3D = data3D.geometry\n", + "ig3D = ag3D.get_ImageGeometry()" + ] + }, + { + "cell_type": "markdown", + "id": "2f97e39e-12db-4eae-9de5-cc31e667490e", + "metadata": {}, + "source": [ + "### Acquisition and Image geometry information" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ece32bb6-5066-4f7c-b6b6-8edc62ecb817", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3D Cone-beam tomography\n", + "System configuration:\n", + "\tSource position: [ 0. , -105.05081177, 0. ]\n", + "\tRotation axis position: [0., 0., 0.]\n", + "\tRotation axis direction: [0., 0., 1.]\n", + "\tDetector position: [ 0. , 45.08757401, 0. ]\n", + "\tDetector direction x: [1., 0., 0.]\n", + "\tDetector direction y: [0., 0., 1.]\n", + "Panel configuration:\n", + "\tNumber of pixels: [1024 1024]\n", + "\tPixel size: [0.0658543 0.0658543]\n", + "\tPixel origin: bottom-left\n", + "Channel configuration:\n", + "\tNumber of channels: 1\n", + "Acquisition description:\n", + "\tNumber of positions: 1601\n", + "\tAngles 0-20 in radians:\n", + "[-3.1415665, -3.1377017, -3.1337626, -3.1298182, -3.125836 , -3.1219127,\n", + " -3.1180956, -3.1140666, -3.1101887, -3.1062822, -3.1022923, -3.0984268,\n", + " -3.0944946, -3.0905435, -3.0865552, -3.082691 , -3.0787866, -3.074828 ,\n", + " -3.0708766, -3.0669732]\n", + "Distances in units: units distance\n" + ] + } + ], + "source": [ + "print(ag3D)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "14083f74-3490-4d18-a784-c659f2c5984b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of channels: 1\n", + "channel_spacing: 1.0\n", + "voxel_num : x1024,y1024,z1024\n", + "voxel_size : x0.04607780456542968,y0.04607780456542968,z0.04607780456542968\n", + "center : x0,y0,z0\n", + "\n" + ] + } + ], + "source": [ + "print(ig3D)" + ] + }, + { + "cell_type": "markdown", + "id": "bab54a03-3ab6-4100-a82a-45a8e807e5f1", + "metadata": {}, + "source": [ + "### Show Acquisition geometry and full 3D sinogram." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "d6b6a162-08d5-4c28-9a2b-a06091747f0a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "show_geometry(ag3D)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fc29dd0a-2f27-4a89-8a49-9733d9453b86", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "show2D(data3D, slice_list = [('vertical',512), ('angle',800), ('horizontal',512)], cmap=\"inferno\", num_cols=3, size=(15,15))" + ] + }, + { + "cell_type": "markdown", + "id": "dc945eb5-17d9-476e-b4dd-998b9b90d51e", + "metadata": {}, + "source": [ + "### Slice through projections" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e6e19c5d-0724-46a2-907c-d9e86b24ee91", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "f76868f2e54240fc904cdf8eca2a7d43", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(Output(), Box(children=(Play(value=800, interval=500, max=1600), VBox(children=(Label(value='Sl…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "islicer(data3D, direction=1, cmap=\"inferno\")" + ] + }, + { + "cell_type": "markdown", + "id": "5afa53ea-6723-44ef-a803-587630568ec4", + "metadata": {}, + "source": [ + "### For demonstration purposes, we extract the central slice and select only 160 angles from the total 1601 angles.\n", + "\n", + "1. We use the `Slicer` processor with step size of 10.\n", + "1. We use the `Binner` processor to crop and bin the acquisition data in order to reduce the field of view.\n", + "1. We use the `TransmissionAbsorptionConverter` to convert from transmission measurements to absorption based on the Beer-Lambert law.\n", + "\n", + "**Note:** To avoid circular artifacts in the reconstruction space, we subtract the mean value of a background Region of interest (ROI), i.e., ROI that does not contain the walnut." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3dae73ff-165f-4ac3-990a-e5584a627e9f", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract vertical slice\n", + "data2D = data3D.get_slice(vertical='centre')\n", + "\n", + "# Select every 10 angles\n", + "sliced_data = Slicer(roi={'angle':(0,1600,10)})(data2D)\n", + "\n", + "# Reduce background regions\n", + "binned_data = Binner(roi={'horizontal':(120,-120,2)})(sliced_data)\n", + "\n", + "# Create absorption data \n", + "absorption_data = TransmissionAbsorptionConverter()(binned_data) \n", + "\n", + "# Remove circular artifacts\n", + "absorption_data -= np.mean(absorption_data.as_array()[80:100,0:30])\n", + "\n", + "#Add some gaussian noise \n", + "absorption_data+=np.random.normal(0, 0.1*np.mean(absorption_data))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4165bcfc-1e28-44ea-bfe3-f85648bc4dc8", + "metadata": {}, + "outputs": [], + "source": [ + "# Get Image and Acquisition geometries for one slice\n", + "ag2D = absorption_data.geometry\n", + "ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian')\n", + "ig2D = ag2D.get_ImageGeometry()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5fdafdab-19f2-499a-8b6b-acfdaa83bf95", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Acquisition Geometry 2D: (160, 392) with labels ('angle', 'horizontal')\n", + " Image Geometry 2D: (392, 392) with labels ('horizontal_y', 'horizontal_x')\n" + ] + } + ], + "source": [ + "print(\" Acquisition Geometry 2D: {} with labels {}\".format(ag2D.shape, ag2D.dimension_labels))\n", + "print(\" Image Geometry 2D: {} with labels {}\".format(ig2D.shape, ig2D.dimension_labels))" + ] + }, + { + "cell_type": "markdown", + "id": "3156de74-773a-4ec9-aadb-1f7d31a435b5", + "metadata": {}, + "source": [ + "### Define Projection Operator \n", + "We can define our projection operator using our __astra__ __plugin__ that wraps the Astra-Toolbox library." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e4919986-1aad-4e2d-9af3-68d7b1d685ea", + "metadata": {}, + "outputs": [], + "source": [ + "A = ProjectionOperator(ig2D, ag2D, device = \"gpu\")" + ] + }, + { + "cell_type": "markdown", + "id": "a2232e53-a927-461b-9e95-2c9f322257b7", + "metadata": {}, + "source": [ + "## PDHG - implicit TV (using CIL)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "35b0e04b-4393-46d5-b8a3-bbf6161feeb8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 200 0.000 8.98686e+03\n", + " 5 200 3.491 1.28336e+02\n", + " 10 200 3.175 6.33684e+01\n", + " 15 200 3.018 4.92200e+01\n", + " 20 200 2.928 3.95762e+01\n", + " 25 200 2.878 3.11324e+01\n", + " 30 200 2.778 2.72461e+01\n", + " 35 200 2.752 2.57557e+01\n", + " 40 200 2.725 2.39985e+01\n", + " 45 200 2.681 2.31592e+01\n", + " 50 200 2.695 2.27356e+01\n", + " 55 200 2.743 2.23128e+01\n", + " 60 200 2.732 2.20016e+01\n", + " 65 200 2.728 2.18614e+01\n", + " 70 200 2.720 2.17656e+01\n", + " 75 200 2.720 2.16970e+01\n", + " 80 200 2.727 2.16574e+01\n", + " 85 200 2.737 2.16201e+01\n", + " 90 200 2.737 2.15945e+01\n", + " 95 200 2.707 2.15802e+01\n", + " 100 200 2.706 2.15705e+01\n", + " 105 200 2.699 2.15634e+01\n", + " 110 200 2.723 2.15575e+01\n", + " 115 200 2.727 2.15534e+01\n", + " 120 200 2.729 2.15506e+01\n", + " 125 200 2.722 2.15484e+01\n", + " 130 200 2.716 2.15468e+01\n", + " 135 200 2.722 2.15457e+01\n", + " 140 200 2.669 2.15449e+01\n", + " 145 200 2.615 2.15441e+01\n", + " 150 200 2.565 2.15435e+01\n", + " 155 200 2.513 2.15431e+01\n", + " 160 200 2.466 2.15427e+01\n", + " 165 200 2.422 2.15424e+01\n", + " 170 200 2.381 2.15422e+01\n", + " 175 200 2.342 2.15420e+01\n", + " 180 200 2.304 2.15418e+01\n", + " 185 200 2.269 2.15416e+01\n", + " 190 200 2.235 2.15414e+01\n", + " 195 200 2.204 2.15413e+01\n", + " 200 200 2.175 2.15411e+01\n", + "-------------------------------------------------------\n", + " 200 200 2.175 2.15411e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "alpha_tv=0.0005\n", + "\n", + "F = 0.5 * L2NormSquared(b=absorption_data)\n", + "G = alpha_tv * TotalVariation(max_iteration=100, lower=0.)\n", + "K = A\n", + "# Setup and run PDHG\n", + "pdhg_tv_implicit_cil = PDHG(f = F, g = G, operator = K,\n", + " max_iteration = 200,\n", + " update_objective_interval = 5)\n", + "pdhg_tv_implicit_cil.run(verbose=1)" + ] + }, + { + "cell_type": "markdown", + "id": "114e68b6", + "metadata": {}, + "source": [ + "## PDHG - implicit TV (using CIL) with warm start " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "59c06af0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 200 0.000 8.98686e+03\n", + " 5 200 0.068 1.28190e+02\n", + " 10 200 0.067 6.31339e+01\n", + " 15 200 0.067 4.90806e+01\n", + " 20 200 0.068 3.93596e+01\n", + " 25 200 0.067 3.10063e+01\n", + " 30 200 0.066 2.71367e+01\n", + " 35 200 0.066 2.56700e+01\n", + " 40 200 0.066 2.39577e+01\n", + " 45 200 0.066 2.31261e+01\n", + " 50 200 0.066 2.27055e+01\n", + " 55 200 0.066 2.22953e+01\n", + " 60 200 0.066 2.19916e+01\n", + " 65 200 0.066 2.18526e+01\n", + " 70 200 0.066 2.17590e+01\n", + " 75 200 0.066 2.16926e+01\n", + " 80 200 0.066 2.16535e+01\n", + " 85 200 0.066 2.16174e+01\n", + " 90 200 0.066 2.15928e+01\n", + " 95 200 0.066 2.15790e+01\n", + " 100 200 0.067 2.15696e+01\n", + " 105 200 0.067 2.15628e+01\n", + " 110 200 0.067 2.15572e+01\n", + " 115 200 0.067 2.15533e+01\n", + " 120 200 0.066 2.15506e+01\n", + " 125 200 0.066 2.15484e+01\n", + " 130 200 0.066 2.15469e+01\n", + " 135 200 0.066 2.15458e+01\n", + " 140 200 0.066 2.15449e+01\n", + " 145 200 0.066 2.15442e+01\n", + " 150 200 0.066 2.15436e+01\n", + " 155 200 0.066 2.15432e+01\n", + " 160 200 0.066 2.15428e+01\n", + " 165 200 0.066 2.15425e+01\n", + " 170 200 0.066 2.15422e+01\n", + " 175 200 0.066 2.15420e+01\n", + " 180 200 0.066 2.15418e+01\n", + " 185 200 0.066 2.15417e+01\n", + " 190 200 0.066 2.15415e+01\n", + " 195 200 0.066 2.15413e+01\n", + " 200 200 0.066 2.15412e+01\n", + "-------------------------------------------------------\n", + " 200 200 0.066 2.15412e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "F = 0.5 * L2NormSquared(b=absorption_data)\n", + "G = alpha_tv * TotalVariation(max_iteration=5, lower=0., warmstart=True)\n", + "K = A\n", + "# Setup and run PDHG\n", + "pdhg_tv_implicit_cil_warm_start = PDHG(f = F, g = G, operator = K,\n", + " max_iteration = 200,\n", + " update_objective_interval = 5)\n", + "pdhg_tv_implicit_cil_warm_start.run(verbose=1)" + ] + }, + { + "cell_type": "markdown", + "id": "37cf55b5", + "metadata": {}, + "source": [ + "## PDHG - implicit TV (using FGP_TV)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "9a8c0557", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 200 0.000 8.98686e+03\n", + " 5 200 0.026 1.28336e+02\n", + " 10 200 0.025 6.33683e+01\n", + " 15 200 0.024 4.92200e+01\n", + " 20 200 0.024 3.95762e+01\n", + " 25 200 0.023 3.11323e+01\n", + " 30 200 0.023 2.72460e+01\n", + " 35 200 0.023 2.57556e+01\n", + " 40 200 0.023 2.39984e+01\n", + " 45 200 0.023 2.31591e+01\n", + " 50 200 0.023 2.27356e+01\n", + " 55 200 0.023 2.23127e+01\n", + " 60 200 0.023 2.20016e+01\n", + " 65 200 0.023 2.18613e+01\n", + " 70 200 0.023 2.17655e+01\n", + " 75 200 0.023 2.16970e+01\n", + " 80 200 0.023 2.16573e+01\n", + " 85 200 0.023 2.16201e+01\n", + " 90 200 0.023 2.15944e+01\n", + " 95 200 0.023 2.15802e+01\n", + " 100 200 0.023 2.15704e+01\n", + " 105 200 0.023 2.15633e+01\n", + " 110 200 0.023 2.15574e+01\n", + " 115 200 0.023 2.15533e+01\n", + " 120 200 0.023 2.15506e+01\n", + " 125 200 0.023 2.15484e+01\n", + " 130 200 0.023 2.15467e+01\n", + " 135 200 0.023 2.15456e+01\n", + " 140 200 0.023 2.15448e+01\n", + " 145 200 0.023 2.15441e+01\n", + " 150 200 0.022 2.15435e+01\n", + " 155 200 0.023 2.15430e+01\n", + " 160 200 0.023 2.15427e+01\n", + " 165 200 0.023 2.15423e+01\n", + " 170 200 0.023 2.15421e+01\n", + " 175 200 0.022 2.15419e+01\n", + " 180 200 0.022 2.15417e+01\n", + " 185 200 0.022 2.15416e+01\n", + " 190 200 0.022 2.15414e+01\n", + " 195 200 0.022 2.15412e+01\n", + " 200 200 0.022 2.15411e+01\n", + "-------------------------------------------------------\n", + " 200 200 0.022 2.15411e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "F = 0.5 * L2NormSquared(b=absorption_data)\n", + "G = (alpha_tv/ig2D.voxel_size_y) * FGP_TV(max_iteration=100, nonnegativity = True, device = 'gpu') \n", + "K = A\n", + "\n", + "# Setup and run PDHG\n", + "pdhg_tv_implicit_regtk = PDHG(f = F, g = G, operator = K,\n", + " max_iteration = 200,\n", + " update_objective_interval = 5)\n", + "pdhg_tv_implicit_regtk.run(verbose=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b78c87bb-9dcf-4d40-b41e-b7118c3ac120", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Absolute error between Regtk solution and warm start solution: 0.0007760412\n", + "[8986.8583984375, 128.33596608042717, 63.368345975875854, 49.2199912071228, 39.576210379600525, 31.132325649261475, 27.246046543121338, 25.755617260932922, 23.998438477516174, 23.1591135263443, 22.735593914985657, 22.3127281665802, 22.001588225364685, 21.861290454864502, 21.76551902294159, 21.696985363960266, 21.657320737838745, 21.62007427215576, 21.59442889690399, 21.5801739692688, 21.570448875427246, 21.56331193447113, 21.557433605194092, 21.553338766098022, 21.550590753555298, 21.548352241516113, 21.546719312667847, 21.5456383228302, 21.544804334640503, 21.54409098625183, 21.543490767478943, 21.543021321296692, 21.54265320301056, 21.542346358299255, 21.542125344276428, 21.54191493988037, 21.541720867156982, 21.54155743122101, 21.54138195514679, 21.54121685028076, 21.54105579853058]\n", + "[8986.8583984375, 128.33597006225585, 63.36835958862304, 49.220016815185545, 39.57623785400391, 31.132365951538088, 27.2461004486084, 25.755655456542968, 23.998477935791016, 23.159166763305663, 22.73563150024414, 22.312793090820314, 22.001643981933594, 21.86135662841797, 21.765576599121093, 21.69703451538086, 21.65737384033203, 21.62012516784668, 21.59448864746094, 21.580240173339845, 21.57049639892578, 21.563368591308596, 21.557487213134767, 21.553393768310546, 21.550642578125, 21.54840592956543, 21.546775329589845, 21.545701599121095, 21.544864135742188, 21.54413049316406, 21.543544692993166, 21.543082000732422, 21.542705047607424, 21.542405120849608, 21.542167541503908, 21.541965911865233, 21.54177732849121, 21.541603515625, 21.541440109252928, 21.541277618408202, 21.541126724243163]\n", + "[8986.8583984375, 128.18999746704102, 63.13393936157227, 49.08058074951172, 39.359574035644535, 31.006344329833986, 27.13668930053711, 25.66995785522461, 23.957702224731445, 23.12611491394043, 22.705514099121093, 22.29525975036621, 21.991572784423827, 21.85256228637695, 21.759012634277344, 21.69258251953125, 21.65354495239258, 21.617425872802734, 21.59281967163086, 21.578999099731444, 21.56964944458008, 21.562801879882812, 21.557206558227538, 21.553263916015624, 21.550565185546876, 21.548426391601563, 21.54688949584961, 21.545794311523437, 21.544929779052733, 21.544213775634766, 21.543643997192383, 21.543185760498048, 21.5428017578125, 21.542493743896486, 21.542242752075197, 21.54202751159668, 21.54182760620117, 21.541650970458985, 21.541484420776367, 21.54131066894531, 21.541150299072264]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Show reconstruction and ground truth\n", + "show2D([pdhg_tv_implicit_regtk.solution,\n", + " pdhg_tv_implicit_cil_warm_start.solution,\n", + " pdhg_tv_implicit_cil.solution,\n", + " (pdhg_tv_implicit_cil.solution-pdhg_tv_implicit_cil_warm_start.solution).abs()], \n", + " fix_range=[(0,0.055),(0,0.055),(0,0.055), None], num_cols=4,\n", + " title = ['TV (CIL)','TV (CIL - warm start)', 'TV (CCPI-RegTk)', 'CIL with/without warm start abs diff' ], \n", + " cmap = 'inferno')\n", + "\n", + "print(' Absolute error between Regtk solution and warm start solution: ', np.linalg.norm(pdhg_tv_implicit_regtk.solution.as_array()-pdhg_tv_implicit_cil_warm_start.solution.as_array()))\n", + "\n", + "\n", + "# Plot middle line profile\n", + "show1D([pdhg_tv_implicit_regtk.solution,pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil_warm_start.solution], slice_list=[('horizontal_y',int(ig2D.voxel_num_y/2))],\n", + " label = ['TV (CCPi-RegTk)','TV (CIL)', 'TV (CIL-warm start)'], title='Middle Line Profiles')\n", + "\n", + "print(pdhg_tv_implicit_regtk.objective)\n", + "print(pdhg_tv_implicit_cil.objective)\n", + "print(pdhg_tv_implicit_cil_warm_start.objective)\n", + "\n", + "plt.figure()\n", + "iter_range = np.arange(0,201,5)\n", + "plt.semilogy(iter_range, pdhg_tv_implicit_regtk.objective, label='implicit PDHG (Regtk)')\n", + "plt.semilogy(iter_range, pdhg_tv_implicit_cil.objective, label='implicit PDHG (CIL)')\n", + "plt.semilogy(iter_range, pdhg_tv_implicit_cil_warm_start.objective, label='implicit PDHG (CIL Warm start)')\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel('Objective function')\n", + "plt.ylim(71,73)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8fcc4831", + "metadata": {}, + "source": [ + "# Trying different number of inner iterations for warm start " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad6242be-de86-4ae4-9e9a-a8c33dacce58", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 400 0.000 7.40475e+03\n", + " 5 400 0.022 1.40917e+02\n", + " 10 400 0.022 5.86010e+01\n", + " 15 400 0.022 4.84877e+01\n", + " 20 400 0.022 4.33890e+01\n", + " 25 400 0.022 3.83292e+01\n", + " 30 400 0.022 3.42867e+01\n", + " 35 400 0.022 3.32200e+01\n", + " 40 400 0.022 3.25358e+01\n", + " 45 400 0.022 3.19039e+01\n", + " 50 400 0.022 3.16158e+01\n", + " 55 400 0.022 3.15406e+01\n", + " 60 400 0.022 3.14002e+01\n", + " 65 400 0.022 3.12791e+01\n", + " 70 400 0.022 3.12358e+01\n", + " 75 400 0.022 3.12142e+01\n", + " 80 400 0.022 3.11905e+01\n", + " 85 400 0.022 3.11765e+01\n", + " 90 400 0.022 3.11676e+01\n", + " 95 400 0.022 3.11601e+01\n", + " 100 400 0.022 3.11562e+01\n", + " 105 400 0.022 3.11546e+01\n", + " 110 400 0.022 3.11528e+01\n", + " 115 400 0.022 3.11515e+01\n", + " 120 400 0.022 3.11509e+01\n", + " 125 400 0.022 3.11504e+01\n", + " 130 400 0.022 3.11498e+01\n", + " 135 400 0.022 3.11495e+01\n", + " 140 400 0.022 3.11490e+01\n", + " 145 400 0.022 3.11488e+01\n", + " 150 400 0.022 3.11488e+01\n", + " 155 400 0.022 3.11487e+01\n", + " 160 400 0.022 3.11488e+01\n", + " 165 400 0.022 3.11488e+01\n", + " 170 400 0.022 3.11488e+01\n", + " 175 400 0.022 3.11488e+01\n", + " 180 400 0.022 3.11489e+01\n", + " 185 400 0.022 3.11489e+01\n", + " 190 400 0.022 3.11489e+01\n", + " 195 400 0.022 3.11488e+01\n", + " 200 400 0.022 3.11488e+01\n", + " 205 400 0.022 3.11488e+01\n", + " 210 400 0.022 3.11488e+01\n", + " 215 400 0.022 3.11488e+01\n", + " 220 400 0.022 3.11488e+01\n", + " 225 400 0.022 3.11489e+01\n", + " 230 400 0.022 3.11489e+01\n", + " 235 400 0.022 3.11488e+01\n", + " 240 400 0.022 3.11489e+01\n", + " 245 400 0.022 3.11489e+01\n", + " 250 400 0.022 3.11489e+01\n", + " 255 400 0.022 3.11488e+01\n", + " 260 400 0.022 3.11488e+01\n", + " 265 400 0.022 3.11488e+01\n", + " 270 400 0.022 3.11488e+01\n", + " 275 400 0.022 3.11488e+01\n", + " 280 400 0.022 3.11488e+01\n", + " 285 400 0.022 3.11488e+01\n", + " 290 400 0.022 3.11488e+01\n", + " 295 400 0.022 3.11488e+01\n", + " 300 400 0.022 3.11488e+01\n", + " 305 400 0.022 3.11488e+01\n", + " 310 400 0.022 3.11488e+01\n", + " 315 400 0.022 3.11488e+01\n", + " 320 400 0.022 3.11488e+01\n", + " 325 400 0.022 3.11488e+01\n", + " 330 400 0.022 3.11488e+01\n", + " 335 400 0.022 3.11488e+01\n", + " 340 400 0.022 3.11488e+01\n", + " 345 400 0.022 3.11488e+01\n", + " 350 400 0.022 3.11488e+01\n", + " 355 400 0.022 3.11488e+01\n", + " 360 400 0.022 3.11488e+01\n", + " 365 400 0.022 3.11488e+01\n", + " 370 400 0.022 3.11488e+01\n", + " 375 400 0.022 3.11488e+01\n", + " 380 400 0.022 3.11488e+01\n", + " 385 400 0.022 3.11488e+01\n", + " 390 400 0.022 3.11488e+01\n", + " 395 400 0.022 3.11488e+01\n", + " 400 400 0.022 3.11488e+01\n", + "-------------------------------------------------------\n", + " 400 400 0.022 3.11488e+01\n", + "Stop criterion has been reached.\n", + "\n", + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 400 0.000 7.40475e+03\n", + " 5 400 1.048 1.40917e+02\n", + " 10 400 1.049 5.86013e+01\n", + " 15 400 1.045 4.84881e+01\n", + " 20 400 1.038 4.33897e+01\n", + " 25 400 1.034 3.83305e+01\n", + " 30 400 1.026 3.42885e+01\n", + " 35 400 1.023 3.32218e+01\n", + " 40 400 1.026 3.25375e+01\n", + " 45 400 1.029 3.19057e+01\n", + " 50 400 1.023 3.16179e+01\n", + " 55 400 1.020 3.15427e+01\n", + " 60 400 1.018 3.14024e+01\n", + " 65 400 1.018 3.12812e+01\n", + " 70 400 1.022 3.12379e+01\n", + " 75 400 1.024 3.12164e+01\n", + " 80 400 1.023 3.11926e+01\n", + " 85 400 1.024 3.11785e+01\n", + " 90 400 1.026 3.11696e+01\n", + " 95 400 1.028 3.11621e+01\n", + " 100 400 1.028 3.11582e+01\n", + " 105 400 1.079 3.11566e+01\n", + " 110 400 1.142 3.11548e+01\n", + " 115 400 1.197 3.11535e+01\n", + " 120 400 1.253 3.11529e+01\n", + " 125 400 1.298 3.11523e+01\n", + " 130 400 1.342 3.11518e+01\n", + " 135 400 1.375 3.11514e+01\n", + " 140 400 1.400 3.11511e+01\n", + " 145 400 1.386 3.11508e+01\n", + " 150 400 1.373 3.11508e+01\n", + " 155 400 1.360 3.11507e+01\n", + " 160 400 1.349 3.11507e+01\n", + " 165 400 1.340 3.11508e+01\n", + " 170 400 1.331 3.11508e+01\n", + " 175 400 1.320 3.11508e+01\n", + " 180 400 1.312 3.11508e+01\n", + " 185 400 1.303 3.11508e+01\n", + " 190 400 1.295 3.11508e+01\n", + " 195 400 1.288 3.11508e+01\n", + " 200 400 1.281 3.11508e+01\n", + " 205 400 1.275 3.11508e+01\n", + " 210 400 1.269 3.11508e+01\n", + " 215 400 1.265 3.11508e+01\n", + " 220 400 1.259 3.11508e+01\n", + " 225 400 1.254 3.11508e+01\n", + " 230 400 1.250 3.11508e+01\n", + " 235 400 1.254 3.11508e+01\n", + " 240 400 1.300 3.11508e+01\n", + " 245 400 1.322 3.11508e+01\n", + " 250 400 1.342 3.11508e+01\n", + " 255 400 1.363 3.11508e+01\n", + " 260 400 1.384 3.11508e+01\n", + " 265 400 1.403 3.11508e+01\n", + " 270 400 1.429 3.11508e+01\n", + " 275 400 1.451 3.11508e+01\n", + " 280 400 1.469 3.11508e+01\n", + " 285 400 1.487 3.11508e+01\n", + " 290 400 1.505 3.11508e+01\n", + " 295 400 1.526 3.11508e+01\n", + " 300 400 1.545 3.11508e+01\n", + " 305 400 1.557 3.11508e+01\n", + " 310 400 1.570 3.11508e+01\n", + " 315 400 1.589 3.11508e+01\n", + " 320 400 1.602 3.11508e+01\n", + " 325 400 1.615 3.11508e+01\n", + " 330 400 1.624 3.11508e+01\n", + " 335 400 1.633 3.11508e+01\n", + " 340 400 1.641 3.11508e+01\n", + " 345 400 1.650 3.11508e+01\n", + " 350 400 1.659 3.11508e+01\n", + " 355 400 1.664 3.11508e+01\n", + " 360 400 1.672 3.11508e+01\n", + " 365 400 1.685 3.11508e+01\n", + " 370 400 1.695 3.11508e+01\n", + " 375 400 1.704 3.11508e+01\n", + " 380 400 1.711 3.11508e+01\n", + " 385 400 1.720 3.11508e+01\n", + " 390 400 1.726 3.11508e+01\n", + " 395 400 1.738 3.11508e+01\n", + " 400 400 1.748 3.11508e+01\n", + "-------------------------------------------------------\n", + " 400 400 1.748 3.11508e+01\n", + "Stop criterion has been reached.\n", + "\n", + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 400 0.000 7.40475e+03\n", + " 5 400 0.039 7.40475e+03\n", + " 10 400 0.026 7.40475e+03\n", + " 15 400 0.031 7.40475e+03\n", + " 20 400 0.032 7.40475e+03\n", + " 25 400 0.030 7.40475e+03\n", + " 30 400 0.032 7.40475e+03\n", + " 35 400 0.030 7.40475e+03\n", + " 40 400 0.032 7.40475e+03\n", + " 45 400 0.030 7.40475e+03\n", + " 50 400 0.031 7.40475e+03\n", + " 55 400 0.030 7.40475e+03\n", + " 60 400 0.030 7.40475e+03\n", + " 65 400 0.029 7.40475e+03\n", + " 70 400 0.028 7.40475e+03\n", + " 75 400 0.027 7.40475e+03\n", + " 80 400 0.028 7.40475e+03\n", + " 85 400 0.028 7.40475e+03\n", + " 90 400 0.027 7.40475e+03\n", + " 95 400 0.030 7.40475e+03\n", + " 100 400 0.030 7.40475e+03\n", + " 105 400 0.029 7.40475e+03\n", + " 110 400 0.028 7.40475e+03\n", + " 115 400 0.028 7.40475e+03\n", + " 120 400 0.027 7.40475e+03\n", + " 125 400 0.027 7.40475e+03\n", + " 130 400 0.027 7.40475e+03\n", + " 135 400 0.026 7.40475e+03\n", + " 140 400 0.027 7.40475e+03\n", + " 145 400 0.026 7.40475e+03\n", + " 150 400 0.026 7.40475e+03\n", + " 155 400 0.025 7.40475e+03\n", + " 160 400 0.026 7.40475e+03\n", + " 165 400 0.026 7.40475e+03\n", + " 170 400 0.026 7.40475e+03\n", + " 175 400 0.026 7.40475e+03\n", + " 180 400 0.026 7.40475e+03\n", + " 185 400 0.027 7.40475e+03\n", + " 190 400 0.027 7.40475e+03\n", + " 195 400 0.026 7.40475e+03\n", + " 200 400 0.026 7.40475e+03\n", + " 205 400 0.026 7.40475e+03\n", + " 210 400 0.026 7.40475e+03\n", + " 215 400 0.026 7.40475e+03\n", + " 220 400 0.026 7.40475e+03\n", + " 225 400 0.026 7.40475e+03\n", + " 230 400 0.026 7.40475e+03\n", + " 235 400 0.026 7.40475e+03\n", + " 240 400 0.026 7.40475e+03\n", + " 245 400 0.026 7.40475e+03\n", + " 250 400 0.026 7.40475e+03\n", + " 255 400 0.026 7.40475e+03\n", + " 260 400 0.027 7.40475e+03\n", + " 265 400 0.027 7.40475e+03\n", + " 270 400 0.027 7.40475e+03\n", + " 275 400 0.027 7.40475e+03\n", + " 280 400 0.027 7.40475e+03\n", + " 285 400 0.027 7.40475e+03\n", + " 290 400 0.027 7.40475e+03\n", + " 295 400 0.027 7.40475e+03\n", + " 300 400 0.027 7.40475e+03\n", + " 305 400 0.027 7.40475e+03\n", + " 310 400 0.027 7.40475e+03\n", + " 315 400 0.027 7.40475e+03\n", + " 320 400 0.027 7.40475e+03\n", + " 325 400 0.027 7.40475e+03\n", + " 330 400 0.027 7.40475e+03\n", + " 335 400 0.027 7.40475e+03\n", + " 340 400 0.027 7.40475e+03\n", + " 345 400 0.027 7.40475e+03\n", + " 350 400 0.027 7.40475e+03\n", + " 355 400 0.027 7.40475e+03\n", + " 360 400 0.027 7.40475e+03\n", + " 365 400 0.027 7.40475e+03\n", + " 370 400 0.027 7.40475e+03\n", + " 375 400 0.027 7.40475e+03\n", + " 380 400 0.027 7.40475e+03\n", + " 385 400 0.027 7.40475e+03\n", + " 390 400 0.027 7.40475e+03\n", + " 395 400 0.027 7.40475e+03\n", + " 400 400 0.027 7.40475e+03\n", + "-------------------------------------------------------\n", + " 400 400 0.027 7.40475e+03\n", + "Stop criterion has been reached.\n", + "\n", + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 400 0.000 7.40475e+03\n", + " 5 400 0.158 1.34114e+02\n", + " 10 400 0.170 5.71919e+01\n", + " 15 400 0.168 4.74188e+01\n", + " 20 400 0.173 4.32707e+01\n", + " 25 400 0.167 3.84927e+01\n", + " 30 400 0.165 3.43658e+01\n", + " 35 400 0.167 3.32847e+01\n", + " 40 400 0.170 3.26578e+01\n", + " 45 400 0.167 3.21251e+01\n", + " 50 400 0.167 3.18015e+01\n", + " 55 400 0.166 3.16845e+01\n", + " 60 400 0.163 3.15549e+01\n", + " 65 400 0.162 3.14120e+01\n", + " 70 400 0.163 3.13045e+01\n", + " 75 400 0.163 3.12693e+01\n", + " 80 400 0.163 3.12513e+01\n", + " 85 400 0.164 3.12159e+01\n", + " 90 400 0.163 3.11925e+01\n", + " 95 400 0.161 3.11819e+01\n", + " 100 400 0.162 3.11726e+01\n", + " 105 400 0.160 3.11654e+01\n", + " 110 400 0.158 3.11605e+01\n", + " 115 400 0.159 3.11562e+01\n", + " 120 400 0.160 3.11528e+01\n", + " 125 400 0.161 3.11501e+01\n", + " 130 400 0.161 3.11482e+01\n", + " 135 400 0.160 3.11467e+01\n", + " 140 400 0.159 3.11456e+01\n", + " 145 400 0.159 3.11449e+01\n", + " 150 400 0.159 3.11442e+01\n", + " 155 400 0.160 3.11435e+01\n", + " 160 400 0.160 3.11429e+01\n", + " 165 400 0.160 3.11424e+01\n", + " 170 400 0.161 3.11420e+01\n", + " 175 400 0.161 3.11418e+01\n", + " 180 400 0.162 3.11416e+01\n", + " 185 400 0.162 3.11414e+01\n", + " 190 400 0.161 3.11412e+01\n", + " 195 400 0.162 3.11410e+01\n", + " 200 400 0.162 3.11408e+01\n", + " 205 400 0.162 3.11407e+01\n", + " 210 400 0.163 3.11405e+01\n", + " 215 400 0.163 3.11404e+01\n", + " 220 400 0.163 3.11403e+01\n", + " 225 400 0.163 3.11402e+01\n", + " 230 400 0.163 3.11401e+01\n", + " 235 400 0.162 3.11401e+01\n", + " 240 400 0.162 3.11400e+01\n", + " 245 400 0.163 3.11399e+01\n", + " 250 400 0.163 3.11398e+01\n", + " 255 400 0.163 3.11398e+01\n", + " 260 400 0.163 3.11397e+01\n", + " 265 400 0.163 3.11396e+01\n", + " 270 400 0.162 3.11396e+01\n", + " 275 400 0.162 3.11395e+01\n", + " 280 400 0.162 3.11395e+01\n", + " 285 400 0.162 3.11394e+01\n", + " 290 400 0.162 3.11394e+01\n", + " 295 400 0.162 3.11393e+01\n", + " 300 400 0.163 3.11393e+01\n", + " 305 400 0.163 3.11393e+01\n", + " 310 400 0.163 3.11392e+01\n", + " 315 400 0.163 3.11392e+01\n", + " 320 400 0.163 3.11392e+01\n", + " 325 400 0.163 3.11391e+01\n", + " 330 400 0.163 3.11391e+01\n", + " 335 400 0.163 3.11391e+01\n", + " 340 400 0.164 3.11391e+01\n", + " 345 400 0.164 3.11390e+01\n", + " 350 400 0.163 3.11390e+01\n", + " 355 400 0.163 3.11390e+01\n", + " 360 400 0.163 3.11389e+01\n", + " 365 400 0.162 3.11389e+01\n", + " 370 400 0.162 3.11389e+01\n", + " 375 400 0.163 3.11389e+01\n", + " 380 400 0.163 3.11388e+01\n", + " 385 400 0.163 3.11388e+01\n", + " 390 400 0.163 3.11388e+01\n", + " 395 400 0.163 3.11388e+01\n", + " 400 400 0.163 3.11388e+01\n", + "-------------------------------------------------------\n", + " 400 400 0.163 3.11388e+01\n", + "Stop criterion has been reached.\n", + "\n", + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 400 0.000 7.40475e+03\n", + " 5 400 0.198 1.37527e+02\n", + " 10 400 0.216 5.76839e+01\n", + " 15 400 0.244 4.79763e+01\n", + " 20 400 0.263 4.32445e+01\n", + " 25 400 0.272 3.81302e+01\n", + " 30 400 0.271 3.41259e+01\n", + " 35 400 0.272 3.31618e+01\n", + " 40 400 0.272 3.25205e+01\n", + " 45 400 0.276 3.19219e+01\n", + " 50 400 0.319 3.16410e+01\n", + " 55 400 0.314 3.15660e+01\n", + " 60 400 0.311 3.14292e+01\n", + " 65 400 0.311 3.13021e+01\n", + " 70 400 0.315 3.12460e+01\n", + " 75 400 0.316 3.12253e+01\n", + " 80 400 0.319 3.12012e+01\n", + " 85 400 0.317 3.11803e+01\n", + " 90 400 0.317 3.11672e+01\n", + " 95 400 0.320 3.11590e+01\n", + " 100 400 0.321 3.11536e+01\n", + " 105 400 0.319 3.11504e+01\n", + " 110 400 0.315 3.11479e+01\n", + " 115 400 0.316 3.11455e+01\n", + " 120 400 0.315 3.11440e+01\n", + " 125 400 0.315 3.11429e+01\n", + " 130 400 0.314 3.11418e+01\n", + " 135 400 0.313 3.11410e+01\n", + " 140 400 0.312 3.11404e+01\n", + " 145 400 0.311 3.11400e+01\n", + " 150 400 0.311 3.11397e+01\n", + " 155 400 0.311 3.11395e+01\n", + " 160 400 0.310 3.11393e+01\n", + " 165 400 0.310 3.11392e+01\n", + " 170 400 0.310 3.11391e+01\n", + " 175 400 0.309 3.11390e+01\n", + " 180 400 0.307 3.11389e+01\n", + " 185 400 0.307 3.11389e+01\n", + " 190 400 0.307 3.11388e+01\n", + " 195 400 0.306 3.11387e+01\n", + " 200 400 0.305 3.11386e+01\n", + " 205 400 0.303 3.11386e+01\n", + " 210 400 0.300 3.11385e+01\n", + " 215 400 0.297 3.11385e+01\n", + " 220 400 0.296 3.11385e+01\n", + " 225 400 0.296 3.11385e+01\n", + " 230 400 0.296 3.11385e+01\n", + " 235 400 0.296 3.11385e+01\n", + " 240 400 0.295 3.11384e+01\n", + " 245 400 0.294 3.11384e+01\n", + " 250 400 0.294 3.11384e+01\n", + " 255 400 0.295 3.11384e+01\n", + " 260 400 0.294 3.11384e+01\n", + " 265 400 0.294 3.11384e+01\n", + " 270 400 0.295 3.11384e+01\n", + " 275 400 0.295 3.11384e+01\n", + " 280 400 0.295 3.11383e+01\n", + " 285 400 0.295 3.11383e+01\n", + " 290 400 0.294 3.11383e+01\n", + " 295 400 0.295 3.11383e+01\n", + " 300 400 0.295 3.11383e+01\n", + " 305 400 0.296 3.11383e+01\n", + " 310 400 0.294 3.11383e+01\n", + " 315 400 0.294 3.11383e+01\n", + " 320 400 0.293 3.11383e+01\n", + " 325 400 0.293 3.11383e+01\n", + " 330 400 0.299 3.11383e+01\n", + " 335 400 0.299 3.11383e+01\n", + " 340 400 0.298 3.11383e+01\n", + " 345 400 0.297 3.11383e+01\n", + " 350 400 0.296 3.11383e+01\n", + " 355 400 0.296 3.11383e+01\n", + " 360 400 0.294 3.11383e+01\n", + " 365 400 0.294 3.11383e+01\n", + " 370 400 0.294 3.11383e+01\n", + " 375 400 0.295 3.11383e+01\n", + " 380 400 0.296 3.11383e+01\n", + " 385 400 0.296 3.11383e+01\n", + " 390 400 0.297 3.11383e+01\n", + " 395 400 0.297 3.11383e+01\n", + " 400 400 0.297 3.11383e+01\n", + "-------------------------------------------------------\n", + " 400 400 0.297 3.11383e+01\n", + "Stop criterion has been reached.\n", + "\n", + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 400 0.000 7.40475e+03\n", + " 5 400 0.585 1.39044e+02\n", + " 10 400 0.517 5.79808e+01\n", + " 15 400 0.488 4.82156e+01\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/envs/cil/lib/python3.10/site-packages/cil/framework/framework.py:3009: RuntimeWarning: invalid value encountered in divide\n", + " pwop(self.as_array(), x2.as_array(), *args, **kwargs )\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 20 400 0.473 4.32572e+01\n", + " 25 400 0.498 3.81482e+01\n", + " 30 400 0.478 3.41160e+01\n", + " 35 400 0.473 3.31553e+01\n", + " 40 400 0.469 3.24838e+01\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 45 400 0.488 3.18673e+01\n" + ] + } + ], + "source": [ + "F = 0.5 * L2NormSquared(b=absorption_data)\n", + "G = (alpha_tv/ig2D.voxel_size_y) * FGP_TV(max_iteration=100, nonnegativity = True, device = 'gpu') \n", + "K = A\n", + "\n", + "# Setup and run PDHG\n", + "pdhg_tv_implicit_regtk = PDHG(f = F, g = G, operator = K,\n", + " max_iteration = 400,\n", + " update_objective_interval = 5)\n", + "pdhg_tv_implicit_regtk.run(verbose=1)\n", + "\n", + "\n", + "F = 0.5 * L2NormSquared(b=absorption_data)\n", + "G = alpha_tv * TotalVariation(max_iteration=100, lower=0.)\n", + "K = A\n", + "# Setup and run PDHG\n", + "pdhg_tv_implicit_cil = PDHG(f = F, g = G, operator = K,\n", + " max_iteration = 400,\n", + " update_objective_interval = 5)\n", + "pdhg_tv_implicit_cil.run(verbose=1)\n", + "\n", + "\n", + "\n", + "F = 0.5 * L2NormSquared(b=absorption_data)\n", + "\n", + "K = A\n", + "plt.figure(figsize=(12,12))\n", + "iter_range = np.arange(0,401,5)\n", + "plt.semilogy(iter_range, pdhg_tv_implicit_regtk.objective, label='implicit PDHG (Regtk)')\n", + "plt.semilogy(iter_range, pdhg_tv_implicit_cil.objective, label='implicit PDHG (CIL)')\n", + "for i in range(0,30,5):\n", + " G = alpha_tv * TotalVariation(max_iteration=i, lower=0., warmstart=True)\n", + " # Setup and run PDHG\n", + " pdhg_tv_implicit_cil_warm_start = PDHG(f = F, g = G, operator = K,\n", + " max_iteration = 400,\n", + " update_objective_interval = 5)\n", + " pdhg_tv_implicit_cil_warm_start.run(verbose=1)\n", + "\n", + "\n", + "\n", + " plt.semilogy(iter_range, pdhg_tv_implicit_cil_warm_start.objective, label='implicit PDHG (CIL Warm start '+str(i)+' iterations')\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel('Objective function')\n", + "plt.ylim(70,76)\n", + "plt.legend()\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "075363a3", + "metadata": {}, + "source": [ + "## Absolute error in the prximal calcultion printed for each iteration " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1a48605", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(392, 392)\n", + "\n", + "(392, 392)\n", + "nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2230921/4163379483.py:16: RuntimeWarning: invalid value encountered in float_scalars\n", + " hold[i]=np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array()-G_new.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())/np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.006371722556651\n", + "0.010306853801012\n", + "0.011967001482844\n", + "0.012141870334744\n", + "0.011154086329043\n", + "0.009454647079110\n", + "0.007848035544157\n", + "0.006351156625897\n", + "0.005269628018141\n", + "0.004583632107824\n", + "0.004208668135107\n", + "0.004053416661918\n", + "0.004076413344592\n", + "0.004518712405115\n", + "0.005058542825282\n", + "0.005769900977612\n", + "0.006268993485719\n", + "0.006738359574229\n", + "0.007248400710523\n", + "0.007657966110855\n", + "0.008042982779443\n", + "0.008422131650150\n", + "0.008730802685022\n", + "0.008927714079618\n", + "0.009071441367269\n", + "0.009164910763502\n", + "0.009100656956434\n", + "0.008927645161748\n", + "0.008697603829205\n", + "0.008455654606223\n", + "0.008085822686553\n", + "0.007645812816918\n", + "0.007195058278739\n", + "0.006962204352021\n", + "0.006865515839309\n", + "0.006813514046371\n", + "0.006723018828779\n", + "0.006607326678932\n", + "0.006437776144594\n", + "0.006262657698244\n", + "0.006103666033596\n", + "0.005938214249909\n", + "0.005754547659308\n", + "0.005590087734163\n", + "0.005453179590404\n", + "0.005287341307849\n", + "0.005129667930305\n", + "0.004963845480233\n", + "0.004822354763746\n", + "0.004711990244687\n", + "0.004615240730345\n", + "0.004531082231551\n", + "0.004449829459190\n", + "0.004367171786726\n", + "0.004280186723918\n", + "0.004190182313323\n", + "0.004111433867365\n", + "0.004028520081192\n", + "0.003944415133446\n", + "0.003865592181683\n", + "0.003787916619331\n", + "0.003729531774297\n", + "0.003681831527501\n", + "0.003627916099504\n", + "0.003575087524951\n", + "0.003522050799802\n", + "0.003468457842246\n", + "0.003419648855925\n", + "0.003379710251465\n", + "0.003341342555359\n", + "0.003291838802397\n", + "0.003240507794544\n", + "0.003189664799720\n", + "0.003140016458929\n", + "0.003090175101534\n", + "0.003045259509236\n", + "0.002999982330948\n", + "0.002958232071251\n", + "0.002921228064224\n", + "0.002884241752326\n", + "0.002845332724974\n", + "0.002801205962896\n", + "0.002756677800789\n", + "0.002718434203416\n", + "0.002684947568923\n", + "0.002651873743162\n", + "0.002621478168294\n", + "0.002595953876153\n", + "0.002570055425167\n", + "0.002539832377806\n", + "0.002511372324079\n", + "0.002486265497282\n", + "0.002461483469233\n", + "0.002436500974000\n", + "0.002412515692413\n", + "0.002390427049249\n", + "0.002369001507759\n", + "0.002347769215703\n", + "0.002326625166461\n", + "0.002304472262040\n", + "0.002281620865688\n", + "0.002259281463921\n", + "0.002238921588287\n", + "0.002219301648438\n", + "0.002200684975833\n", + "0.002183432690799\n", + "0.002167701022699\n", + "0.002152861328796\n", + "0.002138607203960\n", + "0.002123695099726\n", + "0.002109096851200\n", + "0.002094943076372\n", + "0.002080333651975\n", + "0.002065069973469\n", + "0.002049198374152\n", + "0.002032696036622\n", + "0.002015789737925\n", + "0.001998258754611\n", + "0.001980683300644\n", + "0.001963176531717\n", + "0.001946136006154\n", + "0.001929642283358\n", + "0.001913880463690\n", + "0.001898526912555\n", + "0.001883862190880\n", + "0.001869745552540\n", + "0.001856211572886\n", + "0.001843081205152\n", + "0.001830322202295\n", + "0.001817882992327\n", + "0.001805691281334\n", + "0.001793193747289\n", + "0.001780566526577\n", + "0.001768077723682\n", + "0.001755848294124\n", + "0.001743973116390\n", + "0.001732411212288\n", + "0.001721293549053\n", + "0.001710487296805\n", + "0.001699973014183\n", + "0.001689786906354\n", + "0.001679925946519\n", + "0.001670290948823\n", + "0.001660904148594\n", + "0.001651572063565\n", + "0.001642178511247\n", + "0.001632844097912\n", + "0.001623650314286\n", + "0.001614544889890\n", + "0.001605485798791\n", + "0.001596532529220\n", + "0.001587631180882\n", + "0.001578868366778\n", + "0.001570236869156\n", + "0.001561680808663\n", + "0.001553183537908\n", + "0.001544767990708\n", + "0.001536484458484\n", + "0.001528322696686\n", + "0.001520278747194\n", + "0.001512361224741\n", + "0.001504459534772\n", + "0.001496652024798\n", + "0.001488922862336\n", + "0.001481184852310\n", + "0.001473484444432\n", + "0.001465838053264\n", + "0.001458213664591\n", + "0.001450603012927\n", + "0.001442989800125\n", + "0.001435481943190\n", + "0.001427980023436\n", + "0.001420574844815\n", + "0.001413238118403\n", + "0.001406002789736\n", + "0.001398813794367\n", + "0.001391742145643\n", + "0.001384789939038\n", + "0.001377913635224\n", + "0.001371114049107\n", + "0.001364422962070\n", + "0.001357862609439\n", + "0.001351454760879\n", + "0.001345084747300\n", + "0.001338805421256\n", + "0.001332612475380\n", + "0.001326486468315\n", + "0.001320409704931\n", + "0.001314416062087\n", + "0.001308492734097\n", + "0.001302612363361\n", + "0.001296764123254\n", + "0.001290984335355\n", + "0.001285253791139\n", + "0.001279564108700\n", + "0.001273894915357\n", + "0.001268274150789\n", + "0.001262696110643\n", + "0.001257166150026\n", + "0.001251675770618\n", + "0.001246249419637\n", + "0.001240881159902\n", + "0.001235549454577\n", + "0.001230256631970\n", + "0.001224990119226\n", + "0.001219772500917\n", + "0.001214594696648\n", + "0.001209465786815\n", + "0.001204362371936\n", + "0.001199314719997\n", + "0.001194320735522\n", + "0.001189378788695\n", + "0.001184492721222\n", + "0.001179629238322\n", + "0.001174788107164\n", + "0.001169974450022\n", + "0.001165205379948\n", + "0.001160484156571\n", + "0.001155801466666\n", + "0.001151167904027\n", + "0.001146556925960\n", + "0.001142004621215\n", + "0.001137467217632\n", + "0.001132981386036\n", + "0.001128549338318\n", + "0.001124132541008\n", + "0.001119751017541\n", + "0.001115420600399\n", + "0.001111120218411\n", + "0.001106849173084\n", + "0.001102616079152\n", + "0.001098414417356\n", + "0.001094251289032\n", + "0.001090120989829\n", + "0.001086006290279\n", + "0.001081903697923\n", + "0.001077850931324\n", + "0.001073827850632\n", + "0.001069817924872\n", + "0.001065853284672\n", + "0.001061891089194\n", + "0.001057964051142\n", + "0.001054060412571\n", + "0.001050178776495\n", + "0.001046310295351\n", + "0.001042483607307\n", + "0.001038678921759\n", + "0.001034882268868\n", + "0.001031119842082\n", + "0.001027386519127\n", + "0.001023694523610\n", + "0.001020026858896\n", + "0.001016389578581\n", + "0.001012775348499\n", + "0.001009169849567\n", + "0.001005576457828\n", + "0.001001982600428\n", + "0.000998420524411\n", + "0.000994891161099\n", + "0.000991387758404\n", + "0.000987918814644\n", + "0.000984476297162\n", + "0.000981044257060\n", + "0.000977636547759\n", + "0.000974258175120\n", + "0.000970905879512\n", + "0.000967583036982\n", + "0.000964287435636\n", + "0.000961006560829\n", + "0.000957754557021\n", + "0.000954517628998\n", + "0.000951301190071\n", + "0.000948122586124\n", + "0.000944965810049\n", + "0.000941831734963\n", + "0.000938714307267\n", + "0.000935622141697\n", + "0.000932552735321\n", + "0.000929504516535\n", + "0.000926468928810\n", + "0.000923458603211\n", + "0.000920468708500\n", + "0.000917496916372\n", + "0.000914550095331\n", + "0.000911623588763\n", + "0.000908719899599\n", + "0.000905834371224\n", + "0.000902950705495\n", + "0.000900099286810\n", + "0.000897278136108\n", + "0.000894481781870\n", + "0.000891690258868\n", + "0.000888922193553\n", + "0.000886179041117\n", + "0.000883457483724\n", + "0.000880745355971\n", + "0.000878041959368\n", + "0.000875354162417\n", + "0.000872686388902\n", + "0.000870033574756\n", + "0.000867401715368\n", + "0.000864782661665\n", + "0.000862191373017\n", + "0.000859601539560\n", + "0.000857038015965\n", + "0.000854491197970\n", + "0.000851959863212\n", + "0.000849433068652\n", + "0.000846930139232\n", + "0.000844437745400\n", + "0.000841968285386\n", + "0.000839512213133\n", + "0.000837074476294\n", + "0.000834643316921\n", + "0.000832231191453\n", + "0.000829827971756\n", + "0.000827442388982\n", + "0.000825069670100\n", + "0.000822709582280\n", + "0.000820356712211\n", + "0.000818021944724\n", + "0.000815703533590\n", + "0.000813398393802\n", + "0.000811101519503\n", + "0.000808817858342\n", + "0.000806545023806\n", + "0.000804288079962\n", + "0.000802034104709\n", + "0.000799804576673\n", + "0.000797585526016\n", + "0.000795378407929\n", + "0.000793189101387\n", + "0.000791017839219\n", + "0.000788856297731\n", + "0.000786708085798\n", + "0.000784576230217\n", + "0.000782450137194\n", + "0.000780335627496\n", + "0.000778238580097\n", + "0.000776147586294\n", + "0.000774065614678\n", + "0.000771994004026\n", + "0.000769937178120\n", + "0.000767884892412\n", + "0.000765858625527\n", + "0.000763825140893\n", + "0.000761816743761\n", + "0.000759811373428\n", + "0.000757820380386\n", + "0.000755834160373\n", + "0.000753872212954\n", + "0.000751904095523\n", + "0.000749958271626\n", + "0.000748017046135\n", + "0.000746090314351\n", + "0.000744173652492\n", + "0.000742277305108\n", + "0.000740382994991\n", + "0.000738503702451\n", + "0.000736633723136\n", + "0.000734774279408\n", + "0.000732923799660\n", + "0.000731086125597\n", + "0.000729260442313\n", + "0.000727443024516\n", + "0.000725634221453\n", + "0.000723841541912\n", + "0.000722052820493\n", + "0.000720276031643\n", + "0.000718506111298\n", + "0.000716749927960\n", + "0.000715000031050\n", + "0.000713259854820\n", + "0.000711530563422\n", + "0.000709812506102\n", + "0.000708104402293\n", + "0.000706399325281\n", + "0.000704704434611\n", + "0.000703022175003\n", + "0.000701345386915\n", + "0.000699679600075\n", + "0.000698019866832\n", + "0.000696368282661\n", + "0.000694727234077\n", + "0.000693094450980\n", + "0.000691471970640\n", + "0.000689860433340\n", + "0.000688259140588\n", + "0.000686667626724\n", + "0.000685082515702\n", + "0.000683504098561\n", + "0.000681929115672\n", + "0.000680363038555\n", + "0.000678797718138\n", + "0.000677247124258\n", + "0.000675700081047\n", + "0.000674161419738\n", + "0.000672627647873\n", + "0.000671106623486\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Next example \n", + "\n", + "(392, 392)\n", + "\n", + "(392, 392)\n", + "nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_2230921/4163379483.py:42: RuntimeWarning: invalid value encountered in float_scalars\n", + " hold[i]=np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array()-G_new.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())/np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.010666279122233\n", + "0.012341897934675\n", + "0.013167494907975\n", + "0.022420270368457\n", + "0.051656480878592\n", + "0.065988808870316\n", + "0.063225410878658\n", + "0.054585851728916\n", + "0.055126264691353\n", + "0.065847173333168\n", + "0.077282711863518\n", + "0.084939338266850\n", + "0.088499136269093\n", + "0.088845379650593\n", + "0.086914032697678\n", + "0.083601608872414\n", + "0.079300910234451\n", + "0.074013695120811\n", + "0.067921996116638\n", + "0.061353892087936\n", + "0.054695062339306\n", + "0.048259392380714\n", + "0.042184684425592\n", + "0.036270227283239\n", + "0.030534062534571\n", + "0.025448128581047\n", + "0.021619791164994\n", + "0.019673608243465\n", + "0.019028626382351\n", + "0.018612653017044\n", + "0.018131325021386\n", + "0.017687764018774\n", + "0.017378788441420\n", + "0.017116377130151\n", + "0.016541784629226\n", + "0.015858927741647\n", + "0.015140733681619\n", + "0.014418200589716\n", + "0.013796940445900\n", + "0.013375506736338\n", + "0.013117653317750\n", + "0.013039323501289\n", + "0.013048136606812\n", + "0.013130043633282\n", + "0.013322014361620\n", + "0.013535777106881\n", + "0.013687812723219\n", + "0.013718011789024\n", + "0.013623702339828\n", + "0.013454315252602\n", + "0.013251784257591\n", + "0.012980328872800\n", + "0.012672081589699\n", + "0.012351606972516\n", + "0.012078131549060\n", + "0.011839757673442\n", + "0.011604508385062\n", + "0.011412507854402\n", + "0.011257199570537\n", + "0.011124306358397\n", + "0.011011039838195\n", + "0.010934142395854\n", + "0.010878168977797\n", + "0.010818930342793\n", + "0.010764501057565\n", + "0.010732701048255\n", + "0.010731222108006\n", + "0.010735003277659\n", + "0.010724780149758\n", + "0.010712379589677\n", + "0.010696098208427\n", + "0.010682819411159\n", + "0.010665907524526\n", + "0.010632378980517\n", + "0.010594899766147\n", + "0.010558801703155\n", + "0.010529636405408\n", + "0.010503428056836\n", + "0.010476151481271\n", + "0.010453817434609\n", + "0.010438672266901\n", + "0.010430610738695\n", + "0.010429061949253\n", + "0.010429413057864\n", + "0.010428595356643\n", + "0.010428616777062\n", + "0.010429186746478\n", + "0.010427183471620\n", + "0.010421963408589\n", + "0.010412666946650\n", + "0.010400208644569\n", + "0.010386154986918\n", + "0.010371326468885\n", + "0.010353940539062\n", + "0.010332951322198\n", + "0.010310061275959\n", + "0.010284406132996\n", + "0.010255757719278\n", + "0.010224601253867\n", + "0.010193388909101\n", + "0.010162219405174\n", + "0.010131878778338\n", + "0.010102503933012\n", + "0.010073724202812\n", + "0.010046374052763\n", + "0.010020984336734\n", + "0.009997815825045\n", + "0.009976861067116\n", + "0.009958204813302\n", + "0.009941534139216\n", + "0.009926253929734\n", + "0.009913053363562\n", + "0.009901844896376\n", + "0.009892486035824\n", + "0.009884816594422\n", + "0.009878975339234\n", + "0.009875190444291\n", + "0.009873313829303\n", + "0.009872964583337\n", + "0.009874150156975\n", + "0.009877102449536\n", + "0.009880958124995\n", + "0.009885438717902\n", + "0.009890200570226\n", + "0.009895099326968\n", + "0.009899550117552\n", + "0.009903122670949\n", + "0.009905422106385\n", + "0.009906507097185\n", + "0.009905828163028\n", + "0.009903552010655\n", + "0.009899729862809\n", + "0.009894552640617\n", + "0.009888036176562\n", + "0.009880641475320\n", + "0.009872547350824\n", + "0.009864172898233\n", + "0.009855929762125\n", + "0.009847987443209\n", + "0.009840508922935\n", + "0.009833727031946\n", + "0.009827855043113\n", + "0.009822995401919\n", + "0.009819078259170\n", + "0.009816230274737\n", + "0.009814205579460\n", + "0.009813223034143\n", + "0.009813053533435\n", + "0.009813733398914\n", + "0.009815027005970\n", + "0.009816920384765\n", + "0.009819168597460\n", + "0.009821657091379\n", + "0.009824271313846\n", + "0.009826950728893\n", + "0.009829446673393\n", + "0.009831786155701\n", + "0.009833759628236\n", + "0.009835478849709\n", + "0.009836770594120\n", + "0.009837661869824\n", + "0.009838215075433\n", + "0.009838341735303\n", + "0.009838026948273\n", + "0.009837288409472\n", + "0.009836152195930\n", + "0.009834644384682\n", + "0.009832793846726\n", + "0.009830641560256\n", + "0.009828082285821\n", + "0.009825265035033\n", + "0.009822216816247\n", + "0.009819095954299\n", + "0.009815871715546\n", + "0.009812632575631\n", + "0.009809465147555\n", + "0.009806447662413\n", + "0.009803606197238\n", + "0.009800947271287\n", + "0.009798473678529\n", + "0.009796245023608\n", + "0.009794231504202\n", + "0.009792468510568\n", + "0.009790996089578\n", + "0.009789744392037\n", + "0.009788807481527\n", + "0.009788138791919\n", + "0.009787703864276\n", + "0.009787437506020\n", + "0.009787371382117\n", + "0.009787489660084\n", + "0.009787715971470\n", + "0.009788079187274\n", + "0.009788527153432\n", + "0.009789095260203\n", + "0.009789692237973\n", + "0.009790321812034\n", + "0.009790954180062\n", + "0.009791547432542\n", + "0.009792063385248\n", + "0.009792516939342\n", + "0.009792844764888\n", + "0.009793089702725\n", + "0.009793278761208\n", + "0.009793355129659\n", + "0.009793343953788\n", + "0.009793275035918\n", + "0.009793151170015\n", + "0.009792984463274\n", + "0.009792802855372\n", + "0.009792640805244\n", + "0.009792448021472\n", + "0.009792267344892\n", + "0.009792078286409\n", + "0.009791919961572\n", + "0.009791715070605\n", + "0.009791476652026\n", + "0.009791222400963\n", + "0.009790950454772\n", + "0.009790662676096\n", + "0.009790372103453\n", + "0.009790070354939\n", + "0.009789796546102\n", + "0.009789548814297\n", + "0.009789324365556\n", + "0.009789123199880\n", + "0.009788993746042\n", + "0.009788846597075\n", + "0.009788753464818\n", + "0.009788674302399\n", + "0.009788620285690\n", + "0.009788576513529\n", + "0.009788517840207\n", + "0.009788511320949\n", + "0.009788544848561\n", + "0.009788569994271\n", + "0.009788615629077\n", + "0.009788659401238\n", + "0.009788707830012\n", + "0.009788777679205\n", + "0.009788831695914\n", + "0.009788826107979\n", + "0.009788800962269\n", + "0.009788795374334\n", + "0.009788767434657\n", + "0.009788719005883\n", + "0.009788657538593\n", + "0.009788538329303\n", + "0.009788442403078\n", + "0.009788324125111\n", + "0.009788230061531\n", + "0.009788111783564\n", + "0.009787989780307\n", + "0.009787809103727\n", + "0.009787616319954\n", + "0.009787389077246\n", + "0.009787113405764\n", + "0.009786823764443\n", + "0.009786549024284\n", + "0.009786265902221\n", + "0.009785999543965\n", + "0.009785732254386\n", + "0.009785497561097\n", + "0.009785261936486\n", + "0.009785057976842\n", + "0.009784865193069\n", + "0.009784702211618\n", + "0.009784548543394\n", + "0.009784424677491\n", + "0.009784298948944\n", + "0.009784160181880\n", + "0.009784065186977\n", + "0.009783961810172\n", + "0.009783851914108\n", + "0.009783707559109\n", + "0.009783532470465\n", + "0.009783306159079\n", + "0.009783072397113\n", + "0.009782824665308\n", + "0.009782602079213\n", + "0.009782408364117\n", + "0.009782265871763\n", + "0.009782174602151\n", + "0.009782161563635\n", + "0.009782182052732\n", + "0.009782222099602\n", + "0.009782308712602\n", + "0.009782410226762\n", + "0.009782508946955\n", + "0.009782669134438\n", + "0.009782817214727\n", + "0.009782961569726\n", + "0.009783086366951\n", + "0.009783205576241\n", + "0.009783308953047\n", + "0.009783379733562\n", + "0.009783451445401\n", + "0.009783545508981\n", + "0.009783630259335\n", + "0.009783729910851\n", + "0.009783806279302\n", + "0.009783841669559\n", + "0.009783864952624\n", + "0.009783853776753\n", + "0.009783856570721\n", + "0.009783827699721\n", + "0.009783789515495\n", + "0.009783745743334\n", + "0.009783667512238\n", + "0.009783567860723\n", + "0.009783448651433\n", + "0.009783302433789\n", + "0.009783169254661\n", + "0.009783059358597\n", + "0.009782976470888\n", + "0.009782915934920\n", + "0.009782878682017\n", + "0.009782860055566\n", + "0.009782857261598\n", + "0.009782897308469\n", + "0.009782961569726\n", + "0.009783019311726\n", + "0.009783064946532\n", + "0.009783088229597\n", + "0.009783121757209\n", + "0.009783097542822\n", + "0.009783042594790\n", + "0.009782975539565\n", + "0.009782871231437\n", + "0.009782792069018\n", + "0.009782720357180\n", + "0.009782688692212\n", + "0.009782661683857\n", + "0.009782651439309\n", + "0.009782659821212\n", + "0.009782680310309\n", + "0.009782725945115\n", + "0.009782777167857\n", + "0.009782860986888\n", + "0.009782953187823\n", + "0.009783015586436\n", + "0.009783054701984\n", + "0.009783067740500\n", + "0.009783059358597\n", + "0.009783005341887\n", + "0.009782937355340\n", + "0.009782851673663\n", + "0.009782752022147\n", + "0.009782596491277\n", + "0.009782473556697\n", + "0.009782415814698\n", + "0.009782390668988\n", + "0.009782401844859\n", + "0.009782468900084\n", + "0.009782552719116\n", + "0.009782650507987\n", + "0.009782737120986\n", + "0.009782847948372\n", + "0.009782942011952\n", + "0.009783034212887\n", + "0.009783115237951\n", + "0.009783172979951\n", + "0.009783223271370\n", + "0.009783263318241\n", + "0.009783286601305\n", + "0.009783296845853\n", + "0.009783279150724\n", + "0.009783237241209\n", + "0.009783171117306\n", + "0.009783079847693\n", + "0.009782965295017\n", + "0.009782840497792\n", + "0.009782714769244\n", + "0.009782615117729\n", + "0.009782515466213\n", + "0.009782433509827\n", + "0.009782392531633\n", + "0.009782309643924\n", + "0.009782241657376\n", + "0.009782171808183\n", + "0.009782131761312\n", + "0.009782089851797\n", + "0.009782037697732\n", + "0.009781997650862\n", + "0.009781979955733\n", + "0.009781969711185\n", + "0.009781978093088\n", + "0.009782018139958\n", + "0.009782082401216\n", + "0.009782183915377\n", + "0.009782317094505\n", + "0.009782426990569\n", + "0.009782554581761\n", + "0.009782666340470\n", + "0.009782756678760\n", + "0.009782846085727\n", + "0.009782927110791\n", + "0.009782980196178\n", + "0.009783010929823\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "F = 0.5 * L2NormSquared(b=absorption_data)\n", + "G_new = alpha_tv*TotalVariation(max_iteration=5, lower=0., warmstart=True)\n", + "G_FGP_TV=(alpha_tv/ig2D.voxel_size_y)*FGP_TV(max_iteration=500, nonnegativity = True, device = 'gpu') \n", + "K = A\n", + "# Setup and run PDHG\n", + "pdhg_tv_implicit_cil = PDHG(f = F, g = G_FGP_TV, operator = K,\n", + " max_iteration = 400,\n", + " update_objective_interval = 50)\n", + "\n", + "hold=np.zeros(400)\n", + "for i in range(400):\n", + " pdhg_tv_implicit_cil.__next__()\n", + " #print(np.linalg.norm(pdhg_tv_implicit_cil.solution.as_array()))\n", + " #print(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, 0.5).as_array())\n", + " #print(G_new.proximal(pdhg_tv_implicit_cil.solution, 0.5).as_array())\n", + " hold[i]=np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array()-G_new.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())/np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())\n", + " print('{0:.15f}'.format(hold[i]))\n", + "\n", + "plt.figure()\n", + "plt.semilogy(range(400), hold)\n", + "plt.title('Comparison of proximal values of warm start TV and CCPI TV reg at PDHG (Regtk) iteration values')\n", + "plt.ylabel('Absolute error')\n", + "plt.xlabel('Iteration number')\n", + "plt.show()\n", + "\n", + "\n", + "print('Next example ')\n", + "\n", + "F = 0.5 * L2NormSquared(b=absorption_data)\n", + "G_new = alpha_tv*TotalVariation(max_iteration=5, warmstart=True)\n", + "G_FGP_TV=(alpha_tv/ig2D.voxel_size_y)*FGP_TV(max_iteration=500, device = 'gpu') \n", + "K = A\n", + "# Setup and run PDHG\n", + "pdhg_tv_implicit_cil = PDHG(f = F, g = G_new, operator = K,\n", + " max_iteration = 400,\n", + " update_objective_interval = 50)\n", + "\n", + "\n", + "\n", + "for i in range(400):\n", + " pdhg_tv_implicit_cil.__next__()\n", + " hold[i]=np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array()-G_new.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())/np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())\n", + " print('{0:.15f}'.format(hold[i]))\n", + "\n", + "plt.figure()\n", + "plt.semilogy(range(400), hold)\n", + "plt.title('Comparison of proximal values of warm start TV and CCPI TV reg at PDHG (CIL-warm start) iteration values')\n", + "plt.ylabel('Absolute error')\n", + "plt.xlabel('Iteration number')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b7026693", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb42f52d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "43cbf82c2f716cd564b762322e13d4dbd881fd8a341d231fe608abc3118da208" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Wrappers/Python/cil/optimisation/operators/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/operators/ApproximateGradientSumFunction.py new file mode 100644 index 0000000000..1c602f226e --- /dev/null +++ b/Wrappers/Python/cil/optimisation/operators/ApproximateGradientSumFunction.py @@ -0,0 +1,161 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 United Kingdom Research and Innovation +# Copyright 2020 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt + + + +from cil.optimisation.functions import SumFunction + +import numbers +class ApproximateGradientSumFunction(SumFunction): + + r"""ApproximateGradientSumFunction represents the following sum + + .. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) + + where :math:`n` is the number of functions. + + Parameters: + ----------- + functions : list(functions) + A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. + sampler: MORE HERE!!!!!!!!!!! + + Note + ---- + + The :meth:`~ApproximateGradientSumFunction.gradient` computes the `gradient` of only one function of a batch of functions + depending on the :code:`sampler` method. The selected function(s) is the :meth:`~SubsetSumFunction.next_subset` method. + + Example + ------- + + .. math:: \sum_{i=1}^{n} F_{i}(x) = \sum_{i=1}^{n}\|A_{i} x - b_{i}\|^{2} + + >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) + >>> f = ApproximateGradientSumFunction(list_of_functions) + + >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) + >>> selection = RandomSampling.random_shuffle(len(list_of_functions)) + >>> f = ApproximateGradientSumFunction(list_of_functions, selection=selection) + + + """ + + def __init__(self, functions, sampler=None, data_passes=None, initial=None, dask=False): + + if selection is None: + self.selection = RandomSampling.uniform(len(functions)) + else: + self.selection = selection + + self.functions_used = [] + self.data_passes = data_passes + self.initial = initial + self._dask = dask + + try: + import dask + self._dask_available = True + self._module = dask + except ImportError: + print("Dask is not installed.") + self._dask_available = False + + super(ApproximateGradientSumFunction, self).__init__(*functions) + + @property + def dask(self): + return self._dask + + @dask.setter + def dask(self, value): + if self._dask_available: + self._dask = value + else: + print("Dask is not installed.") + + def __call__(self, x): + if self.dask: + return self._call_parallel(x) + else: + r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ + return super(ApproximateGradientSumFunction, self).__call__(x) + + def _call_parallel(self, x): + res = [] + for f in self.functions: + res.append(self._module.delayed(f)(x)) + return sum(self._module.compute(*res)) + + def _gradient_parallel(self, x, out): + + res = [] + for f in self.functions: + res.append(self._module.delayed(f.gradient)(x)) + tmp = self._module.compute(*res) + + if out is None: + return sum(tmp) + else: + out.fill(sum(tmp)) + + def full_gradient(self, x, out=None): + + if self.dask: + return self._gradient_parallel(x, out=out) + else: + r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ + return super(ApproximateGradientSumFunction, self).gradient(x, out=out) + + + def approximate_gradient(self, function_num, x, out=None): + + """ Computes the approximate gradient for each selected function at :code:`x`.""" + raise NotImplemented + + def gradient(self, x, out=None): + + """ Computes the gradient for each selected function at :code:`x`.""" + self.next_function() + + # single function + if isinstance(self.function_num, numbers.Number): + return self.approximate_gradient(self.function_num, x, out=out) + else: + raise ValueError("Batch gradient is not implemented") + + def next_function(self): + + """ Selects the next function or the next batch of functions from the list of :code:`functions` using the :code:`selection`.""" + self.function_num = next(self.selection) + + # append each function used at this iteration + self.functions_used.append(self.function_num) + + def allocate_memory(self): + + raise NotImplementedError + + def update_memory(self): + + raise NotImplementedError + + def free_memory(self): + + raise NotImplementedError \ No newline at end of file diff --git a/Wrappers/Python/cil/optimisation/operators/test_SGD.ipynb b/Wrappers/Python/cil/optimisation/operators/test_SGD.ipynb new file mode 100644 index 0000000000..31171bc10d --- /dev/null +++ b/Wrappers/Python/cil/optimisation/operators/test_SGD.ipynb @@ -0,0 +1,223 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# -*- coding: utf-8 -*-\n", + "# Copyright 2019 - 2022 United Kingdom Research and Innovation\n", + "# Copyright 2019 - 2022 The University of Manchester\n", + "# Copyright 2019 - 2022 The University of Bath\n", + "#\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "#\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "#\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License.\n", + "#\n", + "# Authored by: Claire Delplancke (University of Bath)\n", + "# Evangelos Papoutsellis (UKRI-STFC)\n", + "# Gemma Fardell (UKRI-STFC)\n", + "# Laura Murgatroyd (UKRI-STFC) \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Import libraries\n", + " \n", + "from cil.optimisation.algorithms import PDHG, SPDHG\n", + "from cil.optimisation.operators import GradientOperator, BlockOperator\n", + "from cil.optimisation.functions import IndicatorBox, BlockFunction, L2NormSquared, MixedL21Norm\n", + " \n", + "from cil.io import ZEISSDataReader\n", + " \n", + "from cil.processors import Slicer, Binner, TransmissionAbsorptionConverter\n", + " \n", + "from cil.plugins.astra.operators import ProjectionOperator\n", + "from cil.plugins.ccpi_regularisation.functions import FGP_TV\n", + " \n", + "from cil.utilities.display import show2D\n", + "from cil.utilities.jupyter import islicer\n", + " \n", + " \n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data information\n", + "\n", + "In this demo, we use the **Walnut** found in [Jørgensen_et_all](https://zenodo.org/record/4822516#.YLXyAJMzZp8). In total, there are 6 individual micro Computed Tomography datasets in the native Zeiss TXRM/TXM format. The six datasets were acquired at the 3D Imaging Center at Technical University of Denmark in 2014 (HDTomo3D in 2016) as part of the ERC-funded project High-Definition Tomography (HDTomo) headed by Prof. Per Christian Hansen. \n", + "\n", + "This example requires the dataset walnut.zip from https://zenodo.org/record/4822516 :\n", + "\n", + " https://zenodo.org/record/4822516/files/walnut.zip\n", + "\n", + "If running locally please download the data and update the `path` variable below." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "path = '../../data/walnut/valnut'" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "reader = ZEISSDataReader()\n", + "filename = os.path.join(path, \"valnut_2014-03-21_643_28\",\"tomo-A\",\"valnut_tomo-A.txrm\")\n", + "reader.set_up(file_name=filename)\n", + "data3D = reader.read()\n", + "\n", + "# reorder data to match default order for Astra/Tigre operator\n", + "data3D.reorder('astra')\n", + "\n", + "# Get Image and Acquisition geometries\n", + "ag3D = data3D.geometry\n", + "ig3D = ag3D.get_ImageGeometry()\n", + "\n", + "# Extract vertical slice\n", + "data2D = data3D.get_slice(vertical='centre')\n", + "\n", + "# Select every 10 angles\n", + "sliced_data = Slicer(roi={'angle':(0,1601,10)})(data2D)\n", + "\n", + "# Reduce background regions\n", + "binned_data = Binner(roi={'horizontal':(120,-120,2)})(sliced_data)\n", + "\n", + "# Create absorption data \n", + "data = TransmissionAbsorptionConverter()(binned_data) \n", + "\n", + "# Remove circular artifacts\n", + "data -= np.mean(data.as_array()[80:100,0:30])\n", + "\n", + "# Get Image and Acquisition geometries for one slice\n", + "ag2D = data.geometry\n", + "ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian')\n", + "ig2D = ag2D.get_ImageGeometry()\n", + "\n", + "A = ProjectionOperator(ig2D, ag2D, device = \"gpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need to define the following:\n", + "\n", + "- The operator $K=(K_1,\\dots,K_n)$.\n", + "- The functions $F=(F_1,\\dots,F_N)$ and $G$.\n", + "- The maximum number of iterations\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Define number of subsets\n", + "n_subsets = 10\n", + "\n", + "# Initialize the lists containing the F_i's and A_i's\n", + "f_subsets = []\n", + "A_subsets = []\n", + "\n", + "# Define F_i's and A_i's\n", + "for i in range(n_subsets):\n", + " # Total number of angles\n", + " n_angles = len(ag2D.angles)\n", + " # Divide the data into subsets\n", + " data_subset = Slicer(roi = {'angle' : (i,n_angles,n_subsets)})(data)\n", + " \n", + " # Define A_i and put into list \n", + " ageom_subset = data_subset.geometry\n", + " Ai = ProjectionOperator(ig2D, ageom_subset)\n", + " A_subsets.append(Ai)\n", + " # Define F_i and put into list\n", + " fi = LeastSquares(A_i, b=data_subset)\n", + " f_subsets.append(fi)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "class Sampling():\n", + " def __init__(self, num_subsets, prob=None, seed=99):\n", + " self.type=sampling_type\n", + " self.num_subsets=num_subsets\n", + " np.random.seed(seed)\n", + "\n", + " if prob==None:\n", + " self.prob = [1/self.num_subsets] * self.num_subsets\n", + " else:\n", + " self.prob=prob\n", + " def next(self):\n", + " \n", + " return int(np.random.choice(self.num_subsets, 1, p=self.prob))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "interpreter": { + "hash": "43cbf82c2f716cd564b762322e13d4dbd881fd8a341d231fe608abc3118da208" + }, + "kernelspec": { + "display_name": "Python 3.9.13 ('cil_22.0.0')", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 40ac9c06f356dbf98f931b3f80343ca9b0189958 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 8 Aug 2023 07:57:43 +0000 Subject: [PATCH 004/152] Ready to start some basic testing --- .../ApproximateGradientSumFunction.py | 17 ++--- .../cil/optimisation/functions/SGFunction.py | 67 +++++++++++++++++++ .../{operators => functions}/test_SGD.ipynb | 1 - 3 files changed, 76 insertions(+), 9 deletions(-) rename Wrappers/Python/cil/optimisation/{operators => functions}/ApproximateGradientSumFunction.py (90%) create mode 100644 Wrappers/Python/cil/optimisation/functions/SGFunction.py rename Wrappers/Python/cil/optimisation/{operators => functions}/test_SGD.ipynb (99%) diff --git a/Wrappers/Python/cil/optimisation/operators/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py similarity index 90% rename from Wrappers/Python/cil/optimisation/operators/ApproximateGradientSumFunction.py rename to Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 1c602f226e..5e285b195f 100644 --- a/Wrappers/Python/cil/optimisation/operators/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -51,23 +51,24 @@ class ApproximateGradientSumFunction(SumFunction): >>> f = ApproximateGradientSumFunction(list_of_functions) >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) - >>> selection = RandomSampling.random_shuffle(len(list_of_functions)) - >>> f = ApproximateGradientSumFunction(list_of_functions, selection=selection) + >>> sampler = RandomSampling.random_shuffle(len(list_of_functions)) + >>> f = ApproximateGradientSumFunction(list_of_functions, sampler=sampler) """ def __init__(self, functions, sampler=None, data_passes=None, initial=None, dask=False): - if selection is None: - self.selection = RandomSampling.uniform(len(functions)) + if sampler is None: + raise NotImplementedError else: - self.selection = selection + self.sampler = sampler self.functions_used = [] self.data_passes = data_passes self.initial = initial self._dask = dask + self.num_functions=len(functions) try: import dask @@ -121,7 +122,7 @@ def full_gradient(self, x, out=None): return self._gradient_parallel(x, out=out) else: r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ - return super(ApproximateGradientSumFunction, self).gradient(x, out=out) + return super(ApproximateGradientSumFunction, self).gradient(x, out=out) def approximate_gradient(self, function_num, x, out=None): @@ -142,8 +143,8 @@ def gradient(self, x, out=None): def next_function(self): - """ Selects the next function or the next batch of functions from the list of :code:`functions` using the :code:`selection`.""" - self.function_num = next(self.selection) + """ Selects the next function or the next batch of functions from the list of :code:`functions` using the :code:`sampler`.""" + self.function_num = self.sampler.next() # append each function used at this iteration self.functions_used.append(self.function_num) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py new file mode 100644 index 0000000000..11d75349fe --- /dev/null +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -0,0 +1,67 @@ +# -*- coding: utf-8 -*- +# This work is part of the Core Imaging Library (CIL) developed by CCPi +# (Collaborative Computational Project in Tomographic Imaging), with +# substantial contributions by UKRI-STFC and University of Manchester. + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from cil.optimisation.functions import ApproximateGradientSumFunction + +class SGFunction(ApproximateGradientSumFunction): + + """ + Initialize the SGFunction. + + Parameters: + ---------- + functions: list + A list of functions. + sampler: callable or None, optional + A callable object that selects the function or batch of functions to compute the gradient. If None, a random function will be selected. + + """ + + def __init__(self, functions, sampler=None): + + super(SGFunction, self).__init__(functions, sampler, data_passes=[0.]) + + def approximate_gradient(self, function_num, x, out=None): + + """ Returns the gradient of the selected function or batch of functions at :code:`x`. + The function or batch of functions is selected using the :meth:`~ApproximateGradientSumFunction.next_function`. + """ + + # flag to return or in-place computation + should_return=False + + # compute gradient of randomly selected(function_num) function + if out is None: + out = self.functions[function_num].gradient(x) + should_return=True + else: + self.functions[function_num].gradient(x, out = out) + + # scale wrt number of functions + out*=self.num_functions # Is this the scaling that we need? + + # update data passes + self.data_passes.append(round(self.data_passes[-1] + 1./self.num_functions,4)) # What is this used for? + + if should_return: + return out + + + + + + \ No newline at end of file diff --git a/Wrappers/Python/cil/optimisation/operators/test_SGD.ipynb b/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb similarity index 99% rename from Wrappers/Python/cil/optimisation/operators/test_SGD.ipynb rename to Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb index 31171bc10d..08db406df9 100644 --- a/Wrappers/Python/cil/optimisation/operators/test_SGD.ipynb +++ b/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb @@ -174,7 +174,6 @@ "\n", "class Sampling():\n", " def __init__(self, num_subsets, prob=None, seed=99):\n", - " self.type=sampling_type\n", " self.num_subsets=num_subsets\n", " np.random.seed(seed)\n", "\n", From 34fb1d52abae0def168e2285d1b5399e18c4086a Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 8 Aug 2023 08:48:53 +0000 Subject: [PATCH 005/152] Started to debug --- .../cil/optimisation/functions/SGFunction.py | 2 +- .../cil/optimisation/functions/test_SGD.ipynb | 58 ++++++++++++++----- 2 files changed, 45 insertions(+), 15 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 11d75349fe..7641b0fef1 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -15,7 +15,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from cil.optimisation.functions import ApproximateGradientSumFunction +from ApproximateGradientSumFunction import ApproximateGradientSumFunction class SGFunction(ApproximateGradientSumFunction): diff --git a/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb b/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb index 08db406df9..91a5e30eef 100644 --- a/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb +++ b/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -40,8 +40,10 @@ " \n", "from cil.optimisation.algorithms import PDHG, SPDHG\n", "from cil.optimisation.operators import GradientOperator, BlockOperator\n", - "from cil.optimisation.functions import IndicatorBox, BlockFunction, L2NormSquared, MixedL21Norm\n", - " \n", + "from cil.optimisation.functions import LeastSquares\n", + "from cil.optimisation.algorithms import GD\n", + "\n", + "\n", "from cil.io import ZEISSDataReader\n", " \n", "from cil.processors import Slicer, Binner, TransmissionAbsorptionConverter\n", @@ -52,6 +54,7 @@ "from cil.utilities.display import show2D\n", "from cil.utilities.jupyter import islicer\n", " \n", + "from SGFunction import SGFunction\n", " \n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", @@ -75,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -84,12 +87,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "reader = ZEISSDataReader()\n", - "filename = os.path.join(path, \"valnut_2014-03-21_643_28\",\"tomo-A\",\"valnut_tomo-A.txrm\")\n", + "filename = \"valnut_tomo-A.txrm\"\n", "reader.set_up(file_name=filename)\n", "data3D = reader.read()\n", "\n", @@ -137,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -160,13 +163,13 @@ " Ai = ProjectionOperator(ig2D, ageom_subset)\n", " A_subsets.append(Ai)\n", " # Define F_i and put into list\n", - " fi = LeastSquares(A_i, b=data_subset)\n", + " fi = LeastSquares(Ai, b=data_subset)\n", " f_subsets.append(fi)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -184,15 +187,42 @@ " def next(self):\n", " \n", " return int(np.random.choice(self.num_subsets, 1, p=self.prob))\n", - " " + "sampler=Sampling(n_subsets)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mCannot execute code, session has been disposed. Please try restarting the Kernel." + ] + }, + { + "ename": "", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click here for more info. View Jupyter log for further details." + ] + } + ], + "source": [ + "stochastic_objective=SGFunction(f_subsets,sampler)\n", + "mySGD_LS = GD(initial=ig2D.allocate(0), \n", + " objective_function=stochastic_objective, \n", + " step_size=None, \n", + " max_iteration=1000, \n", + " update_objective_interval=10)\n", + "mySGD_LS.run(300, verbose=1)\n", + "\n", + "show2D(mySGD_LS.solution)" + ] } ], "metadata": { From 6ef169a7bedbc0b867ac414b8a1423e12f058d75 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 8 Aug 2023 10:32:57 +0000 Subject: [PATCH 006/152] Testind SGD --- .../ApproximateGradientSumFunction.py | 2 +- .../cil/optimisation/functions/SGFunction.py | 2 +- .../cil/optimisation/functions/test_SGD.ipynb | 206 ++++++++++++++++-- 3 files changed, 187 insertions(+), 23 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 5e285b195f..944d40ec6a 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -133,7 +133,7 @@ def approximate_gradient(self, function_num, x, out=None): def gradient(self, x, out=None): """ Computes the gradient for each selected function at :code:`x`.""" - self.next_function() + self.next_function() # single function if isinstance(self.function_num, numbers.Number): diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 7641b0fef1..2cddb1c2c3 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -24,7 +24,7 @@ class SGFunction(ApproximateGradientSumFunction): Parameters: ---------- - functions: list + functions: list A list of functions. sampler: callable or None, optional A callable object that selects the function or batch of functions to compute the gradient. If None, a random function will be selected. diff --git a/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb b/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb index 91a5e30eef..010f400017 100644 --- a/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb +++ b/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -32,7 +32,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -78,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -87,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -140,12 +140,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "# Define number of subsets\n", - "n_subsets = 10\n", + "n_subsets = 20\n", "\n", "# Initialize the lists containing the F_i's and A_i's\n", "f_subsets = []\n", @@ -169,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -192,37 +192,201 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 21, "metadata": {}, "outputs": [ { - "ename": "", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31mCannot execute code, session has been disposed. Please try restarting the Kernel." + "name": "stdout", + "output_type": "stream", + "text": [ + "Dask is not installed.\n", + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 1000 0.000 1.38039e+04\n", + " 100 1000 0.028 4.44989e+01\n", + " 200 1000 0.027 4.07130e+01\n", + " 300 1000 0.022 3.95771e+01\n", + " 400 1000 0.019 3.94965e+01\n", + " 500 1000 0.018 3.92958e+01\n", + " 600 1000 0.017 3.89547e+01\n", + " 700 1000 0.017 3.88912e+01\n", + " 800 1000 0.019 3.87862e+01\n", + " 900 1000 0.019 3.86670e+01\n", + " 1000 1000 0.018 3.89482e+01\n", + "-------------------------------------------------------\n", + " 1000 1000 0.018 3.89482e+01\n", + "Stop criterion has been reached.\n", + "\n" ] }, { - "ename": "", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31mThe Kernel crashed while executing code in the the current cell or a previous cell. Please review the code in the cell(s) to identify a possible cause of the failure. Click here for more info. View Jupyter log for further details." + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "stochastic_objective=SGFunction(f_subsets,sampler)\n", + "mySGD_LS = GD(initial=ig2D.allocate(0), \n", + " objective_function=stochastic_objective, \n", + " step_size=0.001, \n", + " max_iteration=1000, \n", + " update_objective_interval=100)\n", + "mySGD_LS.run(1000, verbose=1)\n", + "\n", + "show2D(mySGD_LS.solution)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Dask is not installed.\n", + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 1000 0.000 1.38039e+04\n", + " 100 1000 0.011 4.39259e+01\n", + " 200 1000 0.011 4.02738e+01\n", + " 300 1000 0.014 3.97689e+01\n", + " 400 1000 0.017 3.94480e+01\n", + " 500 1000 0.017 3.93345e+01\n", + " 600 1000 0.016 3.89108e+01\n", + " 700 1000 0.016 4.04457e+01\n", + " 800 1000 0.015 3.90482e+01\n", + " 900 1000 0.015 3.88493e+01\n", + " 1000 1000 0.016 3.87953e+01\n", + "-------------------------------------------------------\n", + " 1000 1000 0.016 3.87953e+01\n", + "Stop criterion has been reached.\n", + "\n" ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "stochastic_objective=SGFunction(f_subsets,sampler)\n", "mySGD_LS = GD(initial=ig2D.allocate(0), \n", " objective_function=stochastic_objective, \n", - " step_size=None, \n", + " step_size=0.001, \n", + " max_iteration=1000, \n", + " update_objective_interval=100)\n", + "mySGD_LS.run(1000, verbose=1)\n", + "\n", + "show2D(mySGD_LS.solution)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 1000 0.000 1.38039e+04\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " 100 1000 0.030 4.34737e+01\n", + " 200 1000 0.023 3.99915e+01\n", + " 300 1000 0.021 3.92955e+01\n", + " 400 1000 0.024 3.89863e+01\n", + " 500 1000 0.025 3.87991e+01\n", + " 600 1000 0.024 3.86670e+01\n", + " 700 1000 0.023 3.85653e+01\n", + " 800 1000 0.023 3.84827e+01\n", + " 900 1000 0.025 3.84133e+01\n", + " 1000 1000 0.024 3.83534e+01\n", + "-------------------------------------------------------\n", + " 1000 1000 0.024 3.83534e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f = LeastSquares(A, b=data)\n", + "myGD_LS = GD(initial=ig2D.allocate(0), \n", + " objective_function=f, \n", + " step_size=0.001, \n", " max_iteration=1000, \n", - " update_objective_interval=10)\n", - "mySGD_LS.run(300, verbose=1)\n", + " update_objective_interval=100)\n", + "myGD_LS.run(1000, verbose=1)\n", "\n", "show2D(mySGD_LS.solution)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 2bce666a30edabb55c0e09c7b416aef19239f59a Mon Sep 17 00:00:00 2001 From: Margaret Duff <43645617+MargaretDuff@users.noreply.github.com> Date: Tue, 8 Aug 2023 12:23:29 +0100 Subject: [PATCH 007/152] Update sampling.py Quick docstring Signed-off-by: Margaret Duff <43645617+MargaretDuff@users.noreply.github.com> --- Wrappers/Python/cil/optimisation/algorithms/sampling.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampling.py b/Wrappers/Python/cil/optimisation/algorithms/sampling.py index b41b7032c8..3481e170b5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/sampling.py +++ b/Wrappers/Python/cil/optimisation/algorithms/sampling.py @@ -19,7 +19,9 @@ import numpy as np import math class Sampling(): - + + r"""Takes an integer number of subsets and a sampling type and returns a class object with a next function. On each call of next, an integer value between 0 and the number of subsets is returned, the next sample.""" + def __init__(self, num_subsets, sampling_type='sequential', prob=None, seed=99): self.type=sampling_type self.num_subsets=num_subsets @@ -98,4 +100,4 @@ def show_epochs(self, num_epochs=2): elif self.type=='herman_meyer': for i in range(num_epochs): print('Epoch {}: '.format(i), self.order) - \ No newline at end of file + From ea759c5a87ba99a75cc21eb6d2040aeea1800555 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 9 Aug 2023 10:59:04 +0000 Subject: [PATCH 008/152] Changed to factory method style and added in permuatations --- .../algorithms/{sampling.py => sampler.py} | 101 +++++++++++------- 1 file changed, 62 insertions(+), 39 deletions(-) rename Wrappers/Python/cil/optimisation/algorithms/{sampling.py => sampler.py} (52%) diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampling.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py similarity index 52% rename from Wrappers/Python/cil/optimisation/algorithms/sampling.py rename to Wrappers/Python/cil/optimisation/algorithms/sampler.py index 3481e170b5..5676ed1da5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/sampling.py +++ b/Wrappers/Python/cil/optimisation/algorithms/sampler.py @@ -18,31 +18,58 @@ import numpy as np import math -class Sampling(): +import time +class Sampler(): r"""Takes an integer number of subsets and a sampling type and returns a class object with a next function. On each call of next, an integer value between 0 and the number of subsets is returned, the next sample.""" - def __init__(self, num_subsets, sampling_type='sequential', prob=None, seed=99): + + @staticmethod + def hermanMeyer(num_subsets): + order=_herman_meyer_order(self.num_subsets) + sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) + return sampler + + @staticmethod + def sequential(num_subsets): + order=range(self.num_subsets) + sampler=Sampler(num_subsets, sampling_type='sequential', order=order) + return sampler + + @staticmethod + def randomWithReplacement(num_subsets, prob=None, seed=None): + if prob==None: + prob = [1/self.num_subsets] * self.num_subsets + else: + prob=prob + sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) + return sampler + + @staticmethod + def randomWithoutReplacement(num_subsets, seed=None): + order=range(self.num_subsets) + sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) + return sampler + + + def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): self.type=sampling_type self.num_subsets=num_subsets - self.seed=seed - - self.last_subset=-1 - if self.type=='sequential': - pass - elif self.type=='random': - if prob==None: - self.prob = [1/self.num_subsets] * self.num_subsets - else: - self.prob=prob - elif self.type=='herman_meyer': - - self.order=self.herman_meyer_order(self.num_subsets) + if seed !=None: + self.seed=seed else: - raise NameError('Please choose from sequential, random, herman_meyer') - + self.seed=int(time.time()) + self.order=order + if order!=None: + self.iterator=self._next_order + self.prob=prob + if prob!=None: + self.iterator=self._next_prob + self.shuffle=shuffle + self.last_subset=self.num_subsets-1 + - def herman_meyer_order(self, n): + def _herman_meyer_order(self, n): # Assuming that the subsets are in geometrical order n_variable = n i = 2 @@ -75,29 +102,25 @@ def herman_meyer_order(self, n): order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping return order + + def _next_order(self) + if shuffle=True & self.last_subset==self.numsubsets-1: + self.order=np.random.perumatation(self.order) + self.last_subset= (self.last_subset+1)%self.num_subsets + return(self.order[self.last_subset]) + + def _next_prob(self): + return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + def next(self): - if self.type=='sequential': - self.last_subset= (self.last_subset+1)%self.num_subsets - return self.last_subset - elif self.type=='random': - if self.last_subset==-1: - np.random.seed(self.seed) - self.last_subset=0 - return int(np.random.choice(self.num_subsets, 1, p=self.prob)) - elif self.type=='herman_meyer': - self.last_subset= (self.last_subset+1)%self.num_subsets - return(self.order[self.last_subset]) + return (self.iterator()) def show_epochs(self, num_epochs=2): - if self.type=='sequential': - for i in range(num_epochs): - print('Epoch {}: '.format(i), [j for j in range(self.num_subsets)]) - elif self.type=='random': - np.random.seed(self.seed) - for i in range(num_epochs): - print('Epoch {}: '.format(i), np.random.choice(self.num_subsets, self.num_subsets, p=self.prob)) - elif self.type=='herman_meyer': - for i in range(num_epochs): - print('Epoch {}: '.format(i), self.order) + current_state=np.random.get_state() + np.random.seed(self.seed) + for i in range(num_epochs): + rint('Epoch {}: '.format(i), [next() for _ in range(self.num_subsets)]) + np.random.set_state(current_state) + From d1909a381832ee198cc2e0dfe220cba684dda09d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 9 Aug 2023 13:20:34 +0000 Subject: [PATCH 009/152] Debugging and fixing random generator in show epochs --- .../cil/optimisation/algorithms/sampler.py | 109 +++---- .../algorithms/testing_sampling.ipynb | 277 +++++++++++++----- 2 files changed, 270 insertions(+), 116 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampler.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py index 5676ed1da5..aaf1334ab5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/sampler.py +++ b/Wrappers/Python/cil/optimisation/algorithms/sampler.py @@ -23,31 +23,66 @@ class Sampler(): r"""Takes an integer number of subsets and a sampling type and returns a class object with a next function. On each call of next, an integer value between 0 and the number of subsets is returned, the next sample.""" + @staticmethod def hermanMeyer(num_subsets): - order=_herman_meyer_order(self.num_subsets) + @staticmethod + def _herman_meyer_order(n): + # Assuming that the subsets are in geometrical order + n_variable = n + i = 2 + factors = [] + while i * i <= n_variable: + if n_variable % i: + i += 1 + else: + n_variable //= i + factors.append(i) + if n_variable > 1: + factors.append(n_variable) + n_factors = len(factors) + order = [0 for _ in range(n)] + value = 0 + for factor_n in range(n_factors): + n_rep_value = 0 + if factor_n == 0: + n_change_value = 1 + else: + n_change_value = math.prod(factors[:factor_n]) + for element in range(n): + mapping = value + n_rep_value += 1 + if n_rep_value >= n_change_value: + value = value + 1 + n_rep_value = 0 + if value == factors[factor_n]: + value = 0 + order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping + return order + + order=_herman_meyer_order(num_subsets) sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) return sampler @staticmethod def sequential(num_subsets): - order=range(self.num_subsets) + order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='sequential', order=order) return sampler @staticmethod def randomWithReplacement(num_subsets, prob=None, seed=None): if prob==None: - prob = [1/self.num_subsets] * self.num_subsets - else: - prob=prob + prob = [1/num_subsets] *num_subsets + else: + prob=prob sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) return sampler @staticmethod def randomWithoutReplacement(num_subsets, seed=None): - order=range(self.num_subsets) + order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) return sampler @@ -59,7 +94,9 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N self.seed=seed else: self.seed=int(time.time()) + self.generator=np.random.RandomState(self.seed) self.order=order + self.initial_order=order if order!=None: self.iterator=self._next_order self.prob=prob @@ -68,59 +105,31 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N self.shuffle=shuffle self.last_subset=self.num_subsets-1 - - def _herman_meyer_order(self, n): - # Assuming that the subsets are in geometrical order - n_variable = n - i = 2 - factors = [] - while i * i <= n_variable: - if n_variable % i: - i += 1 - else: - n_variable //= i - factors.append(i) - if n_variable > 1: - factors.append(n_variable) - n_factors = len(factors) - order = [0 for _ in range(n)] - value = 0 - for factor_n in range(n_factors): - n_rep_value = 0 - if factor_n == 0: - n_change_value = 1 - else: - n_change_value = math.prod(factors[:factor_n]) - for element in range(n): - mapping = value - n_rep_value += 1 - if n_rep_value >= n_change_value: - value = value + 1 - n_rep_value = 0 - if value == factors[factor_n]: - value = 0 - order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping - return order + - def _next_order(self) - if shuffle=True & self.last_subset==self.numsubsets-1: - self.order=np.random.perumatation(self.order) - self.last_subset= (self.last_subset+1)%self.num_subsets - return(self.order[self.last_subset]) + def _next_order(self): + # print(self.last_subset) + if self.shuffle==True and self.last_subset==self.num_subsets-1: + self.order=self.generator.permutation(self.order) + print(self.order) + self.last_subset= (self.last_subset+1)%self.num_subsets + return(self.order[self.last_subset]) def _next_prob(self): - return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) def next(self): return (self.iterator()) def show_epochs(self, num_epochs=2): - current_state=np.random.get_state() - np.random.seed(self.seed) + save_generator=self.generator + save_order=self.order + self.order=self.initial_order + self.generator=np.random.RandomState(self.seed) for i in range(num_epochs): - rint('Epoch {}: '.format(i), [next() for _ in range(self.num_subsets)]) - np.random.set_state(current_state) - + print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) + self.generator=save_generator + self.order=save_order diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb index f135686d3c..a187c08575 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -11,7 +11,7 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import os\n", - "from sampling import Sampling\n" + "from sampler import Sampler\n" ] }, { @@ -132,7 +132,7 @@ } ], "source": [ - "sampler=Sampling(10,'sequential')\n", + "sampler=Sampler.sequential(10)\n", "sampler.show_epochs(5)\n", "for _ in range(100):\n", " print(sampler.next())" @@ -147,116 +147,131 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: [ 7 5 9 0 8 6 3 0 10 0 8]\n", - "Epoch 1: [ 8 4 5 10 4 10 5 1 8 2 6]\n", - "Epoch 2: [3 8 9 2 7 1 4 1 1 2 5]\n", - "Epoch 3: [ 0 2 0 9 6 1 10 5 0 5 7]\n", - "Epoch 4: [ 8 9 2 10 5 2 6 4 2 10 10]\n", - "7\n", - "5\n", - "9\n", - "0\n", - "8\n", - "6\n", + "[ 2 4 3 0 10 5 6 8 7 1 9]\n", + "Epoch 0: [2, 4, 3, 0, 10, 5, 6, 8, 7, 1, 9]\n", + "[ 2 7 6 1 4 10 5 8 0 3 9]\n", + "Epoch 1: [2, 7, 6, 1, 4, 10, 5, 8, 0, 3, 9]\n", + "[ 3 9 8 5 7 10 4 2 6 1 0]\n", + "Epoch 2: [3, 9, 8, 5, 7, 10, 4, 2, 6, 1, 0]\n", + "[ 3 1 9 10 4 2 0 6 7 5 8]\n", + "Epoch 3: [3, 1, 9, 10, 4, 2, 0, 6, 7, 5, 8]\n", + "[ 6 8 1 5 10 7 4 9 0 3 2]\n", + "Epoch 4: [6, 8, 1, 5, 10, 7, 4, 9, 0, 3, 2]\n", + "[ 2 4 3 0 10 5 6 8 7 1 9]\n", + "2\n", + "4\n", "3\n", "0\n", "10\n", - "0\n", - "8\n", - "8\n", - "4\n", "5\n", - "10\n", - "4\n", - "10\n", - "5\n", - "1\n", - "8\n", - "2\n", "6\n", - "3\n", "8\n", - "9\n", - "2\n", "7\n", "1\n", - "4\n", - "1\n", - "1\n", - "2\n", - "5\n", - "0\n", - "2\n", - "0\n", "9\n", + "[ 2 7 6 1 4 10 5 8 0 3 9]\n", + "2\n", + "7\n", "6\n", "1\n", + "4\n", "10\n", "5\n", + "8\n", "0\n", + "3\n", + "9\n", + "[ 3 9 8 5 7 10 4 2 6 1 0]\n", + "3\n", + "9\n", + "8\n", "5\n", "7\n", - "8\n", - "9\n", - "2\n", "10\n", - "5\n", - "2\n", - "6\n", "4\n", "2\n", - "10\n", - "10\n", + "6\n", + "1\n", + "0\n", + "[ 3 1 9 10 4 2 0 6 7 5 8]\n", + "3\n", + "1\n", "9\n", + "10\n", "4\n", - "7\n", - "9\n", + "2\n", "0\n", - "4\n", + "6\n", "7\n", + "5\n", + "8\n", + "[ 6 8 1 5 10 7 4 9 0 3 2]\n", + "6\n", + "8\n", + "1\n", + "5\n", "10\n", "7\n", - "7\n", - "2\n", + "4\n", + "9\n", + "0\n", "3\n", + "2\n", + "[ 4 1 2 7 0 5 10 3 8 9 6]\n", + "4\n", "1\n", - "3\n", + "2\n", "7\n", - "10\n", "0\n", + "5\n", + "10\n", "3\n", - "0\n", + "8\n", "9\n", - "7\n", + "6\n", + "[ 5 6 9 3 10 4 1 0 8 2 7]\n", + "5\n", + "6\n", "9\n", + "3\n", "10\n", + "4\n", "1\n", - "5\n", + "0\n", + "8\n", + "2\n", + "7\n", + "[ 6 7 0 3 1 10 8 5 4 2 9]\n", "6\n", - "5\n", "7\n", - "9\n", - "2\n", + "0\n", + "3\n", "1\n", - "6\n", + "10\n", + "8\n", + "5\n", + "4\n", "2\n", "9\n", - "5\n", + "[ 9 4 7 3 6 0 5 8 10 2 1]\n", + "9\n", + "4\n", "7\n", "3\n", - "1\n", - "3\n", - "1\n", - "2\n", + "6\n", + "0\n", "5\n", - "3\n", "8\n", - "7\n" + "10\n", + "2\n", + "1\n", + "[ 3 8 10 7 2 0 6 1 9 5 4]\n", + "3\n" ] } ], "source": [ - "sampler=Sampling(11,'random')\n", + "sampler=Sampler.randomWithoutReplacement(11)\n", "sampler.show_epochs(5)\n", "for _ in range(100):\n", " print(sampler.next())" @@ -380,12 +395,142 @@ } ], "source": [ - "sampler=Sampling(60,'herman_meyer')\n", + "sampler=Sampler.hermanMeyer(60)\n", "sampler.show_epochs(5)\n", "for _ in range(100):\n", " print(sampler.next())" ] }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: [3, 3, 10, 8, 7, 9, 1, 3, 10, 5, 2]\n", + "Epoch 1: [4, 1, 10, 8, 8, 3, 4, 6, 0, 1, 8]\n", + "Epoch 2: [8, 4, 3, 9, 5, 5, 8, 0, 7, 0, 4]\n", + "Epoch 3: [9, 4, 10, 8, 2, 1, 8, 4, 8, 6, 9]\n", + "Epoch 4: [8, 1, 2, 1, 10, 9, 2, 9, 0, 0, 4]\n", + "3\n", + "3\n", + "10\n", + "8\n", + "7\n", + "9\n", + "1\n", + "3\n", + "10\n", + "5\n", + "2\n", + "4\n", + "1\n", + "10\n", + "8\n", + "8\n", + "3\n", + "4\n", + "6\n", + "0\n", + "1\n", + "8\n", + "8\n", + "4\n", + "3\n", + "9\n", + "5\n", + "5\n", + "8\n", + "0\n", + "7\n", + "0\n", + "4\n", + "9\n", + "4\n", + "10\n", + "8\n", + "2\n", + "1\n", + "8\n", + "4\n", + "8\n", + "6\n", + "9\n", + "8\n", + "1\n", + "2\n", + "1\n", + "10\n", + "9\n", + "2\n", + "9\n", + "0\n", + "0\n", + "4\n", + "8\n", + "4\n", + "6\n", + "7\n", + "7\n", + "6\n", + "3\n", + "3\n", + "0\n", + "5\n", + "8\n", + "8\n", + "3\n", + "1\n", + "7\n", + "5\n", + "4\n", + "8\n", + "3\n", + "8\n", + "5\n", + "5\n", + "3\n", + "10\n", + "8\n", + "5\n", + "6\n", + "3\n", + "3\n", + "2\n", + "8\n", + "4\n", + "6\n", + "3\n", + "7\n", + "10\n", + "4\n", + "2\n", + "7\n", + "6\n", + "6\n", + "1\n", + "5\n", + "8\n", + "5\n", + "Epoch 0: [3, 3, 10, 8, 7, 9, 1, 3, 10, 5, 2]\n", + "Epoch 1: [4, 1, 10, 8, 8, 3, 4, 6, 0, 1, 8]\n", + "Epoch 2: [8, 4, 3, 9, 5, 5, 8, 0, 7, 0, 4]\n", + "Epoch 3: [9, 4, 10, 8, 2, 1, 8, 4, 8, 6, 9]\n", + "Epoch 4: [8, 1, 2, 1, 10, 9, 2, 9, 0, 0, 4]\n" + ] + } + ], + "source": [ + "sampler=Sampler.randomWithReplacement(11)\n", + "sampler.show_epochs(5)\n", + "for _ in range(100):\n", + " print(sampler.next())\n", + "sampler.show_epochs(5)" + ] + }, { "cell_type": "code", "execution_count": null, From 98b0694db3b2e60e2d89adbb16c1336518a82cf9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 9 Aug 2023 15:32:37 +0000 Subject: [PATCH 010/152] Testing SPDHG --- .../optimisation/algorithms/SPDHG_sampling.py | 16 ++- .../SPDHG_sampling.cpython-310.pyc | Bin 7987 -> 8022 bytes .../algorithms/testing_sampling.ipynb | 118 ++++-------------- .../algorithms/testing_sampling_SPDHG.ipynb | 102 +++++++++------ 4 files changed, 91 insertions(+), 145 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py index e860500b7e..ea5083ea08 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging -from sampling import Sampling +from sampler import Sampler class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -50,7 +50,7 @@ class SPDHG(Algorithm): List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: instnace of the Sampling class + sampler: instnace of the Sampler class Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets **kwargs: norms : list of floats @@ -144,20 +144,18 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ self.tau = tau self.sigma = sigma self.prob = prob - self.ndual_subsets = len(self.operator) + self.ndual_subsets = len(self.f) self.gamma = gamma self.rho = .99 self.sampler=sampler if self.sampler==None: - if self.prob != None: - self.sampler=Sampling(self.ndual_subsets, 'random', prob=self.prob) - else: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - self.sampler=Sampling(self.ndual_subsets, 'random', prob=self.prob) + if self.prob == None: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) else: if self.prob==None: - if self.sampler.type=='random': + if self.sampler.prob!=None: self.prob=self.sampler.prob else: self.prob = [1/self.ndual_subsets] * self.ndual_subsets diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc index af5025487fe715bfddba8e7e8c1b9d1ffd0f3e3a..1736e8dc51b534726c18e85e3a339f29a2dde79b 100644 GIT binary patch delta 1054 zcmZ`%OHUI~6rMAs(=xQ>)t1s1cq5CfDzf&?}g z$z5tpo4638Zt9Mei9f(-Vj>A!jccRv5u@j{k$~bXzWd$peCL}v_fER)ZJRA-wW<<6 zHJfjkt$M?j$Tjtars9)fKDJS4-*~hPchfbHmm`OHy485y1nQ7fX&EI46dk?m}4wJ2*j=Enoqstjg&XXB0}BuzA}!9g5G6@)MLs zKP5jV6jw8}h?B1RyyN6Bgc#$k;+882Wg_J&gO}+St|Cy*kh@8|EA=QXMBBypQXg7e z?gscEy4?>Cdq}1UH)T%qb9&=JbAJ^sPor{{s#T)L&4Sq_BARUC`cf-d|gl@4E~0yPI8<_*fz&`EFR|iEbk|6fMAHALtOHA!hm?-@3hsD N5G0_x6kq(Oegkjb_cH(h delta 1063 zcmZ`(OHUI~6rMBF4rSFl|Bny!{nGI26_Pfd)^m}6AWKp`9sTlw%=4W~2Fr*=%t1h8KL$=Z1|F3?m z<}+nn;&)PbKfESqrR%^PEWdrmku0H@X*e!T!!0d^QT_TXU|D1NGmex-I%@goa;!IJ zl3rGTH7QvtR$Tk0USK6JU6zs3KIY7j*B`T|)N~+2kLLfYYRpOL;0|{P*E_q*|5%4< z;C_?25G#^W8kjpRW2!P@%RmMkATgy+s`X@N+(&I@PUX=Ui;vX;cj1OiE?kO_n~8A? z_hOKl1B2py@jd$*U`bdd6YyAkD4C3eaha22!%M)uNO>WFpP&NaDUnJsr}x%u7_DI* zK`kdIhBvIc{m<@uO{f$V-Yf1ZYV{B(2x8IuZqG?1x}hp6Y@NWy7?C!j$H;6OjVBU0HELOdF;=UtkDQaOW^Rg(Kr^fg9$2gklAY#Sk~vMy=}G=I z?Pt+pw5X@3S}krGA^0dB7_D$dECjP2guZMOTJeI>n57{NyMEYWJw9jtVH zLHbEXD3m94VFq=v81Tz{J-dOjc@4pO)c=xykfTq04>oNjH-)MSzL9zXVbUvp1-*iY z+VFio54EVBDE^ehYUl(si2Cy8NEcbV5poWT$E`u0oZ#n3J5O+tpi|r~?}Q%ls=TwL RiG(_YoFlRM3lRSB;oplJ`1=3= diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb index a187c08575..64a25a7c76 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -403,132 +403,56 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: [3, 3, 10, 8, 7, 9, 1, 3, 10, 5, 2]\n", - "Epoch 1: [4, 1, 10, 8, 8, 3, 4, 6, 0, 1, 8]\n", - "Epoch 2: [8, 4, 3, 9, 5, 5, 8, 0, 7, 0, 4]\n", - "Epoch 3: [9, 4, 10, 8, 2, 1, 8, 4, 8, 6, 9]\n", - "Epoch 4: [8, 1, 2, 1, 10, 9, 2, 9, 0, 0, 4]\n", - "3\n", - "3\n", - "10\n", - "8\n", + "Epoch 0: [7, 1, 6, 6, 4, 7, 6, 7, 7, 4, 5]\n", + "Epoch 1: [6, 3, 4, 7, 1, 4, 9, 6, 9, 2, 5]\n", + "Epoch 2: [4, 7, 7, 4, 3, 1, 10, 10, 6, 0, 1]\n", + "Epoch 3: [6, 1, 10, 5, 9, 2, 5, 10, 5, 8, 1]\n", + "Epoch 4: [8, 8, 3, 6, 7, 8, 4, 7, 10, 7, 9]\n", "7\n", - "9\n", - "1\n", - "3\n", - "10\n", - "5\n", - "2\n", - "4\n", "1\n", - "10\n", - "8\n", - "8\n", - "3\n", - "4\n", "6\n", - "0\n", - "1\n", - "8\n", - "8\n", - "4\n", - "3\n", - "9\n", - "5\n", - "5\n", - "8\n", - "0\n", - "7\n", - "0\n", - "4\n", - "9\n", - "4\n", - "10\n", - "8\n", - "2\n", - "1\n", - "8\n", - "4\n", - "8\n", "6\n", - "9\n", - "8\n", - "1\n", - "2\n", - "1\n", - "10\n", - "9\n", - "2\n", - "9\n", - "0\n", - "0\n", - "4\n", - "8\n", "4\n", - "6\n", - "7\n", "7\n", "6\n", - "3\n", - "3\n", - "0\n", - "5\n", - "8\n", - "8\n", - "3\n", - "1\n", "7\n", - "5\n", + "7\n", "4\n", - "8\n", - "3\n", - "8\n", - "5\n", - "5\n", - "3\n", - "10\n", - "8\n", "5\n", + "Epoch 0: [7, 1, 6, 6, 4, 7, 6, 7, 7, 4, 5]\n", + "Epoch 1: [6, 3, 4, 7, 1, 4, 9, 6, 9, 2, 5]\n", + "Epoch 2: [4, 7, 7, 4, 3, 1, 10, 10, 6, 0, 1]\n", + "Epoch 3: [6, 1, 10, 5, 9, 2, 5, 10, 5, 8, 1]\n", + "Epoch 4: [8, 8, 3, 6, 7, 8, 4, 7, 10, 7, 9]\n", "6\n", "3\n", - "3\n", - "2\n", - "8\n", "4\n", - "6\n", - "3\n", "7\n", - "10\n", + "1\n", "4\n", - "2\n", - "7\n", - "6\n", + "9\n", "6\n", - "1\n", - "5\n", - "8\n", - "5\n", - "Epoch 0: [3, 3, 10, 8, 7, 9, 1, 3, 10, 5, 2]\n", - "Epoch 1: [4, 1, 10, 8, 8, 3, 4, 6, 0, 1, 8]\n", - "Epoch 2: [8, 4, 3, 9, 5, 5, 8, 0, 7, 0, 4]\n", - "Epoch 3: [9, 4, 10, 8, 2, 1, 8, 4, 8, 6, 9]\n", - "Epoch 4: [8, 1, 2, 1, 10, 9, 2, 9, 0, 0, 4]\n" + "9\n", + "2\n", + "5\n" ] } ], "source": [ "sampler=Sampler.randomWithReplacement(11)\n", "sampler.show_epochs(5)\n", - "for _ in range(100):\n", + "for _ in range(11):\n", " print(sampler.next())\n", - "sampler.show_epochs(5)" + "sampler.show_epochs(5)\n", + "for _ in range(11):\n", + " print(sampler.next())" ] }, { diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb index be4d3a1752..78fe5957cf 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb @@ -28,7 +28,7 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import os\n", - "from sampling import Sampling\n" + "from sampler import Sampler\n" ] }, { @@ -49,7 +49,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -106,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -138,13 +138,13 @@ " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", " f_subsets.append(fi)\n", " # Define A_i and put into list \n", - " ageom_subset = partitioned_data[i].geometry\n", - " Ai = ProjectionOperator(ig2D, ageom_subset)\n", - " A_subsets.append(Ai)\n", + "ageom_subset = partitioned_data.geometry\n", + "A = ProjectionOperator(ig2D, ageom_subset)\n", + "\n", "\n", "# Define F and K\n", "F = BlockFunction(*f_subsets)\n", - "K = BlockOperator(*A_subsets)\n", + "K = A\n", "\n", "# Define G (by default the positivity constraint is on)\n", "alpha = 0.025\n", @@ -153,7 +153,26 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print(ageom_subset)\n", + "print(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -163,13 +182,13 @@ " Iter Max Iter Time/Iter Objective\n", " [s] \n", " 0 50 0.000 6.90194e+03\n", - " 10 50 3.976 1.59092e+02\n", - " 20 50 5.019 5.91546e+01\n", - " 30 50 5.163 4.56431e+01\n", - " 40 50 4.928 4.06590e+01\n", - " 50 50 4.903 3.73280e+01\n", + " 10 50 3.313 1.59092e+02\n", + " 20 50 3.019 5.91546e+01\n", + " 30 50 2.909 4.56431e+01\n", + " 40 50 2.849 4.06590e+01\n", + " 50 50 2.813 3.73280e+01\n", "-------------------------------------------------------\n", - " 50 50 4.903 3.73280e+01\n", + " 50 50 2.813 3.73280e+01\n", "Stop criterion has been reached.\n", "\n" ] @@ -178,7 +197,7 @@ "source": [ "# Setup and run SPDHG for 50 iterations\n", "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampling(n_subsets, 'sequential'))\n", + " update_objective_interval = 10, sampler=Sampler.sequential(n_subsets))\n", "spdhg.run()\n", "\n", "spdhg_recon = spdhg.solution " @@ -186,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -196,13 +215,13 @@ " Iter Max Iter Time/Iter Objective\n", " [s] \n", " 0 50 0.000 6.90194e+03\n", - " 10 50 4.855 1.61868e+02\n", - " 20 50 4.709 6.13522e+01\n", - " 30 50 4.840 3.85550e+01\n", - " 40 50 4.864 3.88311e+01\n", - " 50 50 4.832 3.46613e+01\n", + " 10 50 0.071 1.68032e+02\n", + " 20 50 0.114 4.89967e+01\n", + " 30 50 0.096 4.18854e+01\n", + " 40 50 0.096 3.86103e+01\n", + " 50 50 0.092 3.70240e+01\n", "-------------------------------------------------------\n", - " 50 50 4.832 3.46613e+01\n", + " 50 50 0.092 3.70240e+01\n", "Stop criterion has been reached.\n", "\n" ] @@ -211,7 +230,7 @@ "source": [ "# Setup and run SPDHG for 50 iterations\n", "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampling(n_subsets, 'random'))\n", + " update_objective_interval = 10, sampler=Sampler.randomWithReplacement(n_subsets))\n", "spdhg.run()\n", "\n", "spdhg_recon = spdhg.solution " @@ -219,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -229,13 +248,18 @@ " Iter Max Iter Time/Iter Objective\n", " [s] \n", " 0 50 0.000 6.90194e+03\n", - " 10 50 5.370 1.61868e+02\n", - " 20 50 5.122 6.13522e+01\n", - " 30 50 5.079 3.85550e+01\n", - " 40 50 5.180 3.88311e+01\n", - " 50 50 5.169 3.46613e+01\n", + "[8 7 5 4 3 2 6 0 9 1]\n", + " 10 50 2.593 1.57735e+02\n", + "[2 0 9 6 3 5 1 4 8 7]\n", + " 20 50 2.916 5.82732e+01\n", + "[3 4 1 9 5 6 2 8 7 0]\n", + " 30 50 3.032 4.02467e+01\n", + "[4 9 6 2 5 3 7 1 0 8]\n", + " 40 50 2.937 3.73084e+01\n", + "[0 7 2 6 8 3 5 9 4 1]\n", + " 50 50 2.880 3.50773e+01\n", "-------------------------------------------------------\n", - " 50 50 5.169 3.46613e+01\n", + " 50 50 2.880 3.50773e+01\n", "Stop criterion has been reached.\n", "\n" ] @@ -244,7 +268,7 @@ "source": [ "# Setup and run SPDHG for 50 iterations\n", "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10)\n", + " update_objective_interval = 10 , sampler=Sampler.randomWithoutReplacement(n_subsets))\n", "spdhg.run()\n", "\n", "spdhg_recon = spdhg.solution " @@ -252,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -262,13 +286,13 @@ " Iter Max Iter Time/Iter Objective\n", " [s] \n", " 0 50 0.000 6.90194e+03\n", - " 10 50 4.708 1.56371e+02\n", - " 20 50 4.701 5.73612e+01\n", - " 30 50 4.564 4.46291e+01\n", - " 40 50 4.731 4.00863e+01\n", - " 50 50 4.812 3.69452e+01\n", + " 10 50 2.494 1.56371e+02\n", + " 20 50 3.314 5.73612e+01\n", + " 30 50 3.081 4.46291e+01\n", + " 40 50 2.944 4.00863e+01\n", + " 50 50 2.862 3.69452e+01\n", "-------------------------------------------------------\n", - " 50 50 4.812 3.69452e+01\n", + " 50 50 2.862 3.69452e+01\n", "Stop criterion has been reached.\n", "\n" ] @@ -276,7 +300,7 @@ ], "source": [ "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampling(n_subsets, 'herman_meyer'))\n", + " update_objective_interval = 10, sampler=Sampler.hermanMeyer(n_subsets))\n", "spdhg.run()\n", "\n", "spdhg_recon = spdhg.solution " From 05b67cb683bce486c0ae581c43c7014bdbfa3179 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 10 Aug 2023 09:45:43 +0000 Subject: [PATCH 011/152] Changed the show epochs --- .../SPDHG_sampling.cpython-310.pyc | Bin 8022 -> 8022 bytes .../cil/optimisation/algorithms/sampler.py | 7 +- .../algorithms/testing_sampling.ipynb | 285 +++++++++--------- .../algorithms/testing_sampling_SPDHG.ipynb | 44 ++- 4 files changed, 163 insertions(+), 173 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc index 1736e8dc51b534726c18e85e3a339f29a2dde79b..6a00f61acf1be2c577ed24a01169f0ddf83fc42f 100644 GIT binary patch delta 29 jcmca+cg>DBpO=@50SIK~UrAx#$a{u|k#+Meo*E$le!U2W delta 29 jcmca+cg>DBpO=@50SI(fUQXfL$a{u|k$v+mo*E$lfTaki diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampler.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py index aaf1334ab5..f175340c49 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/sampler.py +++ b/Wrappers/Python/cil/optimisation/algorithms/sampler.py @@ -112,7 +112,7 @@ def _next_order(self): # print(self.last_subset) if self.shuffle==True and self.last_subset==self.num_subsets-1: self.order=self.generator.permutation(self.order) - print(self.order) + #print(self.order) self.last_subset= (self.last_subset+1)%self.num_subsets return(self.order[self.last_subset]) @@ -125,6 +125,8 @@ def next(self): def show_epochs(self, num_epochs=2): save_generator=self.generator + save_last_subset=self.last_subset + self.last_subset=self.num_subsets-1 save_order=self.order self.order=self.initial_order self.generator=np.random.RandomState(self.seed) @@ -132,4 +134,5 @@ def show_epochs(self, num_epochs=2): print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) self.generator=save_generator self.order=save_order - + self.last_subset=save_last_subset + diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb index 64a25a7c76..171bc3e4f4 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -16,18 +16,22 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "0\n", "1\n", "2\n", @@ -140,157 +144,60 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 2 4 3 0 10 5 6 8 7 1 9]\n", - "Epoch 0: [2, 4, 3, 0, 10, 5, 6, 8, 7, 1, 9]\n", - "[ 2 7 6 1 4 10 5 8 0 3 9]\n", - "Epoch 1: [2, 7, 6, 1, 4, 10, 5, 8, 0, 3, 9]\n", - "[ 3 9 8 5 7 10 4 2 6 1 0]\n", - "Epoch 2: [3, 9, 8, 5, 7, 10, 4, 2, 6, 1, 0]\n", - "[ 3 1 9 10 4 2 0 6 7 5 8]\n", - "Epoch 3: [3, 1, 9, 10, 4, 2, 0, 6, 7, 5, 8]\n", - "[ 6 8 1 5 10 7 4 9 0 3 2]\n", - "Epoch 4: [6, 8, 1, 5, 10, 7, 4, 9, 0, 3, 2]\n", - "[ 2 4 3 0 10 5 6 8 7 1 9]\n", - "2\n", - "4\n", - "3\n", - "0\n", - "10\n", - "5\n", - "6\n", - "8\n", - "7\n", - "1\n", - "9\n", - "[ 2 7 6 1 4 10 5 8 0 3 9]\n", - "2\n", - "7\n", - "6\n", - "1\n", - "4\n", - "10\n", - "5\n", - "8\n", - "0\n", - "3\n", - "9\n", - "[ 3 9 8 5 7 10 4 2 6 1 0]\n", - "3\n", - "9\n", - "8\n", - "5\n", - "7\n", - "10\n", - "4\n", - "2\n", - "6\n", - "1\n", - "0\n", - "[ 3 1 9 10 4 2 0 6 7 5 8]\n", - "3\n", - "1\n", - "9\n", - "10\n", - "4\n", - "2\n", - "0\n", - "6\n", - "7\n", - "5\n", - "8\n", - "[ 6 8 1 5 10 7 4 9 0 3 2]\n", - "6\n", - "8\n", - "1\n", - "5\n", - "10\n", - "7\n", - "4\n", - "9\n", - "0\n", - "3\n", - "2\n", - "[ 4 1 2 7 0 5 10 3 8 9 6]\n", - "4\n", - "1\n", - "2\n", - "7\n", - "0\n", - "5\n", - "10\n", - "3\n", - "8\n", - "9\n", - "6\n", - "[ 5 6 9 3 10 4 1 0 8 2 7]\n", - "5\n", - "6\n", - "9\n", - "3\n", - "10\n", - "4\n", - "1\n", - "0\n", - "8\n", - "2\n", - "7\n", - "[ 6 7 0 3 1 10 8 5 4 2 9]\n", - "6\n", - "7\n", - "0\n", - "3\n", - "1\n", - "10\n", - "8\n", - "5\n", - "4\n", - "2\n", - "9\n", - "[ 9 4 7 3 6 0 5 8 10 2 1]\n", - "9\n", - "4\n", - "7\n", - "3\n", - "6\n", - "0\n", - "5\n", - "8\n", - "10\n", - "2\n", - "1\n", - "[ 3 8 10 7 2 0 6 1 9 5 4]\n", - "3\n" + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "Epoch 0: [6, 9, 7, 5, 1, 8, 3, 2, 4, 0, 10]\n", + "Epoch 1: [7, 3, 0, 4, 8, 1, 10, 9, 6, 2, 5]\n", + "Epoch 2: [2, 9, 3, 7, 1, 6, 5, 0, 8, 4, 10]\n", + "Epoch 3: [3, 0, 6, 1, 10, 7, 2, 9, 8, 5, 4]\n", + "Epoch 4: [4, 5, 10, 6, 9, 8, 7, 3, 2, 0, 1]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "[ 2 9 3 7 1 6 5 0 8 4 10]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "Epoch 0: [6, 9, 7, 5, 1, 8, 3, 2, 4, 0, 10]\n", + "Epoch 1: [7, 3, 0, 4, 8, 1, 10, 9, 6, 2, 5]\n", + "Epoch 2: [2, 9, 3, 7, 1, 6, 5, 0, 8, 4, 10]\n", + "Epoch 3: [3, 0, 6, 1, 10, 7, 2, 9, 8, 5, 4]\n", + "Epoch 4: [4, 5, 10, 6, 9, 8, 7, 3, 2, 0, 1]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "[ 2 9 3 7 1 6 5 0 8 4 10]\n" ] } ], "source": [ "sampler=Sampler.randomWithoutReplacement(11)\n", "sampler.show_epochs(5)\n", - "for _ in range(100):\n", - " print(sampler.next())" + "for _ in range(30):\n", + " sampler.next()\n", + "sampler.show_epochs(5)\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 0: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 1: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 2: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 3: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 4: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "0\n", "30\n", "15\n", @@ -403,56 +310,140 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: [7, 1, 6, 6, 4, 7, 6, 7, 7, 4, 5]\n", - "Epoch 1: [6, 3, 4, 7, 1, 4, 9, 6, 9, 2, 5]\n", - "Epoch 2: [4, 7, 7, 4, 3, 1, 10, 10, 6, 0, 1]\n", - "Epoch 3: [6, 1, 10, 5, 9, 2, 5, 10, 5, 8, 1]\n", - "Epoch 4: [8, 8, 3, 6, 7, 8, 4, 7, 10, 7, 9]\n", + "None\n", + "None\n", + "Epoch 0: [9, 2, 2, 6, 9, 9, 9, 4, 7, 8, 5]\n", + "Epoch 1: [8, 8, 2, 3, 6, 10, 7, 2, 10, 9, 2]\n", + "Epoch 2: [1, 9, 3, 2, 6, 4, 6, 4, 4, 1, 5]\n", + "Epoch 3: [1, 0, 7, 8, 2, 5, 1, 6, 5, 0, 10]\n", + "Epoch 4: [9, 10, 3, 10, 7, 8, 7, 8, 0, 6, 8]\n", + "None\n", + "None\n", + "9\n", + "2\n", + "2\n", + "6\n", + "9\n", + "9\n", + "9\n", + "4\n", "7\n", + "8\n", + "5\n", + "8\n", + "8\n", + "2\n", + "3\n", + "6\n", + "10\n", + "7\n", + "2\n", + "10\n", + "9\n", + "2\n", "1\n", + "9\n", + "3\n", + "2\n", "6\n", + "4\n", "6\n", "4\n", + "4\n", + "1\n", + "5\n", + "1\n", + "0\n", "7\n", + "8\n", + "2\n", + "5\n", + "1\n", "6\n", + "5\n", + "0\n", + "10\n", + "9\n", + "10\n", + "3\n", + "10\n", "7\n", + "8\n", "7\n", - "4\n", - "5\n", - "Epoch 0: [7, 1, 6, 6, 4, 7, 6, 7, 7, 4, 5]\n", - "Epoch 1: [6, 3, 4, 7, 1, 4, 9, 6, 9, 2, 5]\n", - "Epoch 2: [4, 7, 7, 4, 3, 1, 10, 10, 6, 0, 1]\n", - "Epoch 3: [6, 1, 10, 5, 9, 2, 5, 10, 5, 8, 1]\n", - "Epoch 4: [8, 8, 3, 6, 7, 8, 4, 7, 10, 7, 9]\n", + "8\n", + "0\n", "6\n", - "3\n", + "8\n", + "1\n", "4\n", + "1\n", + "0\n", + "6\n", + "10\n", + "2\n", + "5\n", + "2\n", + "8\n", + "2\n", + "0\n", + "9\n", "7\n", "1\n", - "4\n", + "10\n", + "1\n", + "3\n", + "5\n", + "5\n", + "8\n", + "0\n", + "5\n", + "10\n", + "2\n", "9\n", - "6\n", + "1\n", + "1\n", + "0\n", + "7\n", + "0\n", + "9\n", + "5\n", + "5\n", + "0\n", + "7\n", "9\n", + "0\n", + "7\n", + "3\n", "2\n", - "5\n" + "5\n", + "6\n", + "8\n", + "8\n", + "None\n", + "None\n", + "Epoch 0: [9, 2, 2, 6, 9, 9, 9, 4, 7, 8, 5]\n", + "Epoch 1: [8, 8, 2, 3, 6, 10, 7, 2, 10, 9, 2]\n", + "Epoch 2: [1, 9, 3, 2, 6, 4, 6, 4, 4, 1, 5]\n", + "Epoch 3: [1, 0, 7, 8, 2, 5, 1, 6, 5, 0, 10]\n", + "Epoch 4: [9, 10, 3, 10, 7, 8, 7, 8, 0, 6, 8]\n", + "None\n", + "None\n" ] } ], "source": [ "sampler=Sampler.randomWithReplacement(11)\n", "sampler.show_epochs(5)\n", - "for _ in range(11):\n", + "for _ in range(100):\n", " print(sampler.next())\n", - "sampler.show_epochs(5)\n", - "for _ in range(11):\n", - " print(sampler.next())" + "sampler.show_epochs(5)\n" ] }, { diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb index 78fe5957cf..5651c7688c 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb @@ -49,7 +49,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -106,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -138,6 +138,7 @@ " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", " f_subsets.append(fi)\n", " # Define A_i and put into list \n", + " \n", "ageom_subset = partitioned_data.geometry\n", "A = ProjectionOperator(ig2D, ageom_subset)\n", "\n", @@ -153,15 +154,15 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "\n" + "\n", + "\n" ] } ], @@ -172,25 +173,20 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 50 0.000 6.90194e+03\n", - " 10 50 3.313 1.59092e+02\n", - " 20 50 3.019 5.91546e+01\n", - " 30 50 2.909 4.56431e+01\n", - " 40 50 2.849 4.06590e+01\n", - " 50 50 2.813 3.73280e+01\n", - "-------------------------------------------------------\n", - " 50 50 2.813 3.73280e+01\n", - "Stop criterion has been reached.\n", - "\n" + "ename": "TypeError", + "evalue": "object of type 'BlockFunction' has no len()", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39m# Setup and run SPDHG for 50 iterations\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m spdhg \u001b[39m=\u001b[39m SPDHG(f \u001b[39m=\u001b[39;49m F, g \u001b[39m=\u001b[39;49m G, operator \u001b[39m=\u001b[39;49m K, max_iteration \u001b[39m=\u001b[39;49m \u001b[39m50\u001b[39;49m,\n\u001b[1;32m 3\u001b[0m update_objective_interval \u001b[39m=\u001b[39;49m \u001b[39m10\u001b[39;49m, sampler\u001b[39m=\u001b[39;49mSampler\u001b[39m.\u001b[39;49msequential(n_subsets))\n\u001b[1;32m 4\u001b[0m spdhg\u001b[39m.\u001b[39mrun()\n\u001b[1;32m 6\u001b[0m spdhg_recon \u001b[39m=\u001b[39m spdhg\u001b[39m.\u001b[39msolution \n", + "File \u001b[0;32m/app/cil/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py:107\u001b[0m, in \u001b[0;36mSPDHG.__init__\u001b[0;34m(self, f, g, operator, tau, sigma, initial, prob, gamma, sampler, **kwargs)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[39msuper\u001b[39m(SPDHG, \u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m\u001b[39m__init__\u001b[39m(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 106\u001b[0m \u001b[39mif\u001b[39;00m f \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m operator \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m g \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 107\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mset_up(f\u001b[39m=\u001b[39;49mf, g\u001b[39m=\u001b[39;49mg, operator\u001b[39m=\u001b[39;49moperator, tau\u001b[39m=\u001b[39;49mtau, sigma\u001b[39m=\u001b[39;49msigma, \n\u001b[1;32m 108\u001b[0m initial\u001b[39m=\u001b[39;49minitial, prob\u001b[39m=\u001b[39;49mprob, gamma\u001b[39m=\u001b[39;49mgamma,sampler\u001b[39m=\u001b[39;49msampler, norms\u001b[39m=\u001b[39;49mkwargs\u001b[39m.\u001b[39;49mget(\u001b[39m'\u001b[39;49m\u001b[39mnorms\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m))\n", + "File \u001b[0;32m/app/cil/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py:147\u001b[0m, in \u001b[0;36mSPDHG.set_up\u001b[0;34m(self, f, g, operator, tau, sigma, initial, prob, gamma, sampler, norms)\u001b[0m\n\u001b[1;32m 145\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msigma \u001b[39m=\u001b[39m sigma\n\u001b[1;32m 146\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprob \u001b[39m=\u001b[39m prob\n\u001b[0;32m--> 147\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mndual_subsets \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mf)\n\u001b[1;32m 148\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgamma \u001b[39m=\u001b[39m gamma\n\u001b[1;32m 149\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrho \u001b[39m=\u001b[39m \u001b[39m.99\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: object of type 'BlockFunction' has no len()" ] } ], @@ -205,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -238,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -276,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [ { From 001350b65a84ed7070fb83ff5a6cdab7f758223c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 11 Aug 2023 08:45:02 +0000 Subject: [PATCH 012/152] Meeting with Vaggelis, Jakob, Gemma and Edo --- .../SPDHG_sampling.cpython-310.pyc | Bin 8022 -> 8022 bytes .../algorithms/testing_sampling.ipynb | 245 ++++++++++-------- .../algorithms/testing_sampling_SPDHG.ipynb | 9 +- 3 files changed, 137 insertions(+), 117 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc index 6a00f61acf1be2c577ed24a01169f0ddf83fc42f..50238c405fe007f4ad1d74ed7ea628949025d970 100644 GIT binary patch delta 19 Zcmca+cg>C~pO=@50SIEYY~=Eh2LLz+1pEL1 delta 19 Zcmca+cg>C~pO=@50SIK~Z{+fk2LLu61g8K1 diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb index 171bc3e4f4..5da23f9c53 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 16, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -16,22 +16,18 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "0\n", "1\n", "2\n", @@ -133,42 +129,77 @@ "8\n", "9\n" ] + }, + { + "ename": "TypeError", + "evalue": "'Sampler' object is not an iterator", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[6], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mfor\u001b[39;00m _ \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m100\u001b[39m):\n\u001b[1;32m 4\u001b[0m \u001b[39mprint\u001b[39m(sampler\u001b[39m.\u001b[39mnext())\n\u001b[0;32m----> 6\u001b[0m \u001b[39mnext\u001b[39;49m(sampler)\n", + "\u001b[0;31mTypeError\u001b[0m: 'Sampler' object is not an iterator" + ] } ], "source": [ "sampler=Sampler.sequential(10)\n", "sampler.show_epochs(5)\n", "for _ in range(100):\n", - " print(sampler.next())" + " print(sampler.next())\n", + "\n", + "next(sampler)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "Epoch 0: [6, 9, 7, 5, 1, 8, 3, 2, 4, 0, 10]\n", - "Epoch 1: [7, 3, 0, 4, 8, 1, 10, 9, 6, 2, 5]\n", - "Epoch 2: [2, 9, 3, 7, 1, 6, 5, 0, 8, 4, 10]\n", - "Epoch 3: [3, 0, 6, 1, 10, 7, 2, 9, 8, 5, 4]\n", - "Epoch 4: [4, 5, 10, 6, 9, 8, 7, 3, 2, 0, 1]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "[ 2 9 3 7 1 6 5 0 8 4 10]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "Epoch 0: [6, 9, 7, 5, 1, 8, 3, 2, 4, 0, 10]\n", - "Epoch 1: [7, 3, 0, 4, 8, 1, 10, 9, 6, 2, 5]\n", - "Epoch 2: [2, 9, 3, 7, 1, 6, 5, 0, 8, 4, 10]\n", - "Epoch 3: [3, 0, 6, 1, 10, 7, 2, 9, 8, 5, 4]\n", - "Epoch 4: [4, 5, 10, 6, 9, 8, 7, 3, 2, 0, 1]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "[ 2 9 3 7 1 6 5 0 8 4 10]\n" + "Epoch 0: [8, 7, 4, 2, 3, 0, 9, 5, 1, 10, 6]\n", + "Epoch 1: [1, 3, 0, 7, 5, 2, 6, 8, 9, 10, 4]\n", + "Epoch 2: [0, 10, 4, 7, 9, 3, 5, 2, 8, 6, 1]\n", + "Epoch 3: [3, 8, 7, 10, 2, 1, 6, 4, 0, 5, 9]\n", + "Epoch 4: [5, 10, 1, 2, 7, 9, 4, 3, 6, 8, 0]\n", + "8\n", + "7\n", + "4\n", + "2\n", + "3\n", + "0\n", + "9\n", + "5\n", + "1\n", + "10\n", + "6\n", + "1\n", + "3\n", + "0\n", + "7\n", + "5\n", + "2\n", + "6\n", + "8\n", + "9\n", + "10\n", + "4\n", + "0\n", + "10\n", + "4\n", + "7\n", + "9\n", + "3\n", + "5\n", + "2\n", + "Epoch 0: [8, 7, 4, 2, 3, 0, 9, 5, 1, 10, 6]\n", + "Epoch 1: [1, 3, 0, 7, 5, 2, 6, 8, 9, 10, 4]\n", + "Epoch 2: [0, 10, 4, 7, 9, 3, 5, 2, 8, 6, 1]\n", + "Epoch 3: [3, 8, 7, 10, 2, 1, 6, 4, 0, 5, 9]\n", + "Epoch 4: [5, 10, 1, 2, 7, 9, 4, 3, 6, 8, 0]\n" ] } ], @@ -176,28 +207,24 @@ "sampler=Sampler.randomWithoutReplacement(11)\n", "sampler.show_epochs(5)\n", "for _ in range(30):\n", - " sampler.next()\n", + " print(sampler.next())\n", "sampler.show_epochs(5)\n" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 0: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 1: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 2: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 3: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 4: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "0\n", "30\n", "15\n", @@ -310,131 +337,123 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "None\n", - "None\n", - "Epoch 0: [9, 2, 2, 6, 9, 9, 9, 4, 7, 8, 5]\n", - "Epoch 1: [8, 8, 2, 3, 6, 10, 7, 2, 10, 9, 2]\n", - "Epoch 2: [1, 9, 3, 2, 6, 4, 6, 4, 4, 1, 5]\n", - "Epoch 3: [1, 0, 7, 8, 2, 5, 1, 6, 5, 0, 10]\n", - "Epoch 4: [9, 10, 3, 10, 7, 8, 7, 8, 0, 6, 8]\n", - "None\n", - "None\n", - "9\n", - "2\n", + "Epoch 0: [0, 0, 2, 0, 4, 7, 10, 1, 1, 3, 9]\n", + "Epoch 1: [5, 4, 9, 1, 10, 2, 4, 0, 10, 4, 9]\n", + "Epoch 2: [3, 8, 3, 3, 4, 5, 1, 4, 6, 8, 0]\n", + "Epoch 3: [2, 0, 7, 1, 10, 5, 5, 10, 8, 7, 7]\n", + "Epoch 4: [9, 1, 5, 9, 2, 7, 4, 5, 6, 6, 0]\n", + "0\n", + "0\n", "2\n", - "6\n", - "9\n", - "9\n", - "9\n", + "0\n", "4\n", "7\n", - "8\n", - "5\n", - "8\n", - "8\n", - "2\n", - "3\n", - "6\n", - "10\n", - "7\n", - "2\n", "10\n", - "9\n", - "2\n", "1\n", - "9\n", - "3\n", - "2\n", - "6\n", - "4\n", - "6\n", - "4\n", - "4\n", "1\n", + "3\n", + "9\n", "5\n", + "4\n", + "9\n", "1\n", - "0\n", - "7\n", - "8\n", + "10\n", "2\n", - "5\n", - "1\n", - "6\n", - "5\n", + "4\n", "0\n", "10\n", + "4\n", "9\n", - "10\n", "3\n", - "10\n", - "7\n", - "8\n", - "7\n", - "8\n", - "0\n", - "6\n", "8\n", - "1\n", + "3\n", + "3\n", "4\n", + "5\n", "1\n", - "0\n", + "4\n", "6\n", - "10\n", - "2\n", - "5\n", - "2\n", "8\n", + "0\n", "2\n", "0\n", - "9\n", "7\n", "1\n", "10\n", - "1\n", - "3\n", "5\n", "5\n", - "8\n", - "0\n", - "5\n", "10\n", - "2\n", - "9\n", - "1\n", - "1\n", - "0\n", + "8\n", + "7\n", "7\n", - "0\n", "9\n", + "1\n", "5\n", + "9\n", + "2\n", + "7\n", + "4\n", "5\n", + "6\n", + "6\n", + "0\n", "0\n", - "7\n", "9\n", + "4\n", + "2\n", + "8\n", + "6\n", + "1\n", + "6\n", "0\n", - "7\n", + "9\n", + "2\n", + "6\n", + "8\n", "3\n", + "1\n", "2\n", + "8\n", + "3\n", + "4\n", + "1\n", + "8\n", + "8\n", + "10\n", + "8\n", + "9\n", + "3\n", + "10\n", + "10\n", + "4\n", + "4\n", + "9\n", "5\n", - "6\n", + "7\n", + "4\n", + "1\n", "8\n", "8\n", - "None\n", - "None\n", - "Epoch 0: [9, 2, 2, 6, 9, 9, 9, 4, 7, 8, 5]\n", - "Epoch 1: [8, 8, 2, 3, 6, 10, 7, 2, 10, 9, 2]\n", - "Epoch 2: [1, 9, 3, 2, 6, 4, 6, 4, 4, 1, 5]\n", - "Epoch 3: [1, 0, 7, 8, 2, 5, 1, 6, 5, 0, 10]\n", - "Epoch 4: [9, 10, 3, 10, 7, 8, 7, 8, 0, 6, 8]\n", - "None\n", - "None\n" + "9\n", + "8\n", + "4\n", + "9\n", + "7\n", + "4\n", + "2\n", + "3\n", + "Epoch 0: [0, 0, 2, 0, 4, 7, 10, 1, 1, 3, 9]\n", + "Epoch 1: [5, 4, 9, 1, 10, 2, 4, 0, 10, 4, 9]\n", + "Epoch 2: [3, 8, 3, 3, 4, 5, 1, 4, 6, 8, 0]\n", + "Epoch 3: [2, 0, 7, 1, 10, 5, 5, 10, 8, 7, 7]\n", + "Epoch 4: [9, 1, 5, 9, 2, 7, 4, 5, 6, 6, 0]\n" ] } ], diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb index 5651c7688c..ed214d17a2 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb @@ -49,7 +49,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -130,18 +130,19 @@ "\n", "# Initialize the lists containing the F_i's and A_i's\n", "f_subsets = []\n", - "A_subsets = []\n", "\n", - "# Define F_i's and A_i's\n", + "\n", + "# Define F_i's \n", "for i in range(n_subsets):\n", " # Define F_i and put into list\n", " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", " f_subsets.append(fi)\n", - " # Define A_i and put into list \n", + " \n", " \n", "ageom_subset = partitioned_data.geometry\n", "A = ProjectionOperator(ig2D, ageom_subset)\n", "\n", + "#F = L2NormSquared.fromBlockDataContainer(partitioned_data, constant=0.5)\n", "\n", "# Define F and K\n", "F = BlockFunction(*f_subsets)\n", From 890dec05fdf2a88de6fb3680213538e8a38c1a6d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 14 Aug 2023 14:18:44 +0000 Subject: [PATCH 013/152] Set up for installation --- Wrappers/Python/cil/framework/__init__.py | 1 + .../cil/optimisation/algorithms/SPDHG.py | 40 +- .../optimisation/algorithms/SPDHG_sampling.py | 257 --------- .../cil/optimisation/algorithms/sampler.py | 138 ----- .../algorithms/testing_sampling.ipynb | 498 ------------------ .../algorithms/testing_sampling_SPDHG.ipynb | 329 ------------ 6 files changed, 28 insertions(+), 1235 deletions(-) delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/sampler.py delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb diff --git a/Wrappers/Python/cil/framework/__init__.py b/Wrappers/Python/cil/framework/__init__.py index 4571441515..19e6e89c1e 100644 --- a/Wrappers/Python/cil/framework/__init__.py +++ b/Wrappers/Python/cil/framework/__init__.py @@ -34,3 +34,4 @@ from .BlockGeometry import BlockGeometry from .framework import DataOrder from .framework import Partitioner +from .sampler import Sampler diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 37efd460b8..058002f139 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging - +from cil.framework import Sampler class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -50,7 +50,8 @@ class SPDHG(Algorithm): List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes - + sampler: instnace of the Sampler class + Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets **kwargs: norms : list of floats precalculated list of norms of the operators @@ -95,19 +96,20 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, prob=None, gamma=1.,**kwargs): + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, + initial=None, prob=None, gamma=1.,sampler=None,**kwargs): super(SPDHG, self).__init__(**kwargs) - + + if f is not None and operator is not None and g is not None: self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, prob=prob, gamma=gamma, norms=kwargs.get('norms', None)) + initial=initial, prob=prob, gamma=gamma,sampler=sampler, norms=kwargs.get('norms', None)) def set_up(self, f, g, operator, tau=None, sigma=None, \ - initial=None, prob=None, gamma=1., norms=None): + initial=None, prob=None, gamma=1.,sampler=None, norms=None): '''set-up of the algorithm Parameters @@ -142,14 +144,26 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ self.tau = tau self.sigma = sigma self.prob = prob - self.ndual_subsets = len(self.operator) + self.ndual_subsets = self.operator.shape[0] self.gamma = gamma self.rho = .99 - - if self.prob is None: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler=sampler + + if self.sampler==None: + if self.prob == None: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) + else: + if self.prob==None: + if self.sampler.prob!=None: + self.prob=self.sampler.prob + else: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + else: + warnings.warn('You supplied both probabilites and a sampler. The sampler will be used for sampling and the probabilites for calculationg step sizes, if not explicitly set.') + + - if self.sigma is None: if norms is None: # Compute norm of each sub-operator @@ -187,7 +201,7 @@ def update(self): self.g.proximal(self.x_tmp, self.tau, out=self.x) # Choose subset - i = int(np.random.choice(len(self.sigma), 1, p=self.prob)) + i = int(self.sampler.next()) # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py deleted file mode 100644 index ea5083ea08..0000000000 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py +++ /dev/null @@ -1,257 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright 2020 United Kingdom Research and Innovation -# Copyright 2020 The University of Manchester -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Authors: -# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt -# Claire Delplancke (University of Bath) - -from cil.optimisation.algorithms import Algorithm -import numpy as np -import warnings -import logging -from sampler import Sampler -class SPDHG(Algorithm): - r'''Stochastic Primal Dual Hybrid Gradient - - Problem: - - .. math:: - - \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) - - Parameters - ---------- - f : BlockFunction - Each must be a convex function with a "simple" proximal method of its conjugate - g : Function - A convex function with a "simple" proximal - operator : BlockOperator - BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - initial : DataContainer, optional, default=None - Initial point for the SPDHG algorithm - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets - gamma : float - parameter controlling the trade-off between the primal and dual step sizes - sampler: instnace of the Sampler class - Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets - **kwargs: - norms : list of floats - precalculated list of norms of the operators - - Example - ------- - - Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py - - - Note - ---- - - Convergence is guaranteed provided that [2, eq. (12)]: - - .. math:: - - \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i - - Note - ---- - - Notation for primal and dual step-sizes are reversed with comparison - to PDHG.py - - Note - ---- - - this code implements serial sampling only, as presented in [2] - (to be extended to more general case of [1] as future work) - - References - ---------- - - [1]"Stochastic primal-dual hybrid gradient algorithm with arbitrary - sampling and imaging applications", - Chambolle, Antonin, Matthias J. Ehrhardt, Peter Richtárik, and Carola-Bibiane Schonlieb, - SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. - - [2]"Faster PET reconstruction with non-smooth priors by randomization and preconditioning", - Matthias J Ehrhardt, Pawel Markiewicz and Carola-Bibiane Schönlieb, - Physics in Medicine & Biology, Volume 64, Number 22, 2019. - ''' - - def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, prob=None, gamma=1.,sampler=None,**kwargs): - - super(SPDHG, self).__init__(**kwargs) - - - - if f is not None and operator is not None and g is not None: - self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, prob=prob, gamma=gamma,sampler=sampler, norms=kwargs.get('norms', None)) - - - def set_up(self, f, g, operator, tau=None, sigma=None, \ - initial=None, prob=None, gamma=1.,sampler=None, norms=None): - - '''set-up of the algorithm - Parameters - ---------- - f : BlockFunction - Each must be a convex function with a "simple" proximal method of its conjugate - g : Function - A convex function with a "simple" proximal - operator : BlockOperator - BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - initial : DataContainer, optional, default=None - Initial point for the SPDHG algorithm - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets - gamma : float - parameter controlling the trade-off between the primal and dual step sizes - - **kwargs: - norms : list of floats - precalculated list of norms of the operators - ''' - logging.info("{} setting up".format(self.__class__.__name__, )) - - # algorithmic parameters - self.f = f - self.g = g - self.operator = operator - self.tau = tau - self.sigma = sigma - self.prob = prob - self.ndual_subsets = len(self.f) - self.gamma = gamma - self.rho = .99 - self.sampler=sampler - - if self.sampler==None: - if self.prob == None: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) - else: - if self.prob==None: - if self.sampler.prob!=None: - self.prob=self.sampler.prob - else: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - else: - warnings.warn('You supplied both probabilites and a sampler. The sampler will be used for sampling and the probabilites for calculationg step sizes, if not explicitly set.') - - - - if self.sigma is None: - if norms is None: - # Compute norm of each sub-operator - norms = [operator.get_item(i,0).norm() for i in range(self.ndual_subsets)] - self.norms = norms - self.sigma = [self.gamma * self.rho / ni for ni in norms] - if self.tau is None: - self.tau = min( [ pi / ( si * ni**2 ) for pi, ni, si in zip(self.prob, norms, self.sigma)] ) - self.tau *= (self.rho / self.gamma) - - # initialize primal variable - if initial is None: - self.x = self.operator.domain_geometry().allocate(0) - else: - self.x = initial.copy() - - self.x_tmp = self.operator.domain_geometry().allocate(0) - - # initialize dual variable to 0 - self.y_old = operator.range_geometry().allocate(0) - - # initialize variable z corresponding to back-projected dual variable - self.z = operator.domain_geometry().allocate(0) - self.zbar= operator.domain_geometry().allocate(0) - # relaxation parameter - self.theta = 1 - self.configured = True - logging.info("{} configured".format(self.__class__.__name__, )) - - def update(self): - # Gradient descent for the primal variable - # x_tmp = x - tau * zbar - self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) - - self.g.proximal(self.x_tmp, self.tau, out=self.x) - - # Choose subset - i = int(self.sampler.next()) - - # Gradient ascent for the dual variable - # y_k = y_old[i] + sigma[i] * K[i] x - y_k = self.operator[i].direct(self.x) - - y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) - - y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) - - # Back-project - # x_tmp = K[i]^*(y_k - y_old[i]) - y_k.subtract(self.y_old[i], out=self.y_old[i]) - - self.operator[i].adjoint(self.y_old[i], out = self.x_tmp) - # Update backprojected dual variable and extrapolate - # zbar = z + (1 + theta/p[i]) x_tmp - - # z = z + x_tmp - self.z.add(self.x_tmp, out =self.z) - # zbar = z + (theta/p[i]) * x_tmp - - self.z.sapyb(1., self.x_tmp, self.theta / self.prob[i], out = self.zbar) - - # save previous iteration - self.save_previous_iteration(i, y_k) - - def update_objective(self): - # p1 = self.f(self.operator.direct(self.x)) + self.g(self.x) - p1 = 0. - for i,op in enumerate(self.operator.operators): - p1 += self.f[i](op.direct(self.x)) - p1 += self.g(self.x) - - d1 = - self.f.convex_conjugate(self.y_old) - tmp = self.operator.adjoint(self.y_old) - tmp *= -1 - d1 -= self.g.convex_conjugate(tmp) - - self.loss.append([p1, d1, p1-d1]) - - @property - def objective(self): - '''alias of loss''' - return [x[0] for x in self.loss] - @property - def dual_objective(self): - return [x[1] for x in self.loss] - - @property - def primal_dual_gap(self): - return [x[2] for x in self.loss] - def save_previous_iteration(self, index, y_current): - self.y_old[index].fill(y_current) diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampler.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py deleted file mode 100644 index f175340c49..0000000000 --- a/Wrappers/Python/cil/optimisation/algorithms/sampler.py +++ /dev/null @@ -1,138 +0,0 @@ -# -*- coding: utf-8 -*- -# This work is part of the Core Imaging Library (CIL) developed by CCPi -# (Collaborative Computational Project in Tomographic Imaging), with -# substantial contributions by UKRI-STFC and University of Manchester. - -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at - -# http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -import numpy as np -import math -import time -class Sampler(): - - r"""Takes an integer number of subsets and a sampling type and returns a class object with a next function. On each call of next, an integer value between 0 and the number of subsets is returned, the next sample.""" - - - - @staticmethod - def hermanMeyer(num_subsets): - @staticmethod - def _herman_meyer_order(n): - # Assuming that the subsets are in geometrical order - n_variable = n - i = 2 - factors = [] - while i * i <= n_variable: - if n_variable % i: - i += 1 - else: - n_variable //= i - factors.append(i) - if n_variable > 1: - factors.append(n_variable) - n_factors = len(factors) - order = [0 for _ in range(n)] - value = 0 - for factor_n in range(n_factors): - n_rep_value = 0 - if factor_n == 0: - n_change_value = 1 - else: - n_change_value = math.prod(factors[:factor_n]) - for element in range(n): - mapping = value - n_rep_value += 1 - if n_rep_value >= n_change_value: - value = value + 1 - n_rep_value = 0 - if value == factors[factor_n]: - value = 0 - order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping - return order - - order=_herman_meyer_order(num_subsets) - sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) - return sampler - - @staticmethod - def sequential(num_subsets): - order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='sequential', order=order) - return sampler - - @staticmethod - def randomWithReplacement(num_subsets, prob=None, seed=None): - if prob==None: - prob = [1/num_subsets] *num_subsets - else: - prob=prob - sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) - return sampler - - @staticmethod - def randomWithoutReplacement(num_subsets, seed=None): - order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) - return sampler - - - def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): - self.type=sampling_type - self.num_subsets=num_subsets - if seed !=None: - self.seed=seed - else: - self.seed=int(time.time()) - self.generator=np.random.RandomState(self.seed) - self.order=order - self.initial_order=order - if order!=None: - self.iterator=self._next_order - self.prob=prob - if prob!=None: - self.iterator=self._next_prob - self.shuffle=shuffle - self.last_subset=self.num_subsets-1 - - - - - def _next_order(self): - # print(self.last_subset) - if self.shuffle==True and self.last_subset==self.num_subsets-1: - self.order=self.generator.permutation(self.order) - #print(self.order) - self.last_subset= (self.last_subset+1)%self.num_subsets - return(self.order[self.last_subset]) - - def _next_prob(self): - return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) - - def next(self): - return (self.iterator()) - - - def show_epochs(self, num_epochs=2): - save_generator=self.generator - save_last_subset=self.last_subset - self.last_subset=self.num_subsets-1 - save_order=self.order - self.order=self.initial_order - self.generator=np.random.RandomState(self.seed) - for i in range(num_epochs): - print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) - self.generator=save_generator - self.order=save_order - self.last_subset=save_last_subset - diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb deleted file mode 100644 index 5da23f9c53..0000000000 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ /dev/null @@ -1,498 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - " \n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import os\n", - "from sampler import Sampler\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n" - ] - }, - { - "ename": "TypeError", - "evalue": "'Sampler' object is not an iterator", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[6], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mfor\u001b[39;00m _ \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m100\u001b[39m):\n\u001b[1;32m 4\u001b[0m \u001b[39mprint\u001b[39m(sampler\u001b[39m.\u001b[39mnext())\n\u001b[0;32m----> 6\u001b[0m \u001b[39mnext\u001b[39;49m(sampler)\n", - "\u001b[0;31mTypeError\u001b[0m: 'Sampler' object is not an iterator" - ] - } - ], - "source": [ - "sampler=Sampler.sequential(10)\n", - "sampler.show_epochs(5)\n", - "for _ in range(100):\n", - " print(sampler.next())\n", - "\n", - "next(sampler)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: [8, 7, 4, 2, 3, 0, 9, 5, 1, 10, 6]\n", - "Epoch 1: [1, 3, 0, 7, 5, 2, 6, 8, 9, 10, 4]\n", - "Epoch 2: [0, 10, 4, 7, 9, 3, 5, 2, 8, 6, 1]\n", - "Epoch 3: [3, 8, 7, 10, 2, 1, 6, 4, 0, 5, 9]\n", - "Epoch 4: [5, 10, 1, 2, 7, 9, 4, 3, 6, 8, 0]\n", - "8\n", - "7\n", - "4\n", - "2\n", - "3\n", - "0\n", - "9\n", - "5\n", - "1\n", - "10\n", - "6\n", - "1\n", - "3\n", - "0\n", - "7\n", - "5\n", - "2\n", - "6\n", - "8\n", - "9\n", - "10\n", - "4\n", - "0\n", - "10\n", - "4\n", - "7\n", - "9\n", - "3\n", - "5\n", - "2\n", - "Epoch 0: [8, 7, 4, 2, 3, 0, 9, 5, 1, 10, 6]\n", - "Epoch 1: [1, 3, 0, 7, 5, 2, 6, 8, 9, 10, 4]\n", - "Epoch 2: [0, 10, 4, 7, 9, 3, 5, 2, 8, 6, 1]\n", - "Epoch 3: [3, 8, 7, 10, 2, 1, 6, 4, 0, 5, 9]\n", - "Epoch 4: [5, 10, 1, 2, 7, 9, 4, 3, 6, 8, 0]\n" - ] - } - ], - "source": [ - "sampler=Sampler.randomWithoutReplacement(11)\n", - "sampler.show_epochs(5)\n", - "for _ in range(30):\n", - " print(sampler.next())\n", - "sampler.show_epochs(5)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "Epoch 1: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "Epoch 2: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "Epoch 3: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "Epoch 4: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "0\n", - "30\n", - "15\n", - "45\n", - "5\n", - "35\n", - "20\n", - "50\n", - "10\n", - "40\n", - "25\n", - "55\n", - "1\n", - "31\n", - "16\n", - "46\n", - "6\n", - "36\n", - "21\n", - "51\n", - "11\n", - "41\n", - "26\n", - "56\n", - "2\n", - "32\n", - "17\n", - "47\n", - "7\n", - "37\n", - "22\n", - "52\n", - "12\n", - "42\n", - "27\n", - "57\n", - "3\n", - "33\n", - "18\n", - "48\n", - "8\n", - "38\n", - "23\n", - "53\n", - "13\n", - "43\n", - "28\n", - "58\n", - "4\n", - "34\n", - "19\n", - "49\n", - "9\n", - "39\n", - "24\n", - "54\n", - "14\n", - "44\n", - "29\n", - "59\n", - "0\n", - "30\n", - "15\n", - "45\n", - "5\n", - "35\n", - "20\n", - "50\n", - "10\n", - "40\n", - "25\n", - "55\n", - "1\n", - "31\n", - "16\n", - "46\n", - "6\n", - "36\n", - "21\n", - "51\n", - "11\n", - "41\n", - "26\n", - "56\n", - "2\n", - "32\n", - "17\n", - "47\n", - "7\n", - "37\n", - "22\n", - "52\n", - "12\n", - "42\n", - "27\n", - "57\n", - "3\n", - "33\n", - "18\n", - "48\n" - ] - } - ], - "source": [ - "sampler=Sampler.hermanMeyer(60)\n", - "sampler.show_epochs(5)\n", - "for _ in range(100):\n", - " print(sampler.next())" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: [0, 0, 2, 0, 4, 7, 10, 1, 1, 3, 9]\n", - "Epoch 1: [5, 4, 9, 1, 10, 2, 4, 0, 10, 4, 9]\n", - "Epoch 2: [3, 8, 3, 3, 4, 5, 1, 4, 6, 8, 0]\n", - "Epoch 3: [2, 0, 7, 1, 10, 5, 5, 10, 8, 7, 7]\n", - "Epoch 4: [9, 1, 5, 9, 2, 7, 4, 5, 6, 6, 0]\n", - "0\n", - "0\n", - "2\n", - "0\n", - "4\n", - "7\n", - "10\n", - "1\n", - "1\n", - "3\n", - "9\n", - "5\n", - "4\n", - "9\n", - "1\n", - "10\n", - "2\n", - "4\n", - "0\n", - "10\n", - "4\n", - "9\n", - "3\n", - "8\n", - "3\n", - "3\n", - "4\n", - "5\n", - "1\n", - "4\n", - "6\n", - "8\n", - "0\n", - "2\n", - "0\n", - "7\n", - "1\n", - "10\n", - "5\n", - "5\n", - "10\n", - "8\n", - "7\n", - "7\n", - "9\n", - "1\n", - "5\n", - "9\n", - "2\n", - "7\n", - "4\n", - "5\n", - "6\n", - "6\n", - "0\n", - "0\n", - "9\n", - "4\n", - "2\n", - "8\n", - "6\n", - "1\n", - "6\n", - "0\n", - "9\n", - "2\n", - "6\n", - "8\n", - "3\n", - "1\n", - "2\n", - "8\n", - "3\n", - "4\n", - "1\n", - "8\n", - "8\n", - "10\n", - "8\n", - "9\n", - "3\n", - "10\n", - "10\n", - "4\n", - "4\n", - "9\n", - "5\n", - "7\n", - "4\n", - "1\n", - "8\n", - "8\n", - "9\n", - "8\n", - "4\n", - "9\n", - "7\n", - "4\n", - "2\n", - "3\n", - "Epoch 0: [0, 0, 2, 0, 4, 7, 10, 1, 1, 3, 9]\n", - "Epoch 1: [5, 4, 9, 1, 10, 2, 4, 0, 10, 4, 9]\n", - "Epoch 2: [3, 8, 3, 3, 4, 5, 1, 4, 6, 8, 0]\n", - "Epoch 3: [2, 0, 7, 1, 10, 5, 5, 10, 8, 7, 7]\n", - "Epoch 4: [9, 1, 5, 9, 2, 7, 4, 5, 6, 6, 0]\n" - ] - } - ], - "source": [ - "sampler=Sampler.randomWithReplacement(11)\n", - "sampler.show_epochs(5)\n", - "for _ in range(100):\n", - " print(sampler.next())\n", - "sampler.show_epochs(5)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "cil", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb deleted file mode 100644 index ed214d17a2..0000000000 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb +++ /dev/null @@ -1,329 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from cil.framework import DataContainer, BlockDataContainer, Partitioner\n", - "\n", - "# Import libraries\n", - " \n", - "from SPDHG_sampling import SPDHG\n", - "from cil.optimisation.operators import GradientOperator, BlockOperator\n", - "from cil.optimisation.functions import IndicatorBox, BlockFunction, L2NormSquared, MixedL21Norm\n", - " \n", - "from cil.io import ZEISSDataReader\n", - " \n", - "from cil.processors import Slicer, Binner, TransmissionAbsorptionConverter\n", - " \n", - "from cil.plugins.astra.operators import ProjectionOperator\n", - "from cil.plugins.ccpi_regularisation.functions import FGP_TV\n", - " \n", - "from cil.utilities.display import show2D\n", - "from cil.utilities.jupyter import islicer\n", - " \n", - " \n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import os\n", - "from sampler import Sampler\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "reader = ZEISSDataReader()\n", - "filename = '../../../data/valnut_tomo-A.txrm'\n", - "reader.set_up(file_name=filename)\n", - "data3D = reader.read()\n", - "\n", - "# reorder data to match default order for Astra/Tigre operator\n", - "data3D.reorder('astra')\n", - "\n", - "# Get Image and Acquisition geometries\n", - "ag3D = data3D.geometry\n", - "ig3D = ag3D.get_ImageGeometry()\n", - "\n", - "# Extract vertical slice\n", - "data2D = data3D.get_slice(vertical='centre')\n", - "\n", - "# Select every 10 angles\n", - "sliced_data = Slicer(roi={'angle':(0,1601,10)})(data2D)\n", - "\n", - "# Reduce background regions\n", - "binned_data = Binner(roi={'horizontal':(120,-120,2)})(sliced_data)\n", - "\n", - "# Create absorption data \n", - "data = TransmissionAbsorptionConverter()(binned_data) \n", - "\n", - "# Remove circular artifacts\n", - "data -= np.mean(data.as_array()[80:100,0:30])\n", - "\n", - "# Get Image and Acquisition geometries for one slice\n", - "ag2D = data.geometry\n", - "ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian')\n", - "ig2D = ag2D.get_ImageGeometry()\n", - "\n", - "A = ProjectionOperator(ig2D, ag2D, device = \"gpu\")\n", - "\n", - "show2D(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Define number of subsets\n", - "n_subsets = 10\n", - "\n", - "partitioned_data=data.partition(n_subsets, 'staggered')\n", - "show2D(partitioned_data)\n", - "\n", - "\n", - "# Initialize the lists containing the F_i's and A_i's\n", - "f_subsets = []\n", - "\n", - "\n", - "# Define F_i's \n", - "for i in range(n_subsets):\n", - " # Define F_i and put into list\n", - " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", - " f_subsets.append(fi)\n", - " \n", - " \n", - "ageom_subset = partitioned_data.geometry\n", - "A = ProjectionOperator(ig2D, ageom_subset)\n", - "\n", - "#F = L2NormSquared.fromBlockDataContainer(partitioned_data, constant=0.5)\n", - "\n", - "# Define F and K\n", - "F = BlockFunction(*f_subsets)\n", - "K = A\n", - "\n", - "# Define G (by default the positivity constraint is on)\n", - "alpha = 0.025\n", - "G = alpha * FGP_TV()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n" - ] - } - ], - "source": [ - "print(ageom_subset)\n", - "print(A)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "object of type 'BlockFunction' has no len()", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[5], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39m# Setup and run SPDHG for 50 iterations\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m spdhg \u001b[39m=\u001b[39m SPDHG(f \u001b[39m=\u001b[39;49m F, g \u001b[39m=\u001b[39;49m G, operator \u001b[39m=\u001b[39;49m K, max_iteration \u001b[39m=\u001b[39;49m \u001b[39m50\u001b[39;49m,\n\u001b[1;32m 3\u001b[0m update_objective_interval \u001b[39m=\u001b[39;49m \u001b[39m10\u001b[39;49m, sampler\u001b[39m=\u001b[39;49mSampler\u001b[39m.\u001b[39;49msequential(n_subsets))\n\u001b[1;32m 4\u001b[0m spdhg\u001b[39m.\u001b[39mrun()\n\u001b[1;32m 6\u001b[0m spdhg_recon \u001b[39m=\u001b[39m spdhg\u001b[39m.\u001b[39msolution \n", - "File \u001b[0;32m/app/cil/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py:107\u001b[0m, in \u001b[0;36mSPDHG.__init__\u001b[0;34m(self, f, g, operator, tau, sigma, initial, prob, gamma, sampler, **kwargs)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[39msuper\u001b[39m(SPDHG, \u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m\u001b[39m__init__\u001b[39m(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 106\u001b[0m \u001b[39mif\u001b[39;00m f \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m operator \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m g \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 107\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mset_up(f\u001b[39m=\u001b[39;49mf, g\u001b[39m=\u001b[39;49mg, operator\u001b[39m=\u001b[39;49moperator, tau\u001b[39m=\u001b[39;49mtau, sigma\u001b[39m=\u001b[39;49msigma, \n\u001b[1;32m 108\u001b[0m initial\u001b[39m=\u001b[39;49minitial, prob\u001b[39m=\u001b[39;49mprob, gamma\u001b[39m=\u001b[39;49mgamma,sampler\u001b[39m=\u001b[39;49msampler, norms\u001b[39m=\u001b[39;49mkwargs\u001b[39m.\u001b[39;49mget(\u001b[39m'\u001b[39;49m\u001b[39mnorms\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m))\n", - "File \u001b[0;32m/app/cil/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py:147\u001b[0m, in \u001b[0;36mSPDHG.set_up\u001b[0;34m(self, f, g, operator, tau, sigma, initial, prob, gamma, sampler, norms)\u001b[0m\n\u001b[1;32m 145\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msigma \u001b[39m=\u001b[39m sigma\n\u001b[1;32m 146\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprob \u001b[39m=\u001b[39m prob\n\u001b[0;32m--> 147\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mndual_subsets \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mf)\n\u001b[1;32m 148\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgamma \u001b[39m=\u001b[39m gamma\n\u001b[1;32m 149\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrho \u001b[39m=\u001b[39m \u001b[39m.99\u001b[39m\n", - "\u001b[0;31mTypeError\u001b[0m: object of type 'BlockFunction' has no len()" - ] - } - ], - "source": [ - "# Setup and run SPDHG for 50 iterations\n", - "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampler.sequential(n_subsets))\n", - "spdhg.run()\n", - "\n", - "spdhg_recon = spdhg.solution " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 50 0.000 6.90194e+03\n", - " 10 50 0.071 1.68032e+02\n", - " 20 50 0.114 4.89967e+01\n", - " 30 50 0.096 4.18854e+01\n", - " 40 50 0.096 3.86103e+01\n", - " 50 50 0.092 3.70240e+01\n", - "-------------------------------------------------------\n", - " 50 50 0.092 3.70240e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "# Setup and run SPDHG for 50 iterations\n", - "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampler.randomWithReplacement(n_subsets))\n", - "spdhg.run()\n", - "\n", - "spdhg_recon = spdhg.solution " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 50 0.000 6.90194e+03\n", - "[8 7 5 4 3 2 6 0 9 1]\n", - " 10 50 2.593 1.57735e+02\n", - "[2 0 9 6 3 5 1 4 8 7]\n", - " 20 50 2.916 5.82732e+01\n", - "[3 4 1 9 5 6 2 8 7 0]\n", - " 30 50 3.032 4.02467e+01\n", - "[4 9 6 2 5 3 7 1 0 8]\n", - " 40 50 2.937 3.73084e+01\n", - "[0 7 2 6 8 3 5 9 4 1]\n", - " 50 50 2.880 3.50773e+01\n", - "-------------------------------------------------------\n", - " 50 50 2.880 3.50773e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "# Setup and run SPDHG for 50 iterations\n", - "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10 , sampler=Sampler.randomWithoutReplacement(n_subsets))\n", - "spdhg.run()\n", - "\n", - "spdhg_recon = spdhg.solution " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 50 0.000 6.90194e+03\n", - " 10 50 2.494 1.56371e+02\n", - " 20 50 3.314 5.73612e+01\n", - " 30 50 3.081 4.46291e+01\n", - " 40 50 2.944 4.00863e+01\n", - " 50 50 2.862 3.69452e+01\n", - "-------------------------------------------------------\n", - " 50 50 2.862 3.69452e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampler.hermanMeyer(n_subsets))\n", - "spdhg.run()\n", - "\n", - "spdhg_recon = spdhg.solution " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "cil", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 25806fcf8b910ba80f9c536839c05d958ccd1016 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 14 Aug 2023 15:40:25 +0000 Subject: [PATCH 014/152] Added staggered and custom order and started with writing documentation --- Wrappers/Python/cil/framework/sampler.py | 296 +++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 Wrappers/Python/cil/framework/sampler.py diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py new file mode 100644 index 0000000000..09472ab721 --- /dev/null +++ b/Wrappers/Python/cil/framework/sampler.py @@ -0,0 +1,296 @@ +# -*- coding: utf-8 -*- +# This work is part of the Core Imaging Library (CIL) developed by CCPi +# (Collaborative Computational Project in Tomographic Imaging), with +# substantial contributions by UKRI-STFC and University of Manchester. + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import numpy as np +import math +import time + +class Sampler(): + + r""" + A class to select from a list of integers {0, 1, …, S-1}, with each integer representing the index of a subset + The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations/epochs the users asks for. + + Calls are organised into epochs: The single index outputs can be organised into length-S lists. Each length-S list is called an epoch. The user can in principle ask for an infinite number of epochs to be run. Denote by E the number of epochs. + Each epoch always has a list of length S. It may contain the same subset index s multiple times or not at all. + + Parameters + ---------- + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + sampling_type:str + The sampling type used. + + order: list of integers + The list of integers the method selects from using next. + + shuffle= bool, default=False + If True, after each epoch (num_subsets calls of next), the sampling order is shuffled randomly. + + prob: list of floats of length num_subsets that sum to 1. + For random sampling with replacement, this is the probability for each integer to be called by next. + + seed:int, default=None + Random seed for the methods that use a random number generator. + + + + Example + ------- + + >>> sampler=Sampler.sequential(10) + >>> sampler.show_epochs(5) + >>> for _ in range(11): + print(sampler.next()) + + Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + 1 + + Example + ------- + >>> sampler=Sampler.randomWithReplacement(11) + >>> for _ in range(12): + >>> print(next(sampler)) + >>> sampler.show_epochs(5) + + 10 + 5 + 10 + 1 + 6 + 7 + 10 + 0 + 0 + 2 + 5 + 3 + Epoch 0: [10, 5, 10, 1, 6, 7, 10, 0, 0, 2, 5] + Epoch 1: [3, 10, 7, 7, 8, 7, 4, 7, 8, 4, 9] + Epoch 2: [0, 0, 0, 1, 3, 8, 6, 5, 7, 7, 0] + Epoch 3: [8, 8, 6, 4, 0, 2, 7, 2, 8, 3, 8] + Epoch 4: [10, 9, 3, 6, 6, 9, 5, 2, 8, 4, 0] + + + + """ + + @staticmethod + def sequential(num_subsets): + """ + Function that outputs a sampler that outputs sequentially. + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + Example + ------- + + >>> sampler=Sampler.sequential(10) + >>> sampler.show_epochs(5) + >>> for _ in range(11): + print(sampler.next()) + + Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + 1 + """ + order=list(range(num_subsets)) + sampler=Sampler(num_subsets, sampling_type='sequential', order=order) + return sampler + + @staticmethod + def customOrder( customlist): + """ + Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. + + customlist: list of integers + The list that will be sampled from in order. + """ + num_subsets=len(customlist) + sampler=Sampler(num_subsets, sampling_type='custom_order', order=customlist) + return sampler + + @staticmethod + def hermanMeyer(num_subsets): + + def _herman_meyer_order(n): + # Assuming that the subsets are in geometrical order + n_variable = n + i = 2 + factors = [] + while i * i <= n_variable: + if n_variable % i: + i += 1 + else: + n_variable //= i + factors.append(i) + if n_variable > 1: + factors.append(n_variable) + n_factors = len(factors) + order = [0 for _ in range(n)] + value = 0 + for factor_n in range(n_factors): + n_rep_value = 0 + if factor_n == 0: + n_change_value = 1 + else: + n_change_value = math.prod(factors[:factor_n]) + for element in range(n): + mapping = value + n_rep_value += 1 + if n_rep_value >= n_change_value: + value = value + 1 + n_rep_value = 0 + if value == factors[factor_n]: + value = 0 + order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping + return order + + order=_herman_meyer_order(num_subsets) + sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) + return sampler + + @staticmethod + def staggered(num_subsets, offset): + indices=list(range(num_subsets)) + order=[] + [order.extend(indices[i::offset]) for i in range(offset)] + # order=[indices[i::offset] for i in range(offset)] + print(order) + sampler=Sampler(num_subsets, sampling_type='staggered', order=order) + return sampler + + + + @staticmethod + def randomWithReplacement(num_subsets, prob=None, seed=None): + if prob==None: + prob = [1/num_subsets] *num_subsets + else: + prob=prob + if len(prob)!=num_subsets: + raise ValueError("Length of the list of probabilities should equal the number of subsets") + if sum(prob)!=1.: + raise ValueError("Probabilites should sum to 1.") + sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) + return sampler + + @staticmethod + def randomWithoutReplacement(num_subsets, seed=None): + order=list(range(num_subsets)) + sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) + return sampler + + + def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): + self.type=sampling_type + self.num_subsets=num_subsets + if seed !=None: + self.seed=seed + else: + self.seed=int(time.time()) + self.generator=np.random.RandomState(self.seed) + self.order=order + self.initial_order=order + if order!=None: + self.iterator=self._next_order + self.prob=prob + if prob!=None: + self.iterator=self._next_prob + self.shuffle=shuffle + self.last_subset=self.num_subsets-1 + + + + + def _next_order(self): + # print(self.last_subset) + if self.shuffle==True and self.last_subset==self.num_subsets-1: + self.order=self.generator.permutation(self.order) + #print(self.order) + self.last_subset= (self.last_subset+1)%self.num_subsets + return(self.order[self.last_subset]) + + def _next_prob(self): + return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) + + def next(self): + return (self.iterator()) + + def __next__(self): + return(self.next()) + + def show_epochs(self, num_epochs=2): + save_generator=self.generator + save_last_subset=self.last_subset + self.last_subset=self.num_subsets-1 + save_order=self.order + self.order=self.initial_order + self.generator=np.random.RandomState(self.seed) + for i in range(num_epochs): + print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) + self.generator=save_generator + self.order=save_order + self.last_subset=save_last_subset + + def get_epochs(self, num_epochs=2): + save_generator=self.generator + save_last_subset=self.last_subset + self.last_subset=self.num_subsets-1 + save_order=self.order + self.order=self.initial_order + self.generator=np.random.RandomState(self.seed) + output=[] + for i in range(num_epochs): + output.append( [self.next() for _ in range(self.num_subsets)]) + self.generator=save_generator + self.order=save_order + self.last_subset=save_last_subset + return(output) + From 75abbfe3149df26b792480f9eb2dccb5e368e554 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 14 Aug 2023 16:14:46 +0000 Subject: [PATCH 015/152] Work on documentation --- Wrappers/Python/cil/framework/sampler.py | 33 ++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 09472ab721..7befd5319a 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -264,9 +264,28 @@ def next(self): return (self.iterator()) def __next__(self): + """ Allows the user to call next(sampler), to get the same result as sampler.next()""" return(self.next()) def show_epochs(self, num_epochs=2): + """ + Function that takes an integer, num_epochs, and prints the first num_epochs epochs. Calling this function will not interrupt the random number generation, if applicable. + + num_epochs: int, default=2 + The number of epochs to print. + + Example + ------- + + >>> sampler=Sampler.randomWithoutReplacement(11) + >>> sampler.show_epochs(5) + Epoch 0: [9, 7, 2, 8, 0, 10, 1, 5, 3, 6, 4] + Epoch 1: [6, 2, 0, 10, 5, 1, 9, 8, 7, 4, 3] + Epoch 2: [5, 10, 0, 6, 1, 4, 3, 7, 2, 8, 9] + Epoch 3: [4, 8, 3, 7, 1, 10, 5, 6, 2, 9, 0] + Epoch 4: [0, 7, 2, 6, 9, 10, 8, 3, 1, 4, 5] + + """ save_generator=self.generator save_last_subset=self.last_subset self.last_subset=self.num_subsets-1 @@ -280,6 +299,20 @@ def show_epochs(self, num_epochs=2): self.last_subset=save_last_subset def get_epochs(self, num_epochs=2): + """ + Function that takes an integer, num_epochs, and returns the first num_epochs epochs in the form of a list of lists. Calling this function will not interrupt the random number generation, if applicable. + + num_epochs: int, default=2 + The number of epochs to return. + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_epochs()) + [[3, 2, 2, 4, 4], [0, 1, 2, 4, 4]] + + """ save_generator=self.generator save_last_subset=self.last_subset self.last_subset=self.num_subsets-1 From ebdf32978a7aed90845a76122b1ebd4fd81620c6 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 15 Aug 2023 08:34:31 +0000 Subject: [PATCH 016/152] Commenting and examples in the class --- Wrappers/Python/cil/framework/sampler.py | 165 ++++++++++++++++++++++- 1 file changed, 160 insertions(+), 5 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 7befd5319a..0c2dda2ad2 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -47,7 +47,7 @@ class Sampler(): For random sampling with replacement, this is the probability for each integer to be called by next. seed:int, default=None - Random seed for the methods that use a random number generator. + Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. @@ -151,6 +151,19 @@ def customOrder( customlist): customlist: list of integers The list that will be sampled from in order. + + Example + -------- + + >>> sampler=Sampler.customOrder([1,4,6,7,8,9,11]) + >>> sampler.show_epochs(5) + + Epoch 0: [1, 4, 6, 7, 8, 9, 11] + Epoch 1: [1, 4, 6, 7, 8, 9, 11] + Epoch 2: [1, 4, 6, 7, 8, 9, 11] + Epoch 3: [1, 4, 6, 7, 8, 9, 11] + Epoch 4: [1, 4, 6, 7, 8, 9, 11] + """ num_subsets=len(customlist) sampler=Sampler(num_subsets, sampling_type='custom_order', order=customlist) @@ -158,7 +171,27 @@ def customOrder( customlist): @staticmethod def hermanMeyer(num_subsets): + """ + Function that takes a number of subsets and returns a sampler which outputs a Herman Meyer order + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + Reference + ---------- + Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. + Example + ------- + >>> sampler=Sampler.hermanMeyer(12) + >>> sampler.show_epochs(5) + + Epoch 0: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + Epoch 1: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + Epoch 2: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + Epoch 3: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + Epoch 4: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + """ def _herman_meyer_order(n): # Assuming that the subsets are in geometrical order n_variable = n @@ -198,11 +231,32 @@ def _herman_meyer_order(n): @staticmethod def staggered(num_subsets, offset): + + """ + Function that takes a number of subsets and returns a sampler which outputs in a staggered order. + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + offset: int + The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. + + + Example + ------- + >>> sampler=Sampler.staggered(20,4) + >>> sampler.show_epochs(5) + + Epoch 0: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + Epoch 1: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + Epoch 2: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + Epoch 3: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + Epoch 4: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + """ + indices=list(range(num_subsets)) order=[] - [order.extend(indices[i::offset]) for i in range(offset)] - # order=[indices[i::offset] for i in range(offset)] - print(order) + [order.extend(indices[i::offset]) for i in range(offset)] sampler=Sampler(num_subsets, sampling_type='staggered', order=order) return sampler @@ -210,6 +264,40 @@ def staggered(num_subsets, offset): @staticmethod def randomWithReplacement(num_subsets, prob=None, seed=None): + """ + Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets with given probability and with replacement. + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + prob: list of floats of length num_subsets that sum to 1. default=None + This is the probability for each integer to be called by next. If None, then the integers will be sampled uniformly. + + seed:int, default=None + Random seed for the random number generator. If set to None, the seed will be set using the current time. + + + Example + ------- + + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_epochs()) + [[3, 2, 2, 4, 4], [0, 1, 2, 4, 4]] + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(4, [0.7,0.1,0.1,0.1]) + >>> sampler.show_epochs(5) + + Epoch 0: [1, 0, 0, 0] + Epoch 1: [0, 0, 0, 0] + Epoch 2: [0, 0, 2, 2] + Epoch 3: [0, 0, 3, 0] + Epoch 4: [3, 2, 0, 0] + """ + if prob==None: prob = [1/num_subsets] *num_subsets else: @@ -223,12 +311,58 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): @staticmethod def randomWithoutReplacement(num_subsets, seed=None): + + """ + Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. + Each epoch is a different perturbation and in each epoch each integer is outputted exactly once. + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + seed:int, default=None + Random seed for the random number generator. If set to None, the seed will be set using the current time. + + + Example + ------- + >>> sampler=Sampler.randomWithoutReplacement(11) + >>> sampler.show_epochs(5) + Epoch 0: [10, 4, 3, 0, 2, 9, 6, 8, 7, 5, 1] + Epoch 1: [6, 0, 2, 4, 5, 7, 3, 10, 9, 8, 1] + Epoch 2: [1, 2, 7, 4, 9, 5, 6, 3, 0, 8, 10] + Epoch 3: [3, 10, 2, 9, 5, 6, 1, 7, 0, 8, 4] + Epoch 4: [6, 10, 1, 4, 0, 3, 9, 8, 2, 5, 7] + """ + order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) return sampler def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): + """ + This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. + + Parameters + ---------- + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + sampling_type:str + The sampling type used. + + order: list of integers + The list of integers the method selects from using next. + + shuffle= bool, default=False + If True, after each epoch (num_subsets calls of next), the sampling order is shuffled randomly. + + prob: list of floats of length num_subsets that sum to 1. + For random sampling with replacement, this is the probability for each integer to be called by next. + + seed:int, default=None + Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. + """ self.type=sampling_type self.num_subsets=num_subsets if seed !=None: @@ -250,6 +384,14 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N def _next_order(self): + """ + The user should call sampler.next() or next(sampler) rather than use this function. + + A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + + This function us used by samplers that output a permutation of an list in each epoch. + + """ # print(self.last_subset) if self.shuffle==True and self.last_subset==self.num_subsets-1: self.order=self.generator.permutation(self.order) @@ -258,13 +400,26 @@ def _next_order(self): return(self.order[self.last_subset]) def _next_prob(self): + """ + The user should call sampler.next() or next(sampler) rather than use this function. + + A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + + This function us used by samplers that select from a list of integers {0, 1, …, S-1}, with S=num_subsets, randomly with replacement. + + """ return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) def next(self): + """ A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. """ + return (self.iterator()) def __next__(self): - """ Allows the user to call next(sampler), to get the same result as sampler.next()""" + """ + A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + + Allows the user to call next(sampler), to get the same result as sampler.next()""" return(self.next()) def show_epochs(self, num_epochs=2): From ba35fb85ec6ae26467db08b76c170c0e9d2787ac Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 15 Aug 2023 09:55:10 +0000 Subject: [PATCH 017/152] Debugging sampler --- Wrappers/Python/cil/framework/sampler.py | 4 +-- .../cil/optimisation/algorithms/SPDHG.py | 25 ++++++++----------- 2 files changed, 12 insertions(+), 17 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 0c2dda2ad2..a2b60cfeba 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -304,8 +304,8 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): prob=prob if len(prob)!=num_subsets: raise ValueError("Length of the list of probabilities should equal the number of subsets") - if sum(prob)!=1.: - raise ValueError("Probabilites should sum to 1.") + if sum(prob)-1.>=1e-5: + raise ValueError("Probabilities should sum to 1. Your probabilities sum to {}".format(sum(prob))) sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) return sampler diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 058002f139..312bd1f82c 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -50,7 +50,7 @@ class SPDHG(Algorithm): List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: instnace of the Sampler class + sampler: instance of the Sampler class Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets **kwargs: norms : list of floats @@ -77,11 +77,7 @@ class SPDHG(Algorithm): Notation for primal and dual step-sizes are reversed with comparison to PDHG.py - Note - ---- - - this code implements serial sampling only, as presented in [2] - (to be extended to more general case of [1] as future work) + References ---------- @@ -126,11 +122,11 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets + gamma : float parameter controlling the trade-off between the primal and dual step sizes - + sampler: instance of the Sampler class + Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. **kwargs: norms : list of floats precalculated list of norms of the operators @@ -154,13 +150,12 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ self.prob = [1/self.ndual_subsets] * self.ndual_subsets self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) else: - if self.prob==None: - if self.sampler.prob!=None: - self.prob=self.sampler.prob - else: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets + if self.sampler.prob!=None: + self.prob=self.sampler.prob else: - warnings.warn('You supplied both probabilites and a sampler. The sampler will be used for sampling and the probabilites for calculationg step sizes, if not explicitly set.') + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + if self.prob!=None: + warnings.warn('You supplied both probabilities and a sampler. The given probabilities will be ignored.') From ff5cdf1991296f51b78772a549b47c228b1f5655 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 15 Aug 2023 15:29:11 +0000 Subject: [PATCH 018/152] sorted build and imports --- .../cil/optimisation/functions/SGFunction.py | 4 +- .../cil/optimisation/functions/__init__.py | 3 + .../cil/optimisation/functions/test_SGD.ipynb | 416 --- .../functions/testing_TV_warmstart.ipynb | 2333 ----------------- 4 files changed, 5 insertions(+), 2751 deletions(-) delete mode 100644 Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb delete mode 100644 Wrappers/Python/cil/optimisation/functions/testing_TV_warmstart.ipynb diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 2cddb1c2c3..5f4d43a611 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -15,7 +15,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from ApproximateGradientSumFunction import ApproximateGradientSumFunction +from .ApproximateGradientSumFunction import ApproximateGradientSumFunction class SGFunction(ApproximateGradientSumFunction): @@ -27,7 +27,7 @@ class SGFunction(ApproximateGradientSumFunction): functions: list A list of functions. sampler: callable or None, optional - A callable object that selects the function or batch of functions to compute the gradient. If None, a random function will be selected. + A callable object that selects the function or batch of functions to compute the gradient. TODO: If None, a random function will be selected. """ diff --git a/Wrappers/Python/cil/optimisation/functions/__init__.py b/Wrappers/Python/cil/optimisation/functions/__init__.py index 2c97ad4cb1..bcd33e39b5 100644 --- a/Wrappers/Python/cil/optimisation/functions/__init__.py +++ b/Wrappers/Python/cil/optimisation/functions/__init__.py @@ -35,3 +35,6 @@ from .KullbackLeibler import KullbackLeibler from .Rosenbrock import Rosenbrock from .TotalVariation import TotalVariation +from .ApproximateGradientSumFunction import ApproximateGradientSumFunction +from .SGFunction import SGFunction + diff --git a/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb b/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb deleted file mode 100644 index 010f400017..0000000000 --- a/Wrappers/Python/cil/optimisation/functions/test_SGD.ipynb +++ /dev/null @@ -1,416 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# -*- coding: utf-8 -*-\n", - "# Copyright 2019 - 2022 United Kingdom Research and Innovation\n", - "# Copyright 2019 - 2022 The University of Manchester\n", - "# Copyright 2019 - 2022 The University of Bath\n", - "#\n", - "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", - "# you may not use this file except in compliance with the License.\n", - "# You may obtain a copy of the License at\n", - "#\n", - "# http://www.apache.org/licenses/LICENSE-2.0\n", - "#\n", - "# Unless required by applicable law or agreed to in writing, software\n", - "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", - "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", - "# See the License for the specific language governing permissions and\n", - "# limitations under the License.\n", - "#\n", - "# Authored by: Claire Delplancke (University of Bath)\n", - "# Evangelos Papoutsellis (UKRI-STFC)\n", - "# Gemma Fardell (UKRI-STFC)\n", - "# Laura Murgatroyd (UKRI-STFC) \n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# Import libraries\n", - " \n", - "from cil.optimisation.algorithms import PDHG, SPDHG\n", - "from cil.optimisation.operators import GradientOperator, BlockOperator\n", - "from cil.optimisation.functions import LeastSquares\n", - "from cil.optimisation.algorithms import GD\n", - "\n", - "\n", - "from cil.io import ZEISSDataReader\n", - " \n", - "from cil.processors import Slicer, Binner, TransmissionAbsorptionConverter\n", - " \n", - "from cil.plugins.astra.operators import ProjectionOperator\n", - "from cil.plugins.ccpi_regularisation.functions import FGP_TV\n", - " \n", - "from cil.utilities.display import show2D\n", - "from cil.utilities.jupyter import islicer\n", - " \n", - "from SGFunction import SGFunction\n", - " \n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import os" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Data information\n", - "\n", - "In this demo, we use the **Walnut** found in [Jørgensen_et_all](https://zenodo.org/record/4822516#.YLXyAJMzZp8). In total, there are 6 individual micro Computed Tomography datasets in the native Zeiss TXRM/TXM format. The six datasets were acquired at the 3D Imaging Center at Technical University of Denmark in 2014 (HDTomo3D in 2016) as part of the ERC-funded project High-Definition Tomography (HDTomo) headed by Prof. Per Christian Hansen. \n", - "\n", - "This example requires the dataset walnut.zip from https://zenodo.org/record/4822516 :\n", - "\n", - " https://zenodo.org/record/4822516/files/walnut.zip\n", - "\n", - "If running locally please download the data and update the `path` variable below." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "path = '../../data/walnut/valnut'" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "reader = ZEISSDataReader()\n", - "filename = \"valnut_tomo-A.txrm\"\n", - "reader.set_up(file_name=filename)\n", - "data3D = reader.read()\n", - "\n", - "# reorder data to match default order for Astra/Tigre operator\n", - "data3D.reorder('astra')\n", - "\n", - "# Get Image and Acquisition geometries\n", - "ag3D = data3D.geometry\n", - "ig3D = ag3D.get_ImageGeometry()\n", - "\n", - "# Extract vertical slice\n", - "data2D = data3D.get_slice(vertical='centre')\n", - "\n", - "# Select every 10 angles\n", - "sliced_data = Slicer(roi={'angle':(0,1601,10)})(data2D)\n", - "\n", - "# Reduce background regions\n", - "binned_data = Binner(roi={'horizontal':(120,-120,2)})(sliced_data)\n", - "\n", - "# Create absorption data \n", - "data = TransmissionAbsorptionConverter()(binned_data) \n", - "\n", - "# Remove circular artifacts\n", - "data -= np.mean(data.as_array()[80:100,0:30])\n", - "\n", - "# Get Image and Acquisition geometries for one slice\n", - "ag2D = data.geometry\n", - "ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian')\n", - "ig2D = ag2D.get_ImageGeometry()\n", - "\n", - "A = ProjectionOperator(ig2D, ag2D, device = \"gpu\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We need to define the following:\n", - "\n", - "- The operator $K=(K_1,\\dots,K_n)$.\n", - "- The functions $F=(F_1,\\dots,F_N)$ and $G$.\n", - "- The maximum number of iterations\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "# Define number of subsets\n", - "n_subsets = 20\n", - "\n", - "# Initialize the lists containing the F_i's and A_i's\n", - "f_subsets = []\n", - "A_subsets = []\n", - "\n", - "# Define F_i's and A_i's\n", - "for i in range(n_subsets):\n", - " # Total number of angles\n", - " n_angles = len(ag2D.angles)\n", - " # Divide the data into subsets\n", - " data_subset = Slicer(roi = {'angle' : (i,n_angles,n_subsets)})(data)\n", - " \n", - " # Define A_i and put into list \n", - " ageom_subset = data_subset.geometry\n", - " Ai = ProjectionOperator(ig2D, ageom_subset)\n", - " A_subsets.append(Ai)\n", - " # Define F_i and put into list\n", - " fi = LeastSquares(Ai, b=data_subset)\n", - " f_subsets.append(fi)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "\n", - "class Sampling():\n", - " def __init__(self, num_subsets, prob=None, seed=99):\n", - " self.num_subsets=num_subsets\n", - " np.random.seed(seed)\n", - "\n", - " if prob==None:\n", - " self.prob = [1/self.num_subsets] * self.num_subsets\n", - " else:\n", - " self.prob=prob\n", - " def next(self):\n", - " \n", - " return int(np.random.choice(self.num_subsets, 1, p=self.prob))\n", - "sampler=Sampling(n_subsets)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dask is not installed.\n", - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 1000 0.000 1.38039e+04\n", - " 100 1000 0.028 4.44989e+01\n", - " 200 1000 0.027 4.07130e+01\n", - " 300 1000 0.022 3.95771e+01\n", - " 400 1000 0.019 3.94965e+01\n", - " 500 1000 0.018 3.92958e+01\n", - " 600 1000 0.017 3.89547e+01\n", - " 700 1000 0.017 3.88912e+01\n", - " 800 1000 0.019 3.87862e+01\n", - " 900 1000 0.019 3.86670e+01\n", - " 1000 1000 0.018 3.89482e+01\n", - "-------------------------------------------------------\n", - " 1000 1000 0.018 3.89482e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "stochastic_objective=SGFunction(f_subsets,sampler)\n", - "mySGD_LS = GD(initial=ig2D.allocate(0), \n", - " objective_function=stochastic_objective, \n", - " step_size=0.001, \n", - " max_iteration=1000, \n", - " update_objective_interval=100)\n", - "mySGD_LS.run(1000, verbose=1)\n", - "\n", - "show2D(mySGD_LS.solution)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Dask is not installed.\n", - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 1000 0.000 1.38039e+04\n", - " 100 1000 0.011 4.39259e+01\n", - " 200 1000 0.011 4.02738e+01\n", - " 300 1000 0.014 3.97689e+01\n", - " 400 1000 0.017 3.94480e+01\n", - " 500 1000 0.017 3.93345e+01\n", - " 600 1000 0.016 3.89108e+01\n", - " 700 1000 0.016 4.04457e+01\n", - " 800 1000 0.015 3.90482e+01\n", - " 900 1000 0.015 3.88493e+01\n", - " 1000 1000 0.016 3.87953e+01\n", - "-------------------------------------------------------\n", - " 1000 1000 0.016 3.87953e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "stochastic_objective=SGFunction(f_subsets,sampler)\n", - "mySGD_LS = GD(initial=ig2D.allocate(0), \n", - " objective_function=stochastic_objective, \n", - " step_size=0.001, \n", - " max_iteration=1000, \n", - " update_objective_interval=100)\n", - "mySGD_LS.run(1000, verbose=1)\n", - "\n", - "show2D(mySGD_LS.solution)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 1000 0.000 1.38039e+04\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 100 1000 0.030 4.34737e+01\n", - " 200 1000 0.023 3.99915e+01\n", - " 300 1000 0.021 3.92955e+01\n", - " 400 1000 0.024 3.89863e+01\n", - " 500 1000 0.025 3.87991e+01\n", - " 600 1000 0.024 3.86670e+01\n", - " 700 1000 0.023 3.85653e+01\n", - " 800 1000 0.023 3.84827e+01\n", - " 900 1000 0.025 3.84133e+01\n", - " 1000 1000 0.024 3.83534e+01\n", - "-------------------------------------------------------\n", - " 1000 1000 0.024 3.83534e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "f = LeastSquares(A, b=data)\n", - "myGD_LS = GD(initial=ig2D.allocate(0), \n", - " objective_function=f, \n", - " step_size=0.001, \n", - " max_iteration=1000, \n", - " update_objective_interval=100)\n", - "myGD_LS.run(1000, verbose=1)\n", - "\n", - "show2D(mySGD_LS.solution)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "interpreter": { - "hash": "43cbf82c2f716cd564b762322e13d4dbd881fd8a341d231fe608abc3118da208" - }, - "kernelspec": { - "display_name": "Python 3.9.13 ('cil_22.0.0')", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/Wrappers/Python/cil/optimisation/functions/testing_TV_warmstart.ipynb b/Wrappers/Python/cil/optimisation/functions/testing_TV_warmstart.ipynb deleted file mode 100644 index 3ff5241292..0000000000 --- a/Wrappers/Python/cil/optimisation/functions/testing_TV_warmstart.ipynb +++ /dev/null @@ -1,2333 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "id": "d304d2b3", - "metadata": {}, - "outputs": [], - "source": [ - "# -*- coding: utf-8 -*-\n", - "# Copyright 2019 - 2022 United Kingdom Research and Innovation\n", - "# Copyright 2019 - 2022 The University of Manchester\n", - "#\n", - "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", - "# you may not use this file except in compliance with the License.\n", - "# You may obtain a copy of the License at\n", - "#\n", - "# http://www.apache.org/licenses/LICENSE-2.0\n", - "#\n", - "# Unless required by applicable law or agreed to in writing, software\n", - "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", - "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", - "# See the License for the specific language governing permissions and\n", - "# limitations under the License.\n", - "#\n", - "# Authored by: Evangelos Papoutsellis (UKRI-STFC)\n", - "# Gemma Fardell (UKRI-STFC)\n", - "# Laura Murgatroyd (UKRI-STFC) " - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "c06fd185-0bbb-48c1-ba6c-ac61cad8266b", - "metadata": {}, - "source": [ - "# Primal Dual Hybrid Gradient Algorithm\n", - "\n", - "In this demo, we learn how to use the **Primal Dual Hybrid Algorithm (PDHG)** introduced by [Chambolle & Pock](https://hal.archives-ouvertes.fr/hal-00490826/document) for Tomography Reconstruction. We will solve the following minimisation problem under three different regularisation terms, i.e., \n", - "\n", - "* $\\|\\cdot\\|_{1}$ or\n", - "* Tikhonov regularisation or\n", - "* with $L=\\nabla$ and Total variation:\n", - "\n", - "\n", - "\n", - "$$\n", - "u^{*} =\\underset{u}{\\operatorname{argmin}} \\frac{1}{2} \\| \\mathcal{A} u - g\\|^{2} +\n", - "\\underbrace{\n", - "\\begin{cases}\n", - "\\alpha\\,\\|u\\|_{1}, & \\\\[10pt]\n", - "\\alpha\\,\\|\\nabla u\\|_{2}^{2}, & \\\\[10pt]\n", - "\\alpha\\,\\mathrm{TV}(u) + \\mathbb{I}_{\\{u\\geq 0\\}}(u).\n", - "\\end{cases}}_{Regularisers}\n", - "\\tag{all reg}\n", - "$$\n", - "\n", - "where,\n", - "\n", - "1. $g$ is the Acquisition data obtained from the detector.\n", - "\n", - "1. $\\mathcal{A}$ is the projection operator ( _Radon transform_ ) that maps from an image-space to an acquisition space, i.e., $\\mathcal{A} : \\mathbb{X} \\rightarrow \\mathbb{Y}, $ where $\\mathbb{X}$ is an __ImageGeometry__ and $\\mathbb{Y}$ is an __AcquisitionGeometry__.\n", - "\n", - "1. $\\alpha$: regularising parameter that measures the trade-off between the fidelity and the regulariser terms.\n", - "\n", - "1. The total variation (isotropic) is defined as $$\\mathrm{TV}(u) = \\|\\nabla u \\|_{2,1} = \\sum \\sqrt{ (\\partial_{y}u)^{2} + (\\partial_{x}u)^{2} }$$\n", - "\n", - "1. $\\mathbb{I}_{\\{u\\geq 0\\}}(u) : = \n", - "\\begin{cases}\n", - "0, & \\text{ if } u\\geq 0\\\\\n", - "\\infty , & \\text{ otherwise}\n", - "\\,\n", - "\\end{cases}\n", - "$, $\\quad$ a non-negativity constraint for the minimiser $u$." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "385c848a-9d9a-48ff-b029-a42e90e4cb2c", - "metadata": {}, - "source": [ - "# Learning objectives\n", - "\n", - "- Load the data using the CIL reader: `ZEISSDataReader`.\n", - "- Preprocess the data using the CIL processors: `Binner`, `TransmissionAbsorptionConverter`.\n", - "- Run FBP and SIRT reconstructions.\n", - "- Setup PDHG for 3 different regularisers: $L^{1}$, Tikhonov and Total variation.\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "We first import all the necessary libraries for this notebook.\n", - "\n", - "" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "f731d970-d6ce-489a-bf93-7888cc855a60", - "metadata": {}, - "outputs": [], - "source": [ - "# Import libraries\n", - "\n", - "from cil.framework import BlockDataContainer\n", - "\n", - "from cil.optimisation.functions import L2NormSquared, L1Norm, BlockFunction, MixedL21Norm, IndicatorBox\n", - "from TotalVariation import TotalVariation\n", - "\n", - "from cil.optimisation.operators import GradientOperator, BlockOperator\n", - "from cil.optimisation.algorithms import PDHG, SIRT\n", - "\n", - "from cil.plugins.astra.operators import ProjectionOperator\n", - "from cil.plugins.astra.processors import FBP\n", - "\n", - "from cil.plugins.ccpi_regularisation.functions import FGP_TV\n", - "\n", - "from cil.utilities.display import show2D, show1D, show_geometry\n", - "from cil.utilities.jupyter import islicer\n", - "\n", - "from cil.io import ZEISSDataReader\n", - "\n", - "from cil.processors import Binner, TransmissionAbsorptionConverter, Slicer\n", - "\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import numpy as np\n", - "\n", - "import os" - ] - }, - { - "cell_type": "markdown", - "id": "36dc5a6d-c4e9-4ece-9f37-cde82dc93964", - "metadata": {}, - "source": [ - "# Data information\n", - "\n", - "In this demo, we use the **Walnut** found in [Jørgensen_et_all](https://zenodo.org/record/4822516#.YLXyAJMzZp8). In total, there are 6 individual micro Computed Tomography datasets in the native Zeiss TXRM/TXM format. The six datasets were acquired at the 3D Imaging Center at Technical University of Denmark in 2014 (HDTomo3D in 2016) as part of the ERC-funded project High-Definition Tomography (HDTomo) headed by Prof. Per Christian Hansen. \n", - "\n", - "This example requires the dataset walnut.zip from https://zenodo.org/record/4822516 :\n", - "\n", - " - https://zenodo.org/record/4822516/files/walnut.zip\n", - "\n", - "If running locally please download the data and update the `path` variable below." - ] - }, - { - "cell_type": "markdown", - "id": "732c5f6b-6fd4-43ea-b5f6-796632f62528", - "metadata": {}, - "source": [ - "## Load walnut data" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ce2c36aa-1231-4669-9486-197f9332fe2e", - "metadata": {}, - "outputs": [], - "source": [ - "path = '../../../data/'" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "d64a1b3a", - "metadata": {}, - "outputs": [], - "source": [ - "reader = ZEISSDataReader()\n", - "filename = os.path.join(path, \"valnut_tomo-A.txrm\")\n", - "data3D = ZEISSDataReader(file_name=filename).read()" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0fd50459", - "metadata": {}, - "outputs": [], - "source": [ - "# reorder data to match default order for Astra/Tigre operator\n", - "data3D.reorder('astra')\n", - "\n", - "# Get Image and Acquisition geometries\n", - "ag3D = data3D.geometry\n", - "ig3D = ag3D.get_ImageGeometry()" - ] - }, - { - "cell_type": "markdown", - "id": "2f97e39e-12db-4eae-9de5-cc31e667490e", - "metadata": {}, - "source": [ - "### Acquisition and Image geometry information" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "ece32bb6-5066-4f7c-b6b6-8edc62ecb817", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "3D Cone-beam tomography\n", - "System configuration:\n", - "\tSource position: [ 0. , -105.05081177, 0. ]\n", - "\tRotation axis position: [0., 0., 0.]\n", - "\tRotation axis direction: [0., 0., 1.]\n", - "\tDetector position: [ 0. , 45.08757401, 0. ]\n", - "\tDetector direction x: [1., 0., 0.]\n", - "\tDetector direction y: [0., 0., 1.]\n", - "Panel configuration:\n", - "\tNumber of pixels: [1024 1024]\n", - "\tPixel size: [0.0658543 0.0658543]\n", - "\tPixel origin: bottom-left\n", - "Channel configuration:\n", - "\tNumber of channels: 1\n", - "Acquisition description:\n", - "\tNumber of positions: 1601\n", - "\tAngles 0-20 in radians:\n", - "[-3.1415665, -3.1377017, -3.1337626, -3.1298182, -3.125836 , -3.1219127,\n", - " -3.1180956, -3.1140666, -3.1101887, -3.1062822, -3.1022923, -3.0984268,\n", - " -3.0944946, -3.0905435, -3.0865552, -3.082691 , -3.0787866, -3.074828 ,\n", - " -3.0708766, -3.0669732]\n", - "Distances in units: units distance\n" - ] - } - ], - "source": [ - "print(ag3D)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "14083f74-3490-4d18-a784-c659f2c5984b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of channels: 1\n", - "channel_spacing: 1.0\n", - "voxel_num : x1024,y1024,z1024\n", - "voxel_size : x0.04607780456542968,y0.04607780456542968,z0.04607780456542968\n", - "center : x0,y0,z0\n", - "\n" - ] - } - ], - "source": [ - "print(ig3D)" - ] - }, - { - "cell_type": "markdown", - "id": "bab54a03-3ab6-4100-a82a-45a8e807e5f1", - "metadata": {}, - "source": [ - "### Show Acquisition geometry and full 3D sinogram." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "d6b6a162-08d5-4c28-9a2b-a06091747f0a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "show_geometry(ag3D)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "fc29dd0a-2f27-4a89-8a49-9733d9453b86", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "show2D(data3D, slice_list = [('vertical',512), ('angle',800), ('horizontal',512)], cmap=\"inferno\", num_cols=3, size=(15,15))" - ] - }, - { - "cell_type": "markdown", - "id": "dc945eb5-17d9-476e-b4dd-998b9b90d51e", - "metadata": {}, - "source": [ - "### Slice through projections" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "e6e19c5d-0724-46a2-907c-d9e86b24ee91", - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f76868f2e54240fc904cdf8eca2a7d43", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(Output(), Box(children=(Play(value=800, interval=500, max=1600), VBox(children=(Label(value='Sl…" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "islicer(data3D, direction=1, cmap=\"inferno\")" - ] - }, - { - "cell_type": "markdown", - "id": "5afa53ea-6723-44ef-a803-587630568ec4", - "metadata": {}, - "source": [ - "### For demonstration purposes, we extract the central slice and select only 160 angles from the total 1601 angles.\n", - "\n", - "1. We use the `Slicer` processor with step size of 10.\n", - "1. We use the `Binner` processor to crop and bin the acquisition data in order to reduce the field of view.\n", - "1. We use the `TransmissionAbsorptionConverter` to convert from transmission measurements to absorption based on the Beer-Lambert law.\n", - "\n", - "**Note:** To avoid circular artifacts in the reconstruction space, we subtract the mean value of a background Region of interest (ROI), i.e., ROI that does not contain the walnut." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "3dae73ff-165f-4ac3-990a-e5584a627e9f", - "metadata": {}, - "outputs": [], - "source": [ - "# Extract vertical slice\n", - "data2D = data3D.get_slice(vertical='centre')\n", - "\n", - "# Select every 10 angles\n", - "sliced_data = Slicer(roi={'angle':(0,1600,10)})(data2D)\n", - "\n", - "# Reduce background regions\n", - "binned_data = Binner(roi={'horizontal':(120,-120,2)})(sliced_data)\n", - "\n", - "# Create absorption data \n", - "absorption_data = TransmissionAbsorptionConverter()(binned_data) \n", - "\n", - "# Remove circular artifacts\n", - "absorption_data -= np.mean(absorption_data.as_array()[80:100,0:30])\n", - "\n", - "#Add some gaussian noise \n", - "absorption_data+=np.random.normal(0, 0.1*np.mean(absorption_data))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "4165bcfc-1e28-44ea-bfe3-f85648bc4dc8", - "metadata": {}, - "outputs": [], - "source": [ - "# Get Image and Acquisition geometries for one slice\n", - "ag2D = absorption_data.geometry\n", - "ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian')\n", - "ig2D = ag2D.get_ImageGeometry()" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "5fdafdab-19f2-499a-8b6b-acfdaa83bf95", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Acquisition Geometry 2D: (160, 392) with labels ('angle', 'horizontal')\n", - " Image Geometry 2D: (392, 392) with labels ('horizontal_y', 'horizontal_x')\n" - ] - } - ], - "source": [ - "print(\" Acquisition Geometry 2D: {} with labels {}\".format(ag2D.shape, ag2D.dimension_labels))\n", - "print(\" Image Geometry 2D: {} with labels {}\".format(ig2D.shape, ig2D.dimension_labels))" - ] - }, - { - "cell_type": "markdown", - "id": "3156de74-773a-4ec9-aadb-1f7d31a435b5", - "metadata": {}, - "source": [ - "### Define Projection Operator \n", - "We can define our projection operator using our __astra__ __plugin__ that wraps the Astra-Toolbox library." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "e4919986-1aad-4e2d-9af3-68d7b1d685ea", - "metadata": {}, - "outputs": [], - "source": [ - "A = ProjectionOperator(ig2D, ag2D, device = \"gpu\")" - ] - }, - { - "cell_type": "markdown", - "id": "a2232e53-a927-461b-9e95-2c9f322257b7", - "metadata": {}, - "source": [ - "## PDHG - implicit TV (using CIL)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "35b0e04b-4393-46d5-b8a3-bbf6161feeb8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 200 0.000 8.98686e+03\n", - " 5 200 3.491 1.28336e+02\n", - " 10 200 3.175 6.33684e+01\n", - " 15 200 3.018 4.92200e+01\n", - " 20 200 2.928 3.95762e+01\n", - " 25 200 2.878 3.11324e+01\n", - " 30 200 2.778 2.72461e+01\n", - " 35 200 2.752 2.57557e+01\n", - " 40 200 2.725 2.39985e+01\n", - " 45 200 2.681 2.31592e+01\n", - " 50 200 2.695 2.27356e+01\n", - " 55 200 2.743 2.23128e+01\n", - " 60 200 2.732 2.20016e+01\n", - " 65 200 2.728 2.18614e+01\n", - " 70 200 2.720 2.17656e+01\n", - " 75 200 2.720 2.16970e+01\n", - " 80 200 2.727 2.16574e+01\n", - " 85 200 2.737 2.16201e+01\n", - " 90 200 2.737 2.15945e+01\n", - " 95 200 2.707 2.15802e+01\n", - " 100 200 2.706 2.15705e+01\n", - " 105 200 2.699 2.15634e+01\n", - " 110 200 2.723 2.15575e+01\n", - " 115 200 2.727 2.15534e+01\n", - " 120 200 2.729 2.15506e+01\n", - " 125 200 2.722 2.15484e+01\n", - " 130 200 2.716 2.15468e+01\n", - " 135 200 2.722 2.15457e+01\n", - " 140 200 2.669 2.15449e+01\n", - " 145 200 2.615 2.15441e+01\n", - " 150 200 2.565 2.15435e+01\n", - " 155 200 2.513 2.15431e+01\n", - " 160 200 2.466 2.15427e+01\n", - " 165 200 2.422 2.15424e+01\n", - " 170 200 2.381 2.15422e+01\n", - " 175 200 2.342 2.15420e+01\n", - " 180 200 2.304 2.15418e+01\n", - " 185 200 2.269 2.15416e+01\n", - " 190 200 2.235 2.15414e+01\n", - " 195 200 2.204 2.15413e+01\n", - " 200 200 2.175 2.15411e+01\n", - "-------------------------------------------------------\n", - " 200 200 2.175 2.15411e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "alpha_tv=0.0005\n", - "\n", - "F = 0.5 * L2NormSquared(b=absorption_data)\n", - "G = alpha_tv * TotalVariation(max_iteration=100, lower=0.)\n", - "K = A\n", - "# Setup and run PDHG\n", - "pdhg_tv_implicit_cil = PDHG(f = F, g = G, operator = K,\n", - " max_iteration = 200,\n", - " update_objective_interval = 5)\n", - "pdhg_tv_implicit_cil.run(verbose=1)" - ] - }, - { - "cell_type": "markdown", - "id": "114e68b6", - "metadata": {}, - "source": [ - "## PDHG - implicit TV (using CIL) with warm start " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "59c06af0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 200 0.000 8.98686e+03\n", - " 5 200 0.068 1.28190e+02\n", - " 10 200 0.067 6.31339e+01\n", - " 15 200 0.067 4.90806e+01\n", - " 20 200 0.068 3.93596e+01\n", - " 25 200 0.067 3.10063e+01\n", - " 30 200 0.066 2.71367e+01\n", - " 35 200 0.066 2.56700e+01\n", - " 40 200 0.066 2.39577e+01\n", - " 45 200 0.066 2.31261e+01\n", - " 50 200 0.066 2.27055e+01\n", - " 55 200 0.066 2.22953e+01\n", - " 60 200 0.066 2.19916e+01\n", - " 65 200 0.066 2.18526e+01\n", - " 70 200 0.066 2.17590e+01\n", - " 75 200 0.066 2.16926e+01\n", - " 80 200 0.066 2.16535e+01\n", - " 85 200 0.066 2.16174e+01\n", - " 90 200 0.066 2.15928e+01\n", - " 95 200 0.066 2.15790e+01\n", - " 100 200 0.067 2.15696e+01\n", - " 105 200 0.067 2.15628e+01\n", - " 110 200 0.067 2.15572e+01\n", - " 115 200 0.067 2.15533e+01\n", - " 120 200 0.066 2.15506e+01\n", - " 125 200 0.066 2.15484e+01\n", - " 130 200 0.066 2.15469e+01\n", - " 135 200 0.066 2.15458e+01\n", - " 140 200 0.066 2.15449e+01\n", - " 145 200 0.066 2.15442e+01\n", - " 150 200 0.066 2.15436e+01\n", - " 155 200 0.066 2.15432e+01\n", - " 160 200 0.066 2.15428e+01\n", - " 165 200 0.066 2.15425e+01\n", - " 170 200 0.066 2.15422e+01\n", - " 175 200 0.066 2.15420e+01\n", - " 180 200 0.066 2.15418e+01\n", - " 185 200 0.066 2.15417e+01\n", - " 190 200 0.066 2.15415e+01\n", - " 195 200 0.066 2.15413e+01\n", - " 200 200 0.066 2.15412e+01\n", - "-------------------------------------------------------\n", - " 200 200 0.066 2.15412e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "F = 0.5 * L2NormSquared(b=absorption_data)\n", - "G = alpha_tv * TotalVariation(max_iteration=5, lower=0., warmstart=True)\n", - "K = A\n", - "# Setup and run PDHG\n", - "pdhg_tv_implicit_cil_warm_start = PDHG(f = F, g = G, operator = K,\n", - " max_iteration = 200,\n", - " update_objective_interval = 5)\n", - "pdhg_tv_implicit_cil_warm_start.run(verbose=1)" - ] - }, - { - "cell_type": "markdown", - "id": "37cf55b5", - "metadata": {}, - "source": [ - "## PDHG - implicit TV (using FGP_TV)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "9a8c0557", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 200 0.000 8.98686e+03\n", - " 5 200 0.026 1.28336e+02\n", - " 10 200 0.025 6.33683e+01\n", - " 15 200 0.024 4.92200e+01\n", - " 20 200 0.024 3.95762e+01\n", - " 25 200 0.023 3.11323e+01\n", - " 30 200 0.023 2.72460e+01\n", - " 35 200 0.023 2.57556e+01\n", - " 40 200 0.023 2.39984e+01\n", - " 45 200 0.023 2.31591e+01\n", - " 50 200 0.023 2.27356e+01\n", - " 55 200 0.023 2.23127e+01\n", - " 60 200 0.023 2.20016e+01\n", - " 65 200 0.023 2.18613e+01\n", - " 70 200 0.023 2.17655e+01\n", - " 75 200 0.023 2.16970e+01\n", - " 80 200 0.023 2.16573e+01\n", - " 85 200 0.023 2.16201e+01\n", - " 90 200 0.023 2.15944e+01\n", - " 95 200 0.023 2.15802e+01\n", - " 100 200 0.023 2.15704e+01\n", - " 105 200 0.023 2.15633e+01\n", - " 110 200 0.023 2.15574e+01\n", - " 115 200 0.023 2.15533e+01\n", - " 120 200 0.023 2.15506e+01\n", - " 125 200 0.023 2.15484e+01\n", - " 130 200 0.023 2.15467e+01\n", - " 135 200 0.023 2.15456e+01\n", - " 140 200 0.023 2.15448e+01\n", - " 145 200 0.023 2.15441e+01\n", - " 150 200 0.022 2.15435e+01\n", - " 155 200 0.023 2.15430e+01\n", - " 160 200 0.023 2.15427e+01\n", - " 165 200 0.023 2.15423e+01\n", - " 170 200 0.023 2.15421e+01\n", - " 175 200 0.022 2.15419e+01\n", - " 180 200 0.022 2.15417e+01\n", - " 185 200 0.022 2.15416e+01\n", - " 190 200 0.022 2.15414e+01\n", - " 195 200 0.022 2.15412e+01\n", - " 200 200 0.022 2.15411e+01\n", - "-------------------------------------------------------\n", - " 200 200 0.022 2.15411e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "F = 0.5 * L2NormSquared(b=absorption_data)\n", - "G = (alpha_tv/ig2D.voxel_size_y) * FGP_TV(max_iteration=100, nonnegativity = True, device = 'gpu') \n", - "K = A\n", - "\n", - "# Setup and run PDHG\n", - "pdhg_tv_implicit_regtk = PDHG(f = F, g = G, operator = K,\n", - " max_iteration = 200,\n", - " update_objective_interval = 5)\n", - "pdhg_tv_implicit_regtk.run(verbose=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "b78c87bb-9dcf-4d40-b41e-b7118c3ac120", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Absolute error between Regtk solution and warm start solution: 0.0007760412\n", - "[8986.8583984375, 128.33596608042717, 63.368345975875854, 49.2199912071228, 39.576210379600525, 31.132325649261475, 27.246046543121338, 25.755617260932922, 23.998438477516174, 23.1591135263443, 22.735593914985657, 22.3127281665802, 22.001588225364685, 21.861290454864502, 21.76551902294159, 21.696985363960266, 21.657320737838745, 21.62007427215576, 21.59442889690399, 21.5801739692688, 21.570448875427246, 21.56331193447113, 21.557433605194092, 21.553338766098022, 21.550590753555298, 21.548352241516113, 21.546719312667847, 21.5456383228302, 21.544804334640503, 21.54409098625183, 21.543490767478943, 21.543021321296692, 21.54265320301056, 21.542346358299255, 21.542125344276428, 21.54191493988037, 21.541720867156982, 21.54155743122101, 21.54138195514679, 21.54121685028076, 21.54105579853058]\n", - "[8986.8583984375, 128.33597006225585, 63.36835958862304, 49.220016815185545, 39.57623785400391, 31.132365951538088, 27.2461004486084, 25.755655456542968, 23.998477935791016, 23.159166763305663, 22.73563150024414, 22.312793090820314, 22.001643981933594, 21.86135662841797, 21.765576599121093, 21.69703451538086, 21.65737384033203, 21.62012516784668, 21.59448864746094, 21.580240173339845, 21.57049639892578, 21.563368591308596, 21.557487213134767, 21.553393768310546, 21.550642578125, 21.54840592956543, 21.546775329589845, 21.545701599121095, 21.544864135742188, 21.54413049316406, 21.543544692993166, 21.543082000732422, 21.542705047607424, 21.542405120849608, 21.542167541503908, 21.541965911865233, 21.54177732849121, 21.541603515625, 21.541440109252928, 21.541277618408202, 21.541126724243163]\n", - "[8986.8583984375, 128.18999746704102, 63.13393936157227, 49.08058074951172, 39.359574035644535, 31.006344329833986, 27.13668930053711, 25.66995785522461, 23.957702224731445, 23.12611491394043, 22.705514099121093, 22.29525975036621, 21.991572784423827, 21.85256228637695, 21.759012634277344, 21.69258251953125, 21.65354495239258, 21.617425872802734, 21.59281967163086, 21.578999099731444, 21.56964944458008, 21.562801879882812, 21.557206558227538, 21.553263916015624, 21.550565185546876, 21.548426391601563, 21.54688949584961, 21.545794311523437, 21.544929779052733, 21.544213775634766, 21.543643997192383, 21.543185760498048, 21.5428017578125, 21.542493743896486, 21.542242752075197, 21.54202751159668, 21.54182760620117, 21.541650970458985, 21.541484420776367, 21.54131066894531, 21.541150299072264]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Show reconstruction and ground truth\n", - "show2D([pdhg_tv_implicit_regtk.solution,\n", - " pdhg_tv_implicit_cil_warm_start.solution,\n", - " pdhg_tv_implicit_cil.solution,\n", - " (pdhg_tv_implicit_cil.solution-pdhg_tv_implicit_cil_warm_start.solution).abs()], \n", - " fix_range=[(0,0.055),(0,0.055),(0,0.055), None], num_cols=4,\n", - " title = ['TV (CIL)','TV (CIL - warm start)', 'TV (CCPI-RegTk)', 'CIL with/without warm start abs diff' ], \n", - " cmap = 'inferno')\n", - "\n", - "print(' Absolute error between Regtk solution and warm start solution: ', np.linalg.norm(pdhg_tv_implicit_regtk.solution.as_array()-pdhg_tv_implicit_cil_warm_start.solution.as_array()))\n", - "\n", - "\n", - "# Plot middle line profile\n", - "show1D([pdhg_tv_implicit_regtk.solution,pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil_warm_start.solution], slice_list=[('horizontal_y',int(ig2D.voxel_num_y/2))],\n", - " label = ['TV (CCPi-RegTk)','TV (CIL)', 'TV (CIL-warm start)'], title='Middle Line Profiles')\n", - "\n", - "print(pdhg_tv_implicit_regtk.objective)\n", - "print(pdhg_tv_implicit_cil.objective)\n", - "print(pdhg_tv_implicit_cil_warm_start.objective)\n", - "\n", - "plt.figure()\n", - "iter_range = np.arange(0,201,5)\n", - "plt.semilogy(iter_range, pdhg_tv_implicit_regtk.objective, label='implicit PDHG (Regtk)')\n", - "plt.semilogy(iter_range, pdhg_tv_implicit_cil.objective, label='implicit PDHG (CIL)')\n", - "plt.semilogy(iter_range, pdhg_tv_implicit_cil_warm_start.objective, label='implicit PDHG (CIL Warm start)')\n", - "plt.xlabel('Iterations')\n", - "plt.ylabel('Objective function')\n", - "plt.ylim(71,73)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "8fcc4831", - "metadata": {}, - "source": [ - "# Trying different number of inner iterations for warm start " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ad6242be-de86-4ae4-9e9a-a8c33dacce58", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 400 0.000 7.40475e+03\n", - " 5 400 0.022 1.40917e+02\n", - " 10 400 0.022 5.86010e+01\n", - " 15 400 0.022 4.84877e+01\n", - " 20 400 0.022 4.33890e+01\n", - " 25 400 0.022 3.83292e+01\n", - " 30 400 0.022 3.42867e+01\n", - " 35 400 0.022 3.32200e+01\n", - " 40 400 0.022 3.25358e+01\n", - " 45 400 0.022 3.19039e+01\n", - " 50 400 0.022 3.16158e+01\n", - " 55 400 0.022 3.15406e+01\n", - " 60 400 0.022 3.14002e+01\n", - " 65 400 0.022 3.12791e+01\n", - " 70 400 0.022 3.12358e+01\n", - " 75 400 0.022 3.12142e+01\n", - " 80 400 0.022 3.11905e+01\n", - " 85 400 0.022 3.11765e+01\n", - " 90 400 0.022 3.11676e+01\n", - " 95 400 0.022 3.11601e+01\n", - " 100 400 0.022 3.11562e+01\n", - " 105 400 0.022 3.11546e+01\n", - " 110 400 0.022 3.11528e+01\n", - " 115 400 0.022 3.11515e+01\n", - " 120 400 0.022 3.11509e+01\n", - " 125 400 0.022 3.11504e+01\n", - " 130 400 0.022 3.11498e+01\n", - " 135 400 0.022 3.11495e+01\n", - " 140 400 0.022 3.11490e+01\n", - " 145 400 0.022 3.11488e+01\n", - " 150 400 0.022 3.11488e+01\n", - " 155 400 0.022 3.11487e+01\n", - " 160 400 0.022 3.11488e+01\n", - " 165 400 0.022 3.11488e+01\n", - " 170 400 0.022 3.11488e+01\n", - " 175 400 0.022 3.11488e+01\n", - " 180 400 0.022 3.11489e+01\n", - " 185 400 0.022 3.11489e+01\n", - " 190 400 0.022 3.11489e+01\n", - " 195 400 0.022 3.11488e+01\n", - " 200 400 0.022 3.11488e+01\n", - " 205 400 0.022 3.11488e+01\n", - " 210 400 0.022 3.11488e+01\n", - " 215 400 0.022 3.11488e+01\n", - " 220 400 0.022 3.11488e+01\n", - " 225 400 0.022 3.11489e+01\n", - " 230 400 0.022 3.11489e+01\n", - " 235 400 0.022 3.11488e+01\n", - " 240 400 0.022 3.11489e+01\n", - " 245 400 0.022 3.11489e+01\n", - " 250 400 0.022 3.11489e+01\n", - " 255 400 0.022 3.11488e+01\n", - " 260 400 0.022 3.11488e+01\n", - " 265 400 0.022 3.11488e+01\n", - " 270 400 0.022 3.11488e+01\n", - " 275 400 0.022 3.11488e+01\n", - " 280 400 0.022 3.11488e+01\n", - " 285 400 0.022 3.11488e+01\n", - " 290 400 0.022 3.11488e+01\n", - " 295 400 0.022 3.11488e+01\n", - " 300 400 0.022 3.11488e+01\n", - " 305 400 0.022 3.11488e+01\n", - " 310 400 0.022 3.11488e+01\n", - " 315 400 0.022 3.11488e+01\n", - " 320 400 0.022 3.11488e+01\n", - " 325 400 0.022 3.11488e+01\n", - " 330 400 0.022 3.11488e+01\n", - " 335 400 0.022 3.11488e+01\n", - " 340 400 0.022 3.11488e+01\n", - " 345 400 0.022 3.11488e+01\n", - " 350 400 0.022 3.11488e+01\n", - " 355 400 0.022 3.11488e+01\n", - " 360 400 0.022 3.11488e+01\n", - " 365 400 0.022 3.11488e+01\n", - " 370 400 0.022 3.11488e+01\n", - " 375 400 0.022 3.11488e+01\n", - " 380 400 0.022 3.11488e+01\n", - " 385 400 0.022 3.11488e+01\n", - " 390 400 0.022 3.11488e+01\n", - " 395 400 0.022 3.11488e+01\n", - " 400 400 0.022 3.11488e+01\n", - "-------------------------------------------------------\n", - " 400 400 0.022 3.11488e+01\n", - "Stop criterion has been reached.\n", - "\n", - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 400 0.000 7.40475e+03\n", - " 5 400 1.048 1.40917e+02\n", - " 10 400 1.049 5.86013e+01\n", - " 15 400 1.045 4.84881e+01\n", - " 20 400 1.038 4.33897e+01\n", - " 25 400 1.034 3.83305e+01\n", - " 30 400 1.026 3.42885e+01\n", - " 35 400 1.023 3.32218e+01\n", - " 40 400 1.026 3.25375e+01\n", - " 45 400 1.029 3.19057e+01\n", - " 50 400 1.023 3.16179e+01\n", - " 55 400 1.020 3.15427e+01\n", - " 60 400 1.018 3.14024e+01\n", - " 65 400 1.018 3.12812e+01\n", - " 70 400 1.022 3.12379e+01\n", - " 75 400 1.024 3.12164e+01\n", - " 80 400 1.023 3.11926e+01\n", - " 85 400 1.024 3.11785e+01\n", - " 90 400 1.026 3.11696e+01\n", - " 95 400 1.028 3.11621e+01\n", - " 100 400 1.028 3.11582e+01\n", - " 105 400 1.079 3.11566e+01\n", - " 110 400 1.142 3.11548e+01\n", - " 115 400 1.197 3.11535e+01\n", - " 120 400 1.253 3.11529e+01\n", - " 125 400 1.298 3.11523e+01\n", - " 130 400 1.342 3.11518e+01\n", - " 135 400 1.375 3.11514e+01\n", - " 140 400 1.400 3.11511e+01\n", - " 145 400 1.386 3.11508e+01\n", - " 150 400 1.373 3.11508e+01\n", - " 155 400 1.360 3.11507e+01\n", - " 160 400 1.349 3.11507e+01\n", - " 165 400 1.340 3.11508e+01\n", - " 170 400 1.331 3.11508e+01\n", - " 175 400 1.320 3.11508e+01\n", - " 180 400 1.312 3.11508e+01\n", - " 185 400 1.303 3.11508e+01\n", - " 190 400 1.295 3.11508e+01\n", - " 195 400 1.288 3.11508e+01\n", - " 200 400 1.281 3.11508e+01\n", - " 205 400 1.275 3.11508e+01\n", - " 210 400 1.269 3.11508e+01\n", - " 215 400 1.265 3.11508e+01\n", - " 220 400 1.259 3.11508e+01\n", - " 225 400 1.254 3.11508e+01\n", - " 230 400 1.250 3.11508e+01\n", - " 235 400 1.254 3.11508e+01\n", - " 240 400 1.300 3.11508e+01\n", - " 245 400 1.322 3.11508e+01\n", - " 250 400 1.342 3.11508e+01\n", - " 255 400 1.363 3.11508e+01\n", - " 260 400 1.384 3.11508e+01\n", - " 265 400 1.403 3.11508e+01\n", - " 270 400 1.429 3.11508e+01\n", - " 275 400 1.451 3.11508e+01\n", - " 280 400 1.469 3.11508e+01\n", - " 285 400 1.487 3.11508e+01\n", - " 290 400 1.505 3.11508e+01\n", - " 295 400 1.526 3.11508e+01\n", - " 300 400 1.545 3.11508e+01\n", - " 305 400 1.557 3.11508e+01\n", - " 310 400 1.570 3.11508e+01\n", - " 315 400 1.589 3.11508e+01\n", - " 320 400 1.602 3.11508e+01\n", - " 325 400 1.615 3.11508e+01\n", - " 330 400 1.624 3.11508e+01\n", - " 335 400 1.633 3.11508e+01\n", - " 340 400 1.641 3.11508e+01\n", - " 345 400 1.650 3.11508e+01\n", - " 350 400 1.659 3.11508e+01\n", - " 355 400 1.664 3.11508e+01\n", - " 360 400 1.672 3.11508e+01\n", - " 365 400 1.685 3.11508e+01\n", - " 370 400 1.695 3.11508e+01\n", - " 375 400 1.704 3.11508e+01\n", - " 380 400 1.711 3.11508e+01\n", - " 385 400 1.720 3.11508e+01\n", - " 390 400 1.726 3.11508e+01\n", - " 395 400 1.738 3.11508e+01\n", - " 400 400 1.748 3.11508e+01\n", - "-------------------------------------------------------\n", - " 400 400 1.748 3.11508e+01\n", - "Stop criterion has been reached.\n", - "\n", - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 400 0.000 7.40475e+03\n", - " 5 400 0.039 7.40475e+03\n", - " 10 400 0.026 7.40475e+03\n", - " 15 400 0.031 7.40475e+03\n", - " 20 400 0.032 7.40475e+03\n", - " 25 400 0.030 7.40475e+03\n", - " 30 400 0.032 7.40475e+03\n", - " 35 400 0.030 7.40475e+03\n", - " 40 400 0.032 7.40475e+03\n", - " 45 400 0.030 7.40475e+03\n", - " 50 400 0.031 7.40475e+03\n", - " 55 400 0.030 7.40475e+03\n", - " 60 400 0.030 7.40475e+03\n", - " 65 400 0.029 7.40475e+03\n", - " 70 400 0.028 7.40475e+03\n", - " 75 400 0.027 7.40475e+03\n", - " 80 400 0.028 7.40475e+03\n", - " 85 400 0.028 7.40475e+03\n", - " 90 400 0.027 7.40475e+03\n", - " 95 400 0.030 7.40475e+03\n", - " 100 400 0.030 7.40475e+03\n", - " 105 400 0.029 7.40475e+03\n", - " 110 400 0.028 7.40475e+03\n", - " 115 400 0.028 7.40475e+03\n", - " 120 400 0.027 7.40475e+03\n", - " 125 400 0.027 7.40475e+03\n", - " 130 400 0.027 7.40475e+03\n", - " 135 400 0.026 7.40475e+03\n", - " 140 400 0.027 7.40475e+03\n", - " 145 400 0.026 7.40475e+03\n", - " 150 400 0.026 7.40475e+03\n", - " 155 400 0.025 7.40475e+03\n", - " 160 400 0.026 7.40475e+03\n", - " 165 400 0.026 7.40475e+03\n", - " 170 400 0.026 7.40475e+03\n", - " 175 400 0.026 7.40475e+03\n", - " 180 400 0.026 7.40475e+03\n", - " 185 400 0.027 7.40475e+03\n", - " 190 400 0.027 7.40475e+03\n", - " 195 400 0.026 7.40475e+03\n", - " 200 400 0.026 7.40475e+03\n", - " 205 400 0.026 7.40475e+03\n", - " 210 400 0.026 7.40475e+03\n", - " 215 400 0.026 7.40475e+03\n", - " 220 400 0.026 7.40475e+03\n", - " 225 400 0.026 7.40475e+03\n", - " 230 400 0.026 7.40475e+03\n", - " 235 400 0.026 7.40475e+03\n", - " 240 400 0.026 7.40475e+03\n", - " 245 400 0.026 7.40475e+03\n", - " 250 400 0.026 7.40475e+03\n", - " 255 400 0.026 7.40475e+03\n", - " 260 400 0.027 7.40475e+03\n", - " 265 400 0.027 7.40475e+03\n", - " 270 400 0.027 7.40475e+03\n", - " 275 400 0.027 7.40475e+03\n", - " 280 400 0.027 7.40475e+03\n", - " 285 400 0.027 7.40475e+03\n", - " 290 400 0.027 7.40475e+03\n", - " 295 400 0.027 7.40475e+03\n", - " 300 400 0.027 7.40475e+03\n", - " 305 400 0.027 7.40475e+03\n", - " 310 400 0.027 7.40475e+03\n", - " 315 400 0.027 7.40475e+03\n", - " 320 400 0.027 7.40475e+03\n", - " 325 400 0.027 7.40475e+03\n", - " 330 400 0.027 7.40475e+03\n", - " 335 400 0.027 7.40475e+03\n", - " 340 400 0.027 7.40475e+03\n", - " 345 400 0.027 7.40475e+03\n", - " 350 400 0.027 7.40475e+03\n", - " 355 400 0.027 7.40475e+03\n", - " 360 400 0.027 7.40475e+03\n", - " 365 400 0.027 7.40475e+03\n", - " 370 400 0.027 7.40475e+03\n", - " 375 400 0.027 7.40475e+03\n", - " 380 400 0.027 7.40475e+03\n", - " 385 400 0.027 7.40475e+03\n", - " 390 400 0.027 7.40475e+03\n", - " 395 400 0.027 7.40475e+03\n", - " 400 400 0.027 7.40475e+03\n", - "-------------------------------------------------------\n", - " 400 400 0.027 7.40475e+03\n", - "Stop criterion has been reached.\n", - "\n", - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 400 0.000 7.40475e+03\n", - " 5 400 0.158 1.34114e+02\n", - " 10 400 0.170 5.71919e+01\n", - " 15 400 0.168 4.74188e+01\n", - " 20 400 0.173 4.32707e+01\n", - " 25 400 0.167 3.84927e+01\n", - " 30 400 0.165 3.43658e+01\n", - " 35 400 0.167 3.32847e+01\n", - " 40 400 0.170 3.26578e+01\n", - " 45 400 0.167 3.21251e+01\n", - " 50 400 0.167 3.18015e+01\n", - " 55 400 0.166 3.16845e+01\n", - " 60 400 0.163 3.15549e+01\n", - " 65 400 0.162 3.14120e+01\n", - " 70 400 0.163 3.13045e+01\n", - " 75 400 0.163 3.12693e+01\n", - " 80 400 0.163 3.12513e+01\n", - " 85 400 0.164 3.12159e+01\n", - " 90 400 0.163 3.11925e+01\n", - " 95 400 0.161 3.11819e+01\n", - " 100 400 0.162 3.11726e+01\n", - " 105 400 0.160 3.11654e+01\n", - " 110 400 0.158 3.11605e+01\n", - " 115 400 0.159 3.11562e+01\n", - " 120 400 0.160 3.11528e+01\n", - " 125 400 0.161 3.11501e+01\n", - " 130 400 0.161 3.11482e+01\n", - " 135 400 0.160 3.11467e+01\n", - " 140 400 0.159 3.11456e+01\n", - " 145 400 0.159 3.11449e+01\n", - " 150 400 0.159 3.11442e+01\n", - " 155 400 0.160 3.11435e+01\n", - " 160 400 0.160 3.11429e+01\n", - " 165 400 0.160 3.11424e+01\n", - " 170 400 0.161 3.11420e+01\n", - " 175 400 0.161 3.11418e+01\n", - " 180 400 0.162 3.11416e+01\n", - " 185 400 0.162 3.11414e+01\n", - " 190 400 0.161 3.11412e+01\n", - " 195 400 0.162 3.11410e+01\n", - " 200 400 0.162 3.11408e+01\n", - " 205 400 0.162 3.11407e+01\n", - " 210 400 0.163 3.11405e+01\n", - " 215 400 0.163 3.11404e+01\n", - " 220 400 0.163 3.11403e+01\n", - " 225 400 0.163 3.11402e+01\n", - " 230 400 0.163 3.11401e+01\n", - " 235 400 0.162 3.11401e+01\n", - " 240 400 0.162 3.11400e+01\n", - " 245 400 0.163 3.11399e+01\n", - " 250 400 0.163 3.11398e+01\n", - " 255 400 0.163 3.11398e+01\n", - " 260 400 0.163 3.11397e+01\n", - " 265 400 0.163 3.11396e+01\n", - " 270 400 0.162 3.11396e+01\n", - " 275 400 0.162 3.11395e+01\n", - " 280 400 0.162 3.11395e+01\n", - " 285 400 0.162 3.11394e+01\n", - " 290 400 0.162 3.11394e+01\n", - " 295 400 0.162 3.11393e+01\n", - " 300 400 0.163 3.11393e+01\n", - " 305 400 0.163 3.11393e+01\n", - " 310 400 0.163 3.11392e+01\n", - " 315 400 0.163 3.11392e+01\n", - " 320 400 0.163 3.11392e+01\n", - " 325 400 0.163 3.11391e+01\n", - " 330 400 0.163 3.11391e+01\n", - " 335 400 0.163 3.11391e+01\n", - " 340 400 0.164 3.11391e+01\n", - " 345 400 0.164 3.11390e+01\n", - " 350 400 0.163 3.11390e+01\n", - " 355 400 0.163 3.11390e+01\n", - " 360 400 0.163 3.11389e+01\n", - " 365 400 0.162 3.11389e+01\n", - " 370 400 0.162 3.11389e+01\n", - " 375 400 0.163 3.11389e+01\n", - " 380 400 0.163 3.11388e+01\n", - " 385 400 0.163 3.11388e+01\n", - " 390 400 0.163 3.11388e+01\n", - " 395 400 0.163 3.11388e+01\n", - " 400 400 0.163 3.11388e+01\n", - "-------------------------------------------------------\n", - " 400 400 0.163 3.11388e+01\n", - "Stop criterion has been reached.\n", - "\n", - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 400 0.000 7.40475e+03\n", - " 5 400 0.198 1.37527e+02\n", - " 10 400 0.216 5.76839e+01\n", - " 15 400 0.244 4.79763e+01\n", - " 20 400 0.263 4.32445e+01\n", - " 25 400 0.272 3.81302e+01\n", - " 30 400 0.271 3.41259e+01\n", - " 35 400 0.272 3.31618e+01\n", - " 40 400 0.272 3.25205e+01\n", - " 45 400 0.276 3.19219e+01\n", - " 50 400 0.319 3.16410e+01\n", - " 55 400 0.314 3.15660e+01\n", - " 60 400 0.311 3.14292e+01\n", - " 65 400 0.311 3.13021e+01\n", - " 70 400 0.315 3.12460e+01\n", - " 75 400 0.316 3.12253e+01\n", - " 80 400 0.319 3.12012e+01\n", - " 85 400 0.317 3.11803e+01\n", - " 90 400 0.317 3.11672e+01\n", - " 95 400 0.320 3.11590e+01\n", - " 100 400 0.321 3.11536e+01\n", - " 105 400 0.319 3.11504e+01\n", - " 110 400 0.315 3.11479e+01\n", - " 115 400 0.316 3.11455e+01\n", - " 120 400 0.315 3.11440e+01\n", - " 125 400 0.315 3.11429e+01\n", - " 130 400 0.314 3.11418e+01\n", - " 135 400 0.313 3.11410e+01\n", - " 140 400 0.312 3.11404e+01\n", - " 145 400 0.311 3.11400e+01\n", - " 150 400 0.311 3.11397e+01\n", - " 155 400 0.311 3.11395e+01\n", - " 160 400 0.310 3.11393e+01\n", - " 165 400 0.310 3.11392e+01\n", - " 170 400 0.310 3.11391e+01\n", - " 175 400 0.309 3.11390e+01\n", - " 180 400 0.307 3.11389e+01\n", - " 185 400 0.307 3.11389e+01\n", - " 190 400 0.307 3.11388e+01\n", - " 195 400 0.306 3.11387e+01\n", - " 200 400 0.305 3.11386e+01\n", - " 205 400 0.303 3.11386e+01\n", - " 210 400 0.300 3.11385e+01\n", - " 215 400 0.297 3.11385e+01\n", - " 220 400 0.296 3.11385e+01\n", - " 225 400 0.296 3.11385e+01\n", - " 230 400 0.296 3.11385e+01\n", - " 235 400 0.296 3.11385e+01\n", - " 240 400 0.295 3.11384e+01\n", - " 245 400 0.294 3.11384e+01\n", - " 250 400 0.294 3.11384e+01\n", - " 255 400 0.295 3.11384e+01\n", - " 260 400 0.294 3.11384e+01\n", - " 265 400 0.294 3.11384e+01\n", - " 270 400 0.295 3.11384e+01\n", - " 275 400 0.295 3.11384e+01\n", - " 280 400 0.295 3.11383e+01\n", - " 285 400 0.295 3.11383e+01\n", - " 290 400 0.294 3.11383e+01\n", - " 295 400 0.295 3.11383e+01\n", - " 300 400 0.295 3.11383e+01\n", - " 305 400 0.296 3.11383e+01\n", - " 310 400 0.294 3.11383e+01\n", - " 315 400 0.294 3.11383e+01\n", - " 320 400 0.293 3.11383e+01\n", - " 325 400 0.293 3.11383e+01\n", - " 330 400 0.299 3.11383e+01\n", - " 335 400 0.299 3.11383e+01\n", - " 340 400 0.298 3.11383e+01\n", - " 345 400 0.297 3.11383e+01\n", - " 350 400 0.296 3.11383e+01\n", - " 355 400 0.296 3.11383e+01\n", - " 360 400 0.294 3.11383e+01\n", - " 365 400 0.294 3.11383e+01\n", - " 370 400 0.294 3.11383e+01\n", - " 375 400 0.295 3.11383e+01\n", - " 380 400 0.296 3.11383e+01\n", - " 385 400 0.296 3.11383e+01\n", - " 390 400 0.297 3.11383e+01\n", - " 395 400 0.297 3.11383e+01\n", - " 400 400 0.297 3.11383e+01\n", - "-------------------------------------------------------\n", - " 400 400 0.297 3.11383e+01\n", - "Stop criterion has been reached.\n", - "\n", - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 400 0.000 7.40475e+03\n", - " 5 400 0.585 1.39044e+02\n", - " 10 400 0.517 5.79808e+01\n", - " 15 400 0.488 4.82156e+01\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/conda/envs/cil/lib/python3.10/site-packages/cil/framework/framework.py:3009: RuntimeWarning: invalid value encountered in divide\n", - " pwop(self.as_array(), x2.as_array(), *args, **kwargs )\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 20 400 0.473 4.32572e+01\n", - " 25 400 0.498 3.81482e+01\n", - " 30 400 0.478 3.41160e+01\n", - " 35 400 0.473 3.31553e+01\n", - " 40 400 0.469 3.24838e+01\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " 45 400 0.488 3.18673e+01\n" - ] - } - ], - "source": [ - "F = 0.5 * L2NormSquared(b=absorption_data)\n", - "G = (alpha_tv/ig2D.voxel_size_y) * FGP_TV(max_iteration=100, nonnegativity = True, device = 'gpu') \n", - "K = A\n", - "\n", - "# Setup and run PDHG\n", - "pdhg_tv_implicit_regtk = PDHG(f = F, g = G, operator = K,\n", - " max_iteration = 400,\n", - " update_objective_interval = 5)\n", - "pdhg_tv_implicit_regtk.run(verbose=1)\n", - "\n", - "\n", - "F = 0.5 * L2NormSquared(b=absorption_data)\n", - "G = alpha_tv * TotalVariation(max_iteration=100, lower=0.)\n", - "K = A\n", - "# Setup and run PDHG\n", - "pdhg_tv_implicit_cil = PDHG(f = F, g = G, operator = K,\n", - " max_iteration = 400,\n", - " update_objective_interval = 5)\n", - "pdhg_tv_implicit_cil.run(verbose=1)\n", - "\n", - "\n", - "\n", - "F = 0.5 * L2NormSquared(b=absorption_data)\n", - "\n", - "K = A\n", - "plt.figure(figsize=(12,12))\n", - "iter_range = np.arange(0,401,5)\n", - "plt.semilogy(iter_range, pdhg_tv_implicit_regtk.objective, label='implicit PDHG (Regtk)')\n", - "plt.semilogy(iter_range, pdhg_tv_implicit_cil.objective, label='implicit PDHG (CIL)')\n", - "for i in range(0,30,5):\n", - " G = alpha_tv * TotalVariation(max_iteration=i, lower=0., warmstart=True)\n", - " # Setup and run PDHG\n", - " pdhg_tv_implicit_cil_warm_start = PDHG(f = F, g = G, operator = K,\n", - " max_iteration = 400,\n", - " update_objective_interval = 5)\n", - " pdhg_tv_implicit_cil_warm_start.run(verbose=1)\n", - "\n", - "\n", - "\n", - " plt.semilogy(iter_range, pdhg_tv_implicit_cil_warm_start.objective, label='implicit PDHG (CIL Warm start '+str(i)+' iterations')\n", - "plt.xlabel('Iterations')\n", - "plt.ylabel('Objective function')\n", - "plt.ylim(70,76)\n", - "plt.legend()\n", - "plt.show()\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "075363a3", - "metadata": {}, - "source": [ - "## Absolute error in the prximal calcultion printed for each iteration " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e1a48605", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "(392, 392)\n", - "\n", - "(392, 392)\n", - "nan\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_2230921/4163379483.py:16: RuntimeWarning: invalid value encountered in float_scalars\n", - " hold[i]=np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array()-G_new.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())/np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.006371722556651\n", - "0.010306853801012\n", - "0.011967001482844\n", - "0.012141870334744\n", - "0.011154086329043\n", - "0.009454647079110\n", - "0.007848035544157\n", - "0.006351156625897\n", - "0.005269628018141\n", - "0.004583632107824\n", - "0.004208668135107\n", - "0.004053416661918\n", - "0.004076413344592\n", - "0.004518712405115\n", - "0.005058542825282\n", - "0.005769900977612\n", - "0.006268993485719\n", - "0.006738359574229\n", - "0.007248400710523\n", - "0.007657966110855\n", - "0.008042982779443\n", - "0.008422131650150\n", - "0.008730802685022\n", - "0.008927714079618\n", - "0.009071441367269\n", - "0.009164910763502\n", - "0.009100656956434\n", - "0.008927645161748\n", - "0.008697603829205\n", - "0.008455654606223\n", - "0.008085822686553\n", - "0.007645812816918\n", - "0.007195058278739\n", - "0.006962204352021\n", - "0.006865515839309\n", - "0.006813514046371\n", - "0.006723018828779\n", - "0.006607326678932\n", - "0.006437776144594\n", - "0.006262657698244\n", - "0.006103666033596\n", - "0.005938214249909\n", - "0.005754547659308\n", - "0.005590087734163\n", - "0.005453179590404\n", - "0.005287341307849\n", - "0.005129667930305\n", - "0.004963845480233\n", - "0.004822354763746\n", - "0.004711990244687\n", - "0.004615240730345\n", - "0.004531082231551\n", - "0.004449829459190\n", - "0.004367171786726\n", - "0.004280186723918\n", - "0.004190182313323\n", - "0.004111433867365\n", - "0.004028520081192\n", - "0.003944415133446\n", - "0.003865592181683\n", - "0.003787916619331\n", - "0.003729531774297\n", - "0.003681831527501\n", - "0.003627916099504\n", - "0.003575087524951\n", - "0.003522050799802\n", - "0.003468457842246\n", - "0.003419648855925\n", - "0.003379710251465\n", - "0.003341342555359\n", - "0.003291838802397\n", - "0.003240507794544\n", - "0.003189664799720\n", - "0.003140016458929\n", - "0.003090175101534\n", - "0.003045259509236\n", - "0.002999982330948\n", - "0.002958232071251\n", - "0.002921228064224\n", - "0.002884241752326\n", - "0.002845332724974\n", - "0.002801205962896\n", - "0.002756677800789\n", - "0.002718434203416\n", - "0.002684947568923\n", - "0.002651873743162\n", - "0.002621478168294\n", - "0.002595953876153\n", - "0.002570055425167\n", - "0.002539832377806\n", - "0.002511372324079\n", - "0.002486265497282\n", - "0.002461483469233\n", - "0.002436500974000\n", - "0.002412515692413\n", - "0.002390427049249\n", - "0.002369001507759\n", - "0.002347769215703\n", - "0.002326625166461\n", - "0.002304472262040\n", - "0.002281620865688\n", - "0.002259281463921\n", - "0.002238921588287\n", - "0.002219301648438\n", - "0.002200684975833\n", - "0.002183432690799\n", - "0.002167701022699\n", - "0.002152861328796\n", - "0.002138607203960\n", - "0.002123695099726\n", - "0.002109096851200\n", - "0.002094943076372\n", - "0.002080333651975\n", - "0.002065069973469\n", - "0.002049198374152\n", - "0.002032696036622\n", - "0.002015789737925\n", - "0.001998258754611\n", - "0.001980683300644\n", - "0.001963176531717\n", - "0.001946136006154\n", - "0.001929642283358\n", - "0.001913880463690\n", - "0.001898526912555\n", - "0.001883862190880\n", - "0.001869745552540\n", - "0.001856211572886\n", - "0.001843081205152\n", - "0.001830322202295\n", - "0.001817882992327\n", - "0.001805691281334\n", - "0.001793193747289\n", - "0.001780566526577\n", - "0.001768077723682\n", - "0.001755848294124\n", - "0.001743973116390\n", - "0.001732411212288\n", - "0.001721293549053\n", - "0.001710487296805\n", - "0.001699973014183\n", - "0.001689786906354\n", - "0.001679925946519\n", - "0.001670290948823\n", - "0.001660904148594\n", - "0.001651572063565\n", - "0.001642178511247\n", - "0.001632844097912\n", - "0.001623650314286\n", - "0.001614544889890\n", - "0.001605485798791\n", - "0.001596532529220\n", - "0.001587631180882\n", - "0.001578868366778\n", - "0.001570236869156\n", - "0.001561680808663\n", - "0.001553183537908\n", - "0.001544767990708\n", - "0.001536484458484\n", - "0.001528322696686\n", - "0.001520278747194\n", - "0.001512361224741\n", - "0.001504459534772\n", - "0.001496652024798\n", - "0.001488922862336\n", - "0.001481184852310\n", - "0.001473484444432\n", - "0.001465838053264\n", - "0.001458213664591\n", - "0.001450603012927\n", - "0.001442989800125\n", - "0.001435481943190\n", - "0.001427980023436\n", - "0.001420574844815\n", - "0.001413238118403\n", - "0.001406002789736\n", - "0.001398813794367\n", - "0.001391742145643\n", - "0.001384789939038\n", - "0.001377913635224\n", - "0.001371114049107\n", - "0.001364422962070\n", - "0.001357862609439\n", - "0.001351454760879\n", - "0.001345084747300\n", - "0.001338805421256\n", - "0.001332612475380\n", - "0.001326486468315\n", - "0.001320409704931\n", - "0.001314416062087\n", - "0.001308492734097\n", - "0.001302612363361\n", - "0.001296764123254\n", - "0.001290984335355\n", - "0.001285253791139\n", - "0.001279564108700\n", - "0.001273894915357\n", - "0.001268274150789\n", - "0.001262696110643\n", - "0.001257166150026\n", - "0.001251675770618\n", - "0.001246249419637\n", - "0.001240881159902\n", - "0.001235549454577\n", - "0.001230256631970\n", - "0.001224990119226\n", - "0.001219772500917\n", - "0.001214594696648\n", - "0.001209465786815\n", - "0.001204362371936\n", - "0.001199314719997\n", - "0.001194320735522\n", - "0.001189378788695\n", - "0.001184492721222\n", - "0.001179629238322\n", - "0.001174788107164\n", - "0.001169974450022\n", - "0.001165205379948\n", - "0.001160484156571\n", - "0.001155801466666\n", - "0.001151167904027\n", - "0.001146556925960\n", - "0.001142004621215\n", - "0.001137467217632\n", - "0.001132981386036\n", - "0.001128549338318\n", - "0.001124132541008\n", - "0.001119751017541\n", - "0.001115420600399\n", - "0.001111120218411\n", - "0.001106849173084\n", - "0.001102616079152\n", - "0.001098414417356\n", - "0.001094251289032\n", - "0.001090120989829\n", - "0.001086006290279\n", - "0.001081903697923\n", - "0.001077850931324\n", - "0.001073827850632\n", - "0.001069817924872\n", - "0.001065853284672\n", - "0.001061891089194\n", - "0.001057964051142\n", - "0.001054060412571\n", - "0.001050178776495\n", - "0.001046310295351\n", - "0.001042483607307\n", - "0.001038678921759\n", - "0.001034882268868\n", - "0.001031119842082\n", - "0.001027386519127\n", - "0.001023694523610\n", - "0.001020026858896\n", - "0.001016389578581\n", - "0.001012775348499\n", - "0.001009169849567\n", - "0.001005576457828\n", - "0.001001982600428\n", - "0.000998420524411\n", - "0.000994891161099\n", - "0.000991387758404\n", - "0.000987918814644\n", - "0.000984476297162\n", - "0.000981044257060\n", - "0.000977636547759\n", - "0.000974258175120\n", - "0.000970905879512\n", - "0.000967583036982\n", - "0.000964287435636\n", - "0.000961006560829\n", - "0.000957754557021\n", - "0.000954517628998\n", - "0.000951301190071\n", - "0.000948122586124\n", - "0.000944965810049\n", - "0.000941831734963\n", - "0.000938714307267\n", - "0.000935622141697\n", - "0.000932552735321\n", - "0.000929504516535\n", - "0.000926468928810\n", - "0.000923458603211\n", - "0.000920468708500\n", - "0.000917496916372\n", - "0.000914550095331\n", - "0.000911623588763\n", - "0.000908719899599\n", - "0.000905834371224\n", - "0.000902950705495\n", - "0.000900099286810\n", - "0.000897278136108\n", - "0.000894481781870\n", - "0.000891690258868\n", - "0.000888922193553\n", - "0.000886179041117\n", - "0.000883457483724\n", - "0.000880745355971\n", - "0.000878041959368\n", - "0.000875354162417\n", - "0.000872686388902\n", - "0.000870033574756\n", - "0.000867401715368\n", - "0.000864782661665\n", - "0.000862191373017\n", - "0.000859601539560\n", - "0.000857038015965\n", - "0.000854491197970\n", - "0.000851959863212\n", - "0.000849433068652\n", - "0.000846930139232\n", - "0.000844437745400\n", - "0.000841968285386\n", - "0.000839512213133\n", - "0.000837074476294\n", - "0.000834643316921\n", - "0.000832231191453\n", - "0.000829827971756\n", - "0.000827442388982\n", - "0.000825069670100\n", - "0.000822709582280\n", - "0.000820356712211\n", - "0.000818021944724\n", - "0.000815703533590\n", - "0.000813398393802\n", - "0.000811101519503\n", - "0.000808817858342\n", - "0.000806545023806\n", - "0.000804288079962\n", - "0.000802034104709\n", - "0.000799804576673\n", - "0.000797585526016\n", - "0.000795378407929\n", - "0.000793189101387\n", - "0.000791017839219\n", - "0.000788856297731\n", - "0.000786708085798\n", - "0.000784576230217\n", - "0.000782450137194\n", - "0.000780335627496\n", - "0.000778238580097\n", - "0.000776147586294\n", - "0.000774065614678\n", - "0.000771994004026\n", - "0.000769937178120\n", - "0.000767884892412\n", - "0.000765858625527\n", - "0.000763825140893\n", - "0.000761816743761\n", - "0.000759811373428\n", - "0.000757820380386\n", - "0.000755834160373\n", - "0.000753872212954\n", - "0.000751904095523\n", - "0.000749958271626\n", - "0.000748017046135\n", - "0.000746090314351\n", - "0.000744173652492\n", - "0.000742277305108\n", - "0.000740382994991\n", - "0.000738503702451\n", - "0.000736633723136\n", - "0.000734774279408\n", - "0.000732923799660\n", - "0.000731086125597\n", - "0.000729260442313\n", - "0.000727443024516\n", - "0.000725634221453\n", - "0.000723841541912\n", - "0.000722052820493\n", - "0.000720276031643\n", - "0.000718506111298\n", - "0.000716749927960\n", - "0.000715000031050\n", - "0.000713259854820\n", - "0.000711530563422\n", - "0.000709812506102\n", - "0.000708104402293\n", - "0.000706399325281\n", - "0.000704704434611\n", - "0.000703022175003\n", - "0.000701345386915\n", - "0.000699679600075\n", - "0.000698019866832\n", - "0.000696368282661\n", - "0.000694727234077\n", - "0.000693094450980\n", - "0.000691471970640\n", - "0.000689860433340\n", - "0.000688259140588\n", - "0.000686667626724\n", - "0.000685082515702\n", - "0.000683504098561\n", - "0.000681929115672\n", - "0.000680363038555\n", - "0.000678797718138\n", - "0.000677247124258\n", - "0.000675700081047\n", - "0.000674161419738\n", - "0.000672627647873\n", - "0.000671106623486\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Next example \n", - "\n", - "(392, 392)\n", - "\n", - "(392, 392)\n", - "nan\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_2230921/4163379483.py:42: RuntimeWarning: invalid value encountered in float_scalars\n", - " hold[i]=np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array()-G_new.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())/np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.010666279122233\n", - "0.012341897934675\n", - "0.013167494907975\n", - "0.022420270368457\n", - "0.051656480878592\n", - "0.065988808870316\n", - "0.063225410878658\n", - "0.054585851728916\n", - "0.055126264691353\n", - "0.065847173333168\n", - "0.077282711863518\n", - "0.084939338266850\n", - "0.088499136269093\n", - "0.088845379650593\n", - "0.086914032697678\n", - "0.083601608872414\n", - "0.079300910234451\n", - "0.074013695120811\n", - "0.067921996116638\n", - "0.061353892087936\n", - "0.054695062339306\n", - "0.048259392380714\n", - "0.042184684425592\n", - "0.036270227283239\n", - "0.030534062534571\n", - "0.025448128581047\n", - "0.021619791164994\n", - "0.019673608243465\n", - "0.019028626382351\n", - "0.018612653017044\n", - "0.018131325021386\n", - "0.017687764018774\n", - "0.017378788441420\n", - "0.017116377130151\n", - "0.016541784629226\n", - "0.015858927741647\n", - "0.015140733681619\n", - "0.014418200589716\n", - "0.013796940445900\n", - "0.013375506736338\n", - "0.013117653317750\n", - "0.013039323501289\n", - "0.013048136606812\n", - "0.013130043633282\n", - "0.013322014361620\n", - "0.013535777106881\n", - "0.013687812723219\n", - "0.013718011789024\n", - "0.013623702339828\n", - "0.013454315252602\n", - "0.013251784257591\n", - "0.012980328872800\n", - "0.012672081589699\n", - "0.012351606972516\n", - "0.012078131549060\n", - "0.011839757673442\n", - "0.011604508385062\n", - "0.011412507854402\n", - "0.011257199570537\n", - "0.011124306358397\n", - "0.011011039838195\n", - "0.010934142395854\n", - "0.010878168977797\n", - "0.010818930342793\n", - "0.010764501057565\n", - "0.010732701048255\n", - "0.010731222108006\n", - "0.010735003277659\n", - "0.010724780149758\n", - "0.010712379589677\n", - "0.010696098208427\n", - "0.010682819411159\n", - "0.010665907524526\n", - "0.010632378980517\n", - "0.010594899766147\n", - "0.010558801703155\n", - "0.010529636405408\n", - "0.010503428056836\n", - "0.010476151481271\n", - "0.010453817434609\n", - "0.010438672266901\n", - "0.010430610738695\n", - "0.010429061949253\n", - "0.010429413057864\n", - "0.010428595356643\n", - "0.010428616777062\n", - "0.010429186746478\n", - "0.010427183471620\n", - "0.010421963408589\n", - "0.010412666946650\n", - "0.010400208644569\n", - "0.010386154986918\n", - "0.010371326468885\n", - "0.010353940539062\n", - "0.010332951322198\n", - "0.010310061275959\n", - "0.010284406132996\n", - "0.010255757719278\n", - "0.010224601253867\n", - "0.010193388909101\n", - "0.010162219405174\n", - "0.010131878778338\n", - "0.010102503933012\n", - "0.010073724202812\n", - "0.010046374052763\n", - "0.010020984336734\n", - "0.009997815825045\n", - "0.009976861067116\n", - "0.009958204813302\n", - "0.009941534139216\n", - "0.009926253929734\n", - "0.009913053363562\n", - "0.009901844896376\n", - "0.009892486035824\n", - "0.009884816594422\n", - "0.009878975339234\n", - "0.009875190444291\n", - "0.009873313829303\n", - "0.009872964583337\n", - "0.009874150156975\n", - "0.009877102449536\n", - "0.009880958124995\n", - "0.009885438717902\n", - "0.009890200570226\n", - "0.009895099326968\n", - "0.009899550117552\n", - "0.009903122670949\n", - "0.009905422106385\n", - "0.009906507097185\n", - "0.009905828163028\n", - "0.009903552010655\n", - "0.009899729862809\n", - "0.009894552640617\n", - "0.009888036176562\n", - "0.009880641475320\n", - "0.009872547350824\n", - "0.009864172898233\n", - "0.009855929762125\n", - "0.009847987443209\n", - "0.009840508922935\n", - "0.009833727031946\n", - "0.009827855043113\n", - "0.009822995401919\n", - "0.009819078259170\n", - "0.009816230274737\n", - "0.009814205579460\n", - "0.009813223034143\n", - "0.009813053533435\n", - "0.009813733398914\n", - "0.009815027005970\n", - "0.009816920384765\n", - "0.009819168597460\n", - "0.009821657091379\n", - "0.009824271313846\n", - "0.009826950728893\n", - "0.009829446673393\n", - "0.009831786155701\n", - "0.009833759628236\n", - "0.009835478849709\n", - "0.009836770594120\n", - "0.009837661869824\n", - "0.009838215075433\n", - "0.009838341735303\n", - "0.009838026948273\n", - "0.009837288409472\n", - "0.009836152195930\n", - "0.009834644384682\n", - "0.009832793846726\n", - "0.009830641560256\n", - "0.009828082285821\n", - "0.009825265035033\n", - "0.009822216816247\n", - "0.009819095954299\n", - "0.009815871715546\n", - "0.009812632575631\n", - "0.009809465147555\n", - "0.009806447662413\n", - "0.009803606197238\n", - "0.009800947271287\n", - "0.009798473678529\n", - "0.009796245023608\n", - "0.009794231504202\n", - "0.009792468510568\n", - "0.009790996089578\n", - "0.009789744392037\n", - "0.009788807481527\n", - "0.009788138791919\n", - "0.009787703864276\n", - "0.009787437506020\n", - "0.009787371382117\n", - "0.009787489660084\n", - "0.009787715971470\n", - "0.009788079187274\n", - "0.009788527153432\n", - "0.009789095260203\n", - "0.009789692237973\n", - "0.009790321812034\n", - "0.009790954180062\n", - "0.009791547432542\n", - "0.009792063385248\n", - "0.009792516939342\n", - "0.009792844764888\n", - "0.009793089702725\n", - "0.009793278761208\n", - "0.009793355129659\n", - "0.009793343953788\n", - "0.009793275035918\n", - "0.009793151170015\n", - "0.009792984463274\n", - "0.009792802855372\n", - "0.009792640805244\n", - "0.009792448021472\n", - "0.009792267344892\n", - "0.009792078286409\n", - "0.009791919961572\n", - "0.009791715070605\n", - "0.009791476652026\n", - "0.009791222400963\n", - "0.009790950454772\n", - "0.009790662676096\n", - "0.009790372103453\n", - "0.009790070354939\n", - "0.009789796546102\n", - "0.009789548814297\n", - "0.009789324365556\n", - "0.009789123199880\n", - "0.009788993746042\n", - "0.009788846597075\n", - "0.009788753464818\n", - "0.009788674302399\n", - "0.009788620285690\n", - "0.009788576513529\n", - "0.009788517840207\n", - "0.009788511320949\n", - "0.009788544848561\n", - "0.009788569994271\n", - "0.009788615629077\n", - "0.009788659401238\n", - "0.009788707830012\n", - "0.009788777679205\n", - "0.009788831695914\n", - "0.009788826107979\n", - "0.009788800962269\n", - "0.009788795374334\n", - "0.009788767434657\n", - "0.009788719005883\n", - "0.009788657538593\n", - "0.009788538329303\n", - "0.009788442403078\n", - "0.009788324125111\n", - "0.009788230061531\n", - "0.009788111783564\n", - "0.009787989780307\n", - "0.009787809103727\n", - "0.009787616319954\n", - "0.009787389077246\n", - "0.009787113405764\n", - "0.009786823764443\n", - "0.009786549024284\n", - "0.009786265902221\n", - "0.009785999543965\n", - "0.009785732254386\n", - "0.009785497561097\n", - "0.009785261936486\n", - "0.009785057976842\n", - "0.009784865193069\n", - "0.009784702211618\n", - "0.009784548543394\n", - "0.009784424677491\n", - "0.009784298948944\n", - "0.009784160181880\n", - "0.009784065186977\n", - "0.009783961810172\n", - "0.009783851914108\n", - "0.009783707559109\n", - "0.009783532470465\n", - "0.009783306159079\n", - "0.009783072397113\n", - "0.009782824665308\n", - "0.009782602079213\n", - "0.009782408364117\n", - "0.009782265871763\n", - "0.009782174602151\n", - "0.009782161563635\n", - "0.009782182052732\n", - "0.009782222099602\n", - "0.009782308712602\n", - "0.009782410226762\n", - "0.009782508946955\n", - "0.009782669134438\n", - "0.009782817214727\n", - "0.009782961569726\n", - "0.009783086366951\n", - "0.009783205576241\n", - "0.009783308953047\n", - "0.009783379733562\n", - "0.009783451445401\n", - "0.009783545508981\n", - "0.009783630259335\n", - "0.009783729910851\n", - "0.009783806279302\n", - "0.009783841669559\n", - "0.009783864952624\n", - "0.009783853776753\n", - "0.009783856570721\n", - "0.009783827699721\n", - "0.009783789515495\n", - "0.009783745743334\n", - "0.009783667512238\n", - "0.009783567860723\n", - "0.009783448651433\n", - "0.009783302433789\n", - "0.009783169254661\n", - "0.009783059358597\n", - "0.009782976470888\n", - "0.009782915934920\n", - "0.009782878682017\n", - "0.009782860055566\n", - "0.009782857261598\n", - "0.009782897308469\n", - "0.009782961569726\n", - "0.009783019311726\n", - "0.009783064946532\n", - "0.009783088229597\n", - "0.009783121757209\n", - "0.009783097542822\n", - "0.009783042594790\n", - "0.009782975539565\n", - "0.009782871231437\n", - "0.009782792069018\n", - "0.009782720357180\n", - "0.009782688692212\n", - "0.009782661683857\n", - "0.009782651439309\n", - "0.009782659821212\n", - "0.009782680310309\n", - "0.009782725945115\n", - "0.009782777167857\n", - "0.009782860986888\n", - "0.009782953187823\n", - "0.009783015586436\n", - "0.009783054701984\n", - "0.009783067740500\n", - "0.009783059358597\n", - "0.009783005341887\n", - "0.009782937355340\n", - "0.009782851673663\n", - "0.009782752022147\n", - "0.009782596491277\n", - "0.009782473556697\n", - "0.009782415814698\n", - "0.009782390668988\n", - "0.009782401844859\n", - "0.009782468900084\n", - "0.009782552719116\n", - "0.009782650507987\n", - "0.009782737120986\n", - "0.009782847948372\n", - "0.009782942011952\n", - "0.009783034212887\n", - "0.009783115237951\n", - "0.009783172979951\n", - "0.009783223271370\n", - "0.009783263318241\n", - "0.009783286601305\n", - "0.009783296845853\n", - "0.009783279150724\n", - "0.009783237241209\n", - "0.009783171117306\n", - "0.009783079847693\n", - "0.009782965295017\n", - "0.009782840497792\n", - "0.009782714769244\n", - "0.009782615117729\n", - "0.009782515466213\n", - "0.009782433509827\n", - "0.009782392531633\n", - "0.009782309643924\n", - "0.009782241657376\n", - "0.009782171808183\n", - "0.009782131761312\n", - "0.009782089851797\n", - "0.009782037697732\n", - "0.009781997650862\n", - "0.009781979955733\n", - "0.009781969711185\n", - "0.009781978093088\n", - "0.009782018139958\n", - "0.009782082401216\n", - "0.009782183915377\n", - "0.009782317094505\n", - "0.009782426990569\n", - "0.009782554581761\n", - "0.009782666340470\n", - "0.009782756678760\n", - "0.009782846085727\n", - "0.009782927110791\n", - "0.009782980196178\n", - "0.009783010929823\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "F = 0.5 * L2NormSquared(b=absorption_data)\n", - "G_new = alpha_tv*TotalVariation(max_iteration=5, lower=0., warmstart=True)\n", - "G_FGP_TV=(alpha_tv/ig2D.voxel_size_y)*FGP_TV(max_iteration=500, nonnegativity = True, device = 'gpu') \n", - "K = A\n", - "# Setup and run PDHG\n", - "pdhg_tv_implicit_cil = PDHG(f = F, g = G_FGP_TV, operator = K,\n", - " max_iteration = 400,\n", - " update_objective_interval = 50)\n", - "\n", - "hold=np.zeros(400)\n", - "for i in range(400):\n", - " pdhg_tv_implicit_cil.__next__()\n", - " #print(np.linalg.norm(pdhg_tv_implicit_cil.solution.as_array()))\n", - " #print(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, 0.5).as_array())\n", - " #print(G_new.proximal(pdhg_tv_implicit_cil.solution, 0.5).as_array())\n", - " hold[i]=np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array()-G_new.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())/np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())\n", - " print('{0:.15f}'.format(hold[i]))\n", - "\n", - "plt.figure()\n", - "plt.semilogy(range(400), hold)\n", - "plt.title('Comparison of proximal values of warm start TV and CCPI TV reg at PDHG (Regtk) iteration values')\n", - "plt.ylabel('Absolute error')\n", - "plt.xlabel('Iteration number')\n", - "plt.show()\n", - "\n", - "\n", - "print('Next example ')\n", - "\n", - "F = 0.5 * L2NormSquared(b=absorption_data)\n", - "G_new = alpha_tv*TotalVariation(max_iteration=5, warmstart=True)\n", - "G_FGP_TV=(alpha_tv/ig2D.voxel_size_y)*FGP_TV(max_iteration=500, device = 'gpu') \n", - "K = A\n", - "# Setup and run PDHG\n", - "pdhg_tv_implicit_cil = PDHG(f = F, g = G_new, operator = K,\n", - " max_iteration = 400,\n", - " update_objective_interval = 50)\n", - "\n", - "\n", - "\n", - "for i in range(400):\n", - " pdhg_tv_implicit_cil.__next__()\n", - " hold[i]=np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array()-G_new.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())/np.linalg.norm(G_FGP_TV.proximal(pdhg_tv_implicit_cil.solution, pdhg_tv_implicit_cil.tau).as_array())\n", - " print('{0:.15f}'.format(hold[i]))\n", - "\n", - "plt.figure()\n", - "plt.semilogy(range(400), hold)\n", - "plt.title('Comparison of proximal values of warm start TV and CCPI TV reg at PDHG (CIL-warm start) iteration values')\n", - "plt.ylabel('Absolute error')\n", - "plt.xlabel('Iteration number')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b7026693", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bb42f52d", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "interpreter": { - "hash": "43cbf82c2f716cd564b762322e13d4dbd881fd8a341d231fe608abc3118da208" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From f62f0644887e5efcd9d5cb93987152dc91550ccd Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 16 Aug 2023 10:53:39 +0000 Subject: [PATCH 019/152] Changes to todo --- Wrappers/Python/cil/optimisation/functions/SGFunction.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 5f4d43a611..ac78e3e984 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -52,10 +52,10 @@ def approximate_gradient(self, function_num, x, out=None): self.functions[function_num].gradient(x, out = out) # scale wrt number of functions - out*=self.num_functions # Is this the scaling that we need? + out*=self.num_functions # FIXME: Is this the scaling that we need? # update data passes - self.data_passes.append(round(self.data_passes[-1] + 1./self.num_functions,4)) # What is this used for? + self.data_passes.append(round(self.data_passes[-1] + 1./self.num_functions,4)) # FIXME: What is this used for? if should_return: return out From beac6faa9b543ef9693192226603d51acfdb99bc Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 17 Aug 2023 12:22:45 +0000 Subject: [PATCH 020/152] Changes after dev meeting --- Wrappers/Python/cil/framework/sampler.py | 123 +++++++++++------------ 1 file changed, 60 insertions(+), 63 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index a2b60cfeba..5fd9f956d3 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -55,8 +55,8 @@ class Sampler(): ------- >>> sampler=Sampler.sequential(10) - >>> sampler.show_epochs(5) - >>> for _ in range(11): + >>> sampler.show_samples(5) + >>> for _ in range(55): print(sampler.next()) Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] @@ -82,25 +82,22 @@ class Sampler(): >>> sampler=Sampler.randomWithReplacement(11) >>> for _ in range(12): >>> print(next(sampler)) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(54) - 10 - 5 - 10 - 1 - 6 - 7 - 10 - 0 0 2 - 5 3 - Epoch 0: [10, 5, 10, 1, 6, 7, 10, 0, 0, 2, 5] - Epoch 1: [3, 10, 7, 7, 8, 7, 4, 7, 8, 4, 9] - Epoch 2: [0, 0, 0, 1, 3, 8, 6, 5, 7, 7, 0] - Epoch 3: [8, 8, 6, 4, 0, 2, 7, 2, 8, 3, 8] - Epoch 4: [10, 9, 3, 6, 6, 9, 5, 2, 8, 4, 0] + 3 + 2 + 0 + 3 + 3 + 1 + 2 + 1 + 1 + The first 54 samples: [0, 2, 3, 3, 2, 0, 3, 3, 1, 2, 1, 1, 2, 3, 3, 1, 3, 2, 4, 0, 0, 0, 1, 1, 3, 0, 4, 3, 3, 3, 0, 0, 0, 2, 4, 0, 1, 2, 3, 4, 0, 4, 4, 1, 4, 1, 4, 3, 0, 2, 3, 0, 1, 4] + @@ -118,7 +115,7 @@ def sequential(num_subsets): ------- >>> sampler=Sampler.sequential(10) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(49) >>> for _ in range(11): print(sampler.next()) @@ -126,7 +123,7 @@ def sequential(num_subsets): Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8] 0 1 2 @@ -156,13 +153,10 @@ def customOrder( customlist): -------- >>> sampler=Sampler.customOrder([1,4,6,7,8,9,11]) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(11) Epoch 0: [1, 4, 6, 7, 8, 9, 11] - Epoch 1: [1, 4, 6, 7, 8, 9, 11] - Epoch 2: [1, 4, 6, 7, 8, 9, 11] - Epoch 3: [1, 4, 6, 7, 8, 9, 11] - Epoch 4: [1, 4, 6, 7, 8, 9, 11] + Epoch 1: [1, 4, 6, 7] """ num_subsets=len(customlist) @@ -175,7 +169,7 @@ def hermanMeyer(num_subsets): Function that takes a number of subsets and returns a sampler which outputs a Herman Meyer order num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. For Herman-Meyer sampling this number should not be prime. Reference ---------- @@ -184,7 +178,7 @@ def hermanMeyer(num_subsets): Example ------- >>> sampler=Sampler.hermanMeyer(12) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(60) Epoch 0: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] Epoch 1: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] @@ -206,6 +200,8 @@ def _herman_meyer_order(n): if n_variable > 1: factors.append(n_variable) n_factors = len(factors) + if n_factors==0: + raise ValueError('Herman Meyer sampling defaults to sequential ordering if the number of subsets is prime. Please use an alternative sampling method or change the number of subsets. ') order = [0 for _ in range(n)] value = 0 for factor_n in range(n_factors): @@ -240,12 +236,12 @@ def staggered(num_subsets, offset): offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - + The offset should be less than the num_subsets Example ------- >>> sampler=Sampler.staggered(20,4) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(100) Epoch 0: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] Epoch 1: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] @@ -253,7 +249,8 @@ def staggered(num_subsets, offset): Epoch 3: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] Epoch 4: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] """ - + if offset>=num_subsets: + raise(ValueError('The offset should be less than the number of subsets')) indices=list(range(num_subsets)) order=[] [order.extend(indices[i::offset]) for i in range(offset)] @@ -282,35 +279,26 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): >>> sampler=Sampler.randomWithReplacement(5) - >>> print(sampler.get_epochs()) - [[3, 2, 2, 4, 4], [0, 1, 2, 4, 4]] + >>> print(sampler.get_samples(10)) + + The first 10 samples: [2, 1, 2, 3, 2, 1, 2, 2, 1, 2] Example ------- >>> sampler=Sampler.randomWithReplacement(4, [0.7,0.1,0.1,0.1]) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(21) - Epoch 0: [1, 0, 0, 0] - Epoch 1: [0, 0, 0, 0] - Epoch 2: [0, 0, 2, 2] - Epoch 3: [0, 0, 3, 0] - Epoch 4: [3, 2, 0, 0] + The first 21 samples: [3, 2, 0, 2, 0, 0, 0, 0, 0, 3, 0, 1, 0, 0, 2, 0, 0, 0, 1, 2, 0] """ if prob==None: prob = [1/num_subsets] *num_subsets - else: - prob=prob - if len(prob)!=num_subsets: - raise ValueError("Length of the list of probabilities should equal the number of subsets") - if sum(prob)-1.>=1e-5: - raise ValueError("Probabilities should sum to 1. Your probabilities sum to {}".format(sum(prob))) sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) return sampler @staticmethod - def randomWithoutReplacement(num_subsets, seed=None): + def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): """ Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. @@ -322,11 +310,12 @@ def randomWithoutReplacement(num_subsets, seed=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + shuffle:boolean, default=True + If True, there is a random shuffle between each epoch, if false the same random order as the first epoch is repeated for all future epochs. Example ------- >>> sampler=Sampler.randomWithoutReplacement(11) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(55) Epoch 0: [10, 4, 3, 0, 2, 9, 6, 8, 7, 5, 1] Epoch 1: [6, 0, 2, 4, 5, 7, 3, 10, 9, 8, 1] Epoch 2: [1, 2, 7, 4, 9, 5, 6, 3, 0, 8, 10] @@ -335,7 +324,7 @@ def randomWithoutReplacement(num_subsets, seed=None): """ order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) + sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=shuffle, seed=seed) return sampler @@ -422,23 +411,23 @@ def __next__(self): Allows the user to call next(sampler), to get the same result as sampler.next()""" return(self.next()) - def show_epochs(self, num_epochs=2): + def show_samples(self, num_samples=20): """ - Function that takes an integer, num_epochs, and prints the first num_epochs epochs. Calling this function will not interrupt the random number generation, if applicable. + Function that takes an integer, num_samples, and prints the first num_samples, organised into epochs where appropriate. Calling this function will not interrupt the random number generation, if applicable. - num_epochs: int, default=2 - The number of epochs to print. + num_samples: int, default=20 + The number of samples to print. Example ------- >>> sampler=Sampler.randomWithoutReplacement(11) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(50) Epoch 0: [9, 7, 2, 8, 0, 10, 1, 5, 3, 6, 4] Epoch 1: [6, 2, 0, 10, 5, 1, 9, 8, 7, 4, 3] Epoch 2: [5, 10, 0, 6, 1, 4, 3, 7, 2, 8, 9] Epoch 3: [4, 8, 3, 7, 1, 10, 5, 6, 2, 9, 0] - Epoch 4: [0, 7, 2, 6, 9, 10, 8, 3, 1, 4, 5] + Epoch 4: [0, 7, 2, 6, 9, 10] """ save_generator=self.generator @@ -447,25 +436,29 @@ def show_epochs(self, num_epochs=2): save_order=self.order self.order=self.initial_order self.generator=np.random.RandomState(self.seed) - for i in range(num_epochs): - print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) + if self.prob==None: + for i in range(num_samples//self.num_subsets): + print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) + print('Epoch {}: '.format(num_samples//self.num_subsets), [self.next() for _ in range(num_samples%self.num_subsets)]) + else: + print('The first {} samples: '.format(num_samples), [self.next() for _ in range(num_samples)]) self.generator=save_generator self.order=save_order self.last_subset=save_last_subset - def get_epochs(self, num_epochs=2): + def get_samples(self, num_samples=20): """ - Function that takes an integer, num_epochs, and returns the first num_epochs epochs in the form of a list of lists. Calling this function will not interrupt the random number generation, if applicable. + Function that takes an integer, num_samples, and returns the first num_samples, organised into epochs where appropriate, as a list of lists. Calling this function will not interrupt the random number generation, if applicable. - num_epochs: int, default=2 - The number of epochs to return. + num_samples: int, default=20 + The number of samples to return. Example ------- >>> sampler=Sampler.randomWithReplacement(5) - >>> print(sampler.get_epochs()) - [[3, 2, 2, 4, 4], [0, 1, 2, 4, 4]] + >>> print(sampler.get_samples()) + [[2, 4, 2, 4, 1, 3, 2, 2, 1, 2, 4, 4, 2, 3, 2, 1, 0, 4, 2, 3]] """ save_generator=self.generator @@ -475,8 +468,12 @@ def get_epochs(self, num_epochs=2): self.order=self.initial_order self.generator=np.random.RandomState(self.seed) output=[] - for i in range(num_epochs): - output.append( [self.next() for _ in range(self.num_subsets)]) + if self.prob==None: + for i in range(num_samples//self.num_subsets): + output.append( [self.next() for _ in range(self.num_subsets)]) + output.append([self.next() for _ in range(num_samples%self.num_subsets)]) + else: + output.append( [self.next() for _ in range(num_samples)]) self.generator=save_generator self.order=save_order self.last_subset=save_last_subset From 1202e53d8c77fd86c5d0fd90a9247371b49eb3cf Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 18 Aug 2023 12:16:02 +0000 Subject: [PATCH 021/152] Checking probabilities in init --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 312bd1f82c..35aab1872f 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -150,12 +150,13 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ self.prob = [1/self.ndual_subsets] * self.ndual_subsets self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) else: + if self.prob!=None: + warnings.warn('You supplied both probabilities and a sampler. The given probabilities will be ignored.') if self.sampler.prob!=None: self.prob=self.sampler.prob else: self.prob = [1/self.ndual_subsets] * self.ndual_subsets - if self.prob!=None: - warnings.warn('You supplied both probabilities and a sampler. The given probabilities will be ignored.') + From 079935b97b4eb936fbc4d670856adf1758b76441 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 23 Aug 2023 10:33:28 +0000 Subject: [PATCH 022/152] initial testing --- Wrappers/Python/test/test_algorithms.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index a7622b7f62..726bd5726a 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -755,7 +755,8 @@ class TestSPDHG(unittest.TestCase): @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + t1=time.time() + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(32,32)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -798,13 +799,13 @@ def test_SPDHG_vs_PDHG_implicit(self): sigma_tmp = 1. tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) - + t2=time.time() # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, max_iteration = 1000, update_objective_interval = 500) pdhg.run(verbose=0) - + t3=time.time() subsets = 10 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting @@ -831,10 +832,12 @@ def test_SPDHG_vs_PDHG_implicit(self): G = alpha * TotalVariation(50, 1e-4, lower=0) prob = [1/len(A)]*len(A) + t4=time.time() spdhg = SPDHG(f=F,g=G,operator=A, max_iteration = 1000, update_objective_interval=200, prob = prob) spdhg.run(1000, verbose=0) + t5=time.time() qm = (mae(spdhg.get_output(), pdhg.get_output()), mse(spdhg.get_output(), pdhg.get_output()), psnr(spdhg.get_output(), pdhg.get_output()) From 43e3dc40f8fca9484abc7f4510282674f8c3c6cc Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 24 Aug 2023 12:06:01 +0000 Subject: [PATCH 023/152] Sped up PDHG and SPDHG testing --- Wrappers/Python/test/test_algorithms.py | 65 ++++++++++++++----------- 1 file changed, 37 insertions(+), 28 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 726bd5726a..7fa1fe0ff1 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -756,7 +756,7 @@ class TestSPDHG(unittest.TestCase): @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): t1=time.time() - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(32,32)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -802,11 +802,11 @@ def test_SPDHG_vs_PDHG_implicit(self): t2=time.time() # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval = 500) + max_iteration = 70, + update_objective_interval = 1000) pdhg.run(verbose=0) t3=time.time() - subsets = 10 + subsets = 5 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] @@ -834,8 +834,8 @@ def test_SPDHG_vs_PDHG_implicit(self): prob = [1/len(A)]*len(A) t4=time.time() spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob) + max_iteration = 320, + update_objective_interval=1000, prob = prob) spdhg.run(1000, verbose=0) t5=time.time() qm = (mae(spdhg.get_output(), pdhg.get_output()), @@ -852,7 +852,7 @@ def test_SPDHG_vs_PDHG_implicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -883,7 +883,7 @@ def test_SPDHG_vs_PDHG_explicit(self): raise ValueError('Unsupported Noise ', noise) #%% 'explicit' SPDHG, scalar step-sizes - subsets = 10 + subsets = 5 size_of_subsets = int(len(angles)/subsets) # create Gradient operator op1 = GradientOperator(ig) @@ -912,9 +912,11 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob) + max_iteration = 220, + update_objective_interval=1000, prob = prob) + t1=time.time() spdhg.run(1000, verbose=0) + t2=time.time() #%% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) @@ -931,10 +933,11 @@ def test_SPDHG_vs_PDHG_explicit(self): f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) - pdhg.max_iteration = 1000 - pdhg.update_objective_interval = 200 + pdhg.max_iteration = 180 + pdhg.update_objective_interval = 1000 + t3=time.time() pdhg.run(1000, verbose=0) - + t4=time.time() #%% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() @@ -953,7 +956,7 @@ def test_SPDHG_vs_PDHG_explicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_SPDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128), dtype=numpy.float32) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16), dtype=numpy.float32) ig = data.geometry ig.voxel_size_x = 0.1 @@ -989,7 +992,7 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): raise ValueError('Unsupported Noise ', noise) #%% 'explicit' SPDHG, scalar step-sizes - subsets = 10 + subsets = 5 size_of_subsets = int(len(angles)/subsets) # create GradientOperator operator op1 = GradientOperator(ig) @@ -1021,16 +1024,19 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob.copy(), use_axpby=True) + max_iteration = 330, + update_objective_interval=1000, prob = prob.copy(), use_axpby=True) ) + t1=time.time() algos[0].run(1000, verbose=0) - + t2=time.time() algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob.copy(), use_axpby=False) + max_iteration = 330, + update_objective_interval=1000, prob = prob.copy(), use_axpby=False) ) + t3=time.time() algos[1].run(1000, verbose=0) + t4=time.time() # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) @@ -1040,12 +1046,12 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): ) logging.info ("Quality measures {}".format(qm)) assert qm[0] < 0.005 - assert qm[1] < 3.e-05 + assert qm[1] < 5.e-05 @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_PDHG_vs_PDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 @@ -1094,18 +1100,21 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): # Setup and run the PDHG algorithm algos = [] + algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval=200, use_axpby=True) + max_iteration = 300, + update_objective_interval=1000, use_axpby=True) ) + t1=time.time() algos[0].run(1000, verbose=0) - + t2=time.time() algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval=200, use_axpby=False) + max_iteration = 300, + update_objective_interval=1000, use_axpby=False) ) + t3=time.time() algos[1].run(1000, verbose=0) - + t4=time.time() qm = (mae(algos[0].get_output(), algos[1].get_output()), mse(algos[0].get_output(), algos[1].get_output()), psnr(algos[0].get_output(), algos[1].get_output()) From 004ab2f5ad321bb49847416e8d660ccba2b168e2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 24 Aug 2023 12:29:37 +0000 Subject: [PATCH 024/152] Removed timing statements --- Wrappers/Python/test/test_algorithms.py | 42 ++++++++++++------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 7fa1fe0ff1..8f95799c00 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -755,7 +755,7 @@ class TestSPDHG(unittest.TestCase): @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): - t1=time.time() + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry @@ -799,13 +799,13 @@ def test_SPDHG_vs_PDHG_implicit(self): sigma_tmp = 1. tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) - t2=time.time() + # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, max_iteration = 70, update_objective_interval = 1000) pdhg.run(verbose=0) - t3=time.time() + subsets = 5 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting @@ -832,12 +832,12 @@ def test_SPDHG_vs_PDHG_implicit(self): G = alpha * TotalVariation(50, 1e-4, lower=0) prob = [1/len(A)]*len(A) - t4=time.time() + spdhg = SPDHG(f=F,g=G,operator=A, max_iteration = 320, update_objective_interval=1000, prob = prob) spdhg.run(1000, verbose=0) - t5=time.time() + qm = (mae(spdhg.get_output(), pdhg.get_output()), mse(spdhg.get_output(), pdhg.get_output()), psnr(spdhg.get_output(), pdhg.get_output()) @@ -913,10 +913,10 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F,g=G,operator=A, max_iteration = 220, - update_objective_interval=1000, prob = prob) - t1=time.time() + update_objective_interval=220, prob = prob) + spdhg.run(1000, verbose=0) - t2=time.time() + #%% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) @@ -934,10 +934,10 @@ def test_SPDHG_vs_PDHG_explicit(self): # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) pdhg.max_iteration = 180 - pdhg.update_objective_interval = 1000 - t3=time.time() + pdhg.update_objective_interval =180 + pdhg.run(1000, verbose=0) - t4=time.time() + #%% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() @@ -1025,18 +1025,18 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): algos = [] algos.append( SPDHG(f=F,g=G,operator=A, max_iteration = 330, - update_objective_interval=1000, prob = prob.copy(), use_axpby=True) + update_objective_interval=330, prob = prob.copy(), use_axpby=True) ) - t1=time.time() + algos[0].run(1000, verbose=0) - t2=time.time() + algos.append( SPDHG(f=F,g=G,operator=A, max_iteration = 330, - update_objective_interval=1000, prob = prob.copy(), use_axpby=False) + update_objective_interval=330, prob = prob.copy(), use_axpby=False) ) - t3=time.time() + algos[1].run(1000, verbose=0) - t4=time.time() + # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) @@ -1105,16 +1105,16 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): max_iteration = 300, update_objective_interval=1000, use_axpby=True) ) - t1=time.time() + algos[0].run(1000, verbose=0) - t2=time.time() + algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, max_iteration = 300, update_objective_interval=1000, use_axpby=False) ) - t3=time.time() + algos[1].run(1000, verbose=0) - t4=time.time() + qm = (mae(algos[0].get_output(), algos[1].get_output()), mse(algos[0].get_output(), algos[1].get_output()), psnr(algos[0].get_output(), algos[1].get_output()) From 7b857e0cf1f6753b45cfede2e7a755d2cf850f4d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 13 Sep 2023 16:27:24 +0000 Subject: [PATCH 025/152] Got rid of epochs - still need to fix the shuffle --- Wrappers/Python/cil/framework/sampler.py | 173 +++++++++-------------- docs/docs_environment.yml | 2 +- 2 files changed, 71 insertions(+), 104 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 5fd9f956d3..57e85894fb 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -24,11 +24,9 @@ class Sampler(): r""" A class to select from a list of integers {0, 1, …, S-1}, with each integer representing the index of a subset - The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations/epochs the users asks for. + The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations. + - Calls are organised into epochs: The single index outputs can be organised into length-S lists. Each length-S list is called an epoch. The user can in principle ask for an infinite number of epochs to be run. Denote by E the number of epochs. - Each epoch always has a list of length S. It may contain the same subset index s multiple times or not at all. - Parameters ---------- num_subsets: int @@ -41,7 +39,7 @@ class Sampler(): The list of integers the method selects from using next. shuffle= bool, default=False - If True, after each epoch (num_subsets calls of next), the sampling order is shuffled randomly. + If True, after each num_subsets calls of next the sampling order is shuffled randomly. prob: list of floats of length num_subsets that sum to 1. For random sampling with replacement, this is the probability for each integer to be called by next. @@ -55,15 +53,11 @@ class Sampler(): ------- >>> sampler=Sampler.sequential(10) - >>> sampler.show_samples(5) - >>> for _ in range(55): + >>> print(sampler.get_samples(5)) + >>> for _ in range(11): print(sampler.next()) - Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + [0 1 2 3 4] 0 1 2 @@ -75,29 +69,27 @@ class Sampler(): 8 9 0 - 1 Example ------- - >>> sampler=Sampler.randomWithReplacement(11) + >>> sampler=Sampler.randomWithReplacement(5) >>> for _ in range(12): >>> print(next(sampler)) - >>> sampler.show_samples(54) + >>> print(sampler.get_samples()) + 3 + 4 + 0 0 2 3 3 2 - 0 - 3 - 3 - 1 2 1 1 - The first 54 samples: [0, 2, 3, 3, 2, 0, 3, 3, 1, 2, 1, 1, 2, 3, 3, 1, 3, 2, 4, 0, 0, 0, 1, 1, 3, 0, 4, 3, 3, 3, 0, 0, 0, 2, 4, 0, 1, 2, 3, 4, 0, 4, 4, 1, 4, 1, 4, 3, 0, 2, 3, 0, 1, 4] - + 4 + [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] @@ -115,15 +107,11 @@ def sequential(num_subsets): ------- >>> sampler=Sampler.sequential(10) - >>> sampler.show_samples(49) + >>> print(sampler.get_samples(5)) >>> for _ in range(11): print(sampler.next()) - Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8] + [0 1 2 3 4] 0 1 2 @@ -135,7 +123,6 @@ def sequential(num_subsets): 8 9 0 - 1 """ order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='sequential', order=order) @@ -153,10 +140,22 @@ def customOrder( customlist): -------- >>> sampler=Sampler.customOrder([1,4,6,7,8,9,11]) - >>> sampler.show_samples(11) + >>> print(sampler.get_samples(11)) + >>> for _ in range(9): + >>> print(sampler.next()) + >>> print(sampler.get_samples(5)) - Epoch 0: [1, 4, 6, 7, 8, 9, 11] - Epoch 1: [1, 4, 6, 7] + [ 1 4 6 7 8 9 11 1 4 6 7] + 1 + 4 + 6 + 7 + 8 + 9 + 11 + 1 + 4 + [1 4 6 7 8] """ num_subsets=len(customlist) @@ -178,13 +177,10 @@ def hermanMeyer(num_subsets): Example ------- >>> sampler=Sampler.hermanMeyer(12) - >>> sampler.show_samples(60) + >>> print(sampler.get_samples(16)) - Epoch 0: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] - Epoch 1: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] - Epoch 2: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] - Epoch 3: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] - Epoch 4: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] + """ def _herman_meyer_order(n): # Assuming that the subsets are in geometrical order @@ -240,14 +236,29 @@ def staggered(num_subsets, offset): Example ------- - >>> sampler=Sampler.staggered(20,4) - >>> sampler.show_samples(100) + >>> sampler=Sampler.staggered(21,4) + >>> print(sampler.get_samples(5)) + >>> for _ in range(15): + >>> print(sampler.next()) + >>> print(sampler.get_samples(5)) - Epoch 0: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] - Epoch 1: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] - Epoch 2: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] - Epoch 3: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] - Epoch 4: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + [ 0 4 8 12 16] + 0 + 4 + 8 + 12 + 16 + 20 + 1 + 5 + 9 + 13 + 17 + 2 + 6 + 10 + 14 + [ 0 4 8 12 16] """ if offset>=num_subsets: raise(ValueError('The offset should be less than the number of subsets')) @@ -281,15 +292,15 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): >>> sampler=Sampler.randomWithReplacement(5) >>> print(sampler.get_samples(10)) - The first 10 samples: [2, 1, 2, 3, 2, 1, 2, 2, 1, 2] + [3 4 0 0 2 3 3 2 2 1] Example ------- >>> sampler=Sampler.randomWithReplacement(4, [0.7,0.1,0.1,0.1]) - >>> sampler.show_samples(21) + >>> print(sampler.get_samples(10)) - The first 21 samples: [3, 2, 0, 2, 0, 0, 0, 0, 0, 3, 0, 1, 0, 0, 2, 0, 0, 0, 1, 2, 0] + [0 1 3 0 0 3 0 0 0 0] """ if prob==None: @@ -302,7 +313,7 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): """ Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. - Each epoch is a different perturbation and in each epoch each integer is outputted exactly once. + num_subsets: int The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. @@ -311,18 +322,14 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): Random seed for the random number generator. If set to None, the seed will be set using the current time. shuffle:boolean, default=True - If True, there is a random shuffle between each epoch, if false the same random order as the first epoch is repeated for all future epochs. + If True, there is a random shuffle after all the integers have been seen once, if false the same random order each time the data is sampled is used. Example ------- >>> sampler=Sampler.randomWithoutReplacement(11) - >>> sampler.show_samples(55) - Epoch 0: [10, 4, 3, 0, 2, 9, 6, 8, 7, 5, 1] - Epoch 1: [6, 0, 2, 4, 5, 7, 3, 10, 9, 8, 1] - Epoch 2: [1, 2, 7, 4, 9, 5, 6, 3, 0, 8, 10] - Epoch 3: [3, 10, 2, 9, 5, 6, 1, 7, 0, 8, 4] - Epoch 4: [6, 10, 1, 4, 0, 3, 9, 8, 2, 5, 7] + >>> print(sampler.get_samples(12)) + [ 1 7 6 3 2 8 9 5 4 10 0 4] """ - + order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=shuffle, seed=seed) return sampler @@ -344,7 +351,7 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N The list of integers the method selects from using next. shuffle= bool, default=False - If True, after each epoch (num_subsets calls of next), the sampling order is shuffled randomly. + If True, after each num_subsets calls of next, the sampling order is shuffled randomly. prob: list of floats of length num_subsets that sum to 1. For random sampling with replacement, this is the probability for each integer to be called by next. @@ -378,7 +385,7 @@ def _next_order(self): A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. - This function us used by samplers that output a permutation of an list in each epoch. + This function is used by samplers that sample without replacement. """ # print(self.last_subset) @@ -411,44 +418,10 @@ def __next__(self): Allows the user to call next(sampler), to get the same result as sampler.next()""" return(self.next()) - def show_samples(self, num_samples=20): - """ - Function that takes an integer, num_samples, and prints the first num_samples, organised into epochs where appropriate. Calling this function will not interrupt the random number generation, if applicable. - - num_samples: int, default=20 - The number of samples to print. - - Example - ------- - - >>> sampler=Sampler.randomWithoutReplacement(11) - >>> sampler.show_samples(50) - Epoch 0: [9, 7, 2, 8, 0, 10, 1, 5, 3, 6, 4] - Epoch 1: [6, 2, 0, 10, 5, 1, 9, 8, 7, 4, 3] - Epoch 2: [5, 10, 0, 6, 1, 4, 3, 7, 2, 8, 9] - Epoch 3: [4, 8, 3, 7, 1, 10, 5, 6, 2, 9, 0] - Epoch 4: [0, 7, 2, 6, 9, 10] - - """ - save_generator=self.generator - save_last_subset=self.last_subset - self.last_subset=self.num_subsets-1 - save_order=self.order - self.order=self.initial_order - self.generator=np.random.RandomState(self.seed) - if self.prob==None: - for i in range(num_samples//self.num_subsets): - print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) - print('Epoch {}: '.format(num_samples//self.num_subsets), [self.next() for _ in range(num_samples%self.num_subsets)]) - else: - print('The first {} samples: '.format(num_samples), [self.next() for _ in range(num_samples)]) - self.generator=save_generator - self.order=save_order - self.last_subset=save_last_subset - + def get_samples(self, num_samples=20): """ - Function that takes an integer, num_samples, and returns the first num_samples, organised into epochs where appropriate, as a list of lists. Calling this function will not interrupt the random number generation, if applicable. + Function that takes an integer, num_samples, and returns the first num_samples as a numpy array. num_samples: int, default=20 The number of samples to return. @@ -458,7 +431,7 @@ def get_samples(self, num_samples=20): >>> sampler=Sampler.randomWithReplacement(5) >>> print(sampler.get_samples()) - [[2, 4, 2, 4, 1, 3, 2, 2, 1, 2, 4, 4, 2, 3, 2, 1, 0, 4, 2, 3]] + [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ save_generator=self.generator @@ -467,15 +440,9 @@ def get_samples(self, num_samples=20): save_order=self.order self.order=self.initial_order self.generator=np.random.RandomState(self.seed) - output=[] - if self.prob==None: - for i in range(num_samples//self.num_subsets): - output.append( [self.next() for _ in range(self.num_subsets)]) - output.append([self.next() for _ in range(num_samples%self.num_subsets)]) - else: - output.append( [self.next() for _ in range(num_samples)]) + output=[self.next() for _ in range(num_samples)] self.generator=save_generator self.order=save_order self.last_subset=save_last_subset - return(output) + return(np.array(output)) diff --git a/docs/docs_environment.yml b/docs/docs_environment.yml index 07adaa7426..20621fcd22 100644 --- a/docs/docs_environment.yml +++ b/docs/docs_environment.yml @@ -17,7 +17,7 @@ # Authors: # CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt -name: docs +name: cil_testing channels: - conda-forge - intel From 1f7d54633d864043db9ac9252147f424f8c63899 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 14 Sep 2023 10:02:43 +0000 Subject: [PATCH 026/152] Fixed random without replacement shuffle=False --- Wrappers/Python/cil/framework/sampler.py | 193 ++++++++++++----------- 1 file changed, 97 insertions(+), 96 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 57e85894fb..3881bbdee8 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -# This work is part of the Core Imaging Library (CIL) developed by CCPi -# (Collaborative Computational Project in Tomographic Imaging), with +# This work is part of the Core Imaging Library (CIL) developed by CCPi +# (Collaborative Computational Project in Tomographic Imaging), with # substantial contributions by UKRI-STFC and University of Manchester. # Licensed under the Apache License, Version 2.0 (the "License"); @@ -17,27 +17,28 @@ import numpy as np -import math -import time +import math +import time + class Sampler(): - + r""" A class to select from a list of integers {0, 1, …, S-1}, with each integer representing the index of a subset The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations. - - + + Parameters ---------- num_subsets: int The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. - + sampling_type:str The sampling type used. order: list of integers The list of integers the method selects from using next. - + shuffle= bool, default=False If True, after each num_subsets calls of next the sampling order is shuffled randomly. @@ -46,7 +47,7 @@ class Sampler(): seed:int, default=None Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. - + Example @@ -76,7 +77,7 @@ class Sampler(): >>> for _ in range(12): >>> print(next(sampler)) >>> print(sampler.get_samples()) - + 3 4 0 @@ -94,7 +95,7 @@ class Sampler(): """ - + @staticmethod def sequential(num_subsets): """ @@ -124,12 +125,12 @@ def sequential(num_subsets): 9 0 """ - order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='sequential', order=order) - return sampler - + order = list(range(num_subsets)) + sampler = Sampler(num_subsets, sampling_type='sequential', order=order) + return sampler + @staticmethod - def customOrder( customlist): + def customOrder(customlist): """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. @@ -158,9 +159,10 @@ def customOrder( customlist): [1 4 6 7 8] """ - num_subsets=len(customlist) - sampler=Sampler(num_subsets, sampling_type='custom_order', order=customlist) - return sampler + num_subsets = len(customlist) + sampler = Sampler( + num_subsets, sampling_type='custom_order', order=customlist) + return sampler @staticmethod def hermanMeyer(num_subsets): @@ -173,12 +175,12 @@ def hermanMeyer(num_subsets): Reference ---------- Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. - + Example ------- >>> sampler=Sampler.hermanMeyer(12) >>> print(sampler.get_samples(16)) - + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] """ @@ -196,9 +198,10 @@ def _herman_meyer_order(n): if n_variable > 1: factors.append(n_variable) n_factors = len(factors) - if n_factors==0: - raise ValueError('Herman Meyer sampling defaults to sequential ordering if the number of subsets is prime. Please use an alternative sampling method or change the number of subsets. ') - order = [0 for _ in range(n)] + if n_factors == 0: + raise ValueError( + 'Herman Meyer sampling defaults to sequential ordering if the number of subsets is prime. Please use an alternative sampling method or change the number of subsets. ') + order = [0 for _ in range(n)] value = 0 for factor_n in range(n_factors): n_rep_value = 0 @@ -214,16 +217,17 @@ def _herman_meyer_order(n): n_rep_value = 0 if value == factors[factor_n]: value = 0 - order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping + order[element] = order[element] + \ + math.prod(factors[factor_n+1:]) * mapping return order - order=_herman_meyer_order(num_subsets) - sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) - return sampler + order = _herman_meyer_order(num_subsets) + sampler = Sampler( + num_subsets, sampling_type='herman_meyer', order=order) + return sampler @staticmethod def staggered(num_subsets, offset): - """ Function that takes a number of subsets and returns a sampler which outputs in a staggered order. @@ -233,7 +237,7 @@ def staggered(num_subsets, offset): offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. The offset should be less than the num_subsets - + Example ------- >>> sampler=Sampler.staggered(21,4) @@ -241,7 +245,7 @@ def staggered(num_subsets, offset): >>> for _ in range(15): >>> print(sampler.next()) >>> print(sampler.get_samples(5)) - + [ 0 4 8 12 16] 0 4 @@ -260,15 +264,13 @@ def staggered(num_subsets, offset): 14 [ 0 4 8 12 16] """ - if offset>=num_subsets: - raise(ValueError('The offset should be less than the number of subsets')) - indices=list(range(num_subsets)) - order=[] - [order.extend(indices[i::offset]) for i in range(offset)] - sampler=Sampler(num_subsets, sampling_type='staggered', order=order) - return sampler - - + if offset >= num_subsets: + raise (ValueError('The offset should be less than the number of subsets')) + indices = list(range(num_subsets)) + order = [] + [order.extend(indices[i::offset]) for i in range(offset)] + sampler = Sampler(num_subsets, sampling_type='staggered', order=order) + return sampler @staticmethod def randomWithReplacement(num_subsets, prob=None, seed=None): @@ -284,10 +286,10 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + Example ------- - + >>> sampler=Sampler.randomWithReplacement(5) >>> print(sampler.get_samples(10)) @@ -302,18 +304,18 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): [0 1 3 0 0 3 0 0 0 0] """ - - if prob==None: - prob = [1/num_subsets] *num_subsets - sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) - return sampler - + + if prob == None: + prob = [1/num_subsets] * num_subsets + sampler = Sampler( + num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) + return sampler + @staticmethod def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): - """ Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. - + num_subsets: int The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. @@ -329,11 +331,11 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): >>> print(sampler.get_samples(12)) [ 1 7 6 3 2 8 9 5 4 10 0 4] """ - - order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=shuffle, seed=seed) - return sampler + order = list(range(num_subsets)) + sampler = Sampler(num_subsets, sampling_type='random_without_replacement', + order=order, shuffle=shuffle, seed=seed) + return sampler def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): """ @@ -343,13 +345,13 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N ---------- num_subsets: int The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. - + sampling_type:str The sampling type used. order: list of integers The list of integers the method selects from using next. - + shuffle= bool, default=False If True, after each num_subsets calls of next, the sampling order is shuffled randomly. @@ -359,26 +361,27 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N seed:int, default=None Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. """ - self.type=sampling_type - self.num_subsets=num_subsets - if seed !=None: - self.seed=seed + self.type = sampling_type + self.num_subsets = num_subsets + if seed is not None: + self.seed = seed else: - self.seed=int(time.time()) - self.generator=np.random.RandomState(self.seed) - self.order=order - self.initial_order=order - if order!=None: - self.iterator=self._next_order - self.prob=prob - if prob!=None: - self.iterator=self._next_prob - self.shuffle=shuffle - self.last_subset=self.num_subsets-1 + self.seed = int(time.time()) + self.generator = np.random.RandomState(self.seed) + self.order = order + if order is not None: + self.iterator = self._next_order + self.shuffle = shuffle + if self.type == 'random_without_replacement' and self.shuffle == False: + self.order = self.generator.permutation(self.order) + print(self.order) + self.initial_order = self.order + self.prob = prob + if prob is not None: + self.iterator = self._next_prob + self.last_subset = self.num_subsets-1 - - def _next_order(self): """ The user should call sampler.next() or next(sampler) rather than use this function. @@ -386,15 +389,15 @@ def _next_order(self): A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. This function is used by samplers that sample without replacement. - + """ # print(self.last_subset) - if self.shuffle==True and self.last_subset==self.num_subsets-1: - self.order=self.generator.permutation(self.order) - #print(self.order) - self.last_subset= (self.last_subset+1)%self.num_subsets - return(self.order[self.last_subset]) - + if self.shuffle == True and self.last_subset == self.num_subsets-1: + self.order = self.generator.permutation(self.order) + # print(self.order) + self.last_subset = (self.last_subset+1) % self.num_subsets + return (self.order[self.last_subset]) + def _next_prob(self): """ The user should call sampler.next() or next(sampler) rather than use this function. @@ -402,7 +405,7 @@ def _next_prob(self): A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. This function us used by samplers that select from a list of integers {0, 1, …, S-1}, with S=num_subsets, randomly with replacement. - + """ return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) @@ -416,9 +419,8 @@ def __next__(self): A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. Allows the user to call next(sampler), to get the same result as sampler.next()""" - return(self.next()) + return (self.next()) - def get_samples(self, num_samples=20): """ Function that takes an integer, num_samples, and returns the first num_samples as a numpy array. @@ -434,15 +436,14 @@ def get_samples(self, num_samples=20): [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ - save_generator=self.generator - save_last_subset=self.last_subset - self.last_subset=self.num_subsets-1 - save_order=self.order - self.order=self.initial_order - self.generator=np.random.RandomState(self.seed) - output=[self.next() for _ in range(num_samples)] - self.generator=save_generator - self.order=save_order - self.last_subset=save_last_subset - return(np.array(output)) - + save_generator = self.generator + save_last_subset = self.last_subset + self.last_subset = self.num_subsets-1 + save_order = self.order + self.order = self.initial_order + self.generator = np.random.RandomState(self.seed) + output = [self.next() for _ in range(num_samples)] + self.generator = save_generator + self.order = save_order + self.last_subset = save_last_subset + return (np.array(output)) From 6993a959d5ad438d3f014a85b88f55dc22747d68 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 14 Sep 2023 15:27:42 +0000 Subject: [PATCH 027/152] Changes after meeting 12-09-2023. Remove epochs in sampler and deprecate prob in spdhg --- Wrappers/Python/cil/framework/sampler.py | 14 +- .../cil/optimisation/algorithms/SPDHG.py | 192 +++++++++++------- 2 files changed, 124 insertions(+), 82 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 3881bbdee8..3530ec3076 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -327,9 +327,15 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): If True, there is a random shuffle after all the integers have been seen once, if false the same random order each time the data is sampled is used. Example ------- - >>> sampler=Sampler.randomWithoutReplacement(11) - >>> print(sampler.get_samples(12)) - [ 1 7 6 3 2 8 9 5 4 10 0 4] + >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) + >>> print(sampler.get_samples(16)) + [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] + + Example + ------- + >>> sampler=Sampler.randomWithoutReplacement(7, seed=1, shuffle=False) + >>> print(sampler.get_samples(16)) + [6 2 1 0 4 3 5 6 2 1 0 4 3 5 6 2] """ order = list(range(num_subsets)) @@ -374,12 +380,10 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N self.shuffle = shuffle if self.type == 'random_without_replacement' and self.shuffle == False: self.order = self.generator.permutation(self.order) - print(self.order) self.initial_order = self.order self.prob = prob if prob is not None: self.iterator = self._next_prob - self.last_subset = self.num_subsets-1 def _next_order(self): diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 35aab1872f..f918597bf5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -23,15 +23,17 @@ import warnings import logging from cil.framework import Sampler + + class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient Problem: - + .. math:: - + \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) - + Parameters ---------- f : BlockFunction @@ -64,49 +66,100 @@ class SPDHG(Algorithm): Note ---- - + Convergence is guaranteed provided that [2, eq. (12)]: - + .. math:: - + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i - + Note ---- - + Notation for primal and dual step-sizes are reversed with comparison to PDHG.py - - + + References ---------- - + [1]"Stochastic primal-dual hybrid gradient algorithm with arbitrary sampling and imaging applications", Chambolle, Antonin, Matthias J. Ehrhardt, Peter Richtárik, and Carola-Bibiane Schonlieb, SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. - + [2]"Faster PET reconstruction with non-smooth priors by randomization and preconditioning", Matthias J Ehrhardt, Pawel Markiewicz and Carola-Bibiane Schönlieb, Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, prob=None, gamma=1.,sampler=None,**kwargs): + initial=None, gamma=1., sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) - - + + self._prob_weights = kwargs.get('prob', None) + if self._prob_weights is not None: + warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ + If you have passed both prob and a sampler then prob will be') if f is not None and operator is not None and g is not None: - self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, prob=prob, gamma=gamma,sampler=sampler, norms=kwargs.get('norms', None)) - + self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + initial=initial, gamma=gamma, sampler=sampler, norms=kwargs.get('norms', None)) + + @property + def norms(self): + return self._norms + + def set_norms(self, norms=None): + if norms is None: + # Compute norm of each sub-operator + norms = [self.operator.get_item(i, 0).norm() + for i in range(self.ndual_subsets)] + self._norms = norms + + @property + def sigma(self): + return self._sigma + + def set_sigma(self, sigma=None, norms=None): + self.set_norms(norms) + if sigma is None: + self._sigma = [self.gamma * self.rho / ni for ni in self._norms] + else: + self._sigma = sigma + + @property + def tau(self): + return self._tau - def set_up(self, f, g, operator, tau=None, sigma=None, \ - initial=None, prob=None, gamma=1.,sampler=None, norms=None): - + def set_tau(self, tau=None): + if tau is None: + self._tau = min([pi / (si * ni**2) for pi, ni, + si in zip(self._prob_weights, self._norms, self._sigma)]) + self._tau *= (self.rho / self.gamma) + else: + self._tau = tau + + def set_step_sizes(self): + ''' If you update either the norms or the prob_weights run this to reset the default sigma and tau step-sizes''' + self.set_sigma() + self.set_tau() + #TODO: Look at the PDHG one?? + + @property + def prob_weights(self): + return self._prob_weights + + def set_prob_weights(self, prob_weights=None): + if prob_weights is None: + self._prob_weights = [1/self.ndual_subsets] * self.ndual_subsets + else: + self._prob_weights = prob_weights + + def set_up(self, f, g, operator, tau=None, sigma=None, + initial=None, gamma=1., sampler=None, norms=None): '''set-up of the algorithm Parameters ---------- @@ -132,102 +185,85 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ precalculated list of norms of the operators ''' logging.info("{} setting up".format(self.__class__.__name__, )) - + # algorithmic parameters self.f = f self.g = g self.operator = operator - self.tau = tau - self.sigma = sigma - self.prob = prob - self.ndual_subsets = self.operator.shape[0] + self.sampler = sampler self.gamma = gamma + self.ndual_subsets = self.operator.shape[0] self.rho = .99 - self.sampler=sampler - if self.sampler==None: - if self.prob == None: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) - else: - if self.prob!=None: - warnings.warn('You supplied both probabilities and a sampler. The given probabilities will be ignored.') - if self.sampler.prob!=None: - self.prob=self.sampler.prob - else: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - - - - - if self.sigma is None: - if norms is None: - # Compute norm of each sub-operator - norms = [operator.get_item(i,0).norm() for i in range(self.ndual_subsets)] - self.norms = norms - self.sigma = [self.gamma * self.rho / ni for ni in norms] - if self.tau is None: - self.tau = min( [ pi / ( si * ni**2 ) for pi, ni, si in zip(self.prob, norms, self.sigma)] ) - self.tau *= (self.rho / self.gamma) - - # initialize primal variable + # Remove this if statement once prob is deprecated + if self._prob_weights is None or sampler is not None: + self.set_prob_weights(sampler.prob) + if self.sampler is None: + self.sampler = Sampler.randomWithReplacement( + self.ndual_subsets, prob=self._prob_weights) + self.set_norms(norms) + self.set_sigma(sigma) + self.set_tau(tau) + + # initialize primal variable if initial is None: self.x = self.operator.domain_geometry().allocate(0) else: self.x = initial.copy() - + self.x_tmp = self.operator.domain_geometry().allocate(0) - + # initialize dual variable to 0 self.y_old = operator.range_geometry().allocate(0) - + # initialize variable z corresponding to back-projected dual variable self.z = operator.domain_geometry().allocate(0) - self.zbar= operator.domain_geometry().allocate(0) + self.zbar = operator.domain_geometry().allocate(0) # relaxation parameter self.theta = 1 self.configured = True logging.info("{} configured".format(self.__class__.__name__, )) - + def update(self): # Gradient descent for the primal variable # x_tmp = x - tau * zbar - self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) - - self.g.proximal(self.x_tmp, self.tau, out=self.x) - + self.x.sapyb(1., self.zbar, -self._tau, out=self.x_tmp) + + self.g.proximal(self.x_tmp, self._tau, out=self.x) + # Choose subset - i = int(self.sampler.next()) - + i = self.sampler.next() + # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x y_k = self.operator[i].direct(self.x) - y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) - - y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) - + y_k.sapyb(self._sigma[i], self.y_old[i], 1., out=y_k) + + y_k = self.f[i].proximal_conjugate(y_k, self._sigma[i]) + # Back-project # x_tmp = K[i]^*(y_k - y_old[i]) y_k.subtract(self.y_old[i], out=self.y_old[i]) - self.operator[i].adjoint(self.y_old[i], out = self.x_tmp) + self.operator[i].adjoint(self.y_old[i], out=self.x_tmp) # Update backprojected dual variable and extrapolate # zbar = z + (1 + theta/p[i]) x_tmp # z = z + x_tmp - self.z.add(self.x_tmp, out =self.z) + self.z.add(self.x_tmp, out=self.z) # zbar = z + (theta/p[i]) * x_tmp - self.z.sapyb(1., self.x_tmp, self.theta / self.prob[i], out = self.zbar) + self.z.sapyb(1., self.x_tmp, self.theta / + self._prob_weights[i], out=self.zbar) # save previous iteration self.save_previous_iteration(i, y_k) - + def update_objective(self): # p1 = self.f(self.operator.direct(self.x)) + self.g(self.x) p1 = 0. - for i,op in enumerate(self.operator.operators): + for i, op in enumerate(self.operator.operators): p1 += self.f[i](op.direct(self.x)) p1 += self.g(self.x) @@ -240,14 +276,16 @@ def update_objective(self): @property def objective(self): - '''alias of loss''' - return [x[0] for x in self.loss] + '''alias of loss''' + return [x[0] for x in self.loss] + @property def dual_objective(self): return [x[1] for x in self.loss] - + @property def primal_dual_gap(self): return [x[2] for x in self.loss] + def save_previous_iteration(self, index, y_current): self.y_old[index].fill(y_current) From bafc748b27a8813fddd8aa35cabf48faf4ce4803 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 19 Sep 2023 14:10:53 +0000 Subject: [PATCH 028/152] Sampler unit tests added --- Wrappers/Python/test/test_sampler.py | 194 +++++++++++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 Wrappers/Python/test/test_sampler.py diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py new file mode 100644 index 0000000000..cbabbc991a --- /dev/null +++ b/Wrappers/Python/test/test_sampler.py @@ -0,0 +1,194 @@ +# -*- coding: utf-8 -*- +# Copyright 2019 United Kingdom Research and Innovation +# Copyright 2019 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt + +import unittest +from utils import initialise_tests +import os +import sys +from testclass import CCPiTestClass +import numpy as np +from cil.framework import Sampler +initialise_tests() + +sys.path.append(os.path.dirname(os.path.abspath(__file__))) + + +class TestSamplers(CCPiTestClass): + def test_init(self): + + sampler = Sampler.sequential(10) + self.assertEqual(sampler.num_subsets, 10) + self.assertEqual(sampler.type, 'sequential') + self.assertListEqual(sampler.order, list(range(10))) + self.assertListEqual(sampler.initial_order, list(range(10))) + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 9) + + sampler = Sampler.randomWithoutReplacement(7, shuffle=True) + self.assertEqual(sampler.num_subsets, 7) + self.assertEqual(sampler.type, 'random_without_replacement') + self.assertListEqual(sampler.order, list(range(7))) + self.assertListEqual(sampler.initial_order, list(range(7))) + self.assertEqual(sampler.shuffle, True) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 6) + + sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) + self.assertEqual(sampler.num_subsets, 8) + self.assertEqual(sampler.type, 'random_without_replacement') + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 7) + self.assertEqual(sampler.seed, 1) + + sampler = Sampler.hermanMeyer(12) + self.assertEqual(sampler.num_subsets, 12) + self.assertEqual(sampler.type, 'herman_meyer') + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 11) + self.assertListEqual( + sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + self.assertListEqual(sampler.initial_order, [ + 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + + sampler = Sampler.randomWithReplacement(5) + self.assertEqual(sampler.num_subsets, 5) + self.assertEqual(sampler.type, 'random_with_replacement') + self.assertEqual(sampler.order, None) + self.assertEqual(sampler.initial_order, None) + self.assertEqual(sampler.shuffle, False) + self.assertListEqual(sampler.prob, [1/5] * 5) + self.assertEqual(sampler.last_subset, 4) + + sampler = Sampler.randomWithReplacement(4, [0.7, 0.1, 0.1, 0.1]) + self.assertEqual(sampler.num_subsets, 4) + self.assertEqual(sampler.type, 'random_with_replacement') + self.assertEqual(sampler.order, None) + self.assertEqual(sampler.initial_order, None) + self.assertEqual(sampler.shuffle, False) + self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) + self.assertEqual(sampler.last_subset, 3) + + sampler = Sampler.staggered(21, 4) + self.assertEqual(sampler.num_subsets, 21) + self.assertEqual(sampler.type, 'staggered') + self.assertListEqual(sampler.order, [ + 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) + self.assertListEqual(sampler.initial_order, [ + 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 20) + + try: + Sampler.staggered(22, 25) + except ValueError: + self.assertTrue(True) + + sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) + self.assertEqual(sampler.num_subsets, 7) + self.assertEqual(sampler.type, 'custom_order') + self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) + self.assertListEqual(sampler.initial_order, [1, 4, 6, 7, 8, 9, 11]) + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 6) + + + + def test_sequential_iterator_and_get_samples(self): + + #Test the squential sampler + sampler = Sampler.sequential(10) + for i in range(25): + self.assertEqual(next(sampler), i % 10) + if i%5==0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(), np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) + + sampler = Sampler.sequential(10) + for i in range(25): + self.assertEqual(sampler.next(), i % 10) # Repeat the test for .next() + if i%5==0: + self.assertNumpyArrayEqual(sampler.get_samples(), np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) + + def test_random_without_replacement_iterator_and_get_samples(self): + #Test the random without replacement sampler + sampler = Sampler.randomWithoutReplacement(7, shuffle=True, seed=1) + order = [6, 2, 1, 0, 4, 3, 5, 1, 0, 4, 2, 5, + 6, 3, 3, 2, 1, 4, 0, 5, 6, 2, 6, 3, 4] + for i in range(25): + self.assertEqual(next(sampler), order[i]) + if i%4==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(6), np.array(order[:6])) + + #Repeat the test for shuffle=False + sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) + order = [7, 2, 1, 6, 0, 4, 3, 5] + for i in range(25): + self.assertEqual(sampler.next(), order[i % 8]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(5), np.array(order[:5])) + + def test_herman_meyer_iterator_and_get_samples(self): + #Test the Herman Meyer sampler + sampler = Sampler.hermanMeyer(12) + order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + for i in range(25): + self.assertEqual(sampler.next(), order[i % 12]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + + def test_random_with_replacement_iterator_and_get_samples(self): + #Test the Random with replacement sampler + sampler = Sampler.randomWithReplacement(5, seed=5) + order=[1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] + for i in range(25): + self.assertEqual(next(sampler), order[i]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + + sampler = Sampler.randomWithReplacement( + 4, [0.7, 0.1, 0.1, 0.1], seed=5) + order = [0, 2, 0, 3, 0, 0, 1, 0, 0, 0, 0, 1, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + for i in range(25): + self.assertEqual(sampler.next(), order[i]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + + def test_staggered_iterator_and_get_samples(self): + #Test the staggered sampler + sampler = Sampler.staggered(21, 4) + order = [0, 4, 8, 12, 16, 20, 1, 5, 9, 13, + 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + for i in range(25): + self.assertEqual(next(sampler), order[i % 21]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) + + def test_custom_order_iterator_and_get_samples(self): + #Test the custom order sampler + sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) + order = [1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11] + for i in range(25): + self.assertEqual(sampler.next(), order[i % 7]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) \ No newline at end of file From d62aa2bf5d07567afa3f4ff314e8122d5eb7e38c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 19 Sep 2023 16:02:19 +0000 Subject: [PATCH 029/152] Some checks for setting step sizes --- .../cil/optimisation/algorithms/SPDHG.py | 44 ++++++++++++++++++- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index f918597bf5..53a68682a6 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -23,7 +23,7 @@ import warnings import logging from cil.framework import Sampler - +from numbers import Number class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -113,6 +113,8 @@ def norms(self): return self._norms def set_norms(self, norms=None): + #TODO: write some checks for setting norms + if norms is None: # Compute norm of each sub-operator norms = [self.operator.get_item(i, 0).norm() @@ -124,6 +126,16 @@ def sigma(self): return self._sigma def set_sigma(self, sigma=None, norms=None): + #TODO: check if this is correct for PSDHG + if sigma is not None: + if isinstance(sigma, Number): + if sigma <= 0: + raise ValueError("The step-sizes of PDHG are positive, passed sigma = {}".format(sigma)) + elif sigma.shape != self.operator.range_geometry().shape: + raise ValueError(" The shape of sigma = {0} is not the same as the shape of the range_geometry = {1}".format(sigma.shape, self.operator.range_geometry().shape)) + + + self.set_norms(norms) if sigma is None: self._sigma = [self.gamma * self.rho / ni for ni in self._norms] @@ -135,6 +147,16 @@ def tau(self): return self._tau def set_tau(self, tau=None): + #TODO: check if this is correct for SPDHG + if tau is not None: + if isinstance(tau, Number): + if tau <= 0: + raise ValueError("The step-sizes of PDHG must be positive, passed tau = {}".format(tau)) + elif tau.shape != self.operator.domain_geometry().shape: + raise ValueError(" The shape of tau = {0} is not the same as the shape of the domain_geometry = {1}".format(tau.shape, self.operator.domain_geometry().shape)) + + + if tau is None: self._tau = min([pi / (si * ni**2) for pi, ni, si in zip(self._prob_weights, self._norms, self._sigma)]) @@ -146,7 +168,25 @@ def set_step_sizes(self): ''' If you update either the norms or the prob_weights run this to reset the default sigma and tau step-sizes''' self.set_sigma() self.set_tau() - #TODO: Look at the PDHG one?? + + def check_convergence(self): + #TODO: check if this is correct for SPDHG + """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma + + Returns + ------- + Boolean + True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. + """ + if isinstance(self.tau, Number) and isinstance(self.sigma, Number): + if self.sigma * self.tau * self.operator.norm()**2 > 1: + warnings.warn("Convergence criterion of PDHG for scalar step-sizes is not satisfied.") + return False + return True + else: + warnings.warn("Convergence criterion can only be checked for scalar values of tau and sigma.") + return False + @property def prob_weights(self): From c81b71c28ac9210e7c21ff8b83e7063c3f3c3aed Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Sep 2023 15:02:10 +0000 Subject: [PATCH 030/152] Started looking at unit tests and debugging SPDHG setters and init --- .../cil/optimisation/algorithms/SPDHG.py | 197 ++-- Wrappers/Python/test/test_algorithms.py | 968 ++++++++++-------- 2 files changed, 658 insertions(+), 507 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 53a68682a6..4a30d9eac0 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -25,6 +25,7 @@ from cil.framework import Sampler from numbers import Number + class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -77,7 +78,7 @@ class SPDHG(Algorithm): ---- Notation for primal and dual step-sizes are reversed with comparison - to PDHG.py + to SPDHG.py @@ -100,6 +101,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, super(SPDHG, self).__init__(**kwargs) self._prob_weights = kwargs.get('prob', None) + if self._prob_weights is not None: warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ If you have passed both prob and a sampler then prob will be') @@ -113,90 +115,175 @@ def norms(self): return self._norms def set_norms(self, norms=None): - #TODO: write some checks for setting norms + """Sets the operator norms for the step-size calculations for the SPDHG algorithm + Parameters + ---------- + norms : list of floats + precalculated list of norms of the operators""" if norms is None: # Compute norm of each sub-operator norms = [self.operator.get_item(i, 0).norm() for i in range(self.ndual_subsets)] + else: + for i in range(len(norms)): + if isinstance(norms[i], Number): + if norms[i] <= 0: + raise ValueError( + "The norms of the operators should be positive, passed norm= {}".format(norms[i])) + self._norms = norms @property - def sigma(self): - return self._sigma + def sampler(self): + return self._sampler + @property + def prob_weights(self): + return self._prob_weights + + def set_sampler(self, sampler=None): + """ Sets the sampler for the SPDHG algorithm. - def set_sigma(self, sigma=None, norms=None): - #TODO: check if this is correct for PSDHG - if sigma is not None: - if isinstance(sigma, Number): - if sigma <= 0: - raise ValueError("The step-sizes of PDHG are positive, passed sigma = {}".format(sigma)) - elif sigma.shape != self.operator.range_geometry().shape: - raise ValueError(" The shape of sigma = {0} is not the same as the shape of the range_geometry = {1}".format(sigma.shape, self.operator.range_geometry().shape)) + Parameters + ---------- + sampler: instance of the Sampler class + Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. + """ + if sampler is None: + if self._prob_weights is None: + self._prob_weights = [1/self.ndual_subsets] * self.ndual_subsets + self._sampler = Sampler.randomWithReplacement( + self.ndual_subsets, prob=self._prob_weights) + else: + if not isinstance(sampler, Sampler): + raise ValueError( + "The sampler should be an instance of the CIL Sampler class") + self._sampler = sampler + if sampler.prob is None: + self._prob_weights=[1/self.ndual_subsets] * self.ndual_subsets + else: + self._prob_weights=sampler.prob + + - self.set_norms(norms) - if sigma is None: - self._sigma = [self.gamma * self.rho / ni for ni in self._norms] + @property + def gamma(self): + return self._gamma + + def set_gamma(self, gamma=1.): + """ Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. + + Parameters + ---------- + gamma : float + parameter controlling the trade-off between the primal and dual step sizes + + """ + if isinstance(gamma, Number): + if gamma <= 0: + raise ValueError( + "The step-sizes of SPDHG are positive, gamma should also be positive") + + self._gamma = gamma else: + raise ValueError( + "We currently only support scalar values of gamma") + + @property + def sigma(self): + return self._sigma + + def set_sigma(self, sigma=None): + """ Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. + + Parameters + ---------- + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + + The user can set these or default values are calculated. Values passed by the user will be accepted as long as they are positive numbers, + or correct shape array like objects. + """ + if sigma is not None: + for i in range(len(sigma)): + if isinstance(sigma[i], Number): + if sigma[i] <= 0: + raise ValueError( + "The step-sizes of SPDHG are positive, passed sigma = {}".format(sigma[i])) + if len(sigma) != self.operator.range_geometry().shape[0]: + raise ValueError(" The shape of sigma = {0} is not the same as the shape of the range_geometry = {1}".format( + len(sigma), self.operator.range_geometry().shape[0])) self._sigma = sigma + elif sigma is None: + self._sigma = [self._gamma * self.rho / ni for ni in self._norms] + @property def tau(self): return self._tau def set_tau(self, tau=None): - #TODO: check if this is correct for SPDHG - if tau is not None: - if isinstance(tau, Number): - if tau <= 0: - raise ValueError("The step-sizes of PDHG must be positive, passed tau = {}".format(tau)) - elif tau.shape != self.operator.domain_geometry().shape: - raise ValueError(" The shape of tau = {0} is not the same as the shape of the domain_geometry = {1}".format(tau.shape, self.operator.domain_geometry().shape)) - + """ Sets tau step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. + Parameters + ---------- + tau : positive :obj:`float`, or `np.ndarray`, `DataContainer`, `BlockDataContainer`, optional, default=None + Step size for the primal problem. + The user can set either set these or instead the defaults are selected instead. Values passed by the user will be accepted as long as they are positive numbers, + or correct shape array like objects. + """ + if tau is not None: + if isinstance(tau, Number): + if tau <= 0: + raise ValueError( + "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) + elif tau.shape != self.operator.domain_geometry().shape: + raise ValueError(" The shape of tau = {0} is not the same as the shape of the domain_geometry = {1}".format( + tau.shape, self.operator.domain_geometry().shape)) + self._tau = tau if tau is None: self._tau = min([pi / (si * ni**2) for pi, ni, si in zip(self._prob_weights, self._norms, self._sigma)]) self._tau *= (self.rho / self.gamma) - else: - self._tau = tau - def set_step_sizes(self): - ''' If you update either the norms or the prob_weights run this to reset the default sigma and tau step-sizes''' + def reset_default_step_sizes(self): + """ Sets default sigma and tau step-sizes for the SPDHG algorithm. This should be re-run after changing the sampler, norms, gamma or prob_weights. + + Note + ---- + tau : positive float, optional, default=None + Step size parameter for Primal problem + + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + + """ self.set_sigma() self.set_tau() - + def check_convergence(self): - #TODO: check if this is correct for SPDHG + # TODO: check this with someone else """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma Returns ------- Boolean True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. - """ - if isinstance(self.tau, Number) and isinstance(self.sigma, Number): - if self.sigma * self.tau * self.operator.norm()**2 > 1: - warnings.warn("Convergence criterion of PDHG for scalar step-sizes is not satisfied.") + """ + for i in range(len(self._sigma)): + if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): + if self._sigma[i] * self._tau * self._norms[i]**2 > self._prob_weights[i]**2: + warnings.warn( + "Convergence criterion of SPDHG for scalar step-sizes is not satisfied.") + return False + return True + else: + warnings.warn( + "Convergence criterion currently can only be checked for scalar values of tau.") return False - return True - else: - warnings.warn("Convergence criterion can only be checked for scalar values of tau and sigma.") - return False - - - @property - def prob_weights(self): - return self._prob_weights - - def set_prob_weights(self, prob_weights=None): - if prob_weights is None: - self._prob_weights = [1/self.ndual_subsets] * self.ndual_subsets - else: - self._prob_weights = prob_weights def set_up(self, f, g, operator, tau=None, sigma=None, initial=None, gamma=1., sampler=None, norms=None): @@ -215,7 +302,6 @@ def set_up(self, f, g, operator, tau=None, sigma=None, List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class @@ -230,17 +316,12 @@ def set_up(self, f, g, operator, tau=None, sigma=None, self.f = f self.g = g self.operator = operator - self.sampler = sampler - self.gamma = gamma self.ndual_subsets = self.operator.shape[0] self.rho = .99 - # Remove this if statement once prob is deprecated - if self._prob_weights is None or sampler is not None: - self.set_prob_weights(sampler.prob) - if self.sampler is None: - self.sampler = Sampler.randomWithReplacement( - self.ndual_subsets, prob=self._prob_weights) + + self.set_sampler(sampler) + self.set_gamma(gamma) self.set_norms(norms) self.set_sigma(sigma) self.set_tau(tau) @@ -272,7 +353,7 @@ def update(self): self.g.proximal(self.x_tmp, self._tau, out=self.x) # Choose subset - i = self.sampler.next() + i = self._sampler.next() # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index a7622b7f62..64f8df43a4 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -29,13 +29,14 @@ from cil.framework import AcquisitionGeometry from cil.framework import BlockDataContainer from cil.framework import BlockGeometry +from cil.framework import Sampler from cil.optimisation.operators import IdentityOperator from cil.optimisation.operators import GradientOperator, BlockOperator, MatrixOperator from cil.optimisation.functions import LeastSquares, ZeroFunction, \ - L2NormSquared, OperatorCompositionFunction -from cil.optimisation.functions import MixedL21Norm, BlockFunction, L1Norm, KullbackLeibler + L2NormSquared, OperatorCompositionFunction +from cil.optimisation.functions import MixedL21Norm, BlockFunction, L1Norm, KullbackLeibler from cil.optimisation.functions import IndicatorBox from cil.optimisation.algorithms import Algorithm @@ -59,43 +60,45 @@ # Fast Gradient Projection algorithm for Total Variation(TV) from cil.optimisation.functions import TotalVariation +from cil.plugins.ccpi_regularisation.functions import FGP_TV import logging from testclass import CCPiTestClass -from utils import has_astra +from utils import has_astra initialise_tests() if has_astra: from cil.plugins.astra import ProjectionOperator + class TestAlgorithms(CCPiTestClass): - + def test_GD(self): - ig = ImageGeometry(12,13,14) + ig = ImageGeometry(12, 13, 14) initial = ig.allocate() # b = initial.copy() # fill with random numbers # b.fill(numpy.random.random(initial.shape)) b = ig.allocate('random') identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) rate = norm2sq.L / 3. - - alg = GD(initial=initial, - objective_function=norm2sq, - rate=rate, atol=1e-9, rtol=1e-6) + + alg = GD(initial=initial, + objective_function=norm2sq, + rate=rate, atol=1e-9, rtol=1e-6) alg.max_iteration = 1000 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = GD(initial=initial, - objective_function=norm2sq, - rate=rate, max_iteration=20, - update_objective_interval=2, - atol=1e-9, rtol=1e-6) + alg = GD(initial=initial, + objective_function=norm2sq, + rate=rate, max_iteration=20, + update_objective_interval=2, + atol=1e-9, rtol=1e-6) alg.max_iteration = 20 self.assertTrue(alg.max_iteration == 20) - self.assertTrue(alg.update_objective_interval==2) + self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) @@ -105,117 +108,118 @@ def test_update_interval_0(self): the update_objective interval is set to 0 and with verbose on / off ''' - ig = ImageGeometry(12,13,14) + ig = ImageGeometry(12, 13, 14) initial = ig.allocate() b = ig.allocate('random') identity = IdentityOperator(ig) norm2sq = LeastSquares(identity, b) - alg = GD(initial=initial, - objective_function=norm2sq, + alg = GD(initial=initial, + objective_function=norm2sq, max_iteration=20, update_objective_interval=0, atol=1e-9, rtol=1e-6) - self.assertTrue(alg.update_objective_interval==0) + self.assertTrue(alg.update_objective_interval == 0) alg.run(20, verbose=True) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) alg.run(20, verbose=False) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - def test_GDArmijo(self): - ig = ImageGeometry(12,13,14) + ig = ImageGeometry(12, 13, 14) initial = ig.allocate() # b = initial.copy() # fill with random numbers # b.fill(numpy.random.random(initial.shape)) b = ig.allocate('random') identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) rate = None - - alg = GD(initial=initial, - objective_function=norm2sq, rate=rate) + + alg = GD(initial=initial, + objective_function=norm2sq, rate=rate) alg.max_iteration = 100 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = GD(initial=initial, - objective_function=norm2sq, - max_iteration=20, - update_objective_interval=2) - #alg.max_iteration = 20 + alg = GD(initial=initial, + objective_function=norm2sq, + max_iteration=20, + update_objective_interval=2) + # alg.max_iteration = 20 self.assertTrue(alg.max_iteration == 20) - self.assertTrue(alg.update_objective_interval==2) + self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - def test_GDArmijo2(self): - f = Rosenbrock (alpha = 1., beta=100.) + f = Rosenbrock(alpha=1., beta=100.) vg = VectorGeometry(2) x = vg.allocate('random_int', seed=2) - # x = vg.allocate('random', seed=1) - x.fill(numpy.asarray([10.,-3.])) - + # x = vg.allocate('random', seed=1) + x.fill(numpy.asarray([10., -3.])) + max_iter = 10000 update_interval = 1000 - alg = GD(x, f, max_iteration=max_iter, update_objective_interval=update_interval, alpha=1e6) - + alg = GD(x, f, max_iteration=max_iter, + update_objective_interval=update_interval, alpha=1e6) + alg.run(verbose=0) - + # this with 10k iterations - numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [0.13463363, 0.01604593], decimal = 5) + numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [ + 0.13463363, 0.01604593], decimal=5) # this with 1m iterations # numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [1,1], decimal = 1) # numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [0.982744, 0.965725], decimal = 6) - def test_CGLS(self): - ig = ImageGeometry(10,2) + ig = ImageGeometry(10, 2) numpy.random.seed(2) initial = ig.allocate(1.) b = ig.allocate('random') identity = IdentityOperator(ig) - + alg = CGLS(initial=initial, operator=identity, data=b) - - np.testing.assert_array_equal(initial.as_array(), alg.solution.as_array()) - alg.max_iteration = 200 + np.testing.assert_array_equal( + initial.as_array(), alg.solution.as_array()) + + alg.max_iteration = 200 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = CGLS(initial=initial, operator=identity, data=b, max_iteration=200, update_objective_interval=2) + alg = CGLS(initial=initial, operator=identity, data=b, + max_iteration=200, update_objective_interval=2) self.assertTrue(alg.max_iteration == 200) - self.assertTrue(alg.update_objective_interval==2) + self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - - + def test_FISTA(self): - ig = ImageGeometry(127,139,149) + ig = ImageGeometry(127, 139, 149) initial = ig.allocate() b = initial.copy() # fill with random numbers b.fill(numpy.random.random(initial.shape)) initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) - opt = {'tol': 1e-4, 'memopt':False} - logging.info ("initial objective {}".format(norm2sq(initial))) - + opt = {'tol': 1e-4, 'memopt': False} + logging.info("initial objective {}".format(norm2sq(initial))) + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction()) alg.max_iteration = 2 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), max_iteration=2, update_objective_interval=2) - + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), + max_iteration=2, update_objective_interval=2) + self.assertTrue(alg.max_iteration == 2) - self.assertTrue(alg.update_objective_interval==2) + self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) @@ -227,11 +231,12 @@ def test_FISTA_update(self): n = 50 m = 500 - A = np.random.uniform(0,1, (m, n)).astype('float32') - b = (A.dot(np.random.randn(n)) + 0.1*np.random.randn(m)).astype('float32') + A = np.random.uniform(0, 1, (m, n)).astype('float32') + b = (A.dot(np.random.randn(n)) + 0.1 * + np.random.randn(m)).astype('float32') Aop = MatrixOperator(A) - bop = VectorData(b) + bop = VectorData(b) f = LeastSquares(Aop, b=bop, c=0.5) g = ZeroFunction() @@ -239,10 +244,10 @@ def test_FISTA_update(self): ig = Aop.domain initial = ig.allocate() - + # ista run 10 iteration tmp_initial = ig.allocate() - fista = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1) + fista = FISTA(initial=tmp_initial, f=f, g=g, max_iteration=1) fista.run() # fista update method @@ -254,97 +259,99 @@ def test_FISTA_update(self): for _ in range(1): - x = g.proximal(y_old - step_size * f.gradient(y_old), tau = step_size) + x = g.proximal(y_old - step_size * + f.gradient(y_old), tau=step_size) t = 0.5*(1 + numpy.sqrt(1 + 4*(t_old**2))) - y = x + ((t_old-1)/t)* ( x - x_old) + y = x + ((t_old-1)/t) * (x - x_old) x_old.fill(x) y_old.fill(y) t_old = t - - np.testing.assert_allclose(fista.solution.array, x.array, atol=1e-2) - + + np.testing.assert_allclose(fista.solution.array, x.array, atol=1e-2) + # check objective res1 = fista.objective[-1] res2 = f(x) + g(x) - self.assertTrue( res1==res2) + self.assertTrue(res1 == res2) tmp_initial = ig.allocate() - fista1 = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1) + fista1 = FISTA(initial=tmp_initial, f=f, g=g, max_iteration=1) self.assertTrue(fista1.is_provably_convergent()) - fista1 = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1, step_size=30.0) - self.assertFalse(fista1.is_provably_convergent()) + fista1 = FISTA(initial=tmp_initial, f=f, g=g, + max_iteration=1, step_size=30.0) + self.assertFalse(fista1.is_provably_convergent()) - def test_FISTA_Norm2Sq(self): - ig = ImageGeometry(127,139,149) + ig = ImageGeometry(127, 139, 149) b = ig.allocate(ImageGeometry.RANDOM) # fill with random numbers initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) - - opt = {'tol': 1e-4, 'memopt':False} - logging.info ("initial objective {}".format(norm2sq(initial))) + + opt = {'tol': 1e-4, 'memopt': False} + logging.info("initial objective {}".format(norm2sq(initial))) alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction()) alg.max_iteration = 2 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), max_iteration=2, update_objective_interval=3) + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), + max_iteration=2, update_objective_interval=3) self.assertTrue(alg.max_iteration == 2) - self.assertTrue(alg.update_objective_interval== 3) + self.assertTrue(alg.update_objective_interval == 3) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) def test_FISTA_catch_Lipschitz(self): - ig = ImageGeometry(127,139,149) + ig = ImageGeometry(127, 139, 149) initial = ImageData(geometry=ig) initial = ig.allocate() b = initial.copy() - # fill with random numbers + # fill with random numbers b.fill(numpy.random.random(initial.shape)) initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) logging.info('Lipschitz {}'.format(norm2sq.L)) # norm2sq.L = None - #norm2sq.L = 2 * norm2sq.c * identity.norm()**2 - #norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) - opt = {'tol': 1e-4, 'memopt':False} - logging.info ("initial objective".format(norm2sq(initial))) + # norm2sq.L = 2 * norm2sq.c * identity.norm()**2 + # norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) + opt = {'tol': 1e-4, 'memopt': False} + logging.info("initial objective".format(norm2sq(initial))) with self.assertRaises(ValueError): - alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction()) - + alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction()) def test_PDHG_Denoising(self): - # adapted from demo PDHG_TV_Color_Denoising.py in CIL-Demos repository - data = dataexample.PEPPERS.get(size=(256,256)) + # adapted from demo PDHG_TV_Color_Denoising.py in CIL-Demos repository + data = dataexample.PEPPERS.get(size=(256, 256)) ig = data.geometry ag = ig which_noise = 0 - # Create noisy data. + # Create noisy data. noises = ['gaussian', 'poisson', 's&p'] dnoise = noises[which_noise] - + def setup(data, dnoise): if dnoise == 's&p': - n1 = applynoise.saltnpepper(data, salt_vs_pepper = 0.9, amount=0.2, seed=10) + n1 = applynoise.saltnpepper( + data, salt_vs_pepper=0.9, amount=0.2, seed=10) elif dnoise == 'poisson': scale = 5 - n1 = applynoise.poisson( data.as_array()/scale, seed = 10)*scale + n1 = applynoise.poisson(data.as_array()/scale, seed=10)*scale elif dnoise == 'gaussian': - n1 = applynoise.gaussian(data.as_array(), seed = 10) + n1 = applynoise.gaussian(data.as_array(), seed=10) else: raise ValueError('Unsupported Noise ', noise) noisy_data = ig.allocate() noisy_data.fill(n1) - + # Regularisation Parameter depending on the noise distribution if dnoise == 's&p': alpha = 0.8 @@ -362,10 +369,11 @@ def setup(data, dnoise): return noisy_data, alpha, g noisy_data, alpha, g = setup(data, dnoise) - operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + operator = GradientOperator( + ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + + f1 = alpha * MixedL21Norm() - f1 = alpha * MixedL21Norm() - # Compute operator Norm normK = operator.norm() @@ -374,22 +382,23 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma) pdhg1.max_iteration = 2000 pdhg1.update_objective_interval = 200 pdhg1.run(1000, verbose=0) rmse = (pdhg1.get_output() - data).norm() / data.as_array().size - logging.info ("RMSE {}".format(rmse)) + logging.info("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) which_noise = 1 noise = noises[which_noise] noisy_data, alpha, g = setup(data, noise) - operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + operator = GradientOperator( + ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + + f1 = alpha * MixedL21Norm() - f1 = alpha * MixedL21Norm() - # Compute operator Norm normK = operator.norm() @@ -398,23 +407,23 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma, + pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma, max_iteration=2000, update_objective_interval=200) - + pdhg1.run(1000, verbose=0) rmse = (pdhg1.get_output() - data).norm() / data.as_array().size logging.info("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) - - + which_noise = 2 noise = noises[which_noise] noisy_data, alpha, g = setup(data, noise) - operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + operator = GradientOperator( + ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + + f1 = alpha * MixedL21Norm() - f1 = alpha * MixedL21Norm() - # Compute operator Norm normK = operator.norm() @@ -423,7 +432,7 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma) pdhg1.max_iteration = 2000 pdhg1.update_objective_interval = 200 pdhg1.run(1000, verbose=0) @@ -432,169 +441,173 @@ def setup(data, dnoise): logging.info("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) - def test_PDHG_step_sizes(self): - ig = ImageGeometry(3,3) + ig = ImageGeometry(3, 3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = 3*IdentityOperator(ig) - #check if sigma, tau are None + # check if sigma, tau are None pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10) self.assertAlmostEqual(pdhg.sigma, 1./operator.norm()) self.assertAlmostEqual(pdhg.tau, 1./operator.norm()) - #check if sigma is negative + # check if sigma is negative with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, sigma = -1) - - #check if tau is negative + pdhg = PDHG(f=f, g=g, operator=operator, + max_iteration=10, sigma=-1) + + # check if tau is negative with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, tau = -1) - - #check if tau is None + pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, tau=-1) + + # check if tau is None sigma = 3.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, max_iteration=10) self.assertAlmostEqual(pdhg.sigma, sigma) - self.assertAlmostEqual(pdhg.tau, 1./(sigma * operator.norm()**2)) + self.assertAlmostEqual(pdhg.tau, 1./(sigma * operator.norm()**2)) - #check if sigma is None + # check if sigma is None tau = 3.0 - pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, max_iteration=10) self.assertAlmostEqual(pdhg.tau, tau) - self.assertAlmostEqual(pdhg.sigma, 1./(tau * operator.norm()**2)) + self.assertAlmostEqual(pdhg.sigma, 1./(tau * operator.norm()**2)) - #check if sigma/tau are not None + # check if sigma/tau are not None tau = 1.0 sigma = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, sigma = sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, + sigma=sigma, max_iteration=10) self.assertAlmostEqual(pdhg.tau, tau) - self.assertAlmostEqual(pdhg.sigma, sigma) + self.assertAlmostEqual(pdhg.sigma, sigma) - #check sigma/tau as arrays, sigma wrong shape - ig1 = ImageGeometry(2,2) + # check sigma/tau as arrays, sigma wrong shape + ig1 = ImageGeometry(2, 2) sigma = ig1.allocate() with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, + sigma=sigma, max_iteration=10) - #check sigma/tau as arrays, tau wrong shape + # check sigma/tau as arrays, tau wrong shape tau = ig1.allocate() with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, max_iteration=10) + # check sigma not Number or object with correct shape with self.assertRaises(AttributeError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma = "sigma", max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, + sigma="sigma", max_iteration=10) + # check tau not Number or object with correct shape with self.assertRaises(AttributeError): - pdhg = PDHG(f=f, g=g, operator=operator, tau = "tau", max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, + tau="tau", max_iteration=10) + # check warning message if condition is not satisfied sigma = 4 tau = 1/3 with warnings.catch_warnings(record=True) as wa: - pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, sigma = sigma, max_iteration=10) - assert "Convergence criterion" in str(wa[0].message) - + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, + sigma=sigma, max_iteration=10) + assert "Convergence criterion" in str(wa[0].message) def test_PDHG_strongly_convex_gamma_g(self): - ig = ImageGeometry(3,3) + ig = ImageGeometry(3, 3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - # sigma, tau + # sigma, tau sigma = 1.0 - tau = 1.0 + tau = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, max_iteration=5, gamma_g=0.5) pdhg.run(1, verbose=0) - self.assertAlmostEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_g * tau)) + self.assertAlmostEquals( + pdhg.theta, 1.0 / np.sqrt(1 + 2 * pdhg.gamma_g * tau)) self.assertAlmostEquals(pdhg.tau, tau * pdhg.theta) self.assertAlmostEquals(pdhg.sigma, sigma / pdhg.theta) pdhg.run(4, verbose=0) self.assertNotEqual(pdhg.sigma, sigma) - self.assertNotEqual(pdhg.tau, tau) + self.assertNotEqual(pdhg.tau, tau) # check negative strongly convex constant with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, - max_iteration=5, gamma_g=-0.5) - + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + max_iteration=5, gamma_g=-0.5) # check strongly convex constant not a number with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, - max_iteration=5, gamma_g="-0.5") - + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + max_iteration=5, gamma_g="-0.5") def test_PDHG_strongly_convex_gamma_fcong(self): - ig = ImageGeometry(3,3) + ig = ImageGeometry(3, 3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - # sigma, tau + # sigma, tau sigma = 1.0 - tau = 1.0 + tau = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, max_iteration=5, gamma_fconj=0.5) pdhg.run(1, verbose=0) - self.assertEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_fconj * sigma)) + self.assertEquals(pdhg.theta, 1.0 / np.sqrt(1 + + 2 * pdhg.gamma_fconj * sigma)) self.assertEquals(pdhg.tau, tau / pdhg.theta) self.assertEquals(pdhg.sigma, sigma * pdhg.theta) pdhg.run(4, verbose=0) self.assertNotEqual(pdhg.sigma, sigma) - self.assertNotEqual(pdhg.tau, tau) + self.assertNotEqual(pdhg.tau, tau) # check negative strongly convex constant try: - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, - max_iteration=5, gamma_fconj=-0.5) + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + max_iteration=5, gamma_fconj=-0.5) except ValueError as ve: - logging.info(str(ve)) + logging.info(str(ve)) # check strongly convex constant not a number try: - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, - max_iteration=5, gamma_fconj="-0.5") + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + max_iteration=5, gamma_fconj="-0.5") except ValueError as ve: - logging.info(str(ve)) + logging.info(str(ve)) def test_PDHG_strongly_convex_both_fconj_and_g(self): - ig = ImageGeometry(3,3) + ig = ImageGeometry(3, 3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - + try: - pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, - gamma_g = 0.5, gamma_fconj=0.5) + pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, + gamma_g=0.5, gamma_fconj=0.5) pdhg.run(verbose=0) except ValueError as err: - logging.info(str(err)) + logging.info(str(err)) def test_FISTA_Denoising(self): # adapted from demo FISTA_Tikhonov_Poisson_Denoising.py in CIL-Demos repository data = dataexample.SHAPES.get() ig = data.geometry ag = ig - N=300 + N = 300 # Create Noisy data with Poisson noise scale = 5 - noisy_data = applynoise.poisson(data/scale,seed=10) * scale + noisy_data = applynoise.poisson(data/scale, seed=10) * scale # Regularisation Parameter alpha = 10 @@ -605,7 +618,7 @@ def test_FISTA_Denoising(self): reg = OperatorCompositionFunction(alpha * L2NormSquared(), operator) initial = ig.allocate() - fista = FISTA(initial=initial , f=reg, g=fid) + fista = FISTA(initial=initial, f=reg, g=fid) fista.max_iteration = 3000 fista.update_objective_interval = 500 fista.run(verbose=0) @@ -614,161 +627,210 @@ def test_FISTA_Denoising(self): self.assertLess(rmse, 4.2e-4) - - - - - - - - - - - - - - - - class TestSIRT(unittest.TestCase): - - def setUp(self): + def setUp(self): np.random.seed(10) # set up matrix, vectordata n, m = 50, 50 - A = np.random.uniform(0, 1,(m, n)).astype('float32') + A = np.random.uniform(0, 1, (m, n)).astype('float32') b = A.dot(np.random.randn(n)) self.Aop = MatrixOperator(A) - self.bop = VectorData(b) + self.bop = VectorData(b) self.ig = self.Aop.domain self.initial = self.ig.allocate() - + # set up with linear operator - self.ig2 = ImageGeometry(3,4,5) + self.ig2 = ImageGeometry(3, 4, 5) self.initial2 = self.ig2.allocate(0.) - self.b2 = self.ig2.allocate('random') - self.A2 = IdentityOperator(self.ig2) - + self.b2 = self.ig2.allocate('random') + self.A2 = IdentityOperator(self.ig2) def tearDown(self): - pass + pass - - def test_update(self): + def test_update(self): # sirt run 5 iterations tmp_initial = self.ig.allocate() - sirt = SIRT(initial = tmp_initial, operator=self.Aop, data=self.bop, max_iteration=5) + sirt = SIRT(initial=tmp_initial, operator=self.Aop, + data=self.bop, max_iteration=5) sirt.run() x = tmp_initial.copy() x_old = tmp_initial.copy() - for _ in range(5): - x = x_old + sirt.D*(sirt.operator.adjoint(sirt.M*(sirt.data - sirt.operator.direct(x_old)))) + for _ in range(5): + x = x_old + sirt.D * \ + (sirt.operator.adjoint(sirt.M*(sirt.data - sirt.operator.direct(x_old)))) x_old.fill(x) - np.testing.assert_allclose(sirt.solution.array, x.array, atol=1e-2) - + np.testing.assert_allclose(sirt.solution.array, x.array, atol=1e-2) def test_update_constraints(self): - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20) - alg.run(verbose=0) - np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, upper=0.3) + alg = SIRT(initial=self.initial2, operator=self.A2, + data=self.b2, max_iteration=20) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.max(), 0.3) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, lower=0.7) + np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) + + alg = SIRT(initial=self.initial2, operator=self.A2, + data=self.b2, max_iteration=20, upper=0.3) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.min(), 0.7) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, constraint=IndicatorBox(lower=0.1, upper=0.3)) + np.testing.assert_almost_equal(alg.solution.max(), 0.3) + + alg = SIRT(initial=self.initial2, operator=self.A2, + data=self.b2, max_iteration=20, lower=0.7) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.max(), 0.3) - np.testing.assert_almost_equal(alg.solution.min(), 0.1) + np.testing.assert_almost_equal(alg.solution.min(), 0.7) + alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2, + max_iteration=20, constraint=IndicatorBox(lower=0.1, upper=0.3)) + alg.run(verbose=0) + np.testing.assert_almost_equal(alg.solution.max(), 0.3) + np.testing.assert_almost_equal(alg.solution.min(), 0.1) def test_SIRT_relaxation_parameter(self): tmp_initial = self.ig.allocate() - alg = SIRT(initial = tmp_initial, operator=self.Aop, data=self.bop, max_iteration=5) - + alg = SIRT(initial=tmp_initial, operator=self.Aop, + data=self.bop, max_iteration=5) + with self.assertRaises(ValueError): alg.set_relaxation_parameter(0) with self.assertRaises(ValueError): alg.set_relaxation_parameter(2) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20) + alg = SIRT(initial=self.initial2, operator=self.A2, + data=self.b2, max_iteration=20) alg.set_relaxation_parameter(0.5) self.assertEqual(alg.relaxation_parameter, 0.5) alg.run(verbose=0) - np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) - - np.testing.assert_almost_equal(0.5 *alg.D.array, alg._Dscaled.array) + np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) + np.testing.assert_almost_equal(0.5 * alg.D.array, alg._Dscaled.array) def test_SIRT_nan_inf_values(self): Aop_nan_inf = self.Aop - Aop_nan_inf.A[0:10,:] = 0. - Aop_nan_inf.A[:,10:20] = 0. + Aop_nan_inf.A[0:10, :] = 0. + Aop_nan_inf.A[:, 10:20] = 0. tmp_initial = self.ig.allocate() - sirt = SIRT(initial = tmp_initial, operator=Aop_nan_inf, data=self.bop, max_iteration=5) - - self.assertFalse(np.any(sirt.M == inf)) - self.assertFalse(np.any(sirt.D == inf)) + sirt = SIRT(initial=tmp_initial, operator=Aop_nan_inf, + data=self.bop, max_iteration=5) + self.assertFalse(np.any(sirt.M == inf)) + self.assertFalse(np.any(sirt.D == inf)) def test_SIRT_remove_nan_or_inf_with_BlockDataContainer(self): np.random.seed(10) # set up matrix, vectordata n, m = 50, 50 - A = np.random.uniform(0, 1,(m, n)).astype('float32') + A = np.random.uniform(0, 1, (m, n)).astype('float32') b = A.dot(np.random.randn(n)) - A[0:10,:] = 0. - A[:,10:20] = 0. - Aop = BlockOperator( MatrixOperator(A*1), MatrixOperator(A*2) ) - bop = BlockDataContainer( VectorData(b*1), VectorData(b*2) ) - + A[0:10, :] = 0. + A[:, 10:20] = 0. + Aop = BlockOperator(MatrixOperator(A*1), MatrixOperator(A*2)) + bop = BlockDataContainer(VectorData(b*1), VectorData(b*2)) + ig = BlockGeometry(self.ig.copy(), self.ig.copy()) tmp_initial = ig.allocate() - sirt = SIRT(initial = tmp_initial, operator=Aop, data=bop, max_iteration=5) + sirt = SIRT(initial=tmp_initial, operator=Aop, + data=bop, max_iteration=5) for el in sirt.M.containers: self.assertFalse(np.any(el == inf)) - + self.assertFalse(np.any(sirt.D == inf)) -class TestSPDHG(unittest.TestCase): +class TestSPDHG(CCPiTestClass): - @unittest.skipUnless(has_astra, "cil-astra not available") - def test_SPDHG_vs_PDHG_implicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + def test_SPDHG_defaults_and_setters(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) + + subsets = 10 ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 90) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) # Select device dev = 'cpu' - + Aop = ProjectionOperator(ig, ag, dev) + + sin = Aop.direct(data) + partitioned_data = sin.partition(subsets, 'sequential') + A = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) + + # block function + F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(subsets)]) + alpha = 0.025 + G = alpha * FGP_TV() + spdhg = SPDHG(f=F, g=G, operator=A) + self.assertEqual(spdhg.gamma, 1.) + self.assertEqual(spdhg.rho, .99) + self.assertListEqual(spdhg.norms, [A.get_item(i, 0).norm() + for i in range(subsets)]) + self.assertListEqual(spdhg.prob_weights, [1/subsets] * subsets) + self.assertTrue(isinstance(spdhg.sampler, Sampler)) + self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) + self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) + self.assertNumpyArrayEqual(spdhg.x.array, A.domain_geometry().allocate(0).array) + self.assertEqual(spdhg.max_iteration, 0) + self.assertEqual(spdhg.update_objective_interval, 1) + + spdhg.set_norms([1]*subsets) + spdhg.set_sampler(Sampler.randomWithReplacement(10, list(range(1,11)/55))) + spdhg.set_gamma(10) + spdhg.reset_default_step_sizes(self) + + #TODO: Test these changes + spdhg.set_sigma([1]*subsets) + spdhg.set_tau(100) + #TODO: Test again + + def test_spdhg_non_default_init(self): + #TODO:: Test again + pass + + def test_spdhg_check_convergence(self): + #TODO:checkconvergence + pass + + + @unittest.skipUnless(has_astra, "cil-astra not available") + def test_SPDHG_vs_PDHG_implicit(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128, 128)) + + ig = data.geometry + ig.voxel_size_x = 0.1 + ig.voxel_size_y = 0.1 + + detectors = ig.shape[0] + angles = np.linspace(0, np.pi, 90) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) + # Select device + dev = 'cpu' + + Aop = ProjectionOperator(ig, ag, dev) + sin = Aop.direct(data) # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] @@ -778,91 +840,98 @@ def test_SPDHG_vs_PDHG_implicit(self): np.random.seed(10) scale = 20 eta = 0 - noisy_data.fill(np.random.poisson(scale * (eta + sin.as_array()))/scale) + noisy_data.fill(np.random.poisson( + scale * (eta + sin.as_array()))/scale) elif noise == 'gaussian': np.random.seed(10) - n1 = np.random.normal(0, 0.1, size = ag.shape) - noisy_data.fill(n1 + sin.as_array()) + n1 = np.random.normal(0, 0.1, size=ag.shape) + noisy_data.fill(n1 + sin.as_array()) else: raise ValueError('Unsupported Noise ', noise) - + # Create BlockOperator - operator = Aop - f = KullbackLeibler(b=noisy_data) + operator = Aop + f = KullbackLeibler(b=noisy_data) alpha = 0.005 - g = alpha * TotalVariation(50, 1e-4, lower=0) + g = alpha * TotalVariation(50, 1e-4, lower=0) normK = operator.norm() - - #% 'implicit' PDHG, preconditioned step-sizes + + # % 'implicit' PDHG, preconditioned step-sizes tau_tmp = 1. sigma_tmp = 1. - tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) - sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) - + tau = sigma_tmp / \ + operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) + sigma = tau_tmp / \ + operator.direct( + sigma_tmp * operator.domain_geometry().allocate(1.)) + # Setup and run the PDHG algorithm - pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval = 500) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=1000, + update_objective_interval=500) pdhg.run(verbose=0) - + subsets = 10 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] + list_angles = [angles[i:i+size_of_subsets] + for i in range(0, len(angles), size_of_subsets)] # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)]) - ## number of subsets - #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) + for i in range(subsets)]) + # number of subsets + # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) # - ## acquisisiton data + # acquisisiton data AD_list = [] for sub_num in range(subsets): for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets,:] - AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) + arr = noisy_data.as_array()[i:i+size_of_subsets, :] + AD_list.append(AcquisitionData( + arr, geometry=list_geoms[sub_num])) g = BlockDataContainer(*AD_list) - ## block function - F = BlockFunction(*[KullbackLeibler(b=g[i]) for i in range(subsets)]) - G = alpha * TotalVariation(50, 1e-4, lower=0) - + # block function + F = BlockFunction(*[KullbackLeibler(b=g[i]) for i in range(subsets)]) + G = alpha * TotalVariation(50, 1e-4, lower=0) + prob = [1/len(A)]*len(A) - spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob) + spdhg = SPDHG(f=F, g=G, operator=A, + max_iteration=1000, + update_objective_interval=200, prob=prob) spdhg.run(1000, verbose=0) qm = (mae(spdhg.get_output(), pdhg.get_output()), - mse(spdhg.get_output(), pdhg.get_output()), - psnr(spdhg.get_output(), pdhg.get_output()) - ) - logging.info ("Quality measures {}".format(qm)) - - np.testing.assert_almost_equal( mae(spdhg.get_output(), pdhg.get_output()), - 0.000335, decimal=3) - np.testing.assert_almost_equal( mse(spdhg.get_output(), pdhg.get_output()), - 5.51141e-06, decimal=3) - + mse(spdhg.get_output(), pdhg.get_output()), + psnr(spdhg.get_output(), pdhg.get_output()) + ) + logging.info("Quality measures {}".format(qm)) + + np.testing.assert_almost_equal(mae(spdhg.get_output(), pdhg.get_output()), + 0.000335, decimal=3) + np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), + 5.51141e-06, decimal=3) @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128, 128)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) # Select device dev = 'cpu' Aop = ProjectionOperator(ig, ag, dev) - + sin = Aop.direct(data) # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] @@ -875,94 +944,99 @@ def test_SPDHG_vs_PDHG_explicit(self): # eta = 0 # noisy_data = AcquisitionData(np.random.poisson( scale * (eta + sin.as_array()))/scale, ag) elif noise == 'gaussian': - noisy_data = noise.gaussian(sin, var=0.1, seed=10) + noisy_data = noise.gaussian(sin, var=0.1, seed=10) else: raise ValueError('Unsupported Noise ', noise) - - #%% 'explicit' SPDHG, scalar step-sizes + + # %% 'explicit' SPDHG, scalar step-sizes subsets = 10 size_of_subsets = int(len(angles)/subsets) # create Gradient operator op1 = GradientOperator(ig) # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] + list_angles = [angles[i:i+size_of_subsets] + for i in range(0, len(angles), size_of_subsets)] # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)] + [op1]) - ## number of subsets - #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) + for i in range(subsets)] + [op1]) + # number of subsets + # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) # - ## acquisisiton data + # acquisisiton data AD_list = [] for sub_num in range(subsets): for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets,:] - AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) + arr = noisy_data.as_array()[i:i+size_of_subsets, :] + AD_list.append(AcquisitionData( + arr, geometry=list_geoms[sub_num])) g = BlockDataContainer(*AD_list) alpha = 0.5 - ## block function - F = BlockFunction(*[*[KullbackLeibler(b=g[i]) for i in range(subsets)] + [alpha * MixedL21Norm()]]) + # block function + F = BlockFunction(*[*[KullbackLeibler(b=g[i]) + for i in range(subsets)] + [alpha * MixedL21Norm()]]) G = IndicatorBox(lower=0) prob = [1/(2*subsets)]*(len(A)-1) + [1/2] - spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob) + spdhg = SPDHG(f=F, g=G, operator=A, + max_iteration=1000, + update_objective_interval=200, prob=prob) spdhg.run(1000, verbose=0) - #%% 'explicit' PDHG, scalar step-sizes + # %% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) op2 = Aop # Create BlockOperator - operator = BlockOperator(op1, op2, shape=(2,1) ) - f2 = KullbackLeibler(b=noisy_data) - g = IndicatorBox(lower=0) + operator = BlockOperator(op1, op2, shape=(2, 1)) + f2 = KullbackLeibler(b=noisy_data) + g = IndicatorBox(lower=0) normK = operator.norm() sigma = 1/normK tau = 1/normK - - f1 = alpha * MixedL21Norm() - f = BlockFunction(f1, f2) + + f1 = alpha * MixedL21Norm() + f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm - pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma) pdhg.max_iteration = 1000 pdhg.update_objective_interval = 200 pdhg.run(1000, verbose=0) - #%% show diff between PDHG and SPDHG + # %% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() # plt.show() qm = (mae(spdhg.get_output(), pdhg.get_output()), - mse(spdhg.get_output(), pdhg.get_output()), - psnr(spdhg.get_output(), pdhg.get_output()) - ) + mse(spdhg.get_output(), pdhg.get_output()), + psnr(spdhg.get_output(), pdhg.get_output()) + ) logging.info("Quality measures {}".format(qm)) - np.testing.assert_almost_equal( mae(spdhg.get_output(), pdhg.get_output()), - 0.00150 , decimal=3) - np.testing.assert_almost_equal( mse(spdhg.get_output(), pdhg.get_output()), - 1.68590e-05, decimal=3) - + np.testing.assert_almost_equal(mae(spdhg.get_output(), pdhg.get_output()), + 0.00150, decimal=3) + np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), + 1.68590e-05, decimal=3) @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_SPDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128), dtype=numpy.float32) - + data = dataexample.SIMPLE_PHANTOM_2D.get( + size=(128, 128), dtype=numpy.float32) + ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) dev = 'cpu' Aop = ProjectionOperator(ig, ag, dev) - + sin = Aop.direct(data) # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] @@ -972,91 +1046,95 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): scale = 5 eta = 0 noisy_data = AcquisitionData(np.asarray( - np.random.poisson( scale * (eta + sin.as_array()))/scale, - dtype=np.float32 - ), - geometry=ag + np.random.poisson(scale * (eta + sin.as_array()))/scale, + dtype=np.float32 + ), + geometry=ag ) elif noise == 'gaussian': np.random.seed(10) - n1 = np.asarray(np.random.normal(0, 0.1, size = ag.shape), dtype=np.float32) + n1 = np.asarray(np.random.normal( + 0, 0.1, size=ag.shape), dtype=np.float32) noisy_data = AcquisitionData(n1 + sin.as_array(), geometry=ag) - + else: raise ValueError('Unsupported Noise ', noise) - - #%% 'explicit' SPDHG, scalar step-sizes + + # %% 'explicit' SPDHG, scalar step-sizes subsets = 10 size_of_subsets = int(len(angles)/subsets) # create GradientOperator operator op1 = GradientOperator(ig) # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] + list_angles = [angles[i:i+size_of_subsets] + for i in range(0, len(angles), size_of_subsets)] # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)] + [op1]) - ## number of subsets - #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) + for i in range(subsets)] + [op1]) + # number of subsets + # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) # - ## acquisisiton data - ## acquisisiton data + # acquisisiton data + # acquisisiton data AD_list = [] for sub_num in range(subsets): for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets,:] - AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) + arr = noisy_data.as_array()[i:i+size_of_subsets, :] + AD_list.append(AcquisitionData( + arr, geometry=list_geoms[sub_num])) - g = BlockDataContainer(*AD_list) + g = BlockDataContainer(*AD_list) alpha = 0.5 - ## block function - F = BlockFunction(*[*[KullbackLeibler(b=g[i]) for i in range(subsets)] + [alpha * MixedL21Norm()]]) + # block function + F = BlockFunction(*[*[KullbackLeibler(b=g[i]) + for i in range(subsets)] + [alpha * MixedL21Norm()]]) G = IndicatorBox(lower=0) prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] - algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob.copy(), use_axpby=True) - ) + algos.append(SPDHG(f=F, g=G, operator=A, + max_iteration=1000, + update_objective_interval=200, prob=prob.copy(), use_axpby=True) + ) algos[0].run(1000, verbose=0) - algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob.copy(), use_axpby=False) - ) + algos.append(SPDHG(f=F, g=G, operator=A, + max_iteration=1000, + update_objective_interval=200, prob=prob.copy(), use_axpby=False) + ) algos[1].run(1000, verbose=0) - # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) qm = (mae(algos[0].get_output(), algos[1].get_output()), - mse(algos[0].get_output(), algos[1].get_output()), - psnr(algos[0].get_output(), algos[1].get_output()) - ) - logging.info ("Quality measures {}".format(qm)) + mse(algos[0].get_output(), algos[1].get_output()), + psnr(algos[0].get_output(), algos[1].get_output()) + ) + logging.info("Quality measures {}".format(qm)) assert qm[0] < 0.005 assert qm[1] < 3.e-05 - @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_PDHG_vs_PDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128, 128)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) - + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) + dev = 'cpu' Aop = ProjectionOperator(ig, ag, dev) - + sin = Aop.direct(data) - + # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] noise = noises[1] @@ -1064,53 +1142,53 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): np.random.seed(10) scale = 5 eta = 0 - noisy_data = AcquisitionData(numpy.asarray(np.random.poisson( scale * (eta + sin.as_array())),dtype=numpy.float32)/scale, geometry=ag) + noisy_data = AcquisitionData(numpy.asarray(np.random.poisson( + scale * (eta + sin.as_array())), dtype=numpy.float32)/scale, geometry=ag) elif noise == 'gaussian': np.random.seed(10) - n1 = np.random.normal(0, 0.1, size = ag.shape) - noisy_data = AcquisitionData(numpy.asarray(n1 + sin.as_array(), dtype=numpy.float32), geometry=ag) - + n1 = np.random.normal(0, 0.1, size=ag.shape) + noisy_data = AcquisitionData(numpy.asarray( + n1 + sin.as_array(), dtype=numpy.float32), geometry=ag) + else: raise ValueError('Unsupported Noise ', noise) - - + alpha = 0.5 op1 = GradientOperator(ig) op2 = Aop # Create BlockOperator - operator = BlockOperator(op1, op2, shape=(2,1) ) - f2 = KullbackLeibler(b=noisy_data) - g = IndicatorBox(lower=0) + operator = BlockOperator(op1, op2, shape=(2, 1)) + f2 = KullbackLeibler(b=noisy_data) + g = IndicatorBox(lower=0) normK = operator.norm() sigma = 1./normK tau = 1./normK - - f1 = alpha * MixedL21Norm() - f = BlockFunction(f1, f2) + + f1 = alpha * MixedL21Norm() + f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm - + algos = [] - algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval=200, use_axpby=True) - ) + algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=1000, + update_objective_interval=200, use_axpby=True) + ) algos[0].run(1000, verbose=0) - algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval=200, use_axpby=False) - ) + algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=1000, + update_objective_interval=200, use_axpby=False) + ) algos[1].run(1000, verbose=0) - + qm = (mae(algos[0].get_output(), algos[1].get_output()), - mse(algos[0].get_output(), algos[1].get_output()), - psnr(algos[0].get_output(), algos[1].get_output()) - ) - logging.info ("Quality measures {}".format(qm)) - np.testing.assert_array_less( qm[0], 0.005 ) - np.testing.assert_array_less( qm[1], 3e-05) - + mse(algos[0].get_output(), algos[1].get_output()), + psnr(algos[0].get_output(), algos[1].get_output()) + ) + logging.info("Quality measures {}".format(qm)) + np.testing.assert_array_less(qm[0], 0.005) + np.testing.assert_array_less(qm[1], 3e-05) class PrintAlgo(Algorithm): @@ -1119,11 +1197,9 @@ def __init__(self, **kwargs): # self.update_objective() self.configured = True - def update(self): self.x = - self.iteration time.sleep(0.01) - def update_objective(self): self.loss.append(self.iteration * self.iteration) @@ -1131,63 +1207,61 @@ def update_objective(self): class TestPrint(unittest.TestCase): def test_print(self): - def callback (iteration, objective, solution): + def callback(iteration, objective, solution): print("I am being called ", iteration) - algo = PrintAlgo(update_objective_interval = 10, max_iteration = 1000) + algo = PrintAlgo(update_objective_interval=10, max_iteration=1000) - algo.run(20, verbose=2, print_interval = 2) + algo.run(20, verbose=2, print_interval=2) # it 0 - # it 10 + # it 10 # it 20 # --- stop - algo.run(3, verbose=1, print_interval = 2) + algo.run(3, verbose=1, print_interval=2) # it 20 # --- stop - - algo.run(20, verbose=1, print_interval = 7) + + algo.run(20, verbose=1, print_interval=7) # it 20 # it 30 # -- stop - + algo.run(20, verbose=1, very_verbose=False) algo.run(20, verbose=2, print_interval=7, callback=callback) - + logging.info(algo._iteration) logging.info(algo.objective) - np.testing.assert_array_equal([-1, 10, 20, 30, 40, 50, 60, 70, 80], algo.iterations) - np.testing.assert_array_equal([1, 100, 400, 900, 1600, 2500, 3600, 4900, 6400], algo.objective) - + np.testing.assert_array_equal( + [-1, 10, 20, 30, 40, 50, 60, 70, 80], algo.iterations) + np.testing.assert_array_equal( + [1, 100, 400, 900, 1600, 2500, 3600, 4900, 6400], algo.objective) def test_print2(self): - algo = PrintAlgo(update_objective_interval = 4, max_iteration = 1000) + algo = PrintAlgo(update_objective_interval=4, max_iteration=1000) algo.run(10, verbose=2, print_interval=2) - logging.info (algo.iteration) + logging.info(algo.iteration) algo.run(10, verbose=2, print_interval=2) logging.info("{} {}".format(algo._iteration, algo.objective)) - algo = PrintAlgo(update_objective_interval = 4, max_iteration = 1000) + algo = PrintAlgo(update_objective_interval=4, max_iteration=1000) algo.run(20, verbose=2, print_interval=2) - class TestADMM(unittest.TestCase): def setUp(self): - ig = ImageGeometry(2,3,2) + ig = ImageGeometry(2, 3, 2) data = ig.allocate(1, dtype=np.float32) noisy_data = data+1 - + # TV regularisation parameter self.alpha = 1 - - - self.fidelities = [ 0.5 * L2NormSquared(b=noisy_data), L1Norm(b=noisy_data), - KullbackLeibler(b=noisy_data, backend="numpy")] + self.fidelities = [0.5 * L2NormSquared(b=noisy_data), L1Norm(b=noisy_data), + KullbackLeibler(b=noisy_data, backend="numpy")] F = self.alpha * MixedL21Norm() K = GradientOperator(ig) - + # Compute operator Norm normK = K.norm() @@ -1197,44 +1271,40 @@ def setUp(self): self.F = F self.K = K - def test_ADMM_L2(self): self.do_test_with_fidelity(self.fidelities[0]) - def test_ADMM_L1(self): self.do_test_with_fidelity(self.fidelities[1]) - def test_ADMM_KL(self): self.do_test_with_fidelity(self.fidelities[2]) - def do_test_with_fidelity(self, fidelity): alpha = self.alpha # F = BlockFunction(alpha * MixedL21Norm(),fidelity) - + G = fidelity K = self.K F = self.F admm = LADMM(f=G, g=F, operator=K, tau=self.tau, sigma=self.sigma, - max_iteration = 100, update_objective_interval = 10) + max_iteration=100, update_objective_interval=10) admm.run(1, verbose=0) admm_noaxpby = LADMM(f=G, g=F, operator=K, tau=self.tau, sigma=self.sigma, - max_iteration = 100, update_objective_interval = 10, use_axpby=False) + max_iteration=100, update_objective_interval=10, use_axpby=False) admm_noaxpby.run(1, verbose=0) - - np.testing.assert_array_almost_equal(admm.solution.as_array(), admm_noaxpby.solution.as_array()) + np.testing.assert_array_almost_equal( + admm.solution.as_array(), admm_noaxpby.solution.as_array()) def test_compare_with_PDHG(self): - # Load an image from the CIL gallery. - data = dataexample.SHAPES.get(size=(64,64)) - ig = data.geometry + # Load an image from the CIL gallery. + data = dataexample.SHAPES.get(size=(64, 64)) + ig = data.geometry # Add gaussian noise - noisy_data = applynoise.gaussian(data, seed = 10, var = 0.0005) + noisy_data = applynoise.gaussian(data, seed=10, var=0.0005) # TV regularisation parameter alpha = 0.1 @@ -1244,7 +1314,7 @@ def test_compare_with_PDHG(self): fidelity = KullbackLeibler(b=noisy_data, backend="numpy") # Setup and run the PDHG algorithm - F = BlockFunction(alpha * MixedL21Norm(),fidelity) + F = BlockFunction(alpha * MixedL21Norm(), fidelity) G = ZeroFunction() K = BlockOperator(GradientOperator(ig), IdentityOperator(ig)) @@ -1256,14 +1326,14 @@ def test_compare_with_PDHG(self): tau = 1./normK pdhg = PDHG(f=F, g=G, operator=K, tau=tau, sigma=sigma, - max_iteration = 500, update_objective_interval = 10) + max_iteration=500, update_objective_interval=10) pdhg.run(verbose=0) sigma = 1 tau = sigma/normK**2 admm = LADMM(f=G, g=F, operator=K, tau=tau, sigma=sigma, - max_iteration = 500, update_objective_interval = 10) + max_iteration=500, update_objective_interval=10) admm.run(verbose=0) - np.testing.assert_almost_equal(admm.solution.array, pdhg.solution.array, decimal=3) - + np.testing.assert_almost_equal( + admm.solution.array, pdhg.solution.array, decimal=3) From b28f2f1ecce5dcd2554db5d340964fb009b42513 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 22 Sep 2023 14:19:51 +0000 Subject: [PATCH 031/152] Notes after discussions with gemma --- .../cil/optimisation/algorithms/SPDHG.py | 38 +++++---- Wrappers/Python/test/test_algorithms.py | 77 +++++++++++++------ 2 files changed, 77 insertions(+), 38 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 4a30d9eac0..794e29ca6a 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -49,8 +49,7 @@ class SPDHG(Algorithm): List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets + gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class @@ -58,6 +57,9 @@ class SPDHG(Algorithm): **kwargs: norms : list of floats precalculated list of norms of the operators + prob : list of floats, optional, default=None + List of probabilities. If None each subset will have probability = 1/number of subsets + rho #TODO: - maybe in the set sigma and tau? Example ------- @@ -96,7 +98,7 @@ class SPDHG(Algorithm): ''' def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, gamma=1., sampler=None, **kwargs): + initial=None, gamma=1., sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) @@ -108,7 +110,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, if f is not None and operator is not None and g is not None: self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, gamma=gamma, sampler=sampler, norms=kwargs.get('norms', None)) + initial=initial, gamma=gamma, sampler=sampler, rho=kwargs.get('rho', .99),norms=kwargs.get('norms', None)) @property def norms(self): @@ -126,8 +128,8 @@ def set_norms(self, norms=None): norms = [self.operator.get_item(i, 0).norm() for i in range(self.ndual_subsets)] else: - for i in range(len(norms)): - if isinstance(norms[i], Number): + for i in range(len(norms)): # TODO: length should be self.ndual_subsets + if isinstance(norms[i], Number): #TODO: shouldn't be passing if it is not a number if norms[i] <= 0: raise ValueError( "The norms of the operators should be positive, passed norm= {}".format(norms[i])) @@ -141,7 +143,7 @@ def sampler(self): def prob_weights(self): return self._prob_weights - def set_sampler(self, sampler=None): + def set_sampler(self, sampler=None): #TODO: do want to keep this? THink about what should be reset based on this """ Sets the sampler for the SPDHG algorithm. Parameters @@ -249,7 +251,12 @@ def set_tau(self, tau=None): si in zip(self._prob_weights, self._norms, self._sigma)]) self._tau *= (self.rho / self.gamma) - def reset_default_step_sizes(self): + def set_step_sizes_from_ratio(gamma=1, rho=0.99): #TODO: + pass + def set_step_sizes_custom(sigma=None, tau=None): #TODO: + pass + + def set_step_sizes_default(self): #TODO: Pass gamma, sigma, rho, tau to one function? """ Sets default sigma and tau step-sizes for the SPDHG algorithm. This should be re-run after changing the sampler, norms, gamma or prob_weights. Note @@ -266,6 +273,7 @@ def reset_default_step_sizes(self): def check_convergence(self): # TODO: check this with someone else + #TODO: Don't think this is working just at the moment """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma Returns @@ -286,7 +294,7 @@ def check_convergence(self): return False def set_up(self, f, g, operator, tau=None, sigma=None, - initial=None, gamma=1., sampler=None, norms=None): + initial=None, gamma=1., sampler=None, norms=None, rho=.99): '''set-up of the algorithm Parameters ---------- @@ -308,7 +316,11 @@ def set_up(self, f, g, operator, tau=None, sigma=None, Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. **kwargs: norms : list of floats - precalculated list of norms of the operators + precalculated list of norms of the operators #TODO: call it precalculated norms and add to argument list + rho : list of floats #TODO: Add to sigma and tau + + + ''' logging.info("{} setting up".format(self.__class__.__name__, )) @@ -317,13 +329,13 @@ def set_up(self, f, g, operator, tau=None, sigma=None, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - self.rho = .99 + self.rho = rho self.set_sampler(sampler) self.set_gamma(gamma) - self.set_norms(norms) - self.set_sigma(sigma) + self.set_norms(norms) #passed or calculated by constructor + self.set_sigma(sigma) #might not want to do this until it is called (if computationally expensive) self.set_tau(tau) # initialize primal variable diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 64f8df43a4..ac5bdc75eb 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -751,11 +751,10 @@ def test_SIRT_remove_nan_or_inf_with_BlockDataContainer(self): class TestSPDHG(CCPiTestClass): - - def test_SPDHG_defaults_and_setters(self): + def setUp(self): data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) - subsets = 10 + self.subsets = 10 ig = data.geometry ig.voxel_size_x = 0.1 @@ -771,48 +770,76 @@ def test_SPDHG_defaults_and_setters(self): Aop = ProjectionOperator(ig, ag, dev) sin = Aop.direct(data) - partitioned_data = sin.partition(subsets, 'sequential') - A = BlockOperator( - *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) + partitioned_data = sin.partition(self.subsets, 'sequential') + self.A = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(self.subsets)]) # block function - F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(subsets)]) + self.F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(self.subsets)]) alpha = 0.025 - G = alpha * FGP_TV() - spdhg = SPDHG(f=F, g=G, operator=A) + self.G = alpha * FGP_TV() + + def test_SPDHG_defaults_and_setters(self): + + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) self.assertEqual(spdhg.gamma, 1.) self.assertEqual(spdhg.rho, .99) - self.assertListEqual(spdhg.norms, [A.get_item(i, 0).norm() - for i in range(subsets)]) - self.assertListEqual(spdhg.prob_weights, [1/subsets] * subsets) + self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() + for i in range(self.subsets)]) + self.assertListEqual(spdhg.prob_weights, [1/self.subsets] * self.subsets) self.assertTrue(isinstance(spdhg.sampler, Sampler)) self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) - self.assertNumpyArrayEqual(spdhg.x.array, A.domain_geometry().allocate(0).array) + self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(0).array) self.assertEqual(spdhg.max_iteration, 0) self.assertEqual(spdhg.update_objective_interval, 1) - spdhg.set_norms([1]*subsets) - spdhg.set_sampler(Sampler.randomWithReplacement(10, list(range(1,11)/55))) + spdhg.set_norms([1]*self.subsets) + spdhg.set_sampler(Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.))) spdhg.set_gamma(10) - spdhg.reset_default_step_sizes(self) + spdhg.reset_default_step_sizes() - #TODO: Test these changes - spdhg.set_sigma([1]*subsets) + self.assertEqual(spdhg.gamma, 10) + self.assertEqual(spdhg.rho, .99) + self.assertListEqual(spdhg.norms, [1]*self.subsets) + self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) + self.assertTrue(isinstance(spdhg.sampler, Sampler)) + self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) + self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) + + + spdhg.set_sigma([1]*self.subsets) spdhg.set_tau(100) - #TODO: Test again + self.assertListEqual(spdhg.sigma, [1]*self.subsets) + self.assertEqual(spdhg.tau, 100) + def test_spdhg_non_default_init(self): - #TODO:: Test again - pass + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, gamma=10, rho=.45, norms=[1]*self.subsets, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), + sigma=[1]*self.subsets, tau=100, initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + self.assertEqual(spdhg.gamma, 10) + self.assertEqual(spdhg.rho, .45) + self.assertListEqual(spdhg.norms, [1]*self.subsets) + self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) + self.assertTrue(isinstance(spdhg.sampler, Sampler)) + self.assertListEqual(spdhg.sigma, [1]*self.subsets) + self.assertEqual(spdhg.tau, 100) + self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) + self.assertEqual(spdhg.max_iteration, 1000) + self.assertEqual(spdhg.update_objective_interval, 10) def test_spdhg_check_convergence(self): - #TODO:checkconvergence - pass - + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, gamma=10, rho=.45, norms=[1]*self.subsets, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), + sigma=[1]*self.subsets, tau=10, initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + + self.assertFalse(spdhg.check_convergence()) + spdhg.reset_default_step_sizes() + self.assertTrue(spdhg.check_convergence()) + @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): From 4a87f4891520b0a8ad388d1c6e5a29393321413c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Sep 2023 13:47:43 +0000 Subject: [PATCH 032/152] Changes after discussion with gemma --- .../cil/optimisation/algorithms/SPDHG.py | 275 +++++++++--------- Wrappers/Python/test/test_algorithms.py | 82 ++++-- 2 files changed, 185 insertions(+), 172 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 794e29ca6a..52408fb6e8 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -54,13 +54,14 @@ class SPDHG(Algorithm): parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets - **kwargs: - norms : list of floats + precalculated_norms : list of floats precalculated list of norms of the operators + **kwargs: + prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets - rho #TODO: - maybe in the set sigma and tau? - + List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ + norms : list of floats + precalculated list of norms of the operators. To be deprecated - replaced by precalculated_norms Example ------- @@ -97,179 +98,131 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, gamma=1., sampler=None, **kwargs): + def __init__(self, f=None, g=None, operator=None, + initial=None, precalculated_norms=None, sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) - self._prob_weights = kwargs.get('prob', None) - - if self._prob_weights is not None: + self.prob_weights = kwargs.get('prob', None) + if kwargs.get('norms', None) is not None: + warnings.warn('norms is being deprecated, pass instead precalculated_norms=your_custom_norms') + if precalculated_norms is None: + precalculated_norms=kwargs.get('norms', None) + + if self.prob_weights is not None: warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ If you have passed both prob and a sampler then prob will be') if f is not None and operator is not None and g is not None: - self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, gamma=gamma, sampler=sampler, rho=kwargs.get('rho', .99),norms=kwargs.get('norms', None)) + self.set_up(f=f, g=g, operator=operator, + initial=initial, sampler=sampler,precalculated_norms=precalculated_norms) - @property - def norms(self): - return self._norms - def set_norms(self, norms=None): - """Sets the operator norms for the step-size calculations for the SPDHG algorithm - Parameters - ---------- - norms : list of floats - precalculated list of norms of the operators""" - if norms is None: - # Compute norm of each sub-operator - norms = [self.operator.get_item(i, 0).norm() - for i in range(self.ndual_subsets)] - else: - for i in range(len(norms)): # TODO: length should be self.ndual_subsets - if isinstance(norms[i], Number): #TODO: shouldn't be passing if it is not a number - if norms[i] <= 0: - raise ValueError( - "The norms of the operators should be positive, passed norm= {}".format(norms[i])) - - self._norms = norms - - @property - def sampler(self): - return self._sampler - @property - def prob_weights(self): - return self._prob_weights - def set_sampler(self, sampler=None): #TODO: do want to keep this? THink about what should be reset based on this - """ Sets the sampler for the SPDHG algorithm. - - Parameters - ---------- - sampler: instance of the Sampler class - Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. - """ - if sampler is None: - if self._prob_weights is None: - self._prob_weights = [1/self.ndual_subsets] * self.ndual_subsets - self._sampler = Sampler.randomWithReplacement( - self.ndual_subsets, prob=self._prob_weights) - else: - if not isinstance(sampler, Sampler): - raise ValueError( - "The sampler should be an instance of the CIL Sampler class") - self._sampler = sampler - if sampler.prob is None: - self._prob_weights=[1/self.ndual_subsets] * self.ndual_subsets - else: - self._prob_weights=sampler.prob + @property + def sigma(self): + return self._sigma - - - @property - def gamma(self): - return self._gamma - - def set_gamma(self, gamma=1.): + def tau(self): + return self._tau + + def set_step_sizes_from_ratio(self, gamma=1., rho=.99): """ Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. Parameters ---------- gamma : float parameter controlling the trade-off between the primal and dual step sizes - + rho : float + parameter controlling the size of the product :math: \sigma\tau :math: """ if isinstance(gamma, Number): if gamma <= 0: raise ValueError( "The step-sizes of SPDHG are positive, gamma should also be positive") - self._gamma = gamma + else: raise ValueError( "We currently only support scalar values of gamma") + if isinstance(rho, Number): + if rho <= 0: + raise ValueError( + "The step-sizes of SPDHG are positive, gamma should also be positive") - @property - def sigma(self): - return self._sigma + + else: + raise ValueError( + "We currently only support scalar values of gamma") + + self._sigma = [gamma * rho / ni for ni in self.norms] + + self._tau = min([pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)]) + self._tau *= (rho / gamma) + + + - def set_sigma(self, sigma=None): + def set_step_sizes_custom(self, sigma=None, tau=None): """ Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. Parameters ---------- sigma : list of positive float, optional, default=None List of Step size parameters for Dual problem + tau : positive float, optional, default=None + Step size parameter for Primal problem - The user can set these or default values are calculated. Values passed by the user will be accepted as long as they are positive numbers, - or correct shape array like objects. + The user can set these or default values are calculated, either sigma, tau, both or None can be passed. """ + gamma=1. + rho=.99 if sigma is not None: - for i in range(len(sigma)): - if isinstance(sigma[i], Number): - if sigma[i] <= 0: - raise ValueError( - "The step-sizes of SPDHG are positive, passed sigma = {}".format(sigma[i])) - if len(sigma) != self.operator.range_geometry().shape[0]: - raise ValueError(" The shape of sigma = {0} is not the same as the shape of the range_geometry = {1}".format( - len(sigma), self.operator.range_geometry().shape[0])) + if len(sigma==self.ndual_subsets): + if all(isinstance(x, Number) for x in sigma): + if all(x > 0 for x in sigma): + pass + else: + raise ValueError( + "The values of sigma should be positive") + else: + raise ValueError( + "The values of sigma should be a Number") + else: + raise ValueError( + "Please pass a list of floats to sigma with the same number of entries as number of operators") self._sigma = sigma - elif sigma is None: - self._sigma = [self._gamma * self.rho / ni for ni in self._norms] - - @property - def tau(self): - return self._tau - - def set_tau(self, tau=None): - """ Sets tau step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. - - Parameters - ---------- - tau : positive :obj:`float`, or `np.ndarray`, `DataContainer`, `BlockDataContainer`, optional, default=None - Step size for the primal problem. + elif tau is None: + self._sigma = [gamma * rho / ni for ni in self.norms] + else: + self._sigma= [gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] - The user can set either set these or instead the defaults are selected instead. Values passed by the user will be accepted as long as they are positive numbers, - or correct shape array like objects. - """ - if tau is not None: + if tau is None: + self._tau = min([pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)]) + self._tau *= (rho / gamma) + else: if isinstance(tau, Number): if tau <= 0: raise ValueError( "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) - elif tau.shape != self.operator.domain_geometry().shape: - raise ValueError(" The shape of tau = {0} is not the same as the shape of the domain_geometry = {1}".format( - tau.shape, self.operator.domain_geometry().shape)) - self._tau = tau - if tau is None: - self._tau = min([pi / (si * ni**2) for pi, ni, - si in zip(self._prob_weights, self._norms, self._sigma)]) - self._tau *= (self.rho / self.gamma) + else: + raise ValueError( + "The value of tau should be a Number") + self._tau=tau - def set_step_sizes_from_ratio(gamma=1, rho=0.99): #TODO: - pass - def set_step_sizes_custom(sigma=None, tau=None): #TODO: - pass + - def set_step_sizes_default(self): #TODO: Pass gamma, sigma, rho, tau to one function? - """ Sets default sigma and tau step-sizes for the SPDHG algorithm. This should be re-run after changing the sampler, norms, gamma or prob_weights. - Note - ---- - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem + - """ - self.set_sigma() - self.set_tau() + def check_convergence(self): # TODO: check this with someone else @@ -283,7 +236,7 @@ def check_convergence(self): """ for i in range(len(self._sigma)): if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): - if self._sigma[i] * self._tau * self._norms[i]**2 > self._prob_weights[i]**2: + if self._sigma[i] * self._tau * self.norms[i]**2 > self.prob_weights[i]: warnings.warn( "Convergence criterion of SPDHG for scalar step-sizes is not satisfied.") return False @@ -293,8 +246,8 @@ def check_convergence(self): "Convergence criterion currently can only be checked for scalar values of tau.") return False - def set_up(self, f, g, operator, tau=None, sigma=None, - initial=None, gamma=1., sampler=None, norms=None, rho=.99): + def set_up(self, f, g, operator, + initial=None, sampler=None, precalculated_norms=None): '''set-up of the algorithm Parameters ---------- @@ -314,10 +267,11 @@ def set_up(self, f, g, operator, tau=None, sigma=None, parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. - **kwargs: - norms : list of floats - precalculated list of norms of the operators #TODO: call it precalculated norms and add to argument list - rho : list of floats #TODO: Add to sigma and tau + precalculated_norms : list of floats + precalculated list of norms of the operators + + + @@ -329,14 +283,51 @@ def set_up(self, f, g, operator, tau=None, sigma=None, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - self.rho = rho + + + + if precalculated_norms is None: + # Compute norm of each sub-operator + self.norms = [self.operator.get_item(i, 0).norm() + for i in range(self.ndual_subsets)] + else: + if len(precalculated_norms==self.ndual_subsets): + if all(isinstance(x, Number) for x in precalculated_norms): + if all(x > 0 for x in precalculated_norms): + pass + else: + raise ValueError( + "The norms of the operators should be positive") + else: + raise ValueError( + "The norms of the operators should be a Number") + else: + raise ValueError( + "Please pass a list of floats to the precalculated norms with the same number of entries as number of operators") + self.norms=precalculated_norms + - - self.set_sampler(sampler) - self.set_gamma(gamma) - self.set_norms(norms) #passed or calculated by constructor - self.set_sigma(sigma) #might not want to do this until it is called (if computationally expensive) - self.set_tau(tau) + if sampler is None: + if self.prob_weights is None: + self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler = Sampler.randomWithReplacement( + self.ndual_subsets, prob=self.prob_weights) + else: + if not isinstance(sampler, Sampler): + raise ValueError( + "The sampler should be an instance of the CIL Sampler class") + self.sampler = sampler + if sampler.prob is None: + self.prob_weights=[1/self.ndual_subsets] * self.ndual_subsets + else: + self.prob_weights=sampler.prob + + + + + + self.set_step_sizes_custom() #might not want to do this until it is called (if computationally expensive) + # initialize primal variable if initial is None: @@ -365,7 +356,7 @@ def update(self): self.g.proximal(self.x_tmp, self._tau, out=self.x) # Choose subset - i = self._sampler.next() + i = self.sampler.next() # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x @@ -388,7 +379,7 @@ def update(self): # zbar = z + (theta/p[i]) * x_tmp self.z.sapyb(1., self.x_tmp, self.theta / - self._prob_weights[i], out=self.zbar) + self.prob_weights[i], out=self.zbar) # save previous iteration self.save_previous_iteration(i, y_k) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index ac5bdc75eb..5c8cf008f7 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -781,65 +781,87 @@ def setUp(self): self.G = alpha * FGP_TV() def test_SPDHG_defaults_and_setters(self): - + gamma=1. + rho=.99 spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - self.assertEqual(spdhg.gamma, 1.) - self.assertEqual(spdhg.rho, .99) + self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() for i in range(self.subsets)]) self.assertListEqual(spdhg.prob_weights, [1/self.subsets] * self.subsets) self.assertTrue(isinstance(spdhg.sampler, Sampler)) - self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) + self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(0).array) self.assertEqual(spdhg.max_iteration, 0) self.assertEqual(spdhg.update_objective_interval, 1) - spdhg.set_norms([1]*self.subsets) - spdhg.set_sampler(Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.))) - spdhg.set_gamma(10) - spdhg.reset_default_step_sizes() - - self.assertEqual(spdhg.gamma, 10) - self.assertEqual(spdhg.rho, .99) - self.assertListEqual(spdhg.norms, [1]*self.subsets) - self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) - self.assertTrue(isinstance(spdhg.sampler, Sampler)) - self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) + + + gamma=3.7 + rho=5.6 + self.set_step_sizes_from_ratio(gamma,rho) + self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - - spdhg.set_sigma([1]*self.subsets) - spdhg.set_tau(100) + + spdhg.set_step_sizes_custom() + self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + + spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, 100) + spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) + self.assertListEqual(spdhg.sigma, [1]*self.subsets) + self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) + + spdhg.set_step_sizes_custom(sigma=None, tau=100) + self.assertListEqual(spdhg.sigma, [gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)] ) + self.assertEqual(spdhg.tau, 100) + def test_spdhg_non_default_init(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, gamma=10, rho=.45, norms=[1]*self.subsets, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), - sigma=[1]*self.subsets, tau=100, initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) - self.assertEqual(spdhg.gamma, 10) - self.assertEqual(spdhg.rho, .45) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10, precalculated_norms=[5]*self.subsets ) + self.assertListEqual(spdhg.norms, [1]*self.subsets) self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) self.assertTrue(isinstance(spdhg.sampler, Sampler)) - self.assertListEqual(spdhg.sigma, [1]*self.subsets) - self.assertEqual(spdhg.tau, 100) self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) def test_spdhg_check_convergence(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, gamma=10, rho=.45, norms=[1]*self.subsets, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), - sigma=[1]*self.subsets, tau=10, initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - self.assertFalse(spdhg.check_convergence()) - spdhg.reset_default_step_sizes() self.assertTrue(spdhg.check_convergence()) + gamma=3.7 + rho=0.9 + self.set_step_sizes_from_ratio(gamma,rho) + self.assertTrue(spdhg.check_convergence()) + + gamma=3.7 + rho=100 + self.set_step_sizes_from_ratio(gamma,rho) + self.assertFalse(spdhg.check_convergence()) + + + + spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) + self.assertFalse(spdhg.check_convergence()) + + spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) + self.assertTrue(spdhg.check_convergence()) + + spdhg.set_step_sizes_custom(sigma=None, tau=100) + self.assertTrue(spdhg.check_convergence()) @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): From b35222f2d6da3081e5ecb9b63ce692d61d160b4d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Sep 2023 14:51:29 +0000 Subject: [PATCH 033/152] Updated tests --- .../Python/cil/optimisation/algorithms/SPDHG.py | 4 ++-- Wrappers/Python/test/test_algorithms.py | 16 ++++++++-------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 52408fb6e8..1bf77834ea 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -182,7 +182,7 @@ def set_step_sizes_custom(self, sigma=None, tau=None): gamma=1. rho=.99 if sigma is not None: - if len(sigma==self.ndual_subsets): + if len(sigma)==self.ndual_subsets: if all(isinstance(x, Number) for x in sigma): if all(x > 0 for x in sigma): pass @@ -291,7 +291,7 @@ def set_up(self, f, g, operator, self.norms = [self.operator.get_item(i, 0).norm() for i in range(self.ndual_subsets)] else: - if len(precalculated_norms==self.ndual_subsets): + if len(precalculated_norms)==self.ndual_subsets: if all(isinstance(x, Number) for x in precalculated_norms): if all(x > 0 for x in precalculated_norms): pass diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 5c8cf008f7..c93eabce07 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -799,14 +799,16 @@ def test_SPDHG_defaults_and_setters(self): + gamma=3.7 rho=5.6 - self.set_step_sizes_from_ratio(gamma,rho) + spdhg.set_step_sizes_from_ratio(gamma,rho) self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - + gamma=1. + rho=.99 spdhg.set_step_sizes_custom() self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, @@ -818,7 +820,7 @@ def test_SPDHG_defaults_and_setters(self): spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) - self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) spdhg.set_step_sizes_custom(sigma=None, tau=100) @@ -828,7 +830,7 @@ def test_SPDHG_defaults_and_setters(self): def test_spdhg_non_default_init(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10, precalculated_norms=[5]*self.subsets ) + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10, precalculated_norms=[1]*self.subsets ) self.assertListEqual(spdhg.norms, [1]*self.subsets) self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) @@ -844,15 +846,13 @@ def test_spdhg_check_convergence(self): gamma=3.7 rho=0.9 - self.set_step_sizes_from_ratio(gamma,rho) + spdhg.set_step_sizes_from_ratio(gamma,rho) self.assertTrue(spdhg.check_convergence()) gamma=3.7 rho=100 - self.set_step_sizes_from_ratio(gamma,rho) + spdhg.set_step_sizes_from_ratio(gamma,rho) self.assertFalse(spdhg.check_convergence()) - - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) self.assertFalse(spdhg.check_convergence()) From 6e552affbba6eddd25655b37533127676e474621 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Sep 2023 14:53:46 +0000 Subject: [PATCH 034/152] Just a commenting change --- .../cil/optimisation/algorithms/SPDHG.py | 93 +++++++------------ 1 file changed, 32 insertions(+), 61 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 1bf77834ea..62ba0675ad 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -49,7 +49,7 @@ class SPDHG(Algorithm): List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - + gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class @@ -57,7 +57,7 @@ class SPDHG(Algorithm): precalculated_norms : list of floats precalculated list of norms of the operators **kwargs: - + prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats @@ -105,9 +105,10 @@ def __init__(self, f=None, g=None, operator=None, self.prob_weights = kwargs.get('prob', None) if kwargs.get('norms', None) is not None: - warnings.warn('norms is being deprecated, pass instead precalculated_norms=your_custom_norms') + warnings.warn( + 'norms is being deprecated, pass instead precalculated_norms=your_custom_norms') if precalculated_norms is None: - precalculated_norms=kwargs.get('norms', None) + precalculated_norms = kwargs.get('norms', None) if self.prob_weights is not None: warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ @@ -115,21 +116,17 @@ def __init__(self, f=None, g=None, operator=None, if f is not None and operator is not None and g is not None: self.set_up(f=f, g=g, operator=operator, - initial=initial, sampler=sampler,precalculated_norms=precalculated_norms) - - - - + initial=initial, sampler=sampler, precalculated_norms=precalculated_norms) @property def sigma(self): return self._sigma - + @property def tau(self): return self._tau - - def set_step_sizes_from_ratio(self, gamma=1., rho=.99): + + def set_step_sizes_from_ratio(self, gamma=1., rho=.99): """ Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. Parameters @@ -144,7 +141,6 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): raise ValueError( "The step-sizes of SPDHG are positive, gamma should also be positive") - else: raise ValueError( "We currently only support scalar values of gamma") @@ -153,7 +149,6 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): raise ValueError( "The step-sizes of SPDHG are positive, gamma should also be positive") - else: raise ValueError( "We currently only support scalar values of gamma") @@ -161,13 +156,10 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): self._sigma = [gamma * rho / ni for ni in self.norms] self._tau = min([pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)]) + si in zip(self.prob_weights, self.norms, self._sigma)]) self._tau *= (rho / gamma) - - - - def set_step_sizes_custom(self, sigma=None, tau=None): + def set_step_sizes_custom(self, sigma=None, tau=None): """ Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. Parameters @@ -179,28 +171,29 @@ def set_step_sizes_custom(self, sigma=None, tau=None): The user can set these or default values are calculated, either sigma, tau, both or None can be passed. """ - gamma=1. - rho=.99 + gamma = 1. + rho = .99 if sigma is not None: - if len(sigma)==self.ndual_subsets: + if len(sigma) == self.ndual_subsets: if all(isinstance(x, Number) for x in sigma): if all(x > 0 for x in sigma): pass else: - raise ValueError( + raise ValueError( "The values of sigma should be positive") else: raise ValueError( - "The values of sigma should be a Number") + "The values of sigma should be a Number") else: raise ValueError( - "Please pass a list of floats to sigma with the same number of entries as number of operators") + "Please pass a list of floats to sigma with the same number of entries as number of operators") self._sigma = sigma elif tau is None: self._sigma = [gamma * rho / ni for ni in self.norms] else: - self._sigma= [gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] + self._sigma = [ + gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] if tau is None: self._tau = min([pi / (si * ni**2) for pi, ni, @@ -213,20 +206,11 @@ def set_step_sizes_custom(self, sigma=None, tau=None): "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) else: raise ValueError( - "The value of tau should be a Number") - self._tau=tau - - - - - - - - + "The value of tau should be a Number") + self._tau = tau def check_convergence(self): # TODO: check this with someone else - #TODO: Don't think this is working just at the moment """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma Returns @@ -246,7 +230,7 @@ def check_convergence(self): "Convergence criterion currently can only be checked for scalar values of tau.") return False - def set_up(self, f, g, operator, + def set_up(self, f, g, operator, initial=None, sampler=None, precalculated_norms=None): '''set-up of the algorithm Parameters @@ -269,12 +253,6 @@ def set_up(self, f, g, operator, Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. precalculated_norms : list of floats precalculated list of norms of the operators - - - - - - ''' logging.info("{} setting up".format(self.__class__.__name__, )) @@ -283,29 +261,26 @@ def set_up(self, f, g, operator, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - - if precalculated_norms is None: # Compute norm of each sub-operator self.norms = [self.operator.get_item(i, 0).norm() - for i in range(self.ndual_subsets)] + for i in range(self.ndual_subsets)] else: - if len(precalculated_norms)==self.ndual_subsets: + if len(precalculated_norms) == self.ndual_subsets: if all(isinstance(x, Number) for x in precalculated_norms): if all(x > 0 for x in precalculated_norms): pass else: - raise ValueError( + raise ValueError( "The norms of the operators should be positive") else: raise ValueError( - "The norms of the operators should be a Number") + "The norms of the operators should be a Number") else: raise ValueError( - "Please pass a list of floats to the precalculated norms with the same number of entries as number of operators") - self.norms=precalculated_norms - + "Please pass a list of floats to the precalculated norms with the same number of entries as number of operators") + self.norms = precalculated_norms if sampler is None: if self.prob_weights is None: @@ -318,16 +293,12 @@ def set_up(self, f, g, operator, "The sampler should be an instance of the CIL Sampler class") self.sampler = sampler if sampler.prob is None: - self.prob_weights=[1/self.ndual_subsets] * self.ndual_subsets + self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets else: - self.prob_weights=sampler.prob - - - + self.prob_weights = sampler.prob - - self.set_step_sizes_custom() #might not want to do this until it is called (if computationally expensive) - + # might not want to do this until it is called (if computationally expensive) + self.set_step_sizes_custom() # initialize primal variable if initial is None: From 4ae9b3cbd6edc3cbaa50ce379f842709401c1d66 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 28 Sep 2023 14:04:40 +0000 Subject: [PATCH 035/152] Tiny changes --- .../functions/ApproximateGradientSumFunction.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 944d40ec6a..686e2c75a4 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -34,13 +34,13 @@ class ApproximateGradientSumFunction(SumFunction): ----------- functions : list(functions) A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. - sampler: MORE HERE!!!!!!!!!!! + sampler: TODO: Note ---- The :meth:`~ApproximateGradientSumFunction.gradient` computes the `gradient` of only one function of a batch of functions - depending on the :code:`sampler` method. The selected function(s) is the :meth:`~SubsetSumFunction.next_subset` method. + depending on the :code:`sampler` method. Example ------- @@ -139,7 +139,7 @@ def gradient(self, x, out=None): if isinstance(self.function_num, numbers.Number): return self.approximate_gradient(self.function_num, x, out=out) else: - raise ValueError("Batch gradient is not implemented") + raise ValueError("Batch gradient is not yet implemented") def next_function(self): From 6575af60892c28ccb4d378d9f6c4da45760aa738 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 28 Sep 2023 16:23:58 +0000 Subject: [PATCH 036/152] Initial changes and tests- currently failing tests --- .../optimisation/operators/BlockOperator.py | 52 +++++++++++------ Wrappers/Python/test/test_BlockOperator.py | 58 ++++++++++++++++++- 2 files changed, 92 insertions(+), 18 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 79d4851059..f1374516fe 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -19,6 +19,7 @@ import numpy import functools +from numbers import Number from cil.framework import ImageData, BlockDataContainer, DataContainer from cil.optimisation.operators import Operator, LinearOperator from cil.framework import BlockGeometry @@ -135,26 +136,43 @@ def get_item(self, row, col): index = row*self.shape[1]+col return self.operators[index] - def norm(self, **kwargs): - '''Returns the norm of the BlockOperator - - if the operator in the block do not have method norm defined, i.e. they are SIRF - AcquisitionModel's we use PowerMethod if applicable, otherwise we raise an Error + def norm(self): + '''Returns the square root of the sum of the norms of the individual operators in the BlockOperators + ''' + return numpy.sqrt(numpy.sum(numpy.array(self.norms())**2)) + + def norms(self, ): + '''Returns a list of the individual norms of the Operators in the BlockOperator ''' - norm = [] + norms= [] for op in self.operators: - if hasattr(op, 'norm'): - norm.append(op.norm(**kwargs) ** 2.) - else: - # use Power method - if op.is_linear(): - norm.append( - LinearOperator.PowerMethod(op, 20)[0] - ) - else: - raise TypeError('Operator {} does not have a norm method and is not linear'.format(op)) - return numpy.sqrt(sum(norm)) + try: + norms.append(op.norm()) + except: + raise TypeError('Operator {} does not have a norm method'.format(op)) + return norms + def set_norms(self, norms): + '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. + + + ''' + if len(norms)==len(self.operators): + if all(isinstance(i, Number) for i in norms): + if all( i>=0 for i in norms ): + pass + else: + raise ValueError("Each number in the list should be positive") + else: + raise ValueError("Each element in the list of norms should be a number") + else: + raise ValueError("The length of the list of norms should be equal to the number of operators in the BlockOperator") + + for i,value in enumerate(norms): + self.operators[i].set_norm(value) + + + def direct(self, x, out=None): '''Direct operation for the BlockOperator diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 3e81ab4cad..5d59e20969 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -20,7 +20,7 @@ import unittest from utils import initialise_tests import logging -from cil.optimisation.operators import BlockOperator +from cil.optimisation.operators import BlockOperator, GradientOperator from cil.framework import BlockDataContainer from cil.optimisation.operators import IdentityOperator from cil.framework import ImageGeometry, ImageData @@ -30,6 +30,62 @@ initialise_tests() class TestBlockOperator(unittest.TestCase): + def test_norms(self): + numpy.random.seed(1) + N, M = 200, 300 + + ig = ImageGeometry(N, M) + G = GradientOperator(ig) + G.norm() + A=BlockOperator(G,G) + + + #calculates norm + self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) + self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) + + + #sets_norm + A.set_norms([2,3]) + #gets cached norm + self.assertAlmostEqual(A.norms()[0], 2, 2) + self.assertAlmostEqual(A.norms()[1], 3, 2) + self.assertEqual(A.norm(), numpy.sqrt(13)) + + + #Check that it changes the underlying operators + self.assertEqual(A.operators[0]._norm, 2) + self.assertEqual(A.operators[1]._norm, 3) + + #sets cache to None + A.set_norms([None, None]) + #recalculates norm + self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) + self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) + + #Check the warnings on set_norms + try: + A.set_norms([1]) + except ValueError: + pass + else: + self.assertTrue(False) + try: + A.set_norms(['Banana', 'Apple']) + except ValueError: + pass + else: + self.assertTrue(False) + try: + A.set_norms([-1,-3]) + except ValueError: + pass + else: + self.assertTrue(False) + + def test_BlockOperator(self): ig = [ ImageGeometry(10,20,30) , \ From 6b463bc718667ca4c4b88fed0ef9721d2a562cd5 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 2 Oct 2023 10:01:53 +0000 Subject: [PATCH 037/152] Sorted tests and checks on the set_norms function --- .../cil/optimisation/operators/BlockOperator.py | 10 +++++----- Wrappers/Python/test/test_BlockOperator.py | 11 +++++++---- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index f1374516fe..594d2140b6 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -158,18 +158,18 @@ def set_norms(self, norms): ''' if len(norms)==len(self.operators): - if all(isinstance(i, Number) for i in norms): - if all( i>=0 for i in norms ): + if all(isinstance(i, Number) or i is None for i in norms): + if all( k is None or k>=0 for k in norms ): pass else: raise ValueError("Each number in the list should be positive") else: - raise ValueError("Each element in the list of norms should be a number") + raise ValueError("Each element in the list of norms should be a number or None") else: raise ValueError("The length of the list of norms should be equal to the number of operators in the BlockOperator") - for i,value in enumerate(norms): - self.operators[i].set_norm(value) + for j,value in enumerate(norms): + self.operators[j].set_norm(value) diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 5d59e20969..5e308aaf41 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -36,8 +36,9 @@ def test_norms(self): ig = ImageGeometry(N, M) G = GradientOperator(ig) + G2 = GradientOperator(ig) G.norm() - A=BlockOperator(G,G) + A=BlockOperator(G,G2) #calculates norm @@ -47,10 +48,9 @@ def test_norms(self): #sets_norm - A.set_norms([2,3]) + A.set_norms([2,3]) #FIXME: ISSUE HERE!!! #gets cached norm - self.assertAlmostEqual(A.norms()[0], 2, 2) - self.assertAlmostEqual(A.norms()[1], 3, 2) + self.assertListEqual(A.norms(), [2,3], 2) self.assertEqual(A.norm(), numpy.sqrt(13)) @@ -66,18 +66,21 @@ def test_norms(self): self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) #Check the warnings on set_norms + #Check the length of list that is passed try: A.set_norms([1]) except ValueError: pass else: self.assertTrue(False) + #Check that elements in the list are numbers or None try: A.set_norms(['Banana', 'Apple']) except ValueError: pass else: self.assertTrue(False) + #Check that numbers in the list are positive try: A.set_norms([-1,-3]) except ValueError: From 215bfa644819d2142e73da95db8d72c61d739b53 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 2 Oct 2023 10:04:13 +0000 Subject: [PATCH 038/152] Changed a comment --- Wrappers/Python/test/test_BlockOperator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 5e308aaf41..909b49d4a4 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -48,7 +48,7 @@ def test_norms(self): #sets_norm - A.set_norms([2,3]) #FIXME: ISSUE HERE!!! + A.set_norms([2,3]) #gets cached norm self.assertListEqual(A.norms(), [2,3], 2) self.assertEqual(A.norm(), numpy.sqrt(13)) From 3898a038dd3250cba12423f17f4b024cb3ccae91 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 4 Oct 2023 15:00:27 +0000 Subject: [PATCH 039/152] Removed reference to dask --- .../ApproximateGradientSumFunction.py | 122 +++++------------- .../cil/optimisation/functions/SGFunction.py | 5 +- 2 files changed, 31 insertions(+), 96 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 686e2c75a4..1f682dce7e 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -18,30 +18,31 @@ # CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt - from cil.optimisation.functions import SumFunction import numbers + + class ApproximateGradientSumFunction(SumFunction): r"""ApproximateGradientSumFunction represents the following sum - + .. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) where :math:`n` is the number of functions. Parameters: ----------- - functions : list(functions) + functions : list(functions) #TODO: do we want this to be a list of functions or a BlockFunction? Perhaps it could be a list here and a BlockFunction for SGFunction? A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. - sampler: TODO: + sampler: An instance of the :meth:`~framework.sampler` class which has a next function which gives the next subset to calculate the gradient for. Note ---- - + The :meth:`~ApproximateGradientSumFunction.gradient` computes the `gradient` of only one function of a batch of functions depending on the :code:`sampler` method. - + Example ------- @@ -53,110 +54,47 @@ class ApproximateGradientSumFunction(SumFunction): >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) >>> sampler = RandomSampling.random_shuffle(len(list_of_functions)) >>> f = ApproximateGradientSumFunction(list_of_functions, sampler=sampler) - + """ - - def __init__(self, functions, sampler=None, data_passes=None, initial=None, dask=False): - + + def __init__(self, functions, sampler=None, initial=None): + if sampler is None: raise NotImplementedError else: self.sampler = sampler - self.functions_used = [] - self.data_passes = data_passes - self.initial = initial - self._dask = dask - self.num_functions=len(functions) - - try: - import dask - self._dask_available = True - self._module = dask - except ImportError: - print("Dask is not installed.") - self._dask_available = False - - super(ApproximateGradientSumFunction, self).__init__(*functions) - - @property - def dask(self): - return self._dask - - @dask.setter - def dask(self, value): - if self._dask_available: - self._dask = value - else: - print("Dask is not installed.") + self.functions_used = [] + self.num_functions = len(functions) + + super(ApproximateGradientSumFunction, self).__init__(*functions) def __call__(self, x): - if self.dask: - return self._call_parallel(x) - else: - r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ - return super(ApproximateGradientSumFunction, self).__call__(x) - - def _call_parallel(self, x): - res = [] - for f in self.functions: - res.append(self._module.delayed(f)(x)) - return sum(self._module.compute(*res)) - - def _gradient_parallel(self, x, out): - - res = [] - for f in self.functions: - res.append(self._module.delayed(f.gradient)(x)) - tmp = self._module.compute(*res) - - if out is None: - return sum(tmp) - else: - out.fill(sum(tmp)) - + r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ + return super(ApproximateGradientSumFunction, self).__call__(x) + def full_gradient(self, x, out=None): + r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ + return super(ApproximateGradientSumFunction, self).gradient(x, out=out) - if self.dask: - return self._gradient_parallel(x, out=out) - else: - r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ - return super(ApproximateGradientSumFunction, self).gradient(x, out=out) - - def approximate_gradient(self, function_num, x, out=None): - - """ Computes the approximate gradient for each selected function at :code:`x`.""" + """ Computes the approximate gradient for each selected function at :code:`x`.""" raise NotImplemented - - def gradient(self, x, out=None): - """ Computes the gradient for each selected function at :code:`x`.""" - self.next_function() + def gradient(self, x, out=None): + """ Computes the gradient for each selected function at :code:`x`.""" + self.next_function() - # single function - if isinstance(self.function_num, numbers.Number): + # single function + if isinstance(self.function_num, numbers.Number): return self.approximate_gradient(self.function_num, x, out=out) - else: + else: raise ValueError("Batch gradient is not yet implemented") - + def next_function(self): - - """ Selects the next function or the next batch of functions from the list of :code:`functions` using the :code:`sampler`.""" + """ Selects the next subset from the list of :code:`functions` using the :code:`sampler`.""" self.function_num = self.sampler.next() - + # append each function used at this iteration self.functions_used.append(self.function_num) - - def allocate_memory(self): - - raise NotImplementedError - - def update_memory(self): - - raise NotImplementedError - - def free_memory(self): - - raise NotImplementedError \ No newline at end of file diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index ac78e3e984..a5a3cf6f24 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -52,10 +52,7 @@ def approximate_gradient(self, function_num, x, out=None): self.functions[function_num].gradient(x, out = out) # scale wrt number of functions - out*=self.num_functions # FIXME: Is this the scaling that we need? - - # update data passes - self.data_passes.append(round(self.data_passes[-1] + 1./self.num_functions,4)) # FIXME: What is this used for? + out*=self.num_functions # TODO: need to document this decision somewhere if should_return: return out From b946d79d705600fde1c4d42fc09dfef75f7ee93d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 5 Oct 2023 12:44:50 +0000 Subject: [PATCH 040/152] Bug fixes --- Wrappers/Python/cil/optimisation/functions/SGFunction.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index a5a3cf6f24..b32d878b48 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -24,7 +24,7 @@ class SGFunction(ApproximateGradientSumFunction): Parameters: ---------- - functions: list + functions: list #TODO: should this be a list of functions or a block function?? A list of functions. sampler: callable or None, optional A callable object that selects the function or batch of functions to compute the gradient. TODO: If None, a random function will be selected. @@ -33,7 +33,7 @@ class SGFunction(ApproximateGradientSumFunction): def __init__(self, functions, sampler=None): - super(SGFunction, self).__init__(functions, sampler, data_passes=[0.]) + super(SGFunction, self).__init__(functions, sampler) def approximate_gradient(self, function_num, x, out=None): From 96e47304fb1fe9e3cd9e4a4eb7bfe3ab93732f96 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 5 Oct 2023 13:30:29 +0000 Subject: [PATCH 041/152] Changes based on Gemma's review --- .../optimisation/operators/BlockOperator.py | 17 +++----------- .../cil/optimisation/operators/Operator.py | 7 ++++++ Wrappers/Python/test/test_BlockOperator.py | 23 ++++++------------- Wrappers/Python/test/test_Operator.py | 7 ++++++ 4 files changed, 24 insertions(+), 30 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 594d2140b6..3ed59a719b 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -146,25 +146,14 @@ def norms(self, ): ''' norms= [] for op in self.operators: - try: - norms.append(op.norm()) - except: - raise TypeError('Operator {} does not have a norm method'.format(op)) + norms.append(op.norm()) return norms def set_norms(self, norms): '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. - - ''' - if len(norms)==len(self.operators): - if all(isinstance(i, Number) or i is None for i in norms): - if all( k is None or k>=0 for k in norms ): - pass - else: - raise ValueError("Each number in the list should be positive") - else: - raise ValueError("Each element in the list of norms should be a number or None") + if len(norms)==len(self): + pass else: raise ValueError("The length of the list of norms should be equal to the number of operators in the BlockOperator") diff --git a/Wrappers/Python/cil/optimisation/operators/Operator.py b/Wrappers/Python/cil/optimisation/operators/Operator.py index cc2eb44bb4..23f2cb6f46 100644 --- a/Wrappers/Python/cil/optimisation/operators/Operator.py +++ b/Wrappers/Python/cil/optimisation/operators/Operator.py @@ -71,6 +71,13 @@ def norm(self, **kwargs): def set_norm(self,norm=None): '''Sets the norm of the operator to a custom value. ''' + try: + if norm is not None and norm <=0: + raise ValueError("Norm must be a positive real value or None, got {}".format(norm)) + except TypeError: + raise TypeError("Norm must be a positive real value or None, got {} of type {}".format(norm, type(norm))) + + self._norm = norm def calculate_norm(self): diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 909b49d4a4..bdcf297196 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -37,11 +37,13 @@ def test_norms(self): ig = ImageGeometry(N, M) G = GradientOperator(ig) G2 = GradientOperator(ig) - G.norm() + A=BlockOperator(G,G2) #calculates norm + self.assertAlmostEqual(G.norm(), numpy.sqrt(8), 2) + self.assertAlmostEqual(G2.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) @@ -67,26 +69,15 @@ def test_norms(self): #Check the warnings on set_norms #Check the length of list that is passed - try: + with self.assertRaises(ValueError): A.set_norms([1]) - except ValueError: - pass - else: - self.assertTrue(False) #Check that elements in the list are numbers or None - try: + with self.assertRaises(TypeError): A.set_norms(['Banana', 'Apple']) - except ValueError: - pass - else: - self.assertTrue(False) #Check that numbers in the list are positive - try: + with self.assertRaises(ValueError): A.set_norms([-1,-3]) - except ValueError: - pass - else: - self.assertTrue(False) + diff --git a/Wrappers/Python/test/test_Operator.py b/Wrappers/Python/test/test_Operator.py index 78d7e30c8c..012e4a58be 100644 --- a/Wrappers/Python/test/test_Operator.py +++ b/Wrappers/Python/test/test_Operator.py @@ -347,6 +347,13 @@ def test_Norm(self): #recalculates norm self.assertAlmostEqual(G.norm(), numpy.sqrt(8), 2) + + #Check that the provided element is a number or None + with self.assertRaises(TypeError): + G.set_norm['Banana'] + #Check that the provided norm is positive + with self.assertRaises(ValueError): + G.set_norm(-1) def test_ProjectionMap(self): # Check if direct is correct From 3c36f3f75cbd19874e2c8d7fcf19f038c9475721 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 9 Oct 2023 08:46:35 +0000 Subject: [PATCH 042/152] Small changes --- .../ApproximateGradientSumFunction.py | 4 +- Wrappers/Python/test/test_functions.py | 57 ++++++++++++++++++- 2 files changed, 55 insertions(+), 6 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 1f682dce7e..074ed5ccfb 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -65,7 +65,6 @@ def __init__(self, functions, sampler=None, initial=None): else: self.sampler = sampler - self.functions_used = [] self.num_functions = len(functions) super(ApproximateGradientSumFunction, self).__init__(*functions) @@ -96,5 +95,4 @@ def next_function(self): """ Selects the next subset from the list of :code:`functions` using the :code:`sampler`.""" self.function_num = self.sampler.next() - # append each function used at this iteration - self.functions_used.append(self.function_num) + diff --git a/Wrappers/Python/test/test_functions.py b/Wrappers/Python/test/test_functions.py index 082779a9b8..3a480f1820 100644 --- a/Wrappers/Python/test/test_functions.py +++ b/Wrappers/Python/test/test_functions.py @@ -23,10 +23,10 @@ import numpy as np from cil.framework import DataContainer, ImageGeometry, \ - VectorGeometry, VectorData, BlockDataContainer + VectorGeometry, VectorData, BlockDataContainer, AcquisitionData, AcquisitionGeometry from cil.optimisation.operators import IdentityOperator, MatrixOperator, CompositionOperator, DiagonalOperator, BlockOperator from cil.optimisation.functions import Function, KullbackLeibler, ConstantFunction, TranslateFunction -from cil.optimisation.operators import GradientOperator +from cil.optimisation.operators import GradientOperator, BlockOperator from cil.optimisation.functions import Function, KullbackLeibler, WeightedL2NormSquared, L2NormSquared,\ L1Norm, MixedL21Norm, LeastSquares, \ @@ -34,6 +34,9 @@ Rosenbrock, IndicatorBox, TotalVariation from cil.optimisation.functions import BlockFunction + + + import numpy import scipy.special @@ -48,8 +51,9 @@ from cil.utilities.quality_measures import mae import cil.utilities.multiprocessing as cilmp -from utils import has_ccpi_regularisation, has_tomophantom, has_numba, initialise_tests +from utils import has_ccpi_regularisation, has_tomophantom, has_numba, has_astra, initialise_tests import numba +from testclass import CCPiTestClass initialise_tests() @@ -62,6 +66,52 @@ if has_numba: from cil.optimisation.functions.MixedL21Norm import _proximal_step_numba, _proximal_step_numpy +if has_astra: + from cil.plugins.astra import ProjectionOperator + +class TestApproxGradientSumFunction(CCPiTestClass): + def setUp(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + + ig = data.geometry + ig.voxel_size_x = 0.1 + ig.voxel_size_y = 0.1 + + detectors = ig.shape[0] + angles = np.linspace(0, np.pi, 90) + ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + Aop = ProjectionOperator(ig, ag, 'cpu') + #Create noisy data + sin = Aop.direct(data) + noisy_data = ag.allocate() + np.random.seed(10) + n1 = np.random.normal(0, 0.1, size = ag.shape) + noisy_data.fill(n1 + sin.as_array()) + + subsets = 5 + size_of_subsets = int(len(angles)/subsets) + # take angles and create uniform subsets in uniform+sequential setting + list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] + # create acquisition geometries for each the interval of splitting angles + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] + # create with operators as many as the subsets + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], 'cpu') for i in range(subsets)]) + AD_list = [] + for sub_num in range(subsets): + for i in range(0, len(angles), size_of_subsets): + arr = noisy_data.as_array()[i:i+size_of_subsets,:] + AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) + + g = BlockDataContainer(*AD_list) + + ## block function + self.F = BlockFunction(*[KullbackLeibler(b=g[i]) for i in range(subsets)]) + + + def test_set_up(self): + pass + class TestFunction(CCPiTestClass): @@ -1799,3 +1849,4 @@ def test_set_num_threads(self): N = 10 ib.set_num_threads(N) assert ib.num_threads == N + From 1ca3a2b599a218cddc4c85b332000a56f154349d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 9 Oct 2023 08:52:49 +0000 Subject: [PATCH 043/152] Comments from Edo fixed --- .../optimisation/operators/BlockOperator.py | 240 +++++++++--------- 1 file changed, 122 insertions(+), 118 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 3ed59a719b..2309dc1b37 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -29,7 +29,8 @@ has_sirf = True except ImportError as ie: has_sirf = False - + + class BlockOperator(Operator): r'''A Block matrix containing Operators @@ -37,21 +38,22 @@ class BlockOperator(Operator): following form: .. math:: - + \min Regulariser + Fidelity - + BlockOperators have a generic shape M x N, and when applied on an Nx1 BlockDataContainer, will yield and Mx1 BlockDataContainer. Notice: BlockDatacontainer are only allowed to have the shape of N x 1, with N rows and 1 column. - + User may specify the shape of the block, by default is a row vector Operators in a Block are required to have the same domain column-wise and the same range row-wise. ''' __array_priority__ = 1 + def __init__(self, *args, **kwargs): ''' Class creator @@ -64,7 +66,7 @@ def __init__(self, *args, **kwargs): :param: shape (:obj:`tuple`, optional): If shape is passed the Operators in vararg are considered input in a row-by-row fashion. Shape and number of Operators must match. - + Example: BlockOperator(op0,op1) results in a row block BlockOperator(op0,op1,shape=(1,2)) results in a column block @@ -72,95 +74,91 @@ def __init__(self, *args, **kwargs): self.operators = args shape = kwargs.get('shape', None) if shape is None: - shape = (len(args),1) + shape = (len(args), 1) self.shape = shape - n_elements = functools.reduce(lambda x,y: x*y, shape, 1) + n_elements = functools.reduce(lambda x, y: x*y, shape, 1) if len(args) != n_elements: raise ValueError( - 'Dimension and size do not match: expected {} got {}' - .format(n_elements,len(args))) + 'Dimension and size do not match: expected {} got {}' + .format(n_elements, len(args))) # TODO # until a decent way to check equality of Acquisition/Image geometries - # required to fullfil "Operators in a Block are required to have the same + # required to fullfil "Operators in a Block are required to have the same # domain column-wise and the same range row-wise." - # let us just not check if column/row-wise compatible, which is actually + # let us just not check if column/row-wise compatible, which is actually # the same achieved by the column_wise_compatible and row_wise_compatible methods. - + # # test if operators are compatible # if not self.column_wise_compatible(): # raise ValueError('Operators in each column must have the same domain') # if not self.row_wise_compatible(): # raise ValueError('Operators in each row must have the same range') - + def column_wise_compatible(self): '''Operators in a Block should have the same domain per column''' rows, cols = self.shape compatible = True for col in range(cols): column_compatible = True - for row in range(1,rows): - dg0 = self.get_item(row-1,col).domain_geometry() - dg1 = self.get_item(row,col).domain_geometry() - if hasattr(dg0,'handle') and hasattr(dg1,'handle'): + for row in range(1, rows): + dg0 = self.get_item(row-1, col).domain_geometry() + dg1 = self.get_item(row, col).domain_geometry() + if hasattr(dg0, 'handle') and hasattr(dg1, 'handle'): column_compatible = True and column_compatible else: column_compatible = dg0.__dict__ == dg1.__dict__ and column_compatible compatible = compatible and column_compatible return compatible - + def row_wise_compatible(self): '''Operators in a Block should have the same range per row''' rows, cols = self.shape compatible = True for row in range(rows): row_compatible = True - for col in range(1,cols): - dg0 = self.get_item(row,col-1).range_geometry() - dg1 = self.get_item(row,col).range_geometry() - if hasattr(dg0,'handle') and hasattr(dg1,'handle'): + for col in range(1, cols): + dg0 = self.get_item(row, col-1).range_geometry() + dg1 = self.get_item(row, col).range_geometry() + if hasattr(dg0, 'handle') and hasattr(dg1, 'handle'): row_compatible = True and column_compatible else: row_compatible = dg0.__dict__ == dg1.__dict__ and row_compatible - + compatible = compatible and row_compatible - + return compatible def get_item(self, row, col): '''returns the Operator at specified row and col''' if row > self.shape[0]: - raise ValueError('Requested row {} > max {}'.format(row, self.shape[0])) + raise ValueError( + 'Requested row {} > max {}'.format(row, self.shape[0])) if col > self.shape[1]: - raise ValueError('Requested col {} > max {}'.format(col, self.shape[1])) - + raise ValueError( + 'Requested col {} > max {}'.format(col, self.shape[1])) + index = row*self.shape[1]+col return self.operators[index] - + def norm(self): '''Returns the square root of the sum of the norms of the individual operators in the BlockOperators ''' - return numpy.sqrt(numpy.sum(numpy.array(self.norms())**2)) - - def norms(self, ): + return numpy.sqrt(numpy.sum(numpy.array(self.get_norms())**2)) + + def get_norms(self, ): '''Returns a list of the individual norms of the Operators in the BlockOperator ''' - norms= [] - for op in self.operators: - norms.append(op.norm()) - return norms - + return [op.norm() for op in self.operators] + def set_norms(self, norms): '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. ''' - if len(norms)==len(self): - pass - else: - raise ValueError("The length of the list of norms should be equal to the number of operators in the BlockOperator") - - for j,value in enumerate(norms): - self.operators[j].set_norm(value) - + if len(norms) != len(self): + raise ValueError( + "The length of the list of norms should be equal to the number of operators in the BlockOperator") + for j, value in enumerate(norms): + self.operators[j].set_norm(value) def direct(self, x, out=None): '''Direct operation for the BlockOperator @@ -168,41 +166,43 @@ def direct(self, x, out=None): BlockOperator work on BlockDataContainer, but they will work on DataContainers and inherited classes by simple wrapping the input in a BlockDataContainer of shape (1,1) ''' - - if not isinstance (x, BlockDataContainer): + + if not isinstance(x, BlockDataContainer): x_b = BlockDataContainer(x) else: x_b = x shape = self.get_output_shape(x_b.shape) res = [] - + if out is None: - + for row in range(self.shape[0]): for col in range(self.shape[1]): if col == 0: - prod = self.get_item(row,col).direct(x_b.get_item(col)) + prod = self.get_item(row, col).direct( + x_b.get_item(col)) else: - prod += self.get_item(row,col).direct(x_b.get_item(col)) + prod += self.get_item(row, + col).direct(x_b.get_item(col)) res.append(prod) return BlockDataContainer(*res, shape=shape) - + else: - + tmp = self.range_geometry().allocate() for row in range(self.shape[0]): for col in range(self.shape[1]): - if col == 0: - self.get_item(row,col).direct( - x_b.get_item(col), - out=out.get_item(row)) + if col == 0: + self.get_item(row, col).direct( + x_b.get_item(col), + out=out.get_item(row)) else: a = out.get_item(row) - self.get_item(row,col).direct( - x_b.get_item(col), - out=tmp.get_item(row)) + self.get_item(row, col).direct( + x_b.get_item(col), + out=tmp.get_item(row)) a += tmp.get_item(row) - + def adjoint(self, x, out=None): '''Adjoint operation for the BlockOperator @@ -217,7 +217,7 @@ def adjoint(self, x, out=None): ''' if not self.is_linear(): raise ValueError('Not all operators in Block are linear.') - if not isinstance (x, BlockDataContainer): + if not isinstance(x, BlockDataContainer): x_b = BlockDataContainer(x) else: x_b = x @@ -227,11 +227,13 @@ def adjoint(self, x, out=None): for col in range(self.shape[1]): for row in range(self.shape[0]): if row == 0: - prod = self.get_item(row, col).adjoint(x_b.get_item(row)) + prod = self.get_item(row, col).adjoint( + x_b.get_item(row)) else: - prod += self.get_item(row, col).adjoint(x_b.get_item(row)) + prod += self.get_item(row, + col).adjoint(x_b.get_item(row)) res.append(prod) - if self.shape[1]==1: + if self.shape[1] == 1: # the output is a single DataContainer, so we can take it out return res[0] else: @@ -242,74 +244,80 @@ def adjoint(self, x, out=None): for row in range(self.shape[0]): if row == 0: if issubclass(out.__class__, DataContainer) or \ - ( has_sirf and issubclass(out.__class__, SIRFDataContainer) ): + (has_sirf and issubclass(out.__class__, SIRFDataContainer)): self.get_item(row, col).adjoint( - x_b.get_item(row), - out=out) + x_b.get_item(row), + out=out) else: - op = self.get_item(row,col) + op = self.get_item(row, col) self.get_item(row, col).adjoint( - x_b.get_item(row), - out=out.get_item(col)) + x_b.get_item(row), + out=out.get_item(col)) else: if issubclass(out.__class__, DataContainer) or \ - ( has_sirf and issubclass(out.__class__, SIRFDataContainer) ): - out += self.get_item(row,col).adjoint( - x_b.get_item(row)) + (has_sirf and issubclass(out.__class__, SIRFDataContainer)): + out += self.get_item(row, col).adjoint( + x_b.get_item(row)) else: a = out.get_item(col) - a += self.get_item(row,col).adjoint( - x_b.get_item(row), - ) + a += self.get_item(row, col).adjoint( + x_b.get_item(row), + ) + def is_linear(self): '''returns whether all the elements of the BlockOperator are linear''' return functools.reduce(lambda x, y: x and y.is_linear(), self.operators, True) def get_output_shape(self, xshape, adjoint=False): '''returns the shape of the output BlockDataContainer - + A(N,M) direct u(M,1) -> N,1 A(N,M)^T adjoint u(N,1) -> M,1 ''' - rows , cols = self.shape + rows, cols = self.shape xrows, xcols = xshape if xcols != 1: - raise ValueError('BlockDataContainer cannot have more than 1 column') + raise ValueError( + 'BlockDataContainer cannot have more than 1 column') if adjoint: if rows != xrows: - raise ValueError('Incompatible shapes {} {}'.format(self.shape, xshape)) - return (cols,xcols) + raise ValueError( + 'Incompatible shapes {} {}'.format(self.shape, xshape)) + return (cols, xcols) if cols != xrows: - raise ValueError('Incompatible shapes {} {}'.format((rows,cols), xshape)) - return (rows,xcols) - + raise ValueError( + 'Incompatible shapes {} {}'.format((rows, cols), xshape)) + return (rows, xcols) + def __rmul__(self, scalar): '''Defines the left multiplication with a scalar :paramer scalar: (number or iterable containing numbers): Returns: a block operator with Scaled Operators inside''' - if isinstance (scalar, list) or isinstance(scalar, tuple) or \ + if isinstance(scalar, list) or isinstance(scalar, tuple) or \ isinstance(scalar, numpy.ndarray): if len(scalar) != len(self.operators): - raise ValueError('dimensions of scalars and operators do not match') + raise ValueError( + 'dimensions of scalars and operators do not match') scalars = scalar else: scalars = [scalar for _ in self.operators] # create a list of ScaledOperator-s - ops = [ v * op for v,op in zip(scalars, self.operators)] - #return BlockScaledOperator(self, scalars ,shape=self.shape) + ops = [v * op for v, op in zip(scalars, self.operators)] + # return BlockScaledOperator(self, scalars ,shape=self.shape) return type(self)(*ops, shape=self.shape) + @property def T(self): '''Return the transposed of self - + input in a row-by-row''' newshape = (self.shape[1], self.shape[0]) oplist = [] for col in range(newshape[1]): for row in range(newshape[0]): - oplist.append(self.get_item(col,row)) + oplist.append(self.get_item(col, row)) return type(self)(*oplist, shape=newshape) def domain_geometry(self): @@ -320,51 +328,50 @@ def domain_geometry(self): ''' if self.shape[1] == 1: # column BlockOperator - return self.get_item(0,0).domain_geometry() + return self.get_item(0, 0).domain_geometry() else: # get the geometries column wise # we need only the geometries from the first row # since it is compatible from __init__ tmp = [] for i in range(self.shape[1]): - tmp.append(self.get_item(0,i).domain_geometry()) - return BlockGeometry(*tmp) - - #shape = (self.shape[0], 1) - #return BlockGeometry(*[el.domain_geometry() for el in self.operators], + tmp.append(self.get_item(0, i).domain_geometry()) + return BlockGeometry(*tmp) + + # shape = (self.shape[0], 1) + # return BlockGeometry(*[el.domain_geometry() for el in self.operators], # shape=self.shape) def range_geometry(self): '''returns the range of the BlockOperator''' - + tmp = [] for i in range(self.shape[0]): - tmp.append(self.get_item(i,0).range_geometry()) - return BlockGeometry(*tmp) - - - #shape = (self.shape[1], 1) - #return BlockGeometry(*[el.range_geometry() for el in self.operators], + tmp.append(self.get_item(i, 0).range_geometry()) + return BlockGeometry(*tmp) + + # shape = (self.shape[1], 1) + # return BlockGeometry(*[el.range_geometry() for el in self.operators], # shape=shape) - + def sum_abs_row(self): - + res = [] for row in range(self.shape[0]): - for col in range(self.shape[1]): + for col in range(self.shape[1]): if col == 0: - prod = self.get_item(row,col).sum_abs_row() + prod = self.get_item(row, col).sum_abs_row() else: - prod += self.get_item(row,col).sum_abs_row() + prod += self.get_item(row, col).sum_abs_row() res.append(prod) - - if self.shape[1]==1: + + if self.shape[1] == 1: tmp = sum(res) return ImageData(tmp) else: - + return BlockDataContainer(*res) - + def sum_abs_col(self): res = [] @@ -379,9 +386,9 @@ def sum_abs_col(self): return BlockDataContainer(*res) def __len__(self): - - return len(self.operators) - + + return len(self.operators) + def __getitem__(self, index): '''returns the index-th operator in the block irrespectively of it's shape''' return self.operators[index] @@ -389,6 +396,3 @@ def __getitem__(self, index): def get_as_list(self): '''returns the list of operators''' return self.operators - - - From 9a04de4791acdc013efd1e165fac4002ed6ccdb1 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 9 Oct 2023 09:01:30 +0000 Subject: [PATCH 044/152] Added stuff to gitignore --- .../__pycache__/SPDHG_sampling.cpython-310.pyc | Bin 8022 -> 0 bytes .../__pycache__/sampling.cpython-310.pyc | Bin 2552 -> 0 bytes .../__pycache__/TotalVariation.cpython-310.pyc | Bin 7665 -> 0 bytes .../TotalVariationNew.cpython-310.pyc | Bin 9895 -> 0 bytes .../functions/__pycache__/utils.cpython-310.pyc | Bin 1846 -> 0 bytes 5 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc delete mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariation.cpython-310.pyc delete mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc delete mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/utils.cpython-310.pyc diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc deleted file mode 100644 index 50238c405fe007f4ad1d74ed7ea628949025d970..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8022 zcmcIp&5s*LcJJ!u_k4Op$+D#NmSt}sdS^&!)>z8}uf4V;+w#YF)}vixDQO!`c9CqV z*-ckBr5Tz7EFb~a#X$n(n8OT^i-N?bAeS6Be?m@u3j$=}Qvw(Pk_{Hx->YJCNNEIH z*$oF>U0wBFy^nhJK5D{+g_42ajeqzTH~#~}_&55P{$=p-Q#{dSG_K(?-{`SAW7Ic& zvu>$(rk+vnY(0y&<>z|&dY&2Y8g9nT-ZR{+V0W#0!8NyyO73f{WK>vEe9Lc#(u+I2 zO?>6IonGG;vPrYkKjMIXQ6G&k>dZCjrpxM9(JY#7`3s}P6qRB^`IVbMA_J46yTG7#X9!0B%nt+3l^% z@4Y+ti=ts{$6>SMM6uW8Thi+}KEFIb^WJVldM41#9tg~0^*iqq`y-XMy3LvV*T!{D~q;jJ+kzk|)e z@Y%?ttvSp4GTc#OgH|VWdD!A!91&V~&~{>>)@_5@V}#!N&TFeR!oHAB9LkjOkJIn5 zyd=1iXfmOM03)&E1^h!V5RT;OWHixJ>XrO-wzz9X;Qb3noOpi*e(DJgw8MmvIHq(~}r znS-A$(l%{ozVvOf+!B0 zrXVhqiu43;`c9-liTX#A^AHJN;EauF2Vy7YIN;t|!-<=ni2_!+1m&>D6&->mM*bMB zy!`U5JC1Be+P4Iu>_w05+M%+fXgYp#;N#4?6Jym#V>#0k7-?^IWk<=az0KIW%+3IB z5IJqJ!MBCrojC4C8?{;+9%Rs{Hp5=+w&O)>((!ATu70?7S@goF*6_ndtp|rHWbInm z3)|A^cXn&rUQe@zUeNZ%57y6L>Nr6l{2IAp`*vh2ORe^IOPYzzaO`}DH6^BMa2{?8 z*%krz&x?3_fb$!~0y4wYZhI~|amR`I_4QRQKCAL`7uG8`r@ZsTVNW^n8>1WQlwbF5 z{_67!we>yzGXDS{c)`1jhi;61wa)qLybqU6uEK$ddxv~Ifn5wc!wds| zca=L4R3;)ofFwNZ_4S)-30nCaNFjW{)J33F8uDHU7NK`|ai2GxNFAT+7jDuztwB7% z?43~Fsu23*H(5}1J`pV;Y3Gg%X$k}jo}CKGT4QVKICpeNhC!*2eCX50F- zA!Un#G5^GCcH-Y0NbeRjh@~$%a7@nH+g`(S;03pv9cb4R4ZZsI)we$4?}r14P{d&c zA0sUFyrDLU^^2=K2&?=Res2Bzg^QI9zW(aPAFZulJb$qY4bJKgyL0v(b*%W-m20pS z_{1od0~P$W27)kHi+W**01v%|GUAQhu~SM(635td;JR?%ByD@FheMgCMRx88AL@{| zJaNZs4xb?LZ~k#gr}H4(S@pYgZ7&=1?Nx?hC;peOi`Us>gwIu@+s zq(c7Js!HI^->S^e_|G?+DvQ-$#vI;@c<3FuXksH~Bjc{wHC@XyMy0=Df6kaOLMAz2 za&?3p7VqlFRPXa6qic=W$Q)Ut%qTm`jq;q|3-AH59!cqMQm}2p zvh5^?kZBM4iPaWyWiH7e-n3*MFtR`ml2k*IE+h#r=c!qshV&tq&?Gq>C>|gIw`~>1 zY+Ej4=6CPZoPNL7^!(bVaKs=U)wXt#=mlzwvZS6DDRZn%a)hX+T(O-VA^01)g2gC} zkBIyU>ttq;t+3L=`G> zjxc8D?i*nW$4e33TPKxf?pgJ(JoBnsYhcJPN1%@PuT=$;cMJClaT&AociCmsD0`(*2`e7|f}y@C((I^2;~0Y+-GajX z`}hQ^o5DRKeima2qg%Xd5uAdA^ckazw!4UD;k5CZVH(g@PGSEO#`60o4~+fi+_?i< z`BVUV-#>jo8aVaX?3w$<{`aP!pU3w!_V*w8=A;Yz1s6KB&#K*AnB7g+LWQ;HyaXGE zS+5QHX_hrHuZdsVN>lH{q-#>-=!g$5$e(Cq(5wL|M3S@F=sQ&v5MlDZ5eZ?gr? zl#eI4*~#x#{Se;&sRAOzBWeM0D$))A`j_DV1tVo|$Wc zi~U{VyxJsA)1QeBMZ9BpqBCgP#>lu?+GFseDmyta_t}B*m*!`rGf zi(Zl;O;^mste#Jp2L-6`PqAD+hbAe#?&C&*ii0=)7T@0x!868C*ZEbQNmO6Q&5+|q zZ=jO`KgJ~`AxCi8HSQZ-RtB%9$6TsJqGGCaBe7&BME`kW#SA=1a2#C)qWF^>pMOU~ zFQAzrN(4zY+jye0Xq0LeZdiM4&)lQ*%%XJdm{B%T(hu0zB%kIWGp5@2#U))drg@bGTxTgMv>xHUQF^xMX4T0GG5RMlN>f3mw56dt%|fPz`Yyt zrzd7$lzb(YFM|3)K$VF-zRJ)E8A+zHGD%ra{kXmr_!LF+C!+7;+JS1aq=3qvvhOI# zP%p^>tSwZgm{_=7NUWjPuP@;~0heEPTZFitleRIE*zg;H<}Z-s-n z@~nIXUnoGFKFa9V(AOo!kEusxM!f((sBVH23-^b*uE@}3m-0YK&h_BmV_k#1N?2q! z^_3LMhGFR&Cwa&1(ru)?2-w7OTvu)osyac>Mz|ofQH|dA!a+pd5BJ0H zxfM&><@afQYuCQ@$SF^9gT9L+@Xwf!PM|qsoirD%mCWYulk9}5vwvBzVCXCSt zde*+Oqysi*>=88EFQP5LhO(oqYrbaSP2)Mh0qdfMD#6ki#_^mq+7=ZQ;~i{+HTC=Y zA%2zlq$qHIN@@~nQ|iSuwT!g4`YE8*M(ZtI#-8Bv|8Q%h+PJp?m1O)dijo}Fgn?Vh zDU~N?|AHj7CuZ1BO!oqc++P1t^)G9U+F_$h*P^$@Z-Eg}ftWGN>6FPZu({ktDun&r*zVJWnng%8(xe3nzI7U|L+cMF32mn$Z5)q&F+o|I+v;XolxBbrrZK z>>VYTB!wO+*5WMk{{T*DY}p)^k6L|(|ECvF;-8q~6yr(aJtPPvUPUvYFAi+0{{@=i@grAnQW#2q)Tf86IU;i;J5~XL+;e)k*(S0mI*m!Dg@2ZeeO{9F zaNW97FYemSfy7m5{K(;xmw{qHh02!7Z1_FR(34zgaZ~?PEZD5%=}Y%FD~ocK=$CA} z7rFxmNVX`p3 zhH47mA74djNuDJTl`hbcCA(FrV8O^R^F5O-J~Zb|+$$A+UU<=5EHTs4&$6j5%__zE zY20O1r|+$*lZ%B&(%Ha`-JplO$PD_jO4KUU&^4J#$kaMhTAdt|r0}}d!y9Cw>Yi)9 NT!0@dAXO=|KLEk;NEHA8 diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc deleted file mode 100644 index aebdc95d144e7b9b034882bb369e611ed685fd05..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2552 zcmaJ?UvC>l5Z~SV>$9D^o1j7xZ{%!<(?1pJqGa1l&kW4&$*^k~{t1NG?EgH4m(##IWVOft4Mt*wmBn`8) zG}ADYWjzYgY$_|wu}YqltwmcuQ8HAeRSmUHFbW?im8iBw4x(K}u;@0^Y1Dn%M>Qc+ zb&wZKwJ`j7e=``5H+zF<^RWUKs&wIqoP9y*?jPv^dcAm_Y5 zwhLpA6=rVa2C^uga&;4!Fjknlgj|acSz*LAl3Ztn$juX$8_ziho$05ITmUI1utBSW zRx@Dfh!>VLqxNbEjzJHGQsHUdz3wmKx@c6qi}yXkQLc?5+|<744PVd3}{tKCutG+O5U@lvU?Q z)p{002VvK(gnrzu$G!^3FedR*?DzV#OEoW@FbYTLHKjAcNzi>>`(K5Y$=<`4Zh@G> z1ZEq+EN~0VHvV#LLU2nj1F+`!D$FX@_mor^!r+T_~*gy@w-Q4(x?8s$HM(Y=cU z4;QEh5dtuZ6;O0MNEW)=`&z?WG|dUq`jDiiT7Zf^!jVx79X#@ z0;K<}_?%Z2e-`DoP%8*W$%kh$MFp=Y-aEvsf=t%u0Z#kL*M3MFr*AB94U3y(sKHRL zz;GRc(i$tB``rZhW2Uj8Zjq+8A#kX5BKkJcpfEHj&;xJ{R(q;7(x5x4BDy)%7Y^0M zQcByQO!*CNzVyTrxLcZQ@MXZo$ce~c&I0uY*DfwoO=JzyPuTkja#2BW?a zn4QXYMYUOAZC5d72DQ$__CzsO->!eDiHfjZYr^vMSH||FV2`y%^(`=K8x1|HJ?w>U z;zwaN^;IZ**GVGzd34ZV+3c6n5xy5Df7C)GuKSd7);=c#*v~4D| zZC$W!L+HW~rl@#kyE3T}6qcycU#tF0t;Ix5OuU}hw!EsSi^Pa0f$d%Xb2Vuh{F@l&ALjd>QR~=+}%ynpQCBx;UDsy#OdugL3iKbTTkvBG!zy>SN_z%rX!t>mv}N>D;5;5 zwJyzI&jZ`Xv^vcib@`wh^Qgriez`fMs{A%N?0Vy$`eCxjh1YU=LBdy-m&>*JK1mc{ zlhF0n_~Rt%cKvXVyWo^3!P9c7LOZgu6-3Sm(x)3y=snHZ#d$%18%gN}#ql2uJABtm zzV^J3KYiSFTzuw)VhJ+IyASrAF!X}>sghH&?+v6`>h`HKo!TT$xU2JHi0x>FwRIt%K-mPp)zG;=55V z6a(~;O!lKaXmG&0Lye6>9F7>^M&S$ZfX80KAC%-MffOinLmyK9^lsQ~`eEy7xj3i2 z*M)Ofj;-~kO{ zY^Spu9lShswxi#6qjYqO6zGQoK%Wk9JK=!B1|MKQEzYHbuTZ>&umLDfL8~hAucMPXfewzzdeR}S8<+}9)r_&8QIL=~Z>k0n@I74!|ALPz` z=-W&G8%F^aZ9Qqi#t!_B6Wk$E7dgB&##frl10{ocgi+$b<3GjZQ|>w;oEGQ^RY>Jv z8Aco_ox>*I0uAtT@RwK@d)&v#eE5!J-$_86*S#D2eGe?~V8_CzNJXSW^PMiO6ir3L zPrSnGj70;^KWp;OJ@*;8N&Y9;&x7*_0&kJuJ{9clevaJ*|E!F2x%YYyg>XxbA7W}O z=#{+V{Hu<$=kYJRF!EzM8}0Okw;S{%x05h!Hy~vLY5? zP+`DAcuhjFSjdI*7g5mUE1xccqj;|@@@}`uSMROdzq@+xqkD^dBYJ`U^78$~;dw;l zuOU!1S5}tqFKvCb*`#@Z)lXM{Z#icd>7Cl+tw0*HkyVtp&zQUQ(48Dfcc^U?Py9D% zBwE5!?Umlvk%6&q7_u)t)odfhsBNayuB25!D>VSCsR>w1D}WQJ1z1le(X)VI3cYEe z0nR9RLBUxCFQyY1pG#|i^JyJ$A=TOoa$OMCOG0~$tPoj@xq(!TJ^GLQ$p86A4;z=W zO5B5|mKMgcnr%~9vhD2Z>HNf2c1HO_Rv+dC*~B17XA=V-l1+|;$*fugtgNEqM^;f@ zToRYET4@_uJ?V69^xF1=Y{K3v^2@Ahi>L#2$|~J1R%DiXtz;${JWftdDVzA(ksa8$ zOtSjE6RVad8k3nBdqFFkK9$+kT_{ z&-xOKXvy`1rJqW)kW4LY9wL~AYAos|ey7OimRd#f950}xb{zu=o!5a4tD7JVmFWuxK--{Cd@~B}!L*W#l21u$T?VL?)Ax~YG zGLo5vAc6ckGs*eO_c8lMSF~r97f#Ug&SSwZuu3truFpXhXQ(4SE9$n<=vygkla;cc zYGIW@8VvMO|7Ro&UA_wlt8AOcl@wGTTY_NqL|cHM&dlkJsIW^SRI&h za|&$56#(&wE&*?e>u*UD8nvvp=S9f<<)M5B1G%D;XfaV5nk9Thj0AQ@iBe`DPbvAr z4#s#wUcz;Pz_$MyNMgdI8&k|;H7M;3c0)f$RrB?(fwkq2+5^tvvirT9OPOG)F7$5< zcrv4ZZ@`QHLqbazTLV!xGooJ7FyspM&AD;~EevoP_=Lb3fzt+&O_7VruXy%@zr%u< z?zg&`Q$Nf4*T*bmbp0vniShyU89LvmH%Fv1#*vwtg5B5fh6c$^=vw6q?a$|qDrx1| zI?>uyL<`)lztN#}X1j){V&=W)x6q$ZJwze2>xd1-9Jp%sH2G!9jwe&|1a$!5MN4rT zn1o3q$5SV??|EN}@A|S)>8}oCMXEYv3g1LHN20cq?zkdKc2fK04qSV3c*G?sFZ_}c z1I5*i#`K7|u3kuSBA+p#cUt=b@||)WeK$+_Put4BOfIH+GMCJ^7w}wa8LxEtS1D>RZ92(i z!bupfYxgysD4IJxSB@8>`c1V8UtJN^9+Ur)PKerNWMI#9`H!^c@l{YeS**4`$ycMF z&)lRr>RoxpY6BNANEPS_Pq)UW53ZnbYw7FclC!YXzZHca#$S(GQXaU!%T#}r+x z6SDBy-!gfXX(4;QE-1sirXcOkF>@bp#TB$yllR2r@onUglPCHsd>d9VGDRa4m6g;1HFHLv z(-+tcb{QjeeF{!;27kzLnf{lv`ix$KqnyHX%a}E0F+QbRI_7>uS#b@C#vGdg9&)Jk z-I-(q(M8?2&!lOCyqGjd6}$C~Jv7xXr|M(0$LPyu5l&DLvjo~Uqu7fgL@ewFK%zg?1VB!m9EPlViK8(Za>QAkvh4k6ephj$nVDPzMu3Z zT^z>Fsr2P09gWh8I{0I;{_NQC9-UzdWnt<(WO4~kLD?wN5*<0Z(L$Ck7vR73XBB$G zi z8nA{$h13(GAt7By0GTI8jw?MSq8rLNDUXEwk^F~zLO>niJVCjb{h-vLt49C!n2^rl z(wVajE>t8orA7>DbO|j85TWi81c){sb=9Dx87D5(3(51ZP#J?t5pT;o0FQ7XqW|V_ zzeNQpR9}?n@b3;(a}K>^P-KCmBq~oaR&jTqibbmWM3R3&{~kg4h8GuiT1BP4J)m$} zRJ9snr3i4R&>Y%t*Haf6Dr+^6rw=dbjfx}@2QEDgkK*4bsUh4K4y zN%t9(81R;?@cS>TDQN*NtMA1SoP(10`nO+AM>JF^CwXQ`cOMlTKr=@>vvN#hT1(e1 ziG0?!KN-*lUueN^o}sN=nLCmN`ZUD9e^A${+jb`sy@1+Nw*9>41jS6%hRj@i`IydN zAPrZA3RR?mW+aE|j5wS})kpa$omxe+A5)8>fOH6`xJ5di+X8vmY`UnTxE@^_M+m!3 z>wZ9hycXs2F~$3uX6pK)&ghQ_%v(B}`EUJW1PTO{TBSZyuh)6)&vXP36GE<4^$G$_ zRbgsOWd`ar*)@RXXkn%~D9lK5#d#g-?5ffhVoCazRZxmW;YM+$nwMo`6}zP%By{!> dqLjBGqO#hLa%TS_B$nTlYZvK0P*cx>`M-GAy<-3X diff --git a/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc b/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc deleted file mode 100644 index 61876cc7f5fe76b9822b8ebc3f96907ef499010e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9895 zcmd5?OK;p*b|zV@r%JLctL10AZ+Fj3RBpK}X(l~rrR{0Ar`2P?qcPfw2N5dGV%4Q2 zmRV%^l4ZSEo5;Wb0SpAQ%PP|BdNIEvn;^(yR$R;`i@>|dBAYCdeCP5}ReE@A>O+^?Z8Px1m)>qv{kgqs@kh%`Yo6$)cT4iFrbg3W3zOTH z8~mbY2^zA7#==^^+pE6*o*^`&yCZWOFSr^qMMJ3hrPyi`E@`+S;Te5r1fQJdkHP^<7+ z{vMu9@Hu`N-&M?VgI_sLj_R0!t(6{IwtUn#h_iJqBE^CAh*K9c^>o-E1ed2Z3w=K5P z_PDju9Oq1v&96TNf$_7H9ZhDo1D~1rXKkaA0s|1)j>*Kl1 z+ho+V(soSWUuo7y#jc4Nq--+N<>TE>%3qUti6kzZWZfnm37trG6br2JjlH!Um_m3v zY<{!RwnaNWuUg!Bb3Qq~T{(2@c;opWy4a8zu(s)23vzEg;qBU8)5&&1w5>m7+_QY< zdI8%uUs#}oS-W5t^F60e!X|0ku~^@i55YGml#QN}U8b|;2|L*CvcRJuFRYc5^rgZ_ z>ko{BMqu_w1#&RoiY2n|a!dGDaL^wdq+?96)wSKhfHgLS**;hr94yoL0hq;ZvsNSg z_F#FyJ{g@443ayO1qsSA!X?|(7pRHRhukSdP(P}Q7 z*=`QoH@5rBi%W~mdL?G~V^f%23#T)pEh8$^HFu5V>~N+lY{hGJR+_dOU`B3jntdmL z5H2k)O1_c#__+yjfkAMk)g%J4@qWg|)vq598C;iR1J8koxNT6Dtg`8N=J+~mo@-?b zJqf&C&vv(188?eta*~s=ah#A)Q zgs>cGP_v!-ff(aQ^GVNaTg_~}2P0!zR%#J3N&P1m&?A0{G^x6Fd1 zLY2BEoFLKEGTYBAn2{BhaP8Dy+D+;=Lj9M?5J()EtUgTIn5{asl3d8~b}W%m{3n0p zaPDJj7h5qQDh#?|xge+wG4K0yWMk`%I%u+uvEyD~R(-2Z@+=MZXs3C(mj%}E!8q0u zM#!80pZiOApE;>)mn{!MZ@Oc$vo88W8UJ%wPYZSuoF9&cWQ=$`QbXH?XNtYf`cr6j zeBh(5Jlu`tn!NRM5ghCqu!@NlM15J--{`by&Y|AO`K0#`JaY+6wYjFxD14Hr2Bpq*7fNEV~_R z8RKSPCfu?ipYO1(ha}E$pTu-XcTZqXBTm9UZJH85FlL$JgMyZL?v??4d139^!5-E8 zz=YnMZwQCx_CAZpJA0&Ym;r=~F59sP31CaDy+qlh7M;5m5YUQ5ea*&}+3lLm8tbK= zfhaUNANr^h__01TtZM)sv2LGi~|tcKTE_L|8q!ypn*gV zF*5)k2s$LNq4CJt3`7RB{##p#7a?eJu=Gj1m;@>bQi(UwI`Qxv_`>3y5b~7C9%Cfaf+;E!5aY6nScCf(sN7^uv~9w98wsT#0_s?X1wJSqTp`>%|LQ3 z7CYJ(7KGae1a*LXJi_B7Vm`J@@R_7NhDSTL<48nGIFwL3Kq%+ZGQtc9Ypd@d5`#d0?AvggNMNU4=C)6X^q7;5tIkmY~x_5zSwZA=Lkiq1OplaIvDa( z@4}hPuillOXMss@aTl{E0OKyEetY)O@(Hy5-{s+a;~e35lkrNpc^-eH=?8O{tlK}# z7%9amma|(Y#p)FE&UG+%<=k(>M{vFtbCJr|9NCq%C@&Fpq_)>rg^HGT6-D}?dM>&A ze?TQr0yR_)wT^~tk@`wS_DBmABNw98&_k-{!y?K;m_u0%b(Ezr&y~I+J`T#A%7ik= zhXr|mi|z-7FpoYHVF6_|n8aNH^H1UK0#{H@%kpAaMtvq!Iy2&D!KI^Fo;$|sVF|78 zg%c>}@N7=3b6W9oSV4IOEd|jGt{&1n*SPXT39b+8wLB%E)JOjkQ~QUX>@P6{V4Gf( zyePMN!a{b-s z%ov%|k1E5kEh=Y0P*l#2Jen8@g`#2-h(wy(i*ndsl$VMW*wjdb5~HlxY02v^MDnV6;GJu0qHag~ZoRD4LqO)9=e#YZT@c@2YX0kbI|#AE2|il@*^*4LL^TpK$paih{O(>+~+po3Twp(ht??u;i|2p+E`M zKt0s_sQ{VQqgY;j!>#tO)+t6TSKDD*|AD*|s3i4DGB>>HuNseNHZ6S?yFsKzE z^axK0e77x8#DYIAn133>15fkr~}J} z>3mXTO|L>DN@_*NrOm3kcHwhjMHj7uVki-WY%TKqD-AfMFepJfNYkHl9d%mw zLbksgo|l7Zv|c<^f2#cDUk@swJ^-%h=$#p0lUzJYnCn~uzEOEmw&3j=dd$+ixJpv; z%HnTT#qG$E?*RqnlaW9t*kkd!GN^`m;2V_56Cj`;gC2~yjQy$NAHxbS&p|q$X{hIq zu7KLfa55}V4LU$|^nHe&poBPbwQ~)aswiiK^m8q^esqItyb@0EiAz$Gj@8QwpTO!m zR(~I3N*EzI1L`KYc0~#G>k2fafctnq`2kQ^r-ZX3G*)`Pi@TeDqmu5$J4O9+@WIhd zUOi$!T$9HdVKTQQ+a{@vETgIfABM$46{U8lKGQI2DJ*tA!YuOCl3kS0{%Ht}kx#R@vES34{i-%$OcCFVw7Jo|9k#7+Mh{TVnz}sden!;;?Ez3y#PgH^f@CXx2fEH=JW$`if)7u_k z)g2l~zFoSVs3bFjJ!dbv5ChNQJb5{+MfsrHGoD8iFvx_^4Ao&&phi(Gr&VEK;9ETCf-uVv?gg!U34; z9Hu#GsqbSWC3pv4prVzA9#qdwYXx-%e+3|#0x(UbFa@7FgR7+K>NLLTei}Wfjux$o zmXbDy=T-FA)fxS!HjN(W53~vokgKY*=r@z2S)~W~-nbVdM10yUjiD(*AsK=t$&>o2 z?XQn{%?#xvxzg-(-VOO|VSf3Md`n=UAoqBJkZ@w(s3of|NS%QIF0;Hk&*!`T8IddZsih%?gWE71g~;jdqp9- zbkqop^E`J%E=Y+%KVa-{ve&KYn=y)u+Yord_%^+Mqy~CZ9YcG(HlQbaR#0c_WQJwD znF>HN3q_mpn|(5QqZ7uqyP4ul{73*<$Y!eVO$H3S?QtJTahXAp784SZ#gzO08LN&n zkk&gGj79Y1FVZFH?MAv@x*XfI1>QWjESxiCdL4&cMT(~DwPI{JDc%@vMclw`RC!9# zi;Quk0TO2&IZ4G19Xa8xN?}ed=+pmk7Enu zWz4-M=oe68f~srlt8tEMRV>i5(=@eA$Ie(;mQF=PGI`Uzw|1De;o76)Wm=RVI;YQ_(e~IqIV+je3^S5M<(H z(nn@qWX|P`{^_qMbSpC!!sUgjk}mpnGJjX3_*yYl-@JiE1rTH9)miQ0=4*sCbF`dWnjcs0dK; z4XP&D=^E7HCmq0q%h8=9tf~$pJJm?h5X~P*vMySp4ezdq#TvXfg!i2EI#<}M9<>`! z2j7lUotm`BKb6Hu8a07*I7l--80;VJOC8Wmw|QA^Lw(yX6nIkU?Pn8nQsgdIlqMaen&W=9kH`4{9lbp^X{NWziH)(wYOy{n z_7F>AU}CCJF)MY~A%RI(_n+VxqJ2T1gMjA5&#!g^2<$f50%8Jm20BMLevAR+G@#1HkZi|(R3 zBb7L21p2!uWoBM`%+kGRT15{;muNv4=qcF))(Ax%MQvr zxhuHah;6U5lsU=2 zJ0d{@cylCmBem)8e6jmfy$-9ZH^B6$dK3NSvHxEm9P$80=uI%UePFQ9h=!EW7&@cg z#fcu+HtOYA@sT_))Jw;^LJ`{_ACJn3!WongCJEd%mpH*W*KT}Xh;b(O3$s^@bKy?F zU6nSdhkK=4ZBtwy11M@VBDd6Cz8>p!m($Kn70 From 5a302c88e2e3f526a9684c4217937979b29055c2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 9 Oct 2023 10:05:15 +0000 Subject: [PATCH 045/152] Fixed tests --- Wrappers/Python/test/test_BlockOperator.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index bf7904982b..0cfaacffa5 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -45,14 +45,14 @@ def test_norms(self): self.assertAlmostEqual(G.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(G2.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) - self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) - self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms()[1], numpy.sqrt(8), 2) #sets_norm A.set_norms([2,3]) #gets cached norm - self.assertListEqual(A.norms(), [2,3], 2) + self.assertListEqual(A.get_norms(), [2,3], 2) self.assertEqual(A.norm(), numpy.sqrt(13)) @@ -64,8 +64,8 @@ def test_norms(self): A.set_norms([None, None]) #recalculates norm self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) - self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) - self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms()[1], numpy.sqrt(8), 2) #Check the warnings on set_norms #Check the length of list that is passed From 0bffa2483e12553b1953951042278cd1eac65cec Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 11 Oct 2023 10:45:47 +0000 Subject: [PATCH 046/152] Added a note to the documentation about which sampler to use --- Wrappers/Python/cil/framework/sampler.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 3530ec3076..6e3eadc607 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -92,7 +92,15 @@ class Sampler(): 4 [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] - + Note + ----- + The optimal choice of sampler depends on the data and the number of calls to the sampler. + + For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_subsets`. + For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. + In general, we note that for a large number of samples (e.g. `>20*num_subsets`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_subsets`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `num_subsets` samples is guaranteed to see each index exactly once. """ From 8416837b6bc82801eb7eadbd2ebefd230673c66d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 11 Oct 2023 11:54:50 +0000 Subject: [PATCH 047/152] Option for list or blockfunction --- .../functions/ApproximateGradientSumFunction.py | 7 ++----- .../cil/optimisation/functions/SGFunction.py | 17 ++++++++++++----- 2 files changed, 14 insertions(+), 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 074ed5ccfb..df10ffd604 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -58,12 +58,9 @@ class ApproximateGradientSumFunction(SumFunction): """ - def __init__(self, functions, sampler=None, initial=None): + def __init__(self, functions, sampler, initial=None): - if sampler is None: - raise NotImplementedError - else: - self.sampler = sampler + self.sampler = sampler self.num_functions = len(functions) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index b32d878b48..0697e2f7a1 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -16,6 +16,7 @@ # limitations under the License. from .ApproximateGradientSumFunction import ApproximateGradientSumFunction +import BlockFunction class SGFunction(ApproximateGradientSumFunction): @@ -24,16 +25,22 @@ class SGFunction(ApproximateGradientSumFunction): Parameters: ---------- - functions: list #TODO: should this be a list of functions or a block function?? + functions: list or BlockFunction A list of functions. sampler: callable or None, optional - A callable object that selects the function or batch of functions to compute the gradient. TODO: If None, a random function will be selected. + A callable object that selects the function or batch of functions to compute the gradient. """ - def __init__(self, functions, sampler=None): - - super(SGFunction, self).__init__(functions, sampler) + def __init__(self, functions, sampler): + if isinstance(functions, list): + super(SGFunction, self).__init__(functions, sampler) + elif isinstance(functions, BlockFunction): + super(SGFunction, self).__init__(functions.operators(), sampler) + else: + raise TypeError("Input to functions should be a list of functions or a BlockFunction") + + def approximate_gradient(self, function_num, x, out=None): From 37565fc0bc4f679d87f768d88d236e36b646f2f3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 11 Oct 2023 12:17:04 +0000 Subject: [PATCH 048/152] Fixed the bugs of the previous commit --- Wrappers/Python/cil/optimisation/functions/SGFunction.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 0697e2f7a1..83b6a91d16 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -16,7 +16,7 @@ # limitations under the License. from .ApproximateGradientSumFunction import ApproximateGradientSumFunction -import BlockFunction +from .BlockFunction import BlockFunction class SGFunction(ApproximateGradientSumFunction): @@ -36,7 +36,7 @@ def __init__(self, functions, sampler): if isinstance(functions, list): super(SGFunction, self).__init__(functions, sampler) elif isinstance(functions, BlockFunction): - super(SGFunction, self).__init__(functions.operators(), sampler) + super(SGFunction, self).__init__(*functions.functions, sampler) else: raise TypeError("Input to functions should be a list of functions or a BlockFunction") From 222c37770f515d0e490ec7ff879397e6430fed85 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 09:50:21 +0000 Subject: [PATCH 049/152] Moved the sampler to the algorithms folder --- Wrappers/Python/cil/framework/__init__.py | 2 +- .../cil/optimisation/algorithms/SPDHG.py | 2 +- .../cil/optimisation/algorithms/__init__.py | 1 + .../algorithms}/sampler.py | 0 docs/docs_environment.yml | 49 ------------------- 5 files changed, 3 insertions(+), 51 deletions(-) rename Wrappers/Python/cil/{framework => optimisation/algorithms}/sampler.py (100%) delete mode 100644 docs/docs_environment.yml diff --git a/Wrappers/Python/cil/framework/__init__.py b/Wrappers/Python/cil/framework/__init__.py index 19e6e89c1e..437ecd787a 100644 --- a/Wrappers/Python/cil/framework/__init__.py +++ b/Wrappers/Python/cil/framework/__init__.py @@ -34,4 +34,4 @@ from .BlockGeometry import BlockGeometry from .framework import DataOrder from .framework import Partitioner -from .sampler import Sampler + diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 62ba0675ad..efc5fe7354 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging -from cil.framework import Sampler +from sampler import Sampler from numbers import Number diff --git a/Wrappers/Python/cil/optimisation/algorithms/__init__.py b/Wrappers/Python/cil/optimisation/algorithms/__init__.py index b6b23bcb58..00ff33b9d2 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/__init__.py +++ b/Wrappers/Python/cil/optimisation/algorithms/__init__.py @@ -26,3 +26,4 @@ from .PDHG import PDHG from .ADMM import LADMM from .SPDHG import SPDHG +from .sampler import Sampler diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py similarity index 100% rename from Wrappers/Python/cil/framework/sampler.py rename to Wrappers/Python/cil/optimisation/algorithms/sampler.py diff --git a/docs/docs_environment.yml b/docs/docs_environment.yml deleted file mode 100644 index 20621fcd22..0000000000 --- a/docs/docs_environment.yml +++ /dev/null @@ -1,49 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright 2021 United Kingdom Research and Innovation -# Copyright 2021 The University of Manchester -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Authors: -# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt - -name: cil_testing -channels: - - conda-forge - - intel - - ccpi - - defaults - - astra-toolbox -dependencies: - - dxchange - - python-wget - - scikit-image - - packaging - - numba - - tigre=2.4 - - sphinx_rtd_theme - - sphinxcontrib-bibtex - - pydata-sphinx-theme<0.9 - - sphinx=3.5.* - - recommonmark=0.6.* - - sphinx-panels=0.5 - - sphinx-autobuild=0.7 - - sphinx-click=2.7 - - sphinx-copybutton=0.3 - - astra-toolbox>=1.9.9.dev5,<2.1 - - ccpi-regulariser=22.0.0 - - tomophantom=2.0.0 - - ipywidgets - - tqdm - - jinja2<3.1 - - cil-data From 1d70eb326098db34b305707ce6609363fc7b4a9f Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 10:32:18 +0000 Subject: [PATCH 050/152] Updated tests --- Wrappers/Python/test/test_sampler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index cbabbc991a..39b01bc964 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -23,7 +23,7 @@ import sys from testclass import CCPiTestClass import numpy as np -from cil.framework import Sampler +from cil.optimisation.algorithms import Sampler initialise_tests() sys.path.append(os.path.dirname(os.path.abspath(__file__))) From 5c9fa3aa5905d9e76671b63e440988618ff7dbc3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 11:58:18 +0000 Subject: [PATCH 051/152] Sampler inheritance --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index efc5fe7354..cfdbb93e79 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging -from sampler import Sampler +from cil.optimisation.algorithms import Sampler from numbers import Number From 48d355bc2ead99be8871105e2d6a2cec2f4190a6 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 15:04:21 +0000 Subject: [PATCH 052/152] Notes from meeting --- .../optimisation/functions/ApproximateGradientSumFunction.py | 4 ++-- Wrappers/Python/cil/optimisation/functions/SGFunction.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index df10ffd604..1906bc9539 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -58,7 +58,7 @@ class ApproximateGradientSumFunction(SumFunction): """ - def __init__(self, functions, sampler, initial=None): + def __init__(self, functions, sampler): self.sampler = sampler @@ -67,7 +67,7 @@ def __init__(self, functions, sampler, initial=None): super(ApproximateGradientSumFunction, self).__init__(*functions) def __call__(self, x): - r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ + r""" TODO: """ return super(ApproximateGradientSumFunction, self).__call__(x) def full_gradient(self, x, out=None): diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 83b6a91d16..57fd0b86f9 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -26,7 +26,7 @@ class SGFunction(ApproximateGradientSumFunction): Parameters: ---------- functions: list or BlockFunction - A list of functions. + A list of functions. #TODO: write it a bit clearer what the sum function requires :) sampler: callable or None, optional A callable object that selects the function or batch of functions to compute the gradient. @@ -36,7 +36,7 @@ def __init__(self, functions, sampler): if isinstance(functions, list): super(SGFunction, self).__init__(functions, sampler) elif isinstance(functions, BlockFunction): - super(SGFunction, self).__init__(*functions.functions, sampler) + super(SGFunction, self).__init__(*functions.functions, sampler) #TODO: remove this else: raise TypeError("Input to functions should be a list of functions or a BlockFunction") From 8e842765b85b5abe8e9be4e80fda03ec42c1ed08 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 15:24:09 +0000 Subject: [PATCH 053/152] Moved sampler to a new folder algorithms.utilities- think there is still a bug somewhere --- .../cil/optimisation/algorithms/SPDHG.py | 2 +- .../cil/optimisation/algorithms/__init__.py | 1 - .../cil/optimisation/utilities/__init__.py | 21 +++++++++++++++++++ .../{algorithms => utilities}/sampler.py | 0 Wrappers/Python/test/test_sampler.py | 2 +- 5 files changed, 23 insertions(+), 3 deletions(-) create mode 100644 Wrappers/Python/cil/optimisation/utilities/__init__.py rename Wrappers/Python/cil/optimisation/{algorithms => utilities}/sampler.py (100%) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index cfdbb93e79..18ccfa3ce6 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging -from cil.optimisation.algorithms import Sampler +from cil.optimisation.utilities import Sampler from numbers import Number diff --git a/Wrappers/Python/cil/optimisation/algorithms/__init__.py b/Wrappers/Python/cil/optimisation/algorithms/__init__.py index 00ff33b9d2..b6b23bcb58 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/__init__.py +++ b/Wrappers/Python/cil/optimisation/algorithms/__init__.py @@ -26,4 +26,3 @@ from .PDHG import PDHG from .ADMM import LADMM from .SPDHG import SPDHG -from .sampler import Sampler diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py new file mode 100644 index 0000000000..706ceb6e4a --- /dev/null +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +# Copyright 2018 United Kingdom Research and Innovation +# Copyright 2018 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt + + +from .sampler import Sampler diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py similarity index 100% rename from Wrappers/Python/cil/optimisation/algorithms/sampler.py rename to Wrappers/Python/cil/optimisation/utilities/sampler.py diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 39b01bc964..f58f818f29 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -23,7 +23,7 @@ import sys from testclass import CCPiTestClass import numpy as np -from cil.optimisation.algorithms import Sampler +from cil.optimisation.utilities import Sampler initialise_tests() sys.path.append(os.path.dirname(os.path.abspath(__file__))) From a9cb92edd63beb698919859bb7ae9bd24693b7ce Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 16:01:01 +0000 Subject: [PATCH 054/152] Some notes from the stochastic meeting --- .../functions/ApproximateGradientSumFunction.py | 9 +++------ Wrappers/Python/cil/optimisation/functions/SGFunction.py | 8 ++++---- 2 files changed, 7 insertions(+), 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 1906bc9539..3e8014dd2d 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -67,7 +67,7 @@ def __init__(self, functions, sampler): super(ApproximateGradientSumFunction, self).__init__(*functions) def __call__(self, x): - r""" TODO: """ + r""" Computes the full sum at :code:`x`. It is the sum of the outputs for each function. """ return super(ApproximateGradientSumFunction, self).__call__(x) def full_gradient(self, x, out=None): @@ -79,8 +79,8 @@ def approximate_gradient(self, function_num, x, out=None): raise NotImplemented def gradient(self, x, out=None): - """ Computes the gradient for each selected function at :code:`x`.""" - self.next_function() + """ Selects a random function and uses this to calculate the approximate gradient at :code:`x`.""" + self.function_num = next(self.sampler) # single function if isinstance(self.function_num, numbers.Number): @@ -88,8 +88,5 @@ def gradient(self, x, out=None): else: raise ValueError("Batch gradient is not yet implemented") - def next_function(self): - """ Selects the next subset from the list of :code:`functions` using the :code:`sampler`.""" - self.function_num = self.sampler.next() diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 57fd0b86f9..5122250b34 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -16,7 +16,7 @@ # limitations under the License. from .ApproximateGradientSumFunction import ApproximateGradientSumFunction -from .BlockFunction import BlockFunction +from .Function import SumFunction class SGFunction(ApproximateGradientSumFunction): @@ -35,10 +35,10 @@ class SGFunction(ApproximateGradientSumFunction): def __init__(self, functions, sampler): if isinstance(functions, list): super(SGFunction, self).__init__(functions, sampler) - elif isinstance(functions, BlockFunction): - super(SGFunction, self).__init__(*functions.functions, sampler) #TODO: remove this + elif isinstance(functions, SumFunction): + super(SGFunction, self).__init__(*functions.functions, sampler) #TODO: is this the right thing to do? else: - raise TypeError("Input to functions should be a list of functions or a BlockFunction") + raise TypeError("Input to functions should be a list of functions or a SumFunction") From c55225750aa01976a3ab3d558ad81ffbf8884b55 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 16:03:32 +0000 Subject: [PATCH 055/152] changed cmake file for new folder --- Wrappers/Python/CMake/setup.py.in | 1 + 1 file changed, 1 insertion(+) diff --git a/Wrappers/Python/CMake/setup.py.in b/Wrappers/Python/CMake/setup.py.in index 96cbea46b3..fe4cc43950 100644 --- a/Wrappers/Python/CMake/setup.py.in +++ b/Wrappers/Python/CMake/setup.py.in @@ -36,6 +36,7 @@ setup( 'cil.optimisation.functions', 'cil.optimisation.algorithms', 'cil.optimisation.operators', + 'cil.optimisation.utilities', 'cil.processors', 'cil.utilities', 'cil.utilities.jupyter', 'cil.plugins', From c6e1458d2625c290d5cf010674d3d3a77dc49b6a Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 16 Oct 2023 15:14:08 +0000 Subject: [PATCH 056/152] Some changes from Edo --- .../cil/optimisation/algorithms/SPDHG.py | 55 ++++++++++--------- .../cil/optimisation/utilities/__init__.py | 4 +- Wrappers/Python/test/test_algorithms.py | 2 +- docs/doc_environment.yml | 49 +++++++++++++++++ 4 files changed, 81 insertions(+), 29 deletions(-) create mode 100644 docs/doc_environment.yml diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 18ccfa3ce6..daf65645e9 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -52,10 +52,10 @@ class SPDHG(Algorithm): gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: instance of the Sampler class - Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets + sampler: an instance of a `cil.optimisation.utilities.Sampler` class + Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets precalculated_norms : list of floats - precalculated list of norms of the operators + precalculated list of norms of the operators #TODO: to remove based on pull request #1513 **kwargs: prob : list of floats, optional, default=None @@ -98,21 +98,23 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, - initial=None, precalculated_norms=None, sampler=None, **kwargs): + def __init__(self, f=None, g=None, operator=None, + initial=None, precalculated_norms=None, sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) - self.prob_weights = kwargs.get('prob', None) - if kwargs.get('norms', None) is not None: + if precalculated_norms is None and kwargs.get('prob') is not None: + precalculated_norms = kwargs.get('norms', None) warnings.warn( - 'norms is being deprecated, pass instead precalculated_norms=your_custom_norms') - if precalculated_norms is None: - precalculated_norms = kwargs.get('norms', None) - - if self.prob_weights is not None: - warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ - If you have passed both prob and a sampler then prob will be') + 'norms is being deprecated, pass instead precalculated_norms=your_custom_norms') + if sampler is not None: + self.prob_weights = sampler.prob + else: + if kwargs.get('prob', None) is not None: + warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)') + self.prob_weights = kwargs.get('prob', [1/len(operator)]*len(operator)) + sampler=Sampler.randomWithReplacement(len(operator), prob=self.prob_weights) + if f is not None and operator is not None and g is not None: self.set_up(f=f, g=g, operator=operator, @@ -165,9 +167,9 @@ def set_step_sizes_custom(self, sigma=None, tau=None): Parameters ---------- sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem + List of Step size parameters for Dual problem tau : positive float, optional, default=None - Step size parameter for Primal problem + Step size parameter for Primal problem The user can set these or default values are calculated, either sigma, tau, both or None can be passed. """ @@ -209,6 +211,11 @@ def set_step_sizes_custom(self, sigma=None, tau=None): "The value of tau should be a Number") self._tau = tau + def set_step_sizes_default(self): + """Calculates the default values for sigma and tau """ + self.set_step_sizes_custom(sigma=None, tau=None) + + def check_convergence(self): # TODO: check this with someone else """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma @@ -216,18 +223,14 @@ def check_convergence(self): Returns ------- Boolean - True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. + True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. N.B Convergence criterion currently can only be checked for scalar values of tau. """ for i in range(len(self._sigma)): if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): if self._sigma[i] * self._tau * self.norms[i]**2 > self.prob_weights[i]: - warnings.warn( - "Convergence criterion of SPDHG for scalar step-sizes is not satisfied.") return False return True else: - warnings.warn( - "Convergence criterion currently can only be checked for scalar values of tau.") return False def set_up(self, f, g, operator, @@ -249,8 +252,8 @@ def set_up(self, f, g, operator, Initial point for the SPDHG algorithm gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: instance of the Sampler class - Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. + sampler: an instance of a `cil.optimisation.utilities.Sampler` class + Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets precalculated_norms : list of floats precalculated list of norms of the operators ''' @@ -290,7 +293,7 @@ def set_up(self, f, g, operator, else: if not isinstance(sampler, Sampler): raise ValueError( - "The sampler should be an instance of the CIL Sampler class") + "The sampler should be an instance of the cil.optimisation.utilities.Sampler class") self.sampler = sampler if sampler.prob is None: self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets @@ -298,7 +301,7 @@ def set_up(self, f, g, operator, self.prob_weights = sampler.prob # might not want to do this until it is called (if computationally expensive) - self.set_step_sizes_custom() + self.set_step_sizes_default() # initialize primal variable if initial is None: @@ -327,7 +330,7 @@ def update(self): self.g.proximal(self.x_tmp, self._tau, out=self.x) # Choose subset - i = self.sampler.next() + i = next(self.sampler) # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index 706ceb6e4a..6aa6db103f 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -# Copyright 2018 United Kingdom Research and Innovation -# Copyright 2018 The University of Manchester +# Copyright 2023 United Kingdom Research and Innovation +# Copyright 2023 The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index c93eabce07..e21d8c14d8 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -29,7 +29,7 @@ from cil.framework import AcquisitionGeometry from cil.framework import BlockDataContainer from cil.framework import BlockGeometry -from cil.framework import Sampler +from cil.optimisation.utilities import Sampler from cil.optimisation.operators import IdentityOperator from cil.optimisation.operators import GradientOperator, BlockOperator, MatrixOperator diff --git a/docs/doc_environment.yml b/docs/doc_environment.yml new file mode 100644 index 0000000000..89a8341e8c --- /dev/null +++ b/docs/doc_environment.yml @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +# Copyright 2021 United Kingdom Research and Innovation +# Copyright 2021 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt + +name: docs +channels: + - conda-forge + - intel + - ccpi + - defaults + - astra-toolbox +dependencies: + - dxchange + - python-wget + - scikit-image + - packaging + - numba + - tigre=2.4 + - sphinx_rtd_theme + - sphinxcontrib-bibtex + - pydata-sphinx-theme<0.9 + - sphinx=3.5.* + - recommonmark=0.6.* + - sphinx-panels=0.5 + - sphinx-autobuild=0.7 + - sphinx-click=2.7 + - sphinx-copybutton=0.3 + - astra-toolbox>=1.9.9.dev5,<2.1 + - ccpi-regulariser=22.0.0 + - tomophantom=2.0.0 + - ipywidgets + - tqdm + - jinja2<3.1 + - cil-data \ No newline at end of file From 2b35fadde4d4434f810e4580a343a26c6a5cf616 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 16 Oct 2023 16:13:34 +0000 Subject: [PATCH 057/152] Maths documentation --- .../cil/optimisation/algorithms/SPDHG.py | 43 ++++++++++++++++++- 1 file changed, 41 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index daf65645e9..216af804a5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -134,9 +134,18 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): Parameters ---------- gamma : float - parameter controlling the trade-off between the primal and dual step sizes + parameter controlling the trade-off between the primal and dual step sizes rho : float - parameter controlling the size of the product :math: \sigma\tau :math: + parameter controlling the size of the product :math: \sigma\tau :math: + + Note + ----- + The step sizes `sigma` anf `tau` are set using the equations: + .. math:: + + \sigma_i=\gamma\rho / (\|K_i\|**2)\\ + \tau = (\rho/\gamma)\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + """ if isinstance(gamma, Number): if gamma <= 0: @@ -172,6 +181,36 @@ def set_step_sizes_custom(self, sigma=None, tau=None): Step size parameter for Primal problem The user can set these or default values are calculated, either sigma, tau, both or None can be passed. + + Note + ----- + There are 4 possible cases considered by this function: + + - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: + .. math:: + + \sigma_i=0.99 / (\|K_i\|**2) + + and `tau` is set as per case 2 + + - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula + + .. math:: + + \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + + - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula + + .. math:: + + \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) + + - Case 4: Both `sigma` and `tau` are provided. + + + + + """ gamma = 1. rho = .99 From 43e6fee9a58af98cdacda89e45932cbb245875c5 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 16 Oct 2023 16:46:36 +0000 Subject: [PATCH 058/152] Some more Edo comments on sampler --- .../cil/optimisation/utilities/sampler.py | 144 ++++++++---------- docs/doc_environment.yml | 3 +- 2 files changed, 65 insertions(+), 82 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 6e3eadc607..67703308f9 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -24,29 +24,29 @@ class Sampler(): r""" - A class to select from a list of integers {0, 1, …, S-1}, with each integer representing the index of a subset - The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations. + A class to select from a list of indices {0, 1, …, S-1} + The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. Parameters ---------- - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". - order: list of integers - The list of integers the method selects from using next. + order: list of indices + The list of indices the method selects from using next. shuffle= bool, default=False - If True, after each num_subsets calls of next the sampling order is shuffled randomly. + If True, the drawing order changes every each `num_indices`, otherwise the same random order each time the data is sampled is used. - prob: list of floats of length num_subsets that sum to 1. - For random sampling with replacement, this is the probability for each integer to be called by next. + prob: list of floats of length num_indices that sum to 1. + For random sampling with replacement, this is the probability for each index to be called by next. seed:int, default=None - Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. + Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. @@ -97,20 +97,20 @@ class Sampler(): The optimal choice of sampler depends on the data and the number of calls to the sampler. For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of - iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_subsets`. + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_indices`. For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. - In general, we note that for a large number of samples (e.g. `>20*num_subsets`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_subsets`) the user may wish to consider - another sampling method e.g. random without replacement, which, when calling `num_subsets` samples is guaranteed to see each index exactly once. + In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ @staticmethod - def sequential(num_subsets): + def sequential(num_indices): """ Function that outputs a sampler that outputs sequentially. - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. Example ------- @@ -133,8 +133,8 @@ def sequential(num_subsets): 9 0 """ - order = list(range(num_subsets)) - sampler = Sampler(num_subsets, sampling_type='sequential', order=order) + order = list(range(num_indices)) + sampler = Sampler(num_indices, sampling_type='sequential', order=order) return sampler @staticmethod @@ -142,7 +142,7 @@ def customOrder(customlist): """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. - customlist: list of integers + customlist: list of indices The list that will be sampled from in order. Example @@ -167,18 +167,18 @@ def customOrder(customlist): [1 4 6 7 8] """ - num_subsets = len(customlist) + num_indices = len(customlist) sampler = Sampler( - num_subsets, sampling_type='custom_order', order=customlist) + num_indices, sampling_type='custom_order', order=customlist) return sampler @staticmethod - def hermanMeyer(num_subsets): + def hermanMeyer(num_indices): """ Function that takes a number of subsets and returns a sampler which outputs a Herman Meyer order - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. For Herman-Meyer sampling this number should not be prime. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. Reference ---------- @@ -229,22 +229,22 @@ def _herman_meyer_order(n): math.prod(factors[factor_n+1:]) * mapping return order - order = _herman_meyer_order(num_subsets) + order = _herman_meyer_order(num_indices) sampler = Sampler( - num_subsets, sampling_type='herman_meyer', order=order) + num_indices, sampling_type='herman_meyer', order=order) return sampler @staticmethod - def staggered(num_subsets, offset): + def staggered(num_indices, offset): """ Function that takes a number of subsets and returns a sampler which outputs in a staggered order. - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - The offset should be less than the num_subsets + The offset should be less than the num_indices Example ------- @@ -272,24 +272,24 @@ def staggered(num_subsets, offset): 14 [ 0 4 8 12 16] """ - if offset >= num_subsets: + if offset >= num_indices: raise (ValueError('The offset should be less than the number of subsets')) - indices = list(range(num_subsets)) + indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = Sampler(num_subsets, sampling_type='staggered', order=order) + sampler = Sampler(num_indices, sampling_type='staggered', order=order) return sampler @staticmethod - def randomWithReplacement(num_subsets, prob=None, seed=None): + def randomWithReplacement(num_indices, prob=None, seed=None): """ - Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets with given probability and with replacement. + Function that takes a number of subsets and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - prob: list of floats of length num_subsets that sum to 1. default=None - This is the probability for each integer to be called by next. If None, then the integers will be sampled uniformly. + prob: list of floats of length num_indices that sum to 1. default=None + This is the probability for each index to be called by next. If None, then the indices will be sampled uniformly. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. @@ -314,25 +314,26 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): """ if prob == None: - prob = [1/num_subsets] * num_subsets + prob = [1/num_indices] * num_indices sampler = Sampler( - num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) + num_indices, sampling_type='random_with_replacement', prob=prob, seed=seed) return sampler @staticmethod - def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): + def randomWithoutReplacement(num_indices, seed=None, shuffle=True): """ - Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. + Function that takes a number of subsets and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. shuffle:boolean, default=True - If True, there is a random shuffle after all the integers have been seen once, if false the same random order each time the data is sampled is used. + If True, the drawing order changes every each `num_indices`, otherwise the same random order each time the data is sampled is used. + Example ------- >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) @@ -346,37 +347,18 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): [6 2 1 0 4 3 5 6 2 1 0 4 3 5 6 2] """ - order = list(range(num_subsets)) - sampler = Sampler(num_subsets, sampling_type='random_without_replacement', + order = list(range(num_indices)) + sampler = Sampler(num_indices, sampling_type='random_without_replacement', order=order, shuffle=shuffle, seed=seed) return sampler - def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): + def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=None, seed=None): """ This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. - Parameters - ---------- - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. - - sampling_type:str - The sampling type used. - - order: list of integers - The list of integers the method selects from using next. - - shuffle= bool, default=False - If True, after each num_subsets calls of next, the sampling order is shuffled randomly. - - prob: list of floats of length num_subsets that sum to 1. - For random sampling with replacement, this is the probability for each integer to be called by next. - - seed:int, default=None - Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. """ self.type = sampling_type - self.num_subsets = num_subsets + self.num_indices = num_indices if seed is not None: self.seed = seed else: @@ -392,50 +374,50 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N self.prob = prob if prob is not None: self.iterator = self._next_prob - self.last_subset = self.num_subsets-1 + self.last_subset = self.num_indices-1 def _next_order(self): """ The user should call sampler.next() or next(sampler) rather than use this function. - A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. This function is used by samplers that sample without replacement. """ # print(self.last_subset) - if self.shuffle == True and self.last_subset == self.num_subsets-1: + if self.shuffle == True and self.last_subset == self.num_indices-1: self.order = self.generator.permutation(self.order) # print(self.order) - self.last_subset = (self.last_subset+1) % self.num_subsets + self.last_subset = (self.last_subset+1) % self.num_indices return (self.order[self.last_subset]) def _next_prob(self): """ The user should call sampler.next() or next(sampler) rather than use this function. - A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - This function us used by samplers that select from a list of integers {0, 1, …, S-1}, with S=num_subsets, randomly with replacement. + This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with replacement. """ - return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) + return int(self.generator.choice(self.num_indices, 1, p=self.prob)) def next(self): - """ A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. """ + """ A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ return (self.iterator()) def __next__(self): """ - A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. Allows the user to call next(sampler), to get the same result as sampler.next()""" return (self.next()) def get_samples(self, num_samples=20): """ - Function that takes an integer, num_samples, and returns the first num_samples as a numpy array. + Function that takes an index, num_samples, and returns the first num_samples as a numpy array. num_samples: int, default=20 The number of samples to return. @@ -450,7 +432,7 @@ def get_samples(self, num_samples=20): """ save_generator = self.generator save_last_subset = self.last_subset - self.last_subset = self.num_subsets-1 + self.last_subset = self.num_indices-1 save_order = self.order self.order = self.initial_order self.generator = np.random.RandomState(self.seed) diff --git a/docs/doc_environment.yml b/docs/doc_environment.yml index 89a8341e8c..1a19df766e 100644 --- a/docs/doc_environment.yml +++ b/docs/doc_environment.yml @@ -46,4 +46,5 @@ dependencies: - ipywidgets - tqdm - jinja2<3.1 - - cil-data \ No newline at end of file + - cil-data + \ No newline at end of file From f77b5538784f327a1d67cb7c9eab528acdd7f888 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 17 Oct 2023 08:32:50 +0000 Subject: [PATCH 059/152] Tried to sort the tests --- .../cil/optimisation/utilities/sampler.py | 30 ++++++++--------- Wrappers/Python/test/test_sampler.py | 32 +++++++++---------- 2 files changed, 31 insertions(+), 31 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 67703308f9..0691318840 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -175,7 +175,7 @@ def customOrder(customlist): @staticmethod def hermanMeyer(num_indices): """ - Function that takes a number of subsets and returns a sampler which outputs a Herman Meyer order + Function that takes a number of indices and returns a sampler which outputs a Herman Meyer order num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. @@ -193,7 +193,7 @@ def hermanMeyer(num_indices): """ def _herman_meyer_order(n): - # Assuming that the subsets are in geometrical order + # Assuming that the indices are in geometrical order n_variable = n i = 2 factors = [] @@ -208,7 +208,7 @@ def _herman_meyer_order(n): n_factors = len(factors) if n_factors == 0: raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the number of subsets is prime. Please use an alternative sampling method or change the number of subsets. ') + 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') order = [0 for _ in range(n)] value = 0 for factor_n in range(n_factors): @@ -237,7 +237,7 @@ def _herman_meyer_order(n): @staticmethod def staggered(num_indices, offset): """ - Function that takes a number of subsets and returns a sampler which outputs in a staggered order. + Function that takes a number of indices and returns a sampler which outputs in a staggered order. num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -273,7 +273,7 @@ def staggered(num_indices, offset): [ 0 4 8 12 16] """ if offset >= num_indices: - raise (ValueError('The offset should be less than the number of subsets')) + raise (ValueError('The offset should be less than the number of indices')) indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] @@ -283,7 +283,7 @@ def staggered(num_indices, offset): @staticmethod def randomWithReplacement(num_indices, prob=None, seed=None): """ - Function that takes a number of subsets and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. + Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -322,7 +322,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): @staticmethod def randomWithoutReplacement(num_indices, seed=None, shuffle=True): """ - Function that takes a number of subsets and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. + Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. num_indices: int @@ -374,7 +374,7 @@ def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=N self.prob = prob if prob is not None: self.iterator = self._next_prob - self.last_subset = self.num_indices-1 + self.last_index = self.num_indices-1 def _next_order(self): """ @@ -385,12 +385,12 @@ def _next_order(self): This function is used by samplers that sample without replacement. """ - # print(self.last_subset) - if self.shuffle == True and self.last_subset == self.num_indices-1: + # print(self.last_index) + if self.shuffle == True and self.last_index == self.num_indices-1: self.order = self.generator.permutation(self.order) # print(self.order) - self.last_subset = (self.last_subset+1) % self.num_indices - return (self.order[self.last_subset]) + self.last_index = (self.last_index+1) % self.num_indices + return (self.order[self.last_index]) def _next_prob(self): """ @@ -431,13 +431,13 @@ def get_samples(self, num_samples=20): """ save_generator = self.generator - save_last_subset = self.last_subset - self.last_subset = self.num_indices-1 + save_last_index = self.last_index + self.last_index = self.num_indices-1 save_order = self.order self.order = self.initial_order self.generator = np.random.RandomState(self.seed) output = [self.next() for _ in range(num_samples)] self.generator = save_generator self.order = save_order - self.last_subset = save_last_subset + self.last_index = save_last_index return (np.array(output)) diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index f58f818f29..d751034d45 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -33,62 +33,62 @@ class TestSamplers(CCPiTestClass): def test_init(self): sampler = Sampler.sequential(10) - self.assertEqual(sampler.num_subsets, 10) + self.assertEqual(sampler.num_indices, 10) self.assertEqual(sampler.type, 'sequential') self.assertListEqual(sampler.order, list(range(10))) self.assertListEqual(sampler.initial_order, list(range(10))) self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 9) + self.assertEqual(sampler.last_index, 9) sampler = Sampler.randomWithoutReplacement(7, shuffle=True) - self.assertEqual(sampler.num_subsets, 7) + self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler.type, 'random_without_replacement') self.assertListEqual(sampler.order, list(range(7))) self.assertListEqual(sampler.initial_order, list(range(7))) self.assertEqual(sampler.shuffle, True) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 6) + self.assertEqual(sampler.last_index, 6) sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) - self.assertEqual(sampler.num_subsets, 8) + self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler.type, 'random_without_replacement') self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 7) + self.assertEqual(sampler.last_index, 7) self.assertEqual(sampler.seed, 1) sampler = Sampler.hermanMeyer(12) - self.assertEqual(sampler.num_subsets, 12) + self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'herman_meyer') self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 11) + self.assertEqual(sampler.last_index, 11) self.assertListEqual( sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.initial_order, [ 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) sampler = Sampler.randomWithReplacement(5) - self.assertEqual(sampler.num_subsets, 5) + self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler.type, 'random_with_replacement') self.assertEqual(sampler.order, None) self.assertEqual(sampler.initial_order, None) self.assertEqual(sampler.shuffle, False) self.assertListEqual(sampler.prob, [1/5] * 5) - self.assertEqual(sampler.last_subset, 4) + self.assertEqual(sampler.last_index, 4) sampler = Sampler.randomWithReplacement(4, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.num_subsets, 4) + self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler.type, 'random_with_replacement') self.assertEqual(sampler.order, None) self.assertEqual(sampler.initial_order, None) self.assertEqual(sampler.shuffle, False) self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.last_subset, 3) + self.assertEqual(sampler.last_index, 3) sampler = Sampler.staggered(21, 4) - self.assertEqual(sampler.num_subsets, 21) + self.assertEqual(sampler.num_indices, 21) self.assertEqual(sampler.type, 'staggered') self.assertListEqual(sampler.order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) @@ -96,7 +96,7 @@ def test_init(self): 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 20) + self.assertEqual(sampler.last_index, 20) try: Sampler.staggered(22, 25) @@ -104,13 +104,13 @@ def test_init(self): self.assertTrue(True) sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.num_subsets, 7) + self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler.type, 'custom_order') self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) self.assertListEqual(sampler.initial_order, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 6) + self.assertEqual(sampler.last_index, 6) From cf1b7f19b43ceeb9c62034ccc6da0b4af2bb9854 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 17 Oct 2023 08:58:13 +0000 Subject: [PATCH 060/152] Vaggelis comment on checks --- .../Python/cil/optimisation/operators/Operator.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/Operator.py b/Wrappers/Python/cil/optimisation/operators/Operator.py index ee46c45e3b..cc18e4fe6a 100644 --- a/Wrappers/Python/cil/optimisation/operators/Operator.py +++ b/Wrappers/Python/cil/optimisation/operators/Operator.py @@ -72,12 +72,12 @@ def norm(self, **kwargs): def set_norm(self, norm=None): '''Sets the norm of the operator to a custom value. ''' - try: - if norm is not None and norm <=0: - raise ValueError("Norm must be a positive real value or None, got {}".format(norm)) - except TypeError: - raise TypeError("Norm must be a positive real value or None, got {} of type {}".format(norm, type(norm))) - + + if norm is not None and isinstance(norm, Number) is False: + raise TypeError("Norm must be a number or None, got {} of type {}".format(norm, type(norm))) + + if isinstance(norm, Number) and norm <=0: + raise ValueError("Norm must be a positive real valued number or None, got {}".format(norm)) self._norm = norm From c2c4df9fed19b4508ed1b0ffbe5752215c6bedbe Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 17 Oct 2023 09:53:54 +0000 Subject: [PATCH 061/152] Change to jinja version in doc_environment.yml --- docs/doc_environment.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/doc_environment.yml b/docs/doc_environment.yml index 1a19df766e..2fd8ca35e5 100644 --- a/docs/doc_environment.yml +++ b/docs/doc_environment.yml @@ -45,6 +45,6 @@ dependencies: - tomophantom=2.0.0 - ipywidgets - tqdm - - jinja2<3.1 + - jinja2=3.03 - cil-data \ No newline at end of file From d11296f76b7475bdcf85cf5202d65cf6ec4f8baf Mon Sep 17 00:00:00 2001 From: lauramurgatroyd Date: Wed, 18 Oct 2023 10:40:07 +0100 Subject: [PATCH 062/152] Revert changes to docs_environment.yml --- docs/doc_environment.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/doc_environment.yml b/docs/doc_environment.yml index 2fd8ca35e5..07adaa7426 100644 --- a/docs/doc_environment.yml +++ b/docs/doc_environment.yml @@ -45,6 +45,5 @@ dependencies: - tomophantom=2.0.0 - ipywidgets - tqdm - - jinja2=3.03 + - jinja2<3.1 - cil-data - \ No newline at end of file From 32e057b03831de3caab91e7b09749cda196e6287 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 10:22:42 +0000 Subject: [PATCH 063/152] Docstring change --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 3 +-- Wrappers/Python/test/test_Operator.py | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 2309dc1b37..554897c351 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -141,8 +141,7 @@ def get_item(self, row, col): return self.operators[index] def norm(self): - '''Returns the square root of the sum of the norms of the individual operators in the BlockOperators - ''' + '''Returns the Euclidean norm of the norms of the individual operators in the BlockOperators ''' return numpy.sqrt(numpy.sum(numpy.array(self.get_norms())**2)) def get_norms(self, ): diff --git a/Wrappers/Python/test/test_Operator.py b/Wrappers/Python/test/test_Operator.py index 4eee146def..fc289c019d 100644 --- a/Wrappers/Python/test/test_Operator.py +++ b/Wrappers/Python/test/test_Operator.py @@ -679,7 +679,7 @@ def test_BlockOperator(self): self.assertNumpyArrayEqual(res.get_item(1).as_array(), 4 * u.as_array()) - + x1 = B.adjoint(z1) # this should be [15 u, 10 u] el1 = B.get_item(0,0).adjoint(z1.get_item(0)) + B.get_item(1,0).adjoint(z1.get_item(1)) From 4e0ca6a6ae6b50f99b8a20003d9be3bcb2b802b1 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 10:28:42 +0000 Subject: [PATCH 064/152] Docstring change --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 554897c351..fb8ae11167 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -349,10 +349,6 @@ def range_geometry(self): tmp.append(self.get_item(i, 0).range_geometry()) return BlockGeometry(*tmp) - # shape = (self.shape[1], 1) - # return BlockGeometry(*[el.range_geometry() for el in self.operators], - # shape=shape) - def sum_abs_row(self): res = [] From 87f1a00310b1d0a2267710d422d728b333e23e58 Mon Sep 17 00:00:00 2001 From: lauramurgatroyd Date: Wed, 18 Oct 2023 11:58:30 +0100 Subject: [PATCH 065/152] Revert naming of docs environment file --- docs/{doc_environment.yml => docs_environment.yml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/{doc_environment.yml => docs_environment.yml} (100%) diff --git a/docs/doc_environment.yml b/docs/docs_environment.yml similarity index 100% rename from docs/doc_environment.yml rename to docs/docs_environment.yml From 2ff165a261484de0654da54d3dbea41f4b1882c8 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 14:15:44 +0000 Subject: [PATCH 066/152] Updated changelog --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 349e90a9c7..0bf6d85168 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,7 @@ +*xx.x.x + - Added the functions `set_norms` and `get_norms` to the `BlockOperator` class + * 23.1.0 - Fix bug in IndicatorBox proximal_conjugate - Allow CCPi Regulariser functions for non CIL object From 81fc7e2aa7787d906b6687b4e7d5d8f398cdff52 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 14:17:21 +0000 Subject: [PATCH 067/152] Updated changelog --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0bf6d85168..36ff528404 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ *xx.x.x - - Added the functions `set_norms` and `get_norms` to the `BlockOperator` class + - Added the a `Sampler` class as a CIL optimisation utility + - Updated the `SPDHG` algorithm to take a stochastic `Sampler` and to more easily set step sizes * 23.1.0 - Fix bug in IndicatorBox proximal_conjugate From 8f100e0fe71eca523a070a2ab810dd87044173ee Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 14:17:55 +0000 Subject: [PATCH 068/152] Updated changelog --- CHANGELOG.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 349e90a9c7..dccff500fb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,6 @@ - +* xx.x.x + - Added the functions `set_norms` and `get_norms` to the `BlockOperator` class + - * 23.1.0 - Fix bug in IndicatorBox proximal_conjugate - Allow CCPi Regulariser functions for non CIL object From 920cf909715c368d5599c2c58b6dd7fbe0c915e3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 20 Oct 2023 12:28:53 +0000 Subject: [PATCH 069/152] Started adding new unit tests --- .../Python/test/test_approximate_gradient.py | 196 ++++++++++++++++++ 1 file changed, 196 insertions(+) create mode 100644 Wrappers/Python/test/test_approximate_gradient.py diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py new file mode 100644 index 0000000000..6ae7b2c439 --- /dev/null +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -0,0 +1,196 @@ +# -*- coding: utf-8 -*- +# Copyright 2023 United Kingdom Research and Innovation +# Copyright 2023 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt + +#TODO: remove unused packages +import unittest +from utils import initialise_tests +import numpy +import numpy as np +from numpy import nan, inf +from cil.framework import VectorData +from cil.framework import ImageData +from cil.framework import AcquisitionData +from cil.framework import ImageGeometry +from cil.framework import AcquisitionGeometry +from cil.framework import BlockDataContainer +from cil.framework import BlockGeometry + +from cil.optimisation.operators import IdentityOperator +from cil.optimisation.operators import GradientOperator, BlockOperator, MatrixOperator + +from cil.optimisation.functions import LeastSquares, ZeroFunction, \ + L2NormSquared, OperatorCompositionFunction +from cil.optimisation.functions import MixedL21Norm, BlockFunction, L1Norm, KullbackLeibler +from cil.optimisation.functions import IndicatorBox + +from cil.optimisation.algorithms import Algorithm +from cil.optimisation.algorithms import GD +from cil.optimisation.algorithms import CGLS +from cil.optimisation.algorithms import SIRT +from cil.optimisation.algorithms import FISTA +from cil.optimisation.algorithms import SPDHG +from cil.optimisation.algorithms import PDHG +from cil.optimisation.algorithms import LADMM + + +from cil.utilities import dataexample +from cil.utilities import noise as applynoise +import time +import warnings +from cil.optimisation.functions import Rosenbrock +from cil.optimisation.functions import ApproximateGradientSumFunction +from cil.optimisation.functions import SGFunction +#from cil.optimisation.utilities import Sampler + +from cil.framework import VectorData, VectorGeometry +from cil.utilities.quality_measures import mae, mse, psnr +# Fast Gradient Projection algorithm for Total Variation(TV) +from cil.optimisation.functions import TotalVariation +import logging +from testclass import CCPiTestClass +from utils import has_astra + +initialise_tests() + +if has_astra: + from cil.plugins.astra import ProjectionOperator + +class TestApproximateGradientSumFunction(CCPiTestClass): + def test_init(self): + pass + #TODO: +class Sampling(): + def __init__(self, num_subsets, prob=None, seed=99): + self.num_subsets=num_subsets + np.random.seed(seed) + + if prob==None: + self.prob = [1/self.num_subsets] * self.num_subsets + else: + self.prob=prob + def __next__(self): + + return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + +class TestSGD(CCPiTestClass): + + ## def test_SGD_one_function(self): + # ig = ImageGeometry(12,13,14) + # initial = ig.allocate() + # b = ig.allocate('random') + # identity = IdentityOperator(ig) + # + # norm2sq = LeastSquares(identity, b) + # rate = norm2sq.L / 3. + # sampler=Sampling(1) + + # objective=SGFunction([norm2sq], sampler) + # alg = GD(initial=initial, + # objective_function=objective, + # rate=rate, atol=1e-9, rtol=1e-6) + # alg.max_iteration = 1000 + # alg.run(verbose=0) + # self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) + # alg = GD(initial=initial, + # objective_function=objective, + # rate=rate, max_iteration=20, + # update_objective_interval=2, + # atol=1e-9, rtol=1e-6)# + + # alg.run(20, verbose=0) + # self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) + + def test_SGD_toy_example(self): + sampler=Sampling(5) + initial = VectorData(np.zeros(25)) + b = VectorData(np.random.normal(0,1,25)) + functions=[] + for i in range(5): + diagonal=np.zeros(25) + diagonal[5*i:5*(i+1)]=1 + A=MatrixOperator(np.diag(diagonal)) + functions.append( LeastSquares(A, A.direct(b))) + if i==0: + objective=LeastSquares(A, A.direct(b)) + else: + objective+=LeastSquares(A, A.direct(b)) + + rate = objective.L / 3. + + alg = GD(initial=initial, + objective_function=objective, update_objective_interval=1000, + rate=rate, atol=1e-9, rtol=1e-6) + alg.max_iteration = 400 + alg.run(verbose=0) + self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) + + objective=SGFunction(functions, sampler) + alg_stochastic = GD(initial=initial, + objective_function=objective, update_objective_interval=1000, + step_size=0.01, max_iteration =5000) + alg_stochastic.run( 400, verbose=0) + self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) + self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), b.as_array(),3) + + def test_SGD_simulated_parallel_beam_data(self): + sampler=Sampling(5) + data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() + data.reorder('astra') + data2d=data.get_slice(vertical='centre') + ag2D = data2d.geometry + ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') + ig2D = ag2D.get_ImageGeometry() + A = ProjectionOperator(ig2D, ag2D, device = "cpu") + n_subsets = 5 + partitioned_data=data2d.partition(n_subsets, 'sequential') + A_partitioned = ProjectionOperator(ig2D, partitioned_data.geometry, device = "cpu") + f_subsets = [] + for i in range(n_subsets): + fi=LeastSquares(A_partitioned.operators[i], partitioned_data[i]) + f_subsets.append(fi) + f=LeastSquares(A, data2d) + initial=ig2D.allocate() + + + rate = f.L + + alg = GD(initial=initial, + objective_function=f, update_objective_interval=500, + rate=rate, alpha=1e8) + alg.max_iteration = 200 + alg.run(verbose=0) + + + objective=SGFunction(f_subsets, sampler) + alg_stochastic = GD(initial=initial, + objective_function=objective, update_objective_interval=500, + step_size=1e-7, max_iteration =5000) + alg_stochastic.run( n_subsets*50, verbose=0) + self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) + + def test_full_gradient(self): + pass#TODO: + + def test_approximate_gradient(self): + pass#TODO: + def test_gradient(self): + pass + #TODO: + + \ No newline at end of file From 3a02a47589ecdb8feb8136ca2a56c539c0da365f Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 20 Oct 2023 12:58:37 +0000 Subject: [PATCH 070/152] More work on tests --- .../ApproximateGradientSumFunction.py | 2 +- .../Python/test/test_approximate_gradient.py | 26 +++++++++++++++++-- 2 files changed, 25 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 3e8014dd2d..bb41e5c90d 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -76,7 +76,7 @@ def full_gradient(self, x, out=None): def approximate_gradient(self, function_num, x, out=None): """ Computes the approximate gradient for each selected function at :code:`x`.""" - raise NotImplemented + raise NotImplementedError def gradient(self, x, out=None): """ Selects a random function and uses this to calculate the approximate gradient at :code:`x`.""" diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 6ae7b2c439..4219b5353e 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -72,10 +72,32 @@ from cil.plugins.astra import ProjectionOperator class TestApproximateGradientSumFunction(CCPiTestClass): + + def setUp(self): + self.sampler=Sampling(5) + self.initial = VectorData(np.zeros(25)) + self.b = VectorData(np.random.normal(0,1,25)) + self.functions=[] + for i in range(5): + diagonal=np.zeros(25) + diagonal[5*i:5*(i+1)]=1 + A=MatrixOperator(np.diag(diagonal)) + self.functions.append( LeastSquares(A, A.direct(self.b))) + if i==0: + self.objective=LeastSquares(A, A.direct(self.b)) + else: + self.objective+=LeastSquares(A, A.direct(self.b)) + self.stochastic_objective=ApproximateGradientSumFunction(self.functions, self.sampler) def test_init(self): - pass + with self.assertRaises(NotImplementedError): + self.stochastic_objective.approximate_gradient(3, self.initial) + with self.assertRaises(NotImplementedError): + self.stochastic_objective.gradient( self.initial) + self.assertAlmostEqual(self.stochastic_objective(self.initial), self.objective(self.initial)) + self.assertEqual(self.stochastic_objective.num_functions,5) + #TODO: -class Sampling(): +class Sampling(): #TO BE REPLACED BY SAMPLING CLASS THING WHEN THAT HAS BEEN MERGED def __init__(self, num_subsets, prob=None, seed=99): self.num_subsets=num_subsets np.random.seed(seed) From 10748efd1e99d81bbabe262309e497f08eb9dc9b Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 20 Oct 2023 15:52:30 +0000 Subject: [PATCH 071/152] SG tests --- .../Python/test/test_approximate_gradient.py | 73 +++++++++++-------- 1 file changed, 42 insertions(+), 31 deletions(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 4219b5353e..d6e4fc077a 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -137,6 +137,25 @@ class TestSGD(CCPiTestClass): # alg.run(20, verbose=0) # self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) + def setUp(self): + self.sampler=Sampling(5) + self.data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() + self.data.reorder('astra') + self.data2d=self.data.get_slice(vertical='centre') + ag2D = self.data2d.geometry + ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') + ig2D = ag2D.get_ImageGeometry() + self.A = ProjectionOperator(ig2D, ag2D, device = "cpu") + self.n_subsets = 5 + self.partitioned_data=self.data2d.partition(self.n_subsets, 'sequential') + self.A_partitioned = ProjectionOperator(ig2D, self.partitioned_data.geometry, device = "cpu") + f_subsets = [] + for i in range(self.n_subsets): + fi=LeastSquares(self.A_partitioned.operators[i],self. partitioned_data[i]) + f_subsets.append(fi) + self.f=LeastSquares(self.A, self.data2d) + self.f_stochastic=SGFunction(f_subsets,self.sampler) + self.initial=ig2D.allocate() def test_SGD_toy_example(self): sampler=Sampling(5) @@ -170,49 +189,41 @@ def test_SGD_toy_example(self): self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), b.as_array(),3) + + + def test_SGD_simulated_parallel_beam_data(self): - sampler=Sampling(5) - data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() - data.reorder('astra') - data2d=data.get_slice(vertical='centre') - ag2D = data2d.geometry - ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') - ig2D = ag2D.get_ImageGeometry() - A = ProjectionOperator(ig2D, ag2D, device = "cpu") - n_subsets = 5 - partitioned_data=data2d.partition(n_subsets, 'sequential') - A_partitioned = ProjectionOperator(ig2D, partitioned_data.geometry, device = "cpu") - f_subsets = [] - for i in range(n_subsets): - fi=LeastSquares(A_partitioned.operators[i], partitioned_data[i]) - f_subsets.append(fi) - f=LeastSquares(A, data2d) - initial=ig2D.allocate() - - rate = f.L - - alg = GD(initial=initial, - objective_function=f, update_objective_interval=500, + rate = self.f.L + alg = GD(initial=self.initial, + objective_function=self.f, update_objective_interval=500, rate=rate, alpha=1e8) alg.max_iteration = 200 alg.run(verbose=0) - objective=SGFunction(f_subsets, sampler) - alg_stochastic = GD(initial=initial, + objective=self.f_stochastic + alg_stochastic = GD(initial=self.initial, objective_function=objective, update_objective_interval=500, step_size=1e-7, max_iteration =5000) - alg_stochastic.run( n_subsets*50, verbose=0) + alg_stochastic.run( self.n_subsets*50, verbose=0) self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) + + + def test_approximate_gradient(self): + self.assertFalse((self.f_stochastic.full_gradient(self.initial)==self.f_stochastic.gradient(self.initial).array).all()) + + def test_sampler(self): + pass #TODO: + + def test_direct(self): + self.assertAlmostEqual(self.f_stochastic(self.initial), self.f(self.initial),1) + def test_full_gradient(self): - pass#TODO: + self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient(self.initial).array, self.f.gradient(self.initial).array,2) + + - def test_approximate_gradient(self): - pass#TODO: - def test_gradient(self): - pass - #TODO: \ No newline at end of file From 381342c0086c5cf4dc4bbd6af70fb0f293e5cea9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 25 Oct 2023 10:20:04 +0000 Subject: [PATCH 072/152] Changes to docstring --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index fb8ae11167..3cfa676f28 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -151,6 +151,9 @@ def get_norms(self, ): def set_norms(self, norms): '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. + + Args: + :param: norms (:obj:`list`): A list of positive real values the same length as the number of operators in the BlockOperator. ''' if len(norms) != len(self): raise ValueError( From c67818b7b70f002bb4ab3b7bd6afd31487cb533b Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 25 Oct 2023 14:37:32 +0000 Subject: [PATCH 073/152] Changes to tests --- .../ApproximateGradientSumFunction.py | 8 +- .../Python/test/test_approximate_gradient.py | 107 ++++++++---------- 2 files changed, 46 insertions(+), 69 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index bb41e5c90d..ad069bdb0e 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -19,10 +19,7 @@ from cil.optimisation.functions import SumFunction - import numbers - - class ApproximateGradientSumFunction(SumFunction): r"""ApproximateGradientSumFunction represents the following sum @@ -80,13 +77,10 @@ def approximate_gradient(self, function_num, x, out=None): def gradient(self, x, out=None): """ Selects a random function and uses this to calculate the approximate gradient at :code:`x`.""" - self.function_num = next(self.sampler) + self.function_num = self.sampler.next() # single function if isinstance(self.function_num, numbers.Number): return self.approximate_gradient(self.function_num, x, out=out) else: raise ValueError("Batch gradient is not yet implemented") - - - diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index d6e4fc077a..ce1600e650 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -93,9 +93,17 @@ def test_init(self): self.stochastic_objective.approximate_gradient(3, self.initial) with self.assertRaises(NotImplementedError): self.stochastic_objective.gradient( self.initial) - self.assertAlmostEqual(self.stochastic_objective(self.initial), self.objective(self.initial)) self.assertEqual(self.stochastic_objective.num_functions,5) + #TODO: test sampler saved correctly - when we have a sampling class + + def test_direct_call(self): + self.assertAlmostEqual(self.stochastic_objective(self.initial), self.objective(self.initial)) + + def test_full_gradient(self): + self.assertNumpyArrayAlmostEqual(self.stochastic_objective.full_gradient(self.initial).array, self.objective.gradient(self.initial).array) + def test_sampler(self): + pass #TODO: class Sampling(): #TO BE REPLACED BY SAMPLING CLASS THING WHEN THAT HAS BEEN MERGED def __init__(self, num_subsets, prob=None, seed=99): @@ -107,36 +115,13 @@ def __init__(self, num_subsets, prob=None, seed=99): else: self.prob=prob def __next__(self): - - return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + + return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + def next(self): + return int(np.random.choice(self.num_subsets, 1, p=self.prob)) class TestSGD(CCPiTestClass): - ## def test_SGD_one_function(self): - # ig = ImageGeometry(12,13,14) - # initial = ig.allocate() - # b = ig.allocate('random') - # identity = IdentityOperator(ig) - # - # norm2sq = LeastSquares(identity, b) - # rate = norm2sq.L / 3. - # sampler=Sampling(1) - - # objective=SGFunction([norm2sq], sampler) - # alg = GD(initial=initial, - # objective_function=objective, - # rate=rate, atol=1e-9, rtol=1e-6) - # alg.max_iteration = 1000 - # alg.run(verbose=0) - # self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - # alg = GD(initial=initial, - # objective_function=objective, - # rate=rate, max_iteration=20, - # update_objective_interval=2, - # atol=1e-9, rtol=1e-6)# - - # alg.run(20, verbose=0) - # self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) def setUp(self): self.sampler=Sampling(5) self.data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() @@ -157,6 +142,38 @@ def setUp(self): self.f_stochastic=SGFunction(f_subsets,self.sampler) self.initial=ig2D.allocate() + def test_approximate_gradient(self): + self.assertFalse((self.f_stochastic.full_gradient(self.initial)==self.f_stochastic.gradient(self.initial).array).all()) + + def test_sampler(self): + pass #TODO: when we get a sampler class loaded in + + def test_direct(self): + self.assertAlmostEqual(self.f_stochastic(self.initial), self.f(self.initial),1) + + def test_full_gradient(self): + self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient(self.initial).array, self.f.gradient(self.initial).array,2) + + + + def test_SGD_simulated_parallel_beam_data(self): + + rate = self.f.L + alg = GD(initial=self.initial, + objective_function=self.f, update_objective_interval=500, + rate=rate, alpha=1e8) + alg.max_iteration = 200 + alg.run(verbose=0) + + + objective=self.f_stochastic + alg_stochastic = GD(initial=self.initial, + objective_function=objective, update_objective_interval=500, + step_size=1e-7, max_iteration =5000) + alg_stochastic.run( self.n_subsets*50, verbose=0) + self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) + + def test_SGD_toy_example(self): sampler=Sampling(5) initial = VectorData(np.zeros(25)) @@ -190,40 +207,6 @@ def test_SGD_toy_example(self): self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), b.as_array(),3) - - - def test_SGD_simulated_parallel_beam_data(self): - - rate = self.f.L - alg = GD(initial=self.initial, - objective_function=self.f, update_objective_interval=500, - rate=rate, alpha=1e8) - alg.max_iteration = 200 - alg.run(verbose=0) - - - objective=self.f_stochastic - alg_stochastic = GD(initial=self.initial, - objective_function=objective, update_objective_interval=500, - step_size=1e-7, max_iteration =5000) - alg_stochastic.run( self.n_subsets*50, verbose=0) - self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) - - - - def test_approximate_gradient(self): - self.assertFalse((self.f_stochastic.full_gradient(self.initial)==self.f_stochastic.gradient(self.initial).array).all()) - - def test_sampler(self): - pass #TODO: - - def test_direct(self): - self.assertAlmostEqual(self.f_stochastic(self.initial), self.f(self.initial),1) - - def test_full_gradient(self): - self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient(self.initial).array, self.f.gradient(self.initial).array,2) - - \ No newline at end of file From 6b5ff83f8d774daef72165600b4360131d3df8b2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 25 Oct 2023 14:45:11 +0000 Subject: [PATCH 074/152] SGD tests including SumFunction --- .../cil/optimisation/functions/SGFunction.py | 2 +- .../Python/test/test_approximate_gradient.py | 46 ++++--------------- 2 files changed, 11 insertions(+), 37 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 5122250b34..67c92b9fd8 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -36,7 +36,7 @@ def __init__(self, functions, sampler): if isinstance(functions, list): super(SGFunction, self).__init__(functions, sampler) elif isinstance(functions, SumFunction): - super(SGFunction, self).__init__(*functions.functions, sampler) #TODO: is this the right thing to do? + super(SGFunction, self).__init__(functions.functions, sampler) #TODO: is this the right thing to do? else: raise TypeError("Input to functions should be a list of functions or a SumFunction") diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index ce1600e650..7de45588f6 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -20,49 +20,23 @@ #TODO: remove unused packages import unittest from utils import initialise_tests -import numpy + import numpy as np -from numpy import nan, inf + from cil.framework import VectorData -from cil.framework import ImageData -from cil.framework import AcquisitionData -from cil.framework import ImageGeometry -from cil.framework import AcquisitionGeometry -from cil.framework import BlockDataContainer -from cil.framework import BlockGeometry - -from cil.optimisation.operators import IdentityOperator -from cil.optimisation.operators import GradientOperator, BlockOperator, MatrixOperator - -from cil.optimisation.functions import LeastSquares, ZeroFunction, \ - L2NormSquared, OperatorCompositionFunction -from cil.optimisation.functions import MixedL21Norm, BlockFunction, L1Norm, KullbackLeibler -from cil.optimisation.functions import IndicatorBox - -from cil.optimisation.algorithms import Algorithm -from cil.optimisation.algorithms import GD -from cil.optimisation.algorithms import CGLS -from cil.optimisation.algorithms import SIRT -from cil.optimisation.algorithms import FISTA -from cil.optimisation.algorithms import SPDHG -from cil.optimisation.algorithms import PDHG -from cil.optimisation.algorithms import LADMM + from cil.utilities import dataexample -from cil.utilities import noise as applynoise -import time -import warnings -from cil.optimisation.functions import Rosenbrock +from cil.optimisation.functions import LeastSquares from cil.optimisation.functions import ApproximateGradientSumFunction from cil.optimisation.functions import SGFunction -#from cil.optimisation.utilities import Sampler +#from cil.optimisation.utilities import Sampler #TODO: +from cil.optimisation.functions import SumFunction +from cil.optimisation.operators import MatrixOperator +from cil.optimisation.algorithms import GD +from cil.framework import VectorData -from cil.framework import VectorData, VectorGeometry -from cil.utilities.quality_measures import mae, mse, psnr -# Fast Gradient Projection algorithm for Total Variation(TV) -from cil.optimisation.functions import TotalVariation -import logging from testclass import CCPiTestClass from utils import has_astra @@ -139,7 +113,7 @@ def setUp(self): fi=LeastSquares(self.A_partitioned.operators[i],self. partitioned_data[i]) f_subsets.append(fi) self.f=LeastSquares(self.A, self.data2d) - self.f_stochastic=SGFunction(f_subsets,self.sampler) + self.f_stochastic=SGFunction(SumFunction(*f_subsets),self.sampler) self.initial=ig2D.allocate() def test_approximate_gradient(self): From 876d4c99c805c83ac6efe1678d6ae0cb793dd1ef Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 26 Oct 2023 17:01:45 +0100 Subject: [PATCH 075/152] Added size to the BlockOperator --- .../Python/cil/optimisation/operators/BlockOperator.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 3cfa676f28..3126507a88 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -155,7 +155,7 @@ def set_norms(self, norms): Args: :param: norms (:obj:`list`): A list of positive real values the same length as the number of operators in the BlockOperator. ''' - if len(norms) != len(self): + if len(norms) != self.size: raise ValueError( "The length of the list of norms should be equal to the number of operators in the BlockOperator") @@ -384,8 +384,13 @@ def sum_abs_col(self): return BlockDataContainer(*res) def __len__(self): - return len(self.operators) + + @property + def size(self): + return len(self.operators) + + def __getitem__(self, index): '''returns the index-th operator in the block irrespectively of it's shape''' From b983e2f92f92c3cc706ba103ea4b8adb0ac389f6 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 31 Oct 2023 11:42:34 +0000 Subject: [PATCH 076/152] Removed precalculated_norms and pull the prob_weights from the sampler --- .../cil/optimisation/algorithms/SPDHG.py | 77 ++++++------------- .../cil/optimisation/utilities/sampler.py | 19 +++-- Wrappers/Python/test/test_algorithms.py | 4 +- 3 files changed, 37 insertions(+), 63 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 216af804a5..82f4ff8b8f 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -24,7 +24,7 @@ import logging from cil.optimisation.utilities import Sampler from numbers import Number - +import numpy as np class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -49,19 +49,16 @@ class SPDHG(Algorithm): List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets - precalculated_norms : list of floats - precalculated list of norms of the operators #TODO: to remove based on pull request #1513 **kwargs: prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats - precalculated list of norms of the operators. To be deprecated - replaced by precalculated_norms + precalculated list of norms of the operators. To be deprecated and placed by the `set_norms` functionalist in a BlockOperator. Example ------- @@ -99,27 +96,30 @@ class SPDHG(Algorithm): ''' def __init__(self, f=None, g=None, operator=None, - initial=None, precalculated_norms=None, sampler=None, **kwargs): + initial=None, sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) - if precalculated_norms is None and kwargs.get('prob') is not None: - precalculated_norms = kwargs.get('norms', None) + if kwargs.get('norms', None) is not None: + operator.set_norms(kwargs.get('norms')) warnings.warn( - 'norms is being deprecated, pass instead precalculated_norms=your_custom_norms') + ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') + if sampler is not None: - self.prob_weights = sampler.prob + if kwargs.get('prob', None) is not None: + warnings.warn('`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: if kwargs.get('prob', None) is not None: - warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)') - self.prob_weights = kwargs.get('prob', [1/len(operator)]*len(operator)) - sampler=Sampler.randomWithReplacement(len(operator), prob=self.prob_weights) + warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') + sampler=Sampler.randomWithReplacement(len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) - if f is not None and operator is not None and g is not None: + if f is not None and operator is not None and g is not None and sampler is not None: self.set_up(f=f, g=g, operator=operator, - initial=initial, sampler=sampler, precalculated_norms=precalculated_norms) + initial=initial, sampler=sampler) + + @property def sigma(self): return self._sigma @@ -273,7 +273,7 @@ def check_convergence(self): return False def set_up(self, f, g, operator, - initial=None, sampler=None, precalculated_norms=None): + initial=None, sampler=None): '''set-up of the algorithm Parameters ---------- @@ -293,8 +293,6 @@ def set_up(self, f, g, operator, parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets - precalculated_norms : list of floats - precalculated list of norms of the operators ''' logging.info("{} setting up".format(self.__class__.__name__, )) @@ -303,41 +301,14 @@ def set_up(self, f, g, operator, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - - if precalculated_norms is None: - # Compute norm of each sub-operator - self.norms = [self.operator.get_item(i, 0).norm() - for i in range(self.ndual_subsets)] - else: - if len(precalculated_norms) == self.ndual_subsets: - if all(isinstance(x, Number) for x in precalculated_norms): - if all(x > 0 for x in precalculated_norms): - pass - else: - raise ValueError( - "The norms of the operators should be positive") - else: - raise ValueError( - "The norms of the operators should be a Number") - else: - raise ValueError( - "Please pass a list of floats to the precalculated norms with the same number of entries as number of operators") - self.norms = precalculated_norms - - if sampler is None: - if self.prob_weights is None: - self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets - self.sampler = Sampler.randomWithReplacement( - self.ndual_subsets, prob=self.prob_weights) - else: - if not isinstance(sampler, Sampler): - raise ValueError( - "The sampler should be an instance of the cil.optimisation.utilities.Sampler class") - self.sampler = sampler - if sampler.prob is None: - self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets - else: - self.prob_weights = sampler.prob + self.sampler=sampler + self.norms = operator.get_norms() + + self.prob_weights=sampler.prob_weights #TODO: write unit tests for this #TODO: consider the case it is uniform and not saving the array + if self.prob_weights is None: + x=sampler.get_sampler(10000) + self.prob_weights=[np.count_nonzero((x==i)) for i in range(len(operator))] + self.prob_weights/=sum(self.prob_weights) # might not want to do this until it is called (if computationally expensive) self.set_step_sizes_default() diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 0691318840..a19a946de4 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -48,6 +48,8 @@ class Sampler(): seed:int, default=None Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -134,7 +136,7 @@ def sequential(num_indices): 0 """ order = list(range(num_indices)) - sampler = Sampler(num_indices, sampling_type='sequential', order=order) + sampler = Sampler(num_indices, sampling_type='sequential', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod @@ -167,9 +169,9 @@ def customOrder(customlist): [1 4 6 7 8] """ - num_indices = len(customlist) + num_indices = len(customlist)#TODO: is this an issue sampler = Sampler( - num_indices, sampling_type='custom_order', order=customlist) + num_indices, sampling_type='custom_order', order=customlist, prob_weights=None)#TODO: return sampler @staticmethod @@ -231,7 +233,7 @@ def _herman_meyer_order(n): order = _herman_meyer_order(num_indices) sampler = Sampler( - num_indices, sampling_type='herman_meyer', order=order) + num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod @@ -277,7 +279,7 @@ def staggered(num_indices, offset): indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = Sampler(num_indices, sampling_type='staggered', order=order) + sampler = Sampler(num_indices, sampling_type='staggered', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod @@ -316,7 +318,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): if prob == None: prob = [1/num_indices] * num_indices sampler = Sampler( - num_indices, sampling_type='random_with_replacement', prob=prob, seed=seed) + num_indices, sampling_type='random_with_replacement', prob=prob, seed=seed, prob_weights=prob) return sampler @staticmethod @@ -349,14 +351,15 @@ def randomWithoutReplacement(num_indices, seed=None, shuffle=True): order = list(range(num_indices)) sampler = Sampler(num_indices, sampling_type='random_without_replacement', - order=order, shuffle=shuffle, seed=seed) + order=order, shuffle=shuffle, seed=seed, prob_weights=[1/num_indices]*num_indices) return sampler - def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=None, seed=None): + def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=None, seed=None, prob_weights=None): """ This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. """ + self.prob_weights=prob_weights self.type = sampling_type self.num_indices = num_indices if seed is not None: diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index e21d8c14d8..1c372c0306 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -830,9 +830,9 @@ def test_SPDHG_defaults_and_setters(self): def test_spdhg_non_default_init(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10, precalculated_norms=[1]*self.subsets ) + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) - self.assertListEqual(spdhg.norms, [1]*self.subsets) + self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) self.assertTrue(isinstance(spdhg.sampler, Sampler)) self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) From 71cbdf9c03f2afb8d937ba45857121082b0d3cd8 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 31 Oct 2023 12:11:20 +0000 Subject: [PATCH 077/152] Changes to setting tau and new unit test --- .../cil/optimisation/algorithms/SPDHG.py | 18 ++++++++++-------- Wrappers/Python/test/test_algorithms.py | 10 ++++++++++ 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 82f4ff8b8f..eaee7ce942 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -165,9 +165,9 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): "We currently only support scalar values of gamma") self._sigma = [gamma * rho / ni for ni in self.norms] - - self._tau = min([pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)]) + values=[pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)] + self._tau = min([value for value in values if value>1e-6]) #TODO: what value should this be self._tau *= (rho / gamma) def set_step_sizes_custom(self, sigma=None, tau=None): @@ -237,8 +237,9 @@ def set_step_sizes_custom(self, sigma=None, tau=None): gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] if tau is None: - self._tau = min([pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)]) + values=[pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)] + self._tau = min([value for value in values if value>1e-6]) #TODO: what value should this be self._tau *= (rho / gamma) else: if isinstance(tau, Number): @@ -304,11 +305,12 @@ def set_up(self, f, g, operator, self.sampler=sampler self.norms = operator.get_norms() - self.prob_weights=sampler.prob_weights #TODO: write unit tests for this #TODO: consider the case it is uniform and not saving the array + self.prob_weights=sampler.prob_weights #TODO: consider the case it is uniform and not saving the array if self.prob_weights is None: - x=sampler.get_sampler(10000) + x=sampler.get_samples(10000) self.prob_weights=[np.count_nonzero((x==i)) for i in range(len(operator))] - self.prob_weights/=sum(self.prob_weights) + total=sum(self.prob_weights) + self.prob_weights[:] = [x / total for x in self.prob_weights] # might not want to do this until it is called (if computationally expensive) self.set_step_sizes_default() diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 1c372c0306..f582ca3181 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -838,6 +838,16 @@ def test_spdhg_non_default_init(self): self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) + + def test_spdhg_custom_sampler(self): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.customOrder([0,0,0,0]), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + self.assertListEqual(spdhg.prob_weights, [1]+[0]*(len(self.A)-1)) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.customOrder([0,1,0,1]), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + self.assertListEqual(spdhg.prob_weights, [.5]+[.5]+[0]*(len(self.A)-2)) + + def test_spdhg_check_convergence(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) From 8f2463478f6a13b5edb79d2dbbb0b0a9fea05fa3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 31 Oct 2023 14:46:49 +0000 Subject: [PATCH 078/152] Just some comments --- .../optimisation/functions/ApproximateGradientSumFunction.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index ad069bdb0e..4826f6c04a 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -20,7 +20,7 @@ from cil.optimisation.functions import SumFunction import numbers -class ApproximateGradientSumFunction(SumFunction): +class ApproximateGradientSumFunction(SumFunction): #TODO: should be an abstract base class r"""ApproximateGradientSumFunction represents the following sum @@ -71,7 +71,7 @@ def full_gradient(self, x, out=None): r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ return super(ApproximateGradientSumFunction, self).gradient(x, out=out) - def approximate_gradient(self, function_num, x, out=None): + def approximate_gradient(self, function_num, x, out=None):#TODO: x, function_num instead """ Computes the approximate gradient for each selected function at :code:`x`.""" raise NotImplementedError From f0f4de3cbcb6f5fbc8ce061fc345d3a8f50a18a2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 2 Nov 2023 17:38:53 +0000 Subject: [PATCH 079/152] Changes after discussion with Edo and Gemma --- .../optimisation/operators/BlockOperator.py | 38 +++++++++---------- .../cil/optimisation/operators/Operator.py | 15 +++++--- Wrappers/Python/test/test_BlockOperator.py | 10 ++--- 3 files changed, 32 insertions(+), 31 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 3cfa676f28..8bb92e734b 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -56,16 +56,11 @@ class BlockOperator(Operator): def __init__(self, *args, **kwargs): ''' - Class creator + This is the class creator. - Note: - Do not include the `self` parameter in the ``Args`` section. - - Args: + Parameters: :param: vararg (Operator): Operators in the block. - :param: shape (:obj:`tuple`, optional): If shape is passed the Operators in - vararg are considered input in a row-by-row fashion. - Shape and number of Operators must match. + :param: shape (:obj:`tuple`, optional): If shape is passed the Operators in vararg are considered input in a row-by-row fashion. Note that shape and number of Operators must match. Example: BlockOperator(op0,op1) results in a row block @@ -129,7 +124,7 @@ def row_wise_compatible(self): return compatible def get_item(self, row, col): - '''returns the Operator at specified row and col''' + '''Returns the Operator at specified row and col''' if row > self.shape[0]: raise ValueError( 'Requested row {} > max {}'.format(row, self.shape[0])) @@ -142,9 +137,9 @@ def get_item(self, row, col): def norm(self): '''Returns the Euclidean norm of the norms of the individual operators in the BlockOperators ''' - return numpy.sqrt(numpy.sum(numpy.array(self.get_norms())**2)) + return numpy.sqrt(numpy.sum(numpy.array(self.get_norms_as_list())**2)) - def get_norms(self, ): + def get_norms_as_list(self, ): '''Returns a list of the individual norms of the Operators in the BlockOperator ''' return [op.norm() for op in self.operators] @@ -153,7 +148,8 @@ def set_norms(self, norms): '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. Args: - :param: norms (:obj:`list`): A list of positive real values the same length as the number of operators in the BlockOperator. + + param norms (:obj:`list`): A list of positive real values the same length as the number of operators in the BlockOperator. ''' if len(norms) != len(self): raise ValueError( @@ -294,7 +290,9 @@ def get_output_shape(self, xshape, adjoint=False): def __rmul__(self, scalar): '''Defines the left multiplication with a scalar - :paramer scalar: (number or iterable containing numbers): + Args: + + :`scalar`: (number or iterable containing numbers): Returns: a block operator with Scaled Operators inside''' if isinstance(scalar, list) or isinstance(scalar, tuple) or \ @@ -312,9 +310,9 @@ def __rmul__(self, scalar): @property def T(self): - '''Return the transposed of self - - input in a row-by-row''' + '''Returns the transposed of self. + + Recall the input list is shaped in a row-by-row fashion''' newshape = (self.shape[1], self.shape[0]) oplist = [] for col in range(newshape[1]): @@ -323,7 +321,7 @@ def T(self): return type(self)(*oplist, shape=newshape) def domain_geometry(self): - '''returns the domain of the BlockOperator + '''Returns the domain of the BlockOperator If the shape of the BlockOperator is (N,1) the domain is a ImageGeometry or AcquisitionGeometry. Otherwise it is a BlockGeometry. @@ -345,7 +343,7 @@ def domain_geometry(self): # shape=self.shape) def range_geometry(self): - '''returns the range of the BlockOperator''' + '''Returns the range of the BlockOperator''' tmp = [] for i in range(self.shape[0]): @@ -388,9 +386,9 @@ def __len__(self): return len(self.operators) def __getitem__(self, index): - '''returns the index-th operator in the block irrespectively of it's shape''' + '''Returns the index-th operator in the block irrespectively of it's shape''' return self.operators[index] def get_as_list(self): - '''returns the list of operators''' + '''Returns the list of operators''' return self.operators diff --git a/Wrappers/Python/cil/optimisation/operators/Operator.py b/Wrappers/Python/cil/optimisation/operators/Operator.py index cc18e4fe6a..c10032fca2 100644 --- a/Wrappers/Python/cil/optimisation/operators/Operator.py +++ b/Wrappers/Python/cil/optimisation/operators/Operator.py @@ -72,12 +72,15 @@ def norm(self, **kwargs): def set_norm(self, norm=None): '''Sets the norm of the operator to a custom value. ''' - - if norm is not None and isinstance(norm, Number) is False: - raise TypeError("Norm must be a number or None, got {} of type {}".format(norm, type(norm))) - - if isinstance(norm, Number) and norm <=0: - raise ValueError("Norm must be a positive real valued number or None, got {}".format(norm)) + + if norm is not None: + if isinstance(norm, Number): + if norm <= 0: + raise ValueError( + "Norm must be a positive real valued number or None, got {}".format(norm)) + else: + raise TypeError( + "Norm must be a number or None, got {} of type {}".format(norm, type(norm))) self._norm = norm diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 0cfaacffa5..34219054e8 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -45,14 +45,14 @@ def test_norms(self): self.assertAlmostEqual(G.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(G2.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) - self.assertAlmostEqual(A.get_norms()[0], numpy.sqrt(8), 2) - self.assertAlmostEqual(A.get_norms()[1], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms_as_list()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms_as_list()[1], numpy.sqrt(8), 2) #sets_norm A.set_norms([2,3]) #gets cached norm - self.assertListEqual(A.get_norms(), [2,3], 2) + self.assertListEqual(A.get_norms_as_list(), [2,3], 2) self.assertEqual(A.norm(), numpy.sqrt(13)) @@ -64,8 +64,8 @@ def test_norms(self): A.set_norms([None, None]) #recalculates norm self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) - self.assertAlmostEqual(A.get_norms()[0], numpy.sqrt(8), 2) - self.assertAlmostEqual(A.get_norms()[1], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms_as_list()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms_as_list()[1], numpy.sqrt(8), 2) #Check the warnings on set_norms #Check the length of list that is passed From 26584c94206b12765b8ed4281b5dbf86d89fdb75 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 2 Nov 2023 17:51:46 +0000 Subject: [PATCH 080/152] Documentation changes --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 1cd1d8a4b6..a0575c8825 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -263,11 +263,11 @@ def adjoint(self, x, out=None): ) def is_linear(self): - '''returns whether all the elements of the BlockOperator are linear''' + '''Returns whether all the elements of the BlockOperator are linear''' return functools.reduce(lambda x, y: x and y.is_linear(), self.operators, True) def get_output_shape(self, xshape, adjoint=False): - '''returns the shape of the output BlockDataContainer + '''Returns the shape of the output BlockDataContainer A(N,M) direct u(M,1) -> N,1 A(N,M)^T adjoint u(N,1) -> M,1 From d182423403a20b2d90eb359a2c6cfccc11239985 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 3 Nov 2023 13:24:02 +0000 Subject: [PATCH 081/152] Changes to SPDHG with block_norms --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index eaee7ce942..ee694f32d7 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -303,7 +303,7 @@ def set_up(self, f, g, operator, self.operator = operator self.ndual_subsets = self.operator.shape[0] self.sampler=sampler - self.norms = operator.get_norms() + self.norms = operator.get_norms_as_list() self.prob_weights=sampler.prob_weights #TODO: consider the case it is uniform and not saving the array if self.prob_weights is None: From ad86a5802679642afc02e1979f38cc5fd9661624 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 6 Nov 2023 13:02:50 +0000 Subject: [PATCH 082/152] Started setting up factory methods --- .../cil/optimisation/utilities/sampler.py | 385 +++++++++++++----- Wrappers/Python/test/test_sampler.py | 143 +++---- 2 files changed, 349 insertions(+), 179 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index a19a946de4..5631d511de 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -20,6 +20,255 @@ import math import time +class SamplerFromFunction(): + def __init__(self, num_indices,function, sampling_type='from_function', prob_weights=None): + """ + TODO: How should a user call this? + A class to select from a list of indices {0, 1, …, S-1} + The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + + + Parameters + ---------- + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + sampling_type:str + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + + + function: TODO: + + + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + + """ + self.sampling_type=sampling_type + self.num_indices=num_indices + self.function=function + self.prob_weights=prob_weights + if self.prob_weights is None: + self.prob_weights=[1/num_indices]*num_indices + self.iteration_number=-1 + + + + def next(self): + """ + + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + """ + + self.iteration_number+=1 + return (self.function(self.iteration_number)) + + def __next__(self): + """ + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + Allows the user to call next(sampler), to get the same result as sampler.next()""" + return (self.next()) + + def get_samples(self, num_samples=20): + """ + Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + + num_samples: int, default=20 + The number of samples to return. + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_samples()) + [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] + """ + save_last_index = self.iteration_number + self.iteration_number = -1 + output = [self.next() for _ in range(num_samples)] + self.iteration_number = save_last_index + return (np.array(output)) + + +class SamplerFromOrder(): + + def __init__(self, num_indices, order, sampling_type, prob_weights=None): + + """ + TODO: How should a user call this? + A class to select from a list of indices {0, 1, …, S-1} + The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + + + Parameters + ---------- + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + sampling_type:str + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + + order: list of indices + The list of indices the method selects from using next. + + + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + + + """ + self.prob_weights=prob_weights + self.type = sampling_type + self.num_indices = num_indices + self.order = order + self.initial_order = self.order + + + self.last_index = len(order)-1 + + + + def next(self): + """ + + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + """ + + self.last_index = (self.last_index+1) % len(self.order) + return (self.order[self.last_index]) + + def __next__(self): + """ + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + Allows the user to call next(sampler), to get the same result as sampler.next()""" + return (self.next()) + + def get_samples(self, num_samples=20): + """ + Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + + num_samples: int, default=20 + The number of samples to return. + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_samples()) + [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] + + """ + save_last_index = self.last_index + self.last_index = len(self.order)-1 + output = [self.next() for _ in range(num_samples)] + self.last_index = save_last_index + return (np.array(output)) + + +class SamplerRandom(): + + r""" + A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. + The function next() outputs a single next index from the list {0,1,…,S-1} . To be run again and again, depending on how many iterations. + + + Parameters + ---------- + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + sampling_type:str + The sampling type used. + + + replace= bool + If True, sample with replace, otherwise sample without replacement + + + prob: list of floats of length num_indices that sum to 1. + For random sampling with replacement, this is the probability for each index to be called by next. + + seed:int, default=None + Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. + + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + + """ + def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): + """ + This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. + + """ + + self.replace=replace + self.prob=prob + if prob is None: + self.prob=[1/num_indices]*num_indices + if replace: + self.prob_weights=prob + else: + self.prob_weights=[1/num_indices]*num_indices + self.type = sampling_type + self.num_indices = num_indices + if seed is not None: + self.seed = seed + else: + self.seed = int(time.time()) + self.generator = np.random.RandomState(self.seed) + + + + + def next(self): + """ + + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with and without replacement. + + """ + if self.replace: + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + else: + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + + + + def __next__(self): + """ + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + Allows the user to call next(sampler), to get the same result as sampler.next()""" + return (self.next()) + + def get_samples(self, num_samples=20): + """ + Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + + num_samples: int, default=20 + The number of samples to return. + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_samples()) + [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] + + """ + save_generator = self.generator + self.generator = np.random.RandomState(self.seed) + output = [self.next() for _ in range(num_samples)] + self.generator = save_generator + return (np.array(output)) class Sampler(): @@ -39,9 +288,6 @@ class Sampler(): order: list of indices The list of indices the method selects from using next. - shuffle= bool, default=False - If True, the drawing order changes every each `num_indices`, otherwise the same random order each time the data is sampled is used. - prob: list of floats of length num_indices that sum to 1. For random sampling with replacement, this is the probability for each index to be called by next. @@ -136,21 +382,23 @@ def sequential(num_indices): 0 """ order = list(range(num_indices)) - sampler = Sampler(num_indices, sampling_type='sequential', order=order, prob_weights=[1/num_indices]*num_indices) + sampler = SamplerFromOrder(num_indices, sampling_type='sequential', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod - def customOrder(customlist): + def customOrder(num_indices, customlist, prob_weights=None): #TODO: swap to underscores """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. customlist: list of indices The list that will be sampled from in order. + #TODO: + Example -------- - >>> sampler=Sampler.customOrder([1,4,6,7,8,9,11]) + >>> sampler=Sampler.customOrder(12,[1,4,6,7,8,9,11]) >>> print(sampler.get_samples(11)) >>> for _ in range(9): >>> print(sampler.next()) @@ -169,9 +417,15 @@ def customOrder(customlist): [1 4 6 7 8] """ - num_indices = len(customlist)#TODO: is this an issue - sampler = Sampler( - num_indices, sampling_type='custom_order', order=customlist, prob_weights=None)#TODO: + if prob_weights is None: + temp_list=[] + for i in range(num_indices): + temp_list.append(customlist.count(i)) + total=sum(temp_list) + prob_weights=[x/total for x in temp_list] + + sampler = SamplerFromOrder( + num_indices, sampling_type='custom_order', order=customlist, prob_weights=prob_weights) return sampler @staticmethod @@ -232,7 +486,7 @@ def _herman_meyer_order(n): return order order = _herman_meyer_order(num_indices) - sampler = Sampler( + sampler = SamplerFromOrder( num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @@ -279,7 +533,7 @@ def staggered(num_indices, offset): indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = Sampler(num_indices, sampling_type='staggered', order=order, prob_weights=[1/num_indices]*num_indices) + sampler = SamplerFromOrder(num_indices, sampling_type='staggered', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod @@ -317,12 +571,12 @@ def randomWithReplacement(num_indices, prob=None, seed=None): if prob == None: prob = [1/num_indices] * num_indices - sampler = Sampler( - num_indices, sampling_type='random_with_replacement', prob=prob, seed=seed, prob_weights=prob) + sampler = SamplerRandom( + num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @staticmethod - def randomWithoutReplacement(num_indices, seed=None, shuffle=True): + def randomWithoutReplacement(num_indices, seed=None, prob=None): """ Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. @@ -333,8 +587,6 @@ def randomWithoutReplacement(num_indices, seed=None, shuffle=True): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - shuffle:boolean, default=True - If True, the drawing order changes every each `num_indices`, otherwise the same random order each time the data is sampled is used. Example ------- @@ -342,105 +594,34 @@ def randomWithoutReplacement(num_indices, seed=None, shuffle=True): >>> print(sampler.get_samples(16)) [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] - Example - ------- - >>> sampler=Sampler.randomWithoutReplacement(7, seed=1, shuffle=False) - >>> print(sampler.get_samples(16)) - [6 2 1 0 4 3 5 6 2 1 0 4 3 5 6 2] - """ - order = list(range(num_indices)) - sampler = Sampler(num_indices, sampling_type='random_without_replacement', - order=order, shuffle=shuffle, seed=seed, prob_weights=[1/num_indices]*num_indices) - return sampler - - def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=None, seed=None, prob_weights=None): """ - This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. - """ - self.prob_weights=prob_weights - self.type = sampling_type - self.num_indices = num_indices - if seed is not None: - self.seed = seed - else: - self.seed = int(time.time()) - self.generator = np.random.RandomState(self.seed) - self.order = order - if order is not None: - self.iterator = self._next_order - self.shuffle = shuffle - if self.type == 'random_without_replacement' and self.shuffle == False: - self.order = self.generator.permutation(self.order) - self.initial_order = self.order - self.prob = prob - if prob is not None: - self.iterator = self._next_prob - self.last_index = self.num_indices-1 - - def _next_order(self): - """ - The user should call sampler.next() or next(sampler) rather than use this function. - - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - This function is used by samplers that sample without replacement. + sampler = SamplerRandom(num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob ) + return sampler + @staticmethod + def from_function(num_indices, function): """ - # print(self.last_index) - if self.shuffle == True and self.last_index == self.num_indices-1: - self.order = self.generator.permutation(self.order) - # print(self.order) - self.last_index = (self.last_index+1) % self.num_indices - return (self.order[self.last_index]) - - def _next_prob(self): - """ - The user should call sampler.next() or next(sampler) rather than use this function. + Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices TODO: - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with replacement. - - """ - return int(self.generator.choice(self.num_indices, 1, p=self.prob)) - def next(self): - """ A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - return (self.iterator()) + function: TODO: - def __next__(self): - """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + Example + ------- + TODO: - Allows the user to call next(sampler), to get the same result as sampler.next()""" - return (self.next()) - def get_samples(self, num_samples=20): """ - Function that takes an index, num_samples, and returns the first num_samples as a numpy array. - num_samples: int, default=20 - The number of samples to return. + sampler = SamplerFromFunction(num_indices, sampling_type='random_without_replacement', function=function ) + return sampler - Example - ------- - >>> sampler=Sampler.randomWithReplacement(5) - >>> print(sampler.get_samples()) - [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] - """ - save_generator = self.generator - save_last_index = self.last_index - self.last_index = self.num_indices-1 - save_order = self.order - self.order = self.initial_order - self.generator = np.random.RandomState(self.seed) - output = [self.next() for _ in range(num_samples)] - self.generator = save_generator - self.order = save_order - self.last_index = save_last_index - return (np.array(output)) + \ No newline at end of file diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index d751034d45..3de70afd05 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -37,55 +37,43 @@ def test_init(self): self.assertEqual(sampler.type, 'sequential') self.assertListEqual(sampler.order, list(range(10))) self.assertListEqual(sampler.initial_order, list(range(10))) - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) self.assertEqual(sampler.last_index, 9) + self.assertListEqual(sampler.prob_weights, [1/10]*10) - sampler = Sampler.randomWithoutReplacement(7, shuffle=True) + sampler = Sampler.randomWithoutReplacement(7) self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler.type, 'random_without_replacement') - self.assertListEqual(sampler.order, list(range(7))) - self.assertListEqual(sampler.initial_order, list(range(7))) - self.assertEqual(sampler.shuffle, True) - self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_index, 6) + self.assertEqual(sampler.prob, [1/7]*7) + self.assertListEqual(sampler.prob_weights, sampler.prob) - sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) + sampler = Sampler.randomWithoutReplacement(8, seed=1) self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler.type, 'random_without_replacement') - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_index, 7) + self.assertEqual(sampler.prob, [1/8]*8) self.assertEqual(sampler.seed, 1) + self.assertListEqual(sampler.prob_weights, sampler.prob) sampler = Sampler.hermanMeyer(12) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'herman_meyer') - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) self.assertEqual(sampler.last_index, 11) self.assertListEqual( sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.initial_order, [ 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.randomWithReplacement(5) self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler.type, 'random_with_replacement') - self.assertEqual(sampler.order, None) - self.assertEqual(sampler.initial_order, None) - self.assertEqual(sampler.shuffle, False) self.assertListEqual(sampler.prob, [1/5] * 5) - self.assertEqual(sampler.last_index, 4) + self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.randomWithReplacement(4, [0.7, 0.1, 0.1, 0.1]) self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler.type, 'random_with_replacement') - self.assertEqual(sampler.order, None) - self.assertEqual(sampler.initial_order, None) - self.assertEqual(sampler.shuffle, False) self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.last_index, 3) + self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) self.assertEqual(sampler.num_indices, 21) @@ -94,76 +82,73 @@ def test_init(self): 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) self.assertListEqual(sampler.initial_order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) self.assertEqual(sampler.last_index, 20) + self.assertListEqual(sampler.prob_weights, [1/21] * 21) try: Sampler.staggered(22, 25) except ValueError: self.assertTrue(True) - sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.num_indices, 7) + sampler = Sampler.customOrder(12, [1, 4, 6, 7, 8, 9, 11]) + self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'custom_order') self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) self.assertListEqual(sampler.initial_order, [1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) self.assertEqual(sampler.last_index, 6) + self.assertListEqual(sampler.prob_weights, [ + 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) - - def test_sequential_iterator_and_get_samples(self): - - #Test the squential sampler + + # Test the squential sampler sampler = Sampler.sequential(10) for i in range(25): self.assertEqual(next(sampler), i % 10) - if i%5==0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(), np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) - + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) + sampler = Sampler.sequential(10) for i in range(25): - self.assertEqual(sampler.next(), i % 10) # Repeat the test for .next() - if i%5==0: - self.assertNumpyArrayEqual(sampler.get_samples(), np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) - - def test_random_without_replacement_iterator_and_get_samples(self): - #Test the random without replacement sampler - sampler = Sampler.randomWithoutReplacement(7, shuffle=True, seed=1) - order = [6, 2, 1, 0, 4, 3, 5, 1, 0, 4, 2, 5, - 6, 3, 3, 2, 1, 4, 0, 5, 6, 2, 6, 3, 4] + # Repeat the test for .next() + self.assertEqual(sampler.next(), i % 10) + if i % 5 == 0: + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) + + def test_random_without_replacement_iterator_and_get_samples(self): + # Test the random without replacement sampler + sampler = Sampler.randomWithoutReplacement(7, seed=1) + order = [2, 5, 0, 2, 1, 0, 1, 2, 2, 3, 2, 4, + 1, 6, 0, 4, 2, 3, 0, 1, 5, 6, 2, 4, 6] for i in range(25): self.assertEqual(next(sampler), order[i]) - if i%4==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(6), np.array(order[:6])) - - #Repeat the test for shuffle=False - sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) - order = [7, 2, 1, 6, 0, 4, 3, 5] - for i in range(25): - self.assertEqual(sampler.next(), order[i % 8]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(5), np.array(order[:5])) + if i % 4 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(6), np.array(order[:6])) - def test_herman_meyer_iterator_and_get_samples(self): - #Test the Herman Meyer sampler + def test_herman_meyer_iterator_and_get_samples(self): + # Test the Herman Meyer sampler sampler = Sampler.hermanMeyer(12) - order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, + 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] for i in range(25): self.assertEqual(sampler.next(), order[i % 12]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) - def test_random_with_replacement_iterator_and_get_samples(self): - #Test the Random with replacement sampler + def test_random_with_replacement_iterator_and_get_samples(self): + # Test the Random with replacement sampler sampler = Sampler.randomWithReplacement(5, seed=5) - order=[1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] + order = [1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, + 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] for i in range(25): self.assertEqual(next(sampler), order[i]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) sampler = Sampler.randomWithReplacement( 4, [0.7, 0.1, 0.1, 0.1], seed=5) @@ -171,24 +156,28 @@ def test_random_with_replacement_iterator_and_get_samples(self): 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] for i in range(25): self.assertEqual(sampler.next(), order[i]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) - def test_staggered_iterator_and_get_samples(self): - #Test the staggered sampler + def test_staggered_iterator_and_get_samples(self): + # Test the staggered sampler sampler = Sampler.staggered(21, 4) order = [0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] for i in range(25): self.assertEqual(next(sampler), order[i % 21]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) - - def test_custom_order_iterator_and_get_samples(self): - #Test the custom order sampler - sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) - order = [1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11] + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(10), np.array(order[:10])) + + def test_custom_order_iterator_and_get_samples(self): + # Test the custom order sampler + sampler = Sampler.customOrder(12, [1, 4, 6, 7, 8, 9, 11]) + order = [1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, + 11, 1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11] for i in range(25): self.assertEqual(sampler.next(), order[i % 7]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) \ No newline at end of file + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(10), np.array(order[:10])) From 40ba3f44565435aebe4387869ec16fc06eedc4f8 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 6 Nov 2023 14:38:18 +0000 Subject: [PATCH 083/152] Added function sampler --- .../cil/optimisation/algorithms/SPDHG.py | 2 +- .../cil/optimisation/utilities/sampler.py | 97 ++++++++++++++----- Wrappers/Python/test/test_algorithms.py | 8 +- Wrappers/Python/test/test_sampler.py | 48 ++++++--- 4 files changed, 111 insertions(+), 44 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index ee694f32d7..7d0dc6c8fd 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -111,7 +111,7 @@ def __init__(self, f=None, g=None, operator=None, else: if kwargs.get('prob', None) is not None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - sampler=Sampler.randomWithReplacement(len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) + sampler=Sampler.random_with_replacement(len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) if f is not None and operator is not None and g is not None and sampler is not None: diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 5631d511de..0e7b908a33 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -23,9 +23,9 @@ class SamplerFromFunction(): def __init__(self, num_indices,function, sampling_type='from_function', prob_weights=None): """ - TODO: How should a user call this? - A class to select from a list of indices {0, 1, …, S-1} - The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + The user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. + A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. + The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. Parameters @@ -37,15 +37,21 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". - function: TODO: - + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + + Note + ----- + If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise + the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. + + + """ - self.sampling_type=sampling_type + self.type=sampling_type self.num_indices=num_indices self.function=function self.prob_weights=prob_weights @@ -82,7 +88,7 @@ def get_samples(self, num_samples=20): Example ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ @@ -98,7 +104,7 @@ class SamplerFromOrder(): def __init__(self, num_indices, order, sampling_type, prob_weights=None): """ - TODO: How should a user call this? + The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. A class to select from a list of indices {0, 1, …, S-1} The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. @@ -159,7 +165,7 @@ def get_samples(self, num_samples=20): Example ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] @@ -174,6 +180,7 @@ def get_samples(self, num_samples=20): class SamplerRandom(): r""" + The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. The function next() outputs a single next index from the list {0,1,…,S-1} . To be run again and again, depending on how many iterations. @@ -259,7 +266,7 @@ def get_samples(self, num_samples=20): Example ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] @@ -321,7 +328,7 @@ class Sampler(): Example ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> for _ in range(12): >>> print(next(sampler)) >>> print(sampler.get_samples()) @@ -386,7 +393,7 @@ def sequential(num_indices): return sampler @staticmethod - def customOrder(num_indices, customlist, prob_weights=None): #TODO: swap to underscores + def custom_order(num_indices, customlist, prob_weights=None): #TODO: swap to underscores """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. @@ -398,7 +405,7 @@ def customOrder(num_indices, customlist, prob_weights=None): #TODO: swap to unde Example -------- - >>> sampler=Sampler.customOrder(12,[1,4,6,7,8,9,11]) + >>> sampler=Sampler.custom_order(12,[1,4,6,7,8,9,11]) >>> print(sampler.get_samples(11)) >>> for _ in range(9): >>> print(sampler.next()) @@ -429,7 +436,7 @@ def customOrder(num_indices, customlist, prob_weights=None): #TODO: swap to unde return sampler @staticmethod - def hermanMeyer(num_indices): + def herman_meyer(num_indices): """ Function that takes a number of indices and returns a sampler which outputs a Herman Meyer order @@ -442,7 +449,7 @@ def hermanMeyer(num_indices): Example ------- - >>> sampler=Sampler.hermanMeyer(12) + >>> sampler=Sampler.herman_meyer(12) >>> print(sampler.get_samples(16)) [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] @@ -537,7 +544,7 @@ def staggered(num_indices, offset): return sampler @staticmethod - def randomWithReplacement(num_indices, prob=None, seed=None): + def random_with_replacement(num_indices, prob=None, seed=None): """ Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. @@ -555,7 +562,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples(10)) [3 4 0 0 2 3 3 2 2 1] @@ -563,7 +570,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): Example ------- - >>> sampler=Sampler.randomWithReplacement(4, [0.7,0.1,0.1,0.1]) + >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) [0 1 3 0 0 3 0 0 0 0] @@ -576,7 +583,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): return sampler @staticmethod - def randomWithoutReplacement(num_indices, seed=None, prob=None): + def random_without_replacement(num_indices, seed=None, prob=None): """ Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. @@ -603,23 +610,61 @@ def randomWithoutReplacement(num_indices, seed=None, prob=None): @staticmethod def from_function(num_indices, function): """ - Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices TODO: + A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. + The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - function: TODO: + sampling_type:str + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + + + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. + + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + + Note + ----- + If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise + the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. - Example ------- - TODO: - + >>> def test_function(iteration_number): + >>> if iteration_number<500: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(49,1)[0]) + >>> else: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(50,1)[0]) + + + >>> sampler=Sampler.from_function(50, test_function) + >>> for _ in range(11): + >>> print(sampler.next()) + >>> print(list(sampler.get_samples(25))) + 44 + 37 + 40 + 42 + 46 + 35 + 10 + 47 + 3 + 28 + 9 + [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] """ - sampler = SamplerFromFunction(num_indices, sampling_type='random_without_replacement', function=function ) + sampler = SamplerFromFunction(num_indices, sampling_type='from_function', function=function ) return sampler diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index f582ca3181..699329cb93 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -789,7 +789,6 @@ def test_SPDHG_defaults_and_setters(self): self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() for i in range(self.subsets)]) self.assertListEqual(spdhg.prob_weights, [1/self.subsets] * self.subsets) - self.assertTrue(isinstance(spdhg.sampler, Sampler)) self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) @@ -829,21 +828,20 @@ def test_SPDHG_defaults_and_setters(self): def test_spdhg_non_default_init(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1,11)/55.)), initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) - self.assertTrue(isinstance(spdhg.sampler, Sampler)) self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) def test_spdhg_custom_sampler(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.customOrder([0,0,0,0]), + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order( len(self.A), [0,0,0,0]), initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) self.assertListEqual(spdhg.prob_weights, [1]+[0]*(len(self.A)-1)) - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.customOrder([0,1,0,1]), + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A),[0,1,0,1]), initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) self.assertListEqual(spdhg.prob_weights, [.5]+[.5]+[0]*(len(self.A)-2)) diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 3de70afd05..0b33a5b135 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -30,6 +30,15 @@ class TestSamplers(CCPiTestClass): + + def example_function(self, iteration_number): + if iteration_number < 500: + np.random.seed(iteration_number) + return (np.random.choice(49, 1)[0]) + else: + np.random.seed(iteration_number) + return (np.random.choice(50, 1)[0]) + def test_init(self): sampler = Sampler.sequential(10) @@ -40,20 +49,20 @@ def test_init(self): self.assertEqual(sampler.last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) - sampler = Sampler.randomWithoutReplacement(7) + sampler = Sampler.random_without_replacement(7) self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler.type, 'random_without_replacement') self.assertEqual(sampler.prob, [1/7]*7) self.assertListEqual(sampler.prob_weights, sampler.prob) - sampler = Sampler.randomWithoutReplacement(8, seed=1) + sampler = Sampler.random_without_replacement(8, seed=1) self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler.type, 'random_without_replacement') self.assertEqual(sampler.prob, [1/8]*8) self.assertEqual(sampler.seed, 1) self.assertListEqual(sampler.prob_weights, sampler.prob) - sampler = Sampler.hermanMeyer(12) + sampler = Sampler.herman_meyer(12) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'herman_meyer') self.assertEqual(sampler.last_index, 11) @@ -63,13 +72,13 @@ def test_init(self): 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.prob_weights, [1/12] * 12) - sampler = Sampler.randomWithReplacement(5) + sampler = Sampler.random_with_replacement(5) self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler.type, 'random_with_replacement') self.assertListEqual(sampler.prob, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) - sampler = Sampler.randomWithReplacement(4, [0.7, 0.1, 0.1, 0.1]) + sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler.type, 'random_with_replacement') self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) @@ -90,7 +99,7 @@ def test_init(self): except ValueError: self.assertTrue(True) - sampler = Sampler.customOrder(12, [1, 4, 6, 7, 8, 9, 11]) + sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'custom_order') self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) @@ -99,8 +108,23 @@ def test_init(self): self.assertListEqual(sampler.prob_weights, [ 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) - def test_sequential_iterator_and_get_samples(self): + sampler = Sampler.from_function(50, self.example_function) + self.assertListEqual(sampler.prob_weights, [1/50] * 50) + self.assertEqual(sampler.num_indices, 50) + self.assertEqual(sampler.type, 'from_function') + + def test_from_function(self): + + sampler = Sampler.from_function(50, self.example_function) + order = [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, + 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] + for i in range(25): + self.assertEqual(next(sampler), order[i]) + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + order)[:20]) + def test_sequential_iterator_and_get_samples(self): # Test the squential sampler sampler = Sampler.sequential(10) for i in range(25): @@ -119,7 +143,7 @@ def test_sequential_iterator_and_get_samples(self): def test_random_without_replacement_iterator_and_get_samples(self): # Test the random without replacement sampler - sampler = Sampler.randomWithoutReplacement(7, seed=1) + sampler = Sampler.random_without_replacement(7, seed=1) order = [2, 5, 0, 2, 1, 0, 1, 2, 2, 3, 2, 4, 1, 6, 0, 4, 2, 3, 0, 1, 5, 6, 2, 4, 6] for i in range(25): @@ -130,7 +154,7 @@ def test_random_without_replacement_iterator_and_get_samples(self): def test_herman_meyer_iterator_and_get_samples(self): # Test the Herman Meyer sampler - sampler = Sampler.hermanMeyer(12) + sampler = Sampler.herman_meyer(12) order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] for i in range(25): @@ -141,7 +165,7 @@ def test_herman_meyer_iterator_and_get_samples(self): def test_random_with_replacement_iterator_and_get_samples(self): # Test the Random with replacement sampler - sampler = Sampler.randomWithReplacement(5, seed=5) + sampler = Sampler.random_with_replacement(5, seed=5) order = [1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] for i in range(25): @@ -150,7 +174,7 @@ def test_random_with_replacement_iterator_and_get_samples(self): self.assertNumpyArrayEqual( sampler.get_samples(14), np.array(order[:14])) - sampler = Sampler.randomWithReplacement( + sampler = Sampler.random_with_replacement( 4, [0.7, 0.1, 0.1, 0.1], seed=5) order = [0, 2, 0, 3, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] @@ -173,7 +197,7 @@ def test_staggered_iterator_and_get_samples(self): def test_custom_order_iterator_and_get_samples(self): # Test the custom order sampler - sampler = Sampler.customOrder(12, [1, 4, 6, 7, 8, 9, 11]) + sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) order = [1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11] for i in range(25): From 835ce83bcf7210254577fa69f772b7b34a517b62 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 6 Nov 2023 15:50:02 +0000 Subject: [PATCH 084/152] Abstract base class --- .../ApproximateGradientSumFunction.py | 11 +++-- .../cil/optimisation/functions/SGFunction.py | 2 +- .../Python/test/test_approximate_gradient.py | 42 ++++++++---------- Wrappers/Python/test/test_functions.py | 43 ------------------- 4 files changed, 27 insertions(+), 71 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 4826f6c04a..42921d7b31 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -20,7 +20,9 @@ from cil.optimisation.functions import SumFunction import numbers -class ApproximateGradientSumFunction(SumFunction): #TODO: should be an abstract base class +from abc import ABC, abstractmethod + +class ApproximateGradientSumFunction(SumFunction, ABC): #TODO: should be an abstract base class r"""ApproximateGradientSumFunction represents the following sum @@ -71,9 +73,10 @@ def full_gradient(self, x, out=None): r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ return super(ApproximateGradientSumFunction, self).gradient(x, out=out) - def approximate_gradient(self, function_num, x, out=None):#TODO: x, function_num instead + @abstractmethod + def approximate_gradient(self, x, function_num, out=None): """ Computes the approximate gradient for each selected function at :code:`x`.""" - raise NotImplementedError + pass def gradient(self, x, out=None): """ Selects a random function and uses this to calculate the approximate gradient at :code:`x`.""" @@ -81,6 +84,6 @@ def gradient(self, x, out=None): # single function if isinstance(self.function_num, numbers.Number): - return self.approximate_gradient(self.function_num, x, out=out) + return self.approximate_gradient(x, self.function_num, out=out) else: raise ValueError("Batch gradient is not yet implemented") diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 67c92b9fd8..7368a60736 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -42,7 +42,7 @@ def __init__(self, functions, sampler): - def approximate_gradient(self, function_num, x, out=None): + def approximate_gradient(self, x, function_num, out=None): """ Returns the gradient of the selected function or batch of functions at :code:`x`. The function or batch of functions is selected using the :meth:`~ApproximateGradientSumFunction.next_function`. diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 7de45588f6..ab24ccb288 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -49,36 +49,27 @@ class TestApproximateGradientSumFunction(CCPiTestClass): def setUp(self): self.sampler=Sampling(5) - self.initial = VectorData(np.zeros(25)) - self.b = VectorData(np.random.normal(0,1,25)) + self.initial = VectorData(np.zeros(10)) + self.b = VectorData(np.random.normal(0,1,10)) self.functions=[] for i in range(5): - diagonal=np.zeros(25) - diagonal[5*i:5*(i+1)]=1 + diagonal=np.zeros(10) + diagonal[2*i:2*(i+1)]=1 A=MatrixOperator(np.diag(diagonal)) self.functions.append( LeastSquares(A, A.direct(self.b))) if i==0: self.objective=LeastSquares(A, A.direct(self.b)) else: self.objective+=LeastSquares(A, A.direct(self.b)) - self.stochastic_objective=ApproximateGradientSumFunction(self.functions, self.sampler) - def test_init(self): - with self.assertRaises(NotImplementedError): - self.stochastic_objective.approximate_gradient(3, self.initial) - with self.assertRaises(NotImplementedError): - self.stochastic_objective.gradient( self.initial) - self.assertEqual(self.stochastic_objective.num_functions,5) - #TODO: test sampler saved correctly - when we have a sampling class - - def test_direct_call(self): - self.assertAlmostEqual(self.stochastic_objective(self.initial), self.objective(self.initial)) - - def test_full_gradient(self): - self.assertNumpyArrayAlmostEqual(self.stochastic_objective.full_gradient(self.initial).array, self.objective.gradient(self.initial).array) - def test_sampler(self): - pass - #TODO: + def test_ABC(self): + try: + self.stochastic_objective=ApproximateGradientSumFunction(self.functions, self.sampler) + except TypeError: + pass + + + class Sampling(): #TO BE REPLACED BY SAMPLING CLASS THING WHEN THAT HAS BEEN MERGED def __init__(self, num_subsets, prob=None, seed=99): self.num_subsets=num_subsets @@ -172,9 +163,14 @@ def test_SGD_toy_example(self): alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - objective=SGFunction(functions, sampler) + stochastic_objective=SGFunction(functions, sampler) + self.assertAlmostEqual(stochastic_objective(initial), objective(initial)) + self.assertNumpyArrayAlmostEqual(stochastic_objective.full_gradient(initial).array, objective.gradient(initial).array) + + + alg_stochastic = GD(initial=initial, - objective_function=objective, update_objective_interval=1000, + objective_function=stochastic_objective, update_objective_interval=1000, step_size=0.01, max_iteration =5000) alg_stochastic.run( 400, verbose=0) self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) diff --git a/Wrappers/Python/test/test_functions.py b/Wrappers/Python/test/test_functions.py index 3a480f1820..bbd06776fb 100644 --- a/Wrappers/Python/test/test_functions.py +++ b/Wrappers/Python/test/test_functions.py @@ -69,49 +69,6 @@ if has_astra: from cil.plugins.astra import ProjectionOperator -class TestApproxGradientSumFunction(CCPiTestClass): - def setUp(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) - - ig = data.geometry - ig.voxel_size_x = 0.1 - ig.voxel_size_y = 0.1 - - detectors = ig.shape[0] - angles = np.linspace(0, np.pi, 90) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) - Aop = ProjectionOperator(ig, ag, 'cpu') - #Create noisy data - sin = Aop.direct(data) - noisy_data = ag.allocate() - np.random.seed(10) - n1 = np.random.normal(0, 0.1, size = ag.shape) - noisy_data.fill(n1 + sin.as_array()) - - subsets = 5 - size_of_subsets = int(len(angles)/subsets) - # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] - # create acquisition geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] - # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], 'cpu') for i in range(subsets)]) - AD_list = [] - for sub_num in range(subsets): - for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets,:] - AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) - - g = BlockDataContainer(*AD_list) - - ## block function - self.F = BlockFunction(*[KullbackLeibler(b=g[i]) for i in range(subsets)]) - - - def test_set_up(self): - pass - class TestFunction(CCPiTestClass): From 376045863d5e37987207b723bb31a51b1852f068 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 7 Nov 2023 13:50:55 +0000 Subject: [PATCH 085/152] prob_weights to sampler --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 7d0dc6c8fd..c8771dbc82 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -307,10 +307,7 @@ def set_up(self, f, g, operator, self.prob_weights=sampler.prob_weights #TODO: consider the case it is uniform and not saving the array if self.prob_weights is None: - x=sampler.get_samples(10000) - self.prob_weights=[np.count_nonzero((x==i)) for i in range(len(operator))] - total=sum(self.prob_weights) - self.prob_weights[:] = [x / total for x in self.prob_weights] + self.prob_weights=[1/self.ndual_subsets]*self.ndual_subsets # might not want to do this until it is called (if computationally expensive) self.set_step_sizes_default() From 878675d195ea5f7b420183a299aa67932fa61787 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 7 Nov 2023 14:39:33 +0000 Subject: [PATCH 086/152] TODO:s --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 5 ++++- Wrappers/Python/cil/optimisation/utilities/sampler.py | 10 +++++----- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index c8771dbc82..507b401f6d 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -98,6 +98,7 @@ class SPDHG(Algorithm): def __init__(self, f=None, g=None, operator=None, initial=None, sampler=None, **kwargs): + #TODO: keep sigma, tau, gamma in the init and call set_custom_step_sizes super(SPDHG, self).__init__(**kwargs) if kwargs.get('norms', None) is not None: @@ -107,6 +108,8 @@ def __init__(self, f=None, g=None, operator=None, if sampler is not None: if kwargs.get('prob', None) is not None: + #TODO: change warnings to logging + #TODO: change this one to an error warnings.warn('`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: if kwargs.get('prob', None) is not None: @@ -140,7 +143,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): Note ----- - The step sizes `sigma` anf `tau` are set using the equations: + The step sizes `sigma` and `tau` are set using the equations: .. math:: \sigma_i=\gamma\rho / (\|K_i\|**2)\\ diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 0e7b908a33..e12b064789 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -57,7 +57,7 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei self.prob_weights=prob_weights if self.prob_weights is None: self.prob_weights=[1/num_indices]*num_indices - self.iteration_number=-1 + self.iteration_number=-1 #TODO:start at 0. @@ -68,7 +68,7 @@ def next(self): """ - self.iteration_number+=1 + self.iteration_number+=1 #TODO: call, iterate and then return return (self.function(self.iteration_number)) def __next__(self): @@ -245,7 +245,7 @@ def next(self): if self.replace: return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) else: - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) #TODO: @@ -363,7 +363,7 @@ class Sampler(): def sequential(num_indices): """ Function that outputs a sampler that outputs sequentially. - + #TODO: docstring num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -393,7 +393,7 @@ def sequential(num_indices): return sampler @staticmethod - def custom_order(num_indices, customlist, prob_weights=None): #TODO: swap to underscores + def custom_order(num_indices, customlist, prob_weights=None): """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. From 5ce0a09734a271f33d9f1293d2e8b6f161a7149a Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 8 Nov 2023 10:52:31 +0000 Subject: [PATCH 087/152] Changes after stochastic meeting --- .../ApproximateGradientSumFunction.py | 51 +++++++++++++------ .../cil/optimisation/functions/SGFunction.py | 44 +++++++++------- .../Python/test/test_approximate_gradient.py | 36 ++++++++++--- 3 files changed, 89 insertions(+), 42 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 42921d7b31..14ac3243a0 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -19,28 +19,30 @@ from cil.optimisation.functions import SumFunction +#from cil.optimisation.utilities import Sampler TODO: after sampler merged in import numbers from abc import ABC, abstractmethod -class ApproximateGradientSumFunction(SumFunction, ABC): #TODO: should be an abstract base class - +class ApproximateGradientSumFunction(SumFunction, ABC): r"""ApproximateGradientSumFunction represents the following sum .. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) - where :math:`n` is the number of functions. + where :math:`n` is the number of functions. It is an abstract base class and any child classes must implement an `approximate_gradient` function. Parameters: ----------- - functions : list(functions) #TODO: do we want this to be a list of functions or a BlockFunction? Perhaps it could be a list here and a BlockFunction for SGFunction? - A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. - sampler: An instance of the :meth:`~framework.sampler` class which has a next function which gives the next subset to calculate the gradient for. - + functions : `list` of functions + A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. + sampler: An instance of one of the :meth:`~optimisation.utilities.sampler` classes which has a `next` function implemented and a `num_indices` property. + This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. + + + Note ---- - The :meth:`~ApproximateGradientSumFunction.gradient` computes the `gradient` of only one function of a batch of functions - depending on the :code:`sampler` method. + The :meth:`~ApproximateGradientSumFunction.gradient` returns the approximate gradient depending on an index provided by the :code:`sampler` method. Example ------- @@ -57,8 +59,20 @@ class ApproximateGradientSumFunction(SumFunction, ABC): #TODO: should be an abst """ - def __init__(self, functions, sampler): - + def __init__(self, functions, sampler =None): + + # if sampler is None: + # sampler=Sampler.random_with_replacement(len(functions)) #TODO: once sampler is merged in and unit test for this! + + if not isinstance(functions, list): + raise TypeError("Input to functions should be a list of functions") + if not hasattr(sampler, "next"): + raise ValueError('The provided sampler must have a `next` method') + if not hasattr(sampler, "num_indices"): + raise ValueError('The provided sampler must store the `num_indices` it samples from') + if sampler.num_indices !=len(functions): + raise ValueError('The sampler should choose from the same number of indices as there are functions passed to this approximate gradient method') + self.sampler = sampler self.num_functions = len(functions) @@ -66,11 +80,19 @@ def __init__(self, functions, sampler): super(ApproximateGradientSumFunction, self).__init__(*functions) def __call__(self, x): - r""" Computes the full sum at :code:`x`. It is the sum of the outputs for each function. """ + r"""Returns the value of the sum of functions at :math:`x`. + + .. math:: (F_{1} + F_{2} + ... + F_{n})(x) = F_{1}(x) + F_{2}(x) + ... + F_{n}(x) + + """ return super(ApproximateGradientSumFunction, self).__call__(x) def full_gradient(self, x, out=None): - r""" Computes the full gradient at :code:`x`. It is the sum of all the gradients for each function. """ + r"""Returns the value of the full gradient of the sum of functions at :math:`x`. + + .. math:: \nabla_x(F_{1} + F_{2} + ... + F_{n})(x) = \nabla_xF_{1}(x) + \nabla_xF_{2}(x) + ... + \nabla_xF_{n}(x) + + """ return super(ApproximateGradientSumFunction, self).gradient(x, out=out) @abstractmethod @@ -79,10 +101,9 @@ def approximate_gradient(self, x, function_num, out=None): pass def gradient(self, x, out=None): - """ Selects a random function and uses this to calculate the approximate gradient at :code:`x`.""" + """ Selects a random function using the `sampler` and then calls the approximate gradient at :code:`x`.""" self.function_num = self.sampler.next() - # single function if isinstance(self.function_num, numbers.Number): return self.approximate_gradient(x, self.function_num, out=out) else: diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 7368a60736..c298d87ea0 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -21,31 +21,37 @@ class SGFunction(ApproximateGradientSumFunction): """ - Initialize the SGFunction. - - Parameters: - ---------- - functions: list or BlockFunction - A list of functions. #TODO: write it a bit clearer what the sum function requires :) - sampler: callable or None, optional - A callable object that selects the function or batch of functions to compute the gradient. - - """ + Stochastic gradient function, a child class of `ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_1,...,f_n}` a `SumFunction`, :math:`f_1+...+f_n` where each time the `gradient` is called, the `sampler` provides an index, :math:`i \in {1,...,n}` + and the gradient function returns the approximate gradient :math:`n\nabla_xf_i(x)`. This can be used with the `cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. + + Parameters: + ----------- + functions : `list` of functions + A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. + sampler: An instance of one of the :meth:`~optimisation.utilities.sampler` classes which has a `next` function implemented and a `num_indices` property. + This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. + """ - def __init__(self, functions, sampler): - if isinstance(functions, list): - super(SGFunction, self).__init__(functions, sampler) - elif isinstance(functions, SumFunction): - super(SGFunction, self).__init__(functions.functions, sampler) #TODO: is this the right thing to do? - else: - raise TypeError("Input to functions should be a list of functions or a SumFunction") + def __init__(self, functions, sampler=None): + super(SGFunction, self).__init__(functions, sampler) + def approximate_gradient(self, x, function_num, out=None): """ Returns the gradient of the selected function or batch of functions at :code:`x`. - The function or batch of functions is selected using the :meth:`~ApproximateGradientSumFunction.next_function`. + The function num is selected using the :meth:`~ApproximateGradientSumFunction.next_function`. + + Parameters + ---------- + x: element in the domain of the `functions` + + function_num: `int` + Between 1 and the number of functions in the list + + + """ # flag to return or in-place computation @@ -59,7 +65,7 @@ def approximate_gradient(self, x, function_num, out=None): self.functions[function_num].gradient(x, out = out) # scale wrt number of functions - out*=self.num_functions # TODO: need to document this decision somewhere + out*=self.num_functions if should_return: return out diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index ab24ccb288..81dbe8edb7 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -70,20 +70,20 @@ def test_ABC(self): -class Sampling(): #TO BE REPLACED BY SAMPLING CLASS THING WHEN THAT HAS BEEN MERGED +class Sampling(): #TODO: TO BE REPLACED BY SAMPLING CLASS THING WHEN THAT HAS BEEN MERGED def __init__(self, num_subsets, prob=None, seed=99): - self.num_subsets=num_subsets + self.num_indices=num_subsets np.random.seed(seed) if prob==None: - self.prob = [1/self.num_subsets] * self.num_subsets + self.prob = [1/self.num_indices] * self.num_indices else: self.prob=prob def __next__(self): - return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + return int(np.random.choice(self.num_indices, 1, p=self.prob)) def next(self): - return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + return int(np.random.choice(self.num_indices, 1, p=self.prob)) class TestSGD(CCPiTestClass): @@ -104,10 +104,10 @@ def setUp(self): fi=LeastSquares(self.A_partitioned.operators[i],self. partitioned_data[i]) f_subsets.append(fi) self.f=LeastSquares(self.A, self.data2d) - self.f_stochastic=SGFunction(SumFunction(*f_subsets),self.sampler) + self.f_stochastic=SGFunction(f_subsets,self.sampler) self.initial=ig2D.allocate() - def test_approximate_gradient(self): + def test_approximate_gradient(self): #Test when we the approximate gradient is not equal to the full gradient self.assertFalse((self.f_stochastic.full_gradient(self.initial)==self.f_stochastic.gradient(self.initial).array).all()) def test_sampler(self): @@ -119,7 +119,27 @@ def test_direct(self): def test_full_gradient(self): self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient(self.initial).array, self.f.gradient(self.initial).array,2) - + def test_value_error_with_only_one_function(self): + try: + SGFunction([self.f], self.sampler) + except ValueError: + pass + def test_type_error_if_functions_not_a_list(self): + try: + SGFunction(self.f, self.sampler) + except TypeError: + pass + + + def test_sampler_without_next(self): + class bad_Sampler(): + def init(self): + pass + bad_sampler=bad_Sampler() + try: + SGFunction([self.f, self.f], bad_sampler) + except ValueError: + pass def test_SGD_simulated_parallel_beam_data(self): From 2d99762bf6fa1c836f009ea795fe88924cb8533b Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 8 Nov 2023 11:51:49 +0000 Subject: [PATCH 088/152] Updates to sampler --- .../cil/optimisation/utilities/sampler.py | 72 ++++++++++++------- Wrappers/Python/test/test_sampler.py | 40 ++++++++--- 2 files changed, 76 insertions(+), 36 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index e12b064789..15048cd967 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -39,7 +39,7 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - prob_weights: list of floats of length num_indices that sum to 1. + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices #TODO: write unit tests. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. @@ -54,10 +54,12 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei self.type=sampling_type self.num_indices=num_indices self.function=function + if abs(sum(prob_weights)-1)>1e-6: + raise ValueError('The provided prob_weights must sum to one') + if any(np.array(prob_weights)<0): + raise ValueError('The provided prob_weights must be greater than or equal to zero') self.prob_weights=prob_weights - if self.prob_weights is None: - self.prob_weights=[1/num_indices]*num_indices - self.iteration_number=-1 #TODO:start at 0. + self.iteration_number=0 @@ -67,9 +69,9 @@ def next(self): A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ - - self.iteration_number+=1 #TODO: call, iterate and then return - return (self.function(self.iteration_number)) + out=self.function(self.iteration_number) + self.iteration_number=self.iteration_number+1 + return (out) def __next__(self): """ @@ -93,7 +95,7 @@ def get_samples(self, num_samples=20): [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ save_last_index = self.iteration_number - self.iteration_number = -1 + self.iteration_number = 0 output = [self.next() for _ in range(num_samples)] self.iteration_number = save_last_index return (np.array(output)) @@ -127,13 +129,15 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): """ + if abs(sum(prob_weights)-1)>1e-6: + raise ValueError('The provided prob_weights must sum to one') + if any(np.array(prob_weights)<0): + raise ValueError('The provided prob_weights must be greater than or equal to zero') + self.prob_weights=prob_weights self.type = sampling_type self.num_indices = num_indices - self.order = order - self.initial_order = self.order - - + self.order = order self.last_index = len(order)-1 @@ -223,6 +227,11 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): self.prob_weights=prob else: self.prob_weights=[1/num_indices]*num_indices + if abs(sum(self.prob_weights)-1)>1e-6: + raise ValueError('The provided prob_weights must sum to one') + if any(np.array(self.prob_weights)<0): + raise ValueError('The provided prob_weights must be greater than or equal to zero') + self.type = sampling_type self.num_indices = num_indices if seed is not None: @@ -242,10 +251,9 @@ def next(self): This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with and without replacement. """ - if self.replace: - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) - else: - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) #TODO: + + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + @@ -290,7 +298,7 @@ class Sampler(): The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + The sampling type used. Choose from "from_function", "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". order: list of indices The list of indices the method selects from using next. @@ -363,7 +371,9 @@ class Sampler(): def sequential(num_indices): """ Function that outputs a sampler that outputs sequentially. - #TODO: docstring + + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -393,14 +403,19 @@ def sequential(num_indices): return sampler @staticmethod - def custom_order(num_indices, customlist, prob_weights=None): + def custom_order(num_indices, custom_list, prob_weights=None): """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. - customlist: list of indices + Parameters + ---------- + num_indices: `int` + The sampler will select indices for `{1,....,n}` according to the order in `custom_list` where `n` is `num_indices`. + custom_list: `list` of `int` The list that will be sampled from in order. - #TODO: + prob_weights: list of floats of length num_indices that sum to 1. Default is None and the prob_weights are calculated automatically. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example -------- @@ -427,12 +442,13 @@ def custom_order(num_indices, customlist, prob_weights=None): if prob_weights is None: temp_list=[] for i in range(num_indices): - temp_list.append(customlist.count(i)) + temp_list.append(custom_list.count(i)) total=sum(temp_list) prob_weights=[x/total for x in temp_list] + sampler = SamplerFromOrder( - num_indices, sampling_type='custom_order', order=customlist, prob_weights=prob_weights) + num_indices, sampling_type='custom_order', order=custom_list, prob_weights=prob_weights) return sampler @staticmethod @@ -608,7 +624,7 @@ def random_without_replacement(num_indices, seed=None, prob=None): return sampler @staticmethod - def from_function(num_indices, function): + def from_function(num_indices, function, prob_weights=None): """ A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. @@ -622,10 +638,9 @@ def from_function(num_indices, function): sampling_type:str The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - prob_weights: list of floats of length num_indices that sum to 1. + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. @@ -663,8 +678,11 @@ def from_function(num_indices, function): [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] """ + if prob_weights is None: + prob_weights=[1/num_indices]*num_indices + - sampler = SamplerFromFunction(num_indices, sampling_type='from_function', function=function ) + sampler = SamplerFromFunction(num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 0b33a5b135..576660a3d9 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -45,7 +45,6 @@ def test_init(self): self.assertEqual(sampler.num_indices, 10) self.assertEqual(sampler.type, 'sequential') self.assertListEqual(sampler.order, list(range(10))) - self.assertListEqual(sampler.initial_order, list(range(10))) self.assertEqual(sampler.last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) @@ -68,8 +67,6 @@ def test_init(self): self.assertEqual(sampler.last_index, 11) self.assertListEqual( sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) - self.assertListEqual(sampler.initial_order, [ - 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) @@ -89,29 +86,54 @@ def test_init(self): self.assertEqual(sampler.type, 'staggered') self.assertListEqual(sampler.order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) - self.assertListEqual(sampler.initial_order, [ - 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) self.assertEqual(sampler.last_index, 20) self.assertListEqual(sampler.prob_weights, [1/21] * 21) - try: + with self.assertRaises(ValueError): Sampler.staggered(22, 25) - except ValueError: - self.assertTrue(True) + sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'custom_order') self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) - self.assertListEqual(sampler.initial_order, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.last_index, 6) self.assertListEqual(sampler.prob_weights, [ 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) + + sampler = Sampler.custom_order(10, [0,1, 2, 3, 4]) + self.assertEqual(sampler.num_indices, 10) + self.assertEqual(sampler.type, 'custom_order') + self.assertListEqual(sampler.order, [0,1,2,3,4]) + self.assertEqual(sampler.last_index, 4) + self.assertListEqual(sampler.prob_weights, [ + 1/5,1/5,1/5,1/5,1/5,0,0,0,0,0]) + + sampler = Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[1/10]*10) + self.assertListEqual(sampler.prob_weights, [1/10]*10) + + #Check probabilities sum to one and are positive + with self.assertRaises(ValueError): + Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[1/11]*10) + with self.assertRaises(ValueError): + Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[-1]+[2]+[0]*8) + sampler = Sampler.from_function(50, self.example_function) self.assertListEqual(sampler.prob_weights, [1/50] * 50) self.assertEqual(sampler.num_indices, 50) self.assertEqual(sampler.type, 'from_function') + + sampler = Sampler.from_function(40, self.example_function, [1]+[0]*39) + self.assertListEqual(sampler.prob_weights, [1]+[0]*39) + self.assertEqual(sampler.num_indices, 40) + self.assertEqual(sampler.type, 'from_function') + + #check probabilities sum to 1 and are positive + with self.assertRaises(ValueError): + Sampler.from_function(40, self.example_function, [0.9]+[0]*39) + with self.assertRaises(ValueError): + Sampler.from_function(40, self.example_function, [-1]+[2]+[0]*38) def test_from_function(self): From 7154834a167b97ba41178155646cb8a5688d3fe1 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 8 Nov 2023 13:28:50 +0000 Subject: [PATCH 089/152] Updates to SPDHG after stochastic meeting --- .../cil/optimisation/algorithms/SPDHG.py | 88 +++++++++++-------- 1 file changed, 50 insertions(+), 38 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 507b401f6d..37e4786382 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -26,6 +26,7 @@ from numbers import Number import numpy as np + class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -65,22 +66,41 @@ class SPDHG(Algorithm): Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py + Note - ---- + ----- + When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Convergence is guaranteed provided that [2, eq. (12)]: + - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: + .. math:: - .. math:: + \sigma_i=0.99 / (\|K_i\|**2) + + and `tau` is set as per case 2 + + - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula + + .. math:: + + \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + + - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula + + .. math:: + + \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) + + - Case 4: Both `sigma` and `tau` are provided. - \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i Note ---- - Notation for primal and dual step-sizes are reversed with comparison - to SPDHG.py + Convergence is guaranteed provided that [2, eq. (12)]: + .. math:: + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i References ---------- @@ -95,34 +115,30 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, + def __init__(self, f=None, g=None, operator=None, sigma=None, tau=None, initial=None, sampler=None, **kwargs): - #TODO: keep sigma, tau, gamma in the init and call set_custom_step_sizes super(SPDHG, self).__init__(**kwargs) if kwargs.get('norms', None) is not None: operator.set_norms(kwargs.get('norms')) warnings.warn( - ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - + ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') + if sampler is not None: if kwargs.get('prob', None) is not None: - #TODO: change warnings to logging - #TODO: change this one to an error - warnings.warn('`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') + raise TypeError( + '`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: if kwargs.get('prob', None) is not None: - warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - sampler=Sampler.random_with_replacement(len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) - + logging.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') + sampler = Sampler.random_with_replacement( + len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) if f is not None and operator is not None and g is not None and sampler is not None: - self.set_up(f=f, g=g, operator=operator, + self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler) - - @property def sigma(self): return self._sigma @@ -140,7 +156,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): parameter controlling the trade-off between the primal and dual step sizes rho : float parameter controlling the size of the product :math: \sigma\tau :math: - + Note ----- The step sizes `sigma` and `tau` are set using the equations: @@ -168,9 +184,9 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): "We currently only support scalar values of gamma") self._sigma = [gamma * rho / ni for ni in self.norms] - values=[pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)] - self._tau = min([value for value in values if value>1e-6]) #TODO: what value should this be + values = [pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)] + self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) def set_step_sizes_custom(self, sigma=None, tau=None): @@ -184,7 +200,7 @@ def set_step_sizes_custom(self, sigma=None, tau=None): Step size parameter for Primal problem The user can set these or default values are calculated, either sigma, tau, both or None can be passed. - + Note ----- There are 4 possible cases considered by this function: @@ -201,7 +217,7 @@ def set_step_sizes_custom(self, sigma=None, tau=None): .. math:: \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - + - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula .. math:: @@ -209,10 +225,6 @@ def set_step_sizes_custom(self, sigma=None, tau=None): \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. - - - - """ gamma = 1. @@ -240,9 +252,9 @@ def set_step_sizes_custom(self, sigma=None, tau=None): gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] if tau is None: - values=[pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)] - self._tau = min([value for value in values if value>1e-6]) #TODO: what value should this be + values = [pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)] + self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) else: if isinstance(tau, Number): @@ -258,7 +270,6 @@ def set_step_sizes_default(self): """Calculates the default values for sigma and tau """ self.set_step_sizes_custom(sigma=None, tau=None) - def check_convergence(self): # TODO: check this with someone else """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma @@ -276,7 +287,7 @@ def check_convergence(self): else: return False - def set_up(self, f, g, operator, + def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None): '''set-up of the algorithm Parameters @@ -305,15 +316,16 @@ def set_up(self, f, g, operator, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - self.sampler=sampler + self.sampler = sampler self.norms = operator.get_norms_as_list() - self.prob_weights=sampler.prob_weights #TODO: consider the case it is uniform and not saving the array + # TODO: consider the case it is uniform and not saving the array + self.prob_weights = sampler.prob_weights if self.prob_weights is None: - self.prob_weights=[1/self.ndual_subsets]*self.ndual_subsets + self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets # might not want to do this until it is called (if computationally expensive) - self.set_step_sizes_default() + self.set_step_sizes_custom(sigma=sigma, tau=tau) # initialize primal variable if initial is None: From 520b9fa1135d4b61295810c7f6b70541b185b214 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 8 Nov 2023 13:32:24 +0000 Subject: [PATCH 090/152] Updated unit tests --- .../Python/test/test_approximate_gradient.py | 18 +++++++----------- 1 file changed, 7 insertions(+), 11 deletions(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 81dbe8edb7..21bd0c0bcf 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -63,10 +63,9 @@ def setUp(self): self.objective+=LeastSquares(A, A.direct(self.b)) def test_ABC(self): - try: + with self.assertRaises(TypeError): self.stochastic_objective=ApproximateGradientSumFunction(self.functions, self.sampler) - except TypeError: - pass + @@ -120,15 +119,13 @@ def test_full_gradient(self): self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient(self.initial).array, self.f.gradient(self.initial).array,2) def test_value_error_with_only_one_function(self): - try: + with self.assertRaises(ValueError): SGFunction([self.f], self.sampler) - except ValueError: pass def test_type_error_if_functions_not_a_list(self): - try: + with self.assertRaises(TypeError): SGFunction(self.f, self.sampler) - except TypeError: - pass + def test_sampler_without_next(self): @@ -136,10 +133,9 @@ class bad_Sampler(): def init(self): pass bad_sampler=bad_Sampler() - try: + with self.assertRaises(ValueError): SGFunction([self.f, self.f], bad_sampler) - except ValueError: - pass + def test_SGD_simulated_parallel_beam_data(self): From 4e7f2b66d58d8f8931399d16cf1333599d6b6f99 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 8 Nov 2023 14:23:41 +0000 Subject: [PATCH 091/152] Merge error fixed --- .../cil/optimisation/operators/BlockOperator.py | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index d81387c35a..2c02b950f2 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -77,12 +77,7 @@ class BlockOperator(Operator): __array_priority__ = 1 def __init__(self, *args, **kwargs): - - Example: - BlockOperator(op0,op1) results in a row block - BlockOperator(op0,op1,shape=(1,2)) results in a column block - ''' - + self.operators = args shape = kwargs.get('shape', None) if shape is None: @@ -141,7 +136,6 @@ def row_wise_compatible(self): return compatible def get_item(self, row, col): - '''Returns the Operator at specified row and col Parameters ---------- @@ -150,7 +144,6 @@ def get_item(self, row, col): col: `int` The column index required. ''' - if row > self.shape[0]: raise ValueError( 'Requested row {} > max {}'.format(row, self.shape[0])) @@ -300,7 +293,6 @@ def is_linear(self): def get_output_shape(self, xshape, adjoint=False): '''Returns the shape of the output BlockDataContainer - Parameters ---------- xshape: BlockDataContainer @@ -309,7 +301,6 @@ def get_output_shape(self, xshape, adjoint=False): Examples -------- - A(N,M) direct u(M,1) -> N,1 A(N,M)^T adjoint u(N,1) -> M,1 @@ -334,10 +325,10 @@ def __rmul__(self, scalar): Parameters ------------ + scalar: number or iterable containing numbers ''' - if isinstance(scalar, list) or isinstance(scalar, tuple) or \ isinstance(scalar, numpy.ndarray): if len(scalar) != len(self.operators): @@ -354,6 +345,7 @@ def __rmul__(self, scalar): @property def T(self): '''Returns the transposed of self. + Recall the input list is shaped in a row-by-row fashion''' newshape = (self.shape[1], self.shape[0]) oplist = [] From d861a13fd1a30be982eb8126d5f31471e34e77ca Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 15 Nov 2023 16:12:54 +0000 Subject: [PATCH 092/152] SPDHG documentation changes --- .../Python/cil/optimisation/algorithms/SPDHG.py | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 37e4786382..3d0a589f8a 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -54,8 +54,8 @@ class SPDHG(Algorithm): parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets + **kwargs: - prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats @@ -81,13 +81,11 @@ class SPDHG(Algorithm): - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula .. math:: - \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula .. math:: - \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. @@ -99,7 +97,6 @@ class SPDHG(Algorithm): Convergence is guaranteed provided that [2, eq. (12)]: .. math:: - \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i References @@ -148,7 +145,7 @@ def tau(self): return self._tau def set_step_sizes_from_ratio(self, gamma=1., rho=.99): - """ Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. + r""" Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. Parameters ---------- @@ -161,7 +158,6 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): ----- The step sizes `sigma` and `tau` are set using the equations: .. math:: - \sigma_i=\gamma\rho / (\|K_i\|**2)\\ \tau = (\rho/\gamma)\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) @@ -190,7 +186,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): self._tau *= (rho / gamma) def set_step_sizes_custom(self, sigma=None, tau=None): - """ Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. + r""" Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. Parameters ---------- @@ -207,7 +203,6 @@ def set_step_sizes_custom(self, sigma=None, tau=None): - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: .. math:: - \sigma_i=0.99 / (\|K_i\|**2) and `tau` is set as per case 2 @@ -215,13 +210,11 @@ def set_step_sizes_custom(self, sigma=None, tau=None): - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula .. math:: - \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula .. math:: - \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. From fce2a8e3371df87635174a09c3a6a9e91ee8f29e Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 22 Nov 2023 12:04:46 +0000 Subject: [PATCH 093/152] Merged sampler into SGD --- .../ApproximateGradientSumFunction.py | 6 +-- .../cil/optimisation/utilities/__init__.py | 2 +- .../Python/test/test_approximate_gradient.py | 37 +++++++------------ 3 files changed, 17 insertions(+), 28 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 14ac3243a0..c9d4896ceb 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -19,7 +19,7 @@ from cil.optimisation.functions import SumFunction -#from cil.optimisation.utilities import Sampler TODO: after sampler merged in +from cil.optimisation.utilities import Sampler import numbers from abc import ABC, abstractmethod @@ -61,8 +61,8 @@ class ApproximateGradientSumFunction(SumFunction, ABC): def __init__(self, functions, sampler =None): - # if sampler is None: - # sampler=Sampler.random_with_replacement(len(functions)) #TODO: once sampler is merged in and unit test for this! + if sampler is None: + sampler=Sampler.random_with_replacement(len(functions)) if not isinstance(functions, list): raise TypeError("Input to functions should be a list of functions") diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index 6aa6db103f..dc6bad81d7 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -18,4 +18,4 @@ # CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt -from .sampler import Sampler +from .sampler import Sampler, SamplerRandom, SamplerFromOrder, SamplerFromFunction diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 21bd0c0bcf..923f7cbacc 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -31,11 +31,11 @@ from cil.optimisation.functions import LeastSquares from cil.optimisation.functions import ApproximateGradientSumFunction from cil.optimisation.functions import SGFunction -#from cil.optimisation.utilities import Sampler #TODO: from cil.optimisation.functions import SumFunction from cil.optimisation.operators import MatrixOperator from cil.optimisation.algorithms import GD from cil.framework import VectorData +from cil.optimisation.utilities import Sampler, SamplerRandom from testclass import CCPiTestClass from utils import has_astra @@ -48,7 +48,7 @@ class TestApproximateGradientSumFunction(CCPiTestClass): def setUp(self): - self.sampler=Sampling(5) + self.sampler=Sampler.random_with_replacement(5) self.initial = VectorData(np.zeros(10)) self.b = VectorData(np.random.normal(0,1,10)) self.functions=[] @@ -69,25 +69,11 @@ def test_ABC(self): -class Sampling(): #TODO: TO BE REPLACED BY SAMPLING CLASS THING WHEN THAT HAS BEEN MERGED - def __init__(self, num_subsets, prob=None, seed=99): - self.num_indices=num_subsets - np.random.seed(seed) - - if prob==None: - self.prob = [1/self.num_indices] * self.num_indices - else: - self.prob=prob - def __next__(self): - - return int(np.random.choice(self.num_indices, 1, p=self.prob)) - def next(self): - return int(np.random.choice(self.num_indices, 1, p=self.prob)) class TestSGD(CCPiTestClass): def setUp(self): - self.sampler=Sampling(5) + self.sampler=Sampler.random_with_replacement(5) self.data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() self.data.reorder('astra') self.data2d=self.data.get_slice(vertical='centre') @@ -98,19 +84,22 @@ def setUp(self): self.n_subsets = 5 self.partitioned_data=self.data2d.partition(self.n_subsets, 'sequential') self.A_partitioned = ProjectionOperator(ig2D, self.partitioned_data.geometry, device = "cpu") - f_subsets = [] + self.f_subsets = [] for i in range(self.n_subsets): fi=LeastSquares(self.A_partitioned.operators[i],self. partitioned_data[i]) - f_subsets.append(fi) + self.f_subsets.append(fi) self.f=LeastSquares(self.A, self.data2d) - self.f_stochastic=SGFunction(f_subsets,self.sampler) + self.f_stochastic=SGFunction(self.f_subsets,self.sampler) self.initial=ig2D.allocate() def test_approximate_gradient(self): #Test when we the approximate gradient is not equal to the full gradient self.assertFalse((self.f_stochastic.full_gradient(self.initial)==self.f_stochastic.gradient(self.initial).array).all()) def test_sampler(self): - pass #TODO: when we get a sampler class loaded in + self.assertTrue(isinstance(self.f_stochastic.sampler, SamplerRandom)) + f=SGFunction(self.f_subsets) + self.assertTrue(isinstance( f.sampler, SamplerRandom)) + self.assertEqual(f.sampler.type, 'random_with_replacement') def test_direct(self): self.assertAlmostEqual(self.f_stochastic(self.initial), self.f(self.initial),1) @@ -156,7 +145,7 @@ def test_SGD_simulated_parallel_beam_data(self): def test_SGD_toy_example(self): - sampler=Sampling(5) + sampler=Sampler.random_with_replacement(5) initial = VectorData(np.zeros(25)) b = VectorData(np.random.normal(0,1,25)) functions=[] @@ -175,7 +164,7 @@ def test_SGD_toy_example(self): alg = GD(initial=initial, objective_function=objective, update_objective_interval=1000, rate=rate, atol=1e-9, rtol=1e-6) - alg.max_iteration = 400 + alg.max_iteration = 600 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) @@ -188,7 +177,7 @@ def test_SGD_toy_example(self): alg_stochastic = GD(initial=initial, objective_function=stochastic_objective, update_objective_interval=1000, step_size=0.01, max_iteration =5000) - alg_stochastic.run( 400, verbose=0) + alg_stochastic.run( 600, verbose=0) self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), b.as_array(),3) From 0af2e61cf046cf2fd61635a82506aff692894703 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 22 Nov 2023 16:37:09 +0000 Subject: [PATCH 094/152] Changes from meeting with Edo and Gemma --- .../cil/optimisation/algorithms/SPDHG.py | 69 +++++--- .../cil/optimisation/utilities/sampler.py | 147 ++++++++---------- Wrappers/Python/test/test_algorithms.py | 38 ++--- 3 files changed, 131 insertions(+), 123 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 3d0a589f8a..5fb1a5631e 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -112,30 +112,52 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, sigma=None, tau=None, + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, **kwargs): - super(SPDHG, self).__init__(**kwargs) - if kwargs.get('norms', None) is not None: - operator.set_norms(kwargs.get('norms')) + + max_iteration=kwargs.pop('max_iteration', 0) + update_objective_interval=kwargs.pop('update_objective_interval', 1) + log_file=kwargs.pop('log_file', None) + super(SPDHG, self).__init__(max_iteration=max_iteration, update_objective_interval=update_objective_interval, log_file=log_file) + + + self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + initial=initial, sampler=sampler) + + def _deprecated_kwargs(self, deprecated_kwargs): + """ + Handle deprecated keyword arguments for backward compatibility. + + Parameters + ---------- + deprecated_kwargs : dict + Dictionary of keyword arguments. + + Notes + ----- + This method is called by the set_up method. + """ + norms= deprecated_kwargs.pop('norms', None) + prob=deprecated_kwargs.pop('prob', None) + if norms is not None: + self.operator.set_norms(norms) warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - if sampler is not None: - if kwargs.get('prob', None) is not None: + if self.sampler is not None: + if prob is not None: raise TypeError( '`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: - if kwargs.get('prob', None) is not None: - logging.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - sampler = Sampler.random_with_replacement( - len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) - - if f is not None and operator is not None and g is not None and sampler is not None: - self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - initial=initial, sampler=sampler) - + if prob is not None: + warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') + self.sampler = Sampler.random_with_replacement(len(operator), prob=prob) + + if deprecated_kwargs: + warnings.warn("Additional keyword arguments passed but not used: {}".format(deprecated_kwargs)) + @property def sigma(self): return self._sigma @@ -185,7 +207,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) - def set_step_sizes_custom(self, sigma=None, tau=None): + def set_step_sizes(self, sigma=None, tau=None): r""" Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. Parameters @@ -259,12 +281,7 @@ def set_step_sizes_custom(self, sigma=None, tau=None): "The value of tau should be a Number") self._tau = tau - def set_step_sizes_default(self): - """Calculates the default values for sigma and tau """ - self.set_step_sizes_custom(sigma=None, tau=None) - def check_convergence(self): - # TODO: check this with someone else """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma Returns @@ -281,7 +298,7 @@ def check_convergence(self): return False def set_up(self, f, g, operator, sigma=None, tau=None, - initial=None, sampler=None): + initial=None, sampler=None, **deprecated_kwargs): '''set-up of the algorithm Parameters ---------- @@ -310,15 +327,17 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.operator = operator self.ndual_subsets = self.operator.shape[0] self.sampler = sampler + self._deprecated_kwargs(deprecated_kwargs) + if self.sampler is None: + self.sampler=Sampler.random_with_replacement(len(operator)) self.norms = operator.get_norms_as_list() - # TODO: consider the case it is uniform and not saving the array - self.prob_weights = sampler.prob_weights + self.prob_weights = self.sampler.prob_weights # TODO: consider the case it is uniform and not saving the array if self.prob_weights is None: self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets # might not want to do this until it is called (if computationally expensive) - self.set_step_sizes_custom(sigma=sigma, tau=tau) + self.set_step_sizes(sigma=sigma, tau=tau) # initialize primal variable if initial is None: diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 15048cd967..d89d2b9421 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -20,8 +20,9 @@ import math import time + class SamplerFromFunction(): - def __init__(self, num_indices,function, sampling_type='from_function', prob_weights=None): + def __init__(self, num_indices, function, sampling_type='from_function', prob_weights=None): """ The user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. @@ -34,7 +35,7 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + The sampling type used. Choose from "from_function". function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. @@ -49,28 +50,27 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. - + """ - self.type=sampling_type - self.num_indices=num_indices - self.function=function - if abs(sum(prob_weights)-1)>1e-6: + self.type = sampling_type + self.num_indices = num_indices + self.function = function + if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') - if any(np.array(prob_weights)<0): - raise ValueError('The provided prob_weights must be greater than or equal to zero') - self.prob_weights=prob_weights - self.iteration_number=0 - - - + if any(np.array(prob_weights) < 0): + raise ValueError( + 'The provided prob_weights must be greater than or equal to zero') + self.prob_weights = prob_weights + self.iteration_number = 0 + def next(self): """ - + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ - out=self.function(self.iteration_number) - self.iteration_number=self.iteration_number+1 + out = self.function(self.iteration_number) + self.iteration_number = self.iteration_number+1 return (out) def __next__(self): @@ -80,7 +80,7 @@ def __next__(self): Allows the user to call next(sampler), to get the same result as sampler.next()""" return (self.next()) - def get_samples(self, num_samples=20): + def get_samples(self, num_samples=20): """ Function that takes an index, num_samples, and returns the first num_samples as a numpy array. @@ -98,13 +98,12 @@ def get_samples(self, num_samples=20): self.iteration_number = 0 output = [self.next() for _ in range(num_samples)] self.iteration_number = save_last_index - return (np.array(output)) - - + return (np.array(output)) + + class SamplerFromOrder(): - + def __init__(self, num_indices, order, sampling_type, prob_weights=None): - """ The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. A class to select from a list of indices {0, 1, …, S-1} @@ -117,7 +116,7 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", and "staggered" order: list of indices The list of indices the method selects from using next. @@ -126,29 +125,28 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + """ - if abs(sum(prob_weights)-1)>1e-6: + if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') - if any(np.array(prob_weights)<0): - raise ValueError('The provided prob_weights must be greater than or equal to zero') - - self.prob_weights=prob_weights + if any(np.array(prob_weights) < 0): + raise ValueError( + 'The provided prob_weights must be greater than or equal to zero') + + self.prob_weights = prob_weights self.type = sampling_type self.num_indices = num_indices - self.order = order + self.order = order self.last_index = len(order)-1 - - - + def next(self): """ - + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ - + self.last_index = (self.last_index+1) % len(self.order) return (self.order[self.last_index]) @@ -159,7 +157,7 @@ def __next__(self): Allows the user to call next(sampler), to get the same result as sampler.next()""" return (self.next()) - def get_samples(self, num_samples=20): + def get_samples(self, num_samples=20): """ Function that takes an index, num_samples, and returns the first num_samples as a numpy array. @@ -195,12 +193,10 @@ class SamplerRandom(): The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. + The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" - replace= bool If True, sample with replace, otherwise sample without replacement - prob: list of floats of length num_indices that sum to 1. For random sampling with replacement, this is the probability for each index to be called by next. @@ -210,28 +206,28 @@ class SamplerRandom(): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - """ + def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): """ This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. """ - self.replace=replace - self.prob=prob + self.replace = replace + self.prob = prob if prob is None: - self.prob=[1/num_indices]*num_indices + self.prob = [1/num_indices]*num_indices if replace: - self.prob_weights=prob + self.prob_weights = prob else: - self.prob_weights=[1/num_indices]*num_indices - if abs(sum(self.prob_weights)-1)>1e-6: + self.prob_weights = [1/num_indices]*num_indices + if abs(sum(self.prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') - if any(np.array(self.prob_weights)<0): - raise ValueError('The provided prob_weights must be greater than or equal to zero') - + if any(np.array(self.prob_weights) < 0): + raise ValueError( + 'The provided prob_weights must be greater than or equal to zero') + self.type = sampling_type self.num_indices = num_indices if seed is not None: @@ -240,9 +236,6 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): self.seed = int(time.time()) self.generator = np.random.RandomState(self.seed) - - - def next(self): """ @@ -251,11 +244,8 @@ def next(self): This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with and without replacement. """ - - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) - - + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) def __next__(self): """ @@ -285,6 +275,7 @@ def get_samples(self, num_samples=20): self.generator = save_generator return (np.array(output)) + class Sampler(): r""" @@ -298,7 +289,7 @@ class Sampler(): The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. Choose from "from_function", "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + The sampling type used. Choose from "from_function", "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement", "random_without_replacement" and "from_function". order: list of indices The list of indices the method selects from using next. @@ -371,7 +362,7 @@ class Sampler(): def sequential(num_indices): """ Function that outputs a sampler that outputs sequentially. - + Parameters ---------- num_indices: int @@ -399,7 +390,8 @@ def sequential(num_indices): 0 """ order = list(range(num_indices)) - sampler = SamplerFromOrder(num_indices, sampling_type='sequential', order=order, prob_weights=[1/num_indices]*num_indices) + sampler = SamplerFromOrder(num_indices, sampling_type='sequential', order=order, prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod @@ -416,7 +408,7 @@ def custom_order(num_indices, custom_list, prob_weights=None): prob_weights: list of floats of length num_indices that sum to 1. Default is None and the prob_weights are calculated automatically. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + Example -------- @@ -439,14 +431,13 @@ def custom_order(num_indices, custom_list, prob_weights=None): [1 4 6 7 8] """ - if prob_weights is None: - temp_list=[] + if prob_weights is None: + temp_list = [] for i in range(num_indices): temp_list.append(custom_list.count(i)) - total=sum(temp_list) - prob_weights=[x/total for x in temp_list] - - + total = sum(temp_list) + prob_weights = [x/total for x in temp_list] + sampler = SamplerFromOrder( num_indices, sampling_type='custom_order', order=custom_list, prob_weights=prob_weights) return sampler @@ -556,7 +547,8 @@ def staggered(num_indices, offset): indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = SamplerFromOrder(num_indices, sampling_type='staggered', order=order, prob_weights=[1/num_indices]*num_indices) + sampler = SamplerFromOrder(num_indices, sampling_type='staggered', order=order, prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod @@ -610,7 +602,7 @@ def random_without_replacement(num_indices, seed=None, prob=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + Example ------- >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) @@ -620,7 +612,8 @@ def random_without_replacement(num_indices, seed=None, prob=None): """ - sampler = SamplerRandom(num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob ) + sampler = SamplerRandom( + num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) return sampler @staticmethod @@ -658,7 +651,7 @@ def from_function(num_indices, function, prob_weights=None): >>> else: >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) - + >>> sampler=Sampler.from_function(50, test_function) >>> for _ in range(11): @@ -679,12 +672,8 @@ def from_function(num_indices, function, prob_weights=None): """ if prob_weights is None: - prob_weights=[1/num_indices]*num_indices - + prob_weights = [1/num_indices]*num_indices - sampler = SamplerFromFunction(num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) + sampler = SamplerFromFunction( + num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler - - - - \ No newline at end of file diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index e863abf20a..2283fe2371 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -808,21 +808,21 @@ def test_SPDHG_defaults_and_setters(self): gamma=1. rho=.99 - spdhg.set_step_sizes_custom() + spdhg.set_step_sizes() self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, 100) - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) - spdhg.set_step_sizes_custom(sigma=None, tau=100) + spdhg.set_step_sizes(sigma=None, tau=100) self.assertListEqual(spdhg.sigma, [gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)] ) self.assertEqual(spdhg.tau, 100) @@ -862,19 +862,19 @@ def test_spdhg_check_convergence(self): spdhg.set_step_sizes_from_ratio(gamma,rho) self.assertFalse(spdhg.check_convergence()) - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertFalse(spdhg.check_convergence()) - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertTrue(spdhg.check_convergence()) - spdhg.set_step_sizes_custom(sigma=None, tau=100) + spdhg.set_step_sizes(sigma=None, tau=100) self.assertTrue(spdhg.check_convergence()) @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12,12)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -922,7 +922,7 @@ def test_SPDHG_vs_PDHG_implicit(self): # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 70, + max_iteration = 80, update_objective_interval = 1000) pdhg.run(verbose=0) @@ -957,7 +957,7 @@ def test_SPDHG_vs_PDHG_implicit(self): prob = [1/len(A)]*len(A) spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 320, + max_iteration = 200, update_objective_interval=1000, prob = prob) spdhg.run(1000, verbose=0) @@ -974,7 +974,7 @@ def test_SPDHG_vs_PDHG_implicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12,12)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -1039,8 +1039,8 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 220, - update_objective_interval=220, prob = prob) + max_iteration = 300, + update_objective_interval=300, prob = prob) spdhg.run(1000, verbose=0) @@ -1059,8 +1059,8 @@ def test_SPDHG_vs_PDHG_explicit(self): f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) - pdhg.max_iteration = 180 - pdhg.update_objective_interval =180 + pdhg.max_iteration = 300 + pdhg.update_objective_interval =300 pdhg.run(1000, verbose=0) @@ -1155,15 +1155,15 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 330, - update_objective_interval=330, prob = prob.copy(), use_axpby=True) + max_iteration = 250, + update_objective_interval=250, prob = prob.copy(), use_axpby=True) ) algos[0].run(1000, verbose=0) algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 330, - update_objective_interval=330, prob = prob.copy(), use_axpby=False) + max_iteration = 250, + update_objective_interval=250, prob = prob.copy(), use_axpby=False) ) algos[1].run(1000, verbose=0) From 8e140345f5f88e9889481f30382bd4a6700848cb Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 22 Nov 2023 16:39:15 +0000 Subject: [PATCH 095/152] Remove changes to BlockOperator.py --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 78357e68b6..c92b3d54d4 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -77,7 +77,7 @@ class BlockOperator(Operator): __array_priority__ = 1 def __init__(self, *args, **kwargs): - + self.operators = args shape = kwargs.get('shape', None) if shape is None: From 5c34e69af5d4beada2c7a791702bf94d2c687c5d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 22 Nov 2023 16:44:40 +0000 Subject: [PATCH 096/152] sigma and tau properties --- .../cil/optimisation/algorithms/SPDHG.py | 49 ++++++++++--------- .../cil/optimisation/utilities/sampler.py | 2 +- 2 files changed, 26 insertions(+), 25 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 5fb1a5631e..d64b85c98c 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -54,7 +54,7 @@ class SPDHG(Algorithm): parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets - + **kwargs: prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ @@ -112,20 +112,18 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, **kwargs): - - - max_iteration=kwargs.pop('max_iteration', 0) - update_objective_interval=kwargs.pop('update_objective_interval', 1) - log_file=kwargs.pop('log_file', None) - super(SPDHG, self).__init__(max_iteration=max_iteration, update_objective_interval=update_objective_interval, log_file=log_file) - + max_iteration = kwargs.pop('max_iteration', 0) + update_objective_interval = kwargs.pop('update_objective_interval', 1) + log_file = kwargs.pop('log_file', None) + super(SPDHG, self).__init__(max_iteration=max_iteration, + update_objective_interval=update_objective_interval, log_file=log_file) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - initial=initial, sampler=sampler) - + initial=initial, sampler=sampler) + def _deprecated_kwargs(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. @@ -139,9 +137,9 @@ def _deprecated_kwargs(self, deprecated_kwargs): ----- This method is called by the set_up method. """ - norms= deprecated_kwargs.pop('norms', None) - prob=deprecated_kwargs.pop('prob', None) - if norms is not None: + norms = deprecated_kwargs.pop('norms', None) + prob = deprecated_kwargs.pop('prob', None) + if norms is not None: self.operator.set_norms(norms) warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') @@ -153,11 +151,13 @@ def _deprecated_kwargs(self, deprecated_kwargs): else: if prob is not None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - self.sampler = Sampler.random_with_replacement(len(operator), prob=prob) - + self.sampler = Sampler.random_with_replacement( + len(operator), prob=prob) + if deprecated_kwargs: - warnings.warn("Additional keyword arguments passed but not used: {}".format(deprecated_kwargs)) - + warnings.warn("Additional keyword arguments passed but not used: {}".format( + deprecated_kwargs)) + @property def sigma(self): return self._sigma @@ -329,10 +329,11 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.sampler = sampler self._deprecated_kwargs(deprecated_kwargs) if self.sampler is None: - self.sampler=Sampler.random_with_replacement(len(operator)) + self.sampler = Sampler.random_with_replacement(len(operator)) self.norms = operator.get_norms_as_list() - self.prob_weights = self.sampler.prob_weights # TODO: consider the case it is uniform and not saving the array + # TODO: consider the case it is uniform and not saving the array + self.prob_weights = self.sampler.prob_weights if self.prob_weights is None: self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets @@ -361,9 +362,9 @@ def set_up(self, f, g, operator, sigma=None, tau=None, def update(self): # Gradient descent for the primal variable # x_tmp = x - tau * zbar - self.x.sapyb(1., self.zbar, -self._tau, out=self.x_tmp) + self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) - self.g.proximal(self.x_tmp, self._tau, out=self.x) + self.g.proximal(self.x_tmp, self.tau, out=self.x) # Choose subset i = next(self.sampler) @@ -372,9 +373,9 @@ def update(self): # y_k = y_old[i] + sigma[i] * K[i] x y_k = self.operator[i].direct(self.x) - y_k.sapyb(self._sigma[i], self.y_old[i], 1., out=y_k) + y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) - y_k = self.f[i].proximal_conjugate(y_k, self._sigma[i]) + y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) # Back-project # x_tmp = K[i]^*(y_k - y_old[i]) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index d89d2b9421..6b73c3c6ee 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -40,7 +40,7 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices #TODO: write unit tests. + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. From d1fffdf5fb6ec7b8cd21e1f990802d6309f45dc6 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 23 Nov 2023 11:23:33 +0000 Subject: [PATCH 097/152] Another attempt at speeding up unit tests --- Wrappers/Python/test/test_algorithms.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 2283fe2371..d501af8389 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -1155,14 +1155,14 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 250, + max_iteration = 200, update_objective_interval=250, prob = prob.copy(), use_axpby=True) ) algos[0].run(1000, verbose=0) algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 250, + max_iteration = 200, update_objective_interval=250, prob = prob.copy(), use_axpby=False) ) @@ -1177,7 +1177,7 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): ) logging.info("Quality measures {}".format(qm)) assert qm[0] < 0.005 - assert qm[1] < 5.e-05 + assert qm[1] < 0.001 @unittest.skipUnless(has_astra, "ccpi-astra not available") From b3dc8a1cae4c151f387b6fc0b7f1f6229a11ee37 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 23 Nov 2023 13:27:41 +0000 Subject: [PATCH 098/152] Added random seeds to tests --- Wrappers/Python/test/test_algorithms.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index d501af8389..d9ba1d353a 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -957,8 +957,8 @@ def test_SPDHG_vs_PDHG_implicit(self): prob = [1/len(A)]*len(A) spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 200, - update_objective_interval=1000, prob = prob) + max_iteration = 250, sampler=Sampler.random_with_replacement(len(A), seed=2), + update_objective_interval=1000) spdhg.run(1000, verbose=0) qm = (mae(spdhg.get_output(), pdhg.get_output()), @@ -974,7 +974,7 @@ def test_SPDHG_vs_PDHG_implicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12,12)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -1040,7 +1040,7 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F,g=G,operator=A, max_iteration = 300, - update_objective_interval=300, prob = prob) + update_objective_interval=300, sampler=Sampler.random_with_replacement(len(A), prob=prob, seed=10)) spdhg.run(1000, verbose=0) @@ -1155,15 +1155,15 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 200, - update_objective_interval=250, prob = prob.copy(), use_axpby=True) + max_iteration = 220, + update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=True) ) algos[0].run(1000, verbose=0) algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 200, - update_objective_interval=250, prob = prob.copy(), use_axpby=False) + max_iteration = 220, + update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=False) ) algos[1].run(1000, verbose=0) From edbaa9fc02e7f29c8bce560889c05f53ddcbb0c9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 24 Nov 2023 17:08:51 +0000 Subject: [PATCH 099/152] Started on Gemma's suggestions --- .../cil/optimisation/algorithms/SPDHG.py | 21 +-- .../cil/optimisation/utilities/sampler.py | 143 +++++++++--------- 2 files changed, 85 insertions(+), 79 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index d64b85c98c..fd85883ced 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -144,14 +144,14 @@ def _deprecated_kwargs(self, deprecated_kwargs): warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - if self.sampler is not None: + if self._sampler is not None: if prob is not None: raise TypeError( '`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: if prob is not None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - self.sampler = Sampler.random_with_replacement( + self._sampler = Sampler.random_with_replacement( len(operator), prob=prob) if deprecated_kwargs: @@ -289,7 +289,7 @@ def check_convergence(self): Boolean True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. N.B Convergence criterion currently can only be checked for scalar values of tau. """ - for i in range(len(self._sigma)): + for i in range(self.ndual_subsets): if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): if self._sigma[i] * self._tau * self.norms[i]**2 > self.prob_weights[i]: return False @@ -326,18 +326,19 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - self.sampler = sampler + self._sampler = sampler self._deprecated_kwargs(deprecated_kwargs) - if self.sampler is None: - self.sampler = Sampler.random_with_replacement(len(operator)) + if self._sampler is None: + self._sampler = Sampler.random_with_replacement(len(operator)) self.norms = operator.get_norms_as_list() # TODO: consider the case it is uniform and not saving the array - self.prob_weights = self.sampler.prob_weights - if self.prob_weights is None: + if self._sampler.prob_weights is None: self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets + else: + self.prob_weights=self._sampler.prob_weights - # might not want to do this until it is called (if computationally expensive) + self.set_step_sizes(sigma=sigma, tau=tau) # initialize primal variable @@ -367,7 +368,7 @@ def update(self): self.g.proximal(self.x_tmp, self.tau, out=self.x) # Choose subset - i = next(self.sampler) + i = next(self._sampler) # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 6b73c3c6ee..25dcf04d4f 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -42,6 +42,33 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + Example + ------- + >>> def test_function(iteration_number): + >>> if iteration_number<500: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(49,1)[0]) + >>> else: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(50,1)[0]) + + + >>> sampler=SamplerFromFunction(50, test_function) + >>> for _ in range(11): + >>> print(sampler.next()) + >>> print(list(sampler.get_samples(25))) + 44 + 37 + 40 + 42 + 46 + 35 + 10 + 47 + 3 + 28 + 9 + [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] Note @@ -52,38 +79,33 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we """ - self.type = sampling_type - self.num_indices = num_indices + self._type = sampling_type + self._num_indices = num_indices self.function = function if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') if any(np.array(prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') - self.prob_weights = prob_weights - self.iteration_number = 0 + self._prob_weights = prob_weights + self._iteration_number = 0 def next(self): """ - - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - + Returns and increments the sampler """ - out = self.function(self.iteration_number) - self.iteration_number = self.iteration_number+1 - return (out) + out = self.function(self._iteration_number) + self._iteration_number +=1 + return out def __next__(self): - """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - Allows the user to call next(sampler), to get the same result as sampler.next()""" - return (self.next()) + return self.next() def get_samples(self, num_samples=20): """ Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + TODO: change this to be relevant to this class! num_samples: int, default=20 The number of samples to return. @@ -94,11 +116,11 @@ def get_samples(self, num_samples=20): >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ - save_last_index = self.iteration_number - self.iteration_number = 0 + save_last_index = self._iteration_number + self._iteration_number = 0 output = [self.next() for _ in range(num_samples)] - self.iteration_number = save_last_index - return (np.array(output)) + self._iteration_number = save_last_index + return np.array(output) class SamplerFromOrder(): @@ -134,28 +156,21 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') - self.prob_weights = prob_weights - self.type = sampling_type - self.num_indices = num_indices - self.order = order - self.last_index = len(order)-1 + self._prob_weights = prob_weights + self._type = sampling_type + self._num_indices = num_indices + self._order = order + self._last_index = len(order)-1 + # TODO: add in properties for the things that need calling by SPDHG def next(self): - """ + """Returns and increments the sampler """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - """ - - self.last_index = (self.last_index+1) % len(self.order) - return (self.order[self.last_index]) + self._last_index = (self._last_index+1) % len(self._order) + return self._order[self._last_index] def __next__(self): - """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - Allows the user to call next(sampler), to get the same result as sampler.next()""" - return (self.next()) + return self.next() def get_samples(self, num_samples=20): """ @@ -172,11 +187,11 @@ def get_samples(self, num_samples=20): [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ - save_last_index = self.last_index - self.last_index = len(self.order)-1 + save_last_index = self._last_index + self._last_index = len(self._order)-1 output = [self.next() for _ in range(num_samples)] - self.last_index = save_last_index - return (np.array(output)) + self._last_index = save_last_index + return np.array(output) class SamplerRandom(): @@ -214,45 +229,35 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): """ - self.replace = replace - self.prob = prob + self._replace = replace + self._prob = prob if prob is None: - self.prob = [1/num_indices]*num_indices + self._prob = [1/num_indices]*num_indices if replace: - self.prob_weights = prob + self._prob_weights = self._prob else: - self.prob_weights = [1/num_indices]*num_indices - if abs(sum(self.prob_weights)-1) > 1e-6: + self._prob_weights = [1/num_indices]*num_indices + if abs(sum(self._prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') - if any(np.array(self.prob_weights) < 0): + if any(np.array(self._prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') - self.type = sampling_type - self.num_indices = num_indices + self._type = sampling_type + self._num_indices = num_indices if seed is not None: - self.seed = seed + self._seed = seed else: - self.seed = int(time.time()) - self.generator = np.random.RandomState(self.seed) + self._seed = int(time.time()) + self._generator = np.random.RandomState(self._seed) def next(self): - """ - - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + """ Returns and increments the sampler """ - This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with and without replacement. - - """ - - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + return int(self._generator.choice(self._num_indices, 1, p=self._prob, replace=self._replace)) def __next__(self): - """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - Allows the user to call next(sampler), to get the same result as sampler.next()""" - return (self.next()) + return self.next() def get_samples(self, num_samples=20): """ @@ -269,11 +274,11 @@ def get_samples(self, num_samples=20): [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ - save_generator = self.generator - self.generator = np.random.RandomState(self.seed) + save_generator = self._generator + self._generator = np.random.RandomState(self._seed) output = [self.next() for _ in range(num_samples)] - self.generator = save_generator - return (np.array(output)) + self._generator = save_generator + return np.array(output) class Sampler(): From dc1b67ae30b8496e9c80ef5f5be91d54c1792b53 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 27 Nov 2023 14:20:41 +0000 Subject: [PATCH 100/152] Some more of Gemma's changes --- .../cil/optimisation/algorithms/SPDHG.py | 172 ++++++++-------- .../cil/optimisation/utilities/__init__.py | 3 + .../cil/optimisation/utilities/sampler.py | 188 +++++++++++++----- Wrappers/Python/test/test_sampler.py | 56 +++--- docs/source/optimisation.rst | 29 +++ 5 files changed, 285 insertions(+), 163 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index fd85883ced..fd6baa70c1 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -19,6 +19,7 @@ # Claire Delplancke (University of Bath) from cil.optimisation.algorithms import Algorithm +from cil.optimisation.operators import BlockOperator import numpy as np import warnings import logging @@ -116,18 +117,93 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, **kwargs): max_iteration = kwargs.pop('max_iteration', 0) - update_objective_interval = kwargs.pop('update_objective_interval', 1) - log_file = kwargs.pop('log_file', None) + return_all=kwargs.pop('return_all', False) + print_interval= kwargs.pop('print_interval', None) + log_file= kwargs.pop('log_file', None) + update_objective_interval = kwargs.get('update_objective_interval', 1) super(SPDHG, self).__init__(max_iteration=max_iteration, - update_objective_interval=update_objective_interval, log_file=log_file) + update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval, update_objective_interval=update_objective_interval, return_all=return_all) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler) + + def set_up(self, f, g, operator, sigma=None, tau=None, + initial=None, sampler=None, **deprecated_kwargs): + '''set-up of the algorithm + Parameters + ---------- + f : BlockFunction + Each must be a convex function with a "simple" proximal method of its conjugate + g : Function + A convex function with a "simple" proximal + operator : BlockOperator + BlockOperator must contain Linear Operators + tau : positive float, optional, default=None + Step size parameter for Primal problem + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + initial : DataContainer, optional, default=None + Initial point for the SPDHG algorithm + gamma : float + parameter controlling the trade-off between the primal and dual step sizes + sampler: an instance of a `cil.optimisation.utilities.Sampler` class + Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets + ''' + logging.info("{} setting up".format(self.__class__.__name__, )) + + # algorithmic parameters + self.f = f + self.g = g + self.operator = operator + + if not isinstance(operator, BlockOperator): + raise TypeError("operator should be a BlockOperator") + + self.ndual_subsets = len(self.operator) + self._sampler = sampler + self._deprecated_kwargs(deprecated_kwargs) + + if self._sampler is None: + self._sampler = Sampler.random_with_replacement(len(operator)) + + if self._sampler.num_indices != len(operator): + raise ValueError('The `num_indices` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') + + self.norms = operator.get_norms_as_list() + + if self._sampler.prob_weights is None: + self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets + else: + self.prob_weights=self._sampler.prob_weights + + self.set_step_sizes(sigma=sigma, tau=tau) + + # initialize primal variable + if initial is None: + self.x = self.operator.domain_geometry().allocate(0) + else: + self.x = initial.copy() + + self.x_tmp = self.operator.domain_geometry().allocate(0) + + # initialize dual variable to 0 + self.y_old = operator.range_geometry().allocate(0) + + # initialize variable z corresponding to back-projected dual variable + self.z = operator.domain_geometry().allocate(0) + self.zbar = operator.domain_geometry().allocate(0) + # relaxation parameter + self.theta = 1 + self.configured = True + logging.info("{} configured".format(self.__class__.__name__, )) + def _deprecated_kwargs(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. + TODO: test this! + Parameters ---------- deprecated_kwargs : dict @@ -152,7 +228,7 @@ def _deprecated_kwargs(self, deprecated_kwargs): if prob is not None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') self._sampler = Sampler.random_with_replacement( - len(operator), prob=prob) + len(self.operator), prob=prob) if deprecated_kwargs: warnings.warn("Additional keyword arguments passed but not used: {}".format( @@ -171,9 +247,9 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): Parameters ---------- - gamma : float + gamma : Positive float parameter controlling the trade-off between the primal and dual step sizes - rho : float + rho : Positive float parameter controlling the size of the product :math: \sigma\tau :math: Note @@ -195,7 +271,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): if isinstance(rho, Number): if rho <= 0: raise ValueError( - "The step-sizes of SPDHG are positive, gamma should also be positive") + "The step-sizes of SPDHG are positive, rho should also be positive") else: raise ValueError( @@ -246,15 +322,12 @@ def set_step_sizes(self, sigma=None, tau=None): rho = .99 if sigma is not None: if len(sigma) == self.ndual_subsets: - if all(isinstance(x, Number) for x in sigma): - if all(x > 0 for x in sigma): + if all(isinstance(x, Number) and x > 0 for x in sigma): pass - else: - raise ValueError( - "The values of sigma should be positive") else: raise ValueError( - "The values of sigma should be a Number") + "Sigma expected to be a positive number.") + else: raise ValueError( "Please pass a list of floats to sigma with the same number of entries as number of operators") @@ -272,13 +345,12 @@ def set_step_sizes(self, sigma=None, tau=None): self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) else: - if isinstance(tau, Number): - if tau <= 0: - raise ValueError( - "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) + if isinstance(tau, Number) and tau > 0: + pass else: raise ValueError( - "The value of tau should be a Number") + "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) + self._tau = tau def check_convergence(self): @@ -297,69 +369,7 @@ def check_convergence(self): else: return False - def set_up(self, f, g, operator, sigma=None, tau=None, - initial=None, sampler=None, **deprecated_kwargs): - '''set-up of the algorithm - Parameters - ---------- - f : BlockFunction - Each must be a convex function with a "simple" proximal method of its conjugate - g : Function - A convex function with a "simple" proximal - operator : BlockOperator - BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - initial : DataContainer, optional, default=None - Initial point for the SPDHG algorithm - gamma : float - parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class - Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets - ''' - logging.info("{} setting up".format(self.__class__.__name__, )) - - # algorithmic parameters - self.f = f - self.g = g - self.operator = operator - self.ndual_subsets = self.operator.shape[0] - self._sampler = sampler - self._deprecated_kwargs(deprecated_kwargs) - if self._sampler is None: - self._sampler = Sampler.random_with_replacement(len(operator)) - self.norms = operator.get_norms_as_list() - - # TODO: consider the case it is uniform and not saving the array - if self._sampler.prob_weights is None: - self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets - else: - self.prob_weights=self._sampler.prob_weights - - - self.set_step_sizes(sigma=sigma, tau=tau) - - # initialize primal variable - if initial is None: - self.x = self.operator.domain_geometry().allocate(0) - else: - self.x = initial.copy() - - self.x_tmp = self.operator.domain_geometry().allocate(0) - - # initialize dual variable to 0 - self.y_old = operator.range_geometry().allocate(0) - - # initialize variable z corresponding to back-projected dual variable - self.z = operator.domain_geometry().allocate(0) - self.zbar = operator.domain_geometry().allocate(0) - # relaxation parameter - self.theta = 1 - self.configured = True - logging.info("{} configured".format(self.__class__.__name__, )) - + def update(self): # Gradient descent for the primal variable # x_tmp = x - tau * zbar diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index 6aa6db103f..a96692e1ce 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -19,3 +19,6 @@ from .sampler import Sampler +from .sampler import SamplerFromFunction +from .sampler import SamplerFromOrder +from .sampler import SamplerRandom diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 25dcf04d4f..20d215e82e 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -22,12 +22,11 @@ class SamplerFromFunction(): - def __init__(self, num_indices, function, sampling_type='from_function', prob_weights=None): - """ - The user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. + """ A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. Parameters ---------- @@ -37,11 +36,11 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we sampling_type:str The sampling type used. Choose from "from_function". - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + Example ------- >>> def test_function(iteration_number): @@ -51,9 +50,8 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we >>> else: >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) - - - >>> sampler=SamplerFromFunction(50, test_function) + >>> + >>> Sampler.from_function(num_indices, function, prob_weights=None) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -70,32 +68,43 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - Note ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise - the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. - - - + the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ + + def __init__(self, num_indices, function, sampling_type='from_function', prob_weights=None): + self._type = sampling_type self._num_indices = num_indices self.function = function + if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') + if any(np.array(prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') + self._prob_weights = prob_weights self._iteration_number = 0 + @property + def prob_weights(self): + return self._prob_weights + + @property + def num_indices(self): + return self._num_indices + + def next(self): """ Returns and increments the sampler """ out = self.function(self._iteration_number) - self._iteration_number +=1 + self._iteration_number += 1 return out def __next__(self): @@ -103,18 +112,10 @@ def __next__(self): def get_samples(self, num_samples=20): """ - Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + Returns the first `num_samples` produced by the sampler as a numpy array. - TODO: change this to be relevant to this class! num_samples: int, default=20 The number of samples to return. - - Example - ------- - - >>> sampler=Sampler.random_with_replacement(5) - >>> print(sampler.get_samples()) - [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ save_last_index = self._iteration_number self._iteration_number = 0 @@ -127,10 +128,9 @@ class SamplerFromOrder(): def __init__(self, num_indices, order, sampling_type, prob_weights=None): """ - The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. - A class to select from a list of indices {0, 1, …, S-1} - The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + A class to select from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. Parameters ---------- @@ -143,15 +143,58 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): order: list of indices The list of indices the method selects from using next. - prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + Example + ------- + + >>> sampler=Sampler.custom_order(12,[1,4,6,7,8,9,11]) + >>> print(sampler.get_samples(11)) + >>> for _ in range(9): + >>> print(sampler.next()) + >>> print(sampler.get_samples(5)) + [ 1 4 6 7 8 9 11 1 4 6 7] + 1 + 4 + 6 + 7 + 8 + 9 + 11 + 1 + 4 + [1 4 6 7 8] + + + >>> sampler=Sampler.staggered(21,4) + >>> print(sampler.get_samples(5)) + >>> for _ in range(15): + >>> print(sampler.next()) + >>> print(sampler.get_samples(5)) + [ 0 4 8 12 16] + 0 + 4 + 8 + 12 + 16 + 20 + 1 + 5 + 9 + 13 + 17 + 2 + 6 + 10 + 14 + [ 0 4 8 12 16] """ if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') + if any(np.array(prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') @@ -162,7 +205,17 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): self._order = order self._last_index = len(order)-1 - # TODO: add in properties for the things that need calling by SPDHG + + + @property + def prob_weights(self): + return self._prob_weights + + @property + def num_indices(self): + return self._num_indices + + def next(self): """Returns and increments the sampler """ @@ -174,7 +227,10 @@ def __next__(self): def get_samples(self, num_samples=20): """ - Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + Returns the first `num_samples` as a numpy array. + + Parameters + ---------- num_samples: int, default=20 The number of samples to return. @@ -195,12 +251,11 @@ def get_samples(self, num_samples=20): class SamplerRandom(): - r""" - The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. The function next() outputs a single next index from the list {0,1,…,S-1} . To be run again and again, depending on how many iterations. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. Parameters ---------- @@ -221,35 +276,59 @@ class SamplerRandom(): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + Example + ------- + >>> sampler=Sampler.random_with_replacement(5) + >>> print(sampler.get_samples(10)) + [3 4 0 0 2 3 3 2 2 1] + + >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) + >>> print(sampler.get_samples(10)) + [0 1 3 0 0 3 0 0 0 0] + + >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) + >>> print(sampler.get_samples(16)) + [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] """ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): - """ - This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. - - """ - + self._replace = replace self._prob = prob + if prob is None: self._prob = [1/num_indices]*num_indices + if replace: self._prob_weights = self._prob else: self._prob_weights = [1/num_indices]*num_indices + if abs(sum(self._prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') + if any(np.array(self._prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') self._type = sampling_type self._num_indices = num_indices + if seed is not None: self._seed = seed else: self._seed = int(time.time()) + self._generator = np.random.RandomState(self._seed) + + @property + def prob_weights(self): + return self._prob_weights + + @property + def num_indices(self): + return self._num_indices def next(self): """ Returns and increments the sampler """ @@ -261,14 +340,13 @@ def __next__(self): def get_samples(self, num_samples=20): """ - Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + Returns the first `num_samples` as a numpy array. num_samples: int, default=20 The number of samples to return. Example ------- - >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] @@ -316,7 +394,6 @@ class Sampler(): >>> print(sampler.get_samples(5)) >>> for _ in range(11): print(sampler.next()) - [0 1 2 3 4] 0 1 @@ -336,7 +413,6 @@ class Sampler(): >>> for _ in range(12): >>> print(next(sampler)) >>> print(sampler.get_samples()) - 3 4 0 @@ -380,7 +456,6 @@ def sequential(num_indices): >>> print(sampler.get_samples(5)) >>> for _ in range(11): print(sampler.next()) - [0 1 2 3 4] 0 1 @@ -422,7 +497,6 @@ def custom_order(num_indices, custom_list, prob_weights=None): >>> for _ in range(9): >>> print(sampler.next()) >>> print(sampler.get_samples(5)) - [ 1 4 6 7 8 9 11 1 4 6 7] 1 4 @@ -436,6 +510,7 @@ def custom_order(num_indices, custom_list, prob_weights=None): [1 4 6 7 8] """ + if prob_weights is None: temp_list = [] for i in range(num_indices): @@ -463,7 +538,6 @@ def herman_meyer(num_indices): ------- >>> sampler=Sampler.herman_meyer(12) >>> print(sampler.get_samples(16)) - [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] """ @@ -472,34 +546,45 @@ def _herman_meyer_order(n): n_variable = n i = 2 factors = [] + while i * i <= n_variable: if n_variable % i: i += 1 else: n_variable //= i factors.append(i) + if n_variable > 1: factors.append(n_variable) + n_factors = len(factors) + if n_factors == 0: raise ValueError( 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') + order = [0 for _ in range(n)] value = 0 + for factor_n in range(n_factors): n_rep_value = 0 + if factor_n == 0: n_change_value = 1 else: n_change_value = math.prod(factors[:factor_n]) + for element in range(n): mapping = value n_rep_value += 1 + if n_rep_value >= n_change_value: value = value + 1 n_rep_value = 0 + if value == factors[factor_n]: value = 0 + order[element] = order[element] + \ math.prod(factors[factor_n+1:]) * mapping return order @@ -528,7 +613,6 @@ def staggered(num_indices, offset): >>> for _ in range(15): >>> print(sampler.next()) >>> print(sampler.get_samples(5)) - [ 0 4 8 12 16] 0 4 @@ -547,8 +631,10 @@ def staggered(num_indices, offset): 14 [ 0 4 8 12 16] """ + if offset >= num_indices: raise (ValueError('The offset should be less than the number of indices')) + indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] @@ -573,24 +659,19 @@ def random_with_replacement(num_indices, prob=None, seed=None): Example ------- - - >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples(10)) - [3 4 0 0 2 3 3 2 2 1] - Example - ------- - + >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) - [0 1 3 0 0 3 0 0 0 0] """ if prob == None: prob = [1/num_indices] * num_indices + sampler = SamplerRandom( num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @@ -600,21 +681,20 @@ def random_without_replacement(num_indices, seed=None, prob=None): """ Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. - + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - Example ------- >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) >>> print(sampler.get_samples(16)) [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] - """ sampler = SamplerRandom( @@ -645,7 +725,7 @@ def from_function(num_indices, function, prob_weights=None): Note ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise - the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. + the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. Example ------- diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 576660a3d9..d7723de957 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -43,50 +43,50 @@ def test_init(self): sampler = Sampler.sequential(10) self.assertEqual(sampler.num_indices, 10) - self.assertEqual(sampler.type, 'sequential') - self.assertListEqual(sampler.order, list(range(10))) - self.assertEqual(sampler.last_index, 9) + self.assertEqual(sampler._type, 'sequential') + self.assertListEqual(sampler._order, list(range(10))) + self.assertEqual(sampler._last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) sampler = Sampler.random_without_replacement(7) self.assertEqual(sampler.num_indices, 7) - self.assertEqual(sampler.type, 'random_without_replacement') - self.assertEqual(sampler.prob, [1/7]*7) - self.assertListEqual(sampler.prob_weights, sampler.prob) + self.assertEqual(sampler._type, 'random_without_replacement') + self.assertEqual(sampler._prob, [1/7]*7) + self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.random_without_replacement(8, seed=1) self.assertEqual(sampler.num_indices, 8) - self.assertEqual(sampler.type, 'random_without_replacement') - self.assertEqual(sampler.prob, [1/8]*8) - self.assertEqual(sampler.seed, 1) - self.assertListEqual(sampler.prob_weights, sampler.prob) + self.assertEqual(sampler._type, 'random_without_replacement') + self.assertEqual(sampler._prob, [1/8]*8) + self.assertEqual(sampler._seed, 1) + self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.herman_meyer(12) self.assertEqual(sampler.num_indices, 12) - self.assertEqual(sampler.type, 'herman_meyer') - self.assertEqual(sampler.last_index, 11) + self.assertEqual(sampler._type, 'herman_meyer') + self.assertEqual(sampler._last_index, 11) self.assertListEqual( - sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + sampler._order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) self.assertEqual(sampler.num_indices, 5) - self.assertEqual(sampler.type, 'random_with_replacement') - self.assertListEqual(sampler.prob, [1/5] * 5) + self.assertEqual(sampler._type, 'random_with_replacement') + self.assertListEqual(sampler._prob, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) self.assertEqual(sampler.num_indices, 4) - self.assertEqual(sampler.type, 'random_with_replacement') - self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) + self.assertEqual(sampler._type, 'random_with_replacement') + self.assertListEqual(sampler._prob, [0.7, 0.1, 0.1, 0.1]) self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) self.assertEqual(sampler.num_indices, 21) - self.assertEqual(sampler.type, 'staggered') - self.assertListEqual(sampler.order, [ + self.assertEqual(sampler._type, 'staggered') + self.assertListEqual(sampler._order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) - self.assertEqual(sampler.last_index, 20) + self.assertEqual(sampler._last_index, 20) self.assertListEqual(sampler.prob_weights, [1/21] * 21) with self.assertRaises(ValueError): @@ -95,17 +95,17 @@ def test_init(self): sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.num_indices, 12) - self.assertEqual(sampler.type, 'custom_order') - self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.last_index, 6) + self.assertEqual(sampler._type, 'custom_order') + self.assertListEqual(sampler._order, [1, 4, 6, 7, 8, 9, 11]) + self.assertEqual(sampler._last_index, 6) self.assertListEqual(sampler.prob_weights, [ 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) sampler = Sampler.custom_order(10, [0,1, 2, 3, 4]) self.assertEqual(sampler.num_indices, 10) - self.assertEqual(sampler.type, 'custom_order') - self.assertListEqual(sampler.order, [0,1,2,3,4]) - self.assertEqual(sampler.last_index, 4) + self.assertEqual(sampler._type, 'custom_order') + self.assertListEqual(sampler._order, [0,1,2,3,4]) + self.assertEqual(sampler._last_index, 4) self.assertListEqual(sampler.prob_weights, [ 1/5,1/5,1/5,1/5,1/5,0,0,0,0,0]) @@ -122,12 +122,12 @@ def test_init(self): sampler = Sampler.from_function(50, self.example_function) self.assertListEqual(sampler.prob_weights, [1/50] * 50) self.assertEqual(sampler.num_indices, 50) - self.assertEqual(sampler.type, 'from_function') + self.assertEqual(sampler._type, 'from_function') sampler = Sampler.from_function(40, self.example_function, [1]+[0]*39) self.assertListEqual(sampler.prob_weights, [1]+[0]*39) self.assertEqual(sampler.num_indices, 40) - self.assertEqual(sampler.type, 'from_function') + self.assertEqual(sampler._type, 'from_function') #check probabilities sum to 1 and are positive with self.assertRaises(ValueError): diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 8b92feb669..90bff47aeb 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -365,6 +365,33 @@ Total variation :members: :special-members: + +Utilities +======= +Contains utilities for the CIL optimisation framework. + +Sampler +-------- +A class to select from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + +It is recommended to use the static methods in `cil.optimisation.utilities.sampler` to configure your Sampler object rather than initialising this class directly: + +.. autoclass:: cil.optimisation.utilities.Sampler + :members: + + +The static methods will call one of the following: + +.. autoclass:: cil.optimisation.utilities.SamplerRandom + :members: + +.. autoclass:: cil.optimisation.utilities.SamplerFromFunction + :members: + +.. autoclass:: cil.optimisation.utilities.SamplerFromOrder + :members: + + Block Framework *************** @@ -564,6 +591,8 @@ Which in Python would be like .. _BlockOperator: optimisation.html#cil.optimisation.operators.BlockOperators + + References ---------- From 3b41fc405bfb44a69e4e3c2dcc9abd8ebb590d90 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 27 Nov 2023 15:34:43 +0000 Subject: [PATCH 101/152] Last of Gemma's changes --- .../cil/optimisation/algorithms/SPDHG.py | 11 +- Wrappers/Python/test/test_algorithms.py | 293 +++++++++++------- 2 files changed, 184 insertions(+), 120 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index fd6baa70c1..dbda58f72a 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -120,12 +120,13 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, return_all=kwargs.pop('return_all', False) print_interval= kwargs.pop('print_interval', None) log_file= kwargs.pop('log_file', None) - update_objective_interval = kwargs.get('update_objective_interval', 1) + use_axpby=kwargs.pop('use_axpyb', None) + update_objective_interval = kwargs.pop('update_objective_interval', 1) super(SPDHG, self).__init__(max_iteration=max_iteration, - update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval, update_objective_interval=update_objective_interval, return_all=return_all) + update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval, return_all=return_all) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - initial=initial, sampler=sampler) + initial=initial, sampler=sampler, **kwargs) def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None, **deprecated_kwargs): @@ -201,8 +202,6 @@ def set_up(self, f, g, operator, sigma=None, tau=None, def _deprecated_kwargs(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. - - TODO: test this! Parameters ---------- @@ -231,7 +230,7 @@ def _deprecated_kwargs(self, deprecated_kwargs): len(self.operator), prob=prob) if deprecated_kwargs: - warnings.warn("Additional keyword arguments passed but not used: {}".format( + raise ValueError("Additional keyword arguments passed but not used: {}".format( deprecated_kwargs)) @property diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index d9ba1d353a..8b72a4084a 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -773,108 +773,172 @@ def setUp(self): partitioned_data = sin.partition(self.subsets, 'sequential') self.A = BlockOperator( *[IdentityOperator(partitioned_data[i].geometry) for i in range(self.subsets)]) + self.A2 = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(self.subsets)]) # block function self.F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(self.subsets)]) + for i in range(self.subsets)]) alpha = 0.025 self.G = alpha * FGP_TV() def test_SPDHG_defaults_and_setters(self): - gamma=1. - rho=.99 + gamma = 1. + rho = .99 spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - - + self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() - for i in range(self.subsets)]) - self.assertListEqual(spdhg.prob_weights, [1/self.subsets] * self.subsets) - self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + for i in range(self.subsets)]) + self.assertListEqual(spdhg.prob_weights, [ + 1/self.subsets] * self.subsets) + self.assertListEqual( + spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(0).array) + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + self.assertNumpyArrayEqual( + spdhg.x.array, self.A.domain_geometry().allocate(0).array) self.assertEqual(spdhg.max_iteration, 0) self.assertEqual(spdhg.update_objective_interval, 1) - - - - - gamma=3.7 - rho=5.6 - spdhg.set_step_sizes_from_ratio(gamma,rho) - self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + + gamma = 3.7 + rho = 5.6 + spdhg.set_step_sizes_from_ratio(gamma, rho) + self.assertListEqual( + spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - - gamma=1. - rho=.99 + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + + gamma = 1. + rho = .99 spdhg.set_step_sizes() - self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + self.assertListEqual( + spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, 100) - + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) spdhg.set_step_sizes(sigma=None, tau=100) - self.assertListEqual(spdhg.sigma, [gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)] ) + self.assertListEqual(spdhg.sigma, [ + gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)]) self.assertEqual(spdhg.tau, 100) - def test_spdhg_non_default_init(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1,11)/55.)), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.)), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - - self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) - self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) + self.assertListEqual(spdhg.prob_weights, list(np.arange(1, 11)/55.)) + self.assertNumpyArrayEqual( + spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) - + + def test_spdhg_deprecated_vargs(self): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[ + 1]*len(self.A), prob=[1/(self.subsets-1)]*(self.subsets-1)+[0]) + + self.assertListEqual(self.A.get_norms_as_list(), [1]*len(self.A)) + self.assertListEqual(spdhg.norms, [1]*len(self.A)) + self.assertListEqual(spdhg._sampler.prob_weights, [ + 1/(self.subsets-1)]*(self.subsets-1)+[0]) + self.assertListEqual(spdhg.prob_weights, [ + 1/(self.subsets-1)]*(self.subsets-1)+[0]) + + with self.assertRaises(TypeError): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( + self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) + + with self.assertRaises(ValueError): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, norms=[ + 1]*len(self.A), sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) + def test_spdhg_custom_sampler(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order( len(self.A), [0,0,0,0]), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A), [0, 0, 0, 0]), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) self.assertListEqual(spdhg.prob_weights, [1]+[0]*(len(self.A)-1)) - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A),[0,1,0,1]), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) - self.assertListEqual(spdhg.prob_weights, [.5]+[.5]+[0]*(len(self.A)-2)) - - + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A), [0, 1, 0, 1]), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + self.assertListEqual(spdhg.prob_weights, + [.5]+[.5]+[0]*(len(self.A)-2)) + + def test_spdhg_set_norms(self): + + self.A2.set_norms([1]*len(self.A2)) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A2) + self.assertListEqual(spdhg.norms, [1]*len(self.A2)) def test_spdhg_check_convergence(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - + self.assertTrue(spdhg.check_convergence()) - - gamma=3.7 - rho=0.9 - spdhg.set_step_sizes_from_ratio(gamma,rho) + + gamma = 3.7 + rho = 0.9 + spdhg.set_step_sizes_from_ratio(gamma, rho) self.assertTrue(spdhg.check_convergence()) - - gamma=3.7 - rho=100 - spdhg.set_step_sizes_from_ratio(gamma,rho) + + gamma = 3.7 + rho = 100 + spdhg.set_step_sizes_from_ratio(gamma, rho) self.assertFalse(spdhg.check_convergence()) - + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertFalse(spdhg.check_convergence()) - + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertTrue(spdhg.check_convergence()) spdhg.set_step_sizes(sigma=None, tau=100) self.assertTrue(spdhg.check_convergence()) - @unittest.skipUnless(has_astra, "cil-astra not available") - def test_SPDHG_vs_PDHG_implicit(self): + def test_SPDHG_num_subsets_1(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(10, 10)) + + subsets = 1 + + ig = data.geometry + ig.voxel_size_x = 0.1 + ig.voxel_size_y = 0.1 + + detectors = ig.shape[0] + angles = np.linspace(0, np.pi, 90) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) + # Select device + dev = 'cpu' + + Aop = ProjectionOperator(ig, ag, dev) + + sin = Aop.direct(data) + partitioned_data = sin.partition(subsets, 'sequential') + A = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) + + # block function + F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(subsets)]) + alpha = 0.025 + G = alpha * FGP_TV() - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12,12)) + spdhg = SPDHG(f=F, g=G, operator=A, max_iteration=10, update_objective_interval=10, print_interval=10, log_file=None) + + spdhg.run(7) + pdhg = PDHG(f=F, g=G, operator=A, max_iteration=10, update_objective_interval=10, print_interval=10, log_file=None) + + pdhg.run(7) + self.assertNumpyArrayAlmostEqual(pdhg.solution.as_array(), spdhg.solution.as_array(), decimal=3) + + @unittest.skipUnless(has_astra, "cil-astra not available") + def test_SPDHG_vs_PDHG_implicit(self): + + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12, 12)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -917,15 +981,18 @@ def test_SPDHG_vs_PDHG_implicit(self): # % 'implicit' PDHG, preconditioned step-sizes tau_tmp = 1. sigma_tmp = 1. - tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) - sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) - + tau = sigma_tmp / \ + operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) + sigma = tau_tmp / \ + operator.direct( + sigma_tmp * operator.domain_geometry().allocate(1.)) + # Setup and run the PDHG algorithm - pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 80, - update_objective_interval = 1000) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=80, + update_objective_interval=1000) pdhg.run(verbose=0) - + subsets = 5 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting @@ -955,12 +1022,12 @@ def test_SPDHG_vs_PDHG_implicit(self): G = alpha * TotalVariation(50, 1e-4, lower=0) prob = [1/len(A)]*len(A) - - spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 250, sampler=Sampler.random_with_replacement(len(A), seed=2), - update_objective_interval=1000) + + spdhg = SPDHG(f=F, g=G, operator=A, + max_iteration=250, sampler=Sampler.random_with_replacement(len(A), seed=2), + update_objective_interval=1000) spdhg.run(1000, verbose=0) - + qm = (mae(spdhg.get_output(), pdhg.get_output()), mse(spdhg.get_output(), pdhg.get_output()), psnr(spdhg.get_output(), pdhg.get_output()) @@ -974,7 +1041,7 @@ def test_SPDHG_vs_PDHG_implicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16, 16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -1004,8 +1071,8 @@ def test_SPDHG_vs_PDHG_explicit(self): noisy_data = noise.gaussian(sin, var=0.1, seed=10) else: raise ValueError('Unsupported Noise ', noise) - - #%% 'explicit' SPDHG, scalar step-sizes + + # %% 'explicit' SPDHG, scalar step-sizes subsets = 5 size_of_subsets = int(len(angles)/subsets) # create Gradient operator @@ -1038,13 +1105,13 @@ def test_SPDHG_vs_PDHG_explicit(self): G = IndicatorBox(lower=0) prob = [1/(2*subsets)]*(len(A)-1) + [1/2] - spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 300, - update_objective_interval=300, sampler=Sampler.random_with_replacement(len(A), prob=prob, seed=10)) - + spdhg = SPDHG(f=F, g=G, operator=A, + max_iteration=300, + update_objective_interval=300, sampler=Sampler.random_with_replacement(len(A), prob=prob, seed=10)) + spdhg.run(1000, verbose=0) - #%% 'explicit' PDHG, scalar step-sizes + # %% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) op2 = Aop # Create BlockOperator @@ -1058,13 +1125,13 @@ def test_SPDHG_vs_PDHG_explicit(self): f1 = alpha * MixedL21Norm() f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm - pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma) pdhg.max_iteration = 300 - pdhg.update_objective_interval =300 - + pdhg.update_objective_interval = 300 + pdhg.run(1000, verbose=0) - - #%% show diff between PDHG and SPDHG + + # %% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() # plt.show() @@ -1079,10 +1146,11 @@ def test_SPDHG_vs_PDHG_explicit(self): np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), 1.68590e-05, decimal=3) - @unittest.skipUnless(has_astra, "ccpi-astra not available") +""" @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_SPDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16), dtype=numpy.float32) - + data = dataexample.SIMPLE_PHANTOM_2D.get( + size=(16, 16), dtype=numpy.float32) + ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 @@ -1117,8 +1185,8 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): else: raise ValueError('Unsupported Noise ', noise) - - #%% 'explicit' SPDHG, scalar step-sizes + + # %% 'explicit' SPDHG, scalar step-sizes subsets = 5 size_of_subsets = int(len(angles)/subsets) # create GradientOperator operator @@ -1154,21 +1222,19 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] - algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 220, - update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=True) - ) - + algos.append(SPDHG(f=F, g=G, operator=A, + max_iteration=220, + update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=True) + ) + algos[0].run(1000, verbose=0) - - algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 220, - update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=False) - ) - + + algos.append(SPDHG(f=F, g=G, operator=A, + max_iteration=220, + update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=False) + ) + algos[1].run(1000, verbose=0) - - # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) qm = (mae(algos[0].get_output(), algos[1].get_output()), @@ -1179,10 +1245,9 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): assert qm[0] < 0.005 assert qm[1] < 0.001 - @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_PDHG_vs_PDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16, 16)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 @@ -1233,21 +1298,21 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): # Setup and run the PDHG algorithm algos = [] - - algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 300, - update_objective_interval=1000, use_axpby=True) - ) - + + algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=300, + update_objective_interval=1000, use_axpby=True) + ) + algos[0].run(1000, verbose=0) - algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 300, - update_objective_interval=1000, use_axpby=False) - ) - + algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=300, + update_objective_interval=1000, use_axpby=False) + ) + algos[1].run(1000, verbose=0) - + qm = (mae(algos[0].get_output(), algos[1].get_output()), mse(algos[0].get_output(), algos[1].get_output()), psnr(algos[0].get_output(), algos[1].get_output()) @@ -1255,7 +1320,7 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): logging.info("Quality measures {}".format(qm)) np.testing.assert_array_less(qm[0], 0.005) np.testing.assert_array_less(qm[1], 3e-05) - + """ class PrintAlgo(Algorithm): def __init__(self, **kwargs): From bab0b983eda7936401779e72cd3ed3b4988711d0 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 28 Nov 2023 13:26:46 +0000 Subject: [PATCH 102/152] Edo's comments --- .../cil/optimisation/algorithms/SPDHG.py | 33 +++++++++++++++++-- .../cil/optimisation/utilities/sampler.py | 8 +++-- 2 files changed, 36 insertions(+), 5 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index dbda58f72a..51dc2107f0 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -64,9 +64,38 @@ class SPDHG(Algorithm): Example ------- - Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py - + Example + ------- + >>> data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) + >>> subsets = 10 + >>> ig = data.geometry + >>> ig.voxel_size_x = 0.1 + >>> ig.voxel_size_y = 0.1 + >>> + >>> detectors = ig.shape[0] + >>> angles = np.linspace(0, np.pi, 90) + >>> ag = AcquisitionGeometry.create_Parallel2D().set_angles( + >>> angles, angle_unit='radian').set_panel(detectors, 0.1) + >>> + >>> Aop = ProjectionOperator(ig, ag, 'cpu') + >>> + >>> sin = Aop.direct(data) + >>> partitioned_data = sin.partition(subsets, 'sequential') + >>> A = BlockOperator( + *[ProjectionOperator(ig. partitioned_data[i].geometry, 'cpu') for i in range(subsets)]) + >>> + >>> F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(subsets)]) + >>> alpha = 0.025 + >>> G = alpha * FGP_TV() + >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.custom_order(len(A), [1,3,0,4,5,8,2,3,8,4,5]), + initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + >>> spdhg.run(100) + + Example + ------- + Further examples of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py Note ----- diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 20d215e82e..19c56af4c2 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -128,7 +128,7 @@ class SamplerFromOrder(): def __init__(self, num_indices, order, sampling_type, prob_weights=None): """ - A class to select from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + This sampler will sample from a list `order` that is passed. It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. @@ -362,8 +362,10 @@ def get_samples(self, num_samples=20): class Sampler(): r""" - A class to select from a list of indices {0, 1, …, S-1} - The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. The idea of the factory is to simplify the creation of these instances with the static methods. + + Each factory method will instantiate a class to select from a list of indices `{0, 1, …, S-1}` + Common in each instatiated the class, the function `next()` outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. Each class also has a `get_samples(n)` function which will output the first `n` samples. Parameters From 41ff3b5213700d6c9c38106812116e74046baed7 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 30 Nov 2023 14:44:53 +0000 Subject: [PATCH 103/152] New __str__ functions in sampler --- .../optimisation/operators/BlockOperator.py | 4 +-- .../cil/optimisation/utilities/sampler.py | 26 +++++++++++++++++-- 2 files changed, 26 insertions(+), 4 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index c92b3d54d4..1b13ff541a 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -327,7 +327,7 @@ def __rmul__(self, scalar): Parameters ------------ - + scalar: number or iterable containing numbers ''' @@ -347,7 +347,7 @@ def __rmul__(self, scalar): @property def T(self): '''Returns the transposed of self. - + Recall the input list is shaped in a row-by-row fashion''' newshape = (self.shape[1], self.shape[0]) oplist = [] diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 19c56af4c2..7bbed4a076 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -123,7 +123,14 @@ def get_samples(self, num_samples=20): self._iteration_number = save_last_index return np.array(output) - + def __str__(self): + repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres += "Type : {} \n".format(self._type) + repres += "Current iteration number : {} \n".format(self._iteration_number) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres + class SamplerFromOrder(): def __init__(self, num_indices, order, sampling_type, prob_weights=None): @@ -249,6 +256,14 @@ def get_samples(self, num_samples=20): self._last_index = save_last_index return np.array(output) + def __str__(self): + repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the number of indices. \n" + repres += "Type : {} \n".format(self._type) + repres += "Order : {} \n".format(self._order) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Current iteration number (modulo the Number of indices) : {} \n".format(self._last_index) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres class SamplerRandom(): r""" @@ -359,13 +374,20 @@ def get_samples(self, num_samples=20): return np.array(output) + def __str__(self): + repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." + repres += "Type : {} \n".format(self._type) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres + class Sampler(): r""" This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. The idea of the factory is to simplify the creation of these instances with the static methods. Each factory method will instantiate a class to select from a list of indices `{0, 1, …, S-1}` - Common in each instatiated the class, the function `next()` outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. Each class also has a `get_samples(n)` function which will output the first `n` samples. + Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. Each class also has a `get_samples(n)` function which will output the first `n` samples. Parameters From aaa720085e346870d65a65c5c838678ec84ad961 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 30 Nov 2023 15:06:55 +0000 Subject: [PATCH 104/152] Documentation changes --- .../cil/optimisation/utilities/sampler.py | 71 +++++-------------- 1 file changed, 18 insertions(+), 53 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 7bbed4a076..714ba35b7d 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -236,19 +236,8 @@ def get_samples(self, num_samples=20): """ Returns the first `num_samples` as a numpy array. - Parameters - ---------- - num_samples: int, default=20 The number of samples to return. - - Example - ------- - - >>> sampler=Sampler.random_with_replacement(5) - >>> print(sampler.get_samples()) - [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] - """ save_last_index = self._last_index self._last_index = len(self._order)-1 @@ -360,12 +349,6 @@ def get_samples(self, num_samples=20): num_samples: int, default=20 The number of samples to return. - Example - ------- - >>> sampler=Sampler.random_with_replacement(5) - >>> print(sampler.get_samples()) - [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] - """ save_generator = self._generator self._generator = np.random.RandomState(self._seed) @@ -384,36 +367,14 @@ def __str__(self): class Sampler(): r""" - This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. The idea of the factory is to simplify the creation of these instances with the static methods. + This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. - Each factory method will instantiate a class to select from a list of indices `{0, 1, …, S-1}` - Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. Each class also has a `get_samples(n)` function which will output the first `n` samples. - - - Parameters - ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - - sampling_type:str - The sampling type used. Choose from "from_function", "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement", "random_without_replacement" and "from_function". - - order: list of indices - The list of indices the method selects from using next. - - prob: list of floats of length num_indices that sum to 1. - For random sampling with replacement, this is the probability for each index to be called by next. - - seed:int, default=None - Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. - - prob_weights: list of floats of length num_indices that sum to 1. - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. + + Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. Example ------- - >>> sampler=Sampler.sequential(10) >>> print(sampler.get_samples(5)) >>> for _ in range(11): @@ -466,7 +427,7 @@ class Sampler(): @staticmethod def sequential(num_indices): """ - Function that outputs a sampler that outputs sequentially. + Instantiates a sampler that outputs sequentially. Parameters ---------- @@ -549,8 +510,10 @@ def custom_order(num_indices, custom_list, prob_weights=None): @staticmethod def herman_meyer(num_indices): """ - Function that takes a number of indices and returns a sampler which outputs a Herman Meyer order - + Instantiates a sampler which outputs in a Herman Meyer order. + + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. @@ -621,8 +584,10 @@ def _herman_meyer_order(n): @staticmethod def staggered(num_indices, offset): """ - Function that takes a number of indices and returns a sampler which outputs in a staggered order. - + Instantiates a sampler which outputs in a staggered order. + + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -669,8 +634,10 @@ def staggered(num_indices, offset): @staticmethod def random_with_replacement(num_indices, prob=None, seed=None): """ - Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, with given probability and with replacement. + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -703,7 +670,7 @@ def random_with_replacement(num_indices, prob=None, seed=None): @staticmethod def random_without_replacement(num_indices, seed=None, prob=None): """ - Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, uniformly randomly without replacement. Parameters ---------- @@ -728,9 +695,7 @@ def random_without_replacement(num_indices, seed=None, prob=None): @staticmethod def from_function(num_indices, function, prob_weights=None): """ - A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. - The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. - + Instantiates a sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. Parameters ---------- From b9bb04d598e9f636f0fb59a746a84114f6d246af Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 30 Nov 2023 15:20:32 +0000 Subject: [PATCH 105/152] Documentation changes x2 --- .../cil/optimisation/algorithms/SPDHG.py | 28 +++++++++++-------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 51dc2107f0..d0c6804545 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -75,36 +75,36 @@ class SPDHG(Algorithm): >>> >>> detectors = ig.shape[0] >>> angles = np.linspace(0, np.pi, 90) - >>> ag = AcquisitionGeometry.create_Parallel2D().set_angles( - >>> angles, angle_unit='radian').set_panel(detectors, 0.1) + >>> ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles, angle_unit='radian').set_panel(detectors, 0.1) >>> >>> Aop = ProjectionOperator(ig, ag, 'cpu') >>> >>> sin = Aop.direct(data) >>> partitioned_data = sin.partition(subsets, 'sequential') - >>> A = BlockOperator( - *[ProjectionOperator(ig. partitioned_data[i].geometry, 'cpu') for i in range(subsets)]) + >>> A = BlockOperator(*[ProjectionOperator(ig. partitioned_data[i].geometry, 'cpu') for i in range(subsets)]) >>> >>> F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) for i in range(subsets)]) + >>> alpha = 0.025 - >>> G = alpha * FGP_TV() + >>> G = alpha * TotalVariation() >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.custom_order(len(A), [1,3,0,4,5,8,2,3,8,4,5]), initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) >>> spdhg.run(100) Example ------- - Further examples of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py + Further examples of usage see the [CIL demos.](https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py) Note ----- When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: + .. math:: + \sigma_i=0.99 / (\|K_i\|**2) - \sigma_i=0.99 / (\|K_i\|**2) and `tau` is set as per case 2 @@ -127,6 +127,7 @@ class SPDHG(Algorithm): Convergence is guaranteed provided that [2, eq. (12)]: .. math:: + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i References @@ -160,6 +161,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None, **deprecated_kwargs): '''set-up of the algorithm + Parameters ---------- f : BlockFunction @@ -325,22 +327,24 @@ def set_step_sizes(self, sigma=None, tau=None): Note ----- - There are 4 possible cases considered by this function: + When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - .. math:: + + .. math:: \sigma_i=0.99 / (\|K_i\|**2) - and `tau` is set as per case 2 + + and `tau` is set as per case 2 - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula - .. math:: + .. math:: \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula - .. math:: + .. math:: \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. From ef2542525d3b9e77eba45ed4211b12002a9e770a Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 5 Dec 2023 09:58:57 +0000 Subject: [PATCH 106/152] Moved custom order to an example of a function --- .../cil/optimisation/algorithms/SPDHG.py | 6 +- .../cil/optimisation/utilities/sampler.py | 343 ++++++++++-------- Wrappers/Python/test/test_algorithms.py | 8 - Wrappers/Python/test/test_sampler.py | 52 +-- 4 files changed, 198 insertions(+), 211 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index d0c6804545..92bf47a28f 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -88,7 +88,7 @@ class SPDHG(Algorithm): >>> alpha = 0.025 >>> G = alpha * TotalVariation() - >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.custom_order(len(A), [1,3,0,4,5,8,2,3,8,4,5]), + >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.sequential(len(A)), initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) >>> spdhg.run(100) @@ -198,8 +198,8 @@ def set_up(self, f, g, operator, sigma=None, tau=None, if self._sampler is None: self._sampler = Sampler.random_with_replacement(len(operator)) - if self._sampler.num_indices != len(operator): - raise ValueError('The `num_indices` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') + if self._sampler.max_index_number != len(operator): + raise ValueError('The `max_index_number` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') self.norms = operator.get_norms_as_list() diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 714ba35b7d..bac12289e8 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -26,19 +26,20 @@ class SamplerFromFunction(): A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. - It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(max_index_number, function, prob_weights) from cil.optimisation.utilities.sampler. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=max_index_number. + + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. sampling_type:str - The sampling type used. Choose from "from_function". + The sampling type used. This is set to the default "from_function". - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - - prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices + prob_weights: list of floats of length max_index_number that sum to 1. Default is [1/max_index_number]*max_index_number Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -51,7 +52,7 @@ class SamplerFromFunction(): >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) >>> - >>> Sampler.from_function(num_indices, function, prob_weights=None) + >>> Sampler.from_function(max_index_number, function, prob_weights=None) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -68,16 +69,56 @@ class SamplerFromFunction(): 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] + + Example + ------- + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] + >>> max_index_number=13 + >>> + >>> def test_function(iteration_number, custom_list=custom_list): + return(custom_list[iteration_number%len(custom_list)]) + >>> + >>> #calculate prob weights + >>> temp_list = [] + >>> for i in range(max_index_number): + >>> temp_list.append(custom_list.count(i)) + >>> total = sum(temp_list) + >>> prob_weights = [x/total for x in temp_list] + >>> + >>> sampler=Sampler.from_function(max_index_number=max_index_number, function=test_function, prob_weights=prob_weights) + >>> for _ in range(11): + >>> print(sampler.next()) + >>> print(list(sampler.get_samples(25))) + >>> print(sampler) + 1 + 1 + 1 + 0 + 0 + 11 + 5 + 9 + 8 + 3 + 1 + [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. + Type : from_function + Current iteration number : 11 + Max index number : 13 + Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] + + Note ----- - If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise + If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ - def __init__(self, num_indices, function, sampling_type='from_function', prob_weights=None): + def __init__(self, function, max_index_number, sampling_type='from_function', prob_weights=None): self._type = sampling_type - self._num_indices = num_indices + self._max_index_number = max_index_number self.function = function if abs(sum(prob_weights)-1) > 1e-6: @@ -95,8 +136,8 @@ def prob_weights(self): return self._prob_weights @property - def num_indices(self): - return self._num_indices + def max_index_number(self): + return self._max_index_number def next(self): @@ -124,16 +165,16 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. \n" repres += "Type : {} \n".format(self._type) repres += "Current iteration number : {} \n".format(self._iteration_number) - repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Max index number : {} \n".format(self._max_index_number) repres += "Probability weights : {} \n".format(self._prob_weights) return repres class SamplerFromOrder(): - def __init__(self, num_indices, order, sampling_type, prob_weights=None): + def __init__(self, order, max_index_number, sampling_type, prob_weights=None): """ This sampler will sample from a list `order` that is passed. @@ -141,39 +182,21 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - - sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", and "staggered" - order: list of indices The list of indices the method selects from using next. + + max_index_number: int + The elements in `order` should be chosen from {0, 1, …, S-1} with S=max_index_number. - prob_weights: list of floats of length num_indices that sum to 1. + sampling_type:str + The sampling type used. Choose from "sequential", "herman_meyer", and "staggered" + + prob_weights: list of floats of length max_index_number that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example ------- - - >>> sampler=Sampler.custom_order(12,[1,4,6,7,8,9,11]) - >>> print(sampler.get_samples(11)) - >>> for _ in range(9): - >>> print(sampler.next()) - >>> print(sampler.get_samples(5)) - - [ 1 4 6 7 8 9 11 1 4 6 7] - 1 - 4 - 6 - 7 - 8 - 9 - 11 - 1 - 4 - [1 4 6 7 8] - + >>> sampler=Sampler.staggered(21,4) >>> print(sampler.get_samples(5)) @@ -199,28 +222,33 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): 14 [ 0 4 8 12 16] """ + + + if prob_weights is None: + prob_weights= max_index_number*[1/max_index_number] + if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') if any(np.array(prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') - + + self._prob_weights = prob_weights self._type = sampling_type - self._num_indices = num_indices + self._max_index_number = max_index_number self._order = order self._last_index = len(order)-1 - @property def prob_weights(self): return self._prob_weights @property - def num_indices(self): - return self._num_indices + def max_index_number(self): + return self._max_index_number def next(self): @@ -246,25 +274,25 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the number of indices. \n" + repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the max index number. \n" repres += "Type : {} \n".format(self._type) repres += "Order : {} \n".format(self._order) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Current iteration number (modulo the Number of indices) : {} \n".format(self._last_index) + repres += "Max index number : {} \n".format(self._max_index_number) + repres += "Current iteration number (modulo the max index number) : {} \n".format(self._last_index) repres += "Probability weights : {} \n".format(self._prob_weights) return repres class SamplerRandom(): r""" A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. - The function next() outputs a single next index from the list {0,1,…,S-1} . To be run again and again, depending on how many iterations. + The function next() outputs a single next index from the list {0,1,…,S-1} . It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. sampling_type:str The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" @@ -272,13 +300,13 @@ class SamplerRandom(): replace= bool If True, sample with replace, otherwise sample without replacement - prob: list of floats of length num_indices that sum to 1. + prob: list of floats of length max_index_number that sum to 1. For random sampling with replacement, this is the probability for each index to be called by next. seed:int, default=None Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. - prob_weights: list of floats of length num_indices that sum to 1. + prob_weights: list of floats of length max_index_number that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -296,18 +324,18 @@ class SamplerRandom(): [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] """ - def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): + def __init__(self, max_index_number, replace, sampling_type, prob=None, seed=None): self._replace = replace self._prob = prob if prob is None: - self._prob = [1/num_indices]*num_indices + self._prob = [1/max_index_number]*max_index_number if replace: self._prob_weights = self._prob else: - self._prob_weights = [1/num_indices]*num_indices + self._prob_weights = [1/max_index_number]*max_index_number if abs(sum(self._prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') @@ -317,7 +345,7 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): 'The provided prob_weights must be greater than or equal to zero') self._type = sampling_type - self._num_indices = num_indices + self._max_index_number = max_index_number if seed is not None: self._seed = seed @@ -331,13 +359,13 @@ def prob_weights(self): return self._prob_weights @property - def num_indices(self): - return self._num_indices + def max_index_number(self): + return self._max_index_number def next(self): """ Returns and increments the sampler """ - return int(self._generator.choice(self._num_indices, 1, p=self._prob, replace=self._replace)) + return int(self._generator.choice(self._max_index_number, 1, p=self._prob, replace=self._replace)) def __next__(self): return self.next() @@ -358,18 +386,18 @@ def get_samples(self, num_samples=20): def __str__(self): - repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." + repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the max index number." repres += "Type : {} \n".format(self._type) - repres += "Number of indices : {} \n".format(self._num_indices) + repres += "max index number : {} \n".format(self._max_index_number) repres += "Probability weights : {} \n".format(self._prob_weights) return repres class Sampler(): r""" - This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. + This class follows the factory design pattern. It is not instantiated but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. - Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the max index number.`. Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. @@ -417,22 +445,22 @@ class Sampler(): The optimal choice of sampler depends on the data and the number of calls to the sampler. For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of - iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_indices`. + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `max_index_number`. For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. - In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider - another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. + In general, we note that for a large number of samples (e.g. `>20*max_index_number`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*max_index_number`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `max_index_number` samples is guaranteed to draw each index exactly once. """ @staticmethod - def sequential(num_indices): + def sequential(max_index_number): """ Instantiates a sampler that outputs sequentially. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. Example ------- @@ -454,68 +482,22 @@ def sequential(num_indices): 9 0 """ - order = list(range(num_indices)) - sampler = SamplerFromOrder(num_indices, sampling_type='sequential', order=order, prob_weights=[ - 1/num_indices]*num_indices) + order = list(range(max_index_number)) + sampler = SamplerFromOrder(max_index_number=max_index_number, sampling_type='sequential', order=order, prob_weights=[ + 1/max_index_number]*max_index_number) return sampler - @staticmethod - def custom_order(num_indices, custom_list, prob_weights=None): - """ - Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. - - Parameters - ---------- - num_indices: `int` - The sampler will select indices for `{1,....,n}` according to the order in `custom_list` where `n` is `num_indices`. - custom_list: `list` of `int` - The list that will be sampled from in order. - - prob_weights: list of floats of length num_indices that sum to 1. Default is None and the prob_weights are calculated automatically. - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - Example - -------- - - >>> sampler=Sampler.custom_order(12,[1,4,6,7,8,9,11]) - >>> print(sampler.get_samples(11)) - >>> for _ in range(9): - >>> print(sampler.next()) - >>> print(sampler.get_samples(5)) - [ 1 4 6 7 8 9 11 1 4 6 7] - 1 - 4 - 6 - 7 - 8 - 9 - 11 - 1 - 4 - [1 4 6 7 8] - - """ - - if prob_weights is None: - temp_list = [] - for i in range(num_indices): - temp_list.append(custom_list.count(i)) - total = sum(temp_list) - prob_weights = [x/total for x in temp_list] - - sampler = SamplerFromOrder( - num_indices, sampling_type='custom_order', order=custom_list, prob_weights=prob_weights) - return sampler + @staticmethod - def herman_meyer(num_indices): + def herman_meyer(max_index_number): """ Instantiates a sampler which outputs in a Herman Meyer order. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. For Herman-Meyer sampling this number should not be prime. Reference ---------- @@ -548,7 +530,7 @@ def _herman_meyer_order(n): if n_factors == 0: raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') + 'Herman Meyer sampling defaults to sequential ordering if the max index number is prime. Please use an alternative sampling method or change the max index number. ') order = [0 for _ in range(n)] value = 0 @@ -576,24 +558,24 @@ def _herman_meyer_order(n): math.prod(factors[factor_n+1:]) * mapping return order - order = _herman_meyer_order(num_indices) + order = _herman_meyer_order(max_index_number) sampler = SamplerFromOrder( - num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) + max_index_number=max_index_number, sampling_type='herman_meyer', order=order, prob_weights=[1/max_index_number]*max_index_number) return sampler @staticmethod - def staggered(num_indices, offset): + def staggered(max_index_number, offset): """ Instantiates a sampler which outputs in a staggered order. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - The offset should be less than the num_indices + The offset should be less than the max_index_number Example ------- @@ -621,27 +603,27 @@ def staggered(num_indices, offset): [ 0 4 8 12 16] """ - if offset >= num_indices: - raise (ValueError('The offset should be less than the number of indices')) + if offset >= max_index_number: + raise (ValueError('The offset should be less than the max index number')) - indices = list(range(num_indices)) + indices = list(range(max_index_number)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = SamplerFromOrder(num_indices, sampling_type='staggered', order=order, prob_weights=[ - 1/num_indices]*num_indices) + sampler = SamplerFromOrder(max_index_number=max_index_number, sampling_type='staggered', order=order, prob_weights=[ + 1/max_index_number]*max_index_number) return sampler @staticmethod - def random_with_replacement(num_indices, prob=None, seed=None): + def random_with_replacement(max_index_number, prob=None, seed=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, with given probability and with replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=max_index_number, with given probability and with replacement. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. - prob: list of floats of length num_indices that sum to 1. default=None + prob: list of floats of length max_index_number that sum to 1. default=None This is the probability for each index to be called by next. If None, then the indices will be sampled uniformly. seed:int, default=None @@ -661,21 +643,21 @@ def random_with_replacement(num_indices, prob=None, seed=None): """ if prob == None: - prob = [1/num_indices] * num_indices + prob = [1/max_index_number] * max_index_number sampler = SamplerRandom( - num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) + max_index_number=max_index_number, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @staticmethod - def random_without_replacement(num_indices, seed=None, prob=None): + def random_without_replacement(max_index_number, seed=None, prob=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, uniformly randomly without replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=max_index_number, uniformly randomly without replacement. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. @@ -689,25 +671,22 @@ def random_without_replacement(num_indices, seed=None, prob=None): """ sampler = SamplerRandom( - num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) + max_index_number=max_index_number, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) return sampler @staticmethod - def from_function(num_indices, function, prob_weights=None): + def from_function(max_index_number, function, prob_weights=None): """ Instantiates a sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - - sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=max_index_number. - prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices + prob_weights: list of floats of length max_index_number that sum to 1. Default is [1/max_index_number]*max_index_number Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. @@ -743,11 +722,55 @@ def from_function(num_indices, function, prob_weights=None): 28 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - + + Example + ------- + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] + >>> max_index_number=13 + >>> + >>> def test_function(iteration_number, custom_list=custom_list): + return(custom_list[iteration_number%len(custom_list)]) + >>> + >>> #calculate prob weights + >>> temp_list = [] + >>> for i in range(max_index_number): + >>> temp_list.append(custom_list.count(i)) + >>> total = sum(temp_list) + >>> prob_weights = [x/total for x in temp_list] + >>> + >>> sampler=Sampler.from_function(max_index_number=max_index_number, function=test_function, prob_weights=prob_weights) + >>> for _ in range(11): + >>> print(sampler.next()) + >>> print(list(sampler.get_samples(25))) + >>> print(sampler) + 1 + 1 + 1 + 0 + 0 + 11 + 5 + 9 + 8 + 3 + 1 + [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. + Type : from_function + Current iteration number : 11 + Max index number : 13 + Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] + + + Note + ----- + If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise + the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ + if prob_weights is None: - prob_weights = [1/num_indices]*num_indices + prob_weights = [1/max_index_number]*max_index_number sampler = SamplerFromFunction( - num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) + max_index_number=max_index_number, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 8b72a4084a..32a658bead 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -859,14 +859,6 @@ def test_spdhg_deprecated_vargs(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, norms=[ 1]*len(self.A), sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) - def test_spdhg_custom_sampler(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A), [0, 0, 0, 0]), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - self.assertListEqual(spdhg.prob_weights, [1]+[0]*(len(self.A)-1)) - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A), [0, 1, 0, 1]), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - self.assertListEqual(spdhg.prob_weights, - [.5]+[.5]+[0]*(len(self.A)-2)) def test_spdhg_set_norms(self): diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index d7723de957..84eb912688 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -42,27 +42,27 @@ def example_function(self, iteration_number): def test_init(self): sampler = Sampler.sequential(10) - self.assertEqual(sampler.num_indices, 10) + self.assertEqual(sampler.max_index_number, 10) self.assertEqual(sampler._type, 'sequential') self.assertListEqual(sampler._order, list(range(10))) self.assertEqual(sampler._last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) sampler = Sampler.random_without_replacement(7) - self.assertEqual(sampler.num_indices, 7) + self.assertEqual(sampler.max_index_number, 7) self.assertEqual(sampler._type, 'random_without_replacement') self.assertEqual(sampler._prob, [1/7]*7) self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.random_without_replacement(8, seed=1) - self.assertEqual(sampler.num_indices, 8) + self.assertEqual(sampler.max_index_number, 8) self.assertEqual(sampler._type, 'random_without_replacement') self.assertEqual(sampler._prob, [1/8]*8) self.assertEqual(sampler._seed, 1) self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.herman_meyer(12) - self.assertEqual(sampler.num_indices, 12) + self.assertEqual(sampler.max_index_number, 12) self.assertEqual(sampler._type, 'herman_meyer') self.assertEqual(sampler._last_index, 11) self.assertListEqual( @@ -70,19 +70,19 @@ def test_init(self): self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) - self.assertEqual(sampler.num_indices, 5) + self.assertEqual(sampler.max_index_number, 5) self.assertEqual(sampler._type, 'random_with_replacement') self.assertListEqual(sampler._prob, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.num_indices, 4) + self.assertEqual(sampler.max_index_number, 4) self.assertEqual(sampler._type, 'random_with_replacement') self.assertListEqual(sampler._prob, [0.7, 0.1, 0.1, 0.1]) self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) - self.assertEqual(sampler.num_indices, 21) + self.assertEqual(sampler.max_index_number, 21) self.assertEqual(sampler._type, 'staggered') self.assertListEqual(sampler._order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) @@ -92,41 +92,22 @@ def test_init(self): with self.assertRaises(ValueError): Sampler.staggered(22, 25) - - sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.num_indices, 12) - self.assertEqual(sampler._type, 'custom_order') - self.assertListEqual(sampler._order, [1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler._last_index, 6) - self.assertListEqual(sampler.prob_weights, [ - 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) - - sampler = Sampler.custom_order(10, [0,1, 2, 3, 4]) - self.assertEqual(sampler.num_indices, 10) - self.assertEqual(sampler._type, 'custom_order') - self.assertListEqual(sampler._order, [0,1,2,3,4]) - self.assertEqual(sampler._last_index, 4) - self.assertListEqual(sampler.prob_weights, [ - 1/5,1/5,1/5,1/5,1/5,0,0,0,0,0]) - - sampler = Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[1/10]*10) - self.assertListEqual(sampler.prob_weights, [1/10]*10) #Check probabilities sum to one and are positive with self.assertRaises(ValueError): - Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[1/11]*10) + Sampler.from_function(10, self.example_function, prob_weights=[1/11]*10) with self.assertRaises(ValueError): - Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[-1]+[2]+[0]*8) + Sampler.from_function(10, self.example_function, prob_weights=[-1]+[2]+[0]*8) sampler = Sampler.from_function(50, self.example_function) self.assertListEqual(sampler.prob_weights, [1/50] * 50) - self.assertEqual(sampler.num_indices, 50) + self.assertEqual(sampler.max_index_number, 50) self.assertEqual(sampler._type, 'from_function') sampler = Sampler.from_function(40, self.example_function, [1]+[0]*39) self.assertListEqual(sampler.prob_weights, [1]+[0]*39) - self.assertEqual(sampler.num_indices, 40) + self.assertEqual(sampler.max_index_number, 40) self.assertEqual(sampler._type, 'from_function') #check probabilities sum to 1 and are positive @@ -217,13 +198,4 @@ def test_staggered_iterator_and_get_samples(self): self.assertNumpyArrayEqual( sampler.get_samples(10), np.array(order[:10])) - def test_custom_order_iterator_and_get_samples(self): - # Test the custom order sampler - sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) - order = [1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, - 11, 1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11] - for i in range(25): - self.assertEqual(sampler.next(), order[i % 7]) - if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual( - sampler.get_samples(10), np.array(order[:10])) + From 0948e39943f9b2f381ea9fecc9609f6583ef60e9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 5 Dec 2023 15:52:33 +0000 Subject: [PATCH 107/152] Back to num_indices and more explanation for custom function examples --- .../cil/optimisation/algorithms/SPDHG.py | 4 +- .../cil/optimisation/utilities/sampler.py | 203 +++++++++--------- Wrappers/Python/test/test_sampler.py | 18 +- 3 files changed, 115 insertions(+), 110 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 92bf47a28f..8ddd2ec0e6 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -198,8 +198,8 @@ def set_up(self, f, g, operator, sigma=None, tau=None, if self._sampler is None: self._sampler = Sampler.random_with_replacement(len(operator)) - if self._sampler.max_index_number != len(operator): - raise ValueError('The `max_index_number` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') + if self._sampler.num_indices != len(operator): + raise ValueError('The `num_indices` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') self.norms = operator.get_norms_as_list() diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index bac12289e8..24651388e8 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -26,24 +26,26 @@ class SamplerFromFunction(): A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. - It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(max_index_number, function, prob_weights) from cil.optimisation.utilities.sampler. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. Parameters ---------- - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=max_index_number. + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str The sampling type used. This is set to the default "from_function". - prob_weights: list of floats of length max_index_number that sum to 1. Default is [1/max_index_number]*max_index_number + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example ------- + This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. + For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. >>> def test_function(iteration_number): >>> if iteration_number<500: >>> np.random.seed(iteration_number) @@ -52,7 +54,7 @@ class SamplerFromFunction(): >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) >>> - >>> Sampler.from_function(max_index_number, function, prob_weights=None) + >>> Sampler.from_function(num_indices, function, prob_weights=None) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -72,20 +74,23 @@ class SamplerFromFunction(): Example ------- + This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. + The probability weights are calculated and passed to the sampler as they are not uniform. + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] - >>> max_index_number=13 + >>> num_indices=13 >>> >>> def test_function(iteration_number, custom_list=custom_list): return(custom_list[iteration_number%len(custom_list)]) >>> >>> #calculate prob weights >>> temp_list = [] - >>> for i in range(max_index_number): + >>> for i in range(num_indices): >>> temp_list.append(custom_list.count(i)) >>> total = sum(temp_list) >>> prob_weights = [x/total for x in temp_list] >>> - >>> sampler=Sampler.from_function(max_index_number=max_index_number, function=test_function, prob_weights=prob_weights) + >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -102,10 +107,10 @@ class SamplerFromFunction(): 3 1 [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] - Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. Type : from_function Current iteration number : 11 - Max index number : 13 + number of indices : 13 Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] @@ -115,10 +120,10 @@ class SamplerFromFunction(): the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ - def __init__(self, function, max_index_number, sampling_type='from_function', prob_weights=None): + def __init__(self, function, num_indices, sampling_type='from_function', prob_weights=None): self._type = sampling_type - self._max_index_number = max_index_number + self._num_indices = num_indices self.function = function if abs(sum(prob_weights)-1) > 1e-6: @@ -136,8 +141,8 @@ def prob_weights(self): return self._prob_weights @property - def max_index_number(self): - return self._max_index_number + def num_indices(self): + return self._num_indices def next(self): @@ -165,16 +170,16 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. \n" + repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" repres += "Type : {} \n".format(self._type) repres += "Current iteration number : {} \n".format(self._iteration_number) - repres += "Max index number : {} \n".format(self._max_index_number) + repres += "Number of indices : {} \n".format(self._num_indices) repres += "Probability weights : {} \n".format(self._prob_weights) return repres class SamplerFromOrder(): - def __init__(self, order, max_index_number, sampling_type, prob_weights=None): + def __init__(self, order, num_indices, sampling_type, prob_weights=None): """ This sampler will sample from a list `order` that is passed. @@ -185,13 +190,13 @@ def __init__(self, order, max_index_number, sampling_type, prob_weights=None): order: list of indices The list of indices the method selects from using next. - max_index_number: int - The elements in `order` should be chosen from {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The elements in `order` should be chosen from {0, 1, …, S-1} with S=num_indices. sampling_type:str The sampling type used. Choose from "sequential", "herman_meyer", and "staggered" - prob_weights: list of floats of length max_index_number that sum to 1. + prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -225,7 +230,7 @@ def __init__(self, order, max_index_number, sampling_type, prob_weights=None): if prob_weights is None: - prob_weights= max_index_number*[1/max_index_number] + prob_weights= num_indices*[1/num_indices] if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') @@ -237,7 +242,7 @@ def __init__(self, order, max_index_number, sampling_type, prob_weights=None): self._prob_weights = prob_weights self._type = sampling_type - self._max_index_number = max_index_number + self._num_indices = num_indices self._order = order self._last_index = len(order)-1 @@ -247,8 +252,8 @@ def prob_weights(self): return self._prob_weights @property - def max_index_number(self): - return self._max_index_number + def num_indices(self): + return self._num_indices def next(self): @@ -274,11 +279,11 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the max index number. \n" + repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the number of indices. \n" repres += "Type : {} \n".format(self._type) repres += "Order : {} \n".format(self._order) - repres += "Max index number : {} \n".format(self._max_index_number) - repres += "Current iteration number (modulo the max index number) : {} \n".format(self._last_index) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Current iteration number (modulo the number of indices) : {} \n".format(self._last_index) repres += "Probability weights : {} \n".format(self._prob_weights) return repres @@ -291,8 +296,8 @@ class SamplerRandom(): Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" @@ -300,13 +305,13 @@ class SamplerRandom(): replace= bool If True, sample with replace, otherwise sample without replacement - prob: list of floats of length max_index_number that sum to 1. + prob: list of floats of length num_indices that sum to 1. For random sampling with replacement, this is the probability for each index to be called by next. seed:int, default=None Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. - prob_weights: list of floats of length max_index_number that sum to 1. + prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -324,18 +329,18 @@ class SamplerRandom(): [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] """ - def __init__(self, max_index_number, replace, sampling_type, prob=None, seed=None): + def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): self._replace = replace self._prob = prob if prob is None: - self._prob = [1/max_index_number]*max_index_number + self._prob = [1/num_indices]*num_indices if replace: self._prob_weights = self._prob else: - self._prob_weights = [1/max_index_number]*max_index_number + self._prob_weights = [1/num_indices]*num_indices if abs(sum(self._prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') @@ -345,7 +350,7 @@ def __init__(self, max_index_number, replace, sampling_type, prob=None, seed=N 'The provided prob_weights must be greater than or equal to zero') self._type = sampling_type - self._max_index_number = max_index_number + self._num_indices = num_indices if seed is not None: self._seed = seed @@ -359,13 +364,13 @@ def prob_weights(self): return self._prob_weights @property - def max_index_number(self): - return self._max_index_number + def num_indices(self): + return self._num_indices def next(self): """ Returns and increments the sampler """ - return int(self._generator.choice(self._max_index_number, 1, p=self._prob, replace=self._replace)) + return int(self._generator.choice(self._num_indices, 1, p=self._prob, replace=self._replace)) def __next__(self): return self.next() @@ -386,9 +391,9 @@ def get_samples(self, num_samples=20): def __str__(self): - repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the max index number." + repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." repres += "Type : {} \n".format(self._type) - repres += "max index number : {} \n".format(self._max_index_number) + repres += "Number of indices : {} \n".format(self._num_indices) repres += "Probability weights : {} \n".format(self._prob_weights) return repres @@ -397,7 +402,7 @@ class Sampler(): r""" This class follows the factory design pattern. It is not instantiated but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. - Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the max index number.`. + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. @@ -445,22 +450,22 @@ class Sampler(): The optimal choice of sampler depends on the data and the number of calls to the sampler. For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of - iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `max_index_number`. + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_indices`. For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. - In general, we note that for a large number of samples (e.g. `>20*max_index_number`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*max_index_number`) the user may wish to consider - another sampling method e.g. random without replacement, which, when calling `max_index_number` samples is guaranteed to draw each index exactly once. + In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ @staticmethod - def sequential(max_index_number): + def sequential(num_indices): """ Instantiates a sampler that outputs sequentially. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. Example ------- @@ -482,22 +487,22 @@ def sequential(max_index_number): 9 0 """ - order = list(range(max_index_number)) - sampler = SamplerFromOrder(max_index_number=max_index_number, sampling_type='sequential', order=order, prob_weights=[ - 1/max_index_number]*max_index_number) + order = list(range(num_indices)) + sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='sequential', order=order, prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod - def herman_meyer(max_index_number): + def herman_meyer(num_indices): """ Instantiates a sampler which outputs in a Herman Meyer order. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. For Herman-Meyer sampling this number should not be prime. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. Reference ---------- @@ -530,7 +535,7 @@ def _herman_meyer_order(n): if n_factors == 0: raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the max index number is prime. Please use an alternative sampling method or change the max index number. ') + 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') order = [0 for _ in range(n)] value = 0 @@ -558,24 +563,24 @@ def _herman_meyer_order(n): math.prod(factors[factor_n+1:]) * mapping return order - order = _herman_meyer_order(max_index_number) + order = _herman_meyer_order(num_indices) sampler = SamplerFromOrder( - max_index_number=max_index_number, sampling_type='herman_meyer', order=order, prob_weights=[1/max_index_number]*max_index_number) + num_indices=num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod - def staggered(max_index_number, offset): + def staggered(num_indices, offset): """ Instantiates a sampler which outputs in a staggered order. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - The offset should be less than the max_index_number + The offset should be less than the num_indices Example ------- @@ -603,27 +608,27 @@ def staggered(max_index_number, offset): [ 0 4 8 12 16] """ - if offset >= max_index_number: - raise (ValueError('The offset should be less than the max index number')) + if offset >= num_indices: + raise (ValueError('The offset should be less than the number of indices')) - indices = list(range(max_index_number)) + indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = SamplerFromOrder(max_index_number=max_index_number, sampling_type='staggered', order=order, prob_weights=[ - 1/max_index_number]*max_index_number) + sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='staggered', order=order, prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod - def random_with_replacement(max_index_number, prob=None, seed=None): + def random_with_replacement(num_indices, prob=None, seed=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=max_index_number, with given probability and with replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, with given probability and with replacement. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - prob: list of floats of length max_index_number that sum to 1. default=None + prob: list of floats of length num_indices that sum to 1. default=None This is the probability for each index to be called by next. If None, then the indices will be sampled uniformly. seed:int, default=None @@ -643,21 +648,21 @@ def random_with_replacement(max_index_number, prob=None, seed=None): """ if prob == None: - prob = [1/max_index_number] * max_index_number + prob = [1/num_indices] * num_indices sampler = SamplerRandom( - max_index_number=max_index_number, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) + num_indices=num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @staticmethod - def random_without_replacement(max_index_number, seed=None, prob=None): + def random_without_replacement(num_indices, seed=None, prob=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=max_index_number, uniformly randomly without replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, uniformly randomly without replacement. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. @@ -671,22 +676,22 @@ def random_without_replacement(max_index_number, seed=None, prob=None): """ sampler = SamplerRandom( - max_index_number=max_index_number, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) + num_indices=num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) return sampler @staticmethod - def from_function(max_index_number, function, prob_weights=None): + def from_function(num_indices, function, prob_weights=None): """ Instantiates a sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=max_index_number. + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - prob_weights: list of floats of length max_index_number that sum to 1. Default is [1/max_index_number]*max_index_number + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. @@ -697,6 +702,8 @@ def from_function(max_index_number, function, prob_weights=None): Example ------- + This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. + For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. >>> def test_function(iteration_number): >>> if iteration_number<500: >>> np.random.seed(iteration_number) @@ -704,9 +711,8 @@ def from_function(max_index_number, function, prob_weights=None): >>> else: >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) - - - >>> sampler=Sampler.from_function(50, test_function) + >>> + >>> Sampler.from_function(num_indices, function, prob_weights=None) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -722,23 +728,27 @@ def from_function(max_index_number, function, prob_weights=None): 28 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - + + Example ------- + This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. + The probability weights are calculated and passed to the sampler as they are not uniform. + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] - >>> max_index_number=13 + >>> num_indices=13 >>> >>> def test_function(iteration_number, custom_list=custom_list): return(custom_list[iteration_number%len(custom_list)]) >>> >>> #calculate prob weights >>> temp_list = [] - >>> for i in range(max_index_number): + >>> for i in range(num_indices): >>> temp_list.append(custom_list.count(i)) >>> total = sum(temp_list) >>> prob_weights = [x/total for x in temp_list] >>> - >>> sampler=Sampler.from_function(max_index_number=max_index_number, function=test_function, prob_weights=prob_weights) + >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -755,22 +765,17 @@ def from_function(max_index_number, function, prob_weights=None): 3 1 [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] - Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. Type : from_function Current iteration number : 11 - Max index number : 13 + number of indices : 13 Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] - - Note - ----- - If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise - the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ if prob_weights is None: - prob_weights = [1/max_index_number]*max_index_number + prob_weights = [1/num_indices]*num_indices sampler = SamplerFromFunction( - max_index_number=max_index_number, sampling_type='from_function', function=function, prob_weights=prob_weights) + num_indices=num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 84eb912688..0c16f7420e 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -42,27 +42,27 @@ def example_function(self, iteration_number): def test_init(self): sampler = Sampler.sequential(10) - self.assertEqual(sampler.max_index_number, 10) + self.assertEqual(sampler.num_indices, 10) self.assertEqual(sampler._type, 'sequential') self.assertListEqual(sampler._order, list(range(10))) self.assertEqual(sampler._last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) sampler = Sampler.random_without_replacement(7) - self.assertEqual(sampler.max_index_number, 7) + self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler._type, 'random_without_replacement') self.assertEqual(sampler._prob, [1/7]*7) self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.random_without_replacement(8, seed=1) - self.assertEqual(sampler.max_index_number, 8) + self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler._type, 'random_without_replacement') self.assertEqual(sampler._prob, [1/8]*8) self.assertEqual(sampler._seed, 1) self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.herman_meyer(12) - self.assertEqual(sampler.max_index_number, 12) + self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler._type, 'herman_meyer') self.assertEqual(sampler._last_index, 11) self.assertListEqual( @@ -70,19 +70,19 @@ def test_init(self): self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) - self.assertEqual(sampler.max_index_number, 5) + self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler._type, 'random_with_replacement') self.assertListEqual(sampler._prob, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.max_index_number, 4) + self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler._type, 'random_with_replacement') self.assertListEqual(sampler._prob, [0.7, 0.1, 0.1, 0.1]) self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) - self.assertEqual(sampler.max_index_number, 21) + self.assertEqual(sampler.num_indices, 21) self.assertEqual(sampler._type, 'staggered') self.assertListEqual(sampler._order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) @@ -102,12 +102,12 @@ def test_init(self): sampler = Sampler.from_function(50, self.example_function) self.assertListEqual(sampler.prob_weights, [1/50] * 50) - self.assertEqual(sampler.max_index_number, 50) + self.assertEqual(sampler.num_indices, 50) self.assertEqual(sampler._type, 'from_function') sampler = Sampler.from_function(40, self.example_function, [1]+[0]*39) self.assertListEqual(sampler.prob_weights, [1]+[0]*39) - self.assertEqual(sampler.max_index_number, 40) + self.assertEqual(sampler.num_indices, 40) self.assertEqual(sampler._type, 'from_function') #check probabilities sum to 1 and are positive From 5804f7d91f33c2b51747e9d93c3367a25ab01f75 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 7 Dec 2023 17:08:42 +0000 Subject: [PATCH 108/152] Updates from chat with Gemma --- .../cil/optimisation/utilities/sampler.py | 279 ++++++------------ 1 file changed, 88 insertions(+), 191 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 24651388e8..60eb994e4c 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -42,6 +42,10 @@ class SamplerFromFunction(): prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + Returns + ------- + A Sampler wrapping a function that can be called with Sampler.next() or next(Sampler) + Example ------- This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. @@ -55,20 +59,7 @@ class SamplerFromFunction(): >>> return(np.random.choice(50,1)[0]) >>> >>> Sampler.from_function(num_indices, function, prob_weights=None) - >>> for _ in range(11): - >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) - 44 - 37 - 40 - 42 - 46 - 35 - 10 - 47 - 3 - 28 - 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] @@ -91,22 +82,9 @@ class SamplerFromFunction(): >>> prob_weights = [x/total for x in temp_list] >>> >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) - >>> for _ in range(11): - >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) - >>> print(sampler) - 1 - 1 - 1 - 0 - 0 - 11 - 5 - 9 - 8 - 3 - 1 [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + >>> print(sampler) Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. Type : from_function Current iteration number : 11 @@ -144,6 +122,12 @@ def prob_weights(self): def num_indices(self): return self._num_indices + @property + def current_iter_number(self): + return self._iteration_number + + + def next(self): """ @@ -198,33 +182,15 @@ def __init__(self, order, num_indices, sampling_type, prob_weights=None): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - Example + + Returns ------- - + A Sampler outputting in order from an list that can be called with Sampler.next() or next(Sampler) + Example + ------- >>> sampler=Sampler.staggered(21,4) >>> print(sampler.get_samples(5)) - >>> for _ in range(15): - >>> print(sampler.next()) - >>> print(sampler.get_samples(5)) - - [ 0 4 8 12 16] - 0 - 4 - 8 - 12 - 16 - 20 - 1 - 5 - 9 - 13 - 17 - 2 - 6 - 10 - 14 [ 0 4 8 12 16] """ @@ -255,6 +221,11 @@ def prob_weights(self): def num_indices(self): return self._num_indices + @property + def current_index_number(self): + return self._iteration_number + + def next(self): """Returns and increments the sampler """ @@ -283,7 +254,7 @@ def __str__(self): repres += "Type : {} \n".format(self._type) repres += "Order : {} \n".format(self._order) repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Current iteration number (modulo the number of indices) : {} \n".format(self._last_index) + repres += "Current index number : {} \n".format(self._last_index) repres += "Probability weights : {} \n".format(self._prob_weights) return repres @@ -314,6 +285,11 @@ class SamplerRandom(): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + Returns + ------- + A Sampler wrapping numpy.random.choice that can be called with Sampler.next() or next(Sampler) + Example ------- >>> sampler=Sampler.random_with_replacement(5) @@ -410,39 +386,13 @@ class Sampler(): ------- >>> sampler=Sampler.sequential(10) >>> print(sampler.get_samples(5)) - >>> for _ in range(11): - print(sampler.next()) [0 1 2 3 4] - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 0 + Example ------- >>> sampler=Sampler.random_with_replacement(5) - >>> for _ in range(12): - >>> print(next(sampler)) >>> print(sampler.get_samples()) - 3 - 4 - 0 - 0 - 2 - 3 - 3 - 2 - 2 - 1 - 1 - 4 [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] Note @@ -466,26 +416,16 @@ def sequential(num_indices): ---------- num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) and outputs sequentially + Example ------- >>> sampler=Sampler.sequential(10) >>> print(sampler.get_samples(5)) - >>> for _ in range(11): - print(sampler.next()) [0 1 2 3 4] - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 0 """ order = list(range(num_indices)) sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='sequential', order=order, prob_weights=[ @@ -507,63 +447,52 @@ def herman_meyer(num_indices): Reference ---------- Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. - + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a Herman Meyer ordering + Example ------- >>> sampler=Sampler.herman_meyer(12) >>> print(sampler.get_samples(16)) [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] - """ - def _herman_meyer_order(n): - # Assuming that the indices are in geometrical order - n_variable = n - i = 2 - factors = [] - while i * i <= n_variable: - if n_variable % i: - i += 1 - else: - n_variable //= i - factors.append(i) - - if n_variable > 1: - factors.append(n_variable) - - n_factors = len(factors) - - if n_factors == 0: - raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') - - order = [0 for _ in range(n)] - value = 0 - - for factor_n in range(n_factors): - n_rep_value = 0 - - if factor_n == 0: - n_change_value = 1 - else: - n_change_value = math.prod(factors[:factor_n]) - - for element in range(n): - mapping = value - n_rep_value += 1 - - if n_rep_value >= n_change_value: - value = value + 1 - n_rep_value = 0 - - if value == factors[factor_n]: - value = 0 + + n_variable = num_indices + i = 2 + factors = [] + + #Prime factorisation + while i * i <= n_variable: + if n_variable % i: + i += 1 + else: + n_variable //= i + factors.append(i) + if n_variable > 1: + factors.append(n_variable) + + n_factors = len(factors) + + if n_factors == 1: + raise ValueError( + 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') + + #Build the sampling order + order = np.zeros(num_indices, dtype=np.int8) + for factor_n in range(n_factors): + if factor_n == 0: + block_length= 1 + else: + block_length= math.prod(factors[:factor_n]) + + addition=np.tile(np.repeat( math.prod(factors[factor_n+1:])*range(num_indices//(addition*block_length)), block_length), addition) + order += addition + order=list(order) - order[element] = order[element] + \ - math.prod(factors[factor_n+1:]) * mapping - return order - order = _herman_meyer_order(num_indices) sampler = SamplerFromOrder( num_indices=num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @@ -581,30 +510,15 @@ def staggered(num_indices, offset): offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. The offset should be less than the num_indices - + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a staggered ordering + Example ------- >>> sampler=Sampler.staggered(21,4) >>> print(sampler.get_samples(5)) - >>> for _ in range(15): - >>> print(sampler.next()) - >>> print(sampler.get_samples(5)) - [ 0 4 8 12 16] - 0 - 4 - 8 - 12 - 16 - 20 - 1 - 5 - 9 - 13 - 17 - 2 - 6 - 10 - 14 [ 0 4 8 12 16] """ @@ -633,7 +547,11 @@ def random_with_replacement(num_indices, prob=None, seed=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) that samples randomly with replacement + Example ------- @@ -666,7 +584,10 @@ def random_without_replacement(num_indices, seed=None, prob=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) that samples randomly without replacement Example ------- >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) @@ -699,8 +620,10 @@ def from_function(num_indices, function, prob_weights=None): ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. - - Example + + Returns + ------- + A Sampler that wraps a function and can be called with Sampler.next() or next(Sampler) ------- This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. @@ -713,20 +636,7 @@ def from_function(num_indices, function, prob_weights=None): >>> return(np.random.choice(50,1)[0]) >>> >>> Sampler.from_function(num_indices, function, prob_weights=None) - >>> for _ in range(11): - >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) - 44 - 37 - 40 - 42 - 46 - 35 - 10 - 47 - 3 - 28 - 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] @@ -749,22 +659,9 @@ def from_function(num_indices, function, prob_weights=None): >>> prob_weights = [x/total for x in temp_list] >>> >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) - >>> for _ in range(11): - >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) - >>> print(sampler) - 1 - 1 - 1 - 0 - 0 - 11 - 5 - 9 - 8 - 3 - 1 [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + >>> print(sampler) Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. Type : from_function Current iteration number : 11 From fca94f487d59580ee09eca320aaabce753672a29 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 7 Dec 2023 17:20:17 +0000 Subject: [PATCH 109/152] Updates from chat with Gemma --- .../cil/optimisation/utilities/sampler.py | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 60eb994e4c..52aa565e3a 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -470,29 +470,28 @@ def herman_meyer(num_indices): i += 1 else: n_variable //= i - factors.append(i) + factors.append(i) if n_variable > 1: factors.append(n_variable) n_factors = len(factors) - if n_factors == 1: raise ValueError( 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') - #Build the sampling order + #Build up the sampling order iteratively using the prime factors order = np.zeros(num_indices, dtype=np.int8) for factor_n in range(n_factors): if factor_n == 0: - block_length= 1 + repeat_length= 1 else: - block_length= math.prod(factors[:factor_n]) - - addition=np.tile(np.repeat( math.prod(factors[factor_n+1:])*range(num_indices//(addition*block_length)), block_length), addition) - order += addition + repeat_length= math.prod(factors[:factor_n]) + addition=math.prod(factors[factor_n+1:]) + mult=np.tile(np.repeat( range(num_indices//(addition*repeat_length)), repeat_length), addition) + order += addition* mult order=list(order) - + #define the sampler sampler = SamplerFromOrder( num_indices=num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler From 7d4ffe634c1d63ef0be810ef67d97cac9cbc8715 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 8 Dec 2023 08:52:05 +0000 Subject: [PATCH 110/152] Pulled prime factorisation code out of the Herman Meyer function --- .../cil/optimisation/utilities/sampler.py | 38 +++++++++++-------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 52aa565e3a..3f641f25dc 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -432,7 +432,25 @@ def sequential(num_indices): 1/num_indices]*num_indices) return sampler - + @staticmethod + def _prime_factorisation(n): + factors = [] + + while n % 2 == 0: + n//=2 + factors.append(2) + + i = 3 + while i*i <= n: + while n % i == 0: + n //= i; + factors.append(i) + i += 2 + + if n > 1: + factors.append(n) + + return factors @staticmethod def herman_meyer(num_indices): @@ -459,27 +477,15 @@ def herman_meyer(num_indices): [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] """ - - n_variable = num_indices - i = 2 - factors = [] - - #Prime factorisation - while i * i <= n_variable: - if n_variable % i: - i += 1 - else: - n_variable //= i - factors.append(i) - if n_variable > 1: - factors.append(n_variable) + factors=Sampler._prime_factorisation(num_indices) n_factors = len(factors) if n_factors == 1: raise ValueError( 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') - #Build up the sampling order iteratively using the prime factors + #Build up the sampling order iteratively using the prime factors + #In each iteration add on [ [0]*repeat_length, [addition]*repeat_length, ... ] tiled to fill the length of the list order = np.zeros(num_indices, dtype=np.int8) for factor_n in range(n_factors): if factor_n == 0: From 2dba9d7708cf9aea440660eba5201654a8a7c80a Mon Sep 17 00:00:00 2001 From: gfardell Date: Fri, 8 Dec 2023 16:08:42 +0000 Subject: [PATCH 111/152] created herman_meyer sampling as a fucntion of iteration number --- .../cil/optimisation/utilities/sampler.py | 183 +++++++++++++----- Wrappers/Python/test/test_sampler.py | 5 +- 2 files changed, 132 insertions(+), 56 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 3f641f25dc..bd07192ef0 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -19,7 +19,7 @@ import numpy as np import math import time - +from functools import partial class SamplerFromFunction(): """ @@ -126,9 +126,6 @@ def num_indices(self): def current_iter_number(self): return self._iteration_number - - - def next(self): """ Returns and increments the sampler @@ -452,55 +449,6 @@ def _prime_factorisation(n): return factors - @staticmethod - def herman_meyer(num_indices): - """ - Instantiates a sampler which outputs in a Herman Meyer order. - - Parameters - ---------- - num_indices: int - One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. - - Reference - ---------- - Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. - - Returns - ------- - A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a Herman Meyer ordering - - Example - ------- - >>> sampler=Sampler.herman_meyer(12) - >>> print(sampler.get_samples(16)) - [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] - """ - - factors=Sampler._prime_factorisation(num_indices) - - n_factors = len(factors) - if n_factors == 1: - raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') - - #Build up the sampling order iteratively using the prime factors - #In each iteration add on [ [0]*repeat_length, [addition]*repeat_length, ... ] tiled to fill the length of the list - order = np.zeros(num_indices, dtype=np.int8) - for factor_n in range(n_factors): - if factor_n == 0: - repeat_length= 1 - else: - repeat_length= math.prod(factors[:factor_n]) - addition=math.prod(factors[factor_n+1:]) - mult=np.tile(np.repeat( range(num_indices//(addition*repeat_length)), repeat_length), addition) - order += addition* mult - order=list(order) - - #define the sampler - sampler = SamplerFromOrder( - num_indices=num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) - return sampler @staticmethod def staggered(num_indices, offset): @@ -681,3 +629,132 @@ def from_function(num_indices, function, prob_weights=None): sampler = SamplerFromFunction( num_indices=num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler + + @staticmethod + def _prime_factorisation(n): + """ + Parameters + ---------- + + n: int + The number to be factorised. + + Returns + ------- + + factors: list of ints + The prime factors of n. + + """ + factors = [] + + while n % 2 == 0: + n//=2 + factors.append(2) + + i = 3 + while i*i <= n: + while n % i == 0: + n //= i; + factors.append(i) + i += 2 + + if n > 1: + factors.append(n) + + return factors + + + @staticmethod + def _herman_meyer_function(num_indices, factors, addition_arr, repeat_length_arr, iteration_number): + """ + Parameters + ---------- + num_indices: int + The number of indices to be sampled from. + + factors: list of ints + The prime factors of num_indices. + + addition_arr: list of ints + The product of all factors at indices greater than the current factor. + + repeat_length_arr: list of ints + The product of all factors at indices less than the current factor. + + iteration_number: int + The current iteration number. + + Returns + ------- + index: int + The index to be sampled from. + + """ + + index = 0 + for n in range(len(factors)): + addition = addition_arr[n] + repeat_length = repeat_length_arr[n] + + length = num_indices//(addition*repeat_length) + arr = np.arange(length) * addition + + ind = math.floor(iteration_number/repeat_length) % length + index += arr[ind] + + return index + + + @staticmethod + def herman_meyer(num_indices): + """ + Instantiates a sampler which outputs in a Herman Meyer order. + + Parameters + ---------- + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. + + Reference + ---------- + Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a Herman Meyer ordering + + Example + ------- + >>> sampler=Sampler.herman_meyer(12) + >>> print(sampler.get_samples(16)) + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] + """ + + factors = Sampler._prime_factorisation(num_indices) + + n_factors = len(factors) + if n_factors == 1: + raise ValueError( + 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') + + addition_arr = np.empty(n_factors, dtype=np.int64) + repeat_length_arr = np.empty(n_factors, dtype=np.int64) + + repeat_length = 1 + addition = num_indices + for i in range(n_factors): + addition //= factors[i] + addition_arr[i] = addition + + repeat_length_arr[i] = repeat_length + repeat_length *= factors[i] + + hmf_call = partial(Sampler._herman_meyer_function, num_indices, factors, addition_arr, repeat_length_arr) + + #define the sampler + sampler = SamplerFromFunction(function=hmf_call, + num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) + + return sampler + \ No newline at end of file diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 0c16f7420e..2f8cba39b4 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -64,9 +64,8 @@ def test_init(self): sampler = Sampler.herman_meyer(12) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler._type, 'herman_meyer') - self.assertEqual(sampler._last_index, 11) - self.assertListEqual( - sampler._order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + out = [sampler.next() for _ in range(12)] + self.assertListEqual(out, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) From f5c2d96050fc10ae9a05a0e21591fb94e154ce93 Mon Sep 17 00:00:00 2001 From: Margaret Duff <43645617+MargaretDuff@users.noreply.github.com> Date: Mon, 11 Dec 2023 14:35:15 +0000 Subject: [PATCH 112/152] Update Wrappers/Python/cil/optimisation/algorithms/SPDHG.py Co-authored-by: Edoardo Pasca Signed-off-by: Margaret Duff <43645617+MargaretDuff@users.noreply.github.com> --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 8ddd2ec0e6..0b2ad74f57 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -153,7 +153,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, use_axpby=kwargs.pop('use_axpyb', None) update_objective_interval = kwargs.pop('update_objective_interval', 1) super(SPDHG, self).__init__(max_iteration=max_iteration, - update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval, return_all=return_all) + update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler, **kwargs) From 188000fe9540affddde4f44b3254df77f01617b3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 11 Dec 2023 14:37:32 +0000 Subject: [PATCH 113/152] Changes from Edo review --- .../cil/optimisation/algorithms/SPDHG.py | 2 +- Wrappers/Python/test/test_algorithms.py | 175 ------------------ 2 files changed, 1 insertion(+), 176 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 8ddd2ec0e6..ad830f1a3e 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -147,7 +147,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, **kwargs): max_iteration = kwargs.pop('max_iteration', 0) - return_all=kwargs.pop('return_all', False) + print_interval= kwargs.pop('print_interval', None) log_file= kwargs.pop('log_file', None) use_axpby=kwargs.pop('use_axpyb', None) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 32a658bead..0bccf53207 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -1138,181 +1138,6 @@ def test_SPDHG_vs_PDHG_explicit(self): np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), 1.68590e-05, decimal=3) -""" @unittest.skipUnless(has_astra, "ccpi-astra not available") - def test_SPDHG_vs_SPDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get( - size=(16, 16), dtype=numpy.float32) - - ig = data.geometry - ig.voxel_size_x = 0.1 - ig.voxel_size_y = 0.1 - - detectors = ig.shape[0] - angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) - dev = 'cpu' - - Aop = ProjectionOperator(ig, ag, dev) - - sin = Aop.direct(data) - # Create noisy data. Apply Gaussian noise - noises = ['gaussian', 'poisson'] - noise = noises[1] - if noise == 'poisson': - np.random.seed(10) - scale = 5 - eta = 0 - noisy_data = AcquisitionData(np.asarray( - np.random.poisson(scale * (eta + sin.as_array()))/scale, - dtype=np.float32 - ), - geometry=ag - ) - elif noise == 'gaussian': - np.random.seed(10) - n1 = np.asarray(np.random.normal( - 0, 0.1, size=ag.shape), dtype=np.float32) - noisy_data = AcquisitionData(n1 + sin.as_array(), geometry=ag) - - else: - raise ValueError('Unsupported Noise ', noise) - - # %% 'explicit' SPDHG, scalar step-sizes - subsets = 5 - size_of_subsets = int(len(angles)/subsets) - # create GradientOperator operator - op1 = GradientOperator(ig) - # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] - for i in range(0, len(angles), size_of_subsets)] - # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] - # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) - for i in range(subsets)] + [op1]) - # number of subsets - # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) - # - # acquisisiton data - # acquisisiton data - AD_list = [] - for sub_num in range(subsets): - for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets, :] - AD_list.append(AcquisitionData( - arr, geometry=list_geoms[sub_num])) - - g = BlockDataContainer(*AD_list) - - alpha = 0.5 - # block function - F = BlockFunction(*[*[KullbackLeibler(b=g[i]) - for i in range(subsets)] + [alpha * MixedL21Norm()]]) - G = IndicatorBox(lower=0) - - prob = [1/(2*subsets)]*(len(A)-1) + [1/2] - algos = [] - algos.append(SPDHG(f=F, g=G, operator=A, - max_iteration=220, - update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=True) - ) - - algos[0].run(1000, verbose=0) - - algos.append(SPDHG(f=F, g=G, operator=A, - max_iteration=220, - update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=False) - ) - - algos[1].run(1000, verbose=0) - - # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) - qm = (mae(algos[0].get_output(), algos[1].get_output()), - mse(algos[0].get_output(), algos[1].get_output()), - psnr(algos[0].get_output(), algos[1].get_output()) - ) - logging.info("Quality measures {}".format(qm)) - assert qm[0] < 0.005 - assert qm[1] < 0.001 - - @unittest.skipUnless(has_astra, "ccpi-astra not available") - def test_PDHG_vs_PDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16, 16)) - ig = data.geometry - ig.voxel_size_x = 0.1 - ig.voxel_size_y = 0.1 - - detectors = ig.shape[0] - angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) - - dev = 'cpu' - - Aop = ProjectionOperator(ig, ag, dev) - - sin = Aop.direct(data) - - # Create noisy data. Apply Gaussian noise - noises = ['gaussian', 'poisson'] - noise = noises[1] - if noise == 'poisson': - np.random.seed(10) - scale = 5 - eta = 0 - noisy_data = AcquisitionData(numpy.asarray(np.random.poisson( - scale * (eta + sin.as_array())), dtype=numpy.float32)/scale, geometry=ag) - - elif noise == 'gaussian': - np.random.seed(10) - n1 = np.random.normal(0, 0.1, size=ag.shape) - noisy_data = AcquisitionData(numpy.asarray( - n1 + sin.as_array(), dtype=numpy.float32), geometry=ag) - - else: - raise ValueError('Unsupported Noise ', noise) - - alpha = 0.5 - op1 = GradientOperator(ig) - op2 = Aop - # Create BlockOperator - operator = BlockOperator(op1, op2, shape=(2, 1)) - f2 = KullbackLeibler(b=noisy_data) - g = IndicatorBox(lower=0) - normK = operator.norm() - sigma = 1./normK - tau = 1./normK - - f1 = alpha * MixedL21Norm() - f = BlockFunction(f1, f2) - # Setup and run the PDHG algorithm - - algos = [] - - algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - max_iteration=300, - update_objective_interval=1000, use_axpby=True) - ) - - algos[0].run(1000, verbose=0) - - algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - max_iteration=300, - update_objective_interval=1000, use_axpby=False) - ) - - algos[1].run(1000, verbose=0) - - qm = (mae(algos[0].get_output(), algos[1].get_output()), - mse(algos[0].get_output(), algos[1].get_output()), - psnr(algos[0].get_output(), algos[1].get_output()) - ) - logging.info("Quality measures {}".format(qm)) - np.testing.assert_array_less(qm[0], 0.005) - np.testing.assert_array_less(qm[1], 3e-05) - """ class PrintAlgo(Algorithm): def __init__(self, **kwargs): From 86c1e3e1c6872694308b14d35092611b3088446d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 11 Dec 2023 16:22:31 +0000 Subject: [PATCH 114/152] Removed from_order to replace with functions --- .../cil/optimisation/utilities/sampler.py | 312 +++++++----------- Wrappers/Python/test/test_sampler.py | 7 +- docs/source/optimisation.rst | 2 - 3 files changed, 125 insertions(+), 196 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index bd07192ef0..b8f6ea7445 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -21,31 +21,52 @@ import time from functools import partial + class SamplerFromFunction(): """ A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. + The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. Parameters ---------- - + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - + num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - sampling_type:str - The sampling type used. This is set to the default "from_function". + sampling_type:strm default='from_function" + The sampling type used. Choose from "sequential", "staggered", "herman_meyer" and "from_function". prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + Returns ------- A Sampler wrapping a function that can be called with Sampler.next() or next(Sampler) - + + Example + ------- + >>> sampler=Sampler.staggered(21,4) + >>> print(sampler.get_samples(5)) + [ 0 4 8 12 16] + + Example + ------- + >>> sampler=Sampler.sequential(10) + >>> print(sampler.get_samples(5)) + [0 1 2 3 4] + + Example + ------- + >>> sampler=Sampler.herman_meyer(12) + >>> print(sampler.get_samples(16)) + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] + + Example ------- This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. @@ -67,7 +88,7 @@ class SamplerFromFunction(): ------- This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. The probability weights are calculated and passed to the sampler as they are not uniform. - + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] >>> num_indices=13 >>> @@ -90,16 +111,16 @@ class SamplerFromFunction(): Current iteration number : 11 number of indices : 13 Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] - - + + Note ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ - + def __init__(self, function, num_indices, sampling_type='from_function', prob_weights=None): - + self._type = sampling_type self._num_indices = num_indices self.function = function @@ -117,15 +138,15 @@ def __init__(self, function, num_indices, sampling_type='from_function', prob_w @property def prob_weights(self): return self._prob_weights - + @property def num_indices(self): - return self._num_indices - + return self._num_indices + @property def current_iter_number(self): return self._iteration_number - + def next(self): """ Returns and increments the sampler @@ -151,109 +172,14 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres = "Deterministic sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" repres += "Type : {} \n".format(self._type) - repres += "Current iteration number : {} \n".format(self._iteration_number) + repres += "Current iteration number : {} \n".format( + self._iteration_number) repres += "Number of indices : {} \n".format(self._num_indices) repres += "Probability weights : {} \n".format(self._prob_weights) return repres - -class SamplerFromOrder(): - - def __init__(self, order, num_indices, sampling_type, prob_weights=None): - """ - This sampler will sample from a list `order` that is passed. - - It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. - - Parameters - ---------- - order: list of indices - The list of indices the method selects from using next. - - num_indices: int - One above the largest integer that could be drawn by the sampler. The elements in `order` should be chosen from {0, 1, …, S-1} with S=num_indices. - - sampling_type:str - The sampling type used. Choose from "sequential", "herman_meyer", and "staggered" - - prob_weights: list of floats of length num_indices that sum to 1. - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - Returns - ------- - A Sampler outputting in order from an list that can be called with Sampler.next() or next(Sampler) - - Example - ------- - >>> sampler=Sampler.staggered(21,4) - >>> print(sampler.get_samples(5)) - [ 0 4 8 12 16] - """ - - - if prob_weights is None: - prob_weights= num_indices*[1/num_indices] - - if abs(sum(prob_weights)-1) > 1e-6: - raise ValueError('The provided prob_weights must sum to one') - - if any(np.array(prob_weights) < 0): - raise ValueError( - 'The provided prob_weights must be greater than or equal to zero') - - - self._prob_weights = prob_weights - self._type = sampling_type - self._num_indices = num_indices - self._order = order - self._last_index = len(order)-1 - - - @property - def prob_weights(self): - return self._prob_weights - - @property - def num_indices(self): - return self._num_indices - - @property - def current_index_number(self): - return self._iteration_number - - - - def next(self): - """Returns and increments the sampler """ - - self._last_index = (self._last_index+1) % len(self._order) - return self._order[self._last_index] - def __next__(self): - return self.next() - - def get_samples(self, num_samples=20): - """ - Returns the first `num_samples` as a numpy array. - - num_samples: int, default=20 - The number of samples to return. - """ - save_last_index = self._last_index - self._last_index = len(self._order)-1 - output = [self.next() for _ in range(num_samples)] - self._last_index = save_last_index - return np.array(output) - - def __str__(self): - repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the number of indices. \n" - repres += "Type : {} \n".format(self._type) - repres += "Order : {} \n".format(self._order) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Current index number : {} \n".format(self._last_index) - repres += "Probability weights : {} \n".format(self._prob_weights) - return repres class SamplerRandom(): r""" @@ -281,12 +207,12 @@ class SamplerRandom(): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - + + Returns ------- A Sampler wrapping numpy.random.choice that can be called with Sampler.next() or next(Sampler) - + Example ------- >>> sampler=Sampler.random_with_replacement(5) @@ -296,14 +222,14 @@ class SamplerRandom(): >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) [0 1 3 0 0 3 0 0 0 0] - + >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) >>> print(sampler.get_samples(16)) [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] """ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): - + self._replace = replace self._prob = prob @@ -331,11 +257,11 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): self._seed = int(time.time()) self._generator = np.random.RandomState(self._seed) - + @property def prob_weights(self): return self._prob_weights - + @property def num_indices(self): return self._num_indices @@ -362,21 +288,21 @@ def get_samples(self, num_samples=20): self._generator = save_generator return np.array(output) - def __str__(self): - repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." - repres += "Type : {} \n".format(self._type) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Probability weights : {} \n".format(self._prob_weights) - return repres + repres = "Random sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." + repres += "Type : {} \n".format(self._type) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres + class Sampler(): r""" This class follows the factory design pattern. It is not instantiated but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. - + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. - + Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. Example @@ -416,7 +342,7 @@ def sequential(num_indices): Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) and outputs sequentially - + Example ------- @@ -424,9 +350,9 @@ def sequential(num_indices): >>> print(sampler.get_samples(5)) [0 1 2 3 4] """ - order = list(range(num_indices)) - sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='sequential', order=order, prob_weights=[ - 1/num_indices]*num_indices) + def function(x): return x % num_indices + sampler = SamplerFromFunction(function=function, num_indices=num_indices, sampling_type='sequential', prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod @@ -434,13 +360,13 @@ def _prime_factorisation(n): factors = [] while n % 2 == 0: - n//=2 + n //= 2 factors.append(2) i = 3 while i*i <= n: while n % i == 0: - n //= i; + n //= i factors.append(i) i += 2 @@ -449,12 +375,27 @@ def _prime_factorisation(n): return factors + @staticmethod + def _staggered_function(num_indices, offset, iter_number): + """Function that takes in an iteration number and outputs an index number based on the staggered ordering. """ + iter_number_mod = iter_number % num_indices + floor = num_indices//offset + mod = mod + + if iter_number_mod < (floor + 1)*mod: + row_number = iter_number_mod // (floor + 1) + column_number = (iter_number_mod % (floor + 1)) + else: + row_number = mod + (iter_number_mod-(floor+1)*mod)//floor + column_number = (iter_number_mod-(floor+1)*mod) % floor + + return row_number+offset*column_number @staticmethod def staggered(num_indices, offset): """ Instantiates a sampler which outputs in a staggered order. - + Parameters ---------- num_indices: int @@ -463,11 +404,11 @@ def staggered(num_indices, offset): offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. The offset should be less than the num_indices - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a staggered ordering - + Example ------- >>> sampler=Sampler.staggered(21,4) @@ -478,11 +419,9 @@ def staggered(num_indices, offset): if offset >= num_indices: raise (ValueError('The offset should be less than the number of indices')) - indices = list(range(num_indices)) - order = [] - [order.extend(indices[i::offset]) for i in range(offset)] - sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='staggered', order=order, prob_weights=[ - 1/num_indices]*num_indices) + sampler = SamplerFromFunction(function=partial(Sampler._staggered_function, num_indices, offset), num_indices=num_indices, sampling_type='staggered', prob_weights=[ + 1/num_indices]*num_indices) + return sampler @staticmethod @@ -500,11 +439,11 @@ def random_with_replacement(num_indices, prob=None, seed=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) that samples randomly with replacement - + Example ------- @@ -512,7 +451,7 @@ def random_with_replacement(num_indices, prob=None, seed=None): >>> print(sampler.get_samples(10)) [3 4 0 0 2 3 3 2 2 1] - + >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) [0 1 3 0 0 3 0 0 0 0] @@ -537,7 +476,7 @@ def random_without_replacement(num_indices, seed=None, prob=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) that samples randomly without replacement @@ -573,7 +512,7 @@ def from_function(num_indices, function, prob_weights=None): ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. - + Returns ------- A Sampler that wraps a function and can be called with Sampler.next() or next(Sampler) @@ -597,7 +536,7 @@ def from_function(num_indices, function, prob_weights=None): ------- This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. The probability weights are calculated and passed to the sampler as they are not uniform. - + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] >>> num_indices=13 >>> @@ -620,9 +559,9 @@ def from_function(num_indices, function, prob_weights=None): Current iteration number : 11 number of indices : 13 Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] - + """ - + if prob_weights is None: prob_weights = [1/num_indices]*num_indices @@ -632,50 +571,46 @@ def from_function(num_indices, function, prob_weights=None): @staticmethod def _prime_factorisation(n): - """ - Parameters - ---------- - - n: int - The number to be factorised. + """ + Parameters + ---------- - Returns - ------- + n: int + The number to be factorised. - factors: list of ints - The prime factors of n. + Returns + ------- - """ - factors = [] + factors: list of ints + The prime factors of n. - while n % 2 == 0: - n//=2 - factors.append(2) + """ + factors = [] - i = 3 - while i*i <= n: - while n % i == 0: - n //= i; - factors.append(i) - i += 2 + while n % 2 == 0: + n //= 2 + factors.append(2) - if n > 1: - factors.append(n) + i = 3 + while i*i <= n: + while n % i == 0: + n //= i + factors.append(i) + i += 2 - return factors + if n > 1: + factors.append(n) + return factors @staticmethod - def _herman_meyer_function(num_indices, factors, addition_arr, repeat_length_arr, iteration_number): + def _herman_meyer_function(num_indices, addition_arr, repeat_length_arr, iteration_number): """ Parameters ---------- num_indices: int The number of indices to be sampled from. - factors: list of ints - The prime factors of num_indices. - addition_arr: list of ints The product of all factors at indices greater than the current factor. @@ -693,24 +628,23 @@ def _herman_meyer_function(num_indices, factors, addition_arr, repeat_length_arr """ index = 0 - for n in range(len(factors)): + for n in range(len(addition_arr)): addition = addition_arr[n] repeat_length = repeat_length_arr[n] length = num_indices//(addition*repeat_length) arr = np.arange(length) * addition - ind = math.floor(iteration_number/repeat_length) % length - index += arr[ind] + ind = math.floor(iteration_number/repeat_length) % length + index += arr[ind] return index - @staticmethod def herman_meyer(num_indices): """ Instantiates a sampler which outputs in a Herman Meyer order. - + Parameters ---------- num_indices: int @@ -719,11 +653,11 @@ def herman_meyer(num_indices): Reference ---------- Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a Herman Meyer ordering - + Example ------- >>> sampler=Sampler.herman_meyer(12) @@ -750,11 +684,11 @@ def herman_meyer(num_indices): repeat_length_arr[i] = repeat_length repeat_length *= factors[i] - hmf_call = partial(Sampler._herman_meyer_function, num_indices, factors, addition_arr, repeat_length_arr) + hmf_call = partial(Sampler._herman_meyer_function, + num_indices, factors, addition_arr, repeat_length_arr) - #define the sampler + # define the sampler sampler = SamplerFromFunction(function=hmf_call, - num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) + num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) return sampler - \ No newline at end of file diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 2f8cba39b4..381acf9883 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -44,8 +44,6 @@ def test_init(self): sampler = Sampler.sequential(10) self.assertEqual(sampler.num_indices, 10) self.assertEqual(sampler._type, 'sequential') - self.assertListEqual(sampler._order, list(range(10))) - self.assertEqual(sampler._last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) sampler = Sampler.random_without_replacement(7) @@ -83,9 +81,8 @@ def test_init(self): sampler = Sampler.staggered(21, 4) self.assertEqual(sampler.num_indices, 21) self.assertEqual(sampler._type, 'staggered') - self.assertListEqual(sampler._order, [ - 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) - self.assertEqual(sampler._last_index, 20) + out = [sampler.next() for _ in range(21)] + self.assertListEqual(out, [0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) self.assertListEqual(sampler.prob_weights, [1/21] * 21) with self.assertRaises(ValueError): diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 90bff47aeb..d17048594e 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -388,8 +388,6 @@ The static methods will call one of the following: .. autoclass:: cil.optimisation.utilities.SamplerFromFunction :members: -.. autoclass:: cil.optimisation.utilities.SamplerFromOrder - :members: Block Framework From 47542a575526e316416f724ea50616b61b51ddc2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 12 Dec 2023 09:16:02 +0000 Subject: [PATCH 115/152] fix failing tests --- Wrappers/Python/cil/optimisation/utilities/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index a96692e1ce..ff81329840 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -20,5 +20,4 @@ from .sampler import Sampler from .sampler import SamplerFromFunction -from .sampler import SamplerFromOrder from .sampler import SamplerRandom From ddbdbb3c5d96211fa8b60e86879b824300da0502 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 12 Dec 2023 09:49:54 +0000 Subject: [PATCH 116/152] Test fix...again --- Wrappers/Python/cil/optimisation/utilities/sampler.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index b8f6ea7445..89d17df959 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -380,7 +380,7 @@ def _staggered_function(num_indices, offset, iter_number): """Function that takes in an iteration number and outputs an index number based on the staggered ordering. """ iter_number_mod = iter_number % num_indices floor = num_indices//offset - mod = mod + mod = num_indices%offset if iter_number_mod < (floor + 1)*mod: row_number = iter_number_mod // (floor + 1) @@ -685,7 +685,7 @@ def herman_meyer(num_indices): repeat_length *= factors[i] hmf_call = partial(Sampler._herman_meyer_function, - num_indices, factors, addition_arr, repeat_length_arr) + num_indices, addition_arr, repeat_length_arr) # define the sampler sampler = SamplerFromFunction(function=hmf_call, From 5f036752ad1700040371aeb15dbb3dbf002b06b6 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 12 Dec 2023 11:33:32 +0000 Subject: [PATCH 117/152] Fixed tests --- Wrappers/Python/test/test_approximate_gradient.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 923f7cbacc..cd5f408b58 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -99,7 +99,7 @@ def test_sampler(self): self.assertTrue(isinstance(self.f_stochastic.sampler, SamplerRandom)) f=SGFunction(self.f_subsets) self.assertTrue(isinstance( f.sampler, SamplerRandom)) - self.assertEqual(f.sampler.type, 'random_with_replacement') + self.assertEqual(f.sampler._type, 'random_with_replacement') def test_direct(self): self.assertAlmostEqual(self.f_stochastic(self.initial), self.f(self.initial),1) From 3531b96722882a8515a54a6a48f9208e6b1279d7 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 25 Jan 2024 14:44:28 +0000 Subject: [PATCH 118/152] Tidy up PR --- Wrappers/Python/cil/framework/__init__.py | 1 - .../cil/optimisation/algorithms/SPDHG.py | 374 ++---- Wrappers/Python/test/test_algorithms.py | 1094 ++++++++--------- Wrappers/Python/test/test_functions.py | 19 +- Wrappers/Python/test/test_sampler.py | 1 - docs/source/optimisation.rst | 1 + 6 files changed, 622 insertions(+), 868 deletions(-) diff --git a/Wrappers/Python/cil/framework/__init__.py b/Wrappers/Python/cil/framework/__init__.py index 437ecd787a..4571441515 100644 --- a/Wrappers/Python/cil/framework/__init__.py +++ b/Wrappers/Python/cil/framework/__init__.py @@ -34,4 +34,3 @@ from .BlockGeometry import BlockGeometry from .framework import DataOrder from .framework import Partitioner - diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 7ea32ff451..f62372480d 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -32,11 +32,11 @@ class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient Problem: - + .. math:: - + \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) - + Parameters ---------- f : BlockFunction @@ -51,6 +51,8 @@ class SPDHG(Algorithm): List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm + prob : list of floats, optional, default=None + List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class @@ -60,106 +62,62 @@ class SPDHG(Algorithm): prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats - precalculated list of norms of the operators. To be deprecated and placed by the `set_norms` functionalist in a BlockOperator. + precalculated list of norms of the operators + Example ------- - - Example - ------- - >>> data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) - >>> subsets = 10 - >>> ig = data.geometry - >>> ig.voxel_size_x = 0.1 - >>> ig.voxel_size_y = 0.1 - >>> - >>> detectors = ig.shape[0] - >>> angles = np.linspace(0, np.pi, 90) - >>> ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles, angle_unit='radian').set_panel(detectors, 0.1) - >>> - >>> Aop = ProjectionOperator(ig, ag, 'cpu') - >>> - >>> sin = Aop.direct(data) - >>> partitioned_data = sin.partition(subsets, 'sequential') - >>> A = BlockOperator(*[ProjectionOperator(ig. partitioned_data[i].geometry, 'cpu') for i in range(subsets)]) - >>> - >>> F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(subsets)]) - - >>> alpha = 0.025 - >>> G = alpha * TotalVariation() - >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.sequential(len(A)), - initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - >>> spdhg.run(100) - - Example - ------- - Further examples of usage see the [CIL demos.](https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py) - - Note - ----- - When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - - - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - - .. math:: - \sigma_i=0.99 / (\|K_i\|**2) - - - and `tau` is set as per case 2 - - - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula - - .. math:: - \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - - - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula - - .. math:: - \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - - - Case 4: Both `sigma` and `tau` are provided. + Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py Note ---- - + Convergence is guaranteed provided that [2, eq. (12)]: - + .. math:: \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i + + Note + ---- + + Notation for primal and dual step-sizes are reversed with comparison + to PDHG.py + Note + ---- + + this code implements serial sampling only, as presented in [2] + (to be extended to more general case of [1] as future work) + References ---------- - + [1]"Stochastic primal-dual hybrid gradient algorithm with arbitrary sampling and imaging applications", Chambolle, Antonin, Matthias J. Ehrhardt, Peter Richtárik, and Carola-Bibiane Schonlieb, SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. - + [2]"Faster PET reconstruction with non-smooth priors by randomization and preconditioning", Matthias J Ehrhardt, Pawel Markiewicz and Carola-Bibiane Schönlieb, Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, sampler=None, **kwargs): + initial=None, prob=None, gamma=1.,**kwargs): + + super(SPDHG, self).__init__(**kwargs) + - max_iteration = kwargs.pop('max_iteration', 0) - - print_interval= kwargs.pop('print_interval', None) - log_file= kwargs.pop('log_file', None) - use_axpby=kwargs.pop('use_axpyb', None) - update_objective_interval = kwargs.pop('update_objective_interval', 1) - super(SPDHG, self).__init__(max_iteration=max_iteration, - update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval) + if f is not None and operator is not None and g is not None: + self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + initial=initial, prob=prob, gamma=gamma, norms=kwargs.get('norms', None)) + - self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - initial=initial, sampler=sampler, **kwargs) + def set_up(self, f, g, operator, tau=None, sigma=None, \ + initial=None, prob=None, gamma=1., norms=None): - def set_up(self, f, g, operator, sigma=None, tau=None, - initial=None, sampler=None, **deprecated_kwargs): '''set-up of the algorithm Parameters @@ -176,272 +134,100 @@ def set_up(self, f, g, operator, sigma=None, tau=None, List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm + prob : list of floats, optional, default=None + List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class - Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets + + **kwargs: + norms : list of floats + precalculated list of norms of the operators ''' logging.info("{} setting up".format(self.__class__.__name__, )) - + # algorithmic parameters self.f = f self.g = g self.operator = operator - - if not isinstance(operator, BlockOperator): - raise TypeError("operator should be a BlockOperator") - + self.tau = tau + self.sigma = sigma + self.prob = prob self.ndual_subsets = len(self.operator) - self._sampler = sampler - self._deprecated_kwargs(deprecated_kwargs) - - if self._sampler is None: - self._sampler = Sampler.random_with_replacement(len(operator)) + self.gamma = gamma + self.rho = .99 - if self._sampler.num_indices != len(operator): - raise ValueError('The `num_indices` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') - - self.norms = operator.get_norms_as_list() - - if self._sampler.prob_weights is None: - self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets - else: - self.prob_weights=self._sampler.prob_weights - - self.set_step_sizes(sigma=sigma, tau=tau) + if self.prob is None: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets - # initialize primal variable + + if self.sigma is None: + if norms is None: + # Compute norm of each sub-operator + norms = [operator.get_item(i,0).norm() for i in range(self.ndual_subsets)] + self.norms = norms + self.sigma = [self.gamma * self.rho / ni for ni in norms] + if self.tau is None: + self.tau = min( [ pi / ( si * ni**2 ) for pi, ni, si in zip(self.prob, norms, self.sigma)] ) + self.tau *= (self.rho / self.gamma) + + # initialize primal variable if initial is None: self.x = self.operator.domain_geometry().allocate(0) else: self.x = initial.copy() - + self.x_tmp = self.operator.domain_geometry().allocate(0) - + # initialize dual variable to 0 self.y_old = operator.range_geometry().allocate(0) - + # initialize variable z corresponding to back-projected dual variable self.z = operator.domain_geometry().allocate(0) - self.zbar = operator.domain_geometry().allocate(0) + self.zbar= operator.domain_geometry().allocate(0) # relaxation parameter self.theta = 1 self.configured = True logging.info("{} configured".format(self.__class__.__name__, )) - - - def _deprecated_kwargs(self, deprecated_kwargs): - """ - Handle deprecated keyword arguments for backward compatibility. - Parameters - ---------- - deprecated_kwargs : dict - Dictionary of keyword arguments. - - Notes - ----- - This method is called by the set_up method. - """ - norms = deprecated_kwargs.pop('norms', None) - prob = deprecated_kwargs.pop('prob', None) - if norms is not None: - self.operator.set_norms(norms) - warnings.warn( - ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - - if self._sampler is not None: - if prob is not None: - raise TypeError( - '`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - else: - if prob is not None: - warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - self._sampler = Sampler.random_with_replacement( - len(self.operator), prob=prob) - - if deprecated_kwargs: - raise ValueError("Additional keyword arguments passed but not used: {}".format( - deprecated_kwargs)) - - @property - def sigma(self): - return self._sigma - - @property - def tau(self): - return self._tau - - def set_step_sizes_from_ratio(self, gamma=1., rho=.99): - r""" Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. - - Parameters - ---------- - gamma : Positive float - parameter controlling the trade-off between the primal and dual step sizes - rho : Positive float - parameter controlling the size of the product :math: \sigma\tau :math: - - Note - ----- - The step sizes `sigma` and `tau` are set using the equations: - .. math:: - \sigma_i=\gamma\rho / (\|K_i\|**2)\\ - \tau = (\rho/\gamma)\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - - """ - if isinstance(gamma, Number): - if gamma <= 0: - raise ValueError( - "The step-sizes of SPDHG are positive, gamma should also be positive") - - else: - raise ValueError( - "We currently only support scalar values of gamma") - if isinstance(rho, Number): - if rho <= 0: - raise ValueError( - "The step-sizes of SPDHG are positive, rho should also be positive") - - else: - raise ValueError( - "We currently only support scalar values of gamma") - - self._sigma = [gamma * rho / ni for ni in self.norms] - values = [pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)] - self._tau = min([value for value in values if value > 1e-8]) - self._tau *= (rho / gamma) - - def set_step_sizes(self, sigma=None, tau=None): - r""" Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. - - Parameters - ---------- - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - tau : positive float, optional, default=None - Step size parameter for Primal problem - - The user can set these or default values are calculated, either sigma, tau, both or None can be passed. - - Note - ----- - When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - - - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - - .. math:: - \sigma_i=0.99 / (\|K_i\|**2) - - - and `tau` is set as per case 2 - - - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula - - .. math:: - \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - - - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula - - .. math:: - \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - - - Case 4: Both `sigma` and `tau` are provided. - - """ - gamma = 1. - rho = .99 - if sigma is not None: - if len(sigma) == self.ndual_subsets: - if all(isinstance(x, Number) and x > 0 for x in sigma): - pass - else: - raise ValueError( - "Sigma expected to be a positive number.") - - else: - raise ValueError( - "Please pass a list of floats to sigma with the same number of entries as number of operators") - self._sigma = sigma - - elif tau is None: - self._sigma = [gamma * rho / ni for ni in self.norms] - else: - self._sigma = [ - gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] - - if tau is None: - values = [pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)] - self._tau = min([value for value in values if value > 1e-8]) - self._tau *= (rho / gamma) - else: - if isinstance(tau, Number) and tau > 0: - pass - else: - raise ValueError( - "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) - - self._tau = tau - - def check_convergence(self): - """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma - - Returns - ------- - Boolean - True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. N.B Convergence criterion currently can only be checked for scalar values of tau. - """ - for i in range(self.ndual_subsets): - if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): - if self._sigma[i] * self._tau * self.norms[i]**2 > self.prob_weights[i]: - return False - return True - else: - return False - - def update(self): # Gradient descent for the primal variable # x_tmp = x - tau * zbar self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) - + self.g.proximal(self.x_tmp, self.tau, out=self.x) - + # Choose subset - i = next(self._sampler) - + i = int(np.random.choice(len(self.sigma), 1, p=self.prob)) + # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x y_k = self.operator[i].direct(self.x) y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) - + y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) - + # Back-project # x_tmp = K[i]^*(y_k - y_old[i]) y_k.subtract(self.y_old[i], out=self.y_old[i]) - self.operator[i].adjoint(self.y_old[i], out=self.x_tmp) + self.operator[i].adjoint(self.y_old[i], out = self.x_tmp) # Update backprojected dual variable and extrapolate # zbar = z + (1 + theta/p[i]) x_tmp # z = z + x_tmp - self.z.add(self.x_tmp, out=self.z) + self.z.add(self.x_tmp, out =self.z) # zbar = z + (theta/p[i]) * x_tmp - self.z.sapyb(1., self.x_tmp, self.theta / - self.prob_weights[i], out=self.zbar) + self.z.sapyb(1., self.x_tmp, self.theta / self.prob[i], out = self.zbar) # save previous iteration self.save_previous_iteration(i, y_k) - + def update_objective(self): # p1 = self.f(self.operator.direct(self.x)) + self.g(self.x) p1 = 0. - for i, op in enumerate(self.operator.operators): + for i,op in enumerate(self.operator.operators): p1 += self.f[i](op.direct(self.x)) p1 += self.g(self.x) @@ -454,16 +240,14 @@ def update_objective(self): @property def objective(self): - '''alias of loss''' - return [x[0] for x in self.loss] - + '''alias of loss''' + return [x[0] for x in self.loss] @property def dual_objective(self): return [x[1] for x in self.loss] - + @property def primal_dual_gap(self): return [x[2] for x in self.loss] - def save_previous_iteration(self, index, y_current): self.y_old[index].fill(y_current) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 5c8c1d6929..893469b813 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -29,14 +29,13 @@ from cil.framework import AcquisitionGeometry from cil.framework import BlockDataContainer from cil.framework import BlockGeometry -from cil.optimisation.utilities import Sampler from cil.optimisation.operators import IdentityOperator from cil.optimisation.operators import GradientOperator, BlockOperator, MatrixOperator from cil.optimisation.functions import LeastSquares, ZeroFunction, \ - L2NormSquared, OperatorCompositionFunction -from cil.optimisation.functions import MixedL21Norm, BlockFunction, L1Norm, KullbackLeibler + L2NormSquared, OperatorCompositionFunction +from cil.optimisation.functions import MixedL21Norm, BlockFunction, L1Norm, KullbackLeibler from cil.optimisation.functions import IndicatorBox from cil.optimisation.algorithms import Algorithm @@ -60,45 +59,43 @@ # Fast Gradient Projection algorithm for Total Variation(TV) from cil.optimisation.functions import TotalVariation -from cil.plugins.ccpi_regularisation.functions import FGP_TV import logging from testclass import CCPiTestClass -from utils import has_astra +from utils import has_astra initialise_tests() if has_astra: from cil.plugins.astra import ProjectionOperator - class TestAlgorithms(CCPiTestClass): - + def test_GD(self): - ig = ImageGeometry(12, 13, 14) + ig = ImageGeometry(12,13,14) initial = ig.allocate() # b = initial.copy() # fill with random numbers # b.fill(numpy.random.random(initial.shape)) b = ig.allocate('random') identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) rate = norm2sq.L / 3. - - alg = GD(initial=initial, - objective_function=norm2sq, - rate=rate, atol=1e-9, rtol=1e-6) + + alg = GD(initial=initial, + objective_function=norm2sq, + rate=rate, atol=1e-9, rtol=1e-6) alg.max_iteration = 1000 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = GD(initial=initial, - objective_function=norm2sq, - rate=rate, max_iteration=20, - update_objective_interval=2, - atol=1e-9, rtol=1e-6) + alg = GD(initial=initial, + objective_function=norm2sq, + rate=rate, max_iteration=20, + update_objective_interval=2, + atol=1e-9, rtol=1e-6) alg.max_iteration = 20 self.assertTrue(alg.max_iteration == 20) - self.assertTrue(alg.update_objective_interval == 2) + self.assertTrue(alg.update_objective_interval==2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) @@ -108,118 +105,117 @@ def test_update_interval_0(self): the update_objective interval is set to 0 and with verbose on / off ''' - ig = ImageGeometry(12, 13, 14) + ig = ImageGeometry(12,13,14) initial = ig.allocate() b = ig.allocate('random') identity = IdentityOperator(ig) norm2sq = LeastSquares(identity, b) - alg = GD(initial=initial, - objective_function=norm2sq, + alg = GD(initial=initial, + objective_function=norm2sq, max_iteration=20, update_objective_interval=0, atol=1e-9, rtol=1e-6) - self.assertTrue(alg.update_objective_interval == 0) + self.assertTrue(alg.update_objective_interval==0) alg.run(20, verbose=True) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) alg.run(20, verbose=False) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) + def test_GDArmijo(self): - ig = ImageGeometry(12, 13, 14) + ig = ImageGeometry(12,13,14) initial = ig.allocate() # b = initial.copy() # fill with random numbers # b.fill(numpy.random.random(initial.shape)) b = ig.allocate('random') identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) rate = None - - alg = GD(initial=initial, - objective_function=norm2sq, rate=rate) + + alg = GD(initial=initial, + objective_function=norm2sq, rate=rate) alg.max_iteration = 100 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = GD(initial=initial, - objective_function=norm2sq, - max_iteration=20, - update_objective_interval=2) - # alg.max_iteration = 20 + alg = GD(initial=initial, + objective_function=norm2sq, + max_iteration=20, + update_objective_interval=2) + #alg.max_iteration = 20 self.assertTrue(alg.max_iteration == 20) - self.assertTrue(alg.update_objective_interval == 2) + self.assertTrue(alg.update_objective_interval==2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) + def test_GDArmijo2(self): - f = Rosenbrock(alpha=1., beta=100.) + f = Rosenbrock (alpha = 1., beta=100.) vg = VectorGeometry(2) x = vg.allocate('random_int', seed=2) - # x = vg.allocate('random', seed=1) - x.fill(numpy.asarray([10., -3.])) - + # x = vg.allocate('random', seed=1) + x.fill(numpy.asarray([10.,-3.])) + max_iter = 10000 update_interval = 1000 - alg = GD(x, f, max_iteration=max_iter, - update_objective_interval=update_interval, alpha=1e6) - + alg = GD(x, f, max_iteration=max_iter, update_objective_interval=update_interval, alpha=1e6) + alg.run(verbose=0) - + # this with 10k iterations - numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [ - 0.13463363, 0.01604593], decimal=5) + numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [0.13463363, 0.01604593], decimal = 5) # this with 1m iterations # numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [1,1], decimal = 1) # numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [0.982744, 0.965725], decimal = 6) + def test_CGLS(self): - ig = ImageGeometry(10, 2) + ig = ImageGeometry(10,2) numpy.random.seed(2) initial = ig.allocate(1.) b = ig.allocate('random') identity = IdentityOperator(ig) - + alg = CGLS(initial=initial, operator=identity, data=b) + + np.testing.assert_array_equal(initial.as_array(), alg.solution.as_array()) - np.testing.assert_array_equal( - initial.as_array(), alg.solution.as_array()) - - alg.max_iteration = 200 + alg.max_iteration = 200 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = CGLS(initial=initial, operator=identity, data=b, - max_iteration=200, update_objective_interval=2) + alg = CGLS(initial=initial, operator=identity, data=b, max_iteration=200, update_objective_interval=2) self.assertTrue(alg.max_iteration == 200) - self.assertTrue(alg.update_objective_interval == 2) + self.assertTrue(alg.update_objective_interval==2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - + + def test_FISTA(self): - ig = ImageGeometry(127, 139, 149) + ig = ImageGeometry(127,139,149) initial = ig.allocate() b = initial.copy() # fill with random numbers b.fill(numpy.random.random(initial.shape)) initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) - opt = {'tol': 1e-4, 'memopt': False} - logging.info("initial objective {}".format(norm2sq(initial))) - + opt = {'tol': 1e-4, 'memopt':False} + logging.info ("initial objective {}".format(norm2sq(initial))) + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction()) alg.max_iteration = 2 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), - max_iteration=2, update_objective_interval=2) - + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), max_iteration=2, update_objective_interval=2) + self.assertTrue(alg.max_iteration == 2) - self.assertTrue(alg.update_objective_interval == 2) + self.assertTrue(alg.update_objective_interval==2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) @@ -250,12 +246,11 @@ def test_FISTA_update(self): n = 50 m = 500 - A = np.random.uniform(0, 1, (m, n)).astype('float32') - b = (A.dot(np.random.randn(n)) + 0.1 * - np.random.randn(m)).astype('float32') + A = np.random.uniform(0,1, (m, n)).astype('float32') + b = (A.dot(np.random.randn(n)) + 0.1*np.random.randn(m)).astype('float32') Aop = MatrixOperator(A) - bop = VectorData(b) + bop = VectorData(b) f = LeastSquares(Aop, b=bop, c=0.5) g = ZeroFunction() @@ -263,10 +258,10 @@ def test_FISTA_update(self): ig = Aop.domain initial = ig.allocate() - + # ista run 10 iteration tmp_initial = ig.allocate() - fista = FISTA(initial=tmp_initial, f=f, g=g, max_iteration=1) + fista = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1) fista.run() # fista update method @@ -278,99 +273,97 @@ def test_FISTA_update(self): for _ in range(1): - x = g.proximal(y_old - step_size * - f.gradient(y_old), tau=step_size) + x = g.proximal(y_old - step_size * f.gradient(y_old), tau = step_size) t = 0.5*(1 + numpy.sqrt(1 + 4*(t_old**2))) - y = x + ((t_old-1)/t) * (x - x_old) + y = x + ((t_old-1)/t)* ( x - x_old) x_old.fill(x) y_old.fill(y) t_old = t - - np.testing.assert_allclose(fista.solution.array, x.array, atol=1e-2) - + + np.testing.assert_allclose(fista.solution.array, x.array, atol=1e-2) + # check objective res1 = fista.objective[-1] res2 = f(x) + g(x) - self.assertTrue(res1 == res2) + self.assertTrue( res1==res2) tmp_initial = ig.allocate() - fista1 = FISTA(initial=tmp_initial, f=f, g=g, max_iteration=1) + fista1 = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1) self.assertTrue(fista1.is_provably_convergent()) - fista1 = FISTA(initial=tmp_initial, f=f, g=g, - max_iteration=1, step_size=30.0) - self.assertFalse(fista1.is_provably_convergent()) + fista1 = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1, step_size=30.0) + self.assertFalse(fista1.is_provably_convergent()) + def test_FISTA_Norm2Sq(self): - ig = ImageGeometry(127, 139, 149) + ig = ImageGeometry(127,139,149) b = ig.allocate(ImageGeometry.RANDOM) # fill with random numbers initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) - - opt = {'tol': 1e-4, 'memopt': False} - logging.info("initial objective {}".format(norm2sq(initial))) + + opt = {'tol': 1e-4, 'memopt':False} + logging.info ("initial objective {}".format(norm2sq(initial))) alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction()) alg.max_iteration = 2 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), - max_iteration=2, update_objective_interval=3) + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), max_iteration=2, update_objective_interval=3) self.assertTrue(alg.max_iteration == 2) - self.assertTrue(alg.update_objective_interval == 3) + self.assertTrue(alg.update_objective_interval== 3) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) def test_FISTA_catch_Lipschitz(self): - ig = ImageGeometry(127, 139, 149) + ig = ImageGeometry(127,139,149) initial = ImageData(geometry=ig) initial = ig.allocate() b = initial.copy() - # fill with random numbers + # fill with random numbers b.fill(numpy.random.random(initial.shape)) initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) logging.info('Lipschitz {}'.format(norm2sq.L)) # norm2sq.L = None - # norm2sq.L = 2 * norm2sq.c * identity.norm()**2 - # norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) - opt = {'tol': 1e-4, 'memopt': False} - logging.info("initial objective".format(norm2sq(initial))) + #norm2sq.L = 2 * norm2sq.c * identity.norm()**2 + #norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) + opt = {'tol': 1e-4, 'memopt':False} + logging.info ("initial objective".format(norm2sq(initial))) with self.assertRaises(ValueError): - alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction()) + alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction()) + def test_PDHG_Denoising(self): - # adapted from demo PDHG_TV_Color_Denoising.py in CIL-Demos repository - data = dataexample.PEPPERS.get(size=(256, 256)) + # adapted from demo PDHG_TV_Color_Denoising.py in CIL-Demos repository + data = dataexample.PEPPERS.get(size=(256,256)) ig = data.geometry ag = ig which_noise = 0 - # Create noisy data. + # Create noisy data. noises = ['gaussian', 'poisson', 's&p'] dnoise = noises[which_noise] - + def setup(data, dnoise): if dnoise == 's&p': - n1 = applynoise.saltnpepper( - data, salt_vs_pepper=0.9, amount=0.2, seed=10) + n1 = applynoise.saltnpepper(data, salt_vs_pepper = 0.9, amount=0.2, seed=10) elif dnoise == 'poisson': scale = 5 - n1 = applynoise.poisson(data.as_array()/scale, seed=10)*scale + n1 = applynoise.poisson( data.as_array()/scale, seed = 10)*scale elif dnoise == 'gaussian': - n1 = applynoise.gaussian(data.as_array(), seed=10) + n1 = applynoise.gaussian(data.as_array(), seed = 10) else: raise ValueError('Unsupported Noise ', noise) noisy_data = ig.allocate() noisy_data.fill(n1) - + # Regularisation Parameter depending on the noise distribution if dnoise == 's&p': alpha = 0.8 @@ -388,11 +381,10 @@ def setup(data, dnoise): return noisy_data, alpha, g noisy_data, alpha, g = setup(data, dnoise) - operator = GradientOperator( - ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') - - f1 = alpha * MixedL21Norm() + operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + f1 = alpha * MixedL21Norm() + # Compute operator Norm normK = operator.norm() @@ -401,23 +393,22 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma) + pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma) pdhg1.max_iteration = 2000 pdhg1.update_objective_interval = 200 pdhg1.run(1000, verbose=0) rmse = (pdhg1.get_output() - data).norm() / data.as_array().size - logging.info("RMSE {}".format(rmse)) + logging.info ("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) which_noise = 1 noise = noises[which_noise] noisy_data, alpha, g = setup(data, noise) - operator = GradientOperator( - ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') - - f1 = alpha * MixedL21Norm() + operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + f1 = alpha * MixedL21Norm() + # Compute operator Norm normK = operator.norm() @@ -426,23 +417,23 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma, + pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma, max_iteration=2000, update_objective_interval=200) - + pdhg1.run(1000, verbose=0) rmse = (pdhg1.get_output() - data).norm() / data.as_array().size logging.info("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) - + + which_noise = 2 noise = noises[which_noise] noisy_data, alpha, g = setup(data, noise) - operator = GradientOperator( - ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') - - f1 = alpha * MixedL21Norm() + operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + f1 = alpha * MixedL21Norm() + # Compute operator Norm normK = operator.norm() @@ -451,7 +442,7 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma) + pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma) pdhg1.max_iteration = 2000 pdhg1.update_objective_interval = 200 pdhg1.run(1000, verbose=0) @@ -460,173 +451,169 @@ def setup(data, dnoise): logging.info("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) + def test_PDHG_step_sizes(self): - ig = ImageGeometry(3, 3) + ig = ImageGeometry(3,3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = 3*IdentityOperator(ig) - # check if sigma, tau are None + #check if sigma, tau are None pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10) self.assertAlmostEqual(pdhg.sigma, 1./operator.norm()) self.assertAlmostEqual(pdhg.tau, 1./operator.norm()) - # check if sigma is negative + #check if sigma is negative with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, - max_iteration=10, sigma=-1) - - # check if tau is negative + pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, sigma = -1) + + #check if tau is negative with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, tau=-1) - - # check if tau is None + pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, tau = -1) + + #check if tau is None sigma = 3.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, max_iteration=10) self.assertAlmostEqual(pdhg.sigma, sigma) - self.assertAlmostEqual(pdhg.tau, 1./(sigma * operator.norm()**2)) + self.assertAlmostEqual(pdhg.tau, 1./(sigma * operator.norm()**2)) - # check if sigma is None + #check if sigma is None tau = 3.0 - pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, max_iteration=10) self.assertAlmostEqual(pdhg.tau, tau) - self.assertAlmostEqual(pdhg.sigma, 1./(tau * operator.norm()**2)) + self.assertAlmostEqual(pdhg.sigma, 1./(tau * operator.norm()**2)) - # check if sigma/tau are not None + #check if sigma/tau are not None tau = 1.0 sigma = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, - sigma=sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, sigma = sigma, max_iteration=10) self.assertAlmostEqual(pdhg.tau, tau) - self.assertAlmostEqual(pdhg.sigma, sigma) + self.assertAlmostEqual(pdhg.sigma, sigma) - # check sigma/tau as arrays, sigma wrong shape - ig1 = ImageGeometry(2, 2) + #check sigma/tau as arrays, sigma wrong shape + ig1 = ImageGeometry(2,2) sigma = ig1.allocate() with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, - sigma=sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, max_iteration=10) - # check sigma/tau as arrays, tau wrong shape + #check sigma/tau as arrays, tau wrong shape tau = ig1.allocate() with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, max_iteration=10) + # check sigma not Number or object with correct shape with self.assertRaises(AttributeError): - pdhg = PDHG(f=f, g=g, operator=operator, - sigma="sigma", max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, sigma = "sigma", max_iteration=10) + # check tau not Number or object with correct shape with self.assertRaises(AttributeError): - pdhg = PDHG(f=f, g=g, operator=operator, - tau="tau", max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, tau = "tau", max_iteration=10) + # check warning message if condition is not satisfied sigma = 4 tau = 1/3 with warnings.catch_warnings(record=True) as wa: - pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, - sigma=sigma, max_iteration=10) - assert "Convergence criterion" in str(wa[0].message) + pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, sigma = sigma, max_iteration=10) + assert "Convergence criterion" in str(wa[0].message) + def test_PDHG_strongly_convex_gamma_g(self): - ig = ImageGeometry(3, 3) + ig = ImageGeometry(3,3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - # sigma, tau + # sigma, tau sigma = 1.0 - tau = 1.0 + tau = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, max_iteration=5, gamma_g=0.5) pdhg.run(1, verbose=0) - self.assertAlmostEquals( - pdhg.theta, 1.0 / np.sqrt(1 + 2 * pdhg.gamma_g * tau)) + self.assertAlmostEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_g * tau)) self.assertAlmostEquals(pdhg.tau, tau * pdhg.theta) self.assertAlmostEquals(pdhg.sigma, sigma / pdhg.theta) pdhg.run(4, verbose=0) self.assertNotEqual(pdhg.sigma, sigma) - self.assertNotEqual(pdhg.tau, tau) + self.assertNotEqual(pdhg.tau, tau) # check negative strongly convex constant with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - max_iteration=5, gamma_g=-0.5) + pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, + max_iteration=5, gamma_g=-0.5) + # check strongly convex constant not a number with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - max_iteration=5, gamma_g="-0.5") + pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, + max_iteration=5, gamma_g="-0.5") + def test_PDHG_strongly_convex_gamma_fcong(self): - ig = ImageGeometry(3, 3) + ig = ImageGeometry(3,3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - # sigma, tau + # sigma, tau sigma = 1.0 - tau = 1.0 + tau = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, max_iteration=5, gamma_fconj=0.5) pdhg.run(1, verbose=0) - self.assertEquals(pdhg.theta, 1.0 / np.sqrt(1 + - 2 * pdhg.gamma_fconj * sigma)) + self.assertEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_fconj * sigma)) self.assertEquals(pdhg.tau, tau / pdhg.theta) self.assertEquals(pdhg.sigma, sigma * pdhg.theta) pdhg.run(4, verbose=0) self.assertNotEqual(pdhg.sigma, sigma) - self.assertNotEqual(pdhg.tau, tau) + self.assertNotEqual(pdhg.tau, tau) # check negative strongly convex constant try: - pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - max_iteration=5, gamma_fconj=-0.5) + pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, + max_iteration=5, gamma_fconj=-0.5) except ValueError as ve: - logging.info(str(ve)) + logging.info(str(ve)) # check strongly convex constant not a number try: - pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - max_iteration=5, gamma_fconj="-0.5") + pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, + max_iteration=5, gamma_fconj="-0.5") except ValueError as ve: - logging.info(str(ve)) + logging.info(str(ve)) def test_PDHG_strongly_convex_both_fconj_and_g(self): - ig = ImageGeometry(3, 3) + ig = ImageGeometry(3,3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - + try: - pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, - gamma_g=0.5, gamma_fconj=0.5) + pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, + gamma_g = 0.5, gamma_fconj=0.5) pdhg.run(verbose=0) except ValueError as err: - logging.info(str(err)) + logging.info(str(err)) def test_FISTA_Denoising(self): # adapted from demo FISTA_Tikhonov_Poisson_Denoising.py in CIL-Demos repository data = dataexample.SHAPES.get() ig = data.geometry ag = ig - N = 300 + N=300 # Create Noisy data with Poisson noise scale = 5 - noisy_data = applynoise.poisson(data/scale, seed=10) * scale + noisy_data = applynoise.poisson(data/scale,seed=10) * scale # Regularisation Parameter alpha = 10 @@ -637,7 +624,7 @@ def test_FISTA_Denoising(self): reg = OperatorCompositionFunction(alpha * L2NormSquared(), operator) initial = ig.allocate() - fista = FISTA(initial=initial, f=reg, g=fid) + fista = FISTA(initial=initial , f=reg, g=fid) fista.max_iteration = 3000 fista.update_objective_interval = 500 fista.run(verbose=0) @@ -646,324 +633,161 @@ def test_FISTA_Denoising(self): self.assertLess(rmse, 4.2e-4) + + + + + + + + + + + + + + + + class TestSIRT(unittest.TestCase): - def setUp(self): + + def setUp(self): np.random.seed(10) # set up matrix, vectordata n, m = 50, 50 - A = np.random.uniform(0, 1, (m, n)).astype('float32') + A = np.random.uniform(0, 1,(m, n)).astype('float32') b = A.dot(np.random.randn(n)) self.Aop = MatrixOperator(A) - self.bop = VectorData(b) + self.bop = VectorData(b) self.ig = self.Aop.domain self.initial = self.ig.allocate() - + # set up with linear operator - self.ig2 = ImageGeometry(3, 4, 5) + self.ig2 = ImageGeometry(3,4,5) self.initial2 = self.ig2.allocate(0.) - self.b2 = self.ig2.allocate('random') - self.A2 = IdentityOperator(self.ig2) + self.b2 = self.ig2.allocate('random') + self.A2 = IdentityOperator(self.ig2) + def tearDown(self): - pass + pass - def test_update(self): + + def test_update(self): # sirt run 5 iterations tmp_initial = self.ig.allocate() - sirt = SIRT(initial=tmp_initial, operator=self.Aop, - data=self.bop, max_iteration=5) + sirt = SIRT(initial = tmp_initial, operator=self.Aop, data=self.bop, max_iteration=5) sirt.run() x = tmp_initial.copy() x_old = tmp_initial.copy() - for _ in range(5): - x = x_old + sirt.D * \ - (sirt.operator.adjoint(sirt.M*(sirt.data - sirt.operator.direct(x_old)))) + for _ in range(5): + x = x_old + sirt.D*(sirt.operator.adjoint(sirt.M*(sirt.data - sirt.operator.direct(x_old)))) x_old.fill(x) - np.testing.assert_allclose(sirt.solution.array, x.array, atol=1e-2) + np.testing.assert_allclose(sirt.solution.array, x.array, atol=1e-2) + def test_update_constraints(self): - alg = SIRT(initial=self.initial2, operator=self.A2, - data=self.b2, max_iteration=20) + alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20) alg.run(verbose=0) - np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) - - alg = SIRT(initial=self.initial2, operator=self.A2, - data=self.b2, max_iteration=20, upper=0.3) + np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) + + alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, upper=0.3) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.max(), 0.3) - - alg = SIRT(initial=self.initial2, operator=self.A2, - data=self.b2, max_iteration=20, lower=0.7) + np.testing.assert_almost_equal(alg.solution.max(), 0.3) + + alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, lower=0.7) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.min(), 0.7) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2, - max_iteration=20, constraint=IndicatorBox(lower=0.1, upper=0.3)) + np.testing.assert_almost_equal(alg.solution.min(), 0.7) + + alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, constraint=IndicatorBox(lower=0.1, upper=0.3)) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.max(), 0.3) - np.testing.assert_almost_equal(alg.solution.min(), 0.1) + np.testing.assert_almost_equal(alg.solution.max(), 0.3) + np.testing.assert_almost_equal(alg.solution.min(), 0.1) + def test_SIRT_relaxation_parameter(self): tmp_initial = self.ig.allocate() - alg = SIRT(initial=tmp_initial, operator=self.Aop, - data=self.bop, max_iteration=5) - + alg = SIRT(initial = tmp_initial, operator=self.Aop, data=self.bop, max_iteration=5) + with self.assertRaises(ValueError): alg.set_relaxation_parameter(0) with self.assertRaises(ValueError): alg.set_relaxation_parameter(2) - alg = SIRT(initial=self.initial2, operator=self.A2, - data=self.b2, max_iteration=20) + + alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20) alg.set_relaxation_parameter(0.5) self.assertEqual(alg.relaxation_parameter, 0.5) alg.run(verbose=0) - np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) + np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) + + np.testing.assert_almost_equal(0.5 *alg.D.array, alg._Dscaled.array) - np.testing.assert_almost_equal(0.5 * alg.D.array, alg._Dscaled.array) def test_SIRT_nan_inf_values(self): Aop_nan_inf = self.Aop - Aop_nan_inf.A[0:10, :] = 0. - Aop_nan_inf.A[:, 10:20] = 0. + Aop_nan_inf.A[0:10,:] = 0. + Aop_nan_inf.A[:,10:20] = 0. tmp_initial = self.ig.allocate() - sirt = SIRT(initial=tmp_initial, operator=Aop_nan_inf, - data=self.bop, max_iteration=5) - + sirt = SIRT(initial = tmp_initial, operator=Aop_nan_inf, data=self.bop, max_iteration=5) + self.assertFalse(np.any(sirt.M == inf)) - self.assertFalse(np.any(sirt.D == inf)) + self.assertFalse(np.any(sirt.D == inf)) + def test_SIRT_remove_nan_or_inf_with_BlockDataContainer(self): np.random.seed(10) # set up matrix, vectordata n, m = 50, 50 - A = np.random.uniform(0, 1, (m, n)).astype('float32') + A = np.random.uniform(0, 1,(m, n)).astype('float32') b = A.dot(np.random.randn(n)) - A[0:10, :] = 0. - A[:, 10:20] = 0. - Aop = BlockOperator(MatrixOperator(A*1), MatrixOperator(A*2)) - bop = BlockDataContainer(VectorData(b*1), VectorData(b*2)) - + A[0:10,:] = 0. + A[:,10:20] = 0. + Aop = BlockOperator( MatrixOperator(A*1), MatrixOperator(A*2) ) + bop = BlockDataContainer( VectorData(b*1), VectorData(b*2) ) + ig = BlockGeometry(self.ig.copy(), self.ig.copy()) tmp_initial = ig.allocate() - sirt = SIRT(initial=tmp_initial, operator=Aop, - data=bop, max_iteration=5) + sirt = SIRT(initial = tmp_initial, operator=Aop, data=bop, max_iteration=5) for el in sirt.M.containers: self.assertFalse(np.any(el == inf)) - + self.assertFalse(np.any(sirt.D == inf)) -class TestSPDHG(CCPiTestClass): - def setUp(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) - - self.subsets = 10 - - ig = data.geometry - ig.voxel_size_x = 0.1 - ig.voxel_size_y = 0.1 - - detectors = ig.shape[0] - angles = np.linspace(0, np.pi, 90) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) - # Select device - dev = 'cpu' - - Aop = ProjectionOperator(ig, ag, dev) - - sin = Aop.direct(data) - partitioned_data = sin.partition(self.subsets, 'sequential') - self.A = BlockOperator( - *[IdentityOperator(partitioned_data[i].geometry) for i in range(self.subsets)]) - self.A2 = BlockOperator( - *[IdentityOperator(partitioned_data[i].geometry) for i in range(self.subsets)]) - - # block function - self.F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(self.subsets)]) - alpha = 0.025 - self.G = alpha * FGP_TV() - - def test_SPDHG_defaults_and_setters(self): - gamma = 1. - rho = .99 - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - - self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() - for i in range(self.subsets)]) - self.assertListEqual(spdhg.prob_weights, [ - 1/self.subsets] * self.subsets) - self.assertListEqual( - spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) - self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - self.assertNumpyArrayEqual( - spdhg.x.array, self.A.domain_geometry().allocate(0).array) - self.assertEqual(spdhg.max_iteration, 0) - self.assertEqual(spdhg.update_objective_interval, 1) - - gamma = 3.7 - rho = 5.6 - spdhg.set_step_sizes_from_ratio(gamma, rho) - self.assertListEqual( - spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) - self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - - gamma = 1. - rho = .99 - spdhg.set_step_sizes() - self.assertListEqual( - spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) - self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - - spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) - self.assertListEqual(spdhg.sigma, [1]*self.subsets) - self.assertEqual(spdhg.tau, 100) - - spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) - self.assertListEqual(spdhg.sigma, [1]*self.subsets) - self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) - - spdhg.set_step_sizes(sigma=None, tau=100) - self.assertListEqual(spdhg.sigma, [ - gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)]) - self.assertEqual(spdhg.tau, 100) - - def test_spdhg_non_default_init(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.)), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - - self.assertListEqual(spdhg.prob_weights, list(np.arange(1, 11)/55.)) - self.assertNumpyArrayEqual( - spdhg.x.array, self.A.domain_geometry().allocate(1).array) - self.assertEqual(spdhg.max_iteration, 1000) - self.assertEqual(spdhg.update_objective_interval, 10) - - def test_spdhg_deprecated_vargs(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[ - 1]*len(self.A), prob=[1/(self.subsets-1)]*(self.subsets-1)+[0]) - - self.assertListEqual(self.A.get_norms_as_list(), [1]*len(self.A)) - self.assertListEqual(spdhg.norms, [1]*len(self.A)) - self.assertListEqual(spdhg._sampler.prob_weights, [ - 1/(self.subsets-1)]*(self.subsets-1)+[0]) - self.assertListEqual(spdhg.prob_weights, [ - 1/(self.subsets-1)]*(self.subsets-1)+[0]) - - with self.assertRaises(TypeError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( - self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) - - with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, norms=[ - 1]*len(self.A), sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) - - - def test_spdhg_set_norms(self): - - self.A2.set_norms([1]*len(self.A2)) - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A2) - self.assertListEqual(spdhg.norms, [1]*len(self.A2)) - - def test_spdhg_check_convergence(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - - self.assertTrue(spdhg.check_convergence()) - - gamma = 3.7 - rho = 0.9 - spdhg.set_step_sizes_from_ratio(gamma, rho) - self.assertTrue(spdhg.check_convergence()) - - gamma = 3.7 - rho = 100 - spdhg.set_step_sizes_from_ratio(gamma, rho) - self.assertFalse(spdhg.check_convergence()) - - spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) - self.assertFalse(spdhg.check_convergence()) - - spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) - self.assertTrue(spdhg.check_convergence()) - - spdhg.set_step_sizes(sigma=None, tau=100) - self.assertTrue(spdhg.check_convergence()) - - def test_SPDHG_num_subsets_1(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(10, 10)) - - subsets = 1 - - ig = data.geometry - ig.voxel_size_x = 0.1 - ig.voxel_size_y = 0.1 - - detectors = ig.shape[0] - angles = np.linspace(0, np.pi, 90) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) - # Select device - dev = 'cpu' - - Aop = ProjectionOperator(ig, ag, dev) - - sin = Aop.direct(data) - partitioned_data = sin.partition(subsets, 'sequential') - A = BlockOperator( - *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) - - # block function - F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(subsets)]) - alpha = 0.025 - G = alpha * FGP_TV() - - spdhg = SPDHG(f=F, g=G, operator=A, max_iteration=10, update_objective_interval=10, print_interval=10, log_file=None) - - spdhg.run(7) - pdhg = PDHG(f=F, g=G, operator=A, max_iteration=10, update_objective_interval=10, print_interval=10, log_file=None) - - pdhg.run(7) - self.assertNumpyArrayAlmostEqual(pdhg.solution.as_array(), spdhg.solution.as_array(), decimal=3) +class TestSPDHG(unittest.TestCase): @unittest.skipUnless(has_astra, "cil-astra not available") - def test_SPDHG_vs_PDHG_implicit(self): - - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12, 12)) + def test_SPDHG_vs_PDHG_implicit(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 90) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) + ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) # Select device dev = 'cpu' - + Aop = ProjectionOperator(ig, ag, dev) - + sin = Aop.direct(data) # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] @@ -973,100 +797,91 @@ def test_SPDHG_vs_PDHG_implicit(self): np.random.seed(10) scale = 20 eta = 0 - noisy_data.fill(np.random.poisson( - scale * (eta + sin.as_array()))/scale) + noisy_data.fill(np.random.poisson(scale * (eta + sin.as_array()))/scale) elif noise == 'gaussian': np.random.seed(10) - n1 = np.random.normal(0, 0.1, size=ag.shape) - noisy_data.fill(n1 + sin.as_array()) + n1 = np.random.normal(0, 0.1, size = ag.shape) + noisy_data.fill(n1 + sin.as_array()) else: raise ValueError('Unsupported Noise ', noise) - + # Create BlockOperator - operator = Aop - f = KullbackLeibler(b=noisy_data) + operator = Aop + f = KullbackLeibler(b=noisy_data) alpha = 0.005 g = alpha * TotalVariation(50, 1e-4, lower=0, warm_start=True) normK = operator.norm() - - # % 'implicit' PDHG, preconditioned step-sizes + + #% 'implicit' PDHG, preconditioned step-sizes tau_tmp = 1. sigma_tmp = 1. - tau = sigma_tmp / \ - operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) - sigma = tau_tmp / \ - operator.direct( - sigma_tmp * operator.domain_geometry().allocate(1.)) - + tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) + sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) + # Setup and run the PDHG algorithm - pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - max_iteration=80, - update_objective_interval=1000) + pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, + max_iteration = 1000, + update_objective_interval = 500) pdhg.run(verbose=0) - - subsets = 5 + + subsets = 10 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] - for i in range(0, len(angles), size_of_subsets)] + list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) - for i in range(subsets)]) - # number of subsets - # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)]) + ## number of subsets + #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) # - # acquisisiton data + ## acquisisiton data AD_list = [] for sub_num in range(subsets): for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets, :] - AD_list.append(AcquisitionData( - arr, geometry=list_geoms[sub_num])) + arr = noisy_data.as_array()[i:i+size_of_subsets,:] + AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) g = BlockDataContainer(*AD_list) - ## block function F = BlockFunction(*[KullbackLeibler(b=g[i]) for i in range(subsets)]) G = alpha * TotalVariation(50, 1e-4, lower=0, warm_start=True) + prob = [1/len(A)]*len(A) - - spdhg = SPDHG(f=F, g=G, operator=A, - max_iteration=250, sampler=Sampler.random_with_replacement(len(A), seed=2), - update_objective_interval=1000) + spdhg = SPDHG(f=F,g=G,operator=A, + max_iteration = 1000, + update_objective_interval=200, prob = prob) spdhg.run(1000, verbose=0) - qm = (mae(spdhg.get_output(), pdhg.get_output()), - mse(spdhg.get_output(), pdhg.get_output()), - psnr(spdhg.get_output(), pdhg.get_output()) - ) - logging.info("Quality measures {}".format(qm)) - - np.testing.assert_almost_equal(mae(spdhg.get_output(), pdhg.get_output()), - 0.000335, decimal=3) - np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), - 5.51141e-06, decimal=3) + mse(spdhg.get_output(), pdhg.get_output()), + psnr(spdhg.get_output(), pdhg.get_output()) + ) + logging.info ("Quality measures {}".format(qm)) + + np.testing.assert_almost_equal( mae(spdhg.get_output(), pdhg.get_output()), + 0.000335, decimal=3) + np.testing.assert_almost_equal( mse(spdhg.get_output(), pdhg.get_output()), + 5.51141e-06, decimal=3) + @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16, 16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) + ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) # Select device dev = 'cpu' Aop = ProjectionOperator(ig, ag, dev) - + sin = Aop.direct(data) # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] @@ -1079,83 +894,242 @@ def test_SPDHG_vs_PDHG_explicit(self): # eta = 0 # noisy_data = AcquisitionData(np.random.poisson( scale * (eta + sin.as_array()))/scale, ag) elif noise == 'gaussian': - noisy_data = noise.gaussian(sin, var=0.1, seed=10) + noisy_data = noise.gaussian(sin, var=0.1, seed=10) else: raise ValueError('Unsupported Noise ', noise) - - # %% 'explicit' SPDHG, scalar step-sizes - subsets = 5 + + #%% 'explicit' SPDHG, scalar step-sizes + subsets = 10 size_of_subsets = int(len(angles)/subsets) # create Gradient operator op1 = GradientOperator(ig) # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] - for i in range(0, len(angles), size_of_subsets)] + list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) - for i in range(subsets)] + [op1]) - # number of subsets - # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)] + [op1]) + ## number of subsets + #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) # - # acquisisiton data + ## acquisisiton data AD_list = [] for sub_num in range(subsets): for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets, :] - AD_list.append(AcquisitionData( - arr, geometry=list_geoms[sub_num])) + arr = noisy_data.as_array()[i:i+size_of_subsets,:] + AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) g = BlockDataContainer(*AD_list) alpha = 0.5 - # block function - F = BlockFunction(*[*[KullbackLeibler(b=g[i]) - for i in range(subsets)] + [alpha * MixedL21Norm()]]) + ## block function + F = BlockFunction(*[*[KullbackLeibler(b=g[i]) for i in range(subsets)] + [alpha * MixedL21Norm()]]) G = IndicatorBox(lower=0) prob = [1/(2*subsets)]*(len(A)-1) + [1/2] - spdhg = SPDHG(f=F, g=G, operator=A, - max_iteration=300, - update_objective_interval=300, sampler=Sampler.random_with_replacement(len(A), prob=prob, seed=10)) - + spdhg = SPDHG(f=F,g=G,operator=A, + max_iteration = 1000, + update_objective_interval=200, prob = prob) spdhg.run(1000, verbose=0) - # %% 'explicit' PDHG, scalar step-sizes + #%% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) op2 = Aop # Create BlockOperator - operator = BlockOperator(op1, op2, shape=(2, 1)) - f2 = KullbackLeibler(b=noisy_data) - g = IndicatorBox(lower=0) + operator = BlockOperator(op1, op2, shape=(2,1) ) + f2 = KullbackLeibler(b=noisy_data) + g = IndicatorBox(lower=0) normK = operator.norm() sigma = 1/normK tau = 1/normK - - f1 = alpha * MixedL21Norm() - f = BlockFunction(f1, f2) + + f1 = alpha * MixedL21Norm() + f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm - pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma) - pdhg.max_iteration = 300 - pdhg.update_objective_interval = 300 - + pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg.max_iteration = 1000 + pdhg.update_objective_interval = 200 pdhg.run(1000, verbose=0) - # %% show diff between PDHG and SPDHG + #%% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() # plt.show() qm = (mae(spdhg.get_output(), pdhg.get_output()), - mse(spdhg.get_output(), pdhg.get_output()), - psnr(spdhg.get_output(), pdhg.get_output()) - ) + mse(spdhg.get_output(), pdhg.get_output()), + psnr(spdhg.get_output(), pdhg.get_output()) + ) logging.info("Quality measures {}".format(qm)) - np.testing.assert_almost_equal(mae(spdhg.get_output(), pdhg.get_output()), - 0.00150, decimal=3) - np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), - 1.68590e-05, decimal=3) + np.testing.assert_almost_equal( mae(spdhg.get_output(), pdhg.get_output()), + 0.00150 , decimal=3) + np.testing.assert_almost_equal( mse(spdhg.get_output(), pdhg.get_output()), + 1.68590e-05, decimal=3) + + + @unittest.skipUnless(has_astra, "ccpi-astra not available") + def test_SPDHG_vs_SPDHG_explicit_axpby(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128), dtype=numpy.float32) + + ig = data.geometry + ig.voxel_size_x = 0.1 + ig.voxel_size_y = 0.1 + + detectors = ig.shape[0] + angles = np.linspace(0, np.pi, 180) + ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + dev = 'cpu' + + Aop = ProjectionOperator(ig, ag, dev) + + sin = Aop.direct(data) + # Create noisy data. Apply Gaussian noise + noises = ['gaussian', 'poisson'] + noise = noises[1] + if noise == 'poisson': + np.random.seed(10) + scale = 5 + eta = 0 + noisy_data = AcquisitionData(np.asarray( + np.random.poisson( scale * (eta + sin.as_array()))/scale, + dtype=np.float32 + ), + geometry=ag + ) + elif noise == 'gaussian': + np.random.seed(10) + n1 = np.asarray(np.random.normal(0, 0.1, size = ag.shape), dtype=np.float32) + noisy_data = AcquisitionData(n1 + sin.as_array(), geometry=ag) + + else: + raise ValueError('Unsupported Noise ', noise) + + #%% 'explicit' SPDHG, scalar step-sizes + subsets = 10 + size_of_subsets = int(len(angles)/subsets) + # create GradientOperator operator + op1 = GradientOperator(ig) + # take angles and create uniform subsets in uniform+sequential setting + list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] + # create acquisitioin geometries for each the interval of splitting angles + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] + # create with operators as many as the subsets + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)] + [op1]) + ## number of subsets + #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + # + ## acquisisiton data + ## acquisisiton data + AD_list = [] + for sub_num in range(subsets): + for i in range(0, len(angles), size_of_subsets): + arr = noisy_data.as_array()[i:i+size_of_subsets,:] + AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) + + g = BlockDataContainer(*AD_list) + + alpha = 0.5 + ## block function + F = BlockFunction(*[*[KullbackLeibler(b=g[i]) for i in range(subsets)] + [alpha * MixedL21Norm()]]) + G = IndicatorBox(lower=0) + + prob = [1/(2*subsets)]*(len(A)-1) + [1/2] + algos = [] + algos.append( SPDHG(f=F,g=G,operator=A, + max_iteration = 1000, + update_objective_interval=200, prob = prob.copy(), use_axpby=True) + ) + algos[0].run(1000, verbose=0) + + algos.append( SPDHG(f=F,g=G,operator=A, + max_iteration = 1000, + update_objective_interval=200, prob = prob.copy(), use_axpby=False) + ) + algos[1].run(1000, verbose=0) + + + # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) + qm = (mae(algos[0].get_output(), algos[1].get_output()), + mse(algos[0].get_output(), algos[1].get_output()), + psnr(algos[0].get_output(), algos[1].get_output()) + ) + logging.info ("Quality measures {}".format(qm)) + assert qm[0] < 0.005 + assert qm[1] < 3.e-05 + + + @unittest.skipUnless(has_astra, "ccpi-astra not available") + def test_PDHG_vs_PDHG_explicit_axpby(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + ig = data.geometry + ig.voxel_size_x = 0.1 + ig.voxel_size_y = 0.1 + + detectors = ig.shape[0] + angles = np.linspace(0, np.pi, 180) + ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + + dev = 'cpu' + + Aop = ProjectionOperator(ig, ag, dev) + + sin = Aop.direct(data) + + # Create noisy data. Apply Gaussian noise + noises = ['gaussian', 'poisson'] + noise = noises[1] + if noise == 'poisson': + np.random.seed(10) + scale = 5 + eta = 0 + noisy_data = AcquisitionData(numpy.asarray(np.random.poisson( scale * (eta + sin.as_array())),dtype=numpy.float32)/scale, geometry=ag) + + elif noise == 'gaussian': + np.random.seed(10) + n1 = np.random.normal(0, 0.1, size = ag.shape) + noisy_data = AcquisitionData(numpy.asarray(n1 + sin.as_array(), dtype=numpy.float32), geometry=ag) + + else: + raise ValueError('Unsupported Noise ', noise) + + + alpha = 0.5 + op1 = GradientOperator(ig) + op2 = Aop + # Create BlockOperator + operator = BlockOperator(op1, op2, shape=(2,1) ) + f2 = KullbackLeibler(b=noisy_data) + g = IndicatorBox(lower=0) + normK = operator.norm() + sigma = 1./normK + tau = 1./normK + + f1 = alpha * MixedL21Norm() + f = BlockFunction(f1, f2) + # Setup and run the PDHG algorithm + + algos = [] + algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, + max_iteration = 1000, + update_objective_interval=200, use_axpby=True) + ) + algos[0].run(1000, verbose=0) + + algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, + max_iteration = 1000, + update_objective_interval=200, use_axpby=False) + ) + algos[1].run(1000, verbose=0) + + qm = (mae(algos[0].get_output(), algos[1].get_output()), + mse(algos[0].get_output(), algos[1].get_output()), + psnr(algos[0].get_output(), algos[1].get_output()) + ) + logging.info ("Quality measures {}".format(qm)) + np.testing.assert_array_less( qm[0], 0.005 ) + np.testing.assert_array_less( qm[1], 3e-05) + class PrintAlgo(Algorithm): @@ -1164,9 +1138,11 @@ def __init__(self, **kwargs): # self.update_objective() self.configured = True + def update(self): self.x = - self.iteration time.sleep(0.01) + def update_objective(self): self.loss.append(self.iteration * self.iteration) @@ -1174,61 +1150,63 @@ def update_objective(self): class TestPrint(unittest.TestCase): def test_print(self): - def callback(iteration, objective, solution): + def callback (iteration, objective, solution): print("I am being called ", iteration) - algo = PrintAlgo(update_objective_interval=10, max_iteration=1000) + algo = PrintAlgo(update_objective_interval = 10, max_iteration = 1000) - algo.run(20, verbose=2, print_interval=2) + algo.run(20, verbose=2, print_interval = 2) # it 0 - # it 10 + # it 10 # it 20 # --- stop - algo.run(3, verbose=1, print_interval=2) + algo.run(3, verbose=1, print_interval = 2) # it 20 # --- stop - - algo.run(20, verbose=1, print_interval=7) + + algo.run(20, verbose=1, print_interval = 7) # it 20 # it 30 # -- stop - + algo.run(20, verbose=1, very_verbose=False) algo.run(20, verbose=2, print_interval=7, callback=callback) - + logging.info(algo._iteration) logging.info(algo.objective) - np.testing.assert_array_equal( - [-1, 10, 20, 30, 40, 50, 60, 70, 80], algo.iterations) - np.testing.assert_array_equal( - [1, 100, 400, 900, 1600, 2500, 3600, 4900, 6400], algo.objective) + np.testing.assert_array_equal([-1, 10, 20, 30, 40, 50, 60, 70, 80], algo.iterations) + np.testing.assert_array_equal([1, 100, 400, 900, 1600, 2500, 3600, 4900, 6400], algo.objective) + def test_print2(self): - algo = PrintAlgo(update_objective_interval=4, max_iteration=1000) + algo = PrintAlgo(update_objective_interval = 4, max_iteration = 1000) algo.run(10, verbose=2, print_interval=2) - logging.info(algo.iteration) + logging.info (algo.iteration) algo.run(10, verbose=2, print_interval=2) logging.info("{} {}".format(algo._iteration, algo.objective)) - algo = PrintAlgo(update_objective_interval=4, max_iteration=1000) + algo = PrintAlgo(update_objective_interval = 4, max_iteration = 1000) algo.run(20, verbose=2, print_interval=2) + class TestADMM(unittest.TestCase): def setUp(self): - ig = ImageGeometry(2, 3, 2) + ig = ImageGeometry(2,3,2) data = ig.allocate(1, dtype=np.float32) noisy_data = data+1 - + # TV regularisation parameter self.alpha = 1 - self.fidelities = [0.5 * L2NormSquared(b=noisy_data), L1Norm(b=noisy_data), - KullbackLeibler(b=noisy_data, backend="numpy")] + + + self.fidelities = [ 0.5 * L2NormSquared(b=noisy_data), L1Norm(b=noisy_data), + KullbackLeibler(b=noisy_data, backend="numpy")] F = self.alpha * MixedL21Norm() K = GradientOperator(ig) - + # Compute operator Norm normK = K.norm() @@ -1238,40 +1216,44 @@ def setUp(self): self.F = F self.K = K + def test_ADMM_L2(self): self.do_test_with_fidelity(self.fidelities[0]) + def test_ADMM_L1(self): self.do_test_with_fidelity(self.fidelities[1]) + def test_ADMM_KL(self): self.do_test_with_fidelity(self.fidelities[2]) + def do_test_with_fidelity(self, fidelity): alpha = self.alpha # F = BlockFunction(alpha * MixedL21Norm(),fidelity) - + G = fidelity K = self.K F = self.F admm = LADMM(f=G, g=F, operator=K, tau=self.tau, sigma=self.sigma, - max_iteration=100, update_objective_interval=10) + max_iteration = 100, update_objective_interval = 10) admm.run(1, verbose=0) admm_noaxpby = LADMM(f=G, g=F, operator=K, tau=self.tau, sigma=self.sigma, - max_iteration=100, update_objective_interval=10, use_axpby=False) + max_iteration = 100, update_objective_interval = 10, use_axpby=False) admm_noaxpby.run(1, verbose=0) + + np.testing.assert_array_almost_equal(admm.solution.as_array(), admm_noaxpby.solution.as_array()) - np.testing.assert_array_almost_equal( - admm.solution.as_array(), admm_noaxpby.solution.as_array()) def test_compare_with_PDHG(self): - # Load an image from the CIL gallery. - data = dataexample.SHAPES.get(size=(64, 64)) - ig = data.geometry + # Load an image from the CIL gallery. + data = dataexample.SHAPES.get(size=(64,64)) + ig = data.geometry # Add gaussian noise - noisy_data = applynoise.gaussian(data, seed=10, var=0.0005) + noisy_data = applynoise.gaussian(data, seed = 10, var = 0.0005) # TV regularisation parameter alpha = 0.1 @@ -1281,7 +1263,7 @@ def test_compare_with_PDHG(self): fidelity = KullbackLeibler(b=noisy_data, backend="numpy") # Setup and run the PDHG algorithm - F = BlockFunction(alpha * MixedL21Norm(), fidelity) + F = BlockFunction(alpha * MixedL21Norm(),fidelity) G = ZeroFunction() K = BlockOperator(GradientOperator(ig), IdentityOperator(ig)) @@ -1293,14 +1275,14 @@ def test_compare_with_PDHG(self): tau = 1./normK pdhg = PDHG(f=F, g=G, operator=K, tau=tau, sigma=sigma, - max_iteration=500, update_objective_interval=10) + max_iteration = 500, update_objective_interval = 10) pdhg.run(verbose=0) sigma = 1 tau = sigma/normK**2 admm = LADMM(f=G, g=F, operator=K, tau=tau, sigma=sigma, - max_iteration=500, update_objective_interval=10) + max_iteration = 500, update_objective_interval = 10) admm.run(verbose=0) - np.testing.assert_almost_equal( - admm.solution.array, pdhg.solution.array, decimal=3) + np.testing.assert_almost_equal(admm.solution.array, pdhg.solution.array, decimal=3) + diff --git a/Wrappers/Python/test/test_functions.py b/Wrappers/Python/test/test_functions.py index 931feac8d1..7f626d6903 100644 --- a/Wrappers/Python/test/test_functions.py +++ b/Wrappers/Python/test/test_functions.py @@ -22,12 +22,11 @@ from cil.optimisation.functions.Function import ScaledFunction import numpy as np - -from cil.framework import DataContainer, ImageGeometry, \ - VectorGeometry, VectorData, BlockDataContainer, AcquisitionData, AcquisitionGeometry +from cil.framework import ImageGeometry, \ + VectorGeometry, VectorData, BlockDataContainer, DataContainer from cil.optimisation.operators import IdentityOperator, MatrixOperator, CompositionOperator, DiagonalOperator, BlockOperator from cil.optimisation.functions import Function, KullbackLeibler, ConstantFunction, TranslateFunction, soft_shrinkage -from cil.optimisation.operators import GradientOperator, BlockOperator +from cil.optimisation.operators import GradientOperator from cil.optimisation.functions import Function, KullbackLeibler, WeightedL2NormSquared, L2NormSquared,\ L1Norm, MixedL21Norm, LeastSquares, \ @@ -36,9 +35,6 @@ WeightedL2NormSquared from cil.optimisation.functions import BlockFunction - - - import numpy import scipy.special @@ -53,13 +49,10 @@ from cil.utilities.quality_measures import mae import cil.utilities.multiprocessing as cilmp -from utils import has_ccpi_regularisation, has_tomophantom, has_numba, has_astra, initialise_tests +from utils import has_ccpi_regularisation, has_tomophantom, has_numba, initialise_tests import numba - -from testclass import CCPiTestClass from numbers import Number - initialise_tests() if has_ccpi_regularisation: @@ -71,9 +64,6 @@ if has_numba: from cil.optimisation.functions.MixedL21Norm import _proximal_step_numba, _proximal_step_numpy -if has_astra: - from cil.plugins.astra import ProjectionOperator - class TestFunction(CCPiTestClass): @@ -2018,4 +2008,3 @@ def test_set_num_threads(self): N = 10 ib.set_num_threads(N) assert ib.num_threads == N - diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index f368247b27..40f780b8bf 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -32,7 +32,6 @@ class TestSamplers(CCPiTestClass): def example_function(self, iteration_number): - return ((iteration_number+5) % 50) def test_init_Sampler(self): diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 51f895ed84..8ef8c9841e 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -407,6 +407,7 @@ In addition, we provide a random sampling class which is a child class of `cil. + Block Framework *************** From d383733c0f4741cd4117cd73c33f6c41a4abc820 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 25 Jan 2024 14:45:25 +0000 Subject: [PATCH 119/152] Tidy up PR --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index f62372480d..37efd460b8 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -19,14 +19,9 @@ # Claire Delplancke (University of Bath) from cil.optimisation.algorithms import Algorithm -from cil.optimisation.operators import BlockOperator import numpy as np import warnings import logging -from cil.optimisation.utilities import Sampler -from numbers import Number -import numpy as np - class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -55,12 +50,8 @@ class SPDHG(Algorithm): List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class - Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets **kwargs: - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats precalculated list of norms of the operators @@ -119,7 +110,6 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ initial=None, prob=None, gamma=1., norms=None): '''set-up of the algorithm - Parameters ---------- f : BlockFunction From 470ed86b73bd1f4de33cb69987d0300b06e02a08 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 25 Jan 2024 17:11:47 +0000 Subject: [PATCH 120/152] Updated doc strings and requirements for sampler class - need to do documentation --- .../ApproximateGradientSumFunction.py | 71 +++++++++++++++---- .../cil/optimisation/functions/SGFunction.py | 18 ++--- .../Python/test/test_approximate_gradient.py | 12 +++- 3 files changed, 78 insertions(+), 23 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index c9d4896ceb..468f0ffdd6 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -28,25 +28,27 @@ class ApproximateGradientSumFunction(SumFunction, ABC): .. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) - where :math:`n` is the number of functions. It is an abstract base class and any child classes must implement an `approximate_gradient` function. + where :math:`n` is the number of functions. The gradient method from a CIL function is overwritten and calls an approximate gradient method. + + It is an abstract base class and any child classes must implement an `approximate_gradient` function. Parameters: ----------- functions : `list` of functions A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. - sampler: An instance of one of the :meth:`~optimisation.utilities.sampler` classes which has a `next` function implemented and a `num_indices` property. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {1,...,n}. This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. Note ---- - The :meth:`~ApproximateGradientSumFunction.gradient` returns the approximate gradient depending on an index provided by the :code:`sampler` method. Example ------- - + Consider the objective is to minimise: + .. math:: \sum_{i=1}^{n} F_{i}(x) = \sum_{i=1}^{n}\|A_{i} x - b_{i}\|^{2} >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) @@ -68,10 +70,6 @@ def __init__(self, functions, sampler =None): raise TypeError("Input to functions should be a list of functions") if not hasattr(sampler, "next"): raise ValueError('The provided sampler must have a `next` method') - if not hasattr(sampler, "num_indices"): - raise ValueError('The provided sampler must store the `num_indices` it samples from') - if sampler.num_indices !=len(functions): - raise ValueError('The sampler should choose from the same number of indices as there are functions passed to this approximate gradient method') self.sampler = sampler @@ -83,7 +81,16 @@ def __call__(self, x): r"""Returns the value of the sum of functions at :math:`x`. .. math:: (F_{1} + F_{2} + ... + F_{n})(x) = F_{1}(x) + F_{2}(x) + ... + F_{n}(x) - + + Parameters + ---------- + x : DataContainer + + -------- + float + the value of the SumFunction at x + + """ return super(ApproximateGradientSumFunction, self).__call__(x) @@ -92,18 +99,56 @@ def full_gradient(self, x, out=None): .. math:: \nabla_x(F_{1} + F_{2} + ... + F_{n})(x) = \nabla_xF_{1}(x) + \nabla_xF_{2}(x) + ... + \nabla_xF_{n}(x) - """ + Parameters + ---------- + x : DataContainer + out: return DataContainer, if `None` a new DataContainer is returned, default `None`. + + Returns + -------- + DataContainer + the value of the gradient of the sum function at x or nothing if `out` + """ + return super(ApproximateGradientSumFunction, self).gradient(x, out=out) - + @abstractmethod def approximate_gradient(self, x, function_num, out=None): - """ Computes the approximate gradient for each selected function at :code:`x`.""" + """ Computes the approximate gradient for each selected function at :code:`x` given a `function_number` in {1,...,len(functions)}. + + Parameters + ---------- + x : DataContainer + out: return DataContainer, if `None` a new DataContainer is returned, default `None`. + function_num: `int` + Between 1 and the number of functions in the list + Returns + -------- + DataContainer + the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {1,...,len(functions)} or nothing if `out` + """ pass def gradient(self, x, out=None): - """ Selects a random function using the `sampler` and then calls the approximate gradient at :code:`x`.""" + """ Selects a random function using the `sampler` and then calls the approximate gradient at :code:`x` + + Parameters + ---------- + x : DataContainer + out: return DataContainer, if `None` a new DataContainer is returned, default `None`. + + Returns + -------- + DataContainer + the value of the approximate gradient of the sum function at :code:`x` or nothing if `out` + """ + self.function_num = self.sampler.next() + if self.function_num>self.num_functions: + raise IndexError( + 'The sampler has outputted an index larger than the number of functions to sample from. Please ensure your sampler samples from {1,2,...,len(functions)} only.') + if isinstance(self.function_num, numbers.Number): return self.approximate_gradient(x, self.function_num, out=out) else: diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index c298d87ea0..a3aee88da4 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -24,11 +24,11 @@ class SGFunction(ApproximateGradientSumFunction): Stochastic gradient function, a child class of `ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_1,...,f_n}` a `SumFunction`, :math:`f_1+...+f_n` where each time the `gradient` is called, the `sampler` provides an index, :math:`i \in {1,...,n}` and the gradient function returns the approximate gradient :math:`n\nabla_xf_i(x)`. This can be used with the `cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. - Parameters: + Parameters: ----------- functions : `list` of functions A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. - sampler: An instance of one of the :meth:`~optimisation.utilities.sampler` classes which has a `next` function implemented and a `num_indices` property. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {1,...,n}. This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. """ @@ -40,19 +40,21 @@ def __init__(self, functions, sampler=None): def approximate_gradient(self, x, function_num, out=None): - """ Returns the gradient of the selected function or batch of functions at :code:`x`. - The function num is selected using the :meth:`~ApproximateGradientSumFunction.next_function`. + r""" Returns the gradient of the function at index `function_num` at :code:`x`. Parameters ---------- - x: element in the domain of the `functions` - + x : DataContainer + out: return DataContainer, if `None` a new DataContainer is returned, default `None`. function_num: `int` Between 1 and the number of functions in the list + Returns + -------- + DataContainer + the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {1,...,len(functions)} or nothing if `out` + """ - - """ # flag to return or in-place computation should_return=False diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index cd5f408b58..7b03de0eff 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -17,7 +17,7 @@ # Authors: # CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt -#TODO: remove unused packages + import unittest from utils import initialise_tests @@ -31,7 +31,6 @@ from cil.optimisation.functions import LeastSquares from cil.optimisation.functions import ApproximateGradientSumFunction from cil.optimisation.functions import SGFunction -from cil.optimisation.functions import SumFunction from cil.optimisation.operators import MatrixOperator from cil.optimisation.algorithms import GD from cil.framework import VectorData @@ -124,6 +123,15 @@ def init(self): bad_sampler=bad_Sampler() with self.assertRaises(ValueError): SGFunction([self.f, self.f], bad_sampler) + + def test_sampler_out_of_range(self): + bad_sampler=Sampler.sequential(10) + f=SGFunction([self.f, self.f], bad_sampler) + with self.assertRaises(IndexError): + f.gradient(self.initial) + f.gradient(self.initial) + f.gradient(self.initial) + def test_SGD_simulated_parallel_beam_data(self): From 54cf27c46b9daf814ebdf21cf0471ba543e09205 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 26 Jan 2024 11:50:43 +0000 Subject: [PATCH 121/152] optimisation.rst updated to add in the new documentation --- docs/source/optimisation.rst | 66 ++++++++++++++++++++++++++++++++++-- 1 file changed, 64 insertions(+), 2 deletions(-) diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 8ef8c9841e..aaa967920b 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -33,8 +33,8 @@ The fundamental components are: -Algorithms -========== +Algorithms (Deterministic) +========================== A number of generic algorithm implementations are provided including Gradient Descent (GD), Conjugate Gradient Least Squares (CGLS), @@ -120,13 +120,75 @@ LADMM :members: :inherited-members: run, update_objective_interval, max_iteration + + +Algorithms (Stochastic) +======================== + +There are a growing range of Stochastic optimisation algorithms available with potential benefits of faster convergence in number of iterations or in computational cost. +This is an area of development for CIL. + + + SPDHG ----- +Stochastic PRimal Dual Hybrid Gradient (SPDHG) is a stochastic version of PDHG and deals with optimisation problems of the form: + + .. math:: + + \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) + +by passing a sampler (e.g. of the CIL Sampler class) each iteration considers just one index of the sum reducing computational cost. For more examples see our [user notebooks]( https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py). + + .. autoclass:: cil.optimisation.algorithms.SPDHG :members: :inherited-members: run, update_objective_interval, max_iteration +Approximate gradient sum function +---------------------------------- + +Alternatively, consider optimisation problems of the form: + +.. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) + +where :math:`n` is the number of functions. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. +Child classes of this abstract base class can define different approximate gradients with different mathematical properties. Combining these approximate gradients with deterministic optimisation algorithms +leads to different stochastic optimisation algorithms. + +For example in the following table, the left hand column has the approximate gradient function subclass, the header row has the optimisation algorithm and the body of the table has the resulting stochastic algorithm. + ++---------------+-------+------------+----------------+ +| | GD | ISTA | FISTA | ++---------------+-------+------------+----------------+ +| SGFunction | SGD | Prox-SGD | Acc-Prox-SGD | ++---------------+-------+------------+----------------+ +| SAGFunction | SAG | Prox-SAG | Acc-Prox-SAG | ++---------------+-------+------------+----------------+ +| SAGAFunction | SAGA | Prox-SAGA | Acc-Prox-SAGA | ++---------------+-------+------------+----------------+ +| SVRGFunction | SVRG | Prox-SVRG | Acc-Prox-SVRG | ++---------------+-------+------------+----------------+ +| LSVRGFunction | LSVRG | Prox-LSVRG | Acc-Prox-LSVRG | ++---------------+-------+------------+----------------+ + +\*In development + +The base class: + +.. autoclass:: cil.optimisation.functions.ApproximateGradientSumFunction + :members: + :inherited-members: + + +The currently provided child-classes: + +.. autoclass:: cil.optimisation.functions.SGFunction + :members: + :inherited-members: + + Operators ========= From 4c4a26cc69067ddebdc3865e9ce173279355ba92 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 12 Feb 2024 17:10:29 +0000 Subject: [PATCH 122/152] Changes after discussion with Edo and Kris --- .../functions/ApproximateGradientSumFunction.py | 10 ++++++++-- .../cil/optimisation/functions/SGFunction.py | 14 ++++++-------- Wrappers/Python/test/test_approximate_gradient.py | 2 ++ 3 files changed, 16 insertions(+), 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 468f0ffdd6..e52a716404 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -74,6 +74,9 @@ def __init__(self, functions, sampler =None): self.sampler = sampler self.num_functions = len(functions) + + self.data_passes=[] + super(ApproximateGradientSumFunction, self).__init__(*functions) @@ -151,5 +154,8 @@ def gradient(self, x, out=None): if isinstance(self.function_num, numbers.Number): return self.approximate_gradient(x, self.function_num, out=out) - else: - raise ValueError("Batch gradient is not yet implemented") + raise ValueError("Batch gradient is not yet implemented") + + + + \ No newline at end of file diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index a3aee88da4..f2ab26d107 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -35,8 +35,6 @@ class SGFunction(ApproximateGradientSumFunction): def __init__(self, functions, sampler=None): super(SGFunction, self).__init__(functions, sampler) - - def approximate_gradient(self, x, function_num, out=None): @@ -55,22 +53,22 @@ def approximate_gradient(self, x, function_num, out=None): """ - - # flag to return or in-place computation - should_return=False + try: + self.data_passes.append( + self.data_passes[-1] + 1./self.num_functions) + except IndexError: + self.data_passes.append(1./self.num_functions) # compute gradient of randomly selected(function_num) function if out is None: out = self.functions[function_num].gradient(x) - should_return=True else: self.functions[function_num].gradient(x, out = out) # scale wrt number of functions out*=self.num_functions - if should_return: - return out + return out diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 7b03de0eff..5aca8be833 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -149,6 +149,7 @@ def test_SGD_simulated_parallel_beam_data(self): objective_function=objective, update_objective_interval=500, step_size=1e-7, max_iteration =5000) alg_stochastic.run( self.n_subsets*50, verbose=0) + self.assertAlmostEqual(objective.data_passes[-1], self.n_subsets*50/5) self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) @@ -186,6 +187,7 @@ def test_SGD_toy_example(self): objective_function=stochastic_objective, update_objective_interval=1000, step_size=0.01, max_iteration =5000) alg_stochastic.run( 600, verbose=0) + self.assertAlmostEqual(stochastic_objective.data_passes[-1], 600/5) self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), b.as_array(),3) From c0643880505784539228cf69c8468f43985f2de9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 12 Feb 2024 18:04:32 +0000 Subject: [PATCH 123/152] Fixed merge error --- Wrappers/Python/test/test_approximate_gradient.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 5aca8be833..ec506ab0e9 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -31,7 +31,7 @@ from cil.optimisation.functions import LeastSquares from cil.optimisation.functions import ApproximateGradientSumFunction from cil.optimisation.functions import SGFunction -from cil.optimisation.operators import MatrixOperator +from cil.optimisation.operators import MatrixOperator, ProjectionOperator from cil.optimisation.algorithms import GD from cil.framework import VectorData from cil.optimisation.utilities import Sampler, SamplerRandom From 4b97d9b531cc54b4450740d51b85da5c347c74d3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 13 Feb 2024 09:42:09 +0000 Subject: [PATCH 124/152] Fixed merge error --- Wrappers/Python/test/test_approximate_gradient.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index ec506ab0e9..5aca8be833 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -31,7 +31,7 @@ from cil.optimisation.functions import LeastSquares from cil.optimisation.functions import ApproximateGradientSumFunction from cil.optimisation.functions import SGFunction -from cil.optimisation.operators import MatrixOperator, ProjectionOperator +from cil.optimisation.operators import MatrixOperator from cil.optimisation.algorithms import GD from cil.framework import VectorData from cil.optimisation.utilities import Sampler, SamplerRandom From f41ae7bd9dd726a933f8f6159d20ec58d15d21e9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 13 Feb 2024 10:21:57 +0000 Subject: [PATCH 125/152] Added skip astra --- Wrappers/Python/test/test_approximate_gradient.py | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 5aca8be833..1532ae8067 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -70,7 +70,7 @@ def test_ABC(self): class TestSGD(CCPiTestClass): - + @unittest.skipUnless(has_astra, "Requires ASTRA") def setUp(self): self.sampler=Sampler.random_with_replacement(5) self.data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() @@ -91,31 +91,38 @@ def setUp(self): self.f_stochastic=SGFunction(self.f_subsets,self.sampler) self.initial=ig2D.allocate() + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_approximate_gradient(self): #Test when we the approximate gradient is not equal to the full gradient self.assertFalse((self.f_stochastic.full_gradient(self.initial)==self.f_stochastic.gradient(self.initial).array).all()) + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_sampler(self): self.assertTrue(isinstance(self.f_stochastic.sampler, SamplerRandom)) f=SGFunction(self.f_subsets) self.assertTrue(isinstance( f.sampler, SamplerRandom)) self.assertEqual(f.sampler._type, 'random_with_replacement') + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_direct(self): self.assertAlmostEqual(self.f_stochastic(self.initial), self.f(self.initial),1) + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_full_gradient(self): self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient(self.initial).array, self.f.gradient(self.initial).array,2) + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_value_error_with_only_one_function(self): with self.assertRaises(ValueError): SGFunction([self.f], self.sampler) pass + + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_type_error_if_functions_not_a_list(self): with self.assertRaises(TypeError): SGFunction(self.f, self.sampler) - + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_sampler_without_next(self): class bad_Sampler(): def init(self): @@ -124,6 +131,7 @@ def init(self): with self.assertRaises(ValueError): SGFunction([self.f, self.f], bad_sampler) + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_sampler_out_of_range(self): bad_sampler=Sampler.sequential(10) f=SGFunction([self.f, self.f], bad_sampler) @@ -133,7 +141,7 @@ def test_sampler_out_of_range(self): f.gradient(self.initial) - + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_SGD_simulated_parallel_beam_data(self): rate = self.f.L From be753748aa4eed5bea21d303c730a9b3ab7cb907 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 13 Feb 2024 12:05:53 +0000 Subject: [PATCH 126/152] New data_passes function and getter --- .../ApproximateGradientSumFunction.py | 19 +++++++++++++++++-- .../cil/optimisation/functions/SGFunction.py | 6 +----- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index e52a716404..362c857bfc 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -75,7 +75,7 @@ def __init__(self, functions, sampler =None): self.num_functions = len(functions) - self.data_passes=[] + self._data_passes=[] super(ApproximateGradientSumFunction, self).__init__(*functions) @@ -157,5 +157,20 @@ def gradient(self, x, out=None): raise ValueError("Batch gradient is not yet implemented") + def _update_data_passes(self, value): + """ Internal function that updates the list which stores the data passes - \ No newline at end of file + Parameters + ---------- + value: float + + """ + try: + self._data_passes.append( + self._data_passes[-1] + value) + except IndexError: + self._data_passes.append(value) + + @property + def data_passes(self): + return self._data_passes \ No newline at end of file diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index f2ab26d107..7df7c30029 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -53,11 +53,7 @@ def approximate_gradient(self, x, function_num, out=None): """ - try: - self.data_passes.append( - self.data_passes[-1] + 1./self.num_functions) - except IndexError: - self.data_passes.append(1./self.num_functions) + self._update_data_passes(1/self.num_functions) # compute gradient of randomly selected(function_num) function if out is None: From 778c7c13f4761545386096f3579393982de2bc63 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 13 Feb 2024 12:07:27 +0000 Subject: [PATCH 127/152] New data_passes function and getter --- .../cil/optimisation/functions/ApproximateGradientSumFunction.py | 1 + 1 file changed, 1 insertion(+) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 362c857bfc..56f2201a03 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -163,6 +163,7 @@ def _update_data_passes(self, value): Parameters ---------- value: float + The additional proportion of the data that has been seen """ try: From 99905360b3608caca106639b4e0e0b062bcea954 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 13 Feb 2024 14:08:15 +0000 Subject: [PATCH 128/152] Rate to step_size --- Wrappers/Python/test/test_approximate_gradient.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 1532ae8067..105aa74382 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -144,10 +144,10 @@ def test_sampler_out_of_range(self): @unittest.skipUnless(has_astra, "Requires ASTRA") def test_SGD_simulated_parallel_beam_data(self): - rate = self.f.L + step_size = self.f.L alg = GD(initial=self.initial, objective_function=self.f, update_objective_interval=500, - rate=rate, alpha=1e8) + step_size=step_size, alpha=1e8) alg.max_iteration = 200 alg.run(verbose=0) @@ -176,11 +176,11 @@ def test_SGD_toy_example(self): else: objective+=LeastSquares(A, A.direct(b)) - rate = objective.L / 3. + step_size = objective.L / 3. alg = GD(initial=initial, objective_function=objective, update_objective_interval=1000, - rate=rate, atol=1e-9, rtol=1e-6) + step_size=step_size, atol=1e-9, rtol=1e-6) alg.max_iteration = 600 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) From 57b71e18045eb52e6aa687da39f1f5d7658acd8b Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 13 Feb 2024 14:15:57 +0000 Subject: [PATCH 129/152] Use backtracking in unit tests --- .../Python/test/test_approximate_gradient.py | 178 +++++++++--------- 1 file changed, 86 insertions(+), 92 deletions(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 105aa74382..2c818fafa0 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -26,180 +26,174 @@ from cil.framework import VectorData - from cil.utilities import dataexample from cil.optimisation.functions import LeastSquares from cil.optimisation.functions import ApproximateGradientSumFunction from cil.optimisation.functions import SGFunction from cil.optimisation.operators import MatrixOperator -from cil.optimisation.algorithms import GD +from cil.optimisation.algorithms import GD from cil.framework import VectorData from cil.optimisation.utilities import Sampler, SamplerRandom from testclass import CCPiTestClass -from utils import has_astra +from utils import has_astra initialise_tests() if has_astra: from cil.plugins.astra import ProjectionOperator + class TestApproximateGradientSumFunction(CCPiTestClass): def setUp(self): - self.sampler=Sampler.random_with_replacement(5) + self.sampler = Sampler.random_with_replacement(5) self.initial = VectorData(np.zeros(10)) - self.b = VectorData(np.random.normal(0,1,10)) - self.functions=[] + self.b = VectorData(np.random.normal(0, 1, 10)) + self.functions = [] for i in range(5): - diagonal=np.zeros(10) - diagonal[2*i:2*(i+1)]=1 - A=MatrixOperator(np.diag(diagonal)) - self.functions.append( LeastSquares(A, A.direct(self.b))) - if i==0: - self.objective=LeastSquares(A, A.direct(self.b)) + diagonal = np.zeros(10) + diagonal[2*i:2*(i+1)] = 1 + A = MatrixOperator(np.diag(diagonal)) + self.functions.append(LeastSquares(A, A.direct(self.b))) + if i == 0: + self.objective = LeastSquares(A, A.direct(self.b)) else: - self.objective+=LeastSquares(A, A.direct(self.b)) - + self.objective += LeastSquares(A, A.direct(self.b)) + def test_ABC(self): with self.assertRaises(TypeError): - self.stochastic_objective=ApproximateGradientSumFunction(self.functions, self.sampler) - - - + self.stochastic_objective = ApproximateGradientSumFunction( + self.functions, self.sampler) class TestSGD(CCPiTestClass): @unittest.skipUnless(has_astra, "Requires ASTRA") def setUp(self): - self.sampler=Sampler.random_with_replacement(5) - self.data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() + self.sampler = Sampler.random_with_replacement(5) + self.data = dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() self.data.reorder('astra') - self.data2d=self.data.get_slice(vertical='centre') + self.data2d = self.data.get_slice(vertical='centre') ag2D = self.data2d.geometry ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') ig2D = ag2D.get_ImageGeometry() - self.A = ProjectionOperator(ig2D, ag2D, device = "cpu") + self.A = ProjectionOperator(ig2D, ag2D, device="cpu") self.n_subsets = 5 - self.partitioned_data=self.data2d.partition(self.n_subsets, 'sequential') - self.A_partitioned = ProjectionOperator(ig2D, self.partitioned_data.geometry, device = "cpu") + self.partitioned_data = self.data2d.partition( + self.n_subsets, 'sequential') + self.A_partitioned = ProjectionOperator( + ig2D, self.partitioned_data.geometry, device="cpu") self.f_subsets = [] for i in range(self.n_subsets): - fi=LeastSquares(self.A_partitioned.operators[i],self. partitioned_data[i]) + fi = LeastSquares( + self.A_partitioned.operators[i], self. partitioned_data[i]) self.f_subsets.append(fi) - self.f=LeastSquares(self.A, self.data2d) - self.f_stochastic=SGFunction(self.f_subsets,self.sampler) - self.initial=ig2D.allocate() + self.f = LeastSquares(self.A, self.data2d) + self.f_stochastic = SGFunction(self.f_subsets, self.sampler) + self.initial = ig2D.allocate() @unittest.skipUnless(has_astra, "Requires ASTRA") - def test_approximate_gradient(self): #Test when we the approximate gradient is not equal to the full gradient - self.assertFalse((self.f_stochastic.full_gradient(self.initial)==self.f_stochastic.gradient(self.initial).array).all()) + # Test when we the approximate gradient is not equal to the full gradient + def test_approximate_gradient(self): + self.assertFalse((self.f_stochastic.full_gradient( + self.initial) == self.f_stochastic.gradient(self.initial).array).all()) @unittest.skipUnless(has_astra, "Requires ASTRA") def test_sampler(self): self.assertTrue(isinstance(self.f_stochastic.sampler, SamplerRandom)) - f=SGFunction(self.f_subsets) - self.assertTrue(isinstance( f.sampler, SamplerRandom)) + f = SGFunction(self.f_subsets) + self.assertTrue(isinstance(f.sampler, SamplerRandom)) self.assertEqual(f.sampler._type, 'random_with_replacement') @unittest.skipUnless(has_astra, "Requires ASTRA") def test_direct(self): - self.assertAlmostEqual(self.f_stochastic(self.initial), self.f(self.initial),1) + self.assertAlmostEqual(self.f_stochastic( + self.initial), self.f(self.initial), 1) @unittest.skipUnless(has_astra, "Requires ASTRA") def test_full_gradient(self): - self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient(self.initial).array, self.f.gradient(self.initial).array,2) - + self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient( + self.initial).array, self.f.gradient(self.initial).array, 2) + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_value_error_with_only_one_function(self): with self.assertRaises(ValueError): SGFunction([self.f], self.sampler) pass - + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_type_error_if_functions_not_a_list(self): with self.assertRaises(TypeError): SGFunction(self.f, self.sampler) - @unittest.skipUnless(has_astra, "Requires ASTRA") def test_sampler_without_next(self): class bad_Sampler(): def init(self): pass - bad_sampler=bad_Sampler() + bad_sampler = bad_Sampler() with self.assertRaises(ValueError): - SGFunction([self.f, self.f], bad_sampler) - + SGFunction([self.f, self.f], bad_sampler) + @unittest.skipUnless(has_astra, "Requires ASTRA") def test_sampler_out_of_range(self): - bad_sampler=Sampler.sequential(10) - f=SGFunction([self.f, self.f], bad_sampler) + bad_sampler = Sampler.sequential(10) + f = SGFunction([self.f, self.f], bad_sampler) with self.assertRaises(IndexError): f.gradient(self.initial) f.gradient(self.initial) f.gradient(self.initial) - - + @unittest.skipUnless(has_astra, "Requires ASTRA") - def test_SGD_simulated_parallel_beam_data(self): + def test_SGD_simulated_parallel_beam_data(self): - step_size = self.f.L - alg = GD(initial=self.initial, - objective_function=self.f, update_objective_interval=500, - step_size=step_size, alpha=1e8) + alg = GD(initial=self.initial, + objective_function=self.f, update_objective_interval=500, alpha=1e8) alg.max_iteration = 200 alg.run(verbose=0) - - - objective=self.f_stochastic - alg_stochastic = GD(initial=self.initial, - objective_function=objective, update_objective_interval=500, - step_size=1e-7, max_iteration =5000) - alg_stochastic.run( self.n_subsets*50, verbose=0) + + objective = self.f_stochastic + alg_stochastic = GD(initial=self.initial, + objective_function=objective, update_objective_interval=500, + step_size=1e-7, max_iteration=5000) + alg_stochastic.run(self.n_subsets*50, verbose=0) self.assertAlmostEqual(objective.data_passes[-1], self.n_subsets*50/5) - self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) - - - def test_SGD_toy_example(self): - sampler=Sampler.random_with_replacement(5) + self.assertNumpyArrayAlmostEqual( + alg_stochastic.x.as_array(), alg.x.as_array(), 3) + + def test_SGD_toy_example(self): + sampler = Sampler.random_with_replacement(5) initial = VectorData(np.zeros(25)) - b = VectorData(np.random.normal(0,1,25)) - functions=[] + b = VectorData(np.random.normal(0, 1, 25)) + functions = [] for i in range(5): - diagonal=np.zeros(25) - diagonal[5*i:5*(i+1)]=1 - A=MatrixOperator(np.diag(diagonal)) - functions.append( LeastSquares(A, A.direct(b))) - if i==0: - objective=LeastSquares(A, A.direct(b)) + diagonal = np.zeros(25) + diagonal[5*i:5*(i+1)] = 1 + A = MatrixOperator(np.diag(diagonal)) + functions.append(LeastSquares(A, A.direct(b))) + if i == 0: + objective = LeastSquares(A, A.direct(b)) else: - objective+=LeastSquares(A, A.direct(b)) + objective += LeastSquares(A, A.direct(b)) - step_size = objective.L / 3. - - alg = GD(initial=initial, - objective_function=objective, update_objective_interval=1000, - step_size=step_size, atol=1e-9, rtol=1e-6) + alg = GD(initial=initial, + objective_function=objective, update_objective_interval=1000, atol=1e-9, rtol=1e-6) alg.max_iteration = 600 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - - stochastic_objective=SGFunction(functions, sampler) - self.assertAlmostEqual(stochastic_objective(initial), objective(initial)) - self.assertNumpyArrayAlmostEqual(stochastic_objective.full_gradient(initial).array, objective.gradient(initial).array) - - - - alg_stochastic = GD(initial=initial, - objective_function=stochastic_objective, update_objective_interval=1000, - step_size=0.01, max_iteration =5000) - alg_stochastic.run( 600, verbose=0) - self.assertAlmostEqual(stochastic_objective.data_passes[-1], 600/5) - self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), alg.x.as_array(),3) - self.assertNumpyArrayAlmostEqual(alg_stochastic.x.as_array(), b.as_array(),3) - + stochastic_objective = SGFunction(functions, sampler) + self.assertAlmostEqual( + stochastic_objective(initial), objective(initial)) + self.assertNumpyArrayAlmostEqual(stochastic_objective.full_gradient( + initial).array, objective.gradient(initial).array) - - \ No newline at end of file + alg_stochastic = GD(initial=initial, + objective_function=stochastic_objective, update_objective_interval=1000, + step_size=0.01, max_iteration=5000) + alg_stochastic.run(600, verbose=0) + self.assertAlmostEqual(stochastic_objective.data_passes[-1], 600/5) + self.assertNumpyArrayAlmostEqual( + alg_stochastic.x.as_array(), alg.x.as_array(), 3) + self.assertNumpyArrayAlmostEqual( + alg_stochastic.x.as_array(), b.as_array(), 3) From eac539763f8f332f927419162c3dfd3d826430ad Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 13 Feb 2024 15:48:50 +0000 Subject: [PATCH 130/152] Getter for num_functions --- .../functions/ApproximateGradientSumFunction.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 56f2201a03..8bb609378e 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -72,8 +72,6 @@ def __init__(self, functions, sampler =None): raise ValueError('The provided sampler must have a `next` method') self.sampler = sampler - - self.num_functions = len(functions) self._data_passes=[] @@ -174,4 +172,8 @@ def _update_data_passes(self, value): @property def data_passes(self): - return self._data_passes \ No newline at end of file + return self._data_passes + + @property + def num_functions(self): + return len(self.functions) \ No newline at end of file From 9befcf8d6127f34227b251df4abf7110333a131c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 14 Feb 2024 12:30:12 +0000 Subject: [PATCH 131/152] Discussion with Zeljko, Edo and Vaggelis --- .../ApproximateGradientSumFunction.py | 19 ++++++++++++++++--- .../cil/optimisation/functions/Function.py | 3 +++ .../cil/optimisation/functions/SGFunction.py | 1 + .../Python/test/test_approximate_gradient.py | 2 ++ 4 files changed, 22 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 8bb609378e..72f412ffcb 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -74,7 +74,7 @@ def __init__(self, functions, sampler =None): self.sampler = sampler self._data_passes=[] - + self._data_passes_indices=[] super(ApproximateGradientSumFunction, self).__init__(*functions) @@ -164,16 +164,29 @@ def _update_data_passes(self, value): The additional proportion of the data that has been seen """ + value=round(value, 5) try: self._data_passes.append( self._data_passes[-1] + value) except IndexError: self._data_passes.append(value) + def _update_data_passes_indices(self, indices): + """ Internal function that updates the list of lists containing the function indices seen at each iteration. + + Parameters + ---------- + indices: list + List of indices seen in a given iteration + + """ + self._data_passes_indices.append(indices) + + @property def data_passes(self): return self._data_passes @property - def num_functions(self): - return len(self.functions) \ No newline at end of file + def data_passes_indices(self): + return self._data_passes_indices \ No newline at end of file diff --git a/Wrappers/Python/cil/optimisation/functions/Function.py b/Wrappers/Python/cil/optimisation/functions/Function.py index f2111ad773..e3fda1e4ad 100644 --- a/Wrappers/Python/cil/optimisation/functions/Function.py +++ b/Wrappers/Python/cil/optimisation/functions/Function.py @@ -372,6 +372,9 @@ def __add__(self, other): else: return super(SumFunction, self).__add__(other) + @property + def num_functions(self): + return len(self.functions) class ScaledFunction(Function): diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 7df7c30029..ed27572bcf 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -54,6 +54,7 @@ def approximate_gradient(self, x, function_num, out=None): self._update_data_passes(1/self.num_functions) + self._update_data_passes_indices([function_num]) # compute gradient of randomly selected(function_num) function if out is None: diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 2c818fafa0..24a8e8648f 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -158,6 +158,7 @@ def test_SGD_simulated_parallel_beam_data(self): step_size=1e-7, max_iteration=5000) alg_stochastic.run(self.n_subsets*50, verbose=0) self.assertAlmostEqual(objective.data_passes[-1], self.n_subsets*50/5) + self.assertListEqual(objective.data_passes_indices[-1], [objective.function_num]) self.assertNumpyArrayAlmostEqual( alg_stochastic.x.as_array(), alg.x.as_array(), 3) @@ -193,6 +194,7 @@ def test_SGD_toy_example(self): step_size=0.01, max_iteration=5000) alg_stochastic.run(600, verbose=0) self.assertAlmostEqual(stochastic_objective.data_passes[-1], 600/5) + self.assertListEqual(stochastic_objective.data_passes_indices[-1], [stochastic_objective.function_num]) self.assertNumpyArrayAlmostEqual( alg_stochastic.x.as_array(), alg.x.as_array(), 3) self.assertNumpyArrayAlmostEqual( From e1019a398b048aa8a8ccbf132ca03408683eaedc Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 14 Feb 2024 12:34:34 +0000 Subject: [PATCH 132/152] Documentation on data passes --- .../functions/ApproximateGradientSumFunction.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 72f412ffcb..5bd98907b7 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -40,7 +40,14 @@ class ApproximateGradientSumFunction(SumFunction, ABC): This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. - + Note + ----- + We provide two ways of keeping track the amount of data you have seen: + - `data_passes` is a list of floats the length of which should be the number of iterations currently run. Each entry corresponds to the proportion of data seen up to this iteration. Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches`, then this + may not be correct. + - `data_passes_indices` a list of lists the length of which should be the number of iterations currently run. Each entry corresponds to the indices of the function numbers seen in that iteration. + + Note ---- The :meth:`~ApproximateGradientSumFunction.gradient` returns the approximate gradient depending on an index provided by the :code:`sampler` method. From c971dd66493b24f5322e0d56c04058fc2ec5b5b9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 27 Feb 2024 16:05:35 +0000 Subject: [PATCH 133/152] Comments from discussion with Edo --- .../ApproximateGradientSumFunction.py | 140 ++++++++++-------- .../cil/optimisation/functions/SGFunction.py | 2 - .../Python/test/test_approximate_gradient.py | 121 +++++++++------ docs/source/optimisation.rst | 35 +++-- 4 files changed, 175 insertions(+), 123 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 5bd98907b7..e02d193ef4 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -1,6 +1,5 @@ -# -*- coding: utf-8 -*- -# Copyright 2020 United Kingdom Research and Innovation -# Copyright 2020 The University of Manchester +# Copyright 2024 United Kingdom Research and Innovation +# Copyright 2024 The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -19,17 +18,19 @@ from cil.optimisation.functions import SumFunction -from cil.optimisation.utilities import Sampler +from cil.optimisation.utilities import Sampler import numbers from abc import ABC, abstractmethod +import numpy as np -class ApproximateGradientSumFunction(SumFunction, ABC): + +class ApproximateGradientSumFunction(SumFunction, ABC): r"""ApproximateGradientSumFunction represents the following sum .. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) where :math:`n` is the number of functions. The gradient method from a CIL function is overwritten and calls an approximate gradient method. - + It is an abstract base class and any child classes must implement an `approximate_gradient` function. Parameters: @@ -38,16 +39,16 @@ class ApproximateGradientSumFunction(SumFunction, ABC): A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {1,...,n}. This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. - - + + Note ----- We provide two ways of keeping track the amount of data you have seen: - - `data_passes` is a list of floats the length of which should be the number of iterations currently run. Each entry corresponds to the proportion of data seen up to this iteration. Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches`, then this - may not be correct. - `data_passes_indices` a list of lists the length of which should be the number of iterations currently run. Each entry corresponds to the indices of the function numbers seen in that iteration. + - `data_passes` is a list of floats the length of which should be the number of iterations currently run. Each entry corresponds to the proportion of data seen up to this iteration. Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. + + - Note ---- The :meth:`~ApproximateGradientSumFunction.gradient` returns the approximate gradient depending on an index provided by the :code:`sampler` method. @@ -55,7 +56,7 @@ class ApproximateGradientSumFunction(SumFunction, ABC): Example ------- Consider the objective is to minimise: - + .. math:: \sum_{i=1}^{n} F_{i}(x) = \sum_{i=1}^{n}\|A_{i} x - b_{i}\|^{2} >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) @@ -68,62 +69,63 @@ class ApproximateGradientSumFunction(SumFunction, ABC): """ - def __init__(self, functions, sampler =None): - + def __init__(self, functions, sampler=None): + if sampler is None: - sampler=Sampler.random_with_replacement(len(functions)) - + sampler = Sampler.random_with_replacement(len(functions)) + if not isinstance(functions, list): raise TypeError("Input to functions should be a list of functions") if not hasattr(sampler, "next"): raise ValueError('The provided sampler must have a `next` method') - + self.sampler = sampler - - self._data_passes=[] - self._data_passes_indices=[] + + self._partition_weights = [1 / len(functions)] * len(functions) + + self._data_passes_indices = [] super(ApproximateGradientSumFunction, self).__init__(*functions) def __call__(self, x): r"""Returns the value of the sum of functions at :math:`x`. - + .. math:: (F_{1} + F_{2} + ... + F_{n})(x) = F_{1}(x) + F_{2}(x) + ... + F_{n}(x) - + Parameters ---------- x : DataContainer - + -------- float the value of the SumFunction at x - - - """ + + + """ return super(ApproximateGradientSumFunction, self).__call__(x) def full_gradient(self, x, out=None): r"""Returns the value of the full gradient of the sum of functions at :math:`x`. - + .. math:: \nabla_x(F_{1} + F_{2} + ... + F_{n})(x) = \nabla_xF_{1}(x) + \nabla_xF_{2}(x) + ... + \nabla_xF_{n}(x) - + Parameters ---------- x : DataContainer out: return DataContainer, if `None` a new DataContainer is returned, default `None`. - + Returns -------- DataContainer the value of the gradient of the sum function at x or nothing if `out` """ - + return super(ApproximateGradientSumFunction, self).gradient(x, out=out) - + @abstractmethod def approximate_gradient(self, x, function_num, out=None): """ Computes the approximate gradient for each selected function at :code:`x` given a `function_number` in {1,...,len(functions)}. - + Parameters ---------- x : DataContainer @@ -139,61 +141,73 @@ def approximate_gradient(self, x, function_num, out=None): def gradient(self, x, out=None): """ Selects a random function using the `sampler` and then calls the approximate gradient at :code:`x` - + Parameters ---------- x : DataContainer out: return DataContainer, if `None` a new DataContainer is returned, default `None`. - + Returns -------- DataContainer the value of the approximate gradient of the sum function at :code:`x` or nothing if `out` """ - + self.function_num = self.sampler.next() - if self.function_num>self.num_functions: + if self.function_num > self.num_functions: raise IndexError( 'The sampler has outputted an index larger than the number of functions to sample from. Please ensure your sampler samples from {1,2,...,len(functions)} only.') - + if isinstance(self.function_num, numbers.Number): return self.approximate_gradient(x, self.function_num, out=out) raise ValueError("Batch gradient is not yet implemented") - - def _update_data_passes(self, value): - """ Internal function that updates the list which stores the data passes - - Parameters - ---------- - value: float - The additional proportion of the data that has been seen - - """ - value=round(value, 5) - try: - self._data_passes.append( - self._data_passes[-1] + value) - except IndexError: - self._data_passes.append(value) - def _update_data_passes_indices(self, indices): """ Internal function that updates the list of lists containing the function indices seen at each iteration. - + Parameters ---------- indices: list List of indices seen in a given iteration - + """ self._data_passes_indices.append(indices) - - - @property - def data_passes(self): - return self._data_passes - + + def set_data_partition_weights(self, weights): + """ Setter for the partition weights used to calculate the data passes + + Parameters + ---------- + weights: list of positive floats that sum to one. + The proportion of the data held in each function. Equivalent to the proportions that you partitioned your data into. + + """ + if len(weights) != len(self.functions): + raise ValueError( + 'The provided weights must be a list the same length as the number of functions') + + if abs(sum(weights) - 1) > 1e-6: + raise ValueError('The provided weights must sum to one') + + if any(np.array(weights) < 0): + raise ValueError( + 'The provided weights must be greater than or equal to zero') + + self._partition_weights = weights + @property def data_passes_indices(self): - return self._data_passes_indices \ No newline at end of file + return self._data_passes_indices + + @property + def data_passes(self): + data_passes = [] + for el in self._data_passes_indices: + try: + data_passes.append(data_passes[-1]) + except IndexError: + data_passes.append(0) + for i in el: + data_passes[-1] += self._partition_weights[i] + return data_passes diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index ed27572bcf..610df5f9fd 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -52,8 +52,6 @@ def approximate_gradient(self, x, function_num, out=None): the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {1,...,len(functions)} or nothing if `out` """ - - self._update_data_passes(1/self.num_functions) self._update_data_passes_indices([function_num]) # compute gradient of randomly selected(function_num) function diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 24a8e8648f..3716e80d7c 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -1,6 +1,5 @@ -# -*- coding: utf-8 -*- -# Copyright 2023 United Kingdom Research and Innovation -# Copyright 2023 The University of Manchester +# Copyright 2024 United Kingdom Research and Innovation +# Copyright 2024 The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -68,65 +67,84 @@ def test_ABC(self): class TestSGD(CCPiTestClass): - @unittest.skipUnless(has_astra, "Requires ASTRA") + def setUp(self): - self.sampler = Sampler.random_with_replacement(5) - self.data = dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() - self.data.reorder('astra') - self.data2d = self.data.get_slice(vertical='centre') - ag2D = self.data2d.geometry - ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') - ig2D = ag2D.get_ImageGeometry() - self.A = ProjectionOperator(ig2D, ag2D, device="cpu") - self.n_subsets = 5 - self.partitioned_data = self.data2d.partition( - self.n_subsets, 'sequential') - self.A_partitioned = ProjectionOperator( - ig2D, self.partitioned_data.geometry, device="cpu") - self.f_subsets = [] - for i in range(self.n_subsets): - fi = LeastSquares( - self.A_partitioned.operators[i], self. partitioned_data[i]) - self.f_subsets.append(fi) - self.f = LeastSquares(self.A, self.data2d) - self.f_stochastic = SGFunction(self.f_subsets, self.sampler) - self.initial = ig2D.allocate() - - @unittest.skipUnless(has_astra, "Requires ASTRA") - # Test when we the approximate gradient is not equal to the full gradient - def test_approximate_gradient(self): + + if has_astra: + self.sampler = Sampler.random_with_replacement(5) + self.data = dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() + self.data.reorder('astra') + self.data2d = self.data.get_slice(vertical='centre') + ag2D = self.data2d.geometry + ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') + ig2D = ag2D.get_ImageGeometry() + + self.A = ProjectionOperator(ig2D, ag2D, device="cpu") + self.n_subsets = 5 + self.partitioned_data = self.data2d.partition( + self.n_subsets, 'sequential') + self.A_partitioned = ProjectionOperator( + ig2D, self.partitioned_data.geometry, device="cpu") + self.f_subsets = [] + for i in range(self.n_subsets): + fi = LeastSquares( + self.A_partitioned.operators[i], self. partitioned_data[i]) + self.f_subsets.append(fi) + self.f = LeastSquares(self.A, self.data2d) + self.f_stochastic = SGFunction(self.f_subsets, self.sampler) + self.initial = ig2D.allocate() + + else: + + self.sampler = Sampler.random_with_replacement(6) + self.initial = VectorData(np.zeros(30)) + b = VectorData(np.array(range(30))/50) + self.n_subsets = 6 + self.f_subsets = [] + for i in range(6): + diagonal = np.zeros(30) + diagonal[5*i:5*(i+1)] = 1 + Ai = MatrixOperator(np.diag(diagonal)) + self.f_subsets.append(LeastSquares(Ai, Ai.direct(b))) + self.A=MatrixOperator(np.diag(np.ones(30))) + self.f = LeastSquares(self.A, b) + self.f_stochastic = SGFunction(self.f_subsets, self.sampler) + + + + def test_approximate_gradient_not_equal_full(self): self.assertFalse((self.f_stochastic.full_gradient( self.initial) == self.f_stochastic.gradient(self.initial).array).all()) - @unittest.skipUnless(has_astra, "Requires ASTRA") + def test_sampler(self): self.assertTrue(isinstance(self.f_stochastic.sampler, SamplerRandom)) f = SGFunction(self.f_subsets) self.assertTrue(isinstance(f.sampler, SamplerRandom)) self.assertEqual(f.sampler._type, 'random_with_replacement') - @unittest.skipUnless(has_astra, "Requires ASTRA") + def test_direct(self): self.assertAlmostEqual(self.f_stochastic( self.initial), self.f(self.initial), 1) - @unittest.skipUnless(has_astra, "Requires ASTRA") + def test_full_gradient(self): self.assertNumpyArrayAlmostEqual(self.f_stochastic.full_gradient( self.initial).array, self.f.gradient(self.initial).array, 2) - @unittest.skipUnless(has_astra, "Requires ASTRA") + def test_value_error_with_only_one_function(self): with self.assertRaises(ValueError): SGFunction([self.f], self.sampler) pass - @unittest.skipUnless(has_astra, "Requires ASTRA") + def test_type_error_if_functions_not_a_list(self): with self.assertRaises(TypeError): SGFunction(self.f, self.sampler) - @unittest.skipUnless(has_astra, "Requires ASTRA") + def test_sampler_without_next(self): class bad_Sampler(): def init(self): @@ -135,7 +153,7 @@ def init(self): with self.assertRaises(ValueError): SGFunction([self.f, self.f], bad_sampler) - @unittest.skipUnless(has_astra, "Requires ASTRA") + def test_sampler_out_of_range(self): bad_sampler = Sampler.sequential(10) f = SGFunction([self.f, self.f], bad_sampler) @@ -143,10 +161,27 @@ def test_sampler_out_of_range(self): f.gradient(self.initial) f.gradient(self.initial) f.gradient(self.initial) - - @unittest.skipUnless(has_astra, "Requires ASTRA") + + def test_partition_weights(self): + f_stochastic=SGFunction(self.f_subsets, Sampler.sequential(self.n_subsets)) + self.assertListEqual(f_stochastic._partition_weights, [1 / self.n_subsets] * self.n_subsets) + with self.assertRaises(ValueError): + f_stochastic.set_data_partition_weights( list(range(self.n_subsets))) + with self.assertRaises(ValueError): + f_stochastic.set_data_partition_weights( [1]) + with self.assertRaises(ValueError): + f_stochastic.set_data_partition_weights( [-1]+[2/(self.n_subsets-1)]*(self.n_subsets-1)) + a=[i/float(sum(range(self.n_subsets))) for i in range(self.n_subsets)] + f_stochastic.set_data_partition_weights( a) + self.assertListEqual(f_stochastic._partition_weights, a ) + f_stochastic.gradient(self.initial) + for i in range(1,20): + f_stochastic.gradient(self.initial) + self.assertEqual(f_stochastic.data_passes[i], f_stochastic.data_passes[i-1]+a[i%self.n_subsets]) + + + def test_SGD_simulated_parallel_beam_data(self): - alg = GD(initial=self.initial, objective_function=self.f, update_objective_interval=500, alpha=1e8) alg.max_iteration = 200 @@ -155,17 +190,19 @@ def test_SGD_simulated_parallel_beam_data(self): objective = self.f_stochastic alg_stochastic = GD(initial=self.initial, objective_function=objective, update_objective_interval=500, - step_size=1e-7, max_iteration=5000) + step_size=1/self.f_stochastic.L, max_iteration=5000) alg_stochastic.run(self.n_subsets*50, verbose=0) - self.assertAlmostEqual(objective.data_passes[-1], self.n_subsets*50/5) + self.assertAlmostEqual(objective.data_passes[-1], self.n_subsets*50/self.n_subsets) self.assertListEqual(objective.data_passes_indices[-1], [objective.function_num]) self.assertNumpyArrayAlmostEqual( alg_stochastic.x.as_array(), alg.x.as_array(), 3) + + def test_SGD_toy_example(self): sampler = Sampler.random_with_replacement(5) initial = VectorData(np.zeros(25)) - b = VectorData(np.random.normal(0, 1, 25)) + b = VectorData(np.array(range(25))) functions = [] for i in range(5): diagonal = np.zeros(25) diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 570a381484..850c83f1bb 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -132,7 +132,7 @@ This is an area of development for CIL. SPDHG ----- -Stochastic PRimal Dual Hybrid Gradient (SPDHG) is a stochastic version of PDHG and deals with optimisation problems of the form: +Stochastic Primal Dual Hybrid Gradient (SPDHG) is a stochastic version of PDHG and deals with optimisation problems of the form: .. math:: @@ -176,25 +176,28 @@ Alternatively, consider optimisation problems of the form: .. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) -where :math:`n` is the number of functions. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. -Child classes of this abstract base class can define different approximate gradients with different mathematical properties. Combining these approximate gradients with deterministic optimisation algorithms +where :math:`n` is the number of functions. Where there is a large number of :math:`F_i` or their gradients are expensive to calculate stochastic optimisation methods could prove more efficient. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. + +The idea for this class and its sum functions is to consider that some stochastic optimisation algorithms can be viewed as deterministic gradient descent algorithms replacing the gradient with an approximate gradient. For example Stochasstic Gradient Descent replaces the gradient in Gradient Descent with the gradient of just one of the :math:`F_i`. + +CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation of a sum function with an approximate gradient. Child classes of this abstract base class can define different approximate gradients with different mathematical properties. Combining these approximate gradients with deterministic optimisation algorithms leads to different stochastic optimisation algorithms. For example in the following table, the left hand column has the approximate gradient function subclass, the header row has the optimisation algorithm and the body of the table has the resulting stochastic algorithm. -+---------------+-------+------------+----------------+ -| | GD | ISTA | FISTA | -+---------------+-------+------------+----------------+ -| SGFunction | SGD | Prox-SGD | Acc-Prox-SGD | -+---------------+-------+------------+----------------+ -| SAGFunction | SAG | Prox-SAG | Acc-Prox-SAG | -+---------------+-------+------------+----------------+ -| SAGAFunction | SAGA | Prox-SAGA | Acc-Prox-SAGA | -+---------------+-------+------------+----------------+ -| SVRGFunction | SVRG | Prox-SVRG | Acc-Prox-SVRG | -+---------------+-------+------------+----------------+ -| LSVRGFunction | LSVRG | Prox-LSVRG | Acc-Prox-LSVRG | -+---------------+-------+------------+----------------+ ++----------------+-------+------------+----------------+ +| | GD | ISTA | FISTA | ++----------------+-------+------------+----------------+ +| SGFunction | SGD | Prox-SGD | Acc-Prox-SGD | ++----------------+-------+------------+----------------+ +| SAGFunction\* | SAG | Prox-SAG | Acc-Prox-SAG | ++----------------+-------+------------+----------------+ +| SAGAFunction\* | SAGA | Prox-SAGA | Acc-Prox-SAGA | ++----------------+-------+------------+----------------+ +| SVRGFunction\* | SVRG | Prox-SVRG | Acc-Prox-SVRG | ++----------------+-------+------------+----------------+ +| LSVRGFunction\*| LSVRG | Prox-LSVRG | Acc-Prox-LSVRG | ++----------------+-------+------------+----------------+ \*In development From addfe4794d6f73063f9802e28046c80ab5be5579 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 12 Mar 2024 16:11:55 +0000 Subject: [PATCH 134/152] Changes after Vaggelis review --- .../ApproximateGradientSumFunction.py | 24 +++++----- .../cil/optimisation/functions/SGFunction.py | 10 ++-- .../Python/test/test_approximate_gradient.py | 46 ++++++++++++++++++- 3 files changed, 62 insertions(+), 18 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index e02d193ef4..d098d51a32 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -27,17 +27,17 @@ class ApproximateGradientSumFunction(SumFunction, ABC): r"""ApproximateGradientSumFunction represents the following sum - .. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) + .. math:: \sum_{i=0}^{n-1} f_{i} = (f_{0} + f_{2} + ... + f_{n-1}) - where :math:`n` is the number of functions. The gradient method from a CIL function is overwritten and calls an approximate gradient method. + where there are :math:`n` functions. The gradient method from a CIL function is overwritten and calls an approximate gradient method. It is an abstract base class and any child classes must implement an `approximate_gradient` function. Parameters: ----------- functions : `list` of functions - A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {1,...,n}. + A list of functions: :code:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {0,...,n-1}. This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. @@ -57,13 +57,13 @@ class ApproximateGradientSumFunction(SumFunction, ABC): ------- Consider the objective is to minimise: - .. math:: \sum_{i=1}^{n} F_{i}(x) = \sum_{i=1}^{n}\|A_{i} x - b_{i}\|^{2} + .. math:: \sum_{i=0}^{n-1} f_{i}(x) = \sum_{i=0}^{n-1}\|A_{i} x - b_{i}\|^{2} >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) >>> f = ApproximateGradientSumFunction(list_of_functions) >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) - >>> sampler = RandomSampling.random_shuffle(len(list_of_functions)) + >>> sampler = Sampler.random_shuffle(len(list_of_functions)) >>> f = ApproximateGradientSumFunction(list_of_functions, sampler=sampler) @@ -90,7 +90,7 @@ def __init__(self, functions, sampler=None): def __call__(self, x): r"""Returns the value of the sum of functions at :math:`x`. - .. math:: (F_{1} + F_{2} + ... + F_{n})(x) = F_{1}(x) + F_{2}(x) + ... + F_{n}(x) + .. math:: (f_{0} + f_{1} + ... + f_{n-1})(x) = f_{0}(x) + f_{1}(x) + ... + f_{n-1}(x) Parameters ---------- @@ -107,7 +107,7 @@ def __call__(self, x): def full_gradient(self, x, out=None): r"""Returns the value of the full gradient of the sum of functions at :math:`x`. - .. math:: \nabla_x(F_{1} + F_{2} + ... + F_{n})(x) = \nabla_xF_{1}(x) + \nabla_xF_{2}(x) + ... + \nabla_xF_{n}(x) + .. math:: \nabla_x(f_{0} + f_{1} + ... + f_{n-1})(x) = \nabla_xf_{0}(x) + \nabla_xf_{1}(x) + ... + \nabla_xf_{n-1}(x) Parameters ---------- @@ -124,18 +124,18 @@ def full_gradient(self, x, out=None): @abstractmethod def approximate_gradient(self, x, function_num, out=None): - """ Computes the approximate gradient for each selected function at :code:`x` given a `function_number` in {1,...,len(functions)}. + """ Computes the approximate gradient for each selected function at :code:`x` given a `function_number` in {0,...,len(functions)-1}. Parameters ---------- x : DataContainer out: return DataContainer, if `None` a new DataContainer is returned, default `None`. function_num: `int` - Between 1 and the number of functions in the list + Between 0 and the number of functions in the list Returns -------- DataContainer - the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {1,...,len(functions)} or nothing if `out` + the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {0,...,len(functions)-1} or nothing if `out` """ pass @@ -157,7 +157,7 @@ def gradient(self, x, out=None): if self.function_num > self.num_functions: raise IndexError( - 'The sampler has outputted an index larger than the number of functions to sample from. Please ensure your sampler samples from {1,2,...,len(functions)} only.') + 'The sampler has outputted an index larger than the number of functions to sample from. Please ensure your sampler samples from {0,1,...,len(functions)-1} only.') if isinstance(self.function_num, numbers.Number): return self.approximate_gradient(x, self.function_num, out=out) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 610df5f9fd..aa26cdad8d 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -21,14 +21,14 @@ class SGFunction(ApproximateGradientSumFunction): """ - Stochastic gradient function, a child class of `ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_1,...,f_n}` a `SumFunction`, :math:`f_1+...+f_n` where each time the `gradient` is called, the `sampler` provides an index, :math:`i \in {1,...,n}` + Stochastic gradient function, a child class of `ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_0,...,f_{n-1}}` a `SumFunction`, :math:`f_0+...+f_{n-1}` where each time the `gradient` is called, the `sampler` provides an index, :math:`i \in {0,...,n-1}` and the gradient function returns the approximate gradient :math:`n\nabla_xf_i(x)`. This can be used with the `cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. Parameters: ----------- functions : `list` of functions - A list of functions: :code:`[F_{1}, F_{2}, ..., F_{n}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {1,...,n}. + A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {0,...,n-1}. This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. """ @@ -45,11 +45,11 @@ def approximate_gradient(self, x, function_num, out=None): x : DataContainer out: return DataContainer, if `None` a new DataContainer is returned, default `None`. function_num: `int` - Between 1 and the number of functions in the list + Between 0 and the number of functions in the list Returns -------- DataContainer - the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {1,...,len(functions)} or nothing if `out` + the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {0,...,len(functions)-1} or nothing if `out` """ self._update_data_passes_indices([function_num]) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 3716e80d7c..0d99738ceb 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -42,7 +42,12 @@ if has_astra: from cil.plugins.astra import ProjectionOperator +from utils import has_cvxpy +if has_cvxpy: + import cvxpy + + class TestApproximateGradientSumFunction(CCPiTestClass): def setUp(self): @@ -124,7 +129,7 @@ def test_sampler(self): self.assertEqual(f.sampler._type, 'random_with_replacement') - def test_direct(self): + def test_call(self): self.assertAlmostEqual(self.f_stochastic( self.initial), self.f(self.initial), 1) @@ -236,3 +241,42 @@ def test_SGD_toy_example(self): alg_stochastic.x.as_array(), alg.x.as_array(), 3) self.assertNumpyArrayAlmostEqual( alg_stochastic.x.as_array(), b.as_array(), 3) + + @unittest.skipUnless(has_cvxpy, "CVXpy not installed") + def test_with_cvxpy(self): + np.random.seed(10) + n = 300 + m = 100 + A = np.random.normal(0,1, (m, n)).astype('float32') + b = np.random.normal(0,1, m).astype('float32') + + Aop = MatrixOperator(A) + bop = VectorData(b) + n_subsets = 10 + Ai = np.vsplit(A, n_subsets) + bi = [b[i:i+int(m/n_subsets)] for i in range(0, m, int(m/n_subsets))] + fi_cil = [] + for i in range(n_subsets): + Ai_cil = MatrixOperator(Ai[i]) + bi_cil = VectorData(bi[i]) + fi_cil.append(LeastSquares(Ai_cil, bi_cil, c = 0.5)) + F = LeastSquares(Aop, b=bop, c = 0.5) + ig = Aop.domain + initial= ig.allocate(0) + sampler=Sampler.random_with_replacement(n_subsets) + F_SG=SGFunction(fi_cil, sampler) + u_cvxpy = cvxpy.Variable(ig.shape[0]) + objective = cvxpy.Minimize( 0.5*cvxpy.sum_squares(Aop.A @ u_cvxpy - bop.array)) + p = cvxpy.Problem(objective) + p.solve(verbose=True, solver=cvxpy.SCS, eps=1e-4) + + step_size = 1./F_SG.L + + epochs = 200 + sgd = GD(initial = initial, objective_function = F_SG, step_size = step_size, + max_iteration = epochs * n_subsets, + update_objective_interval = epochs * n_subsets) + sgd.run(verbose=0) + + np.testing.assert_allclose(p.value, sgd.objective[-1], atol=1e-1) + np.testing.assert_allclose(u_cvxpy.value, sgd.solution.array, atol=1e-1) \ No newline at end of file From 3a74f7566b3fd3d2d7668a62af916d5283c04192 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 14 Mar 2024 09:56:33 +0000 Subject: [PATCH 135/152] Tweak to unit tests after discussion with Edo --- .../Python/test/test_approximate_gradient.py | 94 ++++++++++--------- 1 file changed, 48 insertions(+), 46 deletions(-) diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 0d99738ceb..013ab1b198 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -75,45 +75,21 @@ class TestSGD(CCPiTestClass): def setUp(self): - if has_astra: - self.sampler = Sampler.random_with_replacement(5) - self.data = dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() - self.data.reorder('astra') - self.data2d = self.data.get_slice(vertical='centre') - ag2D = self.data2d.geometry - ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') - ig2D = ag2D.get_ImageGeometry() - - self.A = ProjectionOperator(ig2D, ag2D, device="cpu") - self.n_subsets = 5 - self.partitioned_data = self.data2d.partition( - self.n_subsets, 'sequential') - self.A_partitioned = ProjectionOperator( - ig2D, self.partitioned_data.geometry, device="cpu") - self.f_subsets = [] - for i in range(self.n_subsets): - fi = LeastSquares( - self.A_partitioned.operators[i], self. partitioned_data[i]) - self.f_subsets.append(fi) - self.f = LeastSquares(self.A, self.data2d) - self.f_stochastic = SGFunction(self.f_subsets, self.sampler) - self.initial = ig2D.allocate() - - else: + - self.sampler = Sampler.random_with_replacement(6) - self.initial = VectorData(np.zeros(30)) - b = VectorData(np.array(range(30))/50) - self.n_subsets = 6 - self.f_subsets = [] - for i in range(6): - diagonal = np.zeros(30) - diagonal[5*i:5*(i+1)] = 1 - Ai = MatrixOperator(np.diag(diagonal)) - self.f_subsets.append(LeastSquares(Ai, Ai.direct(b))) - self.A=MatrixOperator(np.diag(np.ones(30))) - self.f = LeastSquares(self.A, b) - self.f_stochastic = SGFunction(self.f_subsets, self.sampler) + self.sampler = Sampler.random_with_replacement(6) + self.initial = VectorData(np.zeros(30)) + b = VectorData(np.array(range(30))/50) + self.n_subsets = 6 + self.f_subsets = [] + for i in range(6): + diagonal = np.zeros(30) + diagonal[5*i:5*(i+1)] = 1 + Ai = MatrixOperator(np.diag(diagonal)) + self.f_subsets.append(LeastSquares(Ai, Ai.direct(b))) + self.A=MatrixOperator(np.diag(np.ones(30))) + self.f = LeastSquares(self.A, b) + self.f_stochastic = SGFunction(self.f_subsets, self.sampler) @@ -185,19 +161,45 @@ def test_partition_weights(self): self.assertEqual(f_stochastic.data_passes[i], f_stochastic.data_passes[i-1]+a[i%self.n_subsets]) - + + @unittest.skipUnless(has_astra, "Requires ASTRA GPU") def test_SGD_simulated_parallel_beam_data(self): - alg = GD(initial=self.initial, - objective_function=self.f, update_objective_interval=500, alpha=1e8) + + sampler = Sampler.random_with_replacement(5) + data = dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() + data.reorder('astra') + data2d = data.get_slice(vertical='centre') + ag2D = data2d.geometry + ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') + ig2D = ag2D.get_ImageGeometry() + + A = ProjectionOperator(ig2D, ag2D, device="cpu") + n_subsets = 5 + partitioned_data = data2d.partition( + n_subsets, 'sequential') + A_partitioned = ProjectionOperator( + ig2D, partitioned_data.geometry, device="cpu") + f_subsets = [] + for i in range(n_subsets): + fi = LeastSquares( + A_partitioned.operators[i], partitioned_data[i]) + f_subsets.append(fi) + f = LeastSquares(A, data2d) + f_stochastic = SGFunction(f_subsets, sampler) + initial = ig2D.allocate() + + + alg = GD(initial=initial, + objective_function=f, update_objective_interval=500, alpha=1e8) alg.max_iteration = 200 alg.run(verbose=0) - objective = self.f_stochastic - alg_stochastic = GD(initial=self.initial, + objective = f_stochastic + alg_stochastic = GD(initial=initial, objective_function=objective, update_objective_interval=500, - step_size=1/self.f_stochastic.L, max_iteration=5000) - alg_stochastic.run(self.n_subsets*50, verbose=0) - self.assertAlmostEqual(objective.data_passes[-1], self.n_subsets*50/self.n_subsets) + step_size=1/f_stochastic.L, max_iteration=5000) + alg_stochastic.run(n_subsets*50, verbose=0) + self.assertAlmostEqual(objective.data_passes[-1], n_subsets*50/n_subsets) self.assertListEqual(objective.data_passes_indices[-1], [objective.function_num]) self.assertNumpyArrayAlmostEqual( alg_stochastic.x.as_array(), alg.x.as_array(), 3) From 2395b03750923ef4ef7520466dd4623b6198115f Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 20 Mar 2024 16:51:11 +0000 Subject: [PATCH 136/152] Some of Jakob's comments --- .../ApproximateGradientSumFunction.py | 10 ++--- .../cil/optimisation/functions/SGFunction.py | 39 ++++++++++--------- docs/source/optimisation.rst | 11 +++--- 3 files changed, 30 insertions(+), 30 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index d098d51a32..d93c684177 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -36,9 +36,9 @@ class ApproximateGradientSumFunction(SumFunction, ABC): Parameters: ----------- functions : `list` of functions - A list of functions: :code:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {0,...,n-1}. - This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. + A list of functions: :code:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in {0,...,n-1}. + This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. Note @@ -116,7 +116,7 @@ def full_gradient(self, x, out=None): Returns -------- - DataContainer + DataContainer (including ImageData and AcquisitionData) the value of the gradient of the sum function at x or nothing if `out` """ @@ -124,7 +124,7 @@ def full_gradient(self, x, out=None): @abstractmethod def approximate_gradient(self, x, function_num, out=None): - """ Computes the approximate gradient for each selected function at :code:`x` given a `function_number` in {0,...,len(functions)-1}. + """ Updates and outputs the approximate gradient at a given point :code:`x` given a `function_number` in {0,...,len(functions)-1}. Parameters ---------- diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index aa26cdad8d..73c67a18cd 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -1,19 +1,20 @@ -# -*- coding: utf-8 -*- -# This work is part of the Core Imaging Library (CIL) developed by CCPi -# (Collaborative Computational Project in Tomographic Imaging), with -# substantial contributions by UKRI-STFC and University of Manchester. - -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at - -# http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. +# Copyright 2024 United Kingdom Research and Innovation +# Copyright 2024 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt from .ApproximateGradientSumFunction import ApproximateGradientSumFunction from .Function import SumFunction @@ -27,8 +28,8 @@ class SGFunction(ApproximateGradientSumFunction): Parameters: ----------- functions : `list` of functions - A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth function with an implemented :func:`~Function.gradient` method. Each function must have the same domain. The number of functions must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or another class which has a `next` function implemented to output integers in {0,...,n-1}. + A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions must be strictly greater than 1. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in {0,...,n-1}. This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. """ @@ -54,7 +55,7 @@ def approximate_gradient(self, x, function_num, out=None): self._update_data_passes_indices([function_num]) - # compute gradient of randomly selected(function_num) function + # compute gradient of the function indexed by function_num if out is None: out = self.functions[function_num].gradient(x) else: diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 16ca962555..d352c58b9f 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -124,8 +124,8 @@ LADMM Algorithms (Stochastic) ======================== -There are a growing range of Stochastic optimisation algorithms available with potential benefits of faster convergence in number of iterations or in computational cost. -This is an area of development for CIL. +There is a growing range of Stochastic optimisation algorithms available with potential benefits of faster convergence in number of iterations or in computational cost. +This is an area of continued development for CIL. @@ -175,12 +175,11 @@ Alternatively, consider optimisation problems of the form: .. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) -where :math:`n` is the number of functions. Where there is a large number of :math:`F_i` or their gradients are expensive to calculate stochastic optimisation methods could prove more efficient. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. +where :math:`n` is the number of functions. Where there is a large number of :math:`F_i` or their gradients are expensive to calculate, stochastic optimisation methods could prove more efficient. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. -The idea for this class and its sum functions is to consider that some stochastic optimisation algorithms can be viewed as deterministic gradient descent algorithms replacing the gradient with an approximate gradient. For example Stochasstic Gradient Descent replaces the gradient in Gradient Descent with the gradient of just one of the :math:`F_i`. +The idea for this class and its sum functions is to consider that some stochastic optimisation algorithms can be viewed as deterministic gradient descent algorithms replacing the gradient with an approximate gradient. For example Stochastic Gradient Descent replaces the gradient in Gradient Descent with the gradient of just one of the :math:`F_i`. -CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation of a sum function with an approximate gradient. Child classes of this abstract base class can define different approximate gradients with different mathematical properties. Combining these approximate gradients with deterministic optimisation algorithms -leads to different stochastic optimisation algorithms. +CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation of a sum function with an approximate gradient. Child classes of this abstract base class can define different approximate gradients with different mathematical properties. For example in the following table, the left hand column has the approximate gradient function subclass, the header row has the optimisation algorithm and the body of the table has the resulting stochastic algorithm. From a7b501647992f66038506e240f70cbeb6dd4563d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Mar 2024 11:21:59 +0000 Subject: [PATCH 137/152] Updated documentation from Vaggelis and Jakob comments --- .../ApproximateGradientSumFunction.py | 49 +++++++++++++------ .../cil/optimisation/functions/SGFunction.py | 8 ++- docs/source/optimisation.rst | 45 +++++++++++++++-- 3 files changed, 83 insertions(+), 19 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index d93c684177..6e0c425e08 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -14,7 +14,14 @@ # limitations under the License. # # Authors: -# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt +# - CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt +# - Daniel Deidda (National Physical Laboratory, UK) +# - Claire Delplancke (Electricite de France, Research and Development) +# - Ashley Gillman (Australian e-Health Res. Ctr., CSIRO, Brisbane, Queensland, Australia) +# - Zeljko Kerata (Department of Computer Science, University College London, UK) +# - Evgueni Ovtchinnikov (STFC - UKRI) +# - Georg Schramm (Department of Imaging and Pathology, Division of Nuclear Medicine, KU Leuven, Leuven, Belgium) + from cil.optimisation.functions import SumFunction @@ -29,23 +36,27 @@ class ApproximateGradientSumFunction(SumFunction, ABC): .. math:: \sum_{i=0}^{n-1} f_{i} = (f_{0} + f_{2} + ... + f_{n-1}) - where there are :math:`n` functions. The gradient method from a CIL function is overwritten and calls an approximate gradient method. + where there are :math:`n` functions. This function class has two ways of calling gradient: + - `full_gradient` calculates the gradient of the sum :math:`\sum_{i=0}^{n-1} \nabla f_{i}` + - `gradient` calls an `approximate_gradient` function which may be less computationally expensive to calculate than the full gradient + + - It is an abstract base class and any child classes must implement an `approximate_gradient` function. + This class is an abstract base class and therefore is not able to be used as is. It is designed to be sub-classed with different approximate gradient implementations. Parameters: ----------- functions : `list` of functions A list of functions: :code:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in {0,...,n-1}. - This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. + This sampler is called each time `gradient` is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. Note ----- - We provide two ways of keeping track the amount of data you have seen: - - `data_passes_indices` a list of lists the length of which should be the number of iterations currently run. Each entry corresponds to the indices of the function numbers seen in that iteration. - - `data_passes` is a list of floats the length of which should be the number of iterations currently run. Each entry corresponds to the proportion of data seen up to this iteration. Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. + Each time `gradient` is called the class keeps track of which functions have been used to calculate the gradient. This may be useful for debugging or plotting after using this function in an iterative algorithm: + - `data_passes_indices` is a list of lists. Each time `gradient` is called a list is appended with with the indices of the functions have been used to calculate the gradient. + - `data_passes` is a list. Each time `gradient` is called an entry is appended with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. @@ -55,6 +66,8 @@ class ApproximateGradientSumFunction(SumFunction, ABC): Example ------- + This class is an abstract base class, so we give an example using the SGFunction child class. + Consider the objective is to minimise: .. math:: \sum_{i=0}^{n-1} f_{i}(x) = \sum_{i=0}^{n-1}\|A_{i} x - b_{i}\|^{2} @@ -63,8 +76,15 @@ class ApproximateGradientSumFunction(SumFunction, ABC): >>> f = ApproximateGradientSumFunction(list_of_functions) >>> list_of_functions = [LeastSquares(Ai, b=bi)] for Ai,bi in zip(A_subsets, b_subsets)) - >>> sampler = Sampler.random_shuffle(len(list_of_functions)) - >>> f = ApproximateGradientSumFunction(list_of_functions, sampler=sampler) + >>> sampler = Sampler.sequential(len(list_of_functions)) + >>> f = SGFunction(list_of_functions, sampler=sampler) + >>> f.full_gradient(x) + This will return :math:`\sum_{i=0}^{n-1} \nabla f_{i}(x)` + >>> f.gradient(x) + As per the approximate gradient implementation in the SGFunction this will return :math:`\nabla f_{0}`. The choice of the `0` index is because we chose a `sequential` sampler and this is the first time we called `gradient`. + >>> f.gradient(x) + This will return :math:`\nabla f_{1}` because we chose a `sequential` sampler and this is the second time we called `gradient`. + """ @@ -116,15 +136,15 @@ def full_gradient(self, x, out=None): Returns -------- - DataContainer (including ImageData and AcquisitionData) - the value of the gradient of the sum function at x or nothing if `out` + DataContainer + The value of the gradient of the sum function at x or nothing if `out` """ return super(ApproximateGradientSumFunction, self).gradient(x, out=out) @abstractmethod def approximate_gradient(self, x, function_num, out=None): - """ Updates and outputs the approximate gradient at a given point :code:`x` given a `function_number` in {0,...,len(functions)-1}. + """ Returns the approximate gradient at a given point :code:`x` given a `function_number` in {0,...,len(functions)-1}. Parameters ---------- @@ -164,12 +184,11 @@ def gradient(self, x, out=None): raise ValueError("Batch gradient is not yet implemented") def _update_data_passes_indices(self, indices): - """ Internal function that updates the list of lists containing the function indices seen at each iteration. - + """ Internal function that updates the list of lists containing the function indices used to calculate the approximate gradient. Parameters ---------- indices: list - List of indices seen in a given iteration + List of indices used to calculate the approximate gradient in a given iteration """ self._data_passes_indices.append(indices) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 73c67a18cd..d407b61e0e 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -14,7 +14,13 @@ # limitations under the License. # # Authors: -# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt +# - CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt +# - Daniel Deidda (National Physical Laboratory, UK) +# - Claire Delplancke (Electricite de France, Research and Development) +# - Ashley Gillman (Australian e-Health Res. Ctr., CSIRO, Brisbane, Queensland, Australia) +# - Zeljko Kerata (Department of Computer Science, University College London, UK) +# - Evgueni Ovtchinnikov (STFC - UKRI) +# - Georg Schramm (Department of Imaging and Pathology, Division of Nuclear Medicine, KU Leuven, Leuven, Belgium) from .ApproximateGradientSumFunction import ApproximateGradientSumFunction from .Function import SumFunction diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index d352c58b9f..1f0c8e2494 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -173,11 +173,11 @@ Approximate gradient sum function Alternatively, consider optimisation problems of the form: -.. math:: \sum_{i=1}^{n} F_{i} = (F_{1} + F_{2} + ... + F_{n}) +.. math:: \sum_{i=0}^{n-1} f_{i} = (f_{0} + f_{1} + ... + f_{n-1}) -where :math:`n` is the number of functions. Where there is a large number of :math:`F_i` or their gradients are expensive to calculate, stochastic optimisation methods could prove more efficient. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. +where :math:`n` is the number of functions. Where there is a large number of :math:`f_i` or their gradients are expensive to calculate, stochastic optimisation methods could prove more efficient. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. -The idea for this class and its sum functions is to consider that some stochastic optimisation algorithms can be viewed as deterministic gradient descent algorithms replacing the gradient with an approximate gradient. For example Stochastic Gradient Descent replaces the gradient in Gradient Descent with the gradient of just one of the :math:`F_i`. +The idea for this class and its sum functions is to consider that some stochastic optimisation algorithms can be viewed as deterministic gradient descent algorithms replacing the gradient with an approximate gradient. For example Stochastic Gradient Descent replaces the gradient in Gradient Descent with the gradient of just one of the :math:`f_i`. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation of a sum function with an approximate gradient. Child classes of this abstract base class can define different approximate gradients with different mathematical properties. @@ -199,6 +199,45 @@ For example in the following table, the left hand column has the approximate gra \*In development +The below is an example of Stochastic Gradient Descent built of the SGFunction and Gradient Descent algorithm: + +.. code:: python + from cil.optimisation.utilities import Sampler + from cil.optimisation.algorithms import GD + from cil.optimisation.functions import LeastSquares, SGFunction + from cil.utilities import dataexample + from cil.plugins.astra.operators import ProjectionOperator + + # get the data + sampler=Sampler.random_with_replacement(5) + data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() + data.reorder('astra') + data=data.get_slice(vertical='centre') + + # create the geometries + ag=data.geometry + ig=ag.get_ImageGeometry() + + # partition the data and build the projectors + n_subsets=10 + partitioned_data=data.partition(n_subsets, 'sequential') + A_partitioned = ProjectionOperator(ig, partitioned_data.geometry, device = "cpu") + + # create the list of functions for the stochastic sum + list_of_functions = [LeastSquares(Ai, b=bi) for Ai,bi in zip(A_partitioned, partitioned_data)] + + #define the sampler and the stochastic gradient function + sampler = Sampler.sequential(len(list_of_functions)) + f = SGFunction(list_of_functions, sampler=sampler) + + #set up and run the gradient descent algorithm + alg = GD(initial=ig.allocate(0), objective_function=f, step_size=0.1, atol=1e-9, rtol=1e-6, alpha=1e8) + alg.run(300) + + + + + The base class: .. autoclass:: cil.optimisation.functions.ApproximateGradientSumFunction From b9d8ab483ec305a82c57893144190dbf91269dcf Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Mar 2024 11:39:15 +0000 Subject: [PATCH 138/152] Try to fix rst file example --- docs/source/optimisation.rst | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 1f0c8e2494..ba4f7eadeb 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -201,7 +201,8 @@ For example in the following table, the left hand column has the approximate gra The below is an example of Stochastic Gradient Descent built of the SGFunction and Gradient Descent algorithm: -.. code:: python +.. code-block :: python + from cil.optimisation.utilities import Sampler from cil.optimisation.algorithms import GD from cil.optimisation.functions import LeastSquares, SGFunction From 9aebc50ce633fb245e4053ad901a6fb296e9f843 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Mar 2024 11:48:21 +0000 Subject: [PATCH 139/152] Try to fix rst file example --- docs/source/optimisation.rst | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index ba4f7eadeb..11ab4f1a41 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -210,7 +210,6 @@ The below is an example of Stochastic Gradient Descent built of the SGFunction a from cil.plugins.astra.operators import ProjectionOperator # get the data - sampler=Sampler.random_with_replacement(5) data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() data.reorder('astra') data=data.get_slice(vertical='centre') From e034e03a54e9965eae52971284ad22de8c4cc1e2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Mar 2024 11:50:47 +0000 Subject: [PATCH 140/152] Try to fix rst file bullet points --- .../optimisation/functions/ApproximateGradientSumFunction.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 6e0c425e08..856cf1c3bd 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -37,8 +37,8 @@ class ApproximateGradientSumFunction(SumFunction, ABC): .. math:: \sum_{i=0}^{n-1} f_{i} = (f_{0} + f_{2} + ... + f_{n-1}) where there are :math:`n` functions. This function class has two ways of calling gradient: - - `full_gradient` calculates the gradient of the sum :math:`\sum_{i=0}^{n-1} \nabla f_{i}` - - `gradient` calls an `approximate_gradient` function which may be less computationally expensive to calculate than the full gradient + - `full_gradient` calculates the gradient of the sum :math:`\sum_{i=0}^{n-1} \nabla f_{i}` + - `gradient` calls an `approximate_gradient` function which may be less computationally expensive to calculate than the full gradient From cf0e60f5d16cc77ba3c18ac0903a454b1746d8af Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Mar 2024 12:00:05 +0000 Subject: [PATCH 141/152] Try to fix rst file example --- .../optimisation/functions/ApproximateGradientSumFunction.py | 4 ++-- docs/source/optimisation.rst | 2 -- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 856cf1c3bd..f01853c22f 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -47,8 +47,8 @@ class ApproximateGradientSumFunction(SumFunction, ABC): Parameters: ----------- functions : `list` of functions - A list of functions: :code:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in {0,...,n-1}. + A list of functions: :math:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in :math:`{0,...,n-1}`. This sampler is called each time `gradient` is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 11ab4f1a41..c32b26cdb0 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -236,8 +236,6 @@ The below is an example of Stochastic Gradient Descent built of the SGFunction a - - The base class: .. autoclass:: cil.optimisation.functions.ApproximateGradientSumFunction From fe21db09b1f28d9ac5e3bd8f3d2efa0659889a09 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Mar 2024 13:20:07 +0000 Subject: [PATCH 142/152] Try to fix SGD docs --- Wrappers/Python/cil/optimisation/functions/SGFunction.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index d407b61e0e..15a1a2cb2c 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -27,14 +27,14 @@ class SGFunction(ApproximateGradientSumFunction): - """ + r""" Stochastic gradient function, a child class of `ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_0,...,f_{n-1}}` a `SumFunction`, :math:`f_0+...+f_{n-1}` where each time the `gradient` is called, the `sampler` provides an index, :math:`i \in {0,...,n-1}` - and the gradient function returns the approximate gradient :math:`n\nabla_xf_i(x)`. This can be used with the `cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. + and the gradient function returns the approximate gradient :math:`\nabla_x f_i(x)`. This can be used with the `cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. Parameters: ----------- functions : `list` of functions - A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions must be strictly greater than 1. + A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions must be strictly greater than 1. sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in {0,...,n-1}. This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. """ From 53dd8374ee4df2ae101bf2da60891dfc243a84d1 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Mar 2024 13:57:40 +0000 Subject: [PATCH 143/152] Updated example after Vaggelis comments --- .../cil/optimisation/functions/SGFunction.py | 8 ++++---- docs/source/optimisation.rst | 16 ++++++++-------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 15a1a2cb2c..8595c049d1 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -34,10 +34,10 @@ class SGFunction(ApproximateGradientSumFunction): Parameters: ----------- functions : `list` of functions - A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in {0,...,n-1}. - This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. The `num_indices` must match the number of functions provided. Default is `Sampler.random_with_replacement(len(functions))`. - """ + A list of functions: :math:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in :math:`{0,...,n-1}`. + This sampler is called each time `gradient` is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. + """ def __init__(self, functions, sampler=None): super(SGFunction, self).__init__(functions, sampler) diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index c32b26cdb0..62ff3f4597 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -210,28 +210,28 @@ The below is an example of Stochastic Gradient Descent built of the SGFunction a from cil.plugins.astra.operators import ProjectionOperator # get the data - data=dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() + data = dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() data.reorder('astra') - data=data.get_slice(vertical='centre') + data = data.get_slice(vertical='centre') # create the geometries - ag=data.geometry - ig=ag.get_ImageGeometry() + ag = data.geometry + ig = ag.get_ImageGeometry() # partition the data and build the projectors - n_subsets=10 - partitioned_data=data.partition(n_subsets, 'sequential') + n_subsets = 10 + partitioned_data = data.partition(n_subsets, 'sequential') A_partitioned = ProjectionOperator(ig, partitioned_data.geometry, device = "cpu") # create the list of functions for the stochastic sum list_of_functions = [LeastSquares(Ai, b=bi) for Ai,bi in zip(A_partitioned, partitioned_data)] #define the sampler and the stochastic gradient function - sampler = Sampler.sequential(len(list_of_functions)) + sampler = Sampler.staggered(len(list_of_functions)) f = SGFunction(list_of_functions, sampler=sampler) #set up and run the gradient descent algorithm - alg = GD(initial=ig.allocate(0), objective_function=f, step_size=0.1, atol=1e-9, rtol=1e-6, alpha=1e8) + alg = GD(initial=ig.allocate(0), objective_function=f, step_size=1/f.L) alg.run(300) From 843413f9113af383040696ceac65d2bfe4d18818 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Mar 2024 16:23:32 +0000 Subject: [PATCH 144/152] Discussions with Edo and Gemma --- NOTICE.txt | 8 +- .../ApproximateGradientSumFunction.py | 15 +-- .../cil/optimisation/functions/SGFunction.py | 13 +- .../Python/test/test_approximate_gradient.py | 113 +++--------------- 4 files changed, 39 insertions(+), 110 deletions(-) diff --git a/NOTICE.txt b/NOTICE.txt index f9dc60e4d4..cb4148589a 100644 --- a/NOTICE.txt +++ b/NOTICE.txt @@ -32,6 +32,8 @@ Institutions Key: 9 - Swansea University 10 - University of Warwick 11 - University of Helsinki +12 - Australian e-Health Research, Australia +13 - KU Leuven CIL Developers in date order: Edoardo Pasca (2017 – present) - 1 @@ -49,7 +51,7 @@ Srikanth Nagella (2017-2018) - 1 Daniil Kazantsev (2018) - 3 Ryan Warr (2019) - 3 Tomas Kulhanek (2019) - 1 -Claire Delplancke (2019 - 2022) - 7 +Claire Delplancke (2019 - 2022) - 7 Matthias Ehrhardt (2019 - 2023) - 7 Richard Brown (2020-2021) - 5 Sam Tygier (2022) - 1 @@ -57,6 +59,10 @@ Andrew Sharits (2022) - 8 Kyle Pidgeon (2023) - 1 Letizia Protopapa (2023) - 1 Tommi Heikkilä (2023) - 11 +Ashley Gillman (2024) -12 +Zeljko Kerata (2024) - 5 +Evgueni Ovtchinnikov (2024) -1 +Georg Schramm (2024) - 13 CIL Advisory Board: Llion Evans - 9 diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index f01853c22f..55233c48ec 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -174,14 +174,13 @@ def gradient(self, x, out=None): """ self.function_num = self.sampler.next() + + self._update_data_passes_indices([self.function_num]) + - if self.function_num > self.num_functions: - raise IndexError( - 'The sampler has outputted an index larger than the number of functions to sample from. Please ensure your sampler samples from {0,1,...,len(functions)-1} only.') - - if isinstance(self.function_num, numbers.Number): - return self.approximate_gradient(x, self.function_num, out=out) - raise ValueError("Batch gradient is not yet implemented") + + return self.approximate_gradient(x, self.function_num, out=out) + def _update_data_passes_indices(self, indices): """ Internal function that updates the list of lists containing the function indices used to calculate the approximate gradient. @@ -217,10 +216,12 @@ def set_data_partition_weights(self, weights): @property def data_passes_indices(self): + """ The property `data_passes_indices` is a list of lists. Each time `gradient` is called a list is appended with with the indices of the functions have been used to calculate the gradient. """ return self._data_passes_indices @property def data_passes(self): + """ The property `data_passes` is a list. Each time `gradient` is called an entry is appended with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. """ data_passes = [] for el in self._data_passes_indices: try: diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 8595c049d1..1696fd2e85 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -34,10 +34,10 @@ class SGFunction(ApproximateGradientSumFunction): Parameters: ----------- functions : `list` of functions - A list of functions: :math:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in :math:`{0,...,n-1}`. - This sampler is called each time `gradient` is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. - """ + A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions must be strictly greater than 1. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in {0,...,n-1}. + This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. + """ def __init__(self, functions, sampler=None): super(SGFunction, self).__init__(functions, sampler) @@ -58,8 +58,11 @@ def approximate_gradient(self, x, function_num, out=None): DataContainer the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {0,...,len(functions)-1} or nothing if `out` """ + if self.function_num >= self.num_functions or self.function_num<0 : + raise IndexError( + 'The sampler has outputted an index larger than the number of functions to sample from. Please ensure your sampler samples from {0,1,...,len(functions)-1} only.') + - self._update_data_passes_indices([function_num]) # compute gradient of the function indexed by function_num if out is None: diff --git a/Wrappers/Python/test/test_approximate_gradient.py b/Wrappers/Python/test/test_approximate_gradient.py index 013ab1b198..774cdd9fa2 100644 --- a/Wrappers/Python/test/test_approximate_gradient.py +++ b/Wrappers/Python/test/test_approximate_gradient.py @@ -162,50 +162,9 @@ def test_partition_weights(self): - @unittest.skipUnless(has_astra, "Requires ASTRA GPU") - def test_SGD_simulated_parallel_beam_data(self): - - sampler = Sampler.random_with_replacement(5) - data = dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() - data.reorder('astra') - data2d = data.get_slice(vertical='centre') - ag2D = data2d.geometry - ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian') - ig2D = ag2D.get_ImageGeometry() - - A = ProjectionOperator(ig2D, ag2D, device="cpu") - n_subsets = 5 - partitioned_data = data2d.partition( - n_subsets, 'sequential') - A_partitioned = ProjectionOperator( - ig2D, partitioned_data.geometry, device="cpu") - f_subsets = [] - for i in range(n_subsets): - fi = LeastSquares( - A_partitioned.operators[i], partitioned_data[i]) - f_subsets.append(fi) - f = LeastSquares(A, data2d) - f_stochastic = SGFunction(f_subsets, sampler) - initial = ig2D.allocate() - - - alg = GD(initial=initial, - objective_function=f, update_objective_interval=500, alpha=1e8) - alg.max_iteration = 200 - alg.run(verbose=0) - - objective = f_stochastic - alg_stochastic = GD(initial=initial, - objective_function=objective, update_objective_interval=500, - step_size=1/f_stochastic.L, max_iteration=5000) - alg_stochastic.run(n_subsets*50, verbose=0) - self.assertAlmostEqual(objective.data_passes[-1], n_subsets*50/n_subsets) - self.assertListEqual(objective.data_passes_indices[-1], [objective.function_num]) - self.assertNumpyArrayAlmostEqual( - alg_stochastic.x.as_array(), alg.x.as_array(), 3) - + - + @unittest.skipUnless(has_cvxpy, "CVXpy not installed") def test_SGD_toy_example(self): sampler = Sampler.random_with_replacement(5) initial = VectorData(np.zeros(25)) @@ -215,70 +174,30 @@ def test_SGD_toy_example(self): diagonal = np.zeros(25) diagonal[5*i:5*(i+1)] = 1 A = MatrixOperator(np.diag(diagonal)) - functions.append(LeastSquares(A, A.direct(b))) - if i == 0: - objective = LeastSquares(A, A.direct(b)) - else: - objective += LeastSquares(A, A.direct(b)) - - alg = GD(initial=initial, - objective_function=objective, update_objective_interval=1000, atol=1e-9, rtol=1e-6) - alg.max_iteration = 600 - alg.run(verbose=0) - self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) + functions.append(0.5*LeastSquares(A, A.direct(b))) + + Aop=MatrixOperator(np.diag(np.ones(25))) + u_cvxpy = cvxpy.Variable(b.shape[0]) + objective = cvxpy.Minimize( 0.5*cvxpy.sum_squares(Aop.A @ u_cvxpy - Aop.direct(b).array)) + p = cvxpy.Problem(objective) + p.solve(verbose=True, solver=cvxpy.SCS, eps=1e-4) + + stochastic_objective = SGFunction(functions, sampler) - self.assertAlmostEqual( - stochastic_objective(initial), objective(initial)) - self.assertNumpyArrayAlmostEqual(stochastic_objective.full_gradient( - initial).array, objective.gradient(initial).array) alg_stochastic = GD(initial=initial, objective_function=stochastic_objective, update_objective_interval=1000, - step_size=0.01, max_iteration=5000) + step_size=1/stochastic_objective.L) alg_stochastic.run(600, verbose=0) self.assertAlmostEqual(stochastic_objective.data_passes[-1], 600/5) self.assertListEqual(stochastic_objective.data_passes_indices[-1], [stochastic_objective.function_num]) + + np.testing.assert_allclose(p.value ,stochastic_objective(alg_stochastic.x) , atol=1e-1) self.assertNumpyArrayAlmostEqual( - alg_stochastic.x.as_array(), alg.x.as_array(), 3) + alg_stochastic.x.as_array(), u_cvxpy.value, 3) self.assertNumpyArrayAlmostEqual( alg_stochastic.x.as_array(), b.as_array(), 3) - @unittest.skipUnless(has_cvxpy, "CVXpy not installed") - def test_with_cvxpy(self): - np.random.seed(10) - n = 300 - m = 100 - A = np.random.normal(0,1, (m, n)).astype('float32') - b = np.random.normal(0,1, m).astype('float32') - - Aop = MatrixOperator(A) - bop = VectorData(b) - n_subsets = 10 - Ai = np.vsplit(A, n_subsets) - bi = [b[i:i+int(m/n_subsets)] for i in range(0, m, int(m/n_subsets))] - fi_cil = [] - for i in range(n_subsets): - Ai_cil = MatrixOperator(Ai[i]) - bi_cil = VectorData(bi[i]) - fi_cil.append(LeastSquares(Ai_cil, bi_cil, c = 0.5)) - F = LeastSquares(Aop, b=bop, c = 0.5) - ig = Aop.domain - initial= ig.allocate(0) - sampler=Sampler.random_with_replacement(n_subsets) - F_SG=SGFunction(fi_cil, sampler) - u_cvxpy = cvxpy.Variable(ig.shape[0]) - objective = cvxpy.Minimize( 0.5*cvxpy.sum_squares(Aop.A @ u_cvxpy - bop.array)) - p = cvxpy.Problem(objective) - p.solve(verbose=True, solver=cvxpy.SCS, eps=1e-4) - - step_size = 1./F_SG.L - - epochs = 200 - sgd = GD(initial = initial, objective_function = F_SG, step_size = step_size, - max_iteration = epochs * n_subsets, - update_objective_interval = epochs * n_subsets) - sgd.run(verbose=0) - np.testing.assert_allclose(p.value, sgd.objective[-1], atol=1e-1) - np.testing.assert_allclose(u_cvxpy.value, sgd.solution.array, atol=1e-1) \ No newline at end of file + \ No newline at end of file From f3e416a7d02c77edc6ba5dd52f4964a4dba99a1a Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 22 Mar 2024 15:32:10 +0000 Subject: [PATCH 145/152] Documentation for the multiplication factor --- .../optimisation/functions/ApproximateGradientSumFunction.py | 4 ++++ Wrappers/Python/cil/optimisation/functions/SGFunction.py | 2 +- 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 55233c48ec..2a324c01f3 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -51,6 +51,10 @@ class ApproximateGradientSumFunction(SumFunction, ABC): sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in :math:`{0,...,n-1}`. This sampler is called each time `gradient` is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. + Note + ---- + We ensure that the approximate gradient is of a similar order of magnitude to the full gradient calculation. For example, in the `SGFunction` we approximate the full gradient by :math:`n\nabla f_i` for an index :math:`i` given by the sampler. + The multiplication by `math:`n` is a choice to more easily allow comparisons between stochastic and non-stochastic methods with the same step-sizes. Note ----- diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 1696fd2e85..238d00a125 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -29,7 +29,7 @@ class SGFunction(ApproximateGradientSumFunction): r""" Stochastic gradient function, a child class of `ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_0,...,f_{n-1}}` a `SumFunction`, :math:`f_0+...+f_{n-1}` where each time the `gradient` is called, the `sampler` provides an index, :math:`i \in {0,...,n-1}` - and the gradient function returns the approximate gradient :math:`\nabla_x f_i(x)`. This can be used with the `cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. + and the gradient function returns the approximate gradient :math:`n \nabla_x f_i(x)`. This can be used with the `cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. Parameters: ----------- From c22868e36e88e0486030379698a146b9ff12acef Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 22 Mar 2024 15:40:12 +0000 Subject: [PATCH 146/152] Documentation for the multiplication factor --- .../optimisation/functions/ApproximateGradientSumFunction.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 2a324c01f3..07bd285818 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -52,9 +52,9 @@ class ApproximateGradientSumFunction(SumFunction, ABC): This sampler is called each time `gradient` is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. Note - ---- + ----- We ensure that the approximate gradient is of a similar order of magnitude to the full gradient calculation. For example, in the `SGFunction` we approximate the full gradient by :math:`n\nabla f_i` for an index :math:`i` given by the sampler. - The multiplication by `math:`n` is a choice to more easily allow comparisons between stochastic and non-stochastic methods with the same step-sizes. + The multiplication by `math:`n` is a choice to more easily allow comparisons between stochastic and non-stochastic methods and between stochastic methods with varying numbers of subsets. Note ----- From 561f3e73759792c85ee643ee73bbac95f32566f7 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Mar 2024 15:06:28 +0000 Subject: [PATCH 147/152] Improved documentation after discussion with Edo --- docs/source/optimisation.rst | 61 +++++++++++++++++++++++------------- 1 file changed, 40 insertions(+), 21 deletions(-) diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index c9cfe93ef2..c362eb7491 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -124,8 +124,13 @@ LADMM Algorithms (Stochastic) ======================== +Consider optimisation problems that take the form of a seperable sum: + +.. math:: \min_{x} f(x)+g(x) = \min_{x} \sum_{i=0}^{n-1} f_{i} + g = \min_{x} (f_{0} + f_{1} + ... + f_{n-1})+g + +where :math:`n` is the number of functions. Where there is a large number of :math:`f_i` or their gradients are expensive to calculate, stochastic optimisation methods could prove more efficient. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. There is a growing range of Stochastic optimisation algorithms available with potential benefits of faster convergence in number of iterations or in computational cost. -This is an area of continued development for CIL. +This is an area of continued development for CIL and, depending on the properties of the :math:`f_i` and the regulariser :math:`g`, there is a range of different options. @@ -137,7 +142,8 @@ Stochastic Primal Dual Hybrid Gradient (SPDHG) is a stochastic version of PDHG a \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) -by passing a sampler (e.g. of the CIL Sampler class) each iteration considers just one index of the sum reducing computational cost. For more examples see our [user notebooks]( https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py). +where :math:`f_i` and the regulariser :math:`g` need only be proper, convex and lower semi-continuous ( i.e. do not need to be differentiable). +Each iteration considers just one index of the sum reducing computational cost. For more examples see our [user notebooks]( https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py). .. autoclass:: cil.optimisation.algorithms.SPDHG @@ -147,20 +153,25 @@ by passing a sampler (e.g. of the CIL Sampler class) each iteration considers ju -Approximate gradient sum function +Approximate gradient methods ---------------------------------- -Alternatively, consider optimisation problems of the form: +Alternatively, consider that, in addition, the :math:`f_i` are differentiable. In this case we consider stochastic methods that replace a gradient calculation in a deterministic algorithm with a, potentially cheaper to calculate, approximate gradient. +For example, when :math:`g(x)=0`, the standard Gradient Descent algorithm utilises iterations of the form -.. math:: \sum_{i=0}^{n-1} f_{i} = (f_{0} + f_{1} + ... + f_{n-1}) + .. math:: + x_{k+1}=x_k-\alpha \nabla f(x_k) =x_k-\alpha \sum_{i=0}^{n-1}\nabla f_i(x_k). -where :math:`n` is the number of functions. Where there is a large number of :math:`f_i` or their gradients are expensive to calculate, stochastic optimisation methods could prove more efficient. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. +Replacing, :math:`\nabla f(x_k)=\sum_{i=0}^{n-1}\nabla f_i(x_k)` with :math:`n \nabla f_i(x_k)`, for an index :math:`i` which changes each iteration, leads to the well known stochastic gradient descent algorith. -The idea for this class and its sum functions is to consider that some stochastic optimisation algorithms can be viewed as deterministic gradient descent algorithms replacing the gradient with an approximate gradient. For example Stochastic Gradient Descent replaces the gradient in Gradient Descent with the gradient of just one of the :math:`f_i`. - -CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation of a sum function with an approximate gradient. Child classes of this abstract base class can define different approximate gradients with different mathematical properties. +In addition, if :math:`g(x)\neq 0` (and may not be differentiable) one can consider ISTA iterations: -For example in the following table, the left hand column has the approximate gradient function subclass, the header row has the optimisation algorithm and the body of the table has the resulting stochastic algorithm. + .. math:: + x_{k+1}=\prox_{\alpha g}(x_k-\alpha \nabla f(x_k) )=\prox_{\alpha g}(x_k-\alpha \sum_{i=0}^{n-1}\nabla f_i(x_k)) + +and again replacing math:`\nabla f(x_k)=\sum_{i=0}^{n-1}\nabla f_i(x_k)` with an approximate gradient. + +In a similar way, plugging approximate gradient calculations into deterministic algorithms can lead to a range of stochastic algorithms. In the following table, the left hand column has the approximate gradient function subclass, the header row has the optimisation algorithm and the body of the table has the resulting stochastic algorithm. +----------------+-------+------------+----------------+ | | GD | ISTA | FISTA | @@ -178,6 +189,10 @@ For example in the following table, the left hand column has the approximate gra \*In development +The stochastic gradient functions can be found listed under functions in the documentation. + +Stochastic Gradient Descent Example +---------------------------------- The below is an example of Stochastic Gradient Descent built of the SGFunction and Gradient Descent algorithm: .. code-block :: python @@ -215,18 +230,7 @@ The below is an example of Stochastic Gradient Descent built of the SGFunction a -The base class: - -.. autoclass:: cil.optimisation.functions.ApproximateGradientSumFunction - :members: - :inherited-members: - - -The currently provided child-classes: -.. autoclass:: cil.optimisation.functions.SGFunction - :members: - :inherited-members: @@ -470,6 +474,21 @@ Total variation :members: :inherited-members: +Approximate Gradient base class +-------------------------------- + +.. autoclass:: cil.optimisation.functions.ApproximateGradientSumFunction + :members: + :inherited-members: + + +Stochastic Gradient function +----------------------------- + +.. autoclass:: cil.optimisation.functions.SGFunction + :members: + :inherited-members: + Utilities ========= From eab5ce4ddefb2f2057d400c796d7356f8373257d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Mar 2024 16:25:49 +0000 Subject: [PATCH 148/152] Neaten documentation --- docs/source/optimisation.rst | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index c362eb7491..97cba9bf70 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -126,11 +126,11 @@ Algorithms (Stochastic) Consider optimisation problems that take the form of a seperable sum: -.. math:: \min_{x} f(x)+g(x) = \min_{x} \sum_{i=0}^{n-1} f_{i} + g = \min_{x} (f_{0} + f_{1} + ... + f_{n-1})+g +.. math:: \min_{x} f(x)+g(x) = \min_{x} \sum_{i=0}^{n-1} f_{i}(x) + g(x) = \min_{x} (f_{0}(x) + f_{1}(x) + ... + f_{n-1}(x))+g(x) -where :math:`n` is the number of functions. Where there is a large number of :math:`f_i` or their gradients are expensive to calculate, stochastic optimisation methods could prove more efficient. CIL provides an abstract base class which defines the sum function and overwrites the usual (full) gradient calculation with an approximate gradient. +where :math:`n` is the number of functions. Where there is a large number of :math:`f_i` or their gradients are expensive to calculate, stochastic optimisation methods could prove more efficient. There is a growing range of Stochastic optimisation algorithms available with potential benefits of faster convergence in number of iterations or in computational cost. -This is an area of continued development for CIL and, depending on the properties of the :math:`f_i` and the regulariser :math:`g`, there is a range of different options. +This is an area of continued development for CIL and, depending on the properties of the :math:`f_i` and the regulariser :math:`g`, there is a range of different options for the user. @@ -143,7 +143,7 @@ Stochastic Primal Dual Hybrid Gradient (SPDHG) is a stochastic version of PDHG a \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) where :math:`f_i` and the regulariser :math:`g` need only be proper, convex and lower semi-continuous ( i.e. do not need to be differentiable). -Each iteration considers just one index of the sum reducing computational cost. For more examples see our [user notebooks]( https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py). +Each iteration considers just one index of the sum, potentially reducing computational cost. For more examples see our [user notebooks]( https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py). .. autoclass:: cil.optimisation.algorithms.SPDHG @@ -156,7 +156,7 @@ Each iteration considers just one index of the sum reducing computational cost. Approximate gradient methods ---------------------------------- -Alternatively, consider that, in addition, the :math:`f_i` are differentiable. In this case we consider stochastic methods that replace a gradient calculation in a deterministic algorithm with a, potentially cheaper to calculate, approximate gradient. +Alternatively, consider that, in addition to the functions :math:`f_i` and the regulariser :math:`g` being proper, convex and lower semi-continuous, the :math:`f_i` are differentiable. In this case we consider stochastic methods that replace a gradient calculation in a deterministic algorithm with a, potentially cheaper to calculate, approximate gradient. For example, when :math:`g(x)=0`, the standard Gradient Descent algorithm utilises iterations of the form .. math:: @@ -164,12 +164,12 @@ For example, when :math:`g(x)=0`, the standard Gradient Descent algorithm utilis Replacing, :math:`\nabla f(x_k)=\sum_{i=0}^{n-1}\nabla f_i(x_k)` with :math:`n \nabla f_i(x_k)`, for an index :math:`i` which changes each iteration, leads to the well known stochastic gradient descent algorith. -In addition, if :math:`g(x)\neq 0` (and may not be differentiable) one can consider ISTA iterations: +In addition, if :math:`g(x)\neq 0` and has a calculable proximal ( need not be differentiable) one can consider ISTA iterations: .. math:: - x_{k+1}=\prox_{\alpha g}(x_k-\alpha \nabla f(x_k) )=\prox_{\alpha g}(x_k-\alpha \sum_{i=0}^{n-1}\nabla f_i(x_k)) + x_{k+1}=prox_{\alpha g}(x_k-\alpha \nabla f(x_k) )=prox_{\alpha g}(x_k-\alpha \sum_{i=0}^{n-1}\nabla f_i(x_k)) -and again replacing math:`\nabla f(x_k)=\sum_{i=0}^{n-1}\nabla f_i(x_k)` with an approximate gradient. +and again replacing :math:`\nabla f(x_k)=\sum_{i=0}^{n-1}\nabla f_i(x_k)` with an approximate gradient. In a similar way, plugging approximate gradient calculations into deterministic algorithms can lead to a range of stochastic algorithms. In the following table, the left hand column has the approximate gradient function subclass, the header row has the optimisation algorithm and the body of the table has the resulting stochastic algorithm. From ddb159d30cf1b776626c2908a12528ae3d82368c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 26 Mar 2024 08:25:04 +0000 Subject: [PATCH 149/152] Some of Edo's comments --- .../functions/ApproximateGradientSumFunction.py | 12 ++++++------ .../Python/cil/optimisation/functions/SGFunction.py | 8 ++++---- docs/source/optimisation.rst | 6 +++--- 3 files changed, 13 insertions(+), 13 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index 07bd285818..e43f3a3d62 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -42,14 +42,14 @@ class ApproximateGradientSumFunction(SumFunction, ABC): - This class is an abstract base class and therefore is not able to be used as is. It is designed to be sub-classed with different approximate gradient implementations. + This class is an abstract class. Parameters: ----------- functions : `list` of functions A list of functions: :math:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in :math:`{0,...,n-1}`. - This sampler is called each time `gradient` is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a :code:`__next__` function implemented to output integers in :math:`{0,...,n-1}`. + This sampler is called each time :code:`gradient` is called and sets the internal :code:`function_num` passed to the :code:`approximate_gradient` function. Default is :code:`Sampler.random_with_replacement(len(functions))`. Note ----- @@ -58,9 +58,9 @@ class ApproximateGradientSumFunction(SumFunction, ABC): Note ----- - Each time `gradient` is called the class keeps track of which functions have been used to calculate the gradient. This may be useful for debugging or plotting after using this function in an iterative algorithm: - - `data_passes_indices` is a list of lists. Each time `gradient` is called a list is appended with with the indices of the functions have been used to calculate the gradient. - - `data_passes` is a list. Each time `gradient` is called an entry is appended with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. + Each time :code:`gradient` is called the class keeps track of which functions have been used to calculate the gradient. This may be useful for debugging or plotting after using this function in an iterative algorithm: + - :code:`data_passes_indices` is a list of lists. Each time :code:`gradient` is called a list is appended with with the indices of the functions have been used to calculate the gradient. + - :code:`data_passes` is a list. Each time :code:`gradient` is called an entry is appended with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the :code:`set_data_partition_weights` function for this to be accurate. diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 238d00a125..4841b5d5da 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -28,15 +28,15 @@ class SGFunction(ApproximateGradientSumFunction): r""" - Stochastic gradient function, a child class of `ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_0,...,f_{n-1}}` a `SumFunction`, :math:`f_0+...+f_{n-1}` where each time the `gradient` is called, the `sampler` provides an index, :math:`i \in {0,...,n-1}` - and the gradient function returns the approximate gradient :math:`n \nabla_x f_i(x)`. This can be used with the `cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. + Stochastic gradient function, a child class of :code:`ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_0,...,f_{n-1}}` a `SumFunction`, :math:`f_0+...+f_{n-1}` where each time the :code:`gradient` is called, the :code:`sampler` provides an index, :math:`i \in {0,...,n-1}` + and the gradient function returns the approximate gradient :math:`n \nabla_x f_i(x)`. This can be used with the :code:`cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. Parameters: ----------- functions : `list` of functions A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions must be strictly greater than 1. - sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a `next` function implemented to output integers in {0,...,n-1}. - This sampler is called each time gradient is called and sets the internal `function_num` passed to the `approximate_gradient` function. Default is `Sampler.random_with_replacement(len(functions))`. + sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a :code:`__next__` function implemented to output integers in {0,...,n-1}. + This sampler is called each time gradient is called and sets the internal :code:`function_num` passed to the :code:`approximate_gradient` function. Default is :code:`Sampler.random_with_replacement(len(functions))`. """ def __init__(self, functions, sampler=None): diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 97cba9bf70..1309e379f0 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -124,7 +124,7 @@ LADMM Algorithms (Stochastic) ======================== -Consider optimisation problems that take the form of a seperable sum: +Consider optimisation problems that take the form of a separable sum: .. math:: \min_{x} f(x)+g(x) = \min_{x} \sum_{i=0}^{n-1} f_{i}(x) + g(x) = \min_{x} (f_{0}(x) + f_{1}(x) + ... + f_{n-1}(x))+g(x) @@ -162,7 +162,7 @@ For example, when :math:`g(x)=0`, the standard Gradient Descent algorithm utilis .. math:: x_{k+1}=x_k-\alpha \nabla f(x_k) =x_k-\alpha \sum_{i=0}^{n-1}\nabla f_i(x_k). -Replacing, :math:`\nabla f(x_k)=\sum_{i=0}^{n-1}\nabla f_i(x_k)` with :math:`n \nabla f_i(x_k)`, for an index :math:`i` which changes each iteration, leads to the well known stochastic gradient descent algorith. +Replacing, :math:`\nabla f(x_k)=\sum_{i=0}^{n-1}\nabla f_i(x_k)` with :math:`n \nabla f_i(x_k)`, for an index :math:`i` which changes each iteration, leads to the well known stochastic gradient descent algorithm. In addition, if :math:`g(x)\neq 0` and has a calculable proximal ( need not be differentiable) one can consider ISTA iterations: @@ -171,7 +171,7 @@ In addition, if :math:`g(x)\neq 0` and has a calculable proximal ( need not be d and again replacing :math:`\nabla f(x_k)=\sum_{i=0}^{n-1}\nabla f_i(x_k)` with an approximate gradient. -In a similar way, plugging approximate gradient calculations into deterministic algorithms can lead to a range of stochastic algorithms. In the following table, the left hand column has the approximate gradient function subclass, the header row has the optimisation algorithm and the body of the table has the resulting stochastic algorithm. +In a similar way, plugging approximate gradient calculations into deterministic algorithms can lead to a range of stochastic algorithms. In the following table, the left hand column has the approximate gradient function subclass, :ref:`Approximate Gradient base class` the header row has one of CIL's deterministic optimisation algorithm and the body of the table has the resulting stochastic algorithm. +----------------+-------+------------+----------------+ | | GD | ISTA | FISTA | From 13ded02081503c545cfe337b1604f325959d98a4 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 26 Mar 2024 09:07:29 +0000 Subject: [PATCH 150/152] Edo's comments --- .../ApproximateGradientSumFunction.py | 18 +++++++++--------- .../cil/optimisation/functions/SGFunction.py | 8 ++++---- 2 files changed, 13 insertions(+), 13 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index e43f3a3d62..d2ab01b3a1 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -37,8 +37,8 @@ class ApproximateGradientSumFunction(SumFunction, ABC): .. math:: \sum_{i=0}^{n-1} f_{i} = (f_{0} + f_{2} + ... + f_{n-1}) where there are :math:`n` functions. This function class has two ways of calling gradient: - - `full_gradient` calculates the gradient of the sum :math:`\sum_{i=0}^{n-1} \nabla f_{i}` - - `gradient` calls an `approximate_gradient` function which may be less computationally expensive to calculate than the full gradient + - `full_gradient` calculates the gradient of the sum :math:`\sum_{i=0}^{n-1} \nabla f_{i}` + - `gradient` calls an `approximate_gradient` function which may be less computationally expensive to calculate than the full gradient @@ -53,14 +53,14 @@ class ApproximateGradientSumFunction(SumFunction, ABC): Note ----- - We ensure that the approximate gradient is of a similar order of magnitude to the full gradient calculation. For example, in the `SGFunction` we approximate the full gradient by :math:`n\nabla f_i` for an index :math:`i` given by the sampler. - The multiplication by `math:`n` is a choice to more easily allow comparisons between stochastic and non-stochastic methods and between stochastic methods with varying numbers of subsets. + We ensure that the approximate gradient is of a similar order of magnitude to the full gradient calculation. For example, in the :code:`SGFunction` we approximate the full gradient by :math:`n\nabla f_i` for an index :math:`i` given by the sampler. + The multiplication by :math:`n` is a choice to more easily allow comparisons between stochastic and non-stochastic methods and between stochastic methods with varying numbers of subsets. Note ----- Each time :code:`gradient` is called the class keeps track of which functions have been used to calculate the gradient. This may be useful for debugging or plotting after using this function in an iterative algorithm: - - :code:`data_passes_indices` is a list of lists. Each time :code:`gradient` is called a list is appended with with the indices of the functions have been used to calculate the gradient. - - :code:`data_passes` is a list. Each time :code:`gradient` is called an entry is appended with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the :code:`set_data_partition_weights` function for this to be accurate. + - :code:`data_passes_indices` is a list of lists. Each time :code:`gradient` is called a list is appended with with the indices of the functions have been used to calculate the gradient. + - :code:`data_passes` is a list. Each time :code:`gradient` is called an entry is appended with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the :code:`set_data_partition_weights` function for this to be accurate. @@ -159,7 +159,7 @@ def approximate_gradient(self, x, function_num, out=None): Returns -------- DataContainer - the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {0,...,len(functions)-1} or nothing if `out` + the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {0,...,len(functions)-1} """ pass @@ -174,7 +174,7 @@ def gradient(self, x, out=None): Returns -------- DataContainer - the value of the approximate gradient of the sum function at :code:`x` or nothing if `out` + the value of the approximate gradient of the sum function at :code:`x` """ self.function_num = self.sampler.next() @@ -225,7 +225,7 @@ def data_passes_indices(self): @property def data_passes(self): - """ The property `data_passes` is a list. Each time `gradient` is called an entry is appended with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. """ + """ The property `data_passes` is a list of floats. Each time `gradient` is called an entry is appended to this list with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. """ data_passes = [] for el in self._data_passes_indices: try: diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index 4841b5d5da..e1f8e5fe19 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -28,13 +28,13 @@ class SGFunction(ApproximateGradientSumFunction): r""" - Stochastic gradient function, a child class of :code:`ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_0,...,f_{n-1}}` a `SumFunction`, :math:`f_0+...+f_{n-1}` where each time the :code:`gradient` is called, the :code:`sampler` provides an index, :math:`i \in {0,...,n-1}` - and the gradient function returns the approximate gradient :math:`n \nabla_x f_i(x)`. This can be used with the :code:`cil.optimisation.algorithms` algorithm GD to give a stochastic gradient descent algorithm. + Stochastic gradient function, a child class of :code:`ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_0,...,f_{n-1}}` a `SumFunction`, :math:`f_0+...+f_{n-1}` where each time the `gradient` is called, the :code:`sampler` provides an index, :math:`i \in {0,...,n-1}` + and the :code:`gradient` method returns the approximate gradient :math:`n \nabla_x f_i(x)`. This can be used with the :code:`cil.optimisation.algorithms` algorithm :code:`GD` to give a stochastic gradient descent algorithm. Parameters: ----------- functions : `list` of functions - A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions must be strictly greater than 1. + A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. Although CIL does not define a domain of a :code:`Function`, all functions are supposed to have the same domain. The number of functions must be strictly greater than 1. sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a :code:`__next__` function implemented to output integers in {0,...,n-1}. This sampler is called each time gradient is called and sets the internal :code:`function_num` passed to the :code:`approximate_gradient` function. Default is :code:`Sampler.random_with_replacement(len(functions))`. """ @@ -56,7 +56,7 @@ def approximate_gradient(self, x, function_num, out=None): Returns -------- DataContainer - the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {0,...,len(functions)-1} or nothing if `out` + the value of the approximate gradient of the sum function at :code:`x` given a `function_number` in {0,...,len(functions)-1} """ if self.function_num >= self.num_functions or self.function_num<0 : raise IndexError( From e976cf7dc1f4879a7632b5ee77b9fc69d49ac64d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 26 Mar 2024 09:42:27 +0000 Subject: [PATCH 151/152] Try to fix formating in documentation --- .../ApproximateGradientSumFunction.py | 22 ++++++++++--------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py index d2ab01b3a1..e4109c7980 100644 --- a/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/ApproximateGradientSumFunction.py @@ -36,18 +36,19 @@ class ApproximateGradientSumFunction(SumFunction, ABC): .. math:: \sum_{i=0}^{n-1} f_{i} = (f_{0} + f_{2} + ... + f_{n-1}) - where there are :math:`n` functions. This function class has two ways of calling gradient: - - `full_gradient` calculates the gradient of the sum :math:`\sum_{i=0}^{n-1} \nabla f_{i}` - - `gradient` calls an `approximate_gradient` function which may be less computationally expensive to calculate than the full gradient + where there are :math:`n` functions. This function class has two ways of calling gradient + + - `full_gradient` calculates the gradient of the sum :math:`\sum_{i=0}^{n-1} \nabla f_{i}` + - `gradient` calls an `approximate_gradient` function which may be less computationally expensive to calculate than the full gradient This class is an abstract class. - Parameters: + Parameters ----------- functions : `list` of functions - A list of functions: :math:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. + A list of functions: :math:`[f_{0}, f_{2}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. All functions must have the same domain. The number of functions (equivalently the length of the list) must be strictly greater than 1. sampler: An instance of a CIL Sampler class ( :meth:`~optimisation.utilities.sampler`) or of another class which has a :code:`__next__` function implemented to output integers in :math:`{0,...,n-1}`. This sampler is called each time :code:`gradient` is called and sets the internal :code:`function_num` passed to the :code:`approximate_gradient` function. Default is :code:`Sampler.random_with_replacement(len(functions))`. @@ -58,9 +59,10 @@ class ApproximateGradientSumFunction(SumFunction, ABC): Note ----- - Each time :code:`gradient` is called the class keeps track of which functions have been used to calculate the gradient. This may be useful for debugging or plotting after using this function in an iterative algorithm: - - :code:`data_passes_indices` is a list of lists. Each time :code:`gradient` is called a list is appended with with the indices of the functions have been used to calculate the gradient. - - :code:`data_passes` is a list. Each time :code:`gradient` is called an entry is appended with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the :code:`set_data_partition_weights` function for this to be accurate. + Each time :code:`gradient` is called the class keeps track of which functions have been used to calculate the gradient. This may be useful for debugging or plotting after using this function in an iterative algorithm. + + - The property :code:`data_passes_indices` is a list of lists holding the indices of the functions that are processed in each call of `gradient`. This list is updated each time `gradient` is called by appending a list of the indices of the functions used to calculate the gradient. + - The property :code:`data_passes` is a list of floats that holds the amount of data that has been processed up until each call of `gradient`. This list is updated each time `gradient` is called by appending the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. @@ -220,12 +222,12 @@ def set_data_partition_weights(self, weights): @property def data_passes_indices(self): - """ The property `data_passes_indices` is a list of lists. Each time `gradient` is called a list is appended with with the indices of the functions have been used to calculate the gradient. """ + """ The property :code:`data_passes_indices` is a list of lists holding the indices of the functions that are processed in each call of `gradient`. This list is updated each time `gradient` is called by appending a list of the indices of the functions used to calculate the gradient. """ return self._data_passes_indices @property def data_passes(self): - """ The property `data_passes` is a list of floats. Each time `gradient` is called an entry is appended to this list with the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. """ + """ The property :code:`data_passes` is a list of floats that holds the amount of data that has been processed up until each call of `gradient`. This list is updated each time `gradient` is called by appending the proportion of the data used when calculating the approximate gradient since the class was initialised (a full gradient calculation would be 1 full data pass). Warning: if your functions do not contain an equal `amount` of data, for example your data was not partitioned into equal batches, then you must first use the `set_data_partition_weights" function for this to be accurate. """ data_passes = [] for el in self._data_passes_indices: try: From bc6d8b5344b6ebda4312b54760130e66ae74413c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 26 Mar 2024 09:53:05 +0000 Subject: [PATCH 152/152] Update change log --- CHANGELOG.md | 1 + Wrappers/Python/cil/optimisation/functions/SGFunction.py | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6198f8407c..ac43faaed2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -40,6 +40,7 @@ - Improved import error/warning messages - New adjoint operator - Bug fix for complex matrix adjoint + - Added the ApproximateGradientSumFunction and SGFunction to allow for stochastic gradient algorithms to be created using functions with an approximate gradient and deterministic algorithms * 23.1.0 diff --git a/Wrappers/Python/cil/optimisation/functions/SGFunction.py b/Wrappers/Python/cil/optimisation/functions/SGFunction.py index e1f8e5fe19..ba7dd780b4 100644 --- a/Wrappers/Python/cil/optimisation/functions/SGFunction.py +++ b/Wrappers/Python/cil/optimisation/functions/SGFunction.py @@ -31,7 +31,7 @@ class SGFunction(ApproximateGradientSumFunction): Stochastic gradient function, a child class of :code:`ApproximateGradientSumFunction`, which defines from a list of functions, :math:`{f_0,...,f_{n-1}}` a `SumFunction`, :math:`f_0+...+f_{n-1}` where each time the `gradient` is called, the :code:`sampler` provides an index, :math:`i \in {0,...,n-1}` and the :code:`gradient` method returns the approximate gradient :math:`n \nabla_x f_i(x)`. This can be used with the :code:`cil.optimisation.algorithms` algorithm :code:`GD` to give a stochastic gradient descent algorithm. - Parameters: + Parameters ----------- functions : `list` of functions A list of functions: :code:`[f_{0}, f_{1}, ..., f_{n-1}]`. Each function is assumed to be smooth with an implemented :func:`~Function.gradient` method. Although CIL does not define a domain of a :code:`Function`, all functions are supposed to have the same domain. The number of functions must be strictly greater than 1.