The Tallis process modelling and publishing environment

1

• The Tallis process modelling and publishing
  environment
• Implementing clinical guidelines,
• decision support and
• workflow in PROforma

2
A Tallis tutorial

• Concepts
• Basic process design
• Decision-making
• Plans and pathways
• Publishing and customising for the web
• Patterns and idioms
• Design styles and methods
• Your application

3
PROforma

• A language and tools for creating intelligent
  guidelines and other applications
• Analogy with musical notation, invented by Guido
  dArezzo
• Tallis extends InferMeds Arezzo? tools by
  supporting publishing on the web and
• Integration with text, HTML and other media

4
OverviewA PROforma lifecycle
5
(No Transcript)
6
A PROforma lifecycle
Take 1 clinical need 1 source of expertise
7
(No Transcript)
8
Clinical processes as networks of tasks
9
PROforma task classes
Generic task
Enquiry
Decision
Plan
Action
10
Task drawing area
Task summary window
Task properties
Task drawing area and task ontology
11
Action
12
Enquiry
13
Decision
14
Decision

• decision 'Diagnosis_decision'
• caption "Diagnosis decision"
• candidate ''peptic ulcer''
• argument for,age lt 35 OR weight
  normal attributes
• argument_name 'age lt 35 OR
  weight normal'
• end attributes
• recommendation netsupport(decision_11,
  'peptic ulcer') gt 1
• candidate 'cancer'
• argument for,biopsy abnormal
  attributes
• argument_name 'biopsy
  abnormal'
• end attributes
• argument for,age gt 50 AND Weight
  down attributes
• argument_name 'age gt 50 AND
  Weight down'
• caption "Elderly patient has
  lost weight"
• end attributes
• recommendation netsupport(decision_11,
  'cancer') gt 1
• end decision.

15
Plan
16
Plans are recursive
17
Plan

• plan 'Sydney_example'
• caption "Example for presentation in
  Sydney"
• abort patient_discharged yes
• terminate patient_recovered yes
• component 'Diagnosis_decision'
• schedule_constraint
  completed('Patient_history')
• number_of_cycles 1
• component 'Patient_history'
• number_of_cycles 1
• component 'Pathway_1'
• schedule_constraint
  completed('Diagnosis_decision')
• number_of_cycles 1
• component 'Pathway_2'
• schedule_constraint
  completed('Diagnosis_decision')
• number_of_cycles 1
• end plan.

18
An example PROforma process
19
Enactable knowledge format
20
Verification of task spec
21
Testing the behaviour, performance
22
Testing

• Add
• section
• to explain
• use

23
Deployment, trial and use
24
(No Transcript)
25
(No Transcript)
26
Tallis development team

• Development manager
• Tony Rose (tr_at_acl.icnet.uk)
• Enactment engine
• David Sutton, now TR
• Composer, repository manager
• Ali Rahmanzadeh (ahr_at_acl.icnet.uk)
• Web browser support
• Rory Steele (rs_at_acl.icnet.uk)
• PROforma application development
• John Fox (john.fox_at_cancer.org.uk)

Bugzilla !! www.acl.icnet.uk/bugs/
27
Current PROforma technologies
PROforma Process model
28
Pause questions, issues

• Next Basic application development

29
(No Transcript)
30
Tallis composer toolbar
PROforma verification
Composition
Performance
31
Saving/loading applications

• Save and load applications from private files
• Upload and download to a public repository
  (currently at OpenClinical)
• Store and restore application states

32
Exercise 1 the basic process

• Lay out some tasks
• Save and reload the file
• Delete a task
• Copy/paste a task
• Display the PROforma specification
• Save and reload the file

33
Exercise 2 a simple action process

• Create an action, add Hello world to the
  procedure slot
• Save to file and reload
• Add another action Goodbye cruel world
• Make the actions into a sequence and save the
  application
• Run it through the tester
• Save

34
Exercise 3 a process that collects data

• Make a new task sequence which starts with an
  enquiry
• Run the verifier V (in development)
• Add data items to the enquiry, such as age, sex
• Run tester and check data have been correctly
  collected.
