pypharm 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

PyPharm/country_optimization.py

@@ -2,7 +2,6 @@ import random
 import numpy as np
 from operator import attrgetter
 from math import ceil, cos, sin
-from multiprocessing import shared_memory
 
 
 class Individual:
@@ -469,35 +468,3 @@ class CountriesAlgorithm:
                 self.memory_list[-1] = float(result.f)
         return (result.x, result.f, False, ti)
 
-
-
-# def func(x):
-#     s = 0
-#     for i in range(len(x) - 1):
-#         s += -x[i] * np.sin(abs(x[i] - x[i+1] - 47) ** 0.5) - (x[i+1] + 47) * np.sin(abs(x[i+1] + x[i] / 2 + 47) ** 0.5)
-#     return s
-#
-# k = 0
-# for i in range(100):
-#     CA = CountriesAlgorithm(
-#         f=func,
-#         Xmin=[-512 for i in range(3)],
-#         Xmax=[512 for i in range(3)],
-#         M=100,
-#         N=15,
-#         n=[1, 10],
-#         p=[0.00001, 2.5],
-#         m=[1, 8],
-#         k=8,
-#         l=3,
-#         ep=[0.2, 0.4],
-#         tmax=300,
-#         printing=False,
-#         teoretic_y=-1888.3213909
-#     )
-#     r = CA.start()
-#     print(i, r[2], r[0], r[1])
-#     if r[2]:
-#         k += 1
-#
-# print(k/100)

PyPharm/country_optimization_v3.py

