pypharm 1.2.10__py3-none-any.whl → 1.3.1__py3-none-any.whl

PyPharm/country_optimization.py

@@ -2,6 +2,7 @@ import random
 import numpy as np
 from operator import attrgetter
 from math import ceil, cos, sin
+from multiprocessing import shared_memory
 
 
 class Individual:
@@ -350,7 +351,7 @@ class Country:
 
 class CountriesAlgorithm:
 
-    def __init__(self, f, Xmin, Xmax, M, N, n, p, m, k, l, ep, tmax, printing=False):
+    def __init__(self, f, Xmin, Xmax, M, N, n, p, m, k, l, ep, tmax, printing=False, memory_list=None):
         self.f = f
         self.Xmin = Xmin
         self.Xmax = Xmax
@@ -363,6 +364,7 @@ class CountriesAlgorithm:
         self.tmax = tmax
         self.countries = []
         self.printing = printing
+        self.memory_list = memory_list
         for i in range(M):
             self.countries.append(Country(self.Xmin, self.Xmax, N, self.f))
 
@@ -372,6 +374,8 @@ class CountriesAlgorithm:
         trade = 0
         war = 0
         epedemic = 0
+        if self.memory_list is not None:
+            self.memory_list[0] = False
         while ti <= self.tmax:
             ti += 1
             for country in self.countries:
@@ -457,6 +461,12 @@ class CountriesAlgorithm:
             if self.printing:
                 print(f"{ti}) Лучшее решение: {result.x} - {result.f}, Стран осталось: {len(self.countries)}, Движение/Обмен/Войны/Эпидемии: {motion}/{trade}/{war}/{epedemic}")
                 print(f"Общее количество особей: {sum([len(country.population) for country in self.countries])}")
+
+            if self.memory_list is not None:
+                self.memory_list[0] = ti
+                for i in range(len(result.x)):
+                    self.memory_list[i + 1] = float(result.x[i])
+                self.memory_list[-1] = float(result.f)
         return (result.x, result.f, False, ti)
 
 

PyPharm/models.py

@@ -1,3 +1,5 @@
+from multiprocessing import shared_memory
+
 import numpy as np
 from scipy.integrate import solve_ivp, RK45
 from scipy.integrate._ivp.rk import rk_step, SAFETY, MAX_FACTOR, MIN_FACTOR
@@ -16,7 +18,7 @@ class BaseCompartmentModel:
     _optim = False
     numba_option = False
 
-    def __init__(self, configuration_matrix, outputs, volumes=None, numba_option=False):
+    def __init__(self, configuration_matrix, outputs, volumes=None, numba_option=False, use_shared_memory=False):
         """
         Базовая камерная модель для описания фармакокинетики системы
 
@@ -48,8 +50,18 @@ class BaseCompartmentModel:
             self.volumes_target_count = np.sum(self.volumes == None)
         self.last_result = None
         self.numba_option = numba_option
-
-    def _сompartment_model(self, t, c):
+        self.use_shared_memory = use_shared_memory
+        if self.use_shared_memory:
+            self.memory_size = 2 + self.configuration_matrix_target_count + self.outputs_target_count + self.volumes_target_count
+            self.memory = shared_memory.ShareableList(self.memory_size * [None])
+            self.memory_name = self.memory.shm.name
+
+    def __del__(self):
+        if getattr(self, 'memory', None):
+            self.memory.shm.close()
+            self.memory.shm.unlink()
+
+    def _compartment_model(self, t, c):
         """
         Функция для расчета камерной модели
 
@@ -67,7 +79,7 @@ class BaseCompartmentModel:
 
     @staticmethod
     @njit