• Add a successor task and test
• Add precondition to successor

35
Generic task (keystone) properties

• A keystone has general task properties but no
  specific class properties (decision, plan etc.)

• A keystone can be thought of as
• The root class for the PROforma task ontology
• A placeholder for a task whose method has not
  been defined
• A goal to be achieved.

36
Expression editor for logic conditions

• Applies to all tasks
• Preconditions
• State triggers
• Cycle until
• Decisions
• Arguments
• Commitments
• Plans
• Termination conditions
• Abort conditions

37
Exercise 4 A simple flow chart

• Create an enquiry which collects one or more data
  items
• Add successor tasks and set up preconditions to
  ensure they are selected only under certain data
  conditions.
• Why is a task network not really a flow chart?

38
Control flow and data flow

• For flowchart mode you would use scheduling
  constraints between tasks, with preconditions on
  downstream tasks.
• For dataflow mode you can link tasks which are
  not directly connected by using state triggers.
  These dataflow connections can be between tasks
  anywhere in the application.

39
Data definitions

• Data definitions are distinct from context of use
• Can have multiple instances of data collection
• Various functions on data are provided (average,
  max, min, first, last etc.)
• More will be added to Tallis as needed

40
PROforma checking

• Syntax parser and type-checker built into
  composer, provides basic checks for content
  errors
• (Arezzo has more extensive checking)
• B. More advanced model checking and
  constraint validation are important areas for
  future development

41
Exercise 5 a lattice of tasks

• Build a network of enquiries and actions 2
  enquiries followed by at least 2 actions
• Set up the network to arrange that the actions
  are only enacted under specific combinations of
  conditions
• e.g.
• X and Y
• X or Y
• not(X)

42
Pause questions, issues
Next decision-making
43
Making decisions

• A decision is a logical model for any kind of
  choice
• e.g. diagnosis,
• treatment selection,
• risk level,
• alarm
• The simplest decisions are made by generating and
  assessing arguments for and against the options.
• Arguments have the form but not the force of
  logical conditions.

44
(No Transcript)
45
Decision

• decision Diagnosis
• caption "Diagnosis decision"
• candidate ''peptic ulcer''
• argument for,age lt 35 OR weight
  normal attributes
• argument_name 'age lt 35 OR
  weight normal'
• end attributes
• recommendation netsupport(Diagnosis,
  'peptic ulcer') gt 1
• candidate 'cancer'
• argument for,biopsy abnormal
  attributes
• argument_name 'biopsy
  abnormal'
• end attributes
• argument for,age gt 50 AND Weight
  down attributes
• argument_name 'age gt 50 AND
  Weight down'
• caption "Elderly patient has
  lost weight"
• end attributes
• recommendation netsupport(Diagnosis,
  'cancer') gt 1
• end decision.

46
Exercise 6 Making a decision

• Create a task network, ensure that it includes a
  decision that follows at least one data enquiry.
• Add data items to enquiries
• Add one or more candidates to the decision,
  arguments for candidates, and commitment rules
• Test the decision process

47
Advanced decision features

• Candidates and arguments can be weighted
  (Bayesian version a future option)
• Decisions can have single or multiple selections
• Netsupport function should be viewed as a
  default condition for committing to a candidate
• Conditions, including arguments and commitment
  rules, can refer to the results of other
  decisions
• result_of(D) R
• result_of(D) includes R

48
Modes of decision

• Decisions can be direct or remote
• have control flow and/or dataflow consequences
• Can lurk as monitors or demons
• Decision-making can be supervised or autonomous
• Can include a single candidate (e.g. for
  automatic go/no-go decisions)

49
Exercise 7 direct and remote decisions

• Remove any scheduling constraints between the
  decision and other tasks.
• Add
• is_completed(Decision_name)
• to the state trigger of the decision
• C. Run the application through the tester

50
Some comments on decisions

• References to decision candidates in conditions
  are not automatically tracked yet (you will have
  to update them manually)
• Argumentation will currently only consider the
  last value of any data item (actually this is
  true of all conditions)
• Rule input mode (locked/unlocked) can be ignored!

51
Current engine bugs/inadequacies