@@ -0,0 +1,426 @@
+import random
+import numpy as np
+import copy
+from operator import attrgetter
+from math import ceil, cos, sin
+import graycode
+
+def rand_str():
+    s = 'qwertyuiopasdfghjklzxcvbnm'
+    k = np.random.choice(len(s), 8, replace=False)
+    res = ''
+    for ki in k:
+        res += s[ki]
+    return res
+
+def check_population(country):
+    return bool(country.population.size)
+
+vector_check_population = np.vectorize(check_population, signature='()->()')
+
+class Individual:
+
+    def __init__(self, gray_code, x_min, x_max, genes, function):
+
+        self.x_min = x_min
+        self.x_max = x_max
+        self.genes = genes
+        self.function = function
+        self.steps = (self.x_max - self.x_min) / (2 ** (self.genes) - 1)
+        self.gray_code = gray_code
+        self.f = self.function(self.real_x)
+        self.ep_n = 0
+
+    @property
+    def real_x(self):
+        decimal_x = []
+        gray_code = copy.deepcopy(self.gray_code)
+        for g in self.genes:
+            decimal_x.append(graycode.gray_code_to_tc(int(gray_code[:g], base=2)))
+            gray_code = gray_code[g:]
+        return self.x_min + self.steps * np.array(decimal_x)
+
+    @property
+    def decimal_x(self):
+        return (self.real_x - self.x_min) / self.steps
+
+    @classmethod
+    def generate_from_decimal(cls, decimal, x_min, x_max, genes, function):
+        gray_code = ''
+        decimal = np.clip(decimal, np.zeros(decimal.size), 2 ** (genes) - 1)
+        for i in range(len(decimal)):
+            s = '{:0' + str(genes[i]) + 'b}'
+            gray_code += s.format(graycode.tc_to_gray_code(int(decimal[i])))
+
+        return cls(gray_code, x_min, x_max, genes, function)
+
+    def mutation(self, max_mutation=1):
+        n = max(0, max_mutation - self.ep_n)
+        if n:
+            gray_code = copy.deepcopy(self.gray_code)
+            k = np.random.choice(len(gray_code), n, replace=False)
+            for ki in k:
+                b = bool(int(gray_code[ki]))
+                b = not b
+                b = str(int(b))
+                gray_code = gray_code[:ki] + b + gray_code[ki+1:]
+            return Individual(gray_code, self.x_min, self.x_max, self.genes, self.function)
+        else:
+            return self
+
+    @classmethod
+    def crossover(cls, individual1, individual2):
+        k = np.random.randint(1, len(individual1.gray_code) - 1, 2)
+        while k[0] == k[1]:
+            k = np.random.randint(1, len(individual1.gray_code) - 1, 2)
+        k = np.sort(k)
+        new_gray1 = individual1.gray_code[:k[0]] + individual2.gray_code[k[0]:k[1]] + individual1.gray_code[k[1]:]
+        new_gray2 = individual2.gray_code[:k[0]] + individual1.gray_code[k[0]:k[1]] + individual2.gray_code[k[1]:]
+        return [
+            cls(new_gray1, individual1.x_min, individual1.x_max, individual1.genes, individual1.function),
+            cls(new_gray2, individual1.x_min, individual1.x_max, individual1.genes, individual1.function),
+        ]
+
+    def __lt__(self, other):
+        return self.f < other.f
+
+    def __le__(self, other):
+        return self.f <= other.f
+
+    def __gt__(self, other):
+        return self.f > other.f
+
+    def __ge__(self, other):
+        return self.f >= other.f
+
+
+class Country:
+
+    def __init__(self, N, x_min, x_max, genes, function):
+        self.f = function
+        self.N = N
+        self.x_min = np.array(x_min)
+        self.x_max = np.array(x_max)
+        self.genes = np.array(genes)
+        self.name = rand_str()
+
+
+        local_xmin = np.random.randint(np.zeros(self.genes.size), 2 ** self.genes - 1)
+        local_xmax = np.random.randint(local_xmin, 2 ** self.genes)
+
+        self.rand_n_individual = np.vectorize(lambda x: x * self.random_individual(local_xmin, local_xmax), signature='()->(n)')
+        self.generate_population = np.vectorize(lambda decimal: Individual.generate_from_decimal(
+            decimal, self.x_min, self.x_max, self.genes, self.f), signature='(n)->()')
+
+        x = self.rand_n_individual(np.ones(self.N))
+        self.population = self.generate_population(x)
+
+
+        self.sort_population()
+        self.action = None
+        self.enemy = None
+        self.ally = None
+
+    def random_individual(self, x_min, x_max):
+        return np.random.randint(x_min, x_max)
+
+    @property
+    def best_function(self):
+        return self.population[0].f
+
+    def roulette_function(self, f_min, f_max):
+        return (f_max - self.population[0].f) / (f_max - f_min)
+
+    @property
+    def avg_function(self):
+        return sum([individual.f for individual in self.population]) / self.population.size
+
+    def sort_population(self):
+        self.population.sort()
+
+    def reproduction(self, n_min, n_max, f_min, f_max):
+        n = ceil((n_max - n_min) * (f_max - self.avg_function) / (f_max - f_min) + n_min)
+        n = np.clip(n, n_min, n_max)
+        # p2 = (1 - ti / t_max) * (self.avg_function - f_min) / (f_max - f_min)
+        new_individuals = []
+
+        for i in range(n):
+            if len(self.population) == 2 and self.population[0] == self.population[1]:
+                new_individuals.extend(Individual.crossover(self.population[0], self.population[1],
+                                                            self.x_min, self.x_max, self.genes, self.f))
+                continue
+            k1 = random.randint(0, len(self.population) - 1)
+            individual1 = self.population[k1]
+            k2 = k1
+            while k2 == k1:
+                k2 = random.randint(0, len(self.population) - 1)
+            individual2 = self.population[k2]
+            new_individuals += Individual.crossover(individual1, individual2)
+        self.population = np.append(self.population, np.array(new_individuals))
+        self.sort_population()
+
+    def extinction(self, m_min, m_max, f_min, f_max):
+        m = int((m_max - m_min) * (self.avg_function - f_min) / (f_max - f_min) + m_min)
+        m = np.clip(m, m_min, m_max)
+        self.population = self.population[:-m]
+
+    def extinction1(self, n):
+        if self.population.size < n:
+            return n - self.population.size
+        self.population = self.population[:n]
+        return 0
+
+    def select_action(self, countries):
+        self.action = random.randint(0, 3)
+        if self.action == 1:
+            ally_list = [country for country in countries if country.action is None and country != self]
+            if ally_list:
+                self.ally = ally_list.pop(random.randint(0, len(ally_list) - 1))
+                self.ally.action = 1
+                self.ally.ally = self
+            else:
+                self.action = random.choice([0, 3])
+        if self.action == 2:
+            enemy_list = [country for country in countries if country.action is None and country != self]
+            if enemy_list:
+                self.enemy = enemy_list.pop(random.randint(0, len(enemy_list) - 1))
+                self.enemy.action = 2
+                self.enemy.enemy = self
+            else:
+                self.action = random.choice([0, 3])
+
+    def epedemic(self, elite, dead, max_mutation):
+        if max_mutation < 1:
+            max_mutation = 1
+        n_elite = ceil(elite * len(self.population))
+        n_dead = ceil(dead * len(self.population))
+        self.population = self.population[:-n_dead]
+        for i in range(n_elite, self.population.size):
+            self.population[i] = self.population[i].mutation(max_mutation)
+        self.sort_population()
+        self.action = None
+
+    # def sabotage(self, n_copy):
+    #     for i in range(n_copy):
+    #         self.enemy.population.append(copy.copy(self.population[0]))
+    #     self.action = None
+    #     self.enemy = None
+
+    def motion(self):
+        x_best = self.population[0].decimal_x
+        for i in range(1, len(self.population)):
+            self.population[i] = Individual.generate_from_decimal(
+                self.population[i].decimal_x + np.int64(random.uniform(0, 2) * (x_best - self.population[i].decimal_x)), self.x_min, self.x_max, self.genes, self.f
+            )
+        self.sort_population()
+        self.action = None
+
+    @staticmethod
+    def trade(country1, country2, k):
+        if country1.population.size <= k or country2.population.size <= k:
+            k = min(country1.population.size, country2.population.size) // 2
+        indexes1 = np.random.choice(country1.population.size, k, replace=False)
+        indexes2 = np.random.choice(country2.population.size, k, replace=False)
+        country2.population = np.concatenate([country2.population, country1.population[indexes1]])
+        country1.population = np.concatenate([country1.population, country2.population[indexes2]])
+        country1.population = np.delete(country1.population, indexes1)
+        country2.population = np.delete(country2.population, indexes2)
+        country1.sort_population()
+        country2.sort_population()
+        country1.action = None
+        country2.action = None
+        country1.ally = None
+        country2.ally = None
+
+    @staticmethod
+    def war(country1, country2, l):
+        if country1.population.size <= l or country2.population.size <= l:
+            l = min(country1.population.size, country2.population.size)
+        indexes1 = np.random.choice(country1.population.size, l, replace=False)
+        indexes2 = np.random.choice(country2.population.size, l, replace=False)
+        war_list1 = country1.population[indexes1]
+        war_list2 = country2.population[indexes2]
+        country1.population = np.delete(country1.population, indexes1)
+        country2.population = np.delete(country2.population, indexes2)
+        wins1 = np.where(war_list1 > war_list2)
+        wins2 = np.where(war_list2 > war_list2)
+        if wins1[0].size > wins2[0].size:
+            np.concatenate([country1.population, war_list1])
+            np.concatenate([country1.population, war_list2])
+        elif wins2[0].size > wins1[0].size:
+            np.concatenate([country2.population, war_list1])
+            np.concatenate([country2.population, war_list2])
+        else:
+            np.concatenate([country1.population, war_list1])
+            np.concatenate([country2.population, war_list2])
+        country1.sort_population()
+        country2.sort_population()
+        country1.action = None
+        country2.action = None
+        country1.enemy = None
+        country2.enemy = None
+
+
+class CountriesAlgorithm:
+
+    def __init__(self, f, Xmin, Xmax, genes, M, N, n, m, k, l, ep, max_mutation, tmax, printing=False, memory_list=None):
+        self.f = f
+        self.Xmin = Xmin
+        self.Xmax = Xmax
+        self.n = n
+        self.genes = genes
+        self.m = m
+        self.k = k
+        self.M = M
+        self.N = N
+        self.l = l
+        self.ep = ep
+        self.max_mutation = max_mutation
+        self.tmax = tmax
+        self.countries = []
+        self.printing = printing
+        self.memory_list = memory_list
+        for i in range(M):
+            self.countries.append(Country(N, self.Xmin, self.Xmax, self.genes, self.f))
+
+    def start(self):
+        ti = 0
+        motion = 0
+        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:
+                if country.action is None:
+                    country.select_action(self.countries)
+            for country in self.countries:
+                if country.action == 0:
+                    motion += 1
+                    country.motion(                    )
+                elif country.action == 1:
+                    trade += 1
+                    Country.trade(
+                        country1=country,
+                        country2=country.ally,
+                        k=self.k
+                    )
+                elif country.action == 2:
+                    war += 1
+                    Country.war(
+                        country1=country,
+                        country2=country.enemy,
+                        l=self.l
+                    )
+                elif country.action == 3:
+                    epedemic += 1
+                    country.epedemic(
+                        elite=self.ep[0],
+                        dead=self.ep[1],
+                        max_mutation=int((1 - ti / self.tmax) * self.max_mutation),
+                    )
+            indexes = np.where(vector_check_population(self.countries) == True)
+            self.countries = [self.countries[i] for i in indexes[0]]
+
+            self.countries = sorted(self.countries, key=attrgetter('avg_function'))
+            if not self.countries:
+                break
+            f_min = self.countries[0].avg_function
+            f_max = self.countries[-1].avg_function
+            if f_min == f_max:
+                self.countries = sorted(self.countries, key=attrgetter('best_function'))
+                result = self.countries[0].population[0]
+                break
+            e_individuals = []
+            for country in self.countries:
+                if len(country.population) == 1:
+                    e_individuals.append(country.population[0])
+                    continue
+                if country.population.size:
+                    country.reproduction(
+                        n_min=self.n[0],
+                        n_max=self.n[1],
+                        f_min=f_min,
+                        f_max=f_max
+                    )
+                    # country.extinction(
+                    #     m_min=self.m[0],
+                    #     m_max=self.m[1],
+                    #     f_min=f_min,
+                    #     f_max=f_max
+                    # )
+            self.countries = sorted(self.countries, key=attrgetter('best_function'))
+            f_min = self.countries[0].best_function
+            f_max = self.countries[-1].best_function
+            s = sum(country.roulette_function(f_min, f_max) for country in self.countries if len(country.population) > 1)
+            self.countries.reverse()
+            for country in self.countries:
+                plus = 0
+                if len(country.population) >= 1:
+                    res = country.extinction1(
+                        max(self.N // 2, ceil(country.roulette_function(f_min, f_max) / s * self.N * self.M)) + plus
+                    )
+                    if res:
+                        plus += res
+                    else:
+                        plus = 0
+
+            indexes = np.where(vector_check_population(self.countries) == True)
+            self.countries = [self.countries[i] for i in indexes[0]]
+
+            for individual in e_individuals:
+                random_country = self.countries[random.randint(0, len(self.countries) - 1)]
+                np.append(random_country.population, np.array([individual]))
+                random_country.sort_population()
+            self.countries = sorted(self.countries, key=attrgetter('best_function'))
+            if not self.countries:
+                break
+            result = self.countries[0].population[0]
+
+            if self.printing:
+                print(f"{ti}) Лучшее решение: {result.real_x} - {result.f}, Стран осталось: {len(self.countries)}, Движение/Обмен/Войны/Эпидемии: {motion}/{trade}/{war}/{epedemic}")
+                print(f"Общее количество особей: {sum([len(country.population) for country in self.countries])}")
+                print("++++++++++++++++++++++++++++++++++++++++++++++++++")
+                for i, country in enumerate(self.countries):
+                    print(f'{i + 1})', country.name, len(country.population), country.best_function, country.avg_function)
+                print("++++++++++++++++++++++++++++++++++++++++++++++++++")
+
+            if self.memory_list is not None:
+                self.memory_list[0] = ti
+                for i in range(len(result.real_x)):
+                    self.memory_list[i + 1] = float(result.real_x[i])
+                self.memory_list[-1] = float(result.f)
+        return (result.real_x, result.f, False, ti)
+
+
+
+# def f(x):
+#     return sum([(xi ** 4 - 16 * xi ** 2 + 5 *xi) / 2 for xi in x])
+# #
+# # k = 0
+# # for i in range(100):
+# CA = CountriesAlgorithm(
+#     f=f,
+#     Xmin=[-5.12 for i in range(3)],
+#     Xmax=[5.12 for i in range(3)],
+#     genes=[16 for i in range(3)],
+#     M=20,
+#     N=15,
+#     n=[1, 10],
+#     m=[3, 8],
+#     k=8,
+#     l=3,
+#     ep=[0.2, 0.4],
+#     max_mutation=16,
+#     tmax=300,
+#     printing=True,
+# )
+# r = CA.start()
+
+#     print(i, r[2], r[0], r[1])
+#     if r[2]:
+#         k += 1
+#
+# print(k/100)

PyPharm/genetic_optimization.py

@@ -0,0 +1,130 @@
+import graycode
+import numpy as np
+import copy
+
+class Individual:
+
+    x_min = None
+    x_max = None
+    genes = None
+    function = None
+    gray_code = None
+    f = None
+
+    def __init__(self, gray_code, x_min, x_max, genes, function, mutation_chance=None, max_mutation=1):
+
+        self.x_min = x_min
+        self.x_max = x_max
+        self.genes = genes
+        self.function = function
+        self.steps = (self.x_max - self.x_min) / (2 ** (self.genes) - 1)
+        self.gray_code = gray_code
+        if mutation_chance is not None and np.random.random() < mutation_chance:
+            self.mutation(max_mutation)
+        self.f = self.function(self.real_x)
+
+    @property
+    def real_x(self):
+        decimal_x = []
+        gray_code = copy.deepcopy(self.gray_code)
+        for g in self.genes:
+            decimal_x.append(graycode.gray_code_to_tc(int(gray_code[:g], base=2)))
+            gray_code = gray_code[g:]
+        return self.x_min + self.steps * np.array(decimal_x)
+
+    @property
+    def decimal_x(self):
+        return (self.real_x - self.x_min) / self.steps
+
+    @classmethod
+    def generate_from_decimal(cls, decimal, x_min, x_max, genes, function):
+        gray_code = ''
+        decimal = np.clip(decimal, np.zeros(decimal.size), 2 ** (genes) - 1)
+        for i in range(len(decimal)):
+            s = '{:0' + str(genes[i]) + 'b}'
+            gray_code += s.format(graycode.tc_to_gray_code(int(decimal[i])))
+
+        return cls(gray_code, x_min, x_max, genes, function)
+
+    @classmethod
+    def crossover(cls, individual1, individual2, mutation_chance, max_mutation=1):
+        k = np.random.randint(1, len(individual1.gray_code) - 1, 2)
+        while k[0] == k[1]:
+            k = np.random.randint(1, len(individual1.gray_code) - 1, 2)
+        k = np.sort(k)
+        new_gray1 = individual1.gray_code[:k[0]] + individual2.gray_code[k[0]:k[1]] + individual1.gray_code[k[1]:]
+        new_gray2 = individual2.gray_code[:k[0]] + individual1.gray_code[k[0]:k[1]] + individual2.gray_code[k[1]:]
+        return [
+                cls(new_gray1, individual1.x_min, individual1.x_max, individual1.genes,
+                    individual1.function, mutation_chance, max_mutation),
+                cls(new_gray2, individual1.x_min, individual1.x_max, individual1.genes,
+                    individual1.function, mutation_chance, max_mutation),
+        ]
+
+    def mutation(self, max_mutation=1):
+        if max_mutation > 0:
+            n = 1 + np.random.randint(1, max_mutation)
+        else:
+            n = 1
+        k = np.random.choice(len(self.gray_code), n, replace=False)
+        for ki in k:
+            b = bool(int(self.gray_code[ki]))
+            b = not b
+            b = str(int(b))
+            self.gray_code = self.gray_code[:ki] + b + self.gray_code[ki+1:]
+
+    def __lt__(self, other):
+        return self.f < other.f
+
+    def __le__(self, other):
+        return self.f <= other.f
+
+    def __gt__(self, other):
+        return self.f > other.f
+
+    def __ge__(self, other):
+        return self.f >= other.f
+
+
+class GeneticAlgorithm:
+
+    def __init__(self, f, n, child_percent, mutation_chance, max_mutation, x_min, x_max, genes, t_max, printing=False):
+        self.f = f
+        self.n = n
+        self.child_percent = child_percent
+        self.mutation_chance = mutation_chance
+        self.max_mutation = max_mutation
+        self.x_min = np.array(x_min)
+        self.x_max = np.array(x_max)
+        self.genes = np.array(genes)
+        self.t_max = np.array(t_max)
+        self.printing = printing
+
+        self.rand_n_individual = np.vectorize(lambda x: x * self.random_individual(), signature='()->(n)')
+        self.generate_population = np.vectorize(lambda decimal: Individual.generate_from_decimal(
+            decimal, self.x_min, self.x_max, self.genes, self.f), signature='(n)->()')
+
+    def random_individual(self):
+        return np.random.randint(np.zeros(self.genes.size), 2 ** self.genes)
+
+    def start(self):
+        x = self.rand_n_individual(np.ones(self.n))
+        population = self.generate_population(x)
+        child_number = int(self.child_percent * self.n)
+
+        t = 0
+        while t <= self.t_max:
+            new_population = []
+            for i in range(child_number):
+                k = np.random.randint(0, self.n, 2)
+                while k[0] == k[1]:
+                    k = np.random.randint(0, self.n, 2)
+                new_population += Individual.crossover(population[k[0]], population[k[1]],
+                                                       self.mutation_chance, self.max_mutation)
+            population = np.append(population, np.array(new_population))
+            population.sort()
+            population = population[:self.n]
+            if self.printing:
+                print("Поколение {}: {} {}".format(t, population[0].real_x, population[0].f))
+            t += 1
+        return population[0].real_x

PyPharm/gold_digger_optimization.py

@@ -0,0 +1,127 @@
+import numpy as np
+
+
+class GoldDigger:
+
+    def __init__(self, x, function):
+        self.x = x
+        self.f = function(self.x)
+        self.ep_n = 0
+
+    def __lt__(self, other):
+        return self.f < other.f
+
+    def __le__(self, other):
+        return self.f <= other.f
+
+    def __gt__(self, other):
+        return self.f > other.f
+
+    def __ge__(self, other):
+        return self.f >= other.f
+
+    def __add__(self, other):
+        return self.f + other.f
+
+    def __radd__(self, other):
+        return self.f + other
+
+    def __truediv__(self, other):
+        return self.f / other
+
+    def update_function(self, function):
+        self.f = function(self.x)
+
+    def new_sigma_digger(self, x_min, x_max, sigma, function):
+        new_x = np.array([self.x[i] + np.random.normal(0, (x_max[i] - x_min[i]) * sigma) for i in range(self.x.size)])
+        new_x = np.clip(new_x, x_min, x_max)
+        return GoldDigger(new_x, function)
+
+
+
+class GoldDiggersAlgorithm:
+
+    def __init__(self, f, n, k, l, u, a, b, sigma_b, sigma_e, Xmin, Xmax, m, t_max):
+        self.f = f
+        self.n = n
+        self.k = k
+        self.l = l
+        self.u = u
+        self.a = a
+        self.b = b
+        self.sigma_b = sigma_b
+        self.sigma_e = sigma_e
+        self.Xmin = np.array(Xmin)
+        self.Xmax = np.array(Xmax)
+        self.m = m
+        self.t_max = t_max
+        self.rand_mat = np.vectorize(lambda x: self.random_matrix(x, Xmin, Xmax), signature='()->(n)')
+        self.digger_init = np.vectorize(lambda x: GoldDigger(x, self.f), signature='(n)->()')
+
+    @staticmethod
+    def random_matrix(x, x_min, x_max):
+        return x * np.random.uniform(x_min, x_max)
+
+    def start(self):
+        x = self.rand_mat(np.ones(self.n))
+        population = self.digger_init(x)
+
+        t = 0
+        intervals = []
+        while t <= self.t_max:
+
+            x = self.rand_mat(np.ones(self.n))
+            in_interval = np.array([self.interval_in(xi, intervals) for xi in x])
+            if np.any(in_interval == True):
+                ind = np.where(in_interval == False)
+                new_x = x[ind]
+                if new_x.size:
+                    population = np.append(population, self.digger_init(new_x))
+                ind = np.where(in_interval == True)
+                r = np.random.rand(ind[0].size)
+                rand_ind = np.where(r <= self.a)
+                ind = (ind[0][rand_ind])
+                x = x[ind]
+                if x.size:
+                    population = np.append(population, self.digger_init(x))
+            else:
+                population = np.append(population, self.digger_init(x))
+
+            sigma = (((self.t_max - t) / self.t_max) ** self.m) * (self.sigma_b - self.sigma_e) + self.sigma_e
+
+            new_diggers = []
+            for digger in population:
+                for _ in range(self.k):
+                    new_diggers.append(digger.new_sigma_digger(self.Xmin, self.Xmax, sigma, self.f))
+            population = np.append(population, new_diggers)
+            population = np.sort(population)
+
+            worst_diggers = population[self.n:]
+            r = np.random.rand(worst_diggers.size)
+            ind = np.where(r <= self.b)
+            worst_diggers = worst_diggers[ind]
+            for digger in worst_diggers:
+                intervals.append(
+                    (digger.x - (self.Xmax - self.Xmin) * sigma, digger.x + (self.Xmax - self.Xmin)  * sigma)
+                )
+            if len(intervals) > self.u:
+                intervals = intervals[len(intervals) - self.u - 1:len(intervals) - 1]
+            population = population[:self.n]
+            print("Поколение {}: {} {}".format(t, population[0].x, population[0].f))
+            t += 1
+        return population[0].x
+
+    @staticmethod
+    def interval_in(x, intervals):
+        for interval in intervals:
+            res = [x[i] >= interval[0][i] and x[i] <= interval[1][i] for i in range(len(x))]
+            if any(res):
+                return True
+        return False
+
+
+def f(x):
+    return sum([(xi ** 4 - 16 * xi ** 2 + 5 *xi) / 2 for xi in x])
+
+# gda = GoldDiggersAlgorithm(f, 15, 10, 10, 50, 0.5, 0.5, 0.5, 0.000001, [-5.12, -5.12, -5.12, -5.12, -5.12, -5.12, -5.12, -5.12, -5.12, -5.12], [5.12, 5.12, 5.12, 5.12, 5.12, 5.12, 5.12, 5.12, 5.12, 5.12], 2, 300)
+# gda.start()

PyPharm/models.py

@@ -6,6 +6,7 @@ from scipy.integrate import simps
 from scipy.optimize import minimize
 from .country_optimization import CountriesAlgorithm
 from .country_optimization_v2 import CountriesAlgorithm_v2
+from .genetic_optimization import GeneticAlgorithm
 from numba import njit
 import matplotlib.pyplot as plt
 
@@ -216,7 +217,8 @@ class BaseCompartmentModel:
             self.c0 = np.array(c0)
         self.w = np.ones(self.teoretic_y.shape) if w is None else np.array(w)
 
-    def optimize(self, method=None, max_step=0.01, metric='R2', **kwargs):
+    def optimize(self, method=None, user_method=None, method_is_func=True,
+                 optimization_func_name='__call__', max_step=0.01, metric='R2', **kwargs):
         """
         Функция оптимизации модели
 
@@ -230,28 +232,41 @@ class BaseCompartmentModel:
         """
         self._optim = True
         f = lambda x: self._target_function(x, max_step=max_step, metric=metric)
-        if method == 'country_optimization':
-            CA = CountriesAlgorithm(
-                f=f,
-                memory_list=getattr(self, 'memory', None),
-                **kwargs
-            )
-            CA.start()
-            x = CA.countries[0].population[0].x
-        elif method == 'country_optimization_v2':
-            CA = CountriesAlgorithm_v2(
-                f=f,
-                **kwargs
-            )
-            CA.start()
-            x = CA.countries[0].population[0].x
+        if user_method is not None:
+            if method_is_func:
+                x = user_method(f, **kwargs)
+            else:
+                optimization_obj = user_method(f, **kwargs)
+                x = getattr(optimization_obj, optimization_func_name)()
         else:
-            res = minimize(
-                fun=f,
-                method=method,
-                **kwargs
-            )
-            x = res.x
+            if method == 'country_optimization':
+                CA = CountriesAlgorithm(
+                    f=f,
+                    memory_list=getattr(self, 'memory', None),
+                    **kwargs
+                )
+                CA.start()
+                x = CA.countries[0].population[0].x
+            elif method == 'country_optimization_v2':
+                CA = CountriesAlgorithm_v2(
+                    f=f,
+                    **kwargs
+                )
+                CA.start()
+                x = CA.countries[0].population[0].x
+            elif method == 'GA':
+                CA = GeneticAlgorithm(
+                    f=f,
+                    **kwargs
+                )
+                x = CA.start()
+            else:
+                res = minimize(
+                    fun=f,
+                    method=method,
+                    **kwargs
+                )
+                x = res.x
         if self.configuration_matrix_target:
             self.configuration_matrix[self.configuration_matrix_target] = x[:self.configuration_matrix_target_count]
         if self.outputs_target:
@@ -326,8 +341,9 @@ class MagicCompartmentModel(BaseCompartmentModel):
         if self.need_magic_optimization:
             self.magic_coefficient = x[-1]
         
-    def optimize(self, method=None, max_step=0.01, **kwargs):
-        x = super().optimize(method, max_step, **kwargs)
+    def optimize(self, method=None, user_method=None, method_is_func=True,
+                 optimization_func_name='__call__', max_step=0.01, **kwargs):
+        x = super().optimize(method, user_method, method_is_func, optimization_func_name, max_step, **kwargs)
         if self.need_magic_optimization:
             self.magic_coefficient = x[-1]
             self.need_magic_optimization = False
@@ -592,8 +608,9 @@ class ReleaseCompartmentModel(BaseCompartmentModel):
             self.c0 = np.array(c0)
         self.w = np.ones(self.teoretic_y.shape) if w is None else np.array(w)
 
-    def optimize(self, method=None, max_step=0.01, **kwargs):
-        x = super().optimize(method, max_step, **kwargs)
+    def optimize(self, method=None, user_method=None, method_is_func=True,
+                 optimization_func_name='__call__', max_step=0.01, **kwargs):
+        x = super().optimize(method, user_method, method_is_func, optimization_func_name, max_step, **kwargs)
         s = self.configuration_matrix_target_count + self.outputs_target_count + self.volumes_target_count
         if self.release_parameters_target:
             self.release_parameters[self.release_parameters_target] = x[s:s + self.release_parameters_target_count]

{pypharm-1.3.3.dist-info → pypharm-1.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pypharm
-Version: 1.3.3
+Version: 1.3.5
 Summary: Module for solving pharmacokinetic problems
 Home-page: https://github.com/Krash13/PyPharm
 Author: Krash13
@@ -143,6 +143,75 @@ model.optimize(
 При оптимизации, вектор неизвестных это
 x = [configuration_matrix (неизвестные), outputs(неизвестные), volumes(неизвестные)]
 
+Кроме того, вы можете использовать генетический алгоритм:
+```python
+model.optimize(
+    method='GA',
+    x_min=[0.00001, 0.001, 0.01, 1, 1],
+    x_max=[1, 2, 1, 10, 3],
+    genes=[16, 17, 16, 20, 16],
+	n=100,
+    child_percent=0.3,
+    mutation_chance=0.5,
+    max_mutation=5,
+    t_max=300,
+    max_step=0.5,
+    printing=True,
+)
+```
+
+Вы даже можете использовать свой собственный алгоритм, если это необходимо
+
+```python
+# CountriesAlgorithm - ваш класс алгоритма
+# start - функция запуска алгоритма
+# важно, чтобы ваша функция запуска возвращала numpy.array
+
+model.optimize(
+    user_method=CountriesAlgorithm,
+    method_is_func=False,
+    optimization_func_name='start',
+    Xmin=[0.00001, 0.001, 0.01, 1, 1], #ваши настроечные параметры
+    Xmax=[1, 2, 1, 10, 3],
+    genes=[16, 17, 16, 20, 16],
+    M=20,
+    N=25,
+    n=[1, 10],
+    max_mutation=8,
+    m=[1, 8],
+    k=8,
+    l=3,
+    ep=[0.2, 0.4],
+    tmax=200,
+    max_step=0.5,
+    printing=True
+)
+```
+
+или
+
+```python
+# my_alg - ваша функция алгоритма, важно, чтобы она принимала только целевую функцию 
+
+model.optimize(
+    user_method=my_alg,
+    Xmin=[0.00001, 0.001, 0.01, 1, 1], #ваши настроечные параметры
+    Xmax=[1, 2, 1, 10, 3],
+    genes=[16, 17, 16, 20, 16],
+    M=20,
+    N=25,
+    n=[1, 10],
+    max_mutation=8,
+    m=[1, 8],
+    k=8,
+    l=3,
+    ep=[0.2, 0.4],
+    tmax=200,
+    max_step=0.5,
+    printing=True
+)
+```
+
 **4) Модель MagicCompartmentModel** 
 
 Данная модель необходима нам для тех случаев, 
@@ -349,6 +418,77 @@ printing=True,
 When optimizing, the vector of unknowns is
 x = [configuration_matrix (unknown), outputs(unknown), volumes(unknown)]
 
+In addition, you can use a genetic algorithm:
+
+```python 
+
+model.optimize(
+    method='GA',
+    x_min=[0.00001, 0.001, 0.01, 1, 1],
+    x_max=[1, 2, 1, 10, 3],
+    genes=[16, 17, 16, 20, 16],
+    n=100,
+    percentage of descendants=0.3,
+    the probability of mutation =0.5,
+    max_mutation=5,
+    t_max=300,
+    max_step=0.5,
+    print=True,
+)
+```
+
+You can even use your own algorithm if necessary.
+
+```python
+# Countryalgorithm - your class is an algorithm
+# start - start the algorithm
+# it is important that your application aroused the interest of numpy.array
+
+model.optimize(
+    user_method=country Countryalgorithm,
+    method_is_func=False,
+    optimization_func_name='start',
+    Xmin=[0.00001, 0.001, 0.01, 1, 1], # your desktop settings
+    Xmax Max=[1, 2, 1, 10, 3],
+    genes=[16, 17, 16, 20, 16],
+    M=20,
+    N=25,
+    n=[1, 10],
+    max_mutation=8,
+    m=[1, 8],
+    k=8,
+    l=3,
+    ep=[0,2, 0,4],
+    tmax=200,
+    max_step=0.5,
+    print=True
+)
+```
+
+or
+
+```python
+# my_alg is your algorithm function, it is important that it accepts only the target function
+
+model.optimize(
+    custom method=my_alg,
+    Xmin=[0.00001, 0.001, 0.01, 1, 1], # your desktop settings
+    Xmax Max=[1, 2, 1, 10, 3],
+    genes=[16, 17, 16, 20, 16],
+    M=20,
+    N=25,
+    n=[1, 10],
+    max_mutation=8,
+    m=[1, 8],
+    k=8,
+    l=3,
+    ep=[0,2, 0,4],
+    tmax=200,
+    max_step=0.5,
+    print=True
+)
+```
+
 **4) The MagicCompartmentModel model**
 
 We need this model for those cases

pypharm-1.3.5.dist-info/RECORD

@@ -0,0 +1,11 @@
+PyPharm/__init__.py,sha256=hxhMRlWpLMARQV-ZNYkmvhQ9gCYI18an75vlySWjA6s,90
+PyPharm/country_optimization.py,sha256=3fnnAJfdLgD0RP8qyJzHBuPDHcPljcLPQM9oqNip1r8,19664
+PyPharm/country_optimization_v2.py,sha256=3d2mt15DXdr1V3soIJS51xuCv6uzH8pirah1RnI5--8,13156
+PyPharm/country_optimization_v3.py,sha256=-3slM5MwSmiG6rD7p9ycbUQPdt4hd5bcEwpSxjb3A7U,17034
+PyPharm/genetic_optimization.py,sha256=EC_pEWwL-ufCQd71zBhCeAB6-Sh1fijv7F3L0bWCz3I,5036
+PyPharm/gold_digger_optimization.py,sha256=mln67sAYxkwzFqZ9Ylild1F25VuaruXRPaUMOGT5gIM,4449
+PyPharm/models.py,sha256=VQlSLGzV3k7mNKiLAIKV29mc6ka6IakmUtEt10cBcq8,33066
+pypharm-1.3.5.dist-info/METADATA,sha256=zodKyZM_l7ORmGwqdtFfqZJ4kpHLiAhexzqYPbvpfA4,17574
+pypharm-1.3.5.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+pypharm-1.3.5.dist-info/top_level.txt,sha256=yybfSkKw8q1G3aEcnlfVL7_L9ufGFSAYZnpc7q6oYJk,8
+pypharm-1.3.5.dist-info/RECORD,,

pypharm-1.3.3.dist-info/RECORD

@@ -1,8 +0,0 @@
-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=qZDaVKiSdY3kXXeck5M8CEfmMD_V3AilZXIddyIocck,32080
-pypharm-1.3.3.dist-info/METADATA,sha256=fDQvBkW3wSRuOuyBc3RFNg50h4fBT60of6xMCOAughY,14464
-pypharm-1.3.3.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
-pypharm-1.3.3.dist-info/top_level.txt,sha256=yybfSkKw8q1G3aEcnlfVL7_L9ufGFSAYZnpc7q6oYJk,8
-pypharm-1.3.3.dist-info/RECORD,,