Skip to content

projected_values_selector

ProjectedValuesSelector

Source code in src/antakia/gui/high_dim_exp/projected_values_selector.py 
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 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
 97
 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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
class ProjectedValuesSelector:
    def __init__(self, pv_bank: ProjectedValueBank, update_callback: callable, space):
        self.widget = None
        self.progress_bar = None
        self.projected_value = None
        self._proj_params_cards = {}
        self.update_callback = update_callback
        self.pv_bank = pv_bank
        self.space = space

        self.X = None
        self.current_proj = Proj(
            DimReducMethod.dimreduc_method_as_int(config.DEFAULT_PROJECTION),
            config.DEFAULT_DIMENSION
        )

        self.build_widget()

    @property
    def current_dim(self):
        return self.current_proj.dimension

    def build_widget(self):
        self.widget = v.Row(children=[
            v.Select(  # Selection of proj method
                label=f"Projection in the {self.space} :",
                items=DimReducMethod.dimreduc_methods_as_str_list(),
                style_="width: 15%",
                class_="ml-2 mr-2",
            ),
            v.Menu(  # proj settings
                class_="ml-2 mr-2",
                v_slots=[
                    {
                        "name": "activator",
                        "variable": "props",
                        "children": v.Btn(
                            v_on="props.on",
                            icon=True,
                            size="x-large",
                            children=[
                                v.Icon(
                                    children=["mdi-cogs"],
                                    size="large",
                                )
                            ],
                            class_="ma-2 pa-3",
                            elevation="3",
                        ),
                    }
                ],
                children=[
                    v.Card(  # 1410
                        class_="pa-4",
                        rounded=True,
                        children=[
                            widgets.VBox(  # 14100
                                [
                                    v.Slider(  # 141000
                                        class_="ma-8 pa-2",
                                        v_model=10,
                                        min=5,
                                        max=30,
                                        step=1,
                                        label="Number of neighbours",
                                        thumb_label="always",
                                        thumb_size=25,
                                    ),
                                    v.Slider(  # 141001
                                        class_="ma-8 pa-2",
                                        v_model=0.5,
                                        min=0.1,
                                        max=0.9,
                                        step=0.1,
                                        label="MN ratio",
                                        thumb_label="always",
                                        thumb_size=25,
                                    ),
                                    v.Slider(  # 141002
                                        class_="ma-8 pa-2",
                                        v_model=2,
                                        min=0.1,
                                        max=5,
                                        step=0.1,
                                        label="FP ratio",
                                        thumb_label="always",
                                        thumb_size=25,
                                    )
                                ],
                            )
                        ],
                        min_width="500",
                    )
                ],
                v_model=False,
                close_on_content_click=False,
                offset_y=True,
            ),
            v.ProgressCircular(  # progress bar
                indeterminate=True,
                color="blue",
                width="6",
                size="35",
                class_="ml-2 mr-2 mt-2",
            )
        ])
        self.progress_bar = ProgressBar(self.widget.children[2], indeterminate=True)
        self.progress_bar.update(100, 0)
        self.projection_select.on_event("change", self.projection_select_changed)
        self.build_all_proj_param_w()
        self.projection_select.on_event("change", self.projection_select_changed)

    def initialize(self, progress_callback, X: pd.DataFrame):
        self.projected_value = self.pv_bank.get_projected_values(X)
        self.get_current_X_proj(progress_callback=progress_callback)
        self.refresh()

    def refresh(self):
        self.disable(True)
        self.projection_select.v_model = DimReducMethod.dimreduc_method_as_str(
            self.current_proj.reduction_method
        )
        self.update_proj_params_menu()
        self.update_callback()
        self.disable(False)

    def update_X(self, X: pd.DataFrame):
        self.projected_value = self.pv_bank.get_projected_values(X)
        self.refresh()

    def update_dim(self, dim):
        self.current_proj = Proj(self.current_proj.reduction_method, dim)
        self.refresh()

    @property
    def projection_select(self):
        """
        get dim reduc selector
        Returns
        -------

        """
        return self.widget.children[0]

    @property
    def projection_method(self) -> int:
        """
        returns the current projection method
        Returns
        -------

        """
        if self.projection_select.v_model == '!!disabled!!':
            self.projection_select.v_model = config.DEFAULT_PROJECTION
        return DimReducMethod.dimreduc_method_as_int(
            self.projection_select.v_model
        )

    def projection_select_changed(self, *args):
        """
        callback called on projection select change
        projection is computed if needed
        Parameters
        ----------
        widget
        event
        data

        Returns
        -------

        """
        self.current_proj = Proj(self.projection_method, self.current_dim)
        self.update_proj_params_menu()
        self.refresh()

    @property
    def proj_param_widget(self):
        """
        get the projection parameter widget
        Returns
        -------

        """
        return self.widget.children[1]

    def build_proj_param_widget(self, dim_reduc) -> list[v.Slider]:
        """
        build widget
        Parameters
        ----------
        dim_reduc

        Returns
        -------

        """
        parameters = dim_reduc_factory[dim_reduc].parameters()
        sliders = []
        for param, info in parameters.items():
            min_, max_, step = utils.compute_step(info['min'], info['max'])
            default_value = info['default']
            if info['type'] == int:
                step = max(round(step), 1)

            slider = v.Slider(  # 15000
                class_="ma-8 pa-2",
                v_model=default_value,
                min=float(min_),
                max=float(max_),
                step=step,
                label=param,
                thumb_label="always",
                thumb_size=25,
            )
            slider.on_event("change", self.params_changed)
            sliders.append(slider)
        return sliders

    def update_proj_param_value(self):
        parameters = self.projected_value.get_parameters(self.current_proj)['current']
        param_widget = self._proj_params_cards[self.projection_method]
        for slider in param_widget:
            slider.v_model = parameters[slider.label]

    def build_all_proj_param_w(self):
        for dim_reduc in DimReducMethod.dimreduc_methods_as_list():
            self._proj_params_cards[dim_reduc] = self.build_proj_param_widget(dim_reduc)

    def params_changed(self, widget, event, data):
        """
        called when user changes a parameter value
        Parameters
        ----------
        widget: caller widget
        event -
        data : new value

        Returns
        -------

        """
        self.update_params(widget.label, data)

    def update_params(self, parameter, new_value):
        self.projected_value.set_parameters(self.current_proj,
                                            {parameter: new_value})
        self.refresh()

    def update_proj_params_menu(self):
        """
        Called at startup by the GUI
        """
        # We return
        params = self._proj_params_cards[self.projection_method]
        # We neet to set a Card, depending on the projection method
        self.proj_param_widget.children[0].children = [widgets.VBox(params)]
        self.update_proj_param_value()

    def disable_select(self, is_disabled: bool):
        self.projection_select.disabled = is_disabled

    def disable_params(self, is_disabled: bool):
        self.proj_param_widget.disabled = is_disabled

    def disable(self, is_disabled):
        params = self._proj_params_cards[self.projection_method]
        self.disable_select(is_disabled)
        # do not enable proj parama menu if there are no parameters
        is_disabled |= len(params) == 0
        self.disable_params(is_disabled)

    def get_current_X_proj(self, dim=None, progress_callback=None) -> pd.DataFrame | None:
        """
        get current project X
        Parameters
        ----------
        dim: dimension to get, if None use current
        progress_callback: callback to publish progress to, if None use default

        Returns
        -------

        """
        if dim is None:
            dim = self.current_dim
        if progress_callback is None:
            progress_callback = self.progress_bar.update
        X = self.projected_value.get_projection(
            Proj(self.current_proj.reduction_method, dim), progress_callback
        )
        return X

    def is_computed(self, projection_method=None, dim=None) -> bool:
        if projection_method is None:
            projection_method = self.projection_method
        if dim is None:
            dim = self.current_dim
        return self.projected_value.is_present(Proj(projection_method, dim))

