1. Generic Adaptation Languages Explicit Intelligence in Adaptive Hypermedia Generic Adaptation Languages Explicit Intelligence in Adaptive Hypermedia Dr. Alexandra Cristea a.i.cristea@warwick.ac.uk http://www.dcs.warwick.ac.uk/~acristea/

2. LAOS Model

3. Adaptation granularity lowest level: direct adaptation techniques: –adaptive navigation support & adaptive presentation (Brusilovsky 1996), implem.: AHA!; expressed in AHAM syntax –techniques usually based on threshold computations of variable- value pairs. medium level: goal / domain-oriented adaptation techniques: –based on a higher level language that embraces primitive low level adaptation techniques (wrapper) –new techniques: adaptation language (Calvi & Cristea 2002), high level: adaptation strategies – wrapping layers above – goal-oriented Adaptation Assembly language Adaptation Programming language Adaptation Function calls

4. How to create an adaptation language? Adaptation Language as an Intermediate Platform (between authoring environment and adaptation engine) An interface between the adaptation engineer and the authoring system

5. “Authoring problem” Defining: - content alternatives & multiple paths through the content - adaptation techniques - whole user-interaction mechanism design Alleviating “Authoring problem” Improving reuse capabilities: (reuse of previously created material & other components) - reuse of static & dynamic parts of the courseware The solution Reuse of dynamics: “Exchanging not only the ingredients, but the recipes as well” Adaptation languages: - LAG - LAG-XLS (read as “LAG-excels”)

6. How to create an adaptation language? We need to find out which are the: –Elements of course dynamics For this, we need to analyse what happens in an adaptive course, and what is done dynamically:

7. Selection of Media Items Visual style Diagrams Illustrations Graphs Flowcharts Animations+ audio Verbal style More text Possibly audio

8. Providing navigation paths Sequential style Linear step-by-step learning process Global style Global overview first, then details

9. Presentation for Visual+Global Learner

10. Presentation for Verbal+Analytic Learner

11. Ordering information Active style Learn by doing things actively Reflective style Learn by looking at examples

12. Types of Adaptive Strategies Instructional strategies - selection of media items - ordering information / different navigation paths Instructional meta-strategies – monitoring e.g., preferences for : - certain types of information (e.g. text vs. image) - reading order (e.g. breadth-first vs. depth-first)

13. Classification of Actions in Adaptive Strategies (from N. Stash) Basic actions on itemsSelection Showing the content of an item Showing a link to an item Defaults Hierarchical actions on itemsActions on child items Actions on parent items Actions on groups of items (e.g. siblings) Ordering Performing “actions on items” on each group item Actions on the overall environment Changing the layout of the presentation

14. LAG LANGUAGE

15. What does the LAG adaptation language do? Turing-complete ? – no! Captures adaptation patterns, typical for AHS, for reuse We start with a set of desired adaptive behavior: –Inherited from direct adaptation techniques: If => Action –Conditions, Enough conditions –We add more, depending on adaptivity requirements

16. If, enough if UM.knowledge > 1 then ( PM.GM.Concepts.show = true ) for-each enough( GM.Concept.weight > 2 GM.Concept.label == interesting,1) (PM.GM.Concept.show = true)

17. Select selecting concept representation In MOT, given by attributes, so LAG has: –DM.Concept.attribute –GM.Concept –E.g., presentation only: PM.DM.Concept.attribute.show PM.GM.Concept.show PM.GM.Concepts.show

18. Sort Sequencing concept representation Content is sorted alphanumerically on the Concept’s “order” variable Order of the current concept: –PM.GM.Concept.order Defaults to Null

19. Show Content/Link Showing content of a concept –PM.DM.Concept.attribute.show –PM.GM.Concept.show Showing the concept in a specific area of the presentation: –PM.MENU.GM.Concept.show –PM.CONTENT.GM.Concept.show

20. Show Links Displaying a link to a concept No difference, only in the navigational areas can they be made available: –PM.TODO.GM.Concept.show Navigational areas are displayed by default. To switch them off we need: –PM.MENU = false

21. setDefault setting defaults FOR-EACH true ( PM.GM.Concept.show[label = ‘’] = true)

22. Hierarchical actions Hierarchy attributes: –Parent: the parent concept of a given concept: GM.Concept.parent –Child: the child concept of a given concept: GM.Concept.child GM.Concept.parent.child GM.Concept.group