• Data only have single values
• No complex data objects
• No variables in expressions
• Parameter passing needs work
• Temporal predicates/functions need work

52
Pause questions, issues
Next plans and processes
53
Some general features of PROforma

• PROforma is a compositional system (complex
  processes can be composed out of a small number
  of simple components)
• It is recursive over plans (in fact you can put
  whole applications inside plans)
• Tasks and processes can operate synchronously,
  in a planned way, or asynchronously in
  response to unpredictable events and circumstances

54
Plans (1)

• A plan can be thought of as a container for a
  collection of tasks which together achieve some
  goal
• All tasks in a plan are in certain respects
  treated as one task
• Plans can contain other plans (sub-plans)

55
contains
56
Plans (2) tasks in a plan share

• Preconditions (of parent plan)
• must be true before tasks are eligible
• Termination conditions
• the whole plan will be terminated immediately if
  this condition becomes true
• Abort conditions
• the plan will be aborted immediately if this
  condition becomes true

57
Exercise 8 a simple protocol

• Create a protocol with 4 phases of management
• Clinical work-up
• Diagnosis and management decisions
• Treatment
• Follow-up
• Populate the individual plans with tasks
• Test the application

58
Parallel processes streaming
59
Reactive processes event and state triggers
60
Exercise 9 setting up triggers

• Create 4 tasks, an enquiry, a keystone, a
  decision and an action
• Set the enquiry to collect some data, and link
  this to the decision by setting up its state
  trigger to refer to a particular data pattern
• Put a trigger name (string) in the event trigger
  slot of the action, and then set up the
  invocation mechanism by adding a trigger string
  to the context slot of the keystone and
  activate it with the function provided.
• Repeat C but reverse the direction of the trigger
  (use the action to control triggering the
  keystone). Convert the keystone to a task of your
  choice and test.

61
Pause questions, issues
Next Publishing your application
62
(No Transcript)
63
(No Transcript)
64
Publets

• A publet is a formal process for situation
  assessment, decision making, process management
  which can be published over the internet.
• Tallis is designed to support the creation of
  publets based on the PROforma process model,
  integrated with conventional web documents
• The aim is to combine traditional publishing
  methods with software engineering disciplines and
  techniques

65
Repository
NASA tutorial User name NASA Pwd testpass
Add explanatory section here
66
Exercise 10 publishing

• Build an application of your choice
• Publish it
• Log in to the repository and save your
  application there
• Create a folder with your own name such as
  Fred_Smith

67
Pause questions, issues
Next patterns
68
Patterns

• A pattern or idiom is a partially or wholly
  specified task network which captures some
  generic process (e.g. data collection,
  decision-making, research protocol) which can be
  reused across applications.

69
Simple patterns

• Branching Into alternative processes
• Parallelism Simultaneous streams
• Synchronisation Merging streams
• Triggering Asynchronous selection of
  tasks
• Terminate Interrupting plans
• abort

70
Branch by enquiry
71
Exercise 10 Branch by decision
Can you implement a working version of this? If
you can, try making the decision run automatically
72
Synchronising processes
73
Any task can have a synchronisation role (in
control flow or dataflow modes)
A cascade of synchronisation nodes (control flow
mode)
74
Exercise (11)

• Write an application to demonstrate the
  following
• A data collection task followed by a two-stream
  process
• One collects more data
• One takes a decision or an action
• Merge (resynchronise) the two streams in a
  follow-up task

75
Exercise (12)

• Build a SOAP guideline
• Subjective
• data
• Assessment Plan of
• decision care
• Objective
• data

hint
76
Triggering processes
77
Parallel triggers
Holding task
78
Terminate and abort processes
tutorial08_term_abort_1_Known_V1.0.pf
tutorial08_term_abort_2_Known_V1.0.pf
79
Exercise (13)

• Create an application that contains two
  services that can be independently invoked
• Collect patient data and take one of a number of
  actions
• Collect patient data and take a decision
• Dont forget to include a holding task (e.g. an
  action) for initiating and terminating the
  services

