Создадим интересную программу на Python, которая реализует генетический алгоритм для решения задачи оптимизации — нахождения минимума функции. Мы применим генетический алгоритм для минимизации функции Растригина, известной своей сложностью и множеством локальных минимумов.

import numpy as np
import matplotlib.pyplot as plt

# Определение функции Растригина
def rastrigin(x):
    A = 10
    return A * len(x) + sum([(xi**2 - A * np.cos(2 * np.pi * xi)) for xi in x])

# Параметры генетического алгоритма
POP_SIZE = 100       # Размер популяции
GENES = 2            # Количество генов (размерность задачи)
GENERATIONS = 50     # Количество поколений
MUTATION_RATE = 0.1  # Вероятность мутации

# Инициализация популяции
population = [np.random.uniform(-5.12, 5.12, GENES) for _ in range(POP_SIZE)]

# Эволюционный цикл
best_scores = []
for generation in range(GENERATIONS):
    # Оценка приспособленности
    fitness = [ -rastrigin(individual) for individual in population]
    
    # Сохранение лучшего результата
    best_scores.append(-min(fitness))
    
    # Селекция
    parents = [population[i] for i in np.argsort(fitness)[-POP_SIZE//2:]]
    
    # Кроссовер
    offspring = []
    for _ in range(POP_SIZE//2):
        parent1, parent2 = np.random.choice(parents, 2, replace=False)
        crossover_point = np.random.randint(1, GENES)
        child = np.concatenate([parent1[:crossover_point], parent2[crossover_point:]])
        offspring.append(child)
    
    # Мутация
    for individual in offspring:
        if np.random.rand() < MUTATION_RATE:
            mutation_point = np.random.randint(GENES)
            individual[mutation_point] += np.random.uniform(-1, 1)
            individual[mutation_point] = np.clip(individual[mutation_point], -5.12, 5.12)
    
    # Обновление популяции
    population = parents + offspring

# Вывод результатов
best_individual = population[np.argmax(fitness)]
print("Лучшее решение:", best_individual)
print("Значение функции:", rastrigin(best_individual))

# Визуализация сходимости
plt.plot(best_scores)
plt.title('Сходимость генетического алгоритма')
plt.xlabel('Поколение')
plt.ylabel('Значение функции')
plt.show()

Описание кода:

1. Функция Растригина (`rastrigin`): сложная функция с множеством локальных минимумов, часто используемая для тестирования алгоритмов оптимизации.

2. Параметры алгоритма:
- POP_SIZE: количество особей в популяции.
- GENES: количество генов в хромосоме (размерность задачи).
- GENERATIONS: количество поколений для эволюции.
- MUTATION_RATE: вероятность мутации потомка.

3. Инициализация популяции: создаем начальную популяцию со случайными значениями в диапазоне [-5.12, 5.12].

4. Эволюционный цикл:
- Оценка приспособленности: вычисляем отрицательное значение функции Растригина для каждой особи (так как мы минимизируем функцию).
- Сохранение лучшего результата: отслеживаем наилучшее значение функции в каждом поколении.
- Селекция: выбираем лучших особей (с наилучшей приспособленностью) для создания потомства.
- Кроссовер: комбинируем гены пар родителей для создания новых особей.
- Мутация: вносим случайные изменения в гены потомков с определенной вероятностью.
- Обновление популяции: формируем новую популяцию из родителей и потомков.

5. Вывод результатов:
- Находим и выводим лучшую особь после всех поколений.
- Выводим соответствующее значение функции Растригина.
- Строим график сходимости значений функции по поколениям.

Как запустить код:

1. Установите необходимые библиотеки:

   pip install numpy matplotlib
   

2. Сохраните код в файл, например `genetic_algorithm.py`.

3. Запустите скрипт:

   python genetic_algorithm.py
   

Ожидаемый результат:

- В консоли отобразится лучшее найденное решение и значение функции в этой точке.
- Откроется график, показывающий, как значение функции менялось по мере эволюции поколений.

Примечания:

- Эксперименты с параметрами: Попробуйте изменить параметры алгоритма (размер популяции, количество поколений, вероятность мутации), чтобы увидеть, как они влияют на результат и скорость сходимости.
- Расширение на большую размерность: Вы можете увеличить GENES для решения задачи в пространстве большей размерности, что сделает задачу более сложной.

Заключение:

Этот пример демонстрирует применение генетических алгоритмов для решения задач оптимизации сложных функций. Генетические алгоритмы имитируют процессы естественного отбора и генетической мутации, позволяя находить приближенные решения в задачах, где аналитическое решение затруднительно.

Подпишись 👉🏻 @KodduuPython 🤖

Вот код, который создает интерактивную визуализацию, где точки движутся, образуя различные узоры. Этот код создает окно с анимацией точек, которые перемещаются по кругу и создают интересные узоры. К тому же, это легко настраивается для других геометрических форм.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Настройка параметров
num_points = 50
radius = 10

# Создаем исходные координаты точек на окружности
angles = np.linspace(0, 2 * np.pi, num_points, endpoint=False)
x_coords = radius * np.cos(angles)
y_coords = radius * np.sin(angles)

fig, ax = plt.subplots()
ax.set_aspect('equal', 'box')
scatter = ax.scatter(x_coords, y_coords, s=50, color='blue')
ax.set_xlim(-radius * 1.2, radius * 1.2)
ax.set_ylim(-radius * 1.2, radius * 1.2)

def update(frame):
    # Обновление углов и координат для движения точек
    new_angles = angles + 0.1 * frame
    x_coords = radius * np.cos(new_angles + frame * 0.01)
    y_coords = radius * np.sin(new_angles + frame * 0.01)
    scatter.set_offsets(np.c_[x_coords, y_coords])
    return scatter,

ani = animation.FuncAnimation(fig, update, frames=200, interval=50, blit=True)
plt.show()

Этот код:

- Создает 50 точек, которые расположены по кругу.
- С каждой итерацией они слегка смещаются, создавая эффект "волны" и "размытости".
- Получается гипнотическая анимация, которую можно менять, изменяя радиус, количество точек или скорость.

Подпишись 👉🏻 @KodduuPython 🤖

Попробуем создать более сложную анимацию, в которой точки будут двигаться по нелинейным траекториям, создавая узоры. Этот пример использует траектории, которые зависят от синусоидальных и косинусоидальных функций с переменным радиусом, чтобы добавить нелинейные колебания.

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Настройка параметров
num_points = 50
base_radius = 10

# Создаем исходные углы для точек
angles = np.linspace(0, 2 * np.pi, num_points, endpoint=False)

fig, ax = plt.subplots()
ax.set_aspect('equal', 'box')
scatter = ax.scatter([], [], s=50, color='purple')
ax.set_xlim(-base_radius * 1.5, base_radius * 1.5)
ax.set_ylim(-base_radius * 1.5, base_radius * 1.5)

# Обновление координат для нелинейных траекторий
def update(frame):
    # Нелинейный радиус с добавлением синусоидальной амплитуды
    radius = base_radius + 3 * np.sin(frame * 0.05)
    x_coords = radius * np.cos(angles + 0.05 * frame) + 2 * np.sin(angles * 3 + frame * 0.1)
    y_coords = radius * np.sin(angles + 0.05 * frame) + 2 * np.cos(angles * 4 + frame * 0.1)
    
    scatter.set_offsets(np.c_[x_coords, y_coords])
    return scatter,

# Настройка анимации
ani = animation.FuncAnimation(fig, update, frames=400, interval=50, blit=True)
plt.show()

### Как это работает:
- Радиус каждой точки зависит от времени и изменяется по синусоиде, что делает движение точек более динамичным.
- Траектория движения каждой точки - это комбинация нескольких синусоидальных и косинусоидальных функций, что создает уникальные узоры на каждом кадре.
- Частотные множители для angles (например, 3 и 4 внутри x_coords и `y_coords`) добавляют колебания по окружности, что создает сложные, закрученные траектории.

Подпишись 👉🏻 @KodduuPython 🤖

Код анимации выше 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Как насчёт кода, который рисует фрактал *Множества Мандельброта* и анимирует его приближение? Это отличный пример красоты и сложности фрактальной геометрии! И демо того как оно может тормозить на большом кол-во объектов 🐌 В следующем посте расскажем как ускорить ⚡️

Вот код для визуализации этого фрактала с постепенным "увеличением" на определённой области:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

# Настройка параметров фрактала
width, height = 800, 800  # Размер окна
max_iter = 256  # Максимальное количество итераций

# Начальные координаты для анимации (центр Мандельброта)
xmin, xmax, ymin, ymax = -2.0, 1.0, -1.5, 1.5

# Функция для вычисления множества Мандельброта
def mandelbrot(c, max_iter):
    z = c
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z*z + c
    return max_iter

# Функция, которая генерирует фрактал
def generate_mandelbrot(xmin, xmax, ymin, ymax, width, height, max_iter):
    x, y = np.linspace(xmin, xmax, width), np.linspace(ymin, ymax, height)
    C = x + y[:, None] * 1j
    mandelbrot_set = np.frompyfunc(lambda c: mandelbrot(c, max_iter), 1, 1)(C).astype(np.float32)
    return mandelbrot_set

# Создаем фигуру и ось для анимации
fig, ax = plt.subplots(figsize=(6, 6))
im = ax.imshow(generate_mandelbrot(xmin, xmax, ymin, ymax, width, height, max_iter), 
               extent=(xmin, xmax, ymin, ymax), cmap='hot', origin='lower')

# Функция обновления для анимации
def update(frame):
    zoom_factor = 1.5 ** (-frame * 0.1)
    x_center, y_center = -0.7435, 0.1314  # координаты интересной точки
    dx, dy = (xmax - xmin) * zoom_factor, (ymax - ymin) * zoom_factor
    xmin_new, xmax_new = x_center - dx / 2, x_center + dx / 2
    ymin_new, ymax_new = y_center - dy / 2, y_center + dy / 2

    mandelbrot_set = generate_mandelbrot(xmin_new, xmax_new, ymin_new, ymax_new, width, height, max_iter)
    im.set_data(mandelbrot_set)
    im.set_extent((xmin_new, xmax_new, ymin_new, ymax_new))
    return im,

# Анимация фрактала
ani = animation.FuncAnimation(fig, update, frames=100, interval=50, blit=True)
plt.show()

### Объяснение кода:
- Множество Мандельброта создаётся путём проверки, стремятся ли точки в комплексной плоскости к бесконечности при итерациях по формуле \( z = z^2 + c \).
- Функция `generate_mandelbrot` вычисляет фрактал для заданных границ и преобразует его в массив значений.
- Анимация `update` постепенно уменьшает масштаб (приближает) вокруг интересной точки, что позволяет видеть больше деталей.

Подпишись 👉🏻 @KodduuPython 🤖

Код анимации тут 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Для ускорения анимации Множества Мандельброта можно воспользоваться несколькими подходами:

1. Уменьшить разрешение (размер width и `height`), чтобы уменьшить количество вычисляемых точек.
2. Оптимизировать функцию `mandelbrot` с использованием Numba для компиляции в машинный код, что значительно ускоряет обработку.
3. Параллельные вычисления для обработки точек массива.

Давайте применим Numba и создадим ускоренную версию. Для этого сначала нужно установить numba, если она не установлена:

pip install numba

Затем добавим @njit из Numba, чтобы ускорить расчёты:

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from numba import njit

# Настройка параметров фрактала
width, height = 600, 600  # Уменьшили размер для повышения скорости
max_iter = 256  # Максимальное количество итераций

# Компилируем функцию с помощью Numba
@njit
def mandelbrot(c, max_iter):
    z = c
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z * z + c
    return max_iter

@njit
def generate_mandelbrot(xmin, xmax, ymin, ymax, width, height, max_iter):
    x = np.linspace(xmin, xmax, width)
    y = np.linspace(ymin, ymax, height)
    mandelbrot_set = np.empty((height, width), dtype=np.float32)
    for i in range(width):
        for j in range(height):
            mandelbrot_set[j, i] = mandelbrot(x[i] + 1j * y[j], max_iter)
    return mandelbrot_set

# Создаем фигуру и ось для анимации
fig, ax = plt.subplots(figsize=(6, 6))
im = ax.imshow(generate_mandelbrot(-2.0, 1.0, -1.5, 1.5, width, height, max_iter), 
               extent=(-2.0, 1.0, -1.5, 1.5), cmap='hot', origin='lower')

# Функция обновления для анимации
def update(frame):
    zoom_factor = 1.5 ** (-frame * 0.1)
    x_center, y_center = -0.7435, 0.1314  # координаты интересной точки
    dx, dy = (1.0 - -2.0) * zoom_factor, (1.5 - -1.5) * zoom_factor
    xmin_new, xmax_new = x_center - dx / 2, x_center + dx / 2
    ymin_new, ymax_new = y_center - dy / 2, y_center + dy / 2

    mandelbrot_set = generate_mandelbrot(xmin_new, xmax_new, ymin_new, ymax_new, width, height, max_iter)
    im.set_data(mandelbrot_set)
    im.set_extent((xmin_new, xmax_new, ymin_new, ymax_new))
    return im,

# Анимация фрактала
ani = animation.FuncAnimation(fig, update, frames=100, interval=50, blit=True)
plt.show()

### Изменения в коде:
- Numba (`@njit`) значительно ускоряет функции mandelbrot и generate_mandelbrot за счёт компиляции в машинный код.
- Уменьшение `width` и `height` до 600x600 пикселей снижает нагрузку на процессор.

Эти изменения помогут повысить производительность, делая анимацию более плавной и быстрой.

Подпишись 👉🏻 @KodduuPython 🤖

Код анимации тут 👆👆👆

Подпишись 👉🏻 @KodduuPython 🤖

Давайте рассмотрим интересный пример оптимизированного кода без графики. Здесь мы попробуем найти самый длинный общий префикс среди списка строк. Это задача с большими списками строк, которую можно значительно ускорить, оптимизировав подход.

❗️Популярная задача на собеседованиях 👆

### 1. Наивное решение

Обычно, для решения задачи нахождения общего префикса используют простой подход: проверяют символы по очереди в каждой строке, пока они совпадают. Однако, это не самый оптимальный способ, особенно при большом количестве строк.

### 2. Оптимизированное решение: Используем zip и itertools

С помощью zip и itertools.takewhile можно написать более компактный и быстрый вариант решения, где мы проходим по символам сразу в каждой строке:

from itertools import takewhile

def longest_common_prefix(strings):
    if not strings:
        return ""
    # Проверяем символы по позициям, пока все строки имеют одинаковый символ в одной позиции
    prefix = ''.join(
        c[0] for c in takewhile(lambda x: len(set(x)) == 1, zip(*strings))
    )
    return prefix

# Пример использования
strings = ["optimization", "optimize", "option", "optimum"]
print("Самый длинный общий префикс:", longest_common_prefix(strings))

### Объяснение кода:
1. `zip(*strings)` — объединяет символы по одной позиции из каждой строки в кортежи. Например, для ["optimization", "optimize", "option", "optimum"] получится ('o', 'o', 'o', 'o') для первой позиции.
2. `takewhile(lambda x: len(set(x)) == 1, ...)` — проходит по символам, пока в каждой позиции у всех строк одинаковый символ.
3. Компоновка результата — только нужные символы сохраняются, и ''.join() собирает их в строку.

### Почему это быстрее?
- Использование zip и itertools позволяет обрабатывать каждый символ только один раз, без дополнительных проверок по индексам, что ускоряет процесс для длинных строк или больших списков.
- Алгоритм оптимален по времени и памяти, так как завершается, как только находит первое различие между строками.

Подпишись 👉🏻 @KodduuPython 🤖

Отпечатки пальцев, в контексте программирования, могут использоваться для уникальной идентификации данных, обычно с помощью хеширования. Чтобы продемонстрировать, как это работает, можно использовать хеш-функции, например, SHA-256 из библиотеки hashlib в Python. В примере ниже создадим отпечаток пальца для строки, чтобы показать, как хеширование создает уникальный идентификатор для входных данных.

Вот пример кода:

import hashlib

# Функция для создания отпечатка пальца (хеш) данных
def create_fingerprint(data: str) -> str:
    # Преобразуем строку в байты
    byte_data = data.encode('utf-8')
    # Создаем хеш с использованием алгоритма SHA-256
    fingerprint = hashlib.sha256(byte_data).hexdigest()
    return fingerprint

# Примеры данных
data1 = "Hello, world!"
data2 = "Hello, world!"
data3 = "Goodbye, world!"

# Создаем отпечатки пальцев для каждого из примеров
fingerprint1 = create_fingerprint(data1)
fingerprint2 = create_fingerprint(data2)
fingerprint3 = create_fingerprint(data3)

# Выводим результаты
print(f"Отпечаток пальца для 'Hello, world!': {fingerprint1}")
print(f"Отпечаток пальца для идентичной строки 'Hello, world!': {fingerprint2}")
print(f"Отпечаток пальца для 'Goodbye, world!': {fingerprint3}")

# Проверка уникальности
print("\nОтпечатки идентичны для одинаковых данных?" , fingerprint1 == fingerprint2)
print("Отпечатки различаются для разных данных?", fingerprint1 != fingerprint3)

### Объяснение кода:
1. Хеширование данных: Функция create_fingerprint принимает строку и создает для нее хеш с помощью алгоритма SHA-256, возвращая строку с шестнадцатеричным представлением хеша.
2. Проверка идентичности: Отпечатки пальцев для одинаковых данных идентичны, но если изменить хотя бы один символ, хеш будет совершенно другим, что демонстрирует чувствительность хеша к изменениям в данных.

Этот метод может быть использован, например, для проверки целостности файлов, безопасного хранения паролей или идентификации уникальных данных.

Подпишись 👉🏻 @KodduuPython 🤖

Для работы с реальными отпечатками пальцев в Python существуют специализированные библиотеки и инструменты. Они позволяют захватывать, обрабатывать и анализировать изображения отпечатков пальцев, а также выполнять задачи биометрической аутентификации. Вот некоторые из них:

PyFingerprint — это библиотека Python, которая позволяет управлять биометрическими датчиками отпечатков пальцев на базе модуля ZFM-20. Она подходит для простых приложений и работает с популярными USB-сканерами, предоставляя базовый набор функций, включая регистрацию, поиск и удаление отпечатков.

#### Установка
PyFingerprint можно установить через pip:

pip install PyFingerprint

#### Пример кода
Следующий код показывает, как инициализировать сканер и зарегистрировать или идентифицировать отпечаток пальца:

from pyfingerprint.pyfingerprint import PyFingerprint

try:
    # Подключение к сканеру отпечатков пальцев
    f = PyFingerprint('/dev/ttyUSB0', 57600, 0xFFFFFFFF, 0x00000000)
    if not f.verifyPassword():
        raise ValueError("Пароль не подходит!")

    # Ожидание отпечатка пальца
    print("Поместите палец на сканер...")
    while not f.readImage():
        pass

    # Конвертация изображения отпечатка в шаблон
    f.convertImage(0x01)
    positionNumber = f.searchTemplate()
    if positionNumber >= 0:
        print(f"Отпечаток найден на позиции #{positionNumber}")
    else:
        print("Отпечаток не распознан")

except Exception as e:
    print("Ошибка:", str(e))

#### Преимущества и ограничения
* Преимущества: Легкость в использовании, простота интеграции с недорогими USB-сканерами.
* Ограничения: Подходит только для датчиков серии ZFM, ограниченный набор функций для базовых приложений.

PyFingerprint — отличный вариант для проектов с бюджетными ограничениями, особенно для простых DIY-проектов с использованием Raspberry Pi или Arduino.

Подпишись 👉🏻 @KodduuPython 🤖

Отпечатки пальцев, как правило, не хранятся в формате изображений, таких как JPG, из-за риска потери качества и проблем сжатия. Вместо этого используются специализированные форматы и методы хранения биометрической информации, которые сохраняют ключевые характеристики отпечатка пальца в виде шаблона, а не самого изображения.

Предположим, что у нас есть простое изображение отпечатка пальца (в реальности снимок делается датчиком отпечатков и обрабатывается специализированной библиотекой). Вместо изображения будем работать с данными в формате координат уникальных точек, таких как минуции.

# Пример извлеченных данных для отпечатка пальца
# Координаты минуций и углы наклона (в реальных случаях извлекаются автоматически)
fingerprint_data_1 = [
    {"x": 100, "y": 200, "angle": 45},
    {"x": 120, "y": 215, "angle": 60},
    {"x": 130, "y": 210, "angle": 90},
    {"x": 115, "y": 205, "angle": 30},
]

# Для второго отпечатка (моделируем тот же отпечаток с небольшой погрешностью)
fingerprint_data_2 = [
    {"x": 101, "y": 199, "angle": 47},
    {"x": 119, "y": 216, "angle": 59},
    {"x": 132, "y": 211, "angle": 88},
    {"x": 116, "y": 206, "angle": 32},
]

Для каждого отпечатка создаем шаблон, используя его уникальные особенности (минутии). Эти шаблоны позволяют системе распознавания идентифицировать отпечаток без использования полного изображения.

#### Функция для генерации шаблона

import math

# Функция для создания шаблона отпечатка
def create_fingerprint_template(fingerprint_data):
    # Преобразуем каждую минутию в формат (x, y, angle)
    template = []
    for minutia in fingerprint_data:
        template.append((minutia["x"], minutia["y"], minutia["angle"]))
    return template

# Создаем шаблоны для двух отпечатков
template_1 = create_fingerprint_template(fingerprint_data_1)
template_2 = create_fingerprint_template(fingerprint_data_2)

Теперь создадим функцию, которая будет проверять, насколько похожи два шаблона. Функция будет учитывать допустимую погрешность для координат и углов, так как отпечаток может быть немного смещен или повернут.

#### Функция для сравнения

# Задаем допустимые отклонения для сравнения
tolerance_position = 5  # Допустимое отклонение в координатах
tolerance_angle = 5     # Допустимое отклонение в углах

# Функция сравнения двух шаблонов
def compare_fingerprint_templates(template1, template2):
    matches = 0
    for minutia1 in template1:
        for minutia2 in template2:
            # Проверяем, что координаты и угол находятся в пределах допустимых отклонений
            if (abs(minutia1[0] - minutia2[0]) <= tolerance_position and
                abs(minutia1[1] - minutia2[1]) <= tolerance_position and
                abs(minutia1[2] - minutia2[2]) <= tolerance_angle):
                matches += 1
                break  # Переходим к следующей точке
    # Возвращаем количество совпавших точек
    return matches

# Сравниваем два шаблона
matches = compare_fingerprint_templates(template_1, template_2)
total_points = min(len(template_1), len(template_2))
similarity = matches / total_points

print(f"Совпавшие точки: {matches} из {total_points}")
print(f"Сходство: {similarity:.2f}")

### Вывод
Код выше покажет количество совпавших точек и степень сходства в процентном выражении (0.0 - 1.0). Чем ближе значение к 1.0, тем больше вероятность того, что отпечатки принадлежат одному человеку.

### Объяснение работы кода
1. Допуски: Мы задали допустимые отклонения в 5 единиц по координатам и углу, чтобы допустить незначительные отличия из-за положения пальца.
2. Совпадение точек: Мы проходим по каждому элементу из первого шаблона и проверяем, есть ли совпадение в пределах допустимого отклонения в данных второго шаблона. Если найдена подходящая точка, добавляем совпадение.
3. Подсчет сходства: Общее количество совпавших точек делится на минимальное количество точек между двумя шаблонами, чтобы получить процент совпадения.

Подпишись 👉🏻 @KodduuPython 🤖