23. updates updating the User Model Overlay variable: UM.GM.Concept.knowledge = 1 Free variable: UM.knowledge += 1

24. Actions on groups of items for-each GM.Concept.label == mylabel ( if GM.Concept.weight > 1 then ( PM.GM.Concept.show = false )) PM.GM.Concepts.show = true

25. Dealing with multiple labels Example of LIKE if (GM.Concept.label LIKE *text*) then ( PM.GM.Concept.show = false )

26. Concepts & their contents Stressing the overlay structure of user model on top of Conceptmaps (DM) –UM.DM.stereotype1 = beg or Lessons (GM): –UM.GM.stereotype1 = beg or as independent variables: –UM. stereotype1 = beg

27. Concepts & their contents Stressing the overlay structure of presentation model on top of Lessons (GM): –PM.GM.Concepts.show = true –UM.GM.knowledge

28. Type & Order & Label of Attributes Type of Attributes (in Lessons) usage –GM.Concept.type == title –DM.Concept..type == title Order of Attributes (in Lessons) usage –PM.GM.Concept.order = 3 Labels, weights of attributes (in Lessons) usage –GM.Concept.label == beg –GM.Concept.label LIKE *beg*

29. Special attributes Event attributes: –Access: a concept is currently been accessed: UM.GM.Concept.access = true –Accessed: display count for a GM concept UM.GM.Concept.accessed > 1

30. Multiple Selection & Actions Show all concepts that have not been accessed by the user –PM.GM.Concepts[UM.accessed<1].show = true That shows all concepts in the GM where UM.GM.Concept.accessed < 1

31. Layout Adaptation

32. Menu Progress Bars List Text

33. Default Layout Menu Progress Bars List Text

34. Layout Adaptation Set the layout for an area –Layout[E].type = todo –Layout[E].title = “Todo List” Set a HTML/Text Layout –Layout[S].type = text –Layout[S].content = “ ”

35. Dimming Example of Dimming content if (GM.Concept.label == “dimthis”) then ( PM.GM.Concept.dim = true )

36. Overall structure of a LAG adaptation strategy // Description // Variables initialization ( // what the user sees first ) implementation ( // how the user interacts with the system )

37. Meta-strategies strategy “[Stored Strategy Name]” “[Code to Execute]” Meta-Strategy Example initialization( strategy "qoeSetup" "initialization" ) implementation( strategy "qoeSetup" "implementation" strategy "qoeQOS" "implementation" strategy "qoeMM" "implementation" )

38. LAG resources LAG Example Strategies: http://adaptive.dcs.warwick.ac.uk/ http://adaptive.dcs.warwick.ac.uk/ LAG Guide including Semantics and examples: http://adaptive.dcs.warwick.ac.uk/lagGuide.pdf http://adaptive.dcs.warwick.ac.uk/lagGuide.pdf LAG Grammar: –http://adaptive.dcs.warwick.ac.uk/LAGGrammar.txthttp://adaptive.dcs.warwick.ac.uk/LAGGrammar.txt

39. LAG Example: Rollout This strategy slowly rolls out (and hides) the attributes of concepts based on how often a concept has been accessed. Concepts are monitored through the title attribute. Concept.beenthere keeps track of visits; Concepts have the label "showatmost" if they should disappear after a while (with weight indicating the number of visits required) and the label "showafter" if they should show up after a while (again, weight indicates the number of visits)

40. Rollout Visual Example

41. LAG Example: Rollout Code 1/2 Initialization ( UM.GM.Concepts.beenthere = 0 PM.GM.Concepts.show = true for-each GM.Concept.label == showafter ( if GM.Concept.weight > 1 then ( PM.GM.Concept.show = false ) ) )

42. LAG Example: Rollout Code 2/2 implementation ( for-each UM.GM.Concept.access == true ( UM.GM.Concept.beenthere += 1 ) for-each enough(UM.GM.Concept.beenthere >= GM.Concept.weight GM.Concept.label == showatmost,2) ( PM.GM.Concept.show = false ) for-each enough(UM.GM.Concept.beenthere >= GM.Concept.weight GM.Concept.label == showafter,2) ( PM.GM.Concept.show = true ) )

43. LAG Example: BegIntAdv This strategy shows the beginner concepts first (together with the concepts for all learners). After all beginner concepts are read, the intermediate concepts are shown as well; Finally, after all the intermediate concepts are read, the advanced concepts are shown and the course can be viewed completely

