From 8ebe4bbacc3a707f881381447b76857788ed3b63 Mon Sep 17 00:00:00 2001 From: anton Date: Mon, 9 Oct 2023 08:04:42 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B5=D0=B2=D0=BE=D0=B4=20?= =?UTF-8?q?=D0=BA=D0=BE=D0=BC=D0=BC=D0=B5=D0=BD=D1=82=D0=B0=D1=80=D0=B8?= =?UTF-8?q?=D0=B5=D0=B2=20=D0=B2=20=D1=80=D0=B0=D0=B7=D0=B4=D0=B5=D0=BB?= =?UTF-8?q?=D0=B5=20iOpt=20=D0=BD=D0=B0=20=D0=B0=D0=BD=D0=B3=D0=BB=D0=B8?= =?UTF-8?q?=D0=B9=D1=81=D0=BA=D0=B8=D0=B9=20=D0=B4=D0=BB=D1=8F=20=D0=B4?= =?UTF-8?q?=D0=BE=D0=BA=D1=83=D0=BC=D0=B5=D0=BD=D1=82=D0=B0=D1=86=D0=B8?= =?UTF-8?q?=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- iOpt/evolvent/evolvent.py | 40 ++-- iOpt/method/calculator.py | 18 +- iOpt/method/index_method.py | 24 +-- iOpt/method/index_method_calculator.py | 14 +- iOpt/method/listener.py | 2 +- iOpt/method/local_optimizer.py | 20 +- iOpt/method/method.py | 88 ++++---- iOpt/method/mixed_integer_method.py | 16 +- iOpt/method/parallel_process.py | 20 +- iOpt/method/process.py | 44 ++-- iOpt/method/search_data.py | 200 +++++++++--------- iOpt/method/solverFactory.py | 30 +-- .../listeners/animate_painters.py | 40 ++-- .../listeners/console_outputers.py | 16 +- .../listeners/static_painters.py | 66 +++--- iOpt/output_system/painters/painter.py | 2 +- .../painters/plotters/plotters.py | 2 +- iOpt/problem.py | 10 +- iOpt/solution.py | 16 +- iOpt/solver.py | 50 ++--- iOpt/solver_parametrs.py | 34 +-- setup.py | 2 +- 22 files changed, 377 insertions(+), 377 deletions(-) diff --git a/iOpt/evolvent/evolvent.py b/iOpt/evolvent/evolvent.py index 69c33e2a..306413ee 100644 --- a/iOpt/evolvent/evolvent.py +++ b/iOpt/evolvent/evolvent.py @@ -3,15 +3,15 @@ class Evolvent: - """Класс разверток + r"""Class Evolvent - :param lower_bound_of_float_variables: массив для левых (нижних) границ, А. + :param lower_bound_of_float_variables: array for lower bounds, А. :type lower_bound_of_float_variables: np.ndarray(shape = (1), dtype = np.double). - :param upper_bound_of_float_variables: массив для правых (верхних) границ, В. + :param upper_bound_of_float_variables: array for upper bounds, В. :type upper_bound_of_float_variables: np.ndarray(shape = (1), dtype = np.double). - :param number_of_float_variables: размерность задачи (N). - :type number_of_float_variables: int - :param evolvent_density: плотность развертки (m). + :param number_of_float_variables: dimension (N). + :type number_of_float_variables: int. + :param evolvent_density: evolvent density (m). :type evolvent_density: int """ @@ -42,11 +42,11 @@ def set_bounds(self, lower_bound_of_float_variables: np.ndarray(shape=(1), dtype=np.double) = [], upper_bound_of_float_variables: np.ndarray(shape=(1), dtype=np.double) = [] ): - """Установка граничных значений + r"""Set bounds - :param lower_bound_of_float_variables: массив для левых (нижних) границ, А. + :param lower_bound_of_float_variables: array for lower bounds, А. :type lower_bound_of_float_variables: np.ndarray(shape = (1), dtype = np.double). - :param upper_bound_of_float_variables: массив для правых (верхних) границ, В. + :param upper_bound_of_float_variables: array for upper bounds, В. :type upper_bound_of_float_variables: np.ndarray(shape = (1), dtype = np.double). """ @@ -56,11 +56,11 @@ def set_bounds(self, def get_image(self, x: np.double ) -> np.ndarray(shape=(1), dtype=np.double): - """Получить образ (x->y) + r"""Get image (x->y) - :param x: значение x. + :param x: value of *x*. :type x: np.double. - :return: массив значений *y* + :return: array of values *y*. :rtype: np.ndarray(shape = (1), dtype = np.double). """ @@ -72,11 +72,11 @@ def get_image(self, def get_inverse_image(self, y: np.ndarray(shape=(1), dtype=np.double) ) -> np.double: - """Получить обратное значение образа (y->x) + r"""Get inverse image (y->x) - :param y: значение y. - :type y: np.ndarray(shape = (1), dtype = np.double) - :return: значение *x* + :param y: value of *y*. + :type y: np.ndarray(shape = (1), dtype = np.double). + :return: value of *x*. :rtype: np.double:. """ @@ -89,11 +89,11 @@ def get_inverse_image(self, def get_preimages(self, y: np.ndarray(shape=(1), dtype=np.double), ) -> np.double: - """Получить обратное значение образа (y->x) + r"""Get inverse image (y->x) - :param y: значение y. - :type y: np.ndarray(shape = (1), dtype = np.double) - :return: значение *x* + :param y: value of *y*. + :type y: np.ndarray(shape = (1), dtype = np.double). + :return: value of *x*. :rtype: np.double:. """ diff --git a/iOpt/method/calculator.py b/iOpt/method/calculator.py index 28d732b7..0b784ce3 100644 --- a/iOpt/method/calculator.py +++ b/iOpt/method/calculator.py @@ -22,10 +22,10 @@ def __init__(self, parameters: SolverParameters ): r""" - Конструктор класса Calculator + Constructor of class Calculator - :param evaluate_method: метод вычислений, проводящий поисковые испытания по заданным правилам. - :param parameters: параметры решения задачи оптимизации. + :param evaluate_method: a computational method that performs search tests according to specified rules. + :param parameters: solution parameters of the optimisation problem. """ self.evaluate_method = evaluate_method self.parameters = parameters @@ -35,9 +35,9 @@ def __init__(self, initargs=(self.evaluate_method,)) r""" - Инициализация метода вычислений в каждом процессе из пула процессов Calculator.Pool + Initialisation of the calculation method in each process from the process pool Calculator.Pool - :param evaluate_method: метод вычислений, проводящий поисковые испытания по заданным правилам. + :param evaluate_method: a computational method that performs search tests according to specified rules. """ @staticmethod @@ -45,9 +45,9 @@ def worker_init(evaluate_method: ICriterionEvaluateMethod): Calculator.evaluate_method = evaluate_method r""" - Метод проведения испытаний в процессе из пула процессов Calculator.Pool + Method of testing in a process from a pool of processes Calculator.Pool - :param point: точка проведения испытания + :param point: test point """ @staticmethod @@ -60,9 +60,9 @@ def worker(point: SearchDataItem) -> SearchDataItem: return point r""" - Метод проведения испытаний для множества точек + Test method for multiple points - :param points: точки проведения испытаний + :param points: test points """ def calculate_functionals_for_items(self, points: list[SearchDataItem]) -> list[SearchDataItem]: diff --git a/iOpt/method/index_method.py b/iOpt/method/index_method.py index a558198e..3b8c3789 100644 --- a/iOpt/method/index_method.py +++ b/iOpt/method/index_method.py @@ -16,7 +16,7 @@ class IndexMethod(Method): """ - Класс Method содержит реализацию Алгоритма Глобального Поиска + The Method class contains an implementation of the Global Search Algorithm """ def __init__(self, @@ -29,11 +29,11 @@ def __init__(self, def calculate_functionals(self, point: SearchDataItem) -> SearchDataItem: r""" - Проведение поискового испытания в заданной точке. + Performing a search test at a given point. - :param point: точка, в которой надо провести испытание. + :param point: the point at which the test is to be performed. - :return: точка, в которой сохранены результаты испытания. + :return: the point at which the test results are saved. """ try: number_of_constraints = self.task.problem.number_of_constraints @@ -56,10 +56,10 @@ def calculate_functionals(self, point: SearchDataItem) -> SearchDataItem: def calculate_m(self, curr_point: SearchDataItem, left_point: SearchDataItem) -> None: r""" - Вычисление оценки константы Гельдера между между curr_point и left_point. + Computing an estimate of the Gelder constant between curr_point and left_point. - :param curr_point: правая точка интервала - :param left_point: левая точка интервала + :param curr_point: right interval point + :param left_point: left interval point """ # Обратить внимание на вычисление расстояния, должен использоваться метод CalculateDelta if curr_point is None: @@ -98,10 +98,10 @@ def calculate_m(self, curr_point: SearchDataItem, left_point: SearchDataItem) -> def calculate_global_r(self, curr_point: SearchDataItem, left_point: SearchDataItem) -> None: r""" - Вычисление глобальной характеристики интервала [left_point, curr_point]. + Calculating the global characteristic of an interval [left_point, curr_point]. - :param curr_point: правая точка интервала. - :param left_point: левая точка интервала. + :param curr_point: right point of the interval. + :param left_point: left interval point. """ # Сюда переедет целиком calculate_global_r из Method, а там останется только случай с равными индексами @@ -144,9 +144,9 @@ def recalc_all_characteristics(self) -> None: def update_optimum(self, point: SearchDataItem) -> None: r""" - Обновляет оценку оптимума. + Updates the estimate of the optimum. - :param point: точка нового испытания. + :param point: the point of a new trial. """ if self.best is None or self.best.get_index() < point.get_index() or ( diff --git a/iOpt/method/index_method_calculator.py b/iOpt/method/index_method_calculator.py index 46d54e5a..b82503ca 100644 --- a/iOpt/method/index_method_calculator.py +++ b/iOpt/method/index_method_calculator.py @@ -8,7 +8,7 @@ class IndexMethodCalculator(ICriterionEvaluateMethod): """ - Класс Method содержит реализацию Алгоритма Глобального Поиска + The Method class contains an implementation of the Global Search Algorithm """ def __init__(self, @@ -18,11 +18,11 @@ def __init__(self, def calculate_functionals(self, point: SearchDataItem) -> SearchDataItem: r""" - Проведение поискового испытания в заданной точке. + Performing a search test at a given point. - :param point: точка, в которой надо провести испытание. + :param point: the point at which the test is to be performed. - :return: точка, в которой сохранены результаты испытания. + :return: the point at which the test results are saved. """ number_of_constraints = self.task.problem.number_of_constraints for i in range(number_of_constraints): @@ -40,10 +40,10 @@ def calculate_functionals(self, point: SearchDataItem) -> SearchDataItem: def copy_functionals(self, dist_point: SearchDataItem, src_point: SearchDataItem): r""" - Копирование поискового испытания. + Copying the search test. - :param dist_point: точка, в которую копируются значения испытаний. - :param src_point: точка c результатами испытаний. + :param dist_point: point to which the test values are copied. + :param src_point: point with test results. """ dist_point.function_values = copy.deepcopy(src_point.function_values) diff --git a/iOpt/method/listener.py b/iOpt/method/listener.py index 0806060e..424cb183 100644 --- a/iOpt/method/listener.py +++ b/iOpt/method/listener.py @@ -5,7 +5,7 @@ class Listener: """ - Базовый класс слушателя событий. + Event listener base class. """ def before_method_start(self, method: Method): diff --git a/iOpt/method/local_optimizer.py b/iOpt/method/local_optimizer.py index ff75cf45..f1118149 100644 --- a/iOpt/method/local_optimizer.py +++ b/iOpt/method/local_optimizer.py @@ -9,7 +9,7 @@ class LocalTaskWrapper: """ - Класс LocalTaskWrapper (название временное) оборачивает вычисление функции для дальнейшего применения локальных методов. + The LocalTaskWrapper class (the name is temporary) wraps the function computation for further application of local methods. """ def __init__(self, task: OptimizationTask, discrete_variables=None, max_calcs=-1): @@ -20,16 +20,16 @@ def __init__(self, task: OptimizationTask, discrete_variables=None, max_calcs=-1 def evaluate_function(self, y: List[float]) -> float: """ - Метод вычисляет значение целевой функции + The method calculates the value of the target function - :param y: Точка в которой нужно вычислить значение функции + :param y: The point at which you need to calculate the value of the function - :return: возвращает значение целевой функции или - sys.float_info.max, если: - точка лежит за областью поиска - ИЛИ не были выполнены ограничения - ИЛИ было выкинуто исключение (функция не может быть посчитана в этой точке) - ИЛИ число вычислений превысило лимит (если он задан) + :return: returns the value of the target function or + sys.float_info.max, if: + the point lies outside the search area + OR the restrictions have not been met + OR an exception was thrown (the function cannot be calculated at this point) + OR the number of calculations has exceeded the limit (if set) """ point = Point(y, self.discrete_variables) function_value = FunctionValue(FunctionType.OBJECTIV) @@ -60,7 +60,7 @@ def evaluate_function(self, y: List[float]) -> float: class HookeJeevesOptimizer: """ - Класс HookeJeevesOptimizer реализует метод Хука-Дживса. + The HookeJeevesOptimizer class implements the Hooke Jeeves method. """ def __init__(self, func: Callable[[List[float]], float], start_point: Iterable[float], diff --git a/iOpt/method/method.py b/iOpt/method/method.py index ac1a6902..7b2d72bb 100644 --- a/iOpt/method/method.py +++ b/iOpt/method/method.py @@ -18,7 +18,7 @@ class Method: """ - Класс Method содержит реализацию Алгоритма Глобального Поиска + The Method class contains an implementation of the Global Search Algorithm """ def __init__(self, @@ -28,12 +28,12 @@ def __init__(self, search_data: SearchData ): r""" - Конструктор класса Method + Method class constructor - :param parameters: параметры решения задачи оптимизации. - :param task: обёртка решаемой задачи. - :param evolvent: развертка Пеано-Гильберта, отображающая отрезок [0,1] на многомерную область D. - :param search_data: структура данных для хранения накопленной поисковой информации. + :param parameters: parameters of the solution of the optimisation problem. + :param task: problem wrapper. + :param evolvent: Peano-Hilbert evolvent mapping the segment [0,1] to the multidimensional region D. + :param search_data: data structure for storing accumulated search information. """ self.stop: bool = False self.recalcR: bool = True @@ -76,20 +76,20 @@ def min_delta(self, val): def calculate_delta(self, l_point: SearchDataItem, r_point: SearchDataItem, dimension: int) -> float: """ - Вычисляет гельдерово расстояние в метрике Гельдера между двумя точками на отрезке [0,1], - полученными при редукции размерности. + Computes the Gelder distance in the Gelder metric between two points on the segment [0,1], + obtained by dimensionality reduction. - :param l_point: левая точка - :param r_point: правая точка - :param dimension: размерность исходного пространства + :param l_point: left point + :param r_point: right point + :param dimension: dimensionality of the original space - :return: гельдерово расстояние между lx и rx. + :return: helder distance between lx and rx. """ return pow(r_point.get_x() - l_point.get_x(), 1.0 / dimension) def first_iteration(self, calculator: Calculator = None) -> list[SearchDataItem]: r""" - Метод выполняет первую итерацию Алгоритма Глобального Поиска. + The method performs the first iteration of the Global Search Algorithm. """ # Генерация 3х точек 0, 0.5, 1. Значение функции будет вычисляться только в точке 0.5. @@ -180,10 +180,10 @@ def first_iteration(self, calculator: Calculator = None) -> list[SearchDataItem] def check_stop_condition(self) -> bool: r""" - Проверка условия остановки. - Алгоритм должен завершить работу, когда достигнута точность eps или превышен лимит итераций. + Checking the stopping condition. + The algorithm should terminate when eps accuracy is reached or the iteration limit is exceeded. - :return: True, если выполнен критерий остановки; False - в противном случае. + :return: True if the stop criterion is met; False otherwise. """ if self.min_delta < self.parameters.eps or self.iterations_count >= self.parameters.global_method_iteration_count: self.stop = True @@ -194,7 +194,7 @@ def check_stop_condition(self) -> bool: def recalc_m(self) -> None: r""" - Пересчёт оценки константы Липшица. + Recalculating the estimate of the Lipschitz constant. """ if self.recalcM is not True: return @@ -204,7 +204,7 @@ def recalc_m(self) -> None: def recalc_all_characteristics(self) -> None: r""" - Пересчёт характеристик для всех поисковых интервалов. + Recalculation of features for all search intervals. """ if self.recalcR is not True: return @@ -217,11 +217,11 @@ def recalc_all_characteristics(self) -> None: def calculate_next_point_coordinate(self, point: SearchDataItem) -> float: r""" - Вычисление точки нового испытания :math:`x^{k+1}` в заданном интервале :math:`[x_{t-1},x_t]`. + Compute the point of a new test :math:`x^{k+1}` in a given interval :math:`[x_{t-1},x_t]`. - :param point: интервал, заданный его правой точкой :math:`x_t`. + :param point: interval given by its right point :math:`x_t`. - :return: точка нового испытания :math:`x^{k+1}` в этом интервале. + :return: the point of a new test :math:`x^{k+1}` in this interval. """ # https://github.com/MADZEROPIE/ags_nlp_solver/blob/cedcbcc77aa08ef1ba591fc7400c3d558f65a693/solver/src/solver.cpp#L420 left = point.get_left() @@ -251,10 +251,10 @@ def calculate_next_point_coordinate(self, point: SearchDataItem) -> float: def calculate_iteration_point(self) -> Tuple[SearchDataItem, SearchDataItem]: # return (new, old) r""" - Вычисление точки нового испытания :math:`x^{k+1}`. + Calculating the point of a new test :math:`x^{k+1}`. - :return: :math:`x^{k+1}` - точка нового испытания, и :math:`x_t` - левая точка интервала :math:`[x_{t-1},x_t]`, - которому принадлежит :math:`x^{k+1}`, т.е. :math:`x^{k+1} \in [x_{t-1},x_t]`. + :return: :math:`x^{k+1}` - new test point, и :math:`x_t` - left interval point :math:`[x_{t-1},x_t]`, + to which belongs :math:`x^{k+1}`, that is :math:`x^{k+1} \in [x_{t-1},x_t]`. """ if self.recalcM is True: self.recalc_m() @@ -275,11 +275,11 @@ def calculate_iteration_point(self) -> Tuple[SearchDataItem, SearchDataItem]: # def calculate_functionals(self, point: SearchDataItem) -> SearchDataItem: r""" - Проведение поискового испытания в заданной точке. + Performing a search test at a given point. - :param point: точка, в которой надо провести испытание. + :param point: the point at which the test is to be performed. - :return: точка, в которой сохранены результаты испытания. + :return: the point at which the test results are saved. """ try: point = self.task.calculate(point, 0) @@ -293,10 +293,10 @@ def calculate_functionals(self, point: SearchDataItem) -> SearchDataItem: def calculate_m(self, curr_point: SearchDataItem, left_point: SearchDataItem) -> None: r""" - Вычисление оценки константы Гельдера между между curr_point и left_point. + Computing an estimate of the Gelder constant between curr_point and left_point. - :param curr_point: правая точка интервала - :param left_point: левая точка интервала + :param curr_point: right interval point + :param left_point: left interval point """ if curr_point is None: print("CalculateM: curr_point is None") @@ -312,10 +312,10 @@ def calculate_m(self, curr_point: SearchDataItem, left_point: SearchDataItem) -> def calculate_global_r(self, curr_point: SearchDataItem, left_point: SearchDataItem) -> None: r""" - Вычисление глобальной характеристики интервала [left_point, curr_point]. + Calculating the global characteristic of an interval [left_point, curr_point]. - :param curr_point: правая точка интервала. - :param left_point: левая точка интервала. + :param curr_point: right interval point. + :param left_point: left interval point. """ if curr_point is None: print("calculate_global_r: Curr point is NONE") @@ -344,11 +344,11 @@ def calculate_global_r(self, curr_point: SearchDataItem, left_point: SearchDataI def renew_search_data(self, newpoint: SearchDataItem, oldpoint: SearchDataItem) -> None: """ - Метод обновляет всю поисковую информацию: длины интервалов, константы Гёльдера, все характеристики и вставляет - новую точку в хранилище. + The method updates all search information: interval lengths, Gölder constants, all features and inserts a + a new point into the repository. - :param newpoint: новая точка - :param oldpoint: правая точка интервала, которому принадлежит новая точка + :param newpoint: new point + :param oldpoint: right point of the interval to which the new point belongs """ # oldpoint.delta = Method.CalculateDelta(newpoint.GetX(), oldpoint.GetX(), self.dimension) @@ -367,9 +367,9 @@ def renew_search_data(self, newpoint: SearchDataItem, oldpoint: SearchDataItem) def update_optimum(self, point: SearchDataItem) -> None: r""" - Обновляет оценку оптимума. + Updates the optimum estimate. - :param point: точка нового испытания. + :param point: point of a new test. """ if self.best is None or self.best.get_index() < point.get_index(): self.best = point @@ -383,22 +383,22 @@ def update_optimum(self, point: SearchDataItem) -> None: def finalize_iteration(self) -> None: r""" - Заканчивает итерацию, обновляет счётчик итераций. + Ends the iteration, updates the iteration counter. """ self.iterations_count += 1 def get_iterations_count(self) -> int: r""" - Возвращает число выполненных итераций. + Returns the number of iterations performed. - :return: число выполненных итераций. + :return: number of iterations performed. """ return self.iterations_count def get_optimum_estimation(self) -> SearchDataItem: r""" - Возвращает оценку оптимума. + Returns an estimate of the optimum. - :return: текущая оценка оптимума. + :return: current estimate of the optimum. """ return self.best diff --git a/iOpt/method/mixed_integer_method.py b/iOpt/method/mixed_integer_method.py index 9520c21f..afd96bd3 100644 --- a/iOpt/method/mixed_integer_method.py +++ b/iOpt/method/mixed_integer_method.py @@ -22,7 +22,7 @@ class MixedIntegerMethod(IndexMethod): """ - Класс Method содержит реализацию Алгоритма Глобального Поиска + The Method class contains an implementation of the Global Search Algorithm """ def __init__(self, @@ -43,7 +43,7 @@ def __init__(self, def first_iteration(self, calculator: Calculator = None) -> list[SearchDataItem]: r""" - Метод выполняет первую итерацию Алгоритма Глобального Поиска. + The method performs the first iteration of the Global Search Algorithm. """ self.iterations_count = 1 # Генерация 3х точек 0, 0.5, 1. Значение функции будет вычисляться только в точке 0.5. @@ -189,10 +189,10 @@ def first_iteration(self, calculator: Calculator = None) -> list[SearchDataItem] def calculate_iteration_point(self) -> Tuple[SearchDataItem, SearchDataItem]: # return (new, old) r""" - Вычисление точки нового испытания :math:`x^{k+1}`. + Calculating the point of a new test :math:`x^{k+1}`. - :return: :math:`x^{k+1}` - точка нового испытания, и :math:`x_t` - левая точка интервала :math:`[x_{t-1},x_t]`, - которому принадлежит :math:`x^{k+1}`, т.е. :math:`x^{k+1} \in [x_{t-1},x_t]`. + :return: :math:`x^{k+1}` - new test point, и :math:`x_t` - left interval point :math:`[x_{t-1},x_t]`, + to which belongs :math:`x^{k+1}`, that is :math:`x^{k+1} \in [x_{t-1},x_t]`. """ if self.recalcM is True: @@ -219,10 +219,10 @@ def GetDiscreteParameters(problem: Problem) -> list: def calculate_m(self, curr_point: SearchDataItem, left_point: SearchDataItem) -> None: r""" - Вычисление оценки константы Гельдера между между curr_point и left_point. + Computing an estimate of the Gelder constant between curr_point and left_point. - :param curr_point: правая точка интервала - :param left_point: левая точка интервала + :param curr_point: right interval point + :param left_point: left interval point """ # Обратить внимание на вычисление расстояния, должен использоваться метод CalculateDelta if curr_point is None: diff --git a/iOpt/method/parallel_process.py b/iOpt/method/parallel_process.py index 2e2b3a4f..66b54c9c 100644 --- a/iOpt/method/parallel_process.py +++ b/iOpt/method/parallel_process.py @@ -13,7 +13,7 @@ class ParallelProcess(Process): """ - Класс ParallelProcess реализует распараллеливание на уровне потоков (процессов python). + The ParallelProcess class implements parallelisation at the level of threads (python processes). """ def __init__(self, @@ -25,14 +25,14 @@ def __init__(self, listeners: List[Listener] ): """ - Конструктор класса ParallelProcess + Constructor of the ParallelProcess class - :param parameters: Параметры решения задачи оптимизации. - :param task: Обёртка решаемой задачи. - :param evolvent: Развертка Пеано-Гильберта, отображающая отрезок [0,1] на многомерную область D. - :param search_data: Структура данных для хранения накопленной поисковой информации. - :param method: Метод оптимизации, проводящий поисковые испытания по заданным правилам. - :param listeners: Список "наблюдателей" (используется для вывода текущей информации). + :param parameters: Parameters of the solution to the optimisation problem. + :param task: The wrapper of the problem to be solved. + :param evolvent: Peano-Hilbert evolvent mapping the segment [0,1] to the multidimensional region D. + :param search_data: A data structure for storing accumulated search information. + :param method: An optimisation method that performs search tests according to given rules. + :param listeners: List of "observers" (used to display current information). """ super(ParallelProcess, self).__init__(parameters, task, evolvent, search_data, method, listeners) @@ -41,9 +41,9 @@ def __init__(self, def do_global_iteration(self, number: int = 1): """ - Метод позволяет выполнить несколько итераций глобального поиска + The method allows you to perform several iterations of the global search - :param number: Количество итераций глобального поиска + :param number: Number of iterations of global search """ number_ = number done_trials = [] diff --git a/iOpt/method/process.py b/iOpt/method/process.py index 27a04b5f..6832c81b 100644 --- a/iOpt/method/process.py +++ b/iOpt/method/process.py @@ -18,7 +18,7 @@ class Process: """ - Класс Process скрывает внутреннюю имплементацию класса Solver. + The Process class hides the internal implementation of the Solver class. """ def __init__(self, @@ -30,14 +30,14 @@ def __init__(self, listeners: List[Listener] ): """ - Конструктор класса Process - - :param parameters: Параметры решения задачи оптимизации. - :param task: Обёртка решаемой задачи. - :param evolvent: Развертка Пеано-Гильберта, отображающая отрезок [0,1] на многомерную область D. - :param search_data: Структура данных для хранения накопленной поисковой информации. - :param method: Метод оптимизации, проводящий поисковые испытания по заданным правилам. - :param listeners: Список "наблюдателей" (используется для вывода текущей информации). + Constructor of the Process class + + :param parameters: Parameters of the solution to the optimisation problem. + :param task: The wrapper of the problem to be solved. + :param evolvent: Peano-Hilbert evolvent mapping the segment [0,1] to the multidimensional region D. + :param search_data: A data structure for storing accumulated search information. + :param method: An optimisation method that performs search tests according to given rules. + :param listeners: List of "observers" (used to display current information). """ self.parameters = parameters self.task = task @@ -49,10 +49,10 @@ def __init__(self, def solve(self) -> Solution: """ - Метод позволяет решить задачу оптимизации. Остановка поиска выполняется согласно критерию, - заданному при создании класса Solver. + The method allows solving an optimisation problem. The search is stopped according to the criterion, + specified when creating the Solver class. - :return: Текущая оценка решения задачи оптимизации + :return: Current evaluation of the solution to the optimisation problem """ start_time = datetime.now() @@ -79,9 +79,9 @@ def solve(self) -> Solution: def do_global_iteration(self, number: int = 1): """ - Метод позволяет выполнить несколько итераций глобального поиска + The method allows you to perform several iterations of the global search - :param number: Количество итераций глобального поиска + :param number: Number of iterations of global search """ number_ = number done_trials = [] @@ -105,9 +105,9 @@ def do_global_iteration(self, number: int = 1): def do_local_refinement(self, number: int = 1): """ - Метод позволяет выполнить несколько итераций локального поиска + The method allows you to perform several iterations of local search - :param number: Количество итераций локального поиска + :param number: Number of iterations of local search """ try: local_method_iteration_count = number @@ -163,25 +163,25 @@ def do_local_refinement(self, number: int = 1): def get_results(self) -> Solution: """ - Метод возвращает лучшее найденное решение задачи оптимизации + The method returns the best solution to the optimisation problem - :return: Решение задачи оптимизации + :return: Optimisation problem solution """ return self.search_data.solution def save_progress(self, file_name: str) -> None: """ - Сохранение процесса оптимизации из файла + Saving the optimisation process from a file - :param file_name: имя файла + :param file_name: file name """ self.search_data.save_progress(file_name=file_name) def load_progress(self, file_name: str) -> None: """ - Загрузка процесса оптимизации из файла + Loading the optimisation process from a file - :param file_name: имя файла + :param file_name: file name """ self.search_data.load_progress(file_name=file_name) self.method.iterations_count = self.search_data.get_count() - 2 diff --git a/iOpt/method/search_data.py b/iOpt/method/search_data.py index f81bc369..58059f09 100644 --- a/iOpt/method/search_data.py +++ b/iOpt/method/search_data.py @@ -19,21 +19,21 @@ class SearchDataItem(Trial): """ - Класс SearchDataItem предназначен для хранения поисковой информации, представляющей собой - интервал с включенной правой точкой, а так же ссылками на соседние интервалы. SearchDataItem - является наследником от класса Trial. + The SearchDataItem class is intended for storing search information, which is an + interval with a right point included, as well as links to neighbouring intervals. SearchDataItem + is an inheritor of the Trial class. """ def __init__(self, y: Point, x: np.double, function_values: np.ndarray(shape=(1), dtype=FunctionValue) = [FunctionValue()], discrete_value_index: int = 0): """ - Конструктор класса SearchDataItem + Constructor of SearchDataItem class - :param y: Точка испытания в исходной N-мерной области поиска - :param x: Отображении точки испытания y на отрезок [0, 1] - :param function_values: Вектор значений функций (целевой функции и функций ограничений) - :param discrete_value_index: Дискретный параметр + :param y: Test point in the original N-dimensional search area + :param x: Mapping the test point y to the segment [0, 1] + :param function_values: Vector of function values (target and constraint functions) + :param discrete_value_index: Discrete parameter """ super().__init__(point=y, function_values=copy.deepcopy(function_values)) self.point = y @@ -50,171 +50,171 @@ def __init__(self, y: Point, x: np.double, def get_x(self) -> np.double: """ - Метод позволяет получить правую точку поискового интервала, где :math:`x\in[0, 1]`. + The method allows us to obtain the right point of the search interval where :math:`x\in[0, 1]`. - :return: Значение правой точки интервала + :return: Value of the right point of the interval """ return self.__x def get_y(self) -> Point: """ - Метод позволяет получить N-мерную точку испытания исходной области поиска. + The method provides an N-dimensional test point of the original search area. - :return: Значение N-мерной точки испытания + :return: N-dimensional test point value """ return self.point def get_discrete_value_index(self) -> int: """ - Метод позволяет получить дискретный параметр. + The method allows us to obtain a discrete parameter. - :return: Значение дискретного параметра + :return: Discrete parameter value """ return self.__discrete_value_index def set_index(self, index: int): """ - Метод позволяет задать значение индекса последнего выполненного ограничения - для индексной схемы. + The method allows you to specify the index value of the last executed constraint + for the index scheme. - :param index: Индекс ограничения + :param index: Restriction index """ self.__index = index def get_index(self) -> int: """ - Метод позволяет получить значение индекса последнего выполненного ограничения - для индексной схемы. + The method allows to get the index value of the last executed constraint + for the index scheme. - :return: Значение индекса + :return: Index value """ return self.__index def set_z(self, z: np.double): """ - Метод позволяет задать значение функции для заданного индекса. + The method allows you to specify a function value for a given index. - :param z: Значение функции + :param z: Function value """ self.__z = z def get_z(self) -> np.double: """ - Метод позволяет получить значение функции для заданного индекса. + The method allows you to get the value of the function for a given index. - :return: Значение функции для index + :return: Function value for index """ return self.__z def set_left(self, point: SearchDataItem): """ - Метод позволяет задать левый интервал для исходного. + The method allows you to set the left interval for the source interval. - :param point: Левый интервал + :param point: Left interval """ self.__leftPoint = point def get_left(self) -> SearchDataItem: """ - Метод позволяет получить левый интервал для исходного. + The method allows you to get the left interval for the original interval. - :return: Значение левого интервала + :return: Left interval value """ return self.__leftPoint def set_right(self, point: SearchDataItem): """ - Метод позволяет задать правый интервал для исходного. + The method allows you to set the right interval for the original interval. - :param point: Правый интервал + :param point: Right interval """ self.__rightPoint = point def get_right(self) -> SearchDataItem: """ - Метод позволяет получить правый интервал для исходного. + The method allows you to get the right interval for the original interval. - :return: Значение правого интервала + :return: Right interval value """ return self.__rightPoint def __lt__(self, other) -> bool: """ - Метод переопределяет оператор сравнения < для двух интервалов. - :param other: Второй интервал - :return: Значение true - если правая точка исходного интервала меньше - правой точки второго, иначе - false. + The method overrides the < comparison operator for two intervals. + :param other: Second interval + :return: The value is true - if the right point of the initial interval is less than the + the right point of the second interval, otherwise - false. """ return self.get_x() < other.get_x() class CharacteristicsQueue: """ - Класс CharacteristicsQueue предназначен для хранения приоритетной очереди - характеристик с вытеснением. + The CharacteristicsQueue class is designed to store a prioritised queue of + of characteristics with preempting. """ def __init__(self, maxlen: int): """ - Конструктор класса CharacteristicsQueue + Constructor of the CharacteristicsQueue class - :param maxlen: Максимальный размер очереди + :param maxlen: Maximum queue size """ self.__baseQueue = DEPQ(iterable=None, maxlen=maxlen) def Clear(self): """ - Метод позволяет очистить очередь + The method allows you to clear the queue """ self.__baseQueue.clear() def insert(self, key: np.double, data_item: SearchDataItem): """ - Метод добавляет поисковый интервал с указанным приоритетом. - Приоритетом является значение характеристики на данном интервале. + The method adds search interval with specified priority. + The priority is the value of the characteristic on this interval. - :param key: Приоритет поискового интервала - :param data_item: Вставляемый интервал + :param key: Priority of the search interval + :param data_item: Insertion interval """ self.__baseQueue.insert(data_item, key) def get_best_item(self) -> (SearchDataItem, np.double): """ - Метод позволяет получить интервал с лучшей характеристикой + The method allows you to get the interval with the best characteristic - :return: Кортеж: интервал с лучшей характеристикой, приоритет интервала в очереди + :return: Tuple: interval with the best characteristic, priority of the interval in the queue """ return self.__baseQueue.popfirst() def is_empty(self): """ - Метод позволяет сделать проверку на пустоту очереди. + The method allows you to do a check for queue emptiness. - :return: Значение true если очередь пуста, иначе false + :return: True if the queue is empty, otherwise false """ return self.__baseQueue.is_empty() def get_max_len(self) -> int: """ - Метод позволяет получить максимальный размер очереди. + The method allows you to get the maximum queue size. - :return: Значение максимального размера очереди + :return: Value of maximum queue size """ return self.__baseQueue.maxlen def get_len(self) -> int: """ - Метод позволяет получить текущий размер очереди. + The method allows you to get the current queue size. - :return: Значение текущего размера очереди + :return: Value of the current queue size """ return len(self.__baseQueue) class SearchData: """ - Класс SearchData предназначен для хранения множества всех интервалов, исходной задачи - и приоритетной очереди глобальных характеристик. + The SearchData class is used to store the set of all intervals, the original task + and the priority queue of global characteristics. """ # очереди характеристик @@ -228,10 +228,10 @@ class SearchData: def __init__(self, problem: Problem, maxlen: int = None): """ - Конструктор класса SearchData + Constructor of SearchData class - :param problem: Информация об исходной задаче - :param maxlen: Максимальный размер очереди + :param problem: Information about the original task + :param maxlen: Maximum queue size """ self.solution = Solution(problem) self._allTrials = [] @@ -240,7 +240,7 @@ def __init__(self, problem: Problem, maxlen: int = None): def clear_queue(self): """ - Метод позволяет очистить очередь характеристик + The method allows you to clear the feature queue """ self._RGlobalQueue.Clear() @@ -250,11 +250,11 @@ def clear_queue(self): def insert_data_item(self, new_data_item: SearchDataItem, right_data_item: SearchDataItem = None): """ - Метод позволяет добавить новый интервал испытаний в список всех проведенных испытаний - и приоритетную очередь характеристик. + The method allows you to add a new test interval to the list of all tests performed + and prioritised feature queue. - :param new_data_item: Новый интервал испытаний - :param right_data_item: Покрывающий интервал, является правым интервалом для newDataItem + :param new_data_item: New test interval + :param right_data_item: The covering interval, is the right interval for the newDataItem """ flag = True if right_data_item is None: @@ -274,10 +274,10 @@ def insert_data_item(self, new_data_item: SearchDataItem, def insert_first_data_item(self, left_data_item: SearchDataItem, right_data_item: SearchDataItem): """ - Метод позволяет добавить пару интервалов испытаний на первой итерации AGP. + The method allows a pair of test intervals to be added to the first iteration of the AGP. - :param left_data_item: Левый интервал для right_data_item - :param right_data_item: Правый интервал для leftDataItem + :param left_data_item: Left interval for right_data_item + :param right_data_item: Right interval for leftDataItem """ left_data_item.set_right(right_data_item) right_data_item.set_left(left_data_item) @@ -291,10 +291,10 @@ def insert_first_data_item(self, left_data_item: SearchDataItem, # возвращает правую точку def find_data_item_by_one_dimensional_point(self, x: np.double) -> SearchDataItem: """ - Метод позволяет найти покрывающий интервал для полученной точки x. + The method allows you to find the covering interval for the obtained point x. - :param x: Правая точка интервала - :return: Правая точка покрывающего интервала + :param x: Right point of the interval + :return: Right point of the covering interval """ # итерируемся по rightPoint от минимального элемента for item in self: @@ -304,9 +304,9 @@ def find_data_item_by_one_dimensional_point(self, x: np.double) -> SearchDataIte def get_data_item_with_max_global_r(self) -> SearchDataItem: """ - Метод позволяет получить интервал с лучшим значением глобальной характеристики. + The method allows to obtain the interval with the best value of the global characteristic. - :return: Значение интервала с лучшей глобальной характеристикой + :return: Value of the interval with the best global characteristic """ if self._RGlobalQueue.is_empty(): self.refill_queue() @@ -315,8 +315,8 @@ def get_data_item_with_max_global_r(self) -> SearchDataItem: # Перезаполнение очереди (при ее опустошении или при смене оценки константы Липшица) def refill_queue(self): """ - Метод позволяет перезаполнить очередь глобальных характеристик, например, при ее опустошении - или при смене оценки константы Липшица. + The method allows to refill the queue of global characteristics, for example, when it is empty + or when the Lipschitz constant estimation is changed. """ self._RGlobalQueue.Clear() @@ -326,17 +326,17 @@ def refill_queue(self): # Возвращает текущее число интервалов в дереве def get_count(self) -> int: """ - Метод позволяет получить текущее число интервалов в списке. + The method allows you to get the current number of intervals in the list. - :return: Значение числа интервалов в списке + :return: Value of the number of intervals in the list """ return len(self._allTrials) def get_last_item(self) -> SearchDataItem: """ - Метод позволяет получить последний добавленный интервал в список. + The method allows you to get the last added interval to the list. - :return: Значение последнего добавленного интервала + :return: Value of the last added interval """ try: return self._allTrials[-1] @@ -345,9 +345,9 @@ def get_last_item(self) -> SearchDataItem: def get_last_items(self, N: int = 1) -> list[SearchDataItem]: """ - Метод позволяет получить последние добавленные интервалы в список. + The method allows you to get the last added intervals to the list. - :return: Значения последней серии добавленных интервалов + :return: Values of the last series of added intervals """ try: return self._allTrials[-N:] @@ -356,9 +356,9 @@ def get_last_items(self, N: int = 1) -> list[SearchDataItem]: def save_progress(self, file_name: str): """ - Сохранение процесса оптимизации в файл + Saving the optimisation process to a file - :param file_name: имя файла + :param file_name: file name """ data = {} data['SearchDataItem'] = [] @@ -415,9 +415,9 @@ def save_progress(self, file_name: str): def load_progress(self, file_name: str): """ - Загрузка процесса оптимизации из файла + Loading the optimisation process from a file - :param file_name: имя файла + :param file_name: file name """ with open(file_name) as json_file: @@ -503,25 +503,25 @@ def __next__(self): class SearchDataDualQueue(SearchData): """ - Класс SearchDataDualQueue является наследником класса SearchData. Предназначен - для хранения множества всех интервалов, исходной задачи и двух приоритетных очередей - для глобальных и локальных характеристик. + The SearchDataDualQueue class is incherited of the SearchData class. It is intended + for storing a set of all intervals, the initial task and two priority queues + for global and local characteristics. """ def __init__(self, problem: Problem, maxlen: int = None): """ - Конструктор класса SearchDataDualQueue + Constructor of SearchDataDualQueue class - :param problem: Информация об исходной задаче - :param maxlen: Максимальный размер очереди + :param problem: Information on the initial task + :param maxlen: Maximum queue size """ super().__init__(problem, maxlen) self.__RLocalQueue = CharacteristicsQueue(maxlen) def clear_queue(self): """ - Метод позволяет очистить очереди характеристик + The method allows you to clear the feature queues """ self._RGlobalQueue.Clear() self.__RLocalQueue.Clear() @@ -529,11 +529,11 @@ def clear_queue(self): def insert_data_item(self, new_data_item: SearchDataItem, right_data_item: SearchDataItem = None): """ - Метод позволяет добавить новый интервал испытаний в список всех проведенных испытаний - и приоритетные очереди глобальных и локальных характеристик. + The method allows adding a new test interval to the list of all tests performed + and priority queues of global and local characteristics. - :param new_data_item: Новый интервал испытаний - :param right_data_item: Покрывающий интервал, является правым интервалом для newDataItem + :param new_data_item: New test interval + :param right_data_item: The covering interval, is the right interval for the newDataItem """ flag = True if right_data_item is None: @@ -555,9 +555,9 @@ def insert_data_item(self, new_data_item: SearchDataItem, def get_data_item_with_max_global_r(self) -> SearchDataItem: """ - Метод позволяет получить интервал с лучшим значением глобальной характеристики. + The method allows to obtain the interval with the best value of the global characteristic. - :return: Значение интервала с лучшей глобальной характеристикой + :return: Value of the interval with the best global characteristic """ if self._RGlobalQueue.is_empty(): self.refill_queue() @@ -570,9 +570,9 @@ def get_data_item_with_max_global_r(self) -> SearchDataItem: def get_data_item_with_max_local_r(self) -> SearchDataItem: """ - Метод позволяет получить интервал с лучшим значением локальной характеристики. + The method allows to obtain the interval with the best value of the local characteristic. - :return: Значение интервала с лучшей локальной характеристикой + :return: Value of the interval with the best local characteristic """ if self.__RLocalQueue.is_empty(): self.refill_queue() @@ -585,8 +585,8 @@ def get_data_item_with_max_local_r(self) -> SearchDataItem: def refill_queue(self): """ - Метод позволяет перезаполнить очереди глобальных и локальных характеристик, например, - при их опустошении или при смене оценки константы Липшица. + The method allows to refill the queues of global and local characteristics, e.g., + when they are emptied or when the Lipschitz constant estimation is changed. """ self.clear_queue() diff --git a/iOpt/method/solverFactory.py b/iOpt/method/solverFactory.py index 4b466d92..f186683a 100644 --- a/iOpt/method/solverFactory.py +++ b/iOpt/method/solverFactory.py @@ -14,7 +14,7 @@ class SolverFactory: """ - Класс SolverFactory создает подходящие классы метода решения и процесса по заданным параметрам + The SolverFactory class creates suitable solution method and process classes according to the given parameters """ def __init__(self): @@ -26,14 +26,14 @@ def create_method(parameters: SolverParameters, evolvent: Evolvent, search_data: SearchData) -> Method: """ - Создает подходящий класс метода решения по заданным параметрам + Creates a suitable solution method class based on the given parameters - :param parameters: параметры решения задачи оптимизации. - :param task: обёртка решаемой задачи. - :param evolvent: развертка Пеано-Гильберта, отображающая отрезок [0,1] на многомерную область D. - :param search_data: структура данных для хранения накопленной поисковой информации. + :param parameters: parameters of the solution of the optimisation problem. + :param task: the wrapper of the problem to be solved. + :param evolvent: Peano-Hilbert evolvent mapping the segment [0,1] to the multidimensional region D. + :param search_data: data structure for storing accumulated search information. - :return: созданный метод + :return: created method """ if task.problem.number_of_discrete_variables > 0: @@ -51,16 +51,16 @@ def create_process(parameters: SolverParameters, method: Method, listeners: List[Listener]) -> Process: """ - Создает подходящий класс процесса по заданным параметрам + Creates a suitable process class based on the specified parameters - :param parameters: Параметры решения задачи оптимизации. - :param task: Обёртка решаемой задачи. - :param evolvent: Развертка Пеано-Гильберта, отображающая отрезок [0,1] на многомерную область D. - :param search_data: Структура данных для хранения накопленной поисковой информации. - :param method: Метод оптимизации, проводящий поисковые испытания по заданным правилам. - :param listeners: Список "наблюдателей" (используется для вывода текущей информации). + :param parameters: parameters of the solution of the optimisation problem. + :param task: the wrapper of the problem to be solved. + :param evolvent: Peano-Hilbert evolvent mapping the segment [0,1] to the multidimensional region D. + :param search_data: data structure for storing accumulated search information. + :param method: An optimisation method that conducts search tests according to given rules. + :param listeners: List of "observers" (used to display current information). - :return: созданный процесс + :return: created process """ if parameters.number_of_parallel_points == 1: return Process(parameters=parameters, task=task, evolvent=evolvent, diff --git a/iOpt/output_system/listeners/animate_painters.py b/iOpt/output_system/listeners/animate_painters.py index 6b558b61..2619e7ab 100644 --- a/iOpt/output_system/listeners/animate_painters.py +++ b/iOpt/output_system/listeners/animate_painters.py @@ -10,21 +10,21 @@ class AnimatePainterListener(Listener): """ - Класс AnimationPaintListener - слушатель событий. Содержит методы-обработчики, выдающие в качестве - реакции на события динамически обновляющееся изображение процесса оптимизации. - Используется для одномерной оптимизации. + The AnimationPaintListener class is an event listener. It contains handler methods that produce a dynamically updating image of the optimisation process in response to events. + dynamically updated image of the optimisation process as a reaction to events. + It is used for one-dimensional optimisation. """ def __init__(self, file_name: str, path_for_saves="", is_points_at_bottom=False, to_paint_obj_func=True): """ - Конструктор класса AnimationPaintListener - - :param file_name: Название файла с указанием формата для сохранения изображения. Обязательный параметр. - :param path_for_saves: Директория для сохранения изображения. В случае, если параметр не указан, изображение - сохраняется в текущей рабочей директории. - :param is_points_at_bottom: Должны ли точки поисковой информации ставиться под графиком или нет. Если False, - точки ставятся на графике. - :param to_paint_obj_func: Должна ли отрисовываться целевая функция или нет. + AnimationPaintListener class constructor + + :param file_name: File name specifying the format for saving the image. + :param path_for_saves: The directory to save the image. If this parameter is not specified, the image is saved in the current working directory. + is saved in the current working directory. + :param is_points_at_bottom: Whether or not the search information points should be placed below the graph. If False, + the points are placed on the chart. + :param to_paint_obj_func: Whether or not the target function should be rendered. """ self.file_name = file_name self.path_for_saves = path_for_saves @@ -47,20 +47,20 @@ def on_method_stop(self, search_data: SearchData, solution: Solution, status: bo class AnimatePainterNDListener(Listener): """ - Класс AnimationPaintListener - слушатель событий. Содержит методы-обработчики, выдающие в качестве - реакции на события динамически обновляющееся изображение процесса оптимизации. - Используется для многомерной оптимизации. + The AnimationPaintListener class is an event listener. It contains handler methods that produce a dynamically updating image of the optimisation process in response to events. + dynamically updated image of the optimisation process as a reaction to events. + It is used for multidimensional optimisation. """ def __init__(self, file_name: str, path_for_saves="", vars_indxs=[0, 1], to_paint_obj_func=True): """ - Конструктор класса AnimationNDPaintListener + AnimationNDPaintListener class constructor - :param file_name: Название файла с указанием формата для сохранения изображения. Обязательный параметр. - :param path_for_saves: Директория для сохранения изображения. В случае, если параметр не указан, изображение - сохраняется в текущей рабочей директории. - :param vars_indxs: Пара индексов переменных оптимизационной задачи, для которых будет построен рисунок. - :param to_paint_obj_func: Должна ли отрисовываться целевая функция или нет. + :param file_name: File name specifying the format for saving the image. + :param path_for_saves: The directory to save the image. If this parameter is not specified, the image is saved in the current working directory. + is saved in the current working directory. + :param vars_indxs: A pair of indices of the variables of the optimisation problem for which the figure will be plotted. + :param to_paint_obj_func: Whether the target function should be rendered or not. """ self.file_name = file_name self.path_for_saves = path_for_saves diff --git a/iOpt/output_system/listeners/console_outputers.py b/iOpt/output_system/listeners/console_outputers.py index 8955ab0b..0d5e270b 100644 --- a/iOpt/output_system/listeners/console_outputers.py +++ b/iOpt/output_system/listeners/console_outputers.py @@ -11,19 +11,19 @@ class ConsoleOutputListener(Listener): """ - Класс ConsoleFullOutputListener - слушатель событий. Содержит методы-обработчики, выдающие в качестве - реакции на событие консольный вывод. + The ConsoleFullOutputListener class is an event listener. It contains handler methods that produce console output as a + console output as a reaction to the event. """ def __init__(self, mode='full', iters=100): """ - Конструктор класса ConsoleFullOutputListener + Constructor of the ConsoleFullOutputListener class - :param mode: Режим вывода в консоль, который будет использован. Возможные режимы: 'full', 'custom' и 'result'. - Режим 'full' осуществляет в процессе оптимизации полный вывод в консоль получаемой методом поисковой - информации. Режим 'custom' осуществляет вывод текущей лучшей точки с заданной частотой. Режим 'result' - выводит в консоль только финальный результат процесса оптимизации. - :param iters: Частота вывода в консоль. Используется совместно с режимом вывода 'custom'. + :param mode: The console output mode to be used. Possible modes: 'full', 'custom' and 'result'. + The 'full' mode performs full output of the search information obtained by the method to the console during the optimisation process. + information received by the method. The 'custom' mode outputs the current best point with a specified frequency. 'result' mode + mode outputs to the console only the final result of the optimisation process. + :param iters: Frequency of output to the console. Used in conjunction with the 'custom' output mode. """ self.__outputer: ConsoleOutputer = None self.mode = mode diff --git a/iOpt/output_system/listeners/static_painters.py b/iOpt/output_system/listeners/static_painters.py index 107a9371..7861ce6a 100644 --- a/iOpt/output_system/listeners/static_painters.py +++ b/iOpt/output_system/listeners/static_painters.py @@ -79,26 +79,26 @@ def on_method_stop(self, search_data: SearchData, # mode: objective function, approximation, only points class StaticPainterListener(Listener): """ - Класс StaticPaintListener - слушатель событий. Содержит метод-обработчик, выдающий в качестве - реакции на завершение работы метода изображение. + The StaticPaintListener class is an event listener. It contains a method handler that produces an image as a reaction to the method's completion. + as a reaction to the method completion. """ def __init__(self, file_name: str, path_for_saves="", indx=0, is_points_at_bottom=False, mode='objective function'): """ - Конструктор класса StaticPaintListener - - :param file_name: Название файла с указанием формата для сохранения изображения. Обязательный параметр. - :param path_for_saves: Директория для сохранения изображения. В случае, если параметр не указан, изображение - сохраняется в текущей рабочей директории. - :param indx: Индекс переменной оптимизационной задачи. Используется в многомерной оптимизации. - Позволяет отобразить в сечении найденного минимума процесс оптимизации по одной выбранной переменной. - :param is_points_at_bottom: Отрисовать точки поисковой информации под графиком. Если False, точки ставятся на графике. - :param mode: Способ вычислений для отрисовки графика целевой функции, который будет использован. Возможные - режимы: 'objective function', 'only points', 'approximation' и 'interpolation'. Режим 'objective function' - строит график, вычисляя значения целевой функции на равномерной сетке. Режим 'approximation' строит - нейроаппроксимацию для целевой функции на основе полученной поисковой информации. - Режим 'interpolation' строит интерполяцию для целевой функции на основе полученной поисковой информации. - Режим 'only points' не строит график целевой функции. + Constructor of the StaticPaintListener class + + :param file_name: File name specifying the format for saving the image. + :param path_for_saves: The directory to save the image. If this parameter is not specified, the image is saved in the current working directory. + is saved in the current working directory. + :param indx: Index of the variable of the optimisation problem. It is used in multivariate optimisation. + It allows to display in the cross-section of the found minimum the process of optimisation by one selected variable. + :param is_points_at_bottom: Draw search information points below the graph. If False, the points are placed on the graph. + :param mode: The calculation method for drawing the graph of the target function that will be used. Possible + modes: 'objective function', 'only points', 'approximation' and 'interpolation'. The 'objective function' mode + constructs the graph by calculating the values of the objective function on a uniform grid. The 'approximation' mode builds + neuroapproximation for the target function based on the obtained search information. + The 'interpolation' mode builds interpolation for the target function based on the obtained search information. + The 'only points' mode does not plot the target function. """ self.file_name = file_name self.path_for_saves = path_for_saves @@ -119,9 +119,9 @@ def on_method_stop(self, search_data: SearchData, # mode: surface, lines layers, approximation class StaticPainterNDListener(Listener): """ - Класс StaticNDPaintListener - слушатель событий. Содержит метод-обработчик, выдающий в качестве - реакции на завершение работы метода изображение. - Используется для многомерной оптимизации. + The StaticNDPaintListener class is an event listener. It contains a method handler that produces an image as a + image as a reaction to the method completion. + It is used for multidimensional optimisation. """ def __init__(self, file_name: str, path_for_saves="", vars_indxs=[0, 1], mode='lines layers', @@ -129,20 +129,20 @@ def __init__(self, file_name: str, path_for_saves="", vars_indxs=[0, 1], mode='l """ Конструктор класса StaticNDPaintListener - :param file_name: Название файла с указанием формата для сохранения изображения. Обязательный параметр. - :param path_for_saves: Директория для сохранения изображения. В случае, если параметр не указан, изображение - сохраняется в текущей рабочей директории. - :param vars_indxs: Пара индексов переменных оптимизационной задачи, для которых будет построен рисунок. - :param mode_: Режим отрисовки графика целевой функции, который будет использован. - Возможные режимы:'lines layers', 'surface'. - Режим 'lines layers' рисует линии уровня в сечении найденного методом решения. - Режим 'surface' строит поверхность в сечении найденного методом решения. - :param calc: Способ вычислений для отрисовки графика целевой функции, который будет использован. Возможные - режимы: 'objective function' (только в режиме 'lines layers'), 'approximation' (только в режиме 'surface') - и 'interpolation'. Режим 'objective function' строит график, вычисляя значения целевой функции на равномерной - сетке. Режим 'approximation' строит нейроаппроксимацию для целевой функции на основе полученной поисковой - информации. Режим 'interpolation' строит интерполяцию для целевой функции на основе полученной поисковой - информации. + :param file_name: File name specifying the format for saving the image. + :param path_for_saves: The directory to save the image. If this parameter is not specified, the image is saved in the current working directory. + is saved in the current working directory. + :param vars_indxs: A pair of indices of the variables of the optimisation problem for which the figure will be plotted. + :param mode_: Drawing mode of the target function graph that will be used. + Possible modes: 'lines layers', 'surface'. + The 'lines layers' mode draws level lines in the cross-section of the solution found by the method. + The 'surface' mode draws the surface in the cross-section of the solution found by the method. + :param calc: The calculation method for drawing the graph of the target function that will be used. Possible + modes: 'objective function' (only in the 'line layers' mode), 'approximation' (only in the 'surface' mode) + and 'interpolation'. The 'objective function' mode builds a graph by calculating the values of the target function on a uniform grid. + grid. The 'approximation' mode builds a neuroapproximation for the target function based on the obtained search information. + information. The 'interpolation' mode builds interpolation for the target function based on the obtained search information. + information. """ self.file_name = file_name self.path_for_saves = path_for_saves diff --git a/iOpt/output_system/painters/painter.py b/iOpt/output_system/painters/painter.py index 6a117c2e..4e503d54 100644 --- a/iOpt/output_system/painters/painter.py +++ b/iOpt/output_system/painters/painter.py @@ -3,7 +3,7 @@ class Painter: """ - Базовый класс рисовальщика. + Basic Drawer Class. """ def paint_objective_func(self): pass diff --git a/iOpt/output_system/painters/plotters/plotters.py b/iOpt/output_system/painters/plotters/plotters.py index 182ca3bf..1f333750 100644 --- a/iOpt/output_system/painters/plotters/plotters.py +++ b/iOpt/output_system/painters/plotters/plotters.py @@ -219,7 +219,7 @@ def plot_interpolation(self, points, values, points_count=100): class Plotter: """ - Базовый класс вызовов функций стандартного плоттера matplotlib.pyplot. + The base class of standard plotter function calls matplotlib.pyplot. """ def plot_by_grid(self): pass diff --git a/iOpt/problem.py b/iOpt/problem.py index f0c08f77..e92b0aba 100644 --- a/iOpt/problem.py +++ b/iOpt/problem.py @@ -6,7 +6,7 @@ class Problem(ABC): - """Базовый класс для задач оптимизации""" + """Base class for optimisation problems""" def __init__(self): self.name: str = '' @@ -28,16 +28,16 @@ def __init__(self): @abstractmethod def calculate(self, point: Point, function_value: FunctionValue) -> FunctionValue: """ - Метод вычисления функции в заданной точке. - Для любой новой постановки задачи, которая наследуется от :class:`Problem`, этот метод следует перегрузить. + A method for calculating a function at a given point. + For any new problem statement that inherits from :class:`Problem`, this method should be overloaded. - :return: Вычисленное значение функции.""" + :return: Calculated value of the function.""" pass # @abstractmethod def get_name(self): """ - Метод позволяет получить имя задачи + The method allows you to get the name of the problem :return: self.name.""" return self.name diff --git a/iOpt/solution.py b/iOpt/solution.py index 569d1d05..62e68ba5 100644 --- a/iOpt/solution.py +++ b/iOpt/solution.py @@ -5,7 +5,7 @@ class Solution: """ - Класс описания решения задачи оптимизации + Class of description of the solution to the optimisation problem """ def __init__(self, problem: Problem, @@ -16,14 +16,14 @@ def __init__(self, solution_accuracy: np.double = 0.0 ): """ - Конструктор класса + Class constructor - :param problem: Задача оптимизации - :param best_trials: Решение задачи оптимизации - :param number_of_global_trials: Число выполненных глобальных итераций поиска - :param number_of_local_trials: Число выполненных локальных итераций поиска - :param solving_time: Время решения задачи - :param solution_accuracy: Точность найденного решения + :param problem: Optimisation problem + :param best_trials: Solving the optimisation problem + :param number_of_global_trials: Number of global search iterations performed + :param number_of_local_trials: Number of local search iterations performed + :param solving_time: Problem solving time + :param solution_accuracy: Accuracy of the solution found """ self.problem = problem diff --git a/iOpt/solver.py b/iOpt/solver.py index e7613496..05f83318 100644 --- a/iOpt/solver.py +++ b/iOpt/solver.py @@ -13,9 +13,9 @@ class Solver: """ - Класс Solver предназначен для выбора оптимальных (в заданной метрике) значений параметров - сложных объектов и процессов, например, методов искусственного интеллекта и - машинного обучения, а также – методов эвристической оптимизации. + The Solver class is designed to select optimal (in a given metric) values of parameters of complex objects and processes + Solver class is intended for selecting optimal (in a given metric) values of parameters of complex objects and processes, e.g., methods of artificial intelligence and + machine learning and heuristic optimisation methods. """ def __init__(self, @@ -23,10 +23,10 @@ def __init__(self, parameters: SolverParameters = SolverParameters() ): """ - Конструктор класса Solver + Solver class constructor - :param problem: Постановка задачи оптимизации - :param parameters: Параметры поиска оптимальных решений + :param problem: Optimisation problem formulation + :param parameters: Parameters of search for optimal solutions """ self.problem = problem @@ -47,10 +47,10 @@ def __init__(self, def solve(self) -> Solution: """ - Метод позволяет решить задачу оптимизации. Остановка поиска выполняется согласно критерию, - заданному при создании класса Solver. + The method allows solving an optimisation problem. The search is stopped according to the criterion, + specified when creating the Solver class. - :return: решение задачи оптимизации + :return: optimisation problem solution """ Solver.check_parameters(self.problem, self.parameters) if self.parameters.timeout < 0: @@ -73,43 +73,43 @@ def solve(self) -> Solution: def do_global_iteration(self, number: int = 1): """ - Метод позволяет выполнить несколько итераций глобального поиска + The method allows you to perform several iterations of the global search - :param number: число итераций глобального поиска + :param number: number of global search iterations """ Solver.check_parameters(self.problem, self.parameters) self.process.do_global_iteration(number) def do_local_refinement(self, number: int = 1): """ - Метод позволяет выполнить несколько итераций локального поиска + The method allows you to perform several iterations of local search - :param number: число итераций локального поиска + :param number: number of local search iterations """ Solver.check_parameters(self.problem, self.parameters) self.process.do_local_refinement(number) def get_results(self) -> Solution: """ - Метод позволяет получить текущую оценку решения задачи оптимизации + The method provides a current estimate of the solution to the optimisation problem - :return: решение задачи оптимизации + :return: Solving the optimisation problem """ return self.process.get_results() def save_progress(self, file_name: str) -> None: """ - Сохранение процесса оптимизации в файл + Saving the optimisation process to a file - :param file_name: имя файла + :param file_name: file name """ self.process.save_progress(file_name=file_name) def load_progress(self, file_name: str) -> None: """ - Загрузка процесса оптимизации из файла + Loading the optimisation process from a file - :param file_name: имя файла + :param file_name: file name """ Solver.check_parameters(self.problem, self.parameters) self.process.load_progress(file_name=file_name) @@ -120,16 +120,16 @@ def load_progress(self, file_name: str) -> None: def refresh_listener(self) -> None: """ - Метод оповещения наблюдателей о произошедшем событии + Method of notifying observers of an event that has occurred """ pass def add_listener(self, listener: Listener) -> None: """ - Добавления наблюдателя за процессом оптимизации + Additions of an optimisation process observer - :param listener: объект класса реализующий методы наблюдения + :param listener: class object implementing observation methods """ self.__listeners.append(listener) @@ -138,10 +138,10 @@ def add_listener(self, listener: Listener) -> None: def check_parameters(problem: Problem, parameters: SolverParameters = SolverParameters()) -> None: """ - Проверяет параметры решателя + Checks the parameters of the solver - :param problem: Постановка задачи оптимизации - :param parameters: Параметры поиска оптимальных решений + :param problem: Optimisation problem formulation + :param parameters: Parameters of search for optimal solutions """ diff --git a/iOpt/solver_parametrs.py b/iOpt/solver_parametrs.py index 88c21b18..146d1456 100644 --- a/iOpt/solver_parametrs.py +++ b/iOpt/solver_parametrs.py @@ -4,7 +4,7 @@ class SolverParameters: """ - Класс SolverParameters позволяет определить параметры поиска оптимального решения + The SolverParameters class allows you to define the parameters for searching the optimal solution """ def __init__(self, @@ -20,23 +20,23 @@ def __init__(self, proportion_of_global_iterations: float = 0.95 ): r""" - Конструктор класса SolverParameters + Constructor of SolverParameters class - :param eps: Точность решения поставленной задачи. Меньше значения -- выше точность поиска, - меньше вероятность преждевременной остановки. - :param r: Параметр надежности. Более высокое значение r -- более медленная сходимость, - более высокая вероятность нахождения глобального минимума. - :param iters_limit: максимальное число поисковых испытаний. - :param evolvent_density: плотность построения развертки. - По умолчанию плотность :math:`2^{-10}` на гиперкубе :math:`[0,1]^N`, - что означает, что максимальная точность поиска составляет :math:`2^{-10}`. - :param eps_r: параметр, влияющий на скорость решения задачи с ограничениями. eps_r = 0 - медленная сходимоть - к точному решению, eps_r>0 - быстрая сходимть в окрестность решения. - :param refine_solution: если true, то решение будет уточнено с помощью локального метода. - :param start_point: точка начального приближения к решению. - :param number_of_parallel_points: число параллельно вычисляемых испытаний. - :param timeout: ограничение на время вычислений в минутах. - :param proportion_of_global_iterations: доля глобальных итераций в поиске при использовании локальном метода + :param eps: The accuracy of the solution to the task at hand. Smaller values -- higher search accuracy, + less likely to stop prematurely. + :param r: Reliability parameter. Higher value of r -- slower convergence, + higher probability of finding a global minimum. + :param iters_limit: maximum number of search tests. + :param evolvent_density: density of evolvent construction. + The default density is :math:`2^{-10}` on the hypercube :math:`[0,1]^N`, + which means that the maximum search accuracy is :math:`2^{-10}`. + :param eps_r: parameter affecting the speed of solving the problem with constraints. eps_r = 0 - slow convergence + to the exact solution, eps_r>0 - fast convergence to the neighbourhood of the solution. + :param refine_solution: if true, the solution will be refined using the local method. + :param start_point: point of initial approximation to the solution. + :param number_of_parallel_points: number of parallel computed tests. + :param timeout: calculation time limit in minutes. + :param proportion_of_global_iterations: share of global iterations in the search when using the local method """ self.eps = eps self.r = r diff --git a/setup.py b/setup.py index 33c58603..70c3105d 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,7 @@ def _get_requirements(req_name: str): setup( name='iOpt', - version='0.2.1', + version='0.2.22', description='Фреймворк для автоматического выбора значений параметров для математических моделей, ИИ и МО.', author='UNN Team', author_email='',