Autor : Wang Liqi, embajador de innovación en Intel Edge Computing
1. PINN: una red neuronal que agrega restricciones físicas
La red neuronal informada por la física (PINN) basada en información física es un tipo de red neuronal que se utiliza para resolver tareas de aprendizaje supervisadas. No solo puede aprender las reglas de distribución de muestras de datos de entrenamiento como las redes neuronales tradicionales, sino también aprender las leyes de la física descritas. mediante ecuaciones matemáticas. En comparación con el aprendizaje de redes neuronales basado exclusivamente en datos, PINN impone restricciones de información física durante el proceso de entrenamiento, por lo que puede aprender un modelo con mayores capacidades de generalización utilizando menos muestras de datos. Este artículo analiza principalmente esta red neuronal y aplicaciones relacionadas.
1. Introducción al artículo
Redes neuronales basadas en física: un marco de aprendizaje profundo para resolver problemas directos e inversos que involucran ecuaciones diferenciales parciales no lineales.
https://www.sciencedirect.com/science/article/pii/S0021999118307125
En 2019, un equipo de investigación de Matemáticas Aplicadas de la Universidad de Brown propuso una “Red neuronal inspirada físicamente” (PINN) que utiliza ecuaciones físicas como restricciones operativas y la publicó en el Journal of Computational Physics, una revista autorizada en el campo de la física computacional. Física Computacional). Este artículo recibió mucha atención una vez que fue publicado. Debido a la integridad del sistema de código, este documento facilita a los desarrolladores la aplicación de marcos de aprendizaje relacionados en diferentes campos. Poco después de la publicación, otros investigadores desarrollaron una serie de PINN diferentes. Ni siquiera es exagerado decir que PINN es uno de los marcos y vocabulario más comunes en los artículos actuales en el campo de la física de la IA.
2.Descripción del algoritmo
La llamada red neuronal física en realidad agrega ecuaciones físicas como restricciones a la red neuronal para que los resultados del entrenamiento satisfagan las leyes de la física. ¿Y cómo se logra esta llamada restricción? De hecho, al agregar la diferencia entre las iteraciones de las ecuaciones físicas a la función de pérdida de la red neuronal , las ecuaciones físicas también "participan" en el proceso de entrenamiento. De esta manera, la red neuronal optimiza no solo la propia función de pérdida de la red durante las iteraciones de entrenamiento, sino también la diferencia en cada iteración de las ecuaciones físicas, de modo que los resultados finales del entrenamiento satisfagan las leyes de la física.
2. ProfundoXDE
DeepXDE fue desarrollado por Lu Lu desde el verano de 2018 hasta el verano de 2020 bajo la dirección del profesor George Karniadakis en la Universidad de Brown y cuenta con el apoyo de PhILM. DeepXDE originalmente estaba alojado en Subversion en la Universidad de Brown con el nombre de SciCoNet (Scientific Computing Neural Networks). El 7 de febrero de 2019, SciCoNet migró de Subversion a GitHub y cambió su nombre a DeepXDE.
1.Características de DeepXDE
DeepXDE ha implementado muchos de los algoritmos mostrados anteriormente y admite muchas funciones:
- Geometrías de dominio complejas sin generación de malla arbitraria. Las formas geométricas primitivas son intervalos, triángulos, rectángulos, polígonos, discos, cuboides y esferas. Se pueden construir otras geometrías como Geometría Sólida Construida (CSG) utilizando tres operaciones booleanas: unión, diferencia e intersección.
- Multifísica, es decir, ecuaciones diferenciales parciales acopladas (dependientes del tiempo).
- 5 tipos de condiciones de contorno (BC): Dirichlet, Neumann, Robin, BC periódica y general, se pueden definir sobre cualquier dominio o conjunto de puntos.
- Diferentes redes neuronales, como redes neuronales completamente conectadas (apiladas/no apiladas), redes neuronales residuales y redes de características de Fourier multiescala (espaciotemporales).
- 6 métodos de muestreo: muestreo uniforme, muestreo pseudoaleatorio, muestreo de hipercubo latino, secuencia de Halton, secuencia de Hammersley, secuencia de Sobol.
- Los puntos de entrenamiento se pueden mantener constantes durante el entrenamiento o volver a muestrearlos cada ciertas iteraciones.
- Guarde cómodamente el modelo durante el entrenamiento y cargue el modelo entrenado.
- Cuantificación de la incertidumbre mediante abandono.
- Muchas pérdidas (ponderadas) diferentes, optimizadores, programas de tasa de aprendizaje, métricas, etc., devoluciones de llamadas para monitorear el estado interno del modelo y estadísticas durante el entrenamiento, como la parada anticipada.
- Hace que el código de usuario sea compacto, muy parecido a las fórmulas matemáticas.
- Todos los componentes de DeepXDE están débilmente acoplados, lo que hace que DeepXDE esté bien estructurado y sea altamente configurable.
- DeepXDE se puede personalizar fácilmente para satisfacer nuevas necesidades.
2. Ejemplos numéricos
(1), solución de problemas
Resolveremos la ecuación de Schrödinger no lineal dada por:
Las condiciones de contorno periódicas son:
Las condiciones iniciales son:
Deepxde solo usa números reales, por lo que necesitamos dividir explícitamente las partes real e imaginaria del PDE complejo.
En lugar de un único residual:
Obtenemos dos residuos (de valor real):
donde u (x, t) y v (x, t) representan la parte real y la parte imaginaria de h respectivamente.
import numpy as np
import deepxde as dde
# 用于绘图
import matplotlib.pyplot as plt
from scipy.interpolate import griddata
x_lower = -5
x_upper = 5
t_lower = 0
t_upper = np.pi / 2
# 创建 2D 域（用于绘图和输入）
x = np.linspace(x_lower, x_upper, 256)
t = np.linspace(t_lower, t_upper, 201)
X, T = np.meshgrid(x, t)
# 整个域变平
X_star = np.hstack((X.flatten()[:, None], T.flatten()[:, None]))
# 空间和时间域/几何（对于 deepxde 模型）
space_domain = dde.geometry.Interval(x_lower, x_upper)
time_domain = dde.geometry.TimeDomain(t_lower, t_upper)
geomtime = dde.geometry.GeometryXTime(space_domain, time_domain)
# 损失的“物理信息”部分
def pde(x, y):
"""
INPUTS:
x: x[:,0] 是 x 坐标
x[:,1] 是 t 坐标
y: 网络输出，在这种情况下:
y[:,0] 是 u(x,t) 实部
y[:,1] 是 v(x,t) 虚部
OUTPUT:
标准形式的 pde，即必须为零的东西
"""
u = y[:, 0:1]
v = y[:, 1:2]
# 在'jacobian'中，i 是输出分量，j 是输入分量
u_t = dde.grad.jacobian(y, x, i=0, j=1)
v_t = dde.grad.jacobian(y, x, i=1, j=1)
u_x = dde.grad.jacobian(y, x, i=0, j=0)
v_x = dde.grad.jacobian(y, x, i=1, j=0)
# 在“hessian”中，i 和 j 都是输入分量。 （Hessian 原则上可以是 d^2y/dxdt、d^2y/d^2x 等）
# 输出组件由“组件”选择
u_xx = dde.grad.hessian(y, x, component=0, i=0, j=0)
v_xx = dde.grad.hessian(y, x, component=1, i=0, j=0)
f_u = u_t + 0.5 * v_xx + (u ** 2 + v ** 2) * v
f_v = v_t - 0.5 * u_xx - (u ** 2 + v ** 2) * u
return [f_u, f_v]
# 边界条件和初始条件
# 周期性边界条件
bc_u_0 = dde.PeriodicBC(
geomtime, 0, lambda _, on_boundary: on_boundary, derivative_order=0, component=0
)
bc_u_1 = dde.PeriodicBC(
geomtime, 0, lambda _, on_boundary: on_boundary, derivative_order=1, component=0
)
bc_v_0 = dde.PeriodicBC(
geomtime, 0, lambda _, on_boundary: on_boundary, derivative_order=0, component=1
)
bc_v_1 = dde.PeriodicBC(
geomtime, 0, lambda _, on_boundary: on_boundary, derivative_order=1, component=1
)
# 初始条件
def init_cond_u(x):
"2 sech(x)"
return 2 / np.cosh(x[:, 0:1])
def init_cond_v(x):
return 0
ic_u = dde.IC(geomtime, init_cond_u, lambda _, on_initial: on_initial, component=0)
ic_v = dde.IC(geomtime, init_cond_v, lambda _, on_initial: on_initial, component=1)
data = dde.data.TimePDE(
geomtime,
pde,
[bc_u_0, bc_u_1, bc_v_0, bc_v_1, ic_u, ic_v],
num_domain=10000,
num_boundary=20,
num_initial=200,
train_distribution="pseudo",
)
# 网络架构
net = dde.maps.FNN([2] + [100] * 4 + [2], "tanh", "Glorot normal")
model = dde.Model(data, net)optimización de adán
# 强烈建议使用 GPU 加速系统.
model.compile("adam", lr=1e-3, loss="MSE")
model.train(epochs=1000, display_every=100)
Optimización L-BFGS
dde.optimizers.config.set_LBFGS_options(
maxcor=50,
ftol=1.0 * np.finfo(float).eps,
gtol=1e-08,
maxiter=1000,
maxfun=1000,
maxls=50,
)
model.compile("L-BFGS")
model.train()
Compiling model...
'compile' took 0.554160 s
Training model...
Step Train loss Test loss Test metric
1000 [1.25e-02, 1.32e-02, 2.72e-06, 3.28e-04, 5.27e-06, 4.65e-06, 2.24e-02, 1.31e-03] [1.25e-02, 1.32e-02, 2.72e-06, 3.28e-04, 5.27e-06, 4.65e-06, 2.24e-02, 1.31e-03] []
2000 [7.03e-04, 7.62e-04, 6.76e-06, 1.33e-05, 2.88e-07, 8.49e-06, 4.01e-04, 3.86e-05]
INFO:tensorflow:Optimization terminated with:
Message: STOP: TOTAL NO. of f AND g EVALUATIONS EXCEEDS LIMIT
Objective function value: 0.001928
Number of iterations: 945
Number of functions evaluations: 1001
2001 [7.18e-04, 7.43e-04, 6.27e-06, 1.23e-05, 2.94e-07, 8.89e-06, 4.01e-04, 3.82e-05] [7.18e-04, 7.43e-04, 6.27e-06, 1.23e-05, 2.94e-07, 8.89e-06, 4.01e-04, 3.82e-05] []
Best model at step 2001:
train loss: 1.93e-03
test loss: 1.93e-03
test metric: []
'train' took 179.449384 s
(<deepxde.model.LossHistory at 0x13422ad90>,
<deepxde.model.TrainState at 0x10d759850>)
# 做预测
prediction = model.predict(X_star, operator=None)
u = griddata(X_star, prediction[:, 0], (X, T), method="cubic")
v = griddata(X_star, prediction[:, 1], (X, T), method="cubic")
h = np.sqrt(u ** 2 + v ** 2)
# 绘制预测
fig, ax = plt.subplots(3)
ax[0].set_title("Results")
ax[0].set_ylabel("Real part")
ax[0].imshow(
u.T,
interpolation="nearest",
cmap="viridis",
extent=[t_lower, t_upper, x_lower, x_upper],
origin="lower",
aspect="auto",
)
ax[1].set_ylabel("Imaginary part")
ax[1].imshow(
v.T,
interpolation="nearest",
cmap="viridis",
extent=[t_lower, t_upper, x_lower, x_upper],
origin="lower",
aspect="auto",
)
ax[2].set_ylabel("Amplitude")
ax[2].imshow(
h.T,
interpolation="nearest",
cmap="viridis",
extent=[t_lower, t_upper, x_lower, x_upper],
origin="lower",
aspect="auto",
)
plt.show()
3. Generar modelo OpenVINO IR
Si desea utilizar LabVIEW OpenVINO para inferir el modelo deepxde, debe realizar los siguientes pasos:
1. Convierta el modelo deepxde al modelo onnx como middleware:
En el código, primero debemos crear un X2 con la misma forma que X_star como entrada de referencia (X2 debe ser una matriz en la CPU) y, en segundo lugar, crear un nuevo modo2 basado en CPU, cuyo peso sea exactamente el mismo que el modelo. Finalmente, use torch.onnx.export para generar el modelo onnx.
2. Utilice la línea de comando para convertir el modelo onnx en un modelo IR:
mes --input_model Schrodinger.onnx --input_shape "[256,2]"
En el comando, configuramos la forma de entrada en 256*2, donde la 0.ª columna es la posición x y la 1.ª columna es el tiempo t. 256 es el número de x puntos que necesitamos inferir en cada punto de tiempo, que puede tener cualquier longitud.
Después de completar los dos pasos anteriores, podemos ver que hay tres archivos más en la carpeta: Schrodinger.onnx, Schrodinger.xml y Schrodinger.bin. Entre ellos, onnx es el modelo onnx generado por pytorch, y xml y bin son el modelo OpenVINO IR generado por mo.
4. LabVIEW llama al modelo IR
LabVIEW es un entorno de programación gráfica lanzado por NI, que se utiliza ampliamente en los campos de investigación científica y medición y control industrial. Usando el gráfico de forma de onda, el gráfico de intensidad y otros controles de LabVIEW, los usuarios pueden observar los resultados del entrenamiento de sus propios modelos de manera más intuitiva.
Usando Schrodinger_OpenVINO.vi que escribimos, puedes razonar rápidamente sobre el modelo OpenVINO de la ecuación de Schrodinger. Los siguientes son los pasos para llamar a un modelo usando LabVIEW:
1. Inicialice el modelo: use LoadIR.vi para llamar a archivos xml y bin. El motor de inferencia puede usar CPU o GPU (gráficos centrales Intel o gráficos independientes);
2. Inicialice la ubicación. De acuerdo con los parámetros que usamos para el entrenamiento, necesitamos simular cualquier número de puntos de posición en el rango de -5 ~ 5 (en este caso se usan 256 puntos de posición).
3. Tiempo de inicialización, de acuerdo con los parámetros de nuestro entrenamiento, es necesario simular cualquier número de puntos de tiempo en el rango de 0~pi/2 (en este caso se utilizan 201 puntos de tiempo.
4. Al razonar sobre el modelo. En cada ciclo, se copian 256 copias de un determinado punto de tiempo y los 256 puntos de posición se forman en una matriz bidimensional de 2 * 256, y luego se transponen a una matriz de 256 * 2 y se ingresan en la red.
5. Obtenga el resultado. La salida es 256*2, pero su significado es diferente al de la entrada: la 0.ª columna es la parte real de la función de onda h y la 1.ª columna es la parte imaginaria de h. Por lo tanto, es necesario transponer el resultado a 2*256 antes de que se puedan mostrar las dos curvas utilizando el gráfico de forma de onda.
6. Obtenga resultados para todo el período de tiempo y todas las ubicaciones. Usando un índice de bucle For, los resultados de la parte real, la parte imaginaria y la magnitud de todos los períodos de tiempo se guardan y se muestran en el gráfico de intensidad.
7. Utilice release.vi para cerrar el modelo OpenVINO.
Ejecuta el programa. Ejecutamos el modelo utilizando una tarjeta gráfica discreta Intel A770 (nombre del dispositivo GPU.1). Los resultados de ejecución son los siguientes:
El gráfico de forma de onda de la izquierda es la curva de la parte real y la parte imaginaria de la función de onda en cada punto de tiempo, y el gráfico de intensidad de la derecha es la parte real, la parte imaginaria y la distribución de amplitud de todos los puntos de tiempo. Los resultados muestran que el uso de OpenVINO para inferir el modelo de red neuronal de información física es completamente consistente con los resultados de deepxde. Además, los modelos A770 también reciben la máxima aceleración y ahorran muchos recursos de CPU.
5. Presentación de la empresa
Shanghai Yiku Intelligent Technology Co., Ltd. es un proveedor nacional líder de software de inteligencia artificial y desarrollador de aplicaciones de robots. Ha desarrollado una plataforma de personalización de inteligencia artificial reconfigurable de código bajo, que incluye hardware industrial rentable y de alto rendimiento basado en computación de punta. y multiplataforma El software de visión de aprendizaje profundo gráfico de la plataforma satisface las necesidades personalizadas de la fabricación inteligente, la atención médica inteligente, la educación inteligente y otros campos; al mismo tiempo, ha creado una plataforma de software y hardware de educación de inteligencia artificial (paquete de interacción de voz, sin controlador suite) para la mayoría de los usuarios universitarios. , kits de brazos robóticos y plataformas de experimentos en la nube que admiten todo el hardware); la compañía es un socio estratégico de Baidu, Softbank Robotics, NI e Intel. Es una empresa de iFlytek Venture Capital ecosistema de HKUST y ha sido un socio destacado de la Universidad Jiao Tong de Shanghai durante muchos años. Shanghai es una empresa de alta tecnología en la ciudad, un talento líder en Suzhou y se ha establecido en el Centro de Empoderamiento de la Industria de Inteligencia Artificial de Baidu Flying Paddle. Tiene más de 70 patentes y derechos de autor, tiene su sede en Shanghai y sucursales en Suzhou y Anqing.
Puede descargar el kit de herramientas de software Yiku desde el sitio web oficial de la empresa: Yiku Intelligent