-    def _numba_сompartment_model(t, c, configuration_matrix, outputs, volumes):
+    def _numba_compartment_model(t, c, configuration_matrix, outputs, volumes):
         """
         Функция для расчета камерной модели
 
@@ -110,7 +122,7 @@ class BaseCompartmentModel:
             c0 = np.array(c0)
         ts = [0, t_max]
         self.last_result = solve_ivp(
-            fun=self._сompartment_model if not self.numba_option else lambda t, c: self._numba_сompartment_model(t, c, self.configuration_matrix.astype(np.float64), self.outputs.astype(np.float64), self.volumes.astype(np.float64)),
+            fun=self._compartment_model if not self.numba_option else lambda t, c: self._numba_compartment_model(t, c, self.configuration_matrix.astype(np.float64), self.outputs.astype(np.float64), self.volumes.astype(np.float64)),
             t_span=ts,
             y0=c0,
             max_step=max_step,
@@ -206,6 +218,7 @@ class BaseCompartmentModel:
         if method == 'country_optimization':
             CA = CountriesAlgorithm(
                 f=f,
+                memory_list=getattr(self, 'memory', None),
                 **kwargs
             )
             CA.start()
@@ -266,11 +279,19 @@ class MagicCompartmentModel(BaseCompartmentModel):
 
     need_magic_optimization = False
 
-    def __init__(self, configuration_matrix, outputs, volumes=None, magic_coefficient=1, exclude_compartments=[], numba_option=False):
-        super().__init__(configuration_matrix, outputs, volumes, numba_option)
+    def __init__(self, configuration_matrix, outputs, volumes=None, magic_coefficient=1, exclude_compartments=[], numba_option=False, use_shared_memory=False):
+        super().__init__(configuration_matrix, outputs, volumes, numba_option, use_shared_memory)
         self.magic_coefficient = magic_coefficient
         self.exclude_compartments = np.array(exclude_compartments)
         self.need_magic_optimization = self.magic_coefficient is None
+        if getattr(self, "memory", None):
+            self.memory.shm.close()
+            self.memory.shm.unlink()
+            self.memory_size += int(self.need_magic_optimization)
+            self.memory = shared_memory.ShareableList(
+                sequence=self.memory_size * [None]
+            )
+            self.memory_name = self.memory.shm.name
 
     def __call__(self, t_max, c0=None, d=None, compartment_number=None, max_step=0.01, t_eval=None):
         if not self._optim and not self.magic_coefficient:
@@ -301,12 +322,14 @@ class MagicCompartmentModel(BaseCompartmentModel):
 class ReleaseCompartmentModel(BaseCompartmentModel):
 
     need_v_release_optimization = False
+    release_parameters_target = None
+    release_parameters_target = None
 
     class ReleaseRK45(RK45):
 
         def __init__(self, fun, t0, y0, t_bound, release_function, compartment_number, c0, max_step=np.inf,
-                     rtol=1e-3, atol=1e-6, vectorized=False,
-                     first_step=None, **extraneous):
+                     with_accumulate=False, accumulation_function=None, accumulation_type=1, rtol=1e-3, atol=1e-6, vectorized=False,
+                     first_step=None,  **extraneous):
             super().__init__(fun, t0, y0, t_bound, max_step=max_step,
                      rtol=rtol, atol=atol, vectorized=vectorized,
                      first_step=first_step, **extraneous)
@@ -314,15 +337,37 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
             self.compartment_number = compartment_number
             self.c0 = c0
             self.old_release_correction = 0
+            self.old_accumulation_correction = c0
+            self.with_accumulate = with_accumulate
+            self.accumulation_function = accumulation_function
+            self.accumulation_type = accumulation_type
 
         def _step_impl(self):
             result = super()._step_impl()
             release_correction = self.release_function(self.t, self.c0)
-            self.y[self.compartment_number] += release_correction - self.old_release_correction
+            minus_accumulation = 0
+            if self.with_accumulate:
+                if self.accumulation_type == 1:
+                    accumulation_correction = self.accumulation_function(self.t, self.c0 )
+                    minus_accumulation = self.old_accumulation_correction - accumulation_correction
+                elif self.accumulation_type == 2:
+                    coef_accumulation = self.accumulation_function(self.t, self.c0) / self.c0
+            plus_release = release_correction - self.old_release_correction
+            all_corrections = plus_release
+            if self.accumulation_type == 1:
+                if plus_release - minus_accumulation > 0:
+                    all_corrections = plus_release - minus_accumulation
+            elif self.accumulation_type == 2:
+                all_corrections *= coef_accumulation
+            self.y[self.compartment_number] += all_corrections
             self.old_release_correction = release_correction
+            if self.with_accumulate and self.accumulation_type == 1:
+                self.old_accumulation_correction = accumulation_correction
             return result
 
-    def __init__(self, v_release, release_parameters, release_compartment, release_function=None, *args, **kwargs):
+    def __init__(self, v_release, release_parameters, release_compartment,
+                 release_function=None, with_accumulate=False, accumulation_function=None,
+                 accumulation_parameters=[None], accumulation_type=1, *args, **kwargs):
         """
         Камерная модель с высвобождением для описания фармакокинетики системы
 
