Google JAX

# importaciones
de  jax  import  grad
importar  jax.numpy  como  jnp

# definir la función logística
def  logística ( x ):  
    devuelve  jnp . exp ( x )  /  ( jnp . exp ( x )  +  1 )

# obtener la función gradiente de la función logística
grad_logistic  =  grad ( logístico )

# evaluar el gradiente de la función logística en x = 1
salida_grad_log  =  logística_grad ( 1.0 )   
imprimir ( grad_log_out )

# importaciones
Desde  jax  importar  jit
importar  jax.numpy  como  jnp

# define la función cubo
def  cubo ( x ):
    devolver  x  *  x  *  x

# generar datos
x  =  jnp . unos (( 10000 ,  10000 ))

# crea la versión jit de la función cubo
jit_cube  =  jit ( cubo )

# aplicar las funciones cube y jit_cube a los mismos datos para comparar la velocidad
cubo ( x )
cubo jit ( x )

# importaciones
desde  jax  import  vmap  parcial
importar  jax.numpy  como  jnp

# definir función
def  grads ( self ,  entradas ):
    in_grad_partial  =  jax . partial ( self . _net_grads ,  self . _net_params )
    grad_vmap  =  jax . vmap ( in_grad_partial )
    rich_grads  =  grad_vmap ( entradas )
    flat_grads  =  np . asarray ( self . _flatten_batch ( rich_grads ))
    afirmar  flat_grads . ndim  ==  2  y  flat_grads . shape [ 0 ]  ==  entradas . shape [ 0 ]
    Devuelve  flat_grads

# importar pmap y random desde JAX; importar JAX NumPy
desde  jax  import  pmap ,  aleatorio
importar  jax.numpy  como  jnp

# generar 2 matrices aleatorias de dimensiones 5000 x 6000, una por dispositivo
claves_aleatorias  =  random.split ( random.PRNGKey ( 0 ) , 2 )​​​ 
matrices  =  pmap ( clave lambda  : aleatorio.normal ( clave , ( 5000,6000 ) ) ) ( claves_aleatorias )​   

# sin transferencia de datos, en paralelo, realice una multiplicación de matriz local en cada CPU/GPU
salidas  =  pmap ( lambda  x :  jnp . dot ( x ,  x . T )) ( matrices )

# sin transferencia de datos, en paralelo, obtenga la media de ambas matrices en cada CPU/GPU por separado
media  =  pmap ( jnp.media ) ( salidas )​
imprimir ( significa )