o }oi$@sZddlmZddlZddlmZdd d Zdd d ZdddZdddZ ddddZ dS)) annotationsN)_is_pareto_frontsorted_pareto_sols np.ndarrayreference_pointreturnfloatcCs~|jd|jdkrdksJJt|dd|dddfg}|d|dddf}||dddf}||S)Nr)shapenp concatenate)rr rect_diag_y edge_length_x edge_length_yrK/home/ubuntu/.local/lib/python3.10/site-packages/optuna/_hypervolume/wfg.py _compute_2ds ("rc Cs |jd|jdkrdksJJ|jd}t|dddf}tj||ftd}|d||df||t|f<tjjtjj|dddd}|dddf}||df}t|dd|ddg|}t|dd|ddg|}t t |||S)aw Compute hypervolume in 3D. Time complexity is O(N^2) where N is sorted_pareto_sols.shape[0]. If X, Y, Z coordinates are permutations of 0, 1, ..., N-1 and reference_point is (N, N, N), the hypervolume is calculated as the number of voxels (x, y, z) dominated by at least one point. If we fix x and y, this number is equal to the minimum of z' over all points (x', y', z') satisfying x' <= x and y' <= y. This can be efficiently computed using cumulative minimum (`np.minimum.accumulate`). Non-permutation coordinates can be transformed into permutation coordinates by using coordinate compression. r rN)dtyper axis) r r argsortzerosrarangemaximum accumulaterdot) rrny_orderz_deltax_valsy_valsx_deltay_deltarrr _compute_3ds( " ""r&sorted_loss_valsc s|jddkrd}t|dD] \}}|||9}qt|S|jddkrVd\}}}t|d|dD]\}}} |||9}||| 9}||t|| 9}q5|||S|jddt|ddtjf|dtfdd t j dDS) Nrr ?r )r(r(r(r rc3s0|]}t||ddf|VqdS)r N)_compute_exclusive_hv).0i inclusive_hvslimited_sols_arrayrrr =s  z_compute_hv..) r ziprmaxprodr rnewaxissumrangesize) r'r inclusive_hvrvhv1hv2intersecv1v2rr,r _compute_hv)s"      r? limited_solsr7cCsL|jddks J|jddkr|t||St|dd}|t|||S)Nrr rTassume_unique_lexsorted)r r?r)r@r7ron_frontrrrr)Cs  !r)F loss_vals assume_paretoboolcCst||ks tdtt|stdS|jdkrdS|s2tj|dd}t|dd}||}n ||dddf}|j dd krKt ||}n|j dd krXt ||}nt ||}t|rd|StdS) aOHypervolume calculator for any dimension. This class exactly calculates the hypervolume for any dimension. For 3 dimensions or higher, the WFG algorithm will be used. Please refer to ``A Fast Way of Calculating Exact Hypervolumes`` for the WFG algorithm. .. note:: This class is used for computing the hypervolumes of points in multi-objective space. Each coordinate of each point represents a ``values`` of the multi-objective function. .. note:: We check that each objective is to be minimized. Transform objective values that are to be maximized before calling this class's ``compute`` method. Args: loss_vals: An array of loss value vectors to calculate the hypervolume. reference_point: The reference point used to calculate the hypervolume. assume_pareto: Whether to assume the Pareto optimality to ``loss_vals``. In other words, if ``True``, none of loss vectors are dominated by another. ``assume_pareto`` is used only for speedup and it does not change the result even if this argument is wrongly given. If there are many non-Pareto solutions in ``loss_vals``, ``assume_pareto=True`` will speed up the calculation. Returns: The hypervolume of the given arguments. zAll points must dominate or equal the reference point. That is, for all points in the loss_vals and the coordinate `i`, `loss_vals[i] <= reference_point[i]`.infrgrTrANr r) r all ValueErrorisfiniterr6uniquerrr rr&r?)rDrrEunique_lexsorted_loss_valsrCrhvrrrcompute_hypervolumens&"      rN)rrrrrr)r'rrrrr)r@rr7rrrrr)F)rDrrrrErFrr) __future__rnumpyr optuna.study._multi_objectiverrr&r?r)rNrrrrs      ,