Разработка AI-системы генеративного проектирования изделий Generative Design

AI-генеративный дизайн продуктов

Генеративный дизайн применяет AI для создания оптимальных форм изделий с заданными физическими ограничениями: максимальная прочность при минимальном весе, аэродинамика, теплоотвод. Используется в авиации, автопроме, медицинских имплантах, архитектуре.

Топологическая оптимизация с SIMP

import numpy as np
from scipy.sparse import lil_matrix
from scipy.sparse.linalg import spsolve

class TopologyOptimizer:
    """
    SIMP (Solid Isotropic Material with Penalization) метод.
    Классический алгоритм генеративного дизайна.
    """

    def __init__(
        self,
        nelx: int = 60,           # элементов по X
        nely: int = 30,           # элементов по Y
        volfrac: float = 0.5,     # целевая доля материала (50%)
        penal: float = 3.0,       # степень штрафа
        rmin: float = 1.5         # радиус фильтра
    ):
        self.nelx = nelx
        self.nely = nely
        self.volfrac = volfrac
        self.penal = penal
        self.rmin = rmin

    def optimize(
        self,
        load_case: dict,           # {node: (fx, fy), ...}
        boundary_conditions: dict, # {node: (ux, uy), ...} — 0=фиксировано
        max_iterations: int = 100
    ) -> np.ndarray:
        """Возвращает матрицу плотностей (0=пусто, 1=материал)"""
        # Инициализация
        x = np.full((self.nely, self.nelx), self.volfrac)
        xold = x.copy()

        for iteration in range(max_iterations):
            # Конечно-элементный анализ
            U = self._finite_element_analysis(x, load_case, boundary_conditions)

            # Вычисление чувствительностей
            dc = self._sensitivity_analysis(x, U)

            # Фильтрация чувствительностей
            dc = self._filter_sensitivity(x, dc)

            # Обновление через OC (Optimality Criteria)
            x = self._oc_update(x, dc)

            # Конвергенция
            change = np.max(np.abs(x - xold))
            xold = x.copy()

            print(f"Iter {iteration+1:3d}, Volume: {x.mean():.4f}, Change: {change:.4f}")

            if change < 0.01:
                print(f"Converged at iteration {iteration+1}")
                break

        return x

    def _oc_update(self, x: np.ndarray, dc: np.ndarray) -> np.ndarray:
        """Optimality Criteria update"""
        l1, l2 = 0, 1e9
        move = 0.2

        while (l2 - l1) / (l1 + l2) > 1e-3:
            lmid = 0.5 * (l1 + l2)
            xnew = np.maximum(
                1e-3,
                np.maximum(
                    x - move,
                    np.minimum(
                        1.0,
                        np.minimum(x + move, x * np.sqrt(-dc / lmid))
                    )
                )
            )
            if xnew.mean() - self.volfrac > 0:
                l1 = lmid
            else:
                l2 = lmid

        return xnew

Нейросетевой генеративный дизайн

import torch
import torch.nn as nn

class DesignGeneratorVAE(nn.Module):
    """
    Variational Autoencoder для генерации новых дизайнов
    по заданным физическим требованиям.
    """

    def __init__(self, latent_dim: int = 64, design_resolution: int = 64):
        super().__init__()
        self.latent_dim = latent_dim
        res = design_resolution

        # Энкодер: дизайн → латентный вектор
        self.encoder = nn.Sequential(
            nn.Conv2d(1, 32, 4, stride=2, padding=1),   # res/2
            nn.ReLU(),
            nn.Conv2d(32, 64, 4, stride=2, padding=1),  # res/4
            nn.ReLU(),
            nn.Conv2d(64, 128, 4, stride=2, padding=1), # res/8
            nn.ReLU(),
            nn.Flatten()
        )

        encoder_out_size = 128 * (res // 8) ** 2
        self.fc_mu = nn.Linear(encoder_out_size, latent_dim)
        self.fc_logvar = nn.Linear(encoder_out_size, latent_dim)

        # Условный вектор: физические ограничения
        self.condition_proj = nn.Linear(16, latent_dim)

        # Декодер: латентный вектор + условие → дизайн
        self.decoder_input = nn.Linear(latent_dim * 2, 128 * (res // 8) ** 2)
        self.decoder = nn.Sequential(
            nn.ConvTranspose2d(128, 64, 4, stride=2, padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(64, 32, 4, stride=2, padding=1),
            nn.ReLU(),
            nn.ConvTranspose2d(32, 1, 4, stride=2, padding=1),
            nn.Sigmoid()
        )
        self.res = res

    def generate(self, conditions: torch.Tensor, n_samples: int = 1) -> torch.Tensor:
        """
        conditions: тензор физических ограничений (нагрузки, граничные условия)
        Возвращает матрицу плотностей 64×64 для каждого образца
        """
        with torch.no_grad():
            z = torch.randn(n_samples, self.latent_dim)
            c = self.condition_proj(conditions.expand(n_samples, -1))
            zc = torch.cat([z, c], dim=1)

            h = self.decoder_input(zc)
            h = h.view(n_samples, 128, self.res // 8, self.res // 8)
            return self.decoder(h)

Интеграция с CAD (через Python-OCC)

from OCC.Core.BRepBuilderAPI import BRepBuilderAPI_MakeSolid
from OCC.Core.TopoDS import TopoDS_Shape
import trimesh
import numpy as np

def density_to_mesh(density_matrix: np.ndarray, threshold: float = 0.5) -> trimesh.Trimesh:
    """Конвертируем матрицу плотностей в 3D mesh через marching cubes"""
    from skimage.measure import marching_cubes

    # 2D → 3D экструзия для демонстрации
    density_3d = np.stack([density_matrix] * 10, axis=-1)

    verts, faces, normals, _ = marching_cubes(
        density_3d,
        level=threshold,
        spacing=(1.0, 1.0, 1.0)
    )

    mesh = trimesh.Trimesh(vertices=verts, faces=faces, vertex_normals=normals)
    mesh = trimesh.smoothing.filter_laplacian(mesh, iterations=10)
    return mesh

def export_to_stl(mesh: trimesh.Trimesh, output_path: str) -> None:
    mesh.export(output_path)

Применения

Сроки: SIMP топологическая оптимизация для 2D задач — 1–2 недели. VAE-генератор с обучением на датасете оптимизированных форм — 4–6 недель.