phase.py 13.7 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
178
179
180
181
182
        print(norm(self.config['u_0']))
        print(norm(u_1))
        print(norm(u_2))
        print(norm(u_1-u_2))
        print(self.config['norm_rt_data'])
        #print(nonzero(u_1))
        print(u_1[51,55]);
183
        #print(size(self.config['support_idx'][1]))
184
185
186
        print(u_2[51,55])
        print(proj2)

187
188
        # estimate the gap in the relevant metric
        if self.config['Nx'] ==1 or self.config['Ny']==1 :
189
            tmp_gap = square(norm(u_1-u_2)/self.config['norm_rt_data']);
190
        elif self.config['product_space_dimension'] == 1:
191
            tmp_gap = (norm(u_1-u_2)/self.config['norm_rt_data'])**2
192
193
194
195
        else:
            tmp_gap=0;
            for j in range(self.config['product_space_dimension']):
                # compute (||P_Sx-P_Mx||/normM)^2:
196
                tmp_gap = tmp_gap+(norm(u_1[:,:,j]-u_2[:,:,j])/self.config['norm_rt_data'])**2
197
        
198
        gap_0=sqrt(tmp_gap);
199
        print(gap_0)
200
201
202
203
204
205

        # 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.
206
        self.config['data_ball']=self.config['data_ball']*gap_0;
207
208
        # the second tolerance relative to the oder of 
        # magnitude of the metric
209
        self.config['TOL2'] = self.config['data_ball']*1e-15; 
210
211

        self.algorithm = getattr(Algorithms, self.config['algorithm'])(self.config);
212
213
214
215
216
217
218
        
    
    
    def _presolve(self):
        """
        Prepares argument for actual solving routine
        """
219
        
220
221
222
223
224
225
226
    
    def _solve(self):
        """
        Runs the algorithm to solve the given sudoku problem
        """
#        algorithm = self.config['algorithm'](self.config)
        
227
228
229
        self.output = dict();
        
        self.output['u1'],self.output['u2'],self.output['iter'],self.output['change'],self.output['gap'] = \
230
            self.algorithm.run(self.config['u_0'],self.config['TOL'],self.config['MAXIT'])
231

232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
    
    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)))'] =
        """
255
256
257
258
259
260
261
262
263
264

        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)
265
        else:
266
267
268
269
270
271
272
273
274
275
276
            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
            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