@@ -349,6 +394,24 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
             self.need_v_release_optimization = True
         self.release_compartment = release_compartment
         self.release_function = release_function
+        self.with_accumulate = with_accumulate
+        self.accumulation_type = accumulation_type
+
+        if self.with_accumulate:
+            self.accumulation_function = accumulation_function
+            self.accumulation_parameters = np.array(accumulation_parameters)
+            if np.any(self.accumulation_parameters == None):
+                self.accumulation_parameters_target = np.where(self.accumulation_parameters == None)
+                self.accumulation_parameters_target_count = np.sum(self.accumulation_parameters == None)
+
+        if getattr(self, "memory", None):
+            self.memory.shm.close()
+            self.memory.shm.unlink()
+            self.memory_size += self.release_parameters_target_count + int(self.need_v_release_optimization)
+            self.memory = shared_memory.ShareableList(
+                sequence=self.memory_size * [None]
+            )
+            self.memory_name = self.memory.shm.name
 
     def load_data_from_list(self, x):
         super().load_data_from_list(x)
@@ -357,6 +420,10 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
             self.release_parameters[self.release_parameters_target] = x[s:s + self.release_parameters_target_count]
         if self.need_v_release_optimization:
             self.v_release = x[s + self.release_parameters_target_count]
+        if self.with_accumulate:
+            if self.accumulation_parameters_target:
+                s += self.release_parameters_target_count + int(self.need_v_release_optimization)
+                self.accumulation_parameters[self.accumulation_parameters_target] = x[s:s + self.accumulation_parameters_target_count]
 
     def _default_release_function(self, t, c0):
         """
@@ -371,6 +438,19 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
         else:
             return self._default_release_function
 
+    def _default_accumulation_function(self, t, c0):
+        """
+        Функция для поправки на накопление
+        """
+        k, = self.accumulation_parameters
+        return c0 * np.exp(-k * t)
+
+    def get_accumulation_function(self):
+        if self.accumulation_function is not None:
+            return lambda t, c0: self.accumulation_function(t, c0, *self.accumulation_parameters)
+        else:
+            return self._default_accumulation_function
+
     def __call__(self, t_max, c0=None, d=None, max_step=0.01, t_eval=None, **kwargs):
         """
                 Расчет кривых концентраций по фармакокинетической модели
