topics related to the expression problem
play

Topics related to the Expression Problem including but not limited - PowerPoint PPT Presentation

Mar 27, 2024 •36 likes •1.53k views

Topics related to the Expression Problem including but not limited to Compositional and Linear Encoding (of Synthesized and Inherited Attributes as Object Algebras in Scala) Tillmann Rendel University of Tbingen, Germany Invited Talk by

  1. trait Alg[ T ] { Final Embedding def Lit( n : Int): T def Add( l : T , r : T ): T } trait Exp { def fold[T](alg: Alg[T]): T } def Lit( n : Int) = new Exp { def fold[ T ]( alg : Alg[ T ]) = alg .lit( n ) } def Add( l : Exp, r : Exp) = new Exp { def fold[ T ]( alg : Alg[ T ]) = alg .Add( l .fold( alg ), r .fold( alg )) } 11/42

  2. To study the relationship of embedding approaches, we should study defunctionalization and refunctionalization 12/42

  3. To study the relationship of embedding approaches, we should study defunctionalization and refunctionalization (for Scala-ish languages?!) 12/42

  4. Modular, Scalable, and Compositional Encoding (of Attribute Grammars in Scala) Rendel, Brachthäuser, Ostermann 2014 (From Object Algebras to ...) 13/42

  5. Two Dimensions of Modularity constructors consumer 14/42

  6. Third Dimension of Modularity To scale to large programs, solutions to the expression problem need to support components with inner structure: ● Consumers that depend on other consumers. ● Consumers that depend on context information. ● Consumers that are fused together. 15/42

  7. Bottom-Up Data Flow 16/42

  8. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  9. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  10. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  11. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  12. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  13. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  14. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  15. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  16. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  17. Synthesized Attributes Grammar Equations e 0 → n { Lit } e 0. value = n e 1 → e 2 "+" e 3 { Add } e 1 .value = e 2 .value + e 3 .value Signature Algebra trait Sig[ E ] { val Alg = new Sig[Int] { ⇒ E def Lit = n ⇒ def Lit: Int n def Add: ( E , E ) ⇒ def Add = ( e 2 , e 3 ) ⇒ E e 2 + e 3 } } 17/42

  18. Top-Down Data Flow 18/42

  19. Inherited Attributes Grammar Equations e 0 → n { Lit } e 2 . left = true e 1 → e 2 "+" e 3 { Add } e 3 .left = false Signature Algebra trait Sig[ E ] { val Alg = new Sig[Bool] { ⇒ E def Add 1 = e ⇒ def Add 1 : E true def Add 2 : ( E , E ) ⇒ def Add 2 = ( e 1 , e 2 ) ⇒ E false } } 19/42

  20. Inherited Attributes Grammar Equations e 0 → n { Lit } e 2 . left = true e 1 → e 2 "+" e 3 { Add } e 3 .left = false Signature Algebra trait Sig[ E ] { val Alg = new Sig[Bool] { ⇒ E def Add 1 = e ⇒ def Add 1 : E true def Add 2 : ( E , E ) ⇒ def Add 2 = ( e 1 , e 2 ) ⇒ E false } } 19/42

  21. Inherited Attributes Grammar Equations e 0 → n { Lit } e 2 . left = true e 1 → e 2 "+" e 3 { Add } e 3 .left = false Signature Algebra trait Sig[ E ] { val Alg = new Sig[Bool] { ⇒ E def Add 1 = e ⇒ def Add 1 : E true def Add 2 : ( E , E ) ⇒ def Add 2 = ( e 1 , e 2 ) ⇒ E false } } 19/42

  22. Inherited Attributes Grammar Equations e 0 → n { Lit } e 2 . left = true e 1 → e 2 "+" e 3 { Add } e 3 .left = false Signature Algebra trait Sig[ E ] { val Alg = new Sig[Bool] { ⇒ E def Add 1 = e ⇒ def Add 1 : E true def Add 2 : ( E , E ) ⇒ def Add 2 = ( e 1 , e 2 ) ⇒ E false } } 19/42

  23. Inherited Attributes Grammar Equations e 0 → n { Lit } e 2 . left = true e 1 → e 2 "+" e 3 { Add } e 3 .left = false Signature Algebra trait Sig[ E ] { val Alg = new Sig[Bool] { ⇒ E def Add 1 = e ⇒ def Add 1 : E true def Add 2 : ( E , E ) ⇒ def Add 2 = ( e 1 , e 2 ) ⇒ E false } } 19/42

  24. Inherited Attributes Grammar Equations e 0 → n { Lit } e 2 . left = true e 1 → e 2 "+" e 3 { Add } e 3 .left = false Signature Algebra trait Sig[ E ] { val Alg = new Sig[Bool] { ⇒ E def Add 1 = e ⇒ def Add 1 : E true def Add 2 : ( E , E ) ⇒ def Add 2 = ( e 1 , e 2 ) ⇒ E false } } 19/42

  25. Composition 20/42

  26. Composition compose 20/42

  27. Composition compose 20/42

  28. Composition assemble 20/42

  29. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  30. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  31. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  32. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  33. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  34. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  35. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  36. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  37. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[Mix[A, B]] = { ... 21/42

  38. compose( , ) = Extensible Records trait HasValue { def value: Int } trait HasLeft { def left: Bool } def mix[ A , B ]( implicit m: Mix[A, B]): ( A , B ) ⇒ A with B Implicit Macros implicit def mixAll[A, B]: Mix[A, B] = macro impl[A, B] def impl[A, B](c: Context)(implicit aT: c.WeakTypeTag[A], bT: c.WeakTypeTag[B]): c.Expr[ Mix [A, B]] = { ... 21/42

  39. compose( , ) = Dependency Tracking trait Sig[- E , - C , + O ] { ⇒ C ⇒ def Lit: Int O def Add: ( E , E ) ⇒ C ⇒ O } 22/42

  40. compose( , ) = Dependency Tracking trait Sig[- E , - C , + O ] { ⇒ C ⇒ def Lit: Int O def Add: ( E , E ) ⇒ C ⇒ O } 22/42

  41. compose( , ) = Dependency Tracking trait Sig[- E , - C , + O ] { current node ⇒ C ⇒ def Lit: Int O def Add: ( E , E ) ⇒ C ⇒ O } 22/42

  42. compose( , ) = Dependency Tracking trait Sig[- E , - C , + O ] { current node ⇒ C ⇒ def Lit: Int O def Add: ( E , E ) ⇒ C ⇒ O } children 22/42

  43. compose( , ) = Dependency Tracking context from parent trait Sig[- E , - C , + O ] { current node ⇒ C ⇒ def Lit: Int O def Add: ( E , E ) ⇒ C ⇒ O } 22/42

  44. compose( , ) = Dependency Tracking trait Sig[- E , - C , + O ] { current node ⇒ C ⇒ def Lit: Int O def Add: ( E , E ) ⇒ C ⇒ O } 22/42

  45. compose( , ) = Dependency Tracking trait Sig[- E , - C , + O ] { ⇒ C ⇒ def Lit: Int O def Add: ( E , E ) ⇒ C ⇒ O } 22/42

  46. compose( , ) = Dependency Tracking trait Sig[- E , - C , + O ] { ⇒ C ⇒ def Lit: Int O def Add: ( E , E ) ⇒ C ⇒ O } 22/42

  47. compose( , ) = Composing two algebras def compose [E 1 , C 1 , O 1 , E 2 , C 2 >: C 1 with O 1 , O 2 ] (alg 1 : Sig[E 1 , C 1 , O 1 ], alg 2 : Sig[E 2 , C 2 , O 2 ]): Sig[E 1 with E 2 , C 1 , O 1 with O 2 ] 23/42

  48. compose( , ) = Composing two algebras def compose [E 1 , C 1 , O 1 , E 2 , C 2 >: C 1 with O 1 , O 2 ] (alg 1 : Sig[E 1 , C 1 , O 1 ], alg 2 : Sig[E 2 , C 2 , O 2 ]): Sig[E 1 with E 2 , C 1 , O 1 with O 2 ] 23/42

  49. compose( , ) = Composing two algebras def compose [E 1 , C 1 , O 1 , E 2 , C 2 >: C 1 with O 1 , O 2 ] (alg 1 : Sig[E 1 , C 1 , O 1 ], alg 2 : Sig[E 2 , C 2 , O 2 ]): Sig[E 1 with E 2 , C 1 , O 1 with O 2 ] 23/42

  50. compose( , ) = Composing two algebras def compose [E 1 , C 1 , O 1 , E 2 , C 2 >: C 1 with O 1 , O 2 ] (alg 1 : Sig[E 1 , C 1 , O 1 ], alg 2 : Sig[E 2 , C 2 , O 2 ]): Sig[E 1 with E 2 , C 1 , O 1 with O 2 ] 23/42

  51. compose( , ) = Composing two algebras def compose [E 1 , C 1 , O 1 , E 2 , C 2 >: C 1 with O 1 , O 2 ] (alg 1 : Sig[E 1 , C 1 , O 1 ], alg 2 : Sig[E 2 , C 2 , O 2 ]): Sig[E 1 with E 2 , C 1 , O 1 with O 2 ] 23/42

  52. compose( , ) = Composing two algebras def compose [E 1 , C 1 , O 1 , E 2 , C 2 >: C 1 with O 1 , O 2 ] (alg 1 : Sig[E 1 , C 1 , O 1 ], alg 2 : Sig[E 2 , C 2 , O 2 ]): Sig[E 1 with E 2 , C 1 , O 1 with O 2 ] 23/42

Recommend

The Expression Problem and Lenses Lambdajam 2016 Tony Morris The Expression Problem A new name

The Expression Problem and Lenses Lambdajam 2016 Tony Morris The Expression Problem A new name

The Expression Problem and Lenses Lambdajam 2016 Tony Morris The Expression Problem A new name for an old problem[Wad98] Whether a language can solve the Expression Problem is a salient indicator of its capacity for expression. The Expression

894 views • 54 slides
Independently Extensible Solutions to the Expression Problem Martin Odersky, EPFL Matthias

Independently Extensible Solutions to the Expression Problem Martin Odersky, EPFL Matthias

Independently Extensible Solutions to the Expression Problem Martin Odersky, EPFL Matthias Zenger, Google History The expression problem is fundamental for software extensibility. It arises when recursively defined datatypes and

609 views • 30 slides
AP BIOLOGY Gene Expression Summer 2013 www.njctl.org Slide 3 / 199 Gene Expression Unit Topics

AP BIOLOGY Gene Expression Summer 2013 www.njctl.org Slide 3 / 199 Gene Expression Unit Topics

Slide 1 / 199 Slide 2 / 199 AP BIOLOGY Gene Expression Summer 2013 www.njctl.org Slide 3 / 199 Gene Expression Unit Topics Click on the topic to go to that section Discovery of DNA Nucleic Acid Structure DNA Replication

1.07k views • 81 slides
Clustering Expression Data www.cs.washington.edu/527 Why cluster gene expression data?

Clustering Expression Data www.cs.washington.edu/527 Why cluster gene expression data?

Clustering Expression Data www.cs.washington.edu/527 Why cluster gene expression data? Tissue classification Find biologically related genes First step in inferring regulatory networks Look for common promoter elements

334 views • 10 slides
CSci 8980: Advanced Topics in Graphical Models Application: Gene Expression Analysis Instructor:

CSci 8980: Advanced Topics in Graphical Models Application: Gene Expression Analysis Instructor:

Background Gene Expression Analysis Replicated Microarray Analysis CSci 8980: Advanced Topics in Graphical Models Application: Gene Expression Analysis Instructor: Arindam Banerjee November 20, 2007 Background Gene Expression Analysis

870 views • 43 slides
Epigenome and Gene Expression 02-715 Advanced Topics in Computa8onal

Epigenome and Gene Expression 02-715 Advanced Topics in Computa8onal

Epigenome and Gene Expression 02-715 Advanced Topics in Computa8onal Genomics Epigenome and Transcription Histone modifica8on levels can influence gene expressions Nucleosome

507 views • 31 slides
Topics for today Introduction to Bioconductor: Getting started with Bioconductor g Using R

Topics for today Introduction to Bioconductor: Getting started with Bioconductor g Using R

Topics for today Introduction to Bioconductor: Getting started with Bioconductor g Using R with high-throughput genomics U i R ith hi h th h t i Expression microarrays Normalization Intro to differential expression

1.44k views • 7 slides
Structural Types, Recursive Modules, and the Expression Problem Jacques Garrigue Nagoya

Structural Types, Recursive Modules, and the Expression Problem Jacques Garrigue Nagoya

Structural Types, Recursive Modules, and the Expression Problem Jacques Garrigue Nagoya University, Grad. Sch. of Mathematics Jacques Garrigue Structural Types, Recursive Modules, and the Expression Problem 1 Synopsis The Expression

335 views • 22 slides
The Big Picture Related Work Practical Considerations The Boundaries of Our Methods Code

The Big Picture Related Work Practical Considerations The Boundaries of Our Methods Code

The Big Picture Related Work Practical Considerations The Boundaries of Our Methods Code Synthesis for (int i = 0; i < 10; i++){ Token en Console.WriteLine(i); } ForStatement ions ns Expression Expression Body Initialization

469 views • 28 slides
Bayesian modelling of multi-step process differential gene expression data Low-level Model Alex

Bayesian modelling of multi-step process differential gene expression data Low-level Model Alex

Gene expression analysis is a Bayesian modelling of multi-step process differential gene expression data Low-level Model Alex Lewin, with Sylvia Richardson, Clare (how the measured expression is related to the Marshall, Anne Glazier and Tim

196 views • 3 slides
Advanced Main Ideas Behind . . . Computational Methods Specific Topics . . . Topics Related to

Advanced Main Ideas Behind . . . Computational Methods Specific Topics . . . Topics Related to

Why Economics and . . . Important Aspects of . . . Traditional (Basic) . . . Need to Go Beyond . . . Advanced Main Ideas Behind . . . Computational Methods Specific Topics . . . Topics Related to . . . in Economics and Finance Algorithms

655 views • 28 slides
Confluent Orthogonal Drawing for Syntax Diagrams S-expression ( S-expression

Confluent Orthogonal Drawing for Syntax Diagrams S-expression ( S-expression

Confluent Orthogonal Drawing for Syntax Diagrams S-expression ( S-expression S-expression ) . AZ AZ 09 Michael J. Bannister David A. Brown David Eppstein Context-Free Grammars LISP 1.5 S-expression: (

486 views • 30 slides
Aggregation An aggregate function in the [columns] clause computes a value from a group of rows

Aggregation An aggregate function in the [columns] clause computes a value from a group of rows

Aggregate Functions So far, all SQL expressions have referred to the values in a single row at a time [expression] as [name], [expression] as [name], ... select [columns] from [table] where [expression] order by [expression]; Aggregation An

452 views • 4 slides
Gene Expression Data Introduction to gene expression data Expression data storage concept An

Gene Expression Data Introduction to gene expression data Expression data storage concept An

Gene Expression Data Introduction to gene expression data Expression data storage concept An example of storage and retrieval : CleanEx Online Analysis tools for gene expression data Outline - Gene expression measurements : from gene-scale to

700 views • 51 slides
Diet monitoring is a big issue in many health- related topics, so there has been many

Diet monitoring is a big issue in many health- related topics, so there has been many

Hamid Hassannejad, Guido Matrella, Monica Mordonini, and Stefano Cagnoni 14 th Conference of the Italian Association for Artificial Intelligence September 2015 Diet monitoring is a big issue in many health- related topics, so there has been

262 views • 13 slides
Key Topics Related to Grant Accountability and Monitoring

Key Topics Related to Grant Accountability and Monitoring

Key Topics Related to Grant Accountability and Monitoring _____________________________________________________ 21 st Century Fall Project Directors Workshop October 2019 1 Grant Monitoring Points of Emphasis Personally Identifiable

419 views • 28 slides
Aug me nte d Re a lity Sung -e ui Yo o n Project Guidelines: Project Topics Any topics

Aug me nte d Re a lity Sung -e ui Yo o n Project Guidelines: Project Topics Any topics

1 Aug me nte d Re a lity Sung -e ui Yo o n Project Guidelines: Project Topics Any topics related to the course theme are okay You can find topics by browsing recent papers 2 Expectations Mid-term project presentation Introduce

757 views • 34 slides
Lec 03. Regular expression, Pumping lemma Eunjung Kim F ORMAL DEFINITION OF R EGULAR EXPRESSION

Lec 03. Regular expression, Pumping lemma Eunjung Kim F ORMAL DEFINITION OF R EGULAR EXPRESSION

C OMPUTABILITY AND C OMPLEXITY , 2020 F ALL SEMESTER Lec 03. Regular expression, Pumping lemma Eunjung Kim F ORMAL DEFINITION OF R EGULAR EXPRESSION R EGULAR EXPRESSION OVER A FINITE ALPHABET Regular expression over is a string consisting

710 views • 13 slides
Language-Driven Visual Reasoning for Referring Expression Comprehension

Language-Driven Visual Reasoning for Referring Expression Comprehension

Language-Driven Visual Reasoning for Referring Expression Comprehension Outline Introduction and Related Work Cross-Modal Relationship Inference Network, CVPR 2019 Dynamic Graph

611 views • 47 slides
The Expression Problem Prof. Dr. Ralf Lmmel Universitt Koblenz-Landau Software Languages

The Expression Problem Prof. Dr. Ralf Lmmel Universitt Koblenz-Landau Software Languages

The Expression Problem Prof. Dr. Ralf Lmmel Universitt Koblenz-Landau Software Languages Team Elevator speech Suppose you have some data variants (say apples and oranges) and you have some operations on such data (say

1.03k views • 67 slides
Language-Driven Visual Reasoning for Referring Expression Comprehension

Language-Driven Visual Reasoning for Referring Expression Comprehension

Language-Driven Visual Reasoning for Referring Expression Comprehension VALSE 2019-12-18 Outline Introduction and Related Work Cross-Modal Relationship Inference for Grounding

610 views • 34 slides
Related topics: Marc Van Droogenbroecks Computer Vision and Louis Wehenkel/Pierre

Related topics: Marc Van Droogenbroecks Computer Vision and Louis Wehenkel/Pierre

Related topics: Marc Van Droogenbroecks Computer Vision and Louis Wehenkel/Pierre Geurts Introduction to Machine Learning + More recent topics: - End-to-end learning with tree-based methods and deep learning - The need for

1.36k views • 100 slides
Evolving Prolog gene expression programming mndrix The Problem Lending Club peer to peer loans

Evolving Prolog gene expression programming mndrix The Problem Lending Club peer to peer loans

Evolving Prolog gene expression programming mndrix The Problem Lending Club peer to peer loans which ones are good? data! The Result 98% success p2pquant.com note selection Genetic Algorithms because giraffes Candida Ferreira FTW!

698 views • 31 slides
Algebraic Eigenvalue Problem Algebraic Eigenvalue Problem Computers are useless. They can only

Algebraic Eigenvalue Problem Algebraic Eigenvalue Problem Computers are useless. They can only

Algebraic Eigenvalue Problem Algebraic Eigenvalue Problem Computers are useless. They can only give answers. Pablo Picasso 1 Fall 2010 Topics to Be Discussed Topics to Be Discussed This unit requires the knowledge of eigenvalues This

786 views • 76 slides

More recommend