1 / 88

Algunos aspectos de la implementación de TOY

Algunos aspectos de la implementación de TOY. Arquitectura Restricciones de reales Restricciones de dominio finito Carga de bibliotecas API para restricciones Prolog ACIDE Cooperación de resolutores Trabajo futuro. Algunos aspectos de la implementación de TOY. Arquitectura

devika
Download Presentation

Algunos aspectos de la implementación de TOY

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Algunos aspectos de la implementación de TOY • Arquitectura • Restricciones de reales • Restricciones de dominio finito • Carga de bibliotecas • API para restricciones Prolog • ACIDE • Cooperación de resolutores • Trabajo futuro

  2. Algunos aspectos de la implementación de TOY • Arquitectura • Restricciones de reales • Restricciones de dominio finito • Carga de bibliotecas • API para restricciones Prolog • ACIDE • Cooperación de resolutores • Trabajo futuro

  3. 1. Arquitectura Toy FD R store H store store FD R SICStus Prolog

  4. Algunos aspectos de la implementación de TOY • Arquitectura • Restricciones de reales • Restricciones de dominio finito • Carga de bibliotecas • API para restricciones Prolog • ACIDE • Cooperación de resolutores • Trabajo futuro

  5. 2. Restricciones de reales • Programación lineal. • Programación lineal entera mixta (MIP). • Optimización. • MIP en TOY.

  6. Programación lineal Minimizar (Maximizar) Sujeto a Ejemplo Maximizar Sujeto a

  7. Programación entera/mixta Minimizar (Maximizar) Sujeto a Ejemplo Maximizar Sujeto a

  8. Programación lineal Algoritmo del Simplex (Dantzing 1947) Algoritmo de barrera (punto interior Karmarkar 1984) Programación entera/mixta Algoritmo de ramificación y acotación (branch&bound, branch&cut, …) B&B

  9. MIP en Toy minimize, maximize :: real -> real Toy(R)> 2*X+Y <= 16, X+2*Y <= 11, X+3*Y <= 15, Z==30*X+50*Y, maximize Z == Z { X -> 7.00000000000001, Y -> 1.9999999999999956, Z -> 310.00000000000006 } Elapsed time: 0 ms. sol.1, more solutions (y/n/d/a) [y]? no Elapsed time: 0 ms.

  10. MIP en Toy bb_minimize, bb_maximize :: real -> [real ]-> real Toy(R)> E==40*G+50*C,G+C<=50,3*G+4*C<=180, C<=40,C>=0,G>=0,bb_maximize E [C,G] == E      { E -> 2300,        G -> 20,        C -> 30 }      Elapsed time: 31 ms. sol.1, more solutions (y/n/d/a) [y]?      no      Elapsed time: 0 ms.

  11. Resumen de funciones minimize, maximize bb_minimize, bb_maximize

  12. Implementación CFLP(R) • Módulos

  13. Implementación – Compilación de programas • Compilación Archivos Declaraciones Toy (usuario y predefinidas) Unión de archivos Traducción a primer orden Análisis léxico, sintáctico y (parte del) semántico Módulos Outgenerated Inferencia de tipos y última etapa de compilación plgenerated

  14. Implementación – Carga de programas • Carga plgenerated :- consult(program) • toycomm.plPredicados comunes (e.g., hnf) • primFunct.pl Declaraciones de funciones predefinidas • primitivCod.pl Implementación de funciones predefinidas

  15. Implementación – Carga de la biblioteca R /cflpr /nocflpr Módulos Sicstus Archivos Prolog

  16. Implementación – Implementación de funciones $<(X,Y,H,Cin,Cout):- hnf(X,HX,Cin,Cout1), hnf(Y,HY,Cout1,Cout2), (H=true,{HX<HY};H=false,{HX>=HY}), toSolver(HX,Cout2,Cout3), toSolver(HY,Cout3,Cout4), toSolver(H,Cout4,Cout). primitivCod.pl $<(X,Y,H,Cin,Cout):- hnf(X,HX,Cin,Cout1), hnf(Y,HY,Cout1,Cout), (number(HX),number(HY) -> (HX<HY,H=true;HX>=HY,H=false); errPrim). primitivCodClpr.pl

  17. Algunos aspectos de la implementación de TOY • Arquitectura • Restricciones de reales • Restricciones de dominio finito • Carga de bibliotecas • API para restricciones Prolog • ACIDE • Cooperación de resolutores • Trabajo futuro

  18. 2. Restricciones de dominio finito • Abstracción operacional e.g. x  y + z (asignación) es x=y+z (relación), • Carácter multi-disciplinar • Resolución de problemas de naturaleza diversa (no-lineal, cooperativa, optimización, scheduling, timetabling, etc.) • Restricción = relación (ecuacional, simbólica, primitiva, etc.)

  19. Problemas OR Búsqueda + Constraints Motivaciones Marco natural: Declarative Programming DP = LP o FP Objeto Objeto Relación Objeto Constraint

  20. Estructura de un programa de restricciones (DF) Definición de los parámetros Declaración de las variables de decisión Acotación de dominios (domain) Declaración de las restricciones Especificación del proceso de búsqueda (Optimización)

  21. Problema de satisfacción de restricciones X =  X1 , X2 , … , Xn conjunto de variables que toma valores de los respectivos dominios finitos del conjunto D =  D( X1), D( X2), … , D( Xn)  Una asignación a las variables X1 , X2, … , Xn es una n-tupla de valores (d1, d2, … , dn) con di D(Xi) i = 1,...n. Una restricción R(V) con V  X, es un subconjunto del producto cartesiano de los dominios: R( X1, X2, … , Xm)  D( X1) x D( X2)x … x D( Xm). Una asignación (d1, d2, … , dm) satisface la restricción R si: R(d1 , d2, … , dm)  R( X1 , X2, … , Xm) Una restricción es satisfacible si existe al menos una asignación que la satisface

  22. Problema de satisfacción de restricciones(DOMINIOS FINITOS) • Ejemplo • Variables: X, Y, Z • Dominios: D(X) = 1, 2, 5, D(Y) = 1, 2, 3, 4, 5, D(Z) = 1, 2, 5, 7 • Restricción: R(X, Y, Z) = X < Y  Y< Z • Asignaciones: (1, 1, 1) insatisfacible • (1, 2, 5) satisfacible

  23. Problema de satisfacción de restricciones (representación) PSR Soluciones del PSR Solution [1] X = 9 Y = 1 Z = 1 T = 1 W = 8 Solution [2] X = 9 Y = 1 Z = 1 T = 2 W = 7 Solution [3] X = 9 Y = 1 Z = 1 T = 3 W = 6 Solution [4] X = 9 Y = 1 Z = 1 T = 4 W = 5 Solution [5] X = 9 Y = 1 Z = 1 T = 5 W = 4 Solution [6] X = 9 Y = 1 Z = 1 T = 6 W = 3 Solution [7] X = 9 Y = 1 Z = 1 T = 7 W = 2 D(X) = [1..9] D(Y) = [1..9] D(Z) = [1..9] D(T) = [1..9] D(W) = [1..9] X > Y + Z + 6 Y < T + Z W  Y X = W + T X < Z

  24. Arquitectura del resolutor de restricciones de dominios finitos Propagador de X > Y + Z + 6 Dominios D(X) = [1..5] D(Z) = [1..9] D(Y) = [3..7] Propagador de X <> Z Propagador de Y < T + Z D(T) = [1..5] D(W) = [2..5] Propagador de X = W + T Propagador de W <> Y

  25. Arco consistencia • Una restricción primitiva r es arco-consistente con dominio D si |vars(r)| 2 o vars(r) = {x,y} y para cada d in D(x) existe e en D(y) tal que: , y análogamente para y • Un PSR es arco consistente si todas sus restricciones primitivas son arco_consitentes

  26. Consistencia de límites • Una restricción primitiva r es límite_consistente con dominio D si para cada variable x en vars(r) existen números reales d1, ..., dk para el resto de variables x1, ..., xk tal que es una solución de r, y análogamente para • Un PSR aritmético es límite_consistente si lo son todas sus restricciones primitivas

  27. Ejemplos de consistencia de límites No es límite-consistente, ya que para Z=2 (max(D(Z)) no existe solución de X-3Y=10 en D(X) y D(Y) En cambio, sí es límite-consistente el siguiente dominio:

  28. Obtención de la consistencia de límites • Dado un dominio actual D se modifican los puntos extremos de las variables para que resulte límite_consistente • los propagadores o reglas de propagación se encargan de esta tarea

  29. Reglas de propagación (propagadores) Consideremos la restricción primitiva X = Y + Z que es equivalente a las tres formas Razonando sobre los valores mínimo y máximo obtenemos las siguientes reglas de propagación:

  30. Reglas de propagación (propagadores) Las reglas de propagación determinan que: Por lo que los dominios pueden reducirse a:

  31. Reglas de propagación (propagadores) Si el dominio inicial es: Determinamos que y el nuevo dominio será:

  32. Desigualdades Las reglas de las desigualdades proporcionan una propagación débil. Sólo hay propagación cuando un miembro toma un valor fijo e igual al mínimo o máximo del otro miembro.

  33. Multiplicación Si todas las variables son positivas, el propagador sería: Ejemplo: se convierte en:

  34. Fase de propagación de consistencia (ejecución de un propagador activo) no sí Inconsistencia ¿ ? ¿Son todos los ¿Existen sí no sí no dominios dominios no unitarios? vacíos? Retroceso FIN FIN (con solución) (sin solución) Fase de búsqueda (imposición del valor de una variable a uno de los elementos de su dominio actual ) Algoritmo general del resolutor

  35. Motivaciones C(L)P ?(Jaffar y Lassez, 87) CLP Expresividad LP + Eficiencia CP Instancias según dominio de computación CLP(FD), CLP(Sets), CLP(), CLP(Bool),.... LP - Unificación + Resolución de restricciones CLP

  36. CFP ? Ningún intento convincente en FP, sí en en el contexto multiparadigma. • (Arenas et. al, 1996)l • (López-Fraguas y Sánchez Hernández,1999) • (Lux, 2001) • (Smolka,1994) • (Antoy y Hanus, 2000) ¿ Y DOMINIOS FINITOS (FD) ?

  37. Nuestra propuesta Antonio J. Fernández, Teresa Hortalá-González, Fernando Sáenz-Perez PADL’2003, ES’2002 Antonio J. Fernández, Teresa Hortalá-González, Fernando Sáenz-Perez y Rafael del Vado Vírseda TPLP’07

  38. El Modelo Opaco (Black box!) Ventajas: Eficiencia Específico de la aplicación Semántica operacional oculta Desventajas Restricciones “hard wired” Carencia adaptabilidad Constraint Salida Entrada Restricción Opaca

  39. Variables Lógicas No determinismo Propagación restricciones C F L P sobre FD Labeling Funciones FD HO Pereza Composición restricciones Patrones Tipos Aplicacionesparciales

  40. TOY(FD) Modelado problema Evaluación perezosa Lenguaje fuente FLP TOY Almacén de restricciones Resolución restricciones Resolutor (SICStus)

  41. TOY(FD): Restricciones FD =Funciones

  42. TOY(FD)

  43. Repetitivas Resolución CFLP(FD) Resolución (tres fases) + narrowing (reducción de dominios) + propagación + técnicas de splitting (labeling) Fases: (1) selección variable (2) selección valor

  44. CFLP(FD) vs. CLP(FD) CLP(FD)  CFLP(FD) smm :: int  int  int  int  int  int  int  int [labelType]  bool smm S E N D M O R Y Label :- domain [S,E,N,D,M,O,R,Y] 0 9, S #> 0, M #> 0, all_different [S,E,N,D,M,O,R,Y], add S E N D M O R Y, labeling Label [S,E,N,D,M,O,R,Y] add :: int  int  int  int  int  int  int  int  bool add S E N D M O R Y :- 1000#*S #+ 100#*E #+ 10#*N #+ D #+ 1000#*M #+ 100#*O #+ 10#*R #+ E #= 10000#*M #+ 1000#*O #+ 100#*N #+ 10#*E #+ Y

  45. CFLP(FD) vs. CLP(FD) CFLP(FD): Capacidades adicionales • Tipos: ventajas ya conocidas • Notación funcional: domain [X] 1 (10-N) • Aplicaciones parciales, HO y polimorfismo • map (3#<) [X,Y] = [3#<X, 3#< Y] • = [true,true] map :: (A  B)  [A]  [B] map F [ ] = [] map F [X|Xs]] = [(F X) | (map F Xs)] X,Y [4,sup]

  46. CFLP(FD) vs. CLP(FD) CFLP(FD): Capacidades adicionales Pereza:Abre nuevas posibilidades a la Resolución de restricciones generateFD :: int -> [int] generateFD N = [X | generateFD N] <== domain [X] 0 (N-1) lazymagic :: int -> [int] lazymagic N = L <== take N (generateFD N) == L, constrain L L 0 Cs, sum L (#=) N, scalar_product Cs L (#=) N, labeling [ff] L Evaluación perezosa. Listas infinitas !!

  47. CFLP(FD) vs. CLP(FD) CFLP(FD): Pereza (.):: (B -> C) -> (A -> B) -> (A -> C) (F . G) X = F (G X) from :: int  [int] from N = [N|from (N+1)] lazyseries :: int  [[int]] lazyseries = map lazymagic.from take 3 (lazyseries 7) [ [3,2,1,1,0,0,0], [4,2,1,0,1,0,0,0], [5,2,1,0,0,1,0,0,0] ]

  48. CFLP(FD) vs. CLP(FD) Sumario • CLP(FD)  CFLP(FD) • + notación funcional, • + tipos, • + HO, • + Parcialización, • + Evaluación perezosa, • + composición de funciones • (restricciones) • + ????

  49. Aplicaciones

  50. Planificación data taskName = t1 | t2 | t3 | t4 | t5 | t6 data resourceName = m1 | m2 type precedencesType = [taskName] type resourcesType = [resourceName] type task = (taskName, durationType, precedencesType, resourcesType, startType) Tasks == [ (t1,3,[], [m1],S1), (t2,8,[], [m1],S2), (t3,8,[t4,t5],[m1],S3), (t4,6,[], [m2],S4), (t5,3,[t1], [m2],S5), (t6,4,[t1], [m2],S6)], schedule Tasks 1 20, labeling [] [S1,S2,S3,S4,S5,S6] SOLVE!!

More Related