@@ -395,9 +475,9 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
         ts = [0, t_max]
         y0 = np.zeros(self.outputs.shape)
         self.last_result = solve_ivp(
-            fun=self._сompartment_model if
+            fun=self._compartment_model if
             not self.numba_option
-            else lambda t, c: self._numba_сompartment_model(t, c,
+            else lambda t, c: self._numba_compartment_model(t, c,
                                                              self.configuration_matrix.astype(
                                                                  np.float64),
                                                              self.outputs.astype(
@@ -411,6 +491,9 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
             method=self.ReleaseRK45,
             release_function=self.get_release_function(),
             compartment_number=self.release_compartment,
+            with_accumulate=self.with_accumulate,
+            accumulation_function=self.get_accumulation_function() if self.with_accumulate else None,
+            accumulation_type=self.accumulation_type,
             c0=c0
         )
         return self.last_result
@@ -438,13 +521,38 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
         )
         target_results = self.last_result.y[tuple(self.know_compartments), :]
         if metric == 'R2':
-            return np.sum(np.sum(self.w * ((target_results - self.teoretic_y) ** 2), axis=1) / np.sum((self.teoretic_avg - self.teoretic_y) ** 2, axis=1))
+            plus = 0
+            if self.teoretic_realized is not None:
+                model_realized = c0 - self.get_release_function()(self.teoretic_x, c0)
+                if self.with_accumulate:
+                    model_accumulation = self.get_accumulation_function()(self.teoretic_x, c0)
+                    if self.accumulation_type == 1:
+                        model_realized = model_accumulation - self.get_release_function()(self.teoretic_x, c0)
+                    elif self.accumulation_type == 2:
+                        accumulation_coeffs = model_accumulation / c0
+                        model_realized = accumulation_coeffs * self.get_release_function()(self.teoretic_x, c0)
+                        model_realized = model_accumulation - model_realized
+                plus = np.sum(((model_realized - self.teoretic_realized) ** 2) / ((self.teoretic_realized - self.teoretic_realized_avg) ** 2))
+            return plus + np.sum(np.sum(self.w * ((target_results - self.teoretic_y) ** 2), axis=1) / np.sum((self.teoretic_avg - self.teoretic_y) ** 2, axis=1))
         elif metric == 'norm':
-            return np.linalg.norm(target_results - self.teoretic_y)
+            plus = 0
+            if self.teoretic_realized is not None:
+                model_realized = c0 - self.get_release_function()(self.teoretic_x, c0)
+                if self.with_accumulate:
+                    model_accumulation = self.get_accumulation_function()(self.teoretic_x, c0)
+                    if self.accumulation_type == 1:
+                        model_realized = model_accumulation - self.get_release_function()(self.teoretic_x, c0)
+                    elif self.accumulation_type == 2:
+                        accumulation_coeffs = model_accumulation / c0
+                        model_realized = accumulation_coeffs * self.get_release_function()(self.teoretic_x, c0)
+                        model_realized = model_accumulation - model_realized
+                plus = np.linalg.norm(self.teoretic_realized - model_realized)
+            return plus + np.linalg.norm(target_results - self.teoretic_y)
         else:
             return np.sum(np.sum(self.w * ((target_results - self.teoretic_y) ** 2), axis=1) / np.sum((self.teoretic_avg - self.teoretic_y) ** 2, axis=1))
 
-    def load_optimization_data(self, teoretic_x, teoretic_y, know_compartments, w = None, c0=None, d=None, compartment_number=None):
+    def load_optimization_data(self, teoretic_x, teoretic_y, know_compartments,
+                               w = None, c0=None, d=None, compartment_number=None, teoretic_realized=None):
         """
         Функция загрузки в модель эксперементальных данных
 
@@ -460,6 +568,9 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
         """
         self.teoretic_x = np.array(teoretic_x)
         self.teoretic_y = np.array(teoretic_y)
+        self.teoretic_realized = np.array(teoretic_realized) if teoretic_realized is not None else teoretic_realized
+        if teoretic_realized is not None:
+            self.teoretic_realized_avg = np.average(self.teoretic_realized)
         self.know_compartments = know_compartments
         self.teoretic_avg = np.average(self.teoretic_y, axis=1)
         self.teoretic_avg = np.repeat(self.teoretic_avg, self.teoretic_x.size)
@@ -481,4 +592,8 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
         if self.need_v_release_optimization:
             self.v_release = x[s:s + self.release_parameters_target_count + 1]
             self.need_v_release_optimization = False
+        if self.with_accumulate:
+            if self.accumulation_parameters_target:
+                s += self.release_parameters_target_count + int(self.need_v_release_optimization)
+                self.accumulation_parameters[self.accumulation_parameters_target] = x[s:s + self.accumulation_parameters_target_count]
         return x

{pypharm-1.2.10.dist-info → pypharm-1.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypharm
-Version: 1.2.10
+Version: 1.3.1
 Summary: Module for solving pharmacokinetic problems
 Home-page: https://github.com/Krash13/PyPharm
 Author: Krash13
@@ -207,6 +207,22 @@ plt.show()
 в таком случае, искомое нужно просто задать как None. Тогда вектор неизвестных это
 x = [configuration_matrix (неизвестные), outputs(неизвестные), volumes(неизвестные), release_parameters(неизвестные), v_release]
 
+
+**6) Использование shared_memory** 
+
+Начиная с версии 1.3.0, вы можете использовать **shared_memory** для получения текущих данных
+оптимизации. Имя нужного вам участка памяти хранится в поле **memory_name**.
+
+```python
+from multiprocessing import shared_memory
+
+c = shared_memory.ShareableList(name='<your model.memory_name>')
+print(c)
+# ShareableList([4, 3.5192100752465563, 1.4158559227257506, 1.7264077213115414, 0.008336751860551, 0.2549196311342251, 0.5160375718404234, 6.915499993374695, 2.944744649331201, 0.5, 1.907294741996761], name='wnsm_0c50aa90')
+```
+
+Данные хранятся в формате списка [текущая_итерация, x0, ... , xn, f], работает только для алгоритма country_optimization.
+
 **ENG documentation**
 ----------
 
@@ -397,3 +413,17 @@ The release_parameters and v_release parameters can be optimized
 in this case, you just need to set the desired value as None. Then the vector of unknowns is
 x = [configuration_matrix (unknown), outputs(unknown), volumes(unknown), release_parameters(unknown), v_release]
 
+**6) Using shared_memory**
+
+Since version 1.3.0, you can use **shared_memory** to get current data
+optimization. The name of the memory location you need is stored in the **memory_name** field.
+```python
+from multiprocessing import shared_memory
+
+c = shared_memory.ShareableList(name='<your model.memory_name>')
+print(c)
+# ShareableList([4, 3.5192100752465563, 1.4158559227257506, 1.7264077213115414, 0.008336751860551, 0.2549196311342251, 0.5160375718404234, 6.915499993374695, 2.944744649331201, 0.5, 1.907294741996761], name='wnsm_0c50aa90')
+```
+
+The data is stored in list format [current_iteration, x0, ... , xn, f], works only for the country_optimization algorithm.
+

pypharm-1.3.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+PyPharm/__init__.py,sha256=hxhMRlWpLMARQV-ZNYkmvhQ9gCYI18an75vlySWjA6s,90
+PyPharm/country_optimization.py,sha256=WsjfAWAWbxRnUUfBiMi1VatCSVbru7F1_G6kQBRVyA0,20452
+PyPharm/country_optimization_v2.py,sha256=3d2mt15DXdr1V3soIJS51xuCv6uzH8pirah1RnI5--8,13156
+PyPharm/models.py,sha256=i02m8P-R256qbt8oMyB6XccgFoFlx5NnuYk5-nRQYVQ,31145
+pypharm-1.3.1.dist-info/METADATA,sha256=SsNyNCtLgb4s92-PF_wWTOJze9_9j-3uzae3QmEFboA,14464
+pypharm-1.3.1.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+pypharm-1.3.1.dist-info/top_level.txt,sha256=yybfSkKw8q1G3aEcnlfVL7_L9ufGFSAYZnpc7q6oYJk,8
+pypharm-1.3.1.dist-info/RECORD,,

pypharm-1.2.10.dist-info/RECORD

@@ -1,8 +0,0 @@
-PyPharm/__init__.py,sha256=hxhMRlWpLMARQV-ZNYkmvhQ9gCYI18an75vlySWjA6s,90
-PyPharm/country_optimization.py,sha256=nbg5kuJcOhMMfPR0_1O8KUzyqHApUcnqgs_I2I0Z1Gs,20008
-PyPharm/country_optimization_v2.py,sha256=3d2mt15DXdr1V3soIJS51xuCv6uzH8pirah1RnI5--8,13156
-PyPharm/models.py,sha256=6loQuWoPjSAAzHlERF6Bszjh7iyasX8RMe-cqbq4Fws,24228
-pypharm-1.2.10.dist-info/METADATA,sha256=pAZ6OkaCelCdBSf3LHKdE8dU3_WAbqHqwPjcFhZsuz0,12911
-pypharm-1.2.10.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
-pypharm-1.2.10.dist-info/top_level.txt,sha256=yybfSkKw8q1G3aEcnlfVL7_L9ufGFSAYZnpc7q6oYJk,8
-pypharm-1.2.10.dist-info/RECORD,,