?

Log in

No account? Create an account

Publicaciones anteriores | Publicaciones siguientes

Un equipo de investigadores del MIT ha desarrollado un nuevo lenguaje de programación que, según los autores, facilita el ingreso a principiantes en el mundo de la inteligencia artificial.

En un artículo presentado esta semana en la conferencia de Diseño e Implementación de Lenguajes de Programación, los investigadores describen un novedoso sistema de programación probabilística llamado "Gen” cuya aplicación abarca desde temas como la visión por computador, robótica y estadísticas, y les abstrae de lidiar con ecuaciones y tener que escribir manualmente código de alto rendimiento. Gen también permite a los investigadores expertos escribir modelos sofisticados y algoritmos de inferencia, utilizados para tareas de predicción, que antes eran inviables.
Las principales contribuciones son:

  • Gen, un sistema de programación probabilística integrado en Julia, en el que los usuarios (i) definen modelos en lenguajes de modelado embebidos y (ii) implementan programas de inferencia de alto nivel en el lenguaje host.

  • Interfaz de función generativa, una abstracción de caja negra para modelos probabilísticos que separa la lógica para el cálculo eficiente del diseño del algoritmo de inferencia.

  • Tres lenguajes de modelado interoperables: uno que es Turing completo para una máxima expresividad del modelo, uno que es susceptible al análisis estático, y otro basado en TensorFlow.

  • Tres combinadores de funciones generativas (map, unfold, recurse), que producen funciones generativas que explotan patrones comunes de independencia condicional.

  • Una evaluación empírica de la expresividad y la eficiencia de inferencia del modelado de Gen en relación con otros sistemas en cinco desafiantes problemas de inferencia.

Para instalar Gen primero debe tener instalado Julia versión 1.0 o posterior, luego escribir ] para entrar en pkg: una vez en Pkg escribr add http://github.com/probcomp/Gen

julia>

(v1.1) pkg> add http://github.com/probcomp/Gen
Updating registry at `~/.julia/registries/General`
Updating git-repo `https://github.com/JuliaRegistries/General.git`
Cloning git-repo `http://github.com/probcomp/Gen`
Updating git-repo `http://github.com/probcomp/Gen`
Resolving package versions...
Installed PDMats ──────────────── v0.9.7
Installed Missings ────────────── v0.4.1
Installed QuadGK ──────────────── v2.0.3
Installed CommonSubexpressions ── v0.2.0
Installed OrderedCollections ──── v1.1.0
Installed JSON ────────────────── v0.20.0
Installed StaticArrays ────────── v0.11.0
Installed Distributions ───────── v0.19.2
Installed Rmath ───────────────── v0.5.0
Installed ForwardDiff ─────────── v0.10.3
Installed StatsFuns ───────────── v0.8.0
Installed SpecialFunctions ────── v0.7.2
Installed FunctionalCollections ─ v0.5.0
Installed ReverseDiff ─────────── v0.3.1
Installed StatsBase ───────────── v0.31.0
Installed DataStructures ──────── v0.17.0
Installed DiffResults ─────────── v0.0.4
Installed DiffRules ───────────── v0.0.10
Installed FunctionWrappers ────── v1.0.0
Installed Arpack ──────────────── v0.3.1
Installed Compat ──────────────── v2.1.0
Installed BinaryProvider ──────── v0.5.6
Updating `~/.julia/environments/v1.1/Project.toml`
[ea4f424c] + Gen v0.3.1 #master (http://github.com/probcomp/Gen)
  Updating `~/.julia/environments/v1.1/Manifest.toml`
[7d9fca2a] + Arpack v0.3.1
[9e28174c] + BinDeps v0.8.10
  [b99e7846] + BinaryProvider v0.5.6
[bbf7d656] + CommonSubexpressions v0.2.0
.
.
.
[cf7118a7] + UUIDs
[4ec0a83e] + Unicode
Building Rmath ───────────→ `~/.julia/packages/Rmath/Py9gH/deps/build.log`
Building SpecialFunctions → `~/.julia/packages/SpecialFunctions/fvheQ/deps/build.log`
Building Arpack ──────────→ `~/.julia/packages/Arpack/cu5By/deps/build.log`

Luego en Julia se debe indicar el uso del package.

julia> using Pkg; Pkg.test("Gen")
Testing Gen
Resolving package versions...
  Status `/var/folders/p1/2sjzc3f16dz8fjcg_05_vg5m0000gn/T/tmpZyh3dJ/Manifest.toml`
  [7d9fca2a] Arpack v0.3.1
[9e28174c] BinDeps v0.8.10
.
.
.

En el sitio de Gen[1] se proporciona la documentación y tutoriales que se pueden seguir para lograr los primeros resultados en esta versión muy preliminar. persnamente probé un ejemplo de programa muy corto que hace regresión lineal bayesiana: dado un conjunto de puntos en el plano (x, y), se quiere encontrar una línea que se adapte bien a ellos.

Hay tres componentes principales para un programa Gen típico.

En primer lugar, se define un modelo generativo: una función Julia, extendida con alguna sintaxis adicional, que, conceptualmente, simula un conjunto de datos falso. El modelo debajo de los ejemplos de los parámetros de slope e intercept y, a continuación, para cada una de las coordenadas x que acepta como entrada, muestrea una coordenada y correspondiente. Se nombran las decisiones aleatorias quese toman con @trace, por lo que se puede referir a ellas en el programa de inferencia.