proj_param_widget property

get the projection parameter widget Returns

projection_method: int property

returns the current projection method Returns

projection_select property

get dim reduc selector Returns

build_proj_param_widget(dim_reduc)

build widget Parameters

dim_reduc

Returns
Source code in src/antakia/gui/high_dim_exp/projected_values_selector.py 
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
def build_proj_param_widget(self, dim_reduc) -> list[v.Slider]:
    """
    build widget
    Parameters
    ----------
    dim_reduc

    Returns
    -------

    """
    parameters = dim_reduc_factory[dim_reduc].parameters()
    sliders = []
    for param, info in parameters.items():
        min_, max_, step = utils.compute_step(info['min'], info['max'])
        default_value = info['default']
        if info['type'] == int:
            step = max(round(step), 1)

        slider = v.Slider(  # 15000
            class_="ma-8 pa-2",
            v_model=default_value,
            min=float(min_),
            max=float(max_),
            step=step,
            label=param,
            thumb_label="always",
            thumb_size=25,
        )
        slider.on_event("change", self.params_changed)
        sliders.append(slider)
    return sliders

get_current_X_proj(dim=None, progress_callback=None)

get current project X Parameters

dim: dimension to get, if None use current progress_callback: callback to publish progress to, if None use default

Returns
Source code in src/antakia/gui/high_dim_exp/projected_values_selector.py 
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
def get_current_X_proj(self, dim=None, progress_callback=None) -> pd.DataFrame | None:
    """
    get current project X
    Parameters
    ----------
    dim: dimension to get, if None use current
    progress_callback: callback to publish progress to, if None use default

    Returns
    -------

    """
    if dim is None:
        dim = self.current_dim
    if progress_callback is None:
        progress_callback = self.progress_bar.update
    X = self.projected_value.get_projection(
        Proj(self.current_proj.reduction_method, dim), progress_callback
    )
    return X

params_changed(widget, event, data)

called when user changes a parameter value Parameters

widget: caller widget event - data : new value

Returns
Source code in src/antakia/gui/high_dim_exp/projected_values_selector.py 
245
246
247
248
249
250
251
252
253
254
255
256
257
258
def params_changed(self, widget, event, data):
    """
    called when user changes a parameter value
    Parameters
    ----------
    widget: caller widget
    event -
    data : new value

    Returns
    -------

    """
    self.update_params(widget.label, data)

projection_select_changed(*args)

callback called on projection select change projection is computed if needed Parameters

widget event data

Returns
Source code in src/antakia/gui/high_dim_exp/projected_values_selector.py 
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
def projection_select_changed(self, *args):
    """
    callback called on projection select change
    projection is computed if needed
    Parameters
    ----------
    widget
    event
    data

    Returns
    -------

    """
    self.current_proj = Proj(self.projection_method, self.current_dim)
    self.update_proj_params_menu()
    self.refresh()

update_proj_params_menu()

Called at startup by the GUI

Source code in src/antakia/gui/high_dim_exp/projected_values_selector.py 
265
266
267
268
269
270
271
272
273
def update_proj_params_menu(self):
    """
    Called at startup by the GUI
    """
    # We return
    params = self._proj_params_cards[self.projection_method]
    # We neet to set a Card, depending on the projection method
    self.proj_param_widget.children[0].children = [widgets.VBox(params)]
    self.update_proj_param_value()