From b6d4920f2c84f92b6a4d25cbe2c9aa29a0429b4d Mon Sep 17 00:00:00 2001 From: Jaroslav Fowkes Date: Wed, 18 Sep 2024 07:35:52 +0100 Subject: [PATCH] Use sqrt of fluence and apply twice --- ptypy/engines/ML.py | 149 +++++++++--------- templates/notebooks/moonflower_ml.ipynb | 128 ++++++++------- .../notebooks/moonflower_ml_wavefield.ipynb | 147 +++++++++++++++++ 3 files changed, 294 insertions(+), 130 deletions(-) create mode 100644 templates/notebooks/moonflower_ml_wavefield.ipynb diff --git a/ptypy/engines/ML.py b/ptypy/engines/ML.py index db5107f5b..827fe1198 100644 --- a/ptypy/engines/ML.py +++ b/ptypy/engines/ML.py @@ -106,21 +106,21 @@ class ML(PositionCorrectionEngine): help = How many coefficients to be used in the the linesearch doc = choose between the 'quadratic' approximation (default) or 'all' - [lipschitz_precond] + [wavefield_precond] default = False type = bool - help = Whether to use the Lipschitz preconditioner + help = Whether to use the wavefield preconditioner doc = This parameter can give faster convergence. - [lipschitz_delta_object] + [wavefield_delta_object] default = 0.1 type = float - help = Lipschitz preconditioner damping constant for the object. + help = Wavefield preconditioner damping constant for the object. - [lipschitz_delta_probe] + [wavefield_delta_probe] default = 0.1 type = float - help = Lipschitz preconditioner damping constant for the probe. + help = Wavefield preconditioner damping constant for the probe. """ @@ -153,10 +153,10 @@ def __init__(self, ptycho_parent, pars=None): # Probe gradient self.pr_grad_new = None - # Object and probe normalisation - if self.p.lipschitz_precond: - self.ob_nrm = None - self.pr_nrm = None + # Object and probe fluence maps + if self.p.wavefield_precond: + self.ob_fln = None + self.pr_fln = None # Other self.tmin = None @@ -192,10 +192,10 @@ def engine_initialize(self): self.pr_grad_new = self.pr.copy(self.pr.ID + '_grad_new', fill=0.) self.pr_h = self.pr.copy(self.pr.ID + '_h', fill=0.) - # Object and probe normalisation - if self.p.lipschitz_precond: - self.ob_nrm = self.ob.copy(self.ob.ID + '_nrm', fill=0., dtype='real') - self.pr_nrm = self.pr.copy(self.pr.ID + '_nrm', fill=0., dtype='real') + # Object and probe fluence maps + if self.p.wavefield_precond: + self.ob_fln = self.ob.copy(self.ob.ID + '_fln', fill=0., dtype='real') + self.pr_fln = self.pr.copy(self.pr.ID + '_fln', fill=0., dtype='real') self.tmin = 1. @@ -255,12 +255,12 @@ def engine_iterate(self, num=1): else: new_pr_grad.fill(0.) - # Lipschitz preconditioner - if self.p.lipschitz_precond: - self.ob_nrm += self.p.lipschitz_delta_object - self.pr_nrm += self.p.lipschitz_delta_probe - new_ob_grad /= self.ob_nrm - new_pr_grad /= self.pr_nrm + # Wavefield preconditioner + if self.p.wavefield_precond: + self.ob_fln += self.p.wavefield_delta_object + self.pr_fln += self.p.wavefield_delta_probe + new_ob_grad /= self.ob_fln + new_pr_grad /= self.pr_fln # Smoothing preconditioner if self.smooth_gradient: @@ -311,15 +311,14 @@ def engine_iterate(self, num=1): # 3. Next conjugate self.ob_h *= bt / self.tmin - # Smoothing and Lipschitz preconditioners for the object - # if self.smooth_gradient and self.p.lipschitz_precond: - # for name, s in self.ob_h.storages.items(): - # s.data[:] -= self.smooth_gradient(self.ob_grad.storages[name].data / self.ob_nrm.storages[name].data) - # elif self.p.lipschitz_precond: - # for name, s in self.ob_h.storages.items(): - # s.data[:] -= self.ob_grad.storages[name].data / self.ob_nrm.storages[name].data - # elif self.smooth_gradient: - if self.smooth_gradient: + # Smoothing and wavefield preconditioners for the object + if self.smooth_gradient and self.p.wavefield_precond: + for name, s in self.ob_h.storages.items(): + s.data[:] -= self.smooth_gradient(self.ob_grad.storages[name].data / self.ob_fln.storages[name].data) + elif self.p.wavefield_precond: + for name, s in self.ob_h.storages.items(): + s.data[:] -= self.ob_grad.storages[name].data / self.ob_fln.storages[name].data + elif self.smooth_gradient: for name, s in self.ob_h.storages.items(): s.data[:] -= self.smooth_gradient(self.ob_grad.storages[name].data) else: @@ -327,12 +326,12 @@ def engine_iterate(self, num=1): self.pr_h *= bt / self.tmin self.pr_grad *= self.scale_p_o - # # Lipschitz preconditioner for the probe - # if self.p.lipschitz_precond: - # for name, s in self.pr_h.storages.items(): - # s.data[:] -= self.pr_grad.storages[name].data / self.pr_nrm.storages[name].data - # else: - self.pr_h -= self.pr_grad + # Wavefield preconditioner for the probe + if self.p.wavefield_precond: + for name, s in self.pr_h.storages.items(): + s.data[:] -= self.pr_grad.storages[name].data / self.pr_fln.storages[name].data + else: + self.pr_h -= self.pr_grad # In principle, the way things are now programmed this part # could be iterated over in a real Newton-Raphson style. @@ -353,9 +352,9 @@ def engine_iterate(self, num=1): self.tmin = dt(-0.5 * B[1] / B[2]) else: raise NotImplementedError("poly_line_coeffs should be 'quadratic' or 'all'") - + tc += time.time() - t2 - + self.ob_h *= self.tmin self.pr_h *= self.tmin self.ob += self.ob_h @@ -397,11 +396,11 @@ def engine_finalize(self): del self.pr_grad_new del self.ptycho.containers[self.pr_h.ID] del self.pr_h - if self.p.lipschitz_precond: - del self.ptycho.containers[self.ob_nrm.ID] - del self.ob_nrm - del self.ptycho.containers[self.pr_nrm.ID] - del self.pr_nrm + if self.p.wavefield_precond: + del self.ptycho.containers[self.ob_fln.ID] + del self.ob_fln + del self.ptycho.containers[self.pr_fln.ID] + del self.pr_fln # Save floating intensities into runtime self.ptycho.runtime["float_intens"] = parallel.gather_dict(self.ML_model.float_intens_coeff) @@ -426,9 +425,9 @@ def __init__(self, MLengine): self.ob = self.engine.ob self.ob_grad = self.engine.ob_grad_new self.pr_grad = self.engine.pr_grad_new - if self.p.lipschitz_precond: - self.ob_nrm = self.engine.ob_nrm - self.pr_nrm = self.engine.pr_nrm + if self.p.wavefield_precond: + self.ob_fln = self.engine.ob_fln + self.pr_fln = self.engine.pr_fln self.pr = self.engine.pr self.float_intens_coeff = {} @@ -542,9 +541,9 @@ def new_grad(self): """ self.ob_grad.fill(0.) self.pr_grad.fill(0.) - if self.p.lipschitz_precond: - self.ob_nrm.fill(0.) - self.pr_nrm.fill(0.) + if self.p.wavefield_precond: + self.ob_fln.fill(0.) + self.pr_fln.fill(0.) # We need an array for MPI LL = np.array([0.]) @@ -586,10 +585,10 @@ def new_grad(self): self.ob_grad[pod.ob_view] += 2. * xi * pod.probe.conj() self.pr_grad[pod.pr_view] += 2. * xi * pod.object.conj() - # Compute normalisations for object and probe - if self.p.lipschitz_precond: - self.ob_nrm[pod.ob_view] += u.abs2(pod.probe) - self.pr_nrm[pod.pr_view] += u.abs2(pod.object) + # Compute fluence maps for object and probe + if self.p.wavefield_precond: + self.ob_fln[pod.ob_view] += np.sqrt(u.abs2(pod.probe)) + self.pr_fln[pod.pr_view] += np.sqrt(u.abs2(pod.object)) diff_view.error = LLL error_dct[dname] = np.array([0, LLL / np.prod(DI.shape), 0]) @@ -598,9 +597,9 @@ def new_grad(self): # MPI reduction of gradients self.ob_grad.allreduce() self.pr_grad.allreduce() - if self.p.lipschitz_precond: - self.ob_nrm.allreduce() - self.pr_nrm.allreduce() + if self.p.wavefield_precond: + self.ob_fln.allreduce() + self.pr_fln.allreduce() parallel.allreduce(LL) # Object regularizer @@ -796,9 +795,9 @@ def new_grad(self): """ self.ob_grad.fill(0.) self.pr_grad.fill(0.) - if self.p.lipschitz_precond: - self.ob_nrm.fill(0.) - self.pr_nrm.fill(0.) + if self.p.wavefield_precond: + self.ob_fln.fill(0.) + self.pr_fln.fill(0.) # We need an array for MPI LL = np.array([0.]) @@ -840,10 +839,10 @@ def new_grad(self): self.ob_grad[pod.ob_view] += 2 * xi * pod.probe.conj() self.pr_grad[pod.pr_view] += 2 * xi * pod.object.conj() - # Compute normalisations for object and probe - if self.p.lipschitz_precond: - self.ob_nrm[pod.ob_view] += u.abs2(pod.probe) - self.pr_nrm[pod.pr_view] += u.abs2(pod.object) + # Compute fluence maps for object and probe + if self.p.wavefield_precond: + self.ob_fln[pod.ob_view] += np.sqrt(u.abs2(pod.probe)) + self.pr_fln[pod.pr_view] += np.sqrt(u.abs2(pod.object)) diff_view.error = LLL error_dct[dname] = np.array([0, LLL / np.prod(DI.shape), 0]) @@ -852,9 +851,9 @@ def new_grad(self): # MPI reduction of gradients self.ob_grad.allreduce() self.pr_grad.allreduce() - if self.p.lipschitz_precond: - self.ob_nrm.allreduce() - self.pr_nrm.allreduce() + if self.p.wavefield_precond: + self.ob_fln.allreduce() + self.pr_fln.allreduce() parallel.allreduce(LL) # Object regularizer @@ -1063,9 +1062,9 @@ def new_grad(self): """ self.ob_grad.fill(0.) self.pr_grad.fill(0.) - if self.p.lipschitz_precond: - self.ob_nrm.fill(0.) - self.pr_nrm.fill(0.) + if self.p.wavefield_precond: + self.ob_fln.fill(0.) + self.pr_fln.fill(0.) # We need an array for MPI LL = np.array([0.]) @@ -1107,10 +1106,10 @@ def new_grad(self): self.ob_grad[pod.ob_view] += 2. * xi * pod.probe.conj() self.pr_grad[pod.pr_view] += 2. * xi * pod.object.conj() - # Compute normalisations for object and probe - if self.p.lipschitz_precond: - self.ob_nrm[pod.ob_view] += u.abs2(pod.probe) - self.pr_nrm[pod.pr_view] += u.abs2(pod.object) + # Compute fluence maps for object and probe + if self.p.wavefield_precond: + self.ob_fln[pod.ob_view] += np.sqrt(u.abs2(pod.probe)) + self.pr_fln[pod.pr_view] += np.sqrt(u.abs2(pod.object)) diff_view.error = LLL error_dct[dname] = np.array([0, LLL / np.prod(DA.shape), 0]) @@ -1119,9 +1118,9 @@ def new_grad(self): # MPI reduction of gradients self.ob_grad.allreduce() self.pr_grad.allreduce() - if self.p.lipschitz_precond: - self.ob_nrm.allreduce() - self.pr_nrm.allreduce() + if self.p.wavefield_precond: + self.ob_fln.allreduce() + self.pr_fln.allreduce() parallel.allreduce(LL) # Object regularizer diff --git a/templates/notebooks/moonflower_ml.ipynb b/templates/notebooks/moonflower_ml.ipynb index b1cab354d..ffd0781c4 100644 --- a/templates/notebooks/moonflower_ml.ipynb +++ b/templates/notebooks/moonflower_ml.ipynb @@ -11,13 +11,17 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "python" + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[SCLTMAC423:28244] shmem: mmap: an error occurred while determining whether or not /var/folders/zb/m51h9ld51gq2x0fygstdbp1h0000gq/T//ompi.SCLTMAC423.503/jf.0/377552896/sm_segment.SCLTMAC423.503.16810000.0 could be created.\n" + ] } - }, - "outputs": [], + ], "source": [ "from ptypy.core import Ptycho\n", "from ptypy import utils as u" @@ -25,12 +29,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "python" - } - }, + "execution_count": 2, + "metadata": {}, "outputs": [], "source": [ "# create parameter tree\n", @@ -39,12 +39,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "python" - } - }, + "execution_count": 3, + "metadata": {}, "outputs": [], "source": [ "# set verbose level to interactive\n", @@ -53,12 +49,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "python" - } - }, + "execution_count": 4, + "metadata": {}, "outputs": [], "source": [ "# set home path and io settings (no files saved)\n", @@ -71,12 +63,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "python" - } - }, + "execution_count": 5, + "metadata": {}, "outputs": [], "source": [ "# max 200 frames (128x128px) of diffraction data\n", @@ -95,12 +83,8 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "python" - } - }, + "execution_count": 6, + "metadata": {}, "outputs": [], "source": [ "# maximum likelihood reconstrucion engine\n", @@ -108,24 +92,39 @@ "p.engines.engine00 = u.Param()\n", "p.engines.engine00.name = 'ML'\n", "p.engines.engine00.ML_type = 'Gaussian'\n", - "p.engines.engine00.reg_del2 = True \n", - "p.engines.engine00.reg_del2_amplitude = 1. \n", - "p.engines.engine00.scale_precond = True\n", - "p.engines.engine00.smooth_gradient = 20.\n", - "p.engines.engine00.smooth_gradient_decay = 1/50.\n", - "p.engines.engine00.floating_intensities = False\n", - "p.engines.engine00.numiter = 300" + "#p.engines.engine00.reg_del2 = True \n", + "#p.engines.engine00.reg_del2_amplitude = 1. \n", + "#p.engines.engine00.scale_precond = True\n", + "#p.engines.engine00.smooth_gradient = 20.\n", + "#p.engines.engine00.smooth_gradient_decay = 1/50.\n", + "#p.engines.engine00.floating_intensities = False\n", + "p.engines.engine00.numiter = 200" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "python" + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "BlockGradFull: loading data for scan MF (161 diffraction frames, 161 PODs, 1 probe(s) and 1 object(s))\n", + "BlockGradFull: loading data for scan MF (reformatting probe/obj/exit)\n", + "BlockGradFull: loading data for scan MF (initializing probe/obj/exit)\n", + "ML: initializing engine\n", + "ML: preparing engine\n", + "ML: Iteration # 200/200 :: Fourier 0.00e+00, Photons 1.07e+03, Exit 0.00e+00\n", + "==== This reconstruction relied on the following work ==========================\n", + "The Ptypy framework:\n", + " Enders B. and Thibault P., \"A computational framework for ptychographic reconstructions\" Proc. Royal Soc. A 472 (2016) 20160640, doi: 10.1098/rspa.2016.0640.\n", + "The maximum likelihood reconstruction algorithm:\n", + " Thibault P. and Guizar-Sicairos M., \"Maximum-likelihood refinement for coherent diffractive imaging\" New Journal of Physics 14 (2012) 63004, doi: 10.1088/1367-2630/14/6/063004.\n", + "================================================================================\n" + ] } - }, - "outputs": [], + ], "source": [ "# prepare and run\n", "P = Ptycho(p,level=5)" @@ -140,13 +139,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "vscode": { - "languageId": "python" + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } - }, - "outputs": [], + ], "source": [ "import ptypy.utils.plot_client as pc\n", "fig = pc.figure_from_ptycho(P)" @@ -159,6 +165,18 @@ "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.12.6" + }, "orig_nbformat": 4 }, "nbformat": 4, diff --git a/templates/notebooks/moonflower_ml_wavefield.ipynb b/templates/notebooks/moonflower_ml_wavefield.ipynb new file mode 100644 index 000000000..201d0c4a2 --- /dev/null +++ b/templates/notebooks/moonflower_ml_wavefield.ipynb @@ -0,0 +1,147 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PtyPy moonflower example\n", + "#### scan model: BlockGradFull\n", + "#### engine: Maximum Likelihood (ML)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from ptypy.core import Ptycho\n", + "from ptypy import utils as u" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# create parameter tree\n", + "p = u.Param()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# set verbose level to interactive\n", + "p.verbose_level = \"interactive\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# set home path and io settings (no files saved)\n", + "p.io = u.Param()\n", + "p.io.rfile = None\n", + "p.io.autosave = u.Param(active=False)\n", + "p.io.autoplot = u.Param(active=False)\n", + "p.io.interaction = u.Param(active=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# max 200 frames (128x128px) of diffraction data\n", + "p.scans = u.Param()\n", + "p.scans.MF = u.Param()\n", + "p.scans.MF.name = 'BlockGradFull'\n", + "p.scans.MF.data= u.Param()\n", + "p.scans.MF.data.name = 'MoonFlowerScan'\n", + "p.scans.MF.data.shape = 128\n", + "p.scans.MF.data.num_frames = 200\n", + "p.scans.MF.data.save = None\n", + "p.scans.MF.data.density = 0.2\n", + "p.scans.MF.data.photons = 1e8\n", + "p.scans.MF.data.psf = 0." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# maximum likelihood reconstrucion engine\n", + "p.engines = u.Param()\n", + "p.engines.engine00 = u.Param()\n", + "p.engines.engine00.name = 'ML'\n", + "p.engines.engine00.ML_type = 'Gaussian'\n", + "p.engines.engine00.wavefield_precond = True\n", + "#p.engines.engine00.reg_del2 = True\n", + "#p.engines.engine00.reg_del2_amplitude = 1.\n", + "#p.engines.engine00.scale_precond = True\n", + "#p.engines.engine00.smooth_gradient = 20.\n", + "#p.engines.engine00.smooth_gradient_decay = 1/50.\n", + "#p.engines.engine00.floating_intensities = False\n", + "p.engines.engine00.numiter = 200" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# prepare and run\n", + "P = Ptycho(p,level=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plotting the results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import ptypy.utils.plot_client as pc\n", + "fig = pc.figure_from_ptycho(P)" + ] + } + ], + "metadata": { + "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.12.6" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +}