phase.py 14 KB
Newer Older
1
2
# -*- coding: utf-8 -*-

3
from proxtoolbox.Problems.problems import Problem
4
5
6
from proxtoolbox import Algorithms
from proxtoolbox import ProxOperators
from proxtoolbox.ProxOperators.proxoperators import ProxOperator
7
from proxtoolbox.Problems.Phase.JWST_graphics import JWST_graphics
8
from numpy.linalg import norm
9
10
import numpy as np
import h5py
11
from numpy import square, sqrt, nonzero, size
12
13


14
class Phase(Problem):
15
    """
16
    Phase Problem
17
18
19
20
21
22
    """
    config = {
    }
    
    def __init__(self, new_config={}):
        """
23
        The initialization of a Phase instance takes the default configuration
24
25
26
27
28
29
30
        and updates the parameters with the arguments in new_config.
        
        Parameters
        ----------
        new_config : dict, optional - Parameters to initialize the problem. If unspecified, the default config is used.
        """
        self.config.update(new_config)
31

32
33
34
35
36
37
38
39
40
41
        
        #moved here from JWST_in since if statements not possible in dictonary
        if 'distance' in self.config:
            if self.config['distance'] =='near field':
                self.config['fresnel_nr'] = 1*2*pi*self.config['Nx']
                self.config['use_farfield_formula'] = 0
            else:
                self.config['fresnel_nr'] = 0
                self.config['use_farfield_formula'] = 1

42
        
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

        #call data processor, read data

        module = __import__(self.config['data_filename'])
        data_processor = getattr(module, self.config['data_filename'])
        data_processor(self.config)
        

        #reshape and rename the data 
        self.config['data_sq'] = self.config['data'];
        self.config['data'] = self.config['rt_data'];
        tmp = self.config['data'].shape;
        if(tmp[0]==1 or tmp[1]==1):
            self.config['data_sq'] = self.config['data_sq'].reshape((self.config['Nx'],self.config['Ny']));
            #the projection algorithms work with the square root of the measurement:
            self.config['data'] = self.config['data'].reshape((self.config['Nx'],self.config['Ny']));

60
        self.config['normM']=self.config['norm_rt_data']; #previously (in matlab) norm_data
61
        if 'Nz' not in self.config:
62
            self.config['Nz'] = 1;
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


        #If method_config[formulation is does not exist, i.e. not specified in 
        #the *_in.m file, use the product space as the default.
        if 'formulation' in self.config:
            formulation = self.config['formulation'];
        else:
            formulation = 'product space';

        # Set the projectors and inputs based on the types of constraints and 
        # experiments
        proxoperators = ['','',''];

        if self.config['constraint'] == 'hybrid':
            proxoperators[0] = 'P_cP'; # This will be problem specific
        elif self.config['constraint'] == 'support only':
            proxoperators[0] = 'P_S';
        elif self.config['constraint'] == 'real and support':
            proxoperators[0] ='P_S_real';
        elif self.config['constraint'] =='nonnegative and support':
            proxoperators[0] ='P_SP';
        elif self.config['constraint'] =='amplitude only':
            proxoperators[0] ='P_amp';
        elif self.config['constraint'] =='minimum amplitude':
            proxoperators[0] = 'P_min_amp';
        elif self.config['constraint'] =='sparse':
            proxoperators[0] = 'not in yet';  
        elif self.config['constraint'] =='phaselift':
            proxoperators[0] = 'P_mean_SP';
        elif self.config['constraint'] =='phaselift2':
            proxoperators[0] ='P_liftM';
            proxoperators[2] ='Approx_PM_Poisson'; # Patrick: This is just to monitor the change of phases!  

        if self.config['experiment'] == 'single diffraction':
97
            if self.config['distance'] == 'far field':
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
                if self.config['constraint'] == 'phaselift':
                    proxoperators[1] = 'P_Rank1';
                elif self.config['constraint'] == 'phaselift2':
                    proxoperators[1] = 'P_rank1_SR';
                else:
                    if self.config['noise'] == 'Poisson':
                        proxoperators[1] ='Approx_PM_Poisson';
                    else:
                        proxoperators[1] ='Approx_PM_Gaussian';
            else:
                proxoperators[1]='P_Fresnel';

        # The following selects the projectors for diversity diffraction not
        # performed in the product space. So far only used for RCAAR.
        elif self.config['experiment'] == 'diversity diffraction' and formulation == 'sequential':
            proxoperators[1] = 'Approx_P_RCAAR_JWST_Poisson';
            proxoperators[0] = proxoperators[1];
        elif self.config['experiment'] == 'JWST': 
            proxoperators[1] = 'Approx_P_JWST_Poisson';  
            proxoperators[2] = proxoperators[0];
            proxoperators[0] = 'P_diag';
        elif self.config['experiment'] == 'CDP':
            proxoperators[1] = 'P_CDP';  
            proxoperators[2] = proxoperators[0];
            proxoperators[0] = 'P_diag';
        elif self.config['experiment'] == 'ptychography':
            proxoperators[1] = 'not in yet';
        elif self.config['experiment'] == 'complex':
            proxoperators[1] = 'not in yet';
        elif self.config['constraint'] == 'phaselift':
            proxoperators[1] ='P_PL_lowrank';

        self.config['proxoperators'] = [];

        for prox in proxoperators:
133
134
            if prox != '':
                self.config['proxoperators'].append(getattr(ProxOperators, prox))
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

        # input.Proj1_input.F=F;  % is it any more expensive to pass everything
        # into the projectors rather than just a selection of data and
        # parameters?  If not, and we pass everything anyway, there is no need
        # to create a new structure element.

        if 'product_space_dimension' not in self.config:
            self.config['product_space_dimension'] = 1;

        # set the animation program:
        self.config['animation']='Phase_animation';
        #
        # if you are only working with two sets but
        # want to do averaged projections
        # (= alternating projections on the product space)
        # or RAAR on the product space (=swarming), then
        # you will want to change product_space_dimension=2
        # and adjust your input files and projectors accordingly. 
        # you could also do this within the data processor

155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
        self.config['TOL2'] = 1e-15;

        #To estimate the gap in the sequential formulation, we build the
        # appropriate point in the product space. This allows for code reuse.
        # Note for sequential diversity diffraction, input.Proj1 is the "RCAAR"
        # version of the function.
        if formulation == 'sequential':
            for j in range(self.config['product_space_dimension']):
                self.config['proj_iter'] =j;
                proj1 = self.config['proxoperators'][0](self.config)
                u_1[:,:,j]= proj1.work(self.config['u_0']);
                self.config['proj_iter'] = mod(j,config['product_space_dimension'])+1;
                proj1 = self.config['proxoperators'][0](self.config)
                u_1[:,:,j]= proj1.work(self.config['u_0']);
            end;
        else: #i.e. formulation=='product space'
            proj1 = self.config['proxoperators'][0](self.config)
            u_1 = proj1.work(self.config['u_0']);
            proj2 = self.config['proxoperators'][1](self.config)
174
            u_2 = proj2.work(u_1);
175
176
177

        # estimate the gap in the relevant metric
        if self.config['Nx'] ==1 or self.config['Ny']==1 :
178
            tmp_gap = square(norm(u_1-u_2)/self.config['norm_rt_data']);
179
        elif self.config['product_space_dimension'] == 1:
180
            tmp_gap = (norm(u_1-u_2)/self.config['norm_rt_data'])**2
181
182
183
184
        else:
            tmp_gap=0;
            for j in range(self.config['product_space_dimension']):
                # compute (||P_Sx-P_Mx||/normM)^2:
185
                tmp_gap = tmp_gap+(norm(u_1[:,:,j]-u_2[:,:,j])/self.config['norm_rt_data'])**2
186
        
187
188
189
190
191
192
193
        gap_0=sqrt(tmp_gap);

        # sets the set fattening to be a percentage of the
        # initial gap to the unfattened set with 
        # respect to the relevant metric (KL or L2), 
        # that percentage given by
        # input.data_ball input by the user.
194
        self.config['data_ball']=self.config['data_ball']*gap_0;
195
196
        # the second tolerance relative to the oder of 
        # magnitude of the metric
197
        self.config['TOL2'] = self.config['data_ball']*1e-15; 
198
        self.config['proxoperators']
199
        self.algorithm = getattr(Algorithms, self.config['algorithm'])(self.config);
200
201
202
203
204
205
206
        
    
    
    def _presolve(self):
        """
        Prepares argument for actual solving routine
        """
207
        
208
209
210
211
212
213
214
    
    def _solve(self):
        """
        Runs the algorithm to solve the given sudoku problem
        """
#        algorithm = self.config['algorithm'](self.config)
        
215
        self.output = self.algorithm.run(self.config['u_0'],self.config['TOL'],self.config['MAXIT'])
216

217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
    
    def _postsolve(self):
        """
        Processes the solution and generates the output
        """
        
        
        
    def show(self):
        """
        Generates graphical output from the solution
        """
        
        print("Calculation time:")
        print(self.elapsed_time)
        JWST_graphics(self.config,self.output)

    def compare_to_matlab(self):
        """
        Routine to test and verify results by comparing to matlab
        Note that this is only for development and should not be used by a normal user
        For result to match u_0 should be chosen as np.multiply(config['abs_illumination'],exp(1j*2*pi*0.5*np.ones(newres)))'] =
        """
240
241
242
243
244
245
246
247
248
249

        if self.config['experiment'] == 'JWST':
            if self.config['MAXIT'] == 1:
                f = h5py.File('Phase_test_data/u1_1.mat')
            elif self.config['MAXIT'] == 500 :
                f = h5py.File('Phase_test_data/u1_500.mat')
            else:
                print("No file available to compare to.")
                return
            u1 = f['u1'].value.view(np.complex)
250
        else:
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
            if self.config['algorithm'] == 'RAAR':
                if self.config['beta_0'] == 0.95:
                    if self.config['MAXIT'] == 1000 :
                        f = h5py.File('Phase_test_data/tasse_u1_1000.mat')
                    elif self.config['MAXIT'] == 20:
                        f = h5py.File('Phase_test_data/tasse_u1_20.mat')
                    elif self.config['MAXIT'] == 1:
                        f = h5py.File('Phase_test_data/tasse_u1_1.mat')
                    else:
                        print("No file available to compare to.")
                        return
                elif self.config['beta_0'] == 0.50:
                    if self.config['MAXIT'] == 20:
                        f = h5py.File('Phase_test_data/tasse_u1_20_beta_0_5.mat')
                    else:
                        print("No file available to compare to.")
                        return
                else:
                        print("No file available to compare to.")
                        return
            elif self.config['algorithm'] == 'AP':
                if self.config['MAXIT'] == 20:
                        f = h5py.File('Phase_test_data/tasse_u1_ap_20.mat')

275
276
            u1 = f['u1'].value.view(np.float)

277
278
279
        u1 =np.array(u1)
        u1 = u1.T
        print("Compare u1:")
280
281
282
283
        #print("Nonzero indices matlab:")
        #print(nonzero(u1))
        #print("Nonzero indices python:")
        #print(nonzero(self.output['u1']))
284
285
        print("Nonzero indices equal:")
        print(np.array_equal(nonzero(u1),nonzero(self.output['u1'])))
286
287
288
289
290
291
        #print("Nonzero values matlab:")
        #print(u1[nonzero(u1)])
        #print("Nonzero values python:")
        #print(self.output['u1'][nonzero(self.output['u1'])])
        #print("Difference at nonzero values:")
        #nonz = nonzero(u1)
292
        diff = u1 - self.output['u1']
293
        #print(diff[nonz])
294
        print("Maximum norm of difference:")
295
        print(np.amax(abs(diff)));
296
        print("Frobenius norm of difference:")
297
298
299
300
301
        print(norm(diff))
        print("Frobenius norm of matlab u1:")
        print(norm(u1))
        print("Frobenius norm of python u1:")
        print(norm(self.output['u1']))
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327

    def compare_data_to_matlab(self):
        """
        Routine to test and verify results by comparing to matlab
        Note that this is only for development and should not be used by a normal user
        For result to match u_0 should be chosen as np.multiply(config['abs_illumination'],exp(1j*2*pi*0.5*np.ones(newres)))'] =
        """

        if self.config['data_filename'] == 'CDI_data_processor':
            f = h5py.File('Phase_test_data/CDI_data_processor_rt_data.mat')
            rt_data = f['rt_data'].value.view(np.float)

        rt_data =np.array(rt_data)
        rt_data = rt_data.T
        print("Compare rt_data:")
        print("Nonzero indices equal:")
        print(np.array_equal(nonzero(rt_data),nonzero(self.config['rt_data'])))
        diff = rt_data - self.config['rt_data']
        print("Maximum norm of difference:")
        print(np.amax(abs(diff)));
        print("Frobenius norm of difference:")
        print(norm(diff))
        print("Frobenius norm of matlab rt_data:")
        print(norm(rt_data))
        print("Frobenius norm of python rt_data:")
        print(norm(self.config['rt_data']))
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346

        if self.config['data_filename'] == 'CDI_data_processor':
            f = h5py.File('Phase_test_data/CDI_data_processor_S.mat')
            S = f['S'].value.view(np.float)

        S =np.array(S)
        S = S.T
        print("Compare S:")
        print("Nonzero indices equal:")
        print(np.array_equal(nonzero(S),nonzero(self.config['abs_illumination'])))
        diff = S - self.config['abs_illumination']
        print("Maximum norm of difference:")
        print(np.amax(abs(diff)));
        print("Frobenius norm of difference:")
        print(norm(diff))
        print("Frobenius norm of matlab S:")
        print(norm(S))
        print("Frobenius norm of python S:")
        print(norm(self.config['abs_illumination']))
347