44. LAG Example: BegIntAdv 1/4 initialization( PM.next = true PM.ToDo = true PM.menu = true UM.GM.knowlvl = beg...

45. LAG Example: BegIntAdv 2/4 for-each (true) ( if ( GM.Concept.label == "beg") then ( PM.GM.Concept.show = true UM.GM.begnum += 1 ) elseif (GM.Concept.label == "int") then ( PM.GM.Concept.show = false UM.GM.intnum += 1 ) elseif (GM.Concept.label == "adv") then ( PM.GM.Concept.show = false ) else ( PM.GM.Concept.show = true ) ) )

46. LAG Example: BegIntAdv 3/4 implementation ( for-each ( UM.GM.Concept.access == true ) ( if (UM.GM.Concept.accessed == 1) then ( if (GM.Concept.label == beg) then ( UM.GM.begnum -= 1 ) elseif (GM.Concept.label == int) then ( UM.GM.intnum -= 1 ) ) )...

47. LAG Example: BegIntAdv 4/4 if (UM.GM.begnum < 1 and UM.GM.knowlvl == beg) then ( UM.GM.knowlvl = int PM.GM.Concepts[GM.label == UM.GM.knowlvl].show = true ) elseif (UM.GM.intnum < 1 and UM.GM.knowlvl == int) then ( UM.GM.knowlvl = adv PM.GM.Concepts[GM.label == UM.GM.knowlvl].show = true ) )

48. LAG Example: instance usage initialization ( PM.GM.Concepts.show = false '\Neural Networks II\Neural Networks I\title'.show = true )