using Gen

@gen function my_model(xs::Vector{Float64})
  slope = @trace(normal(0, 2), :slope)
  intercept = @trace(normal(0, 10), :intercept)
    for (i, x) in enumerate(xs)
        @trace(normal(slope * x + intercept, 1), "y-$i")
    end
end


En segundo lugar, se escribe un programa de inferencia que implementa un algoritmo para manipular los seguimientos de ejecución del modelo. Los programas de inferencia son código Julia regular y hacen uso de la biblioteca de inferencia estándar de Gen.

El siguiente programa de inferencia toma un conjunto de datos y ejecuta un algoritmo MCMC iterativo para ajustar los parámetros de pendiente e interceptación:

function my_inference_program(xs::Vector{Float64}, ys::Vector{Float64}, num_iters::Int)
    # Create a set of constraints fixing the
    # y coordinates to the observed y values
  constraints = choicemap()
    for (i, y) in enumerate(ys)
      constraints["y-$i"] = y
    end
 
    # Run the model, constrained by `constraints`,
    # to get an initial execution trace
  (trace, _) = generate(my_model, (xs,), constraints)
 
    # Iteratively update the slope then the intercept,
    # using Gen's metropolis_hastings operator.
    for iter=1:num_iters
      (trace, _) = metropolis_hastings(trace, select(:slope))
      (trace, _) = metropolis_hastings(trace, select(:intercept))
    end
 
    # From the final trace, read out the slope and
    # the intercept.
  choices = get_choices(trace)
    return (choices[:slope], choices[:intercept])
end

Finalmente se ejecuta el programa y se obtiene los resultado:
xs = [1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]
ys = [8.23, 5.87, 3.99, 2.59, 0.23, -0.66, -3.53, -6.91, -7.24, -9.90]
(slope, intercept) = my_inference_program(xs, ys, 1000)
println("slope: $slope, intercept: $intercept")

La ejecución en REPL sería algo como lo siguiente:

julia> using Gen


julia> @gen function my_model(xs::Vector{Float64})
         slope = @trace(normal(0, 2), :slope)
         intercept = @trace(normal(0, 10), :intercept)
         for (i, x) in enumerate(xs)
               @trace(normal(slope * x + intercept, 1), "y-$i")
           end
     end
DynamicDSLFunction{Any}(Dict{Symbol,Any}(), Dict{Symbol,Any}(), Type[Array{Float64,1}], ##my_model#364, Bool[false], false)

julia> function my_inference_program(xs::Vector{Float64}, ys::Vector{Float64}, num_iters::Int)
         # Create a set of constraints fixing the
         # y coordinates to the observed y values
         constraints = choicemap()
         for (i, y) in enumerate(ys)
             constraints["y-$i"] = y
         end
        
         # Run the model, constrained by `constraints`,
         # to get an initial execution trace
         (trace, _) = generate(my_model, (xs,), constraints)
        
         # Iteratively update the slope then the intercept,
         # using Gen's metropolis_hastings operator.
         for iter=1:num_iters
             (trace, _) = metropolis_hastings(trace, select(:slope))
             (trace, _) = metropolis_hastings(trace, select(:intercept))
         end
        
         # From the final trace, read out the slope and
         # the intercept.
         choices = get_choices(trace)
         return (choices[:slope], choices[:intercept])
     end
my_inference_program (generic function with 1 method)

julia> xs = [1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]
10-element Array{Float64,1}:
  1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0

julia> ys = [8.23, 5.87, 3.99, 2.59, 0.23, -0.66, -3.53, -6.91, -7.24, -9.90]
10-element Array{Float64,1}:
8.23
5.87
  3.99
2.59
0.23
-0.66
-3.53
-6.91
-7.24
-9.9

julia> (slope, intercept) = my_inference_program(xs, ys, 1000)
(-2.059831593709758, 10.979679334853522)

julia> println("slope: $slope, intercept: $intercept")
slope: -2.059831593709758, intercept: 10.979679334853522

Habrá que ver si los investigadores Marco F. Cusumano-Towner, Feras Saad, Alex Lew, Vikash Mansinghka, presentan alguna demo en el próximo JuliaCon [2] que estará muy bueno, espero haya streaming, el paper ACM original lo pueden descargar aquí[3].

[1] https://probcomp.github.io/Gen/
[2] https://pretalx.com/juliacon2019/talk/GVYCEL/
[3] https://dl.acm.org/citation.cfm?id=3314221.3314642

Perfil

deoxyt2
Juan Rodrigo Anabalón R.
Website

Acerca de mi

He estado escribiendo sobre temas de seguridad en Livejournal desde el 2008 y en mi horrible y extinto MSN Spaces desde el 2006. En la actualidad, soy CISO en MonkeysLab y Presidente en ISSA Chile.




MonkeysLab




Copyleft

Copyleft: Atribuir con enlace.







Flickr


ISSA Chile



contador de visitas


contadores gratis

Último mes

September 2019
S M T W T F S
1234567
891011121314
15161718192021
22232425262728
2930     

Tags

Powered by LiveJournal.com
Designed by Lilia Ahner