80
Repositories of standard components?
81
Tallis publishing lifecycle
The Syntax and Semantics of the PROforma
guideline modelling language D Sutton and J Fox,
JAMIA, 2003.
82
Pause questions, issues
Next Customising your application UI
83
Quick UIs Text and HTML
84
Quick UIs Text and HTML

• HTML can also be used in description fields (but
  no HTML editor yet and may be a bit clumsy)
• Decisions
• Candidates
• Arguments
• Decision rules
• Enquiries
• Data item captions

85
Exercise 14 Customising task UIs

• Create an action
• Select the HTML mode in the procedure slot.
• Add and format the text
• Create a keystone or any other task
• Select the context slot (left panel tab)
• Add and format text to taste
• You may also be able to copy simple HTML directly
  from another application (this is not well
  developed and may be buggy)

86
Customising task pages

• 3 options
• HTML editor in composer (context and action
  procedure)
• Customising pages outside the composer (e.g.
  commercial editors)
• Attaching applets to a task

87
RepriseThe basic method
88
(No Transcript)
89
Pause questions, issues
Next General design methods
90
Design methods/styles

• Standard task network method
• Top-down from Keystones
• Bottom-up from data
• Assemble from components
• Customise prefabs
• Service-based modelling (e.g. CREDO)
• Agent-oriented modelling

91
Standard method
92
Bottom up
Patient forename PATSFNAM  Patient surname
PATSNAME  Patient address PATADD1 - 4 Date of
birth DOB DD/MM/CCYY Hospital of referral
HOSP Referring GP GP Date of referral REF
DATE Unit number UNITNUM Menopausal status
MSTATUS 1Pre 2Peri 3Post 9Not
recorded Side SIDE 1Left 2Right 3Bilateral
4Not recorded Tumour T According to TNM
Clinical Stage Nodal N According to TNM
Clinical Stage Metastases M According to TNM
Clinical Stage Date of definitive diagnosis
DIAGDATE DD/MM/CCYY Type of tumour TUMOUR
1Invasive 2DCIS 3Other non-invasive 9Not
recorded Dist from excision margins DISTEX
1lt1mm 21-5mm 3gt5mm 9Not known Maximum
pathological diameter MAXPATH Tumour grade
TGRADE 1I 2II 3III 4Not assessable 9Not
recorded No.. of lymph nodes examined
EXNODES No. of lymph nodes involved I NVNODES  
93
Top down from keystones (1)
94
Top down from keystones (2)
95
Exercise 15 Top down design

• Create an application that contains several
  keystones
• Modify some keystones by
• Converting one into a specialised task
• Replacing one by importing an application that
  you created earlier
• If you are connected to the CR-UK repository, try
  replacing one with a component taken from my
  folder

96
Exercise 16 components
Create a small network of keystones. Right
button on one of them and select web
repository import Go to my folder (John_Fox),
and open the workshop and components folders.
Double click on a component
97
Prefabricated services prefabs
98
Exercise 17 Creating services

• Create a set of keystones (to become services)
• Add a trigger to each one
• Edit the holding task to include appropriate
  trigger phrases
• Use the trigger insert function to create links
• Test the application
• Convert the keystones into services by defining
  them as plans and populating them as you like.
• Test and publish the application

99
Agent-oriented design

• Service agents
• Care pathway agents
• Specialised clinical views
• Clinical trial agent
• Patient services
• Autonomous agents
• Clinical audit and black box
• Hazard monitor

100
Wrap-up

101
Current PROforma technologies
PROforma Process model
102
Future of Tallis

• A stronger logic, data and agent model
• Simpler UI configuration, multi-modal
• Integration with a multimedia authoring
  environment which recognises and links a range of
  knowledge types and media
• Integration of voice into UI (spoken and
  recognised)
• Support for editorial functions
• Support for other knowledge formats (e.g. Arden
  MLMs, GLIF?)

103
Exercise 18 Your application

• Decide on a simple application that will require
  less than a dozen tasks in total
• Decide on the design method (e.g. bottom up,
  top-down)
• Create the task network and data definitions
• Specify task details
• Test, rework from C or D until acceptable
• Customise the tasks using the HTML editor
• Publish, rework from F until acceptable

104
More at