49. LAG Example: Parent/Child implementation ( // if you visited the parent you should be able to visit the child for-each (UM.GM.Concept.parent.access == true) then ( GM.Concept.show = true )

50. LAG Example: Positioning 1/2 initialization ( PM.CONTENT.GM.Concepts.show = true for-each (GM.Concept.label == menu) then ( PM.MENU.GM.Concept.show = true ) for-each (GM.Concept.label == todo) then ( PM.TODO.GM.Concept.show = true ) for-each (GM.Concept.label == next) then ( PM.NEXT.GM.Concept.show = true )

51. LAG Example: Positioning 2/2 implementation ( for-each (UM.GM.Concept.accessed > 0) then ( PM.MENU.GM.Concept.show = true )

52. LAG grammar LAG: initialization implementation initialization:"initialization" LEFT_PAREN command_block? RIGHT_PAREN implementation :"implementation" LEFT_PAREN command_block? RIGHT_PAREN command_block:statement (NEWLINE statement)* statement :ifstat | whilestat | action | stratstat | foreachstat stratstat :"strategy" NAME NAME whilestat:"while" condition LEFT_PAREN command_block RIGHT_PAREN ifstat :"if" condition "then" LEFT_PAREN command_block RIGHT_PAREN elseif* elseblock? elseblock:"else" LEFT_PAREN command_block RIGHT_PAREN; elseif :"elseif" condition "then“ LEFT_PAREN command_block RIGHT_PAREN foreachstat :foreach condition LEFT_PAREN command_block RIGHT_PAREN condition_block:condition (NEWLINE condition)* enough :"enough" LEFT_PAREN condition_block "," NUMBER RIGHT_PAREN action:variable OP atom value:TRUE | FALSE | NUMBER | NAME object:variable | value

53. LAG grammar variable :GENCONCEPTATTR -> ^(VAR GENCONCEPTATTR) condition:conditionCOMP ((AND|OR) conditionCOMP)* conditionCOMP:calculation (COMPARE calculation)* | enough calculation:atom (SIGN atom)* atom :object | condition LAOSCM :'DM' | 'GM' | 'UM' | 'PM' | 'CM' | 'dm' | 'gm' | 'um' | 'pm' | 'cm' SIGN : '+' | '-' | '*' | '/'; OP:'=' | '+=' | '-=' | '.='; COMPARE : '==' | '!=' | (' ')('='|)| ('I'|'i') ('N'|'n')| ('L'|'l') ('I'|'i') ('K'|'k') ('E'|'e'); GENCONCEPTATTR :LAOSCM (DOT LAOSCM)? (DOT (GROUP|CONCEPTS|RELATIONS|LABELS|CHILDREN|CONCEPT|SOCKET|PARENT) ('[' NONCONTROL_CHAR+ ']')? )* (DOT NAME)?;

54. Grammar + Semantics LAG: initialization implementation LAG: A LAG strategy or procedure, containing a set of instructions (programming constructs) defining the user and presentation adaptation in an adaptive hypermedia environment. INITIALIZATION: The static initialization part of PROG; in this part, the initial experience of the user, when entering the adaptive environment, is described. This is useful so that a user doesn’t enter a void environment. Here, all the default decisions are set. Adaptive environments which are adaptable but not adaptive can only render this part. IMPLEMENTATION: The dynamic implementation part of PROG; in this part, the interactivity between the adaptive environment and the user is described (for instance, the effect of user clicks).

55. Grammar + Semantics (cont) statement :ifstat | whilestat | action | stratstat | foreachstat STATEMENT: The LAG language is a simple language built of a number of programming constructs, or statements, as follows: –FOREACHSTAT: This loop statement conditionally selects Concepts that can then be referenced by the [UM/PM].[GM/DM].Concept statements. –IFSTAT: condition-action rules: the basic building block of the adaptation language. –WHILESTAT: loops –ACTION: This is part of the basic building block of condition-actions. It can be used by itself, as if the condition attached to it would be set to TRUE. This statement is the only one that allows specification of updates and changes of visible (such as the current screen) or invisible (such as the user knowledge) variables. –STRATSTAT: This statement executes initialization or implementation blocks from other external strategies.

56. Classification of Actions in Adaptive Strategies (from N. Stash) Basic actions on itemsSelection Showing the content of an item Showing a link to an item Hierarchical actions on itemsActions on child items Actions on parent items Actions on groups of items (e.g. siblings) Ordering Performing “actions on items” on each group item Actions on the overall environment Changing the layout of the presentation

57. LAG-XLS: an XML Learning Style Adaptation Language Elements of the language: select – selecting concept representation sort – sequencing concept representation showContent – showing content of a concept showLink – showing link to a concept setDefault – setting defaults actions – updating the User Model

58. Select selecting concept representation

59. sort sequencing concept representation

60. showContent showing content of a concept image

61. showLink showing link to a concept text See textual information

62. setDefault setting defaults default

63. actions updating the User Model personal.VERBvsIM personal.VERBvsIM-5

64. Examples LAG-XLS

65. Verbalizer versus Imager personal.VERBvsIM < 30 image default text Textual information personal.VERBvsIM > 70 text default image Pictorial information

66. Monitoring Strategy: Image versus Text Preference personal.initial.VERBvsI M > 29 & personal.initial.VERBvsIM personal.VERBvsIM personal.VERBvsIM-5 personal.initial.VERBvsI M > 29 & personal.initial.VERBvsIM personal.VERBvsIM personal.VERBvsIM+5

67. Inferring preferences: text vs. image UM: personal.VERBvsIM- 5 UM: personal.VERBvsIM+5 Presentation for Verbalizer Presentation for Imager

69. Contents Motivation Adaptation Language as an Intermediate Platform AHA! & LAG-XLS (XML LS adaptation language) LAOS & LAG (generic adaptation language) Authoring of learning styles in LAG and LAG-XLS Conclusion

70. Strategy for "Verbal" versus "Visual“ style personal.VERBvsIM < 30 image default text See textual information … Imager (Visualizer) strategy LAG LAG-XLS if UM.GM.VERBvsIM < 30 && GM.Concept.type == image then PM.GM.Concept.show

71. personal.initial.VERBvsIM 71 & personal.traceTextvsImage & concept.media==“image” & concept.visited==0 & !parent.text personal.VERBvsIM personal.VERBvsIM- 5 Monitoring Strategy: Preference for Image LAGLAG-XLS if UM.GM.VERBvsIM 71 && UM.GM.traceTextvsImage == true && GM.Concept. type == image && DM.GM.Concept.access == true && ?? then UM.VERBvsIM -= 5

72. Contents Motivation Adaptation Language as an Intermediate Platform AHA! & LAG-XLS (XML LS adaptation language) LAOS & LAG (generic adaptation language) Authoring of learning styles in LAG and AHA! Conclusion

73. Conclusion Extracted intelligence Presented 2 adaptation languages: - LAG - LAG-XLS

74. Questions