Download
slide1 n.
Skip this Video
Loading SlideShow in 5 Seconds..
LAG PowerPoint Presentation

LAG

7 Vues Download Presentation
Télécharger la présentation

LAG

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. LAG Alexandra I. Cristea UPB intensive course “Adaptive Hypermedia”January 2004

  2. Overview: LAG • What is LAG • LAG components • Why LAG? • New adaptation rules • Adaptation strategies

  3. What is LAG?

  4. What is LAG ? • a generalized adaptation model for generic adaptive hypermedia authoring • First paper: http://wwwis.win.tue.nl/~alex/Conferences/02/AH02/calvi-cristea-final-w-header-ah2002.pdf • Second (referring) paper: http://wwwis.win.tue.nl/~alex/Conferences/02/ELEARN02/Cristea-Adaptation-Adaptability.pdf • Third paper: http://wwwis.win.tue.nl/~alex/HTML/Minerva/papers/UM03-cristea-calvi-accepted.doc

  5. LAG components

  6. LAG components • Direct adaptation Techniques • Adaptation Language • Adaptation Strategies

  7. 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: more 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

  8. Why LAG?

  9. Motivation LAG • Authoring with different complexity degrees (beginner authors vs. advanced) • Re-usage at each level • Better semantics • standardization

  10. New adaptation rules proposed(Adaptation Language)

  11. Adaptation ‘Programming’ language level rule: IF ENOUGH(<PREREQUISITES>) THEN<ACTION> temporal rule: WHILE <CONDITION> DO <ACTION> repetition rule: FOR <i=1..n> DO <ACTION> interruption command: BREAK <ACTION> generalization command: GENERALIZE (COND, COND1, …, CONDn) specialization command: SPECIALIZE (COND, COND1, …, CONDn)

  12. A level rule IF ENOUGH(<PREREQUISITES>) THEN<ACTION> • ENOUGH = fct. of no. & quality of prerequisites; true if, e.g., a given no. of prerequisites from a set is fulfilled • Ex: PREREQUISITES = time_spent; ACTION = “go to next level” • Rule becomes: • IF ENOUGH (time_spent on crt. level) THEN “go to next level” • Where ENOUGH is defined, e.g., as follows: • ENOUGH (time) = 30 time units; • time (advanced topic) = 10 (time units per topic); • ENOUGH (medium topic) = 5 (time units per topic); • ENOUGH (beginner topic) = 2 (time units per topic);

  13. A temporal rule: • action repeated as long as 1-more cond.s hold: WHILE <CONDITION> DO <ACTION> • According to CM paradigm, concepts  canned but assembled depending on UM & their attr.s ( more than mere addition/deletion of links) • E.g, a warning is repeated that user search direction is wrong. Another cond. can trigger a service denial response if a threshold is passed.

  14. A repetition rule: • a certain (simple / composed) action repeated for a no. of times predefined by author: FOR <i=1..n> DO <ACTION> • describes the time this action has to last before reader can move on.

  15. An interruption command: • user action is interrupted & s/he is forced to undertake a different one: BREAK <ACTION> • represents an exacerbation of traditional behavior of AHS: user is “punished” if she doesn’t stick to learning pathways provided by system.

  16. A generalization command: • new concept reader has reached is compared w. more general ones it refers to. As a result, the reader is pointed to related concept(s): GENERALIZE (COND, COND1, …, CONDn)

  17. A specialization command: • if concept is general, system deductively points reader to more specific instantiations: SPECIALIZE (COND, COND1, …, CONDn) • E.g, if student reads about “Model Reader” in a course on postmodern literature, she can be pointed to an extract from Calvino’s novel ‘Se una notte’, where this notion is exemplified.

  18. Other commands • comparison (concept analogy search) & • difference • both instances of generalization; • duration – a rule related to repetition • lyrical use of repetitions in hyperfiction has given rise to a particular design pattern

  19. Adaptation Strategies

  20. Adaptive strategies for cognitive styles

  21. medium_increase() : generate adaptive presentation with (obviously) increasing difficulty 1. Explanation: Convergers are abstract and active; they like to feel in control; start with course for intermediates at medium adaptivity level, repeat for a number of times: -evaluate state of learner and start increasing difficulty & decreasing adaptivity level if result=good -evaluate state of learner and start decreasing level if result=bad 2. Translation at medium level: (ENOUGH shows here that the result is above an average result) AdaptLevel= 5; N=AskUser(); # this is to let user feel and be in control; levels: (1=min to 10=max) FOR <I=1..N> DO { SPECIALIZE (ENOUGH(Result)); IF (AdaptLevel>1) AdaptLevel--; GENERALIZE (NOT(ENOUGH(Result))); IF (AdaptLevel<5) AdaptLevel++; } # Note that adaptation level is not allowed to increase too much 3. Translation at low level: (the average can be implemented but takes more space) DiffLevel = 3; AdaptLevel= 5; # note that here there is no predefined number of repetitions IF <ACTION> THEN # Note that above we don’t need the action of the user for triggering; { IF (Result1 +Result2)/2>5 AND DiffLevel<10 THEN # Note that ‘enough’ and specialize { DiffLevel++; IF (AdaptLevel>1) AdaptLevel--;} # must be redefined each time IF (Result1 +Result2)/2<5 AND DiffLevel>1 THEN {DiffLevel--; IF (AdaptLevel<5) AdaptLevel++;} } converger (abstract, active)

  22. low() : generate adaptive presentation with adaptively increasing difficulty Explanation: start with course for beginners at high level of adaptation, from general issues + examples, down + rest as in Table 1 2. Translation at medium level: (ENOUGH same as in Table 1) AdaptLevel= 10; GENERALIZE(); WHILE (not_finished) DO { SPECIALIZE (ENOUGH(Result)); IF (AdaptLevel>5) AdaptLevel--; # Note that we keep adaptation GENERALIZE (NOT(ENOUGH(Result))); IF (AdaptLevel<10) AdaptLevel++; } # level high here 3. Translation at low level: DiffLevel = 1; AdaptLevel= 10; IF <ACTION> THEN { IF (Result1 +Result2)/2>5 AND DiffLevel<10 THEN { DiffLevel++; IF (AdaptLevel>5) AdaptLevel--;} IF (Result1 +Result2)/2<5 AND DiffLevel>1 THEN {DiffLevel--; IF (AdaptLevel<10) AdaptLevel++;}} diverger (concrete, reflective)

  23. high() : generate adaptive presentation with high difficulty and little adaptivity 1. Explanation: start with course for intermediates at high level adaptation + similar Table 1 2. Translation at medium level: (ENOUGH same as in Table 1) SPECIALIZE(); AdaptLevel= 1; WHILE (not_finished) DO { GENERALIZE(ENOUGH(Result)); SPECIALIZE (NOT(ENOUGH(Result))); } 3. Translation at low level: DiffLevel = 10; AdaptLevel= 1; IF <ACTION> THEN { IF (Result1 +Result2)/2>5 AND DiffLevel<10 THEN DiffLevel++; IF (Result1 +Result2)/2<5 AND DiffLevel>1 THEN DiffLevel--; } assimilator (abstract, reflective)

  24. medium_decrease() : generate adaptive presentation with (obviously) decreasing difficulty -1. Explanation: Accomodators like to feel in control; they want first examples and then theory. 2. Translation at medium level: (ENOUGH same as in Table 1) AdaptLevel= 5; N=AskUser(); # this is to let user feel and be in control; FOR <I=1..N> DO { SPECIALIZE (ENOUGH(Result)); IF (AdaptLevel>1) AdaptLevel--; GENERALIZE (NOT(ENOUGH(Result))); IF (AdaptLevel<5) AdaptLevel++; } 3. Translation at low level: (the average can be implemented but takes more space) DiffLevel = 8; AdaptLevel= 5; IF <ACTION> THEN { IF (Result1 +Result2)/2>5 AND DiffLevel<10 THEN {DiffLevel++; IF (AdaptLevel>1) AdaptLevel--;} IF (Result1 +Result2)/2<5 AND DiffLevel>1 THEN {DiffLevel--; IF (AdaptLevel<5) AdaptLevel++;}} accommodator (concrete, active)