Lowering the Barrier to Stream Processing With Alex Morley | Current 2022
0 likes469 views
The document outlines Babylon's approach to stream processing using Python and Faust, addressing issues like high entry barriers and costly solutions associated with existing options like Kafka. It presents Babylon's own health graph functions for various use cases, such as risk prediction and early detection alerts, emphasizing customization and integration with existing tools. Additionally, it discusses the architecture of these solutions and the potential for shadow model deployments, along with a call for talent in technology roles at Babylon.
![9
© Babylon 2022
Our Solution | Health Graph Functions
class Context(BaseContext ):
terminology_client: AsyncRESTClientContext
async def code_mapping_function (
key: DFHIRKey,
value: DFHIRValue,
metadata: EventMetadata,
context: Context,
) -> t.Dict[ str, t.List[Event]]:
...
mapped_codes = context.terminology_client.post({“codes”: value.codes})
...
return {
“conditions” : condition_events,
“labs”: labs_events,
}
agents:
CodeMapping:
enabled: true
function: code_mapping.code_mapper
version: latest
error_handling: BLOCK
store: S3
input_topic:
name: domainevent.redox-cq-integration.clinical-summary
output_topics:
condition:
name: dfhir.reportedcondition.v1
labs:
name: dfhir.labs.v1
context:
terminology_client:
url: '{{ services }}/fast-ct/codeableconcept/convert'
auth: default](https://image.slidesharecdn.com/alexmorleylt0029-221021141741-ae2d5715/85/Lowering-the-Barrier-to-Stream-Processing-With-Alex-Morley-Current-2022-8-320.jpg)
![10
© Babylon 2022
What does it look like? Code Mapping
class Context(BaseContext):
terminology_client: AsyncRESTClientContext
async def code_mapping_function
(
key: DFHIRKey,
value: DFHIRValue,
metadata: EventMetadata,
context: Context,
) -> t.Dict[str, t.List[Event]]:
...
mapped_codes = context.terminology_client.post({“codes”:
value.codes})
...
return {
“conditions”
: condition_events,
“labs”: labs_events,
}
Auto-injected client.
Highly configurable.](https://image.slidesharecdn.com/alexmorleylt0029-221021141741-ae2d5715/85/Lowering-the-Barrier-to-Stream-Processing-With-Alex-Morley-Current-2022-9-320.jpg)
![12
© Babylon 2022
class Thresholds(BaseModel):
high: float
medium: float
class Context(BaseContext):
thresholds: Thresholds
model_version: SemanticVersion
healthIQ_client: AsyncRESTClientContext
async def risk_prediction_function
(
key: DFHIRKey,
value: DFHIRValue,
metadata: EventMetadata,
context: Context,
) -> t.Dict[str, t.List[Event]]:
...
mapped_codes = context.terminology_client.post({“codes”:
value.codes})
...
return {“predictions”: predictions}
Custom contexts can
be extended with your
own models.
Everything is
typed/validated with
pydantic.
This one is simple but
they can be super
powerful if required!
What does it look like? Risk Prediction](https://image.slidesharecdn.com/alexmorleylt0029-221021141741-ae2d5715/85/Lowering-the-Barrier-to-Stream-Processing-With-Alex-Morley-Current-2022-11-320.jpg)
![15
© Babylon 2022
class Context(BaseContext):
graphql_client: AsyncGraphQLClientContext
notification_client: AsyncRESTClientContext
debounce_table: TableContext
debounce_days: float
# IRL there’s lots more here!
async def early_detection_function
(
key: NotificationKey,
value: NotificationValue,
metadata: EventMetadata,
context: Context,
) -> t.Dict[str, t.List[Event]]:
last_alerted_subject = (time.now()-
context.debounce_table[key.subject.id].time)
...
if last_alerted_subject < timedelta(days=debounce_days):
return {“early_detection_alert_skipped”
: alert_event}
return {“early_detection”
: alert_event}
You can have multiple
clients if you want.
And stream-backed
state stores.
We means we can
avoid sending
unnecessary alerts!
(We do still return
an event in case we
want those to be
saved for auditing)
What does it look like? Early Detection](https://image.slidesharecdn.com/alexmorleylt0029-221021141741-ae2d5715/85/Lowering-the-Barrier-to-Stream-Processing-With-Alex-Morley-Current-2022-14-320.jpg)
![17
© Babylon 2022
What else? Other features
Auto-generated Agent
Configuration UI
async def window_function
(events:
t.Sequence[Events], context: Context):
---
batching:
size: 200
timeout: 2
Windowing and batching
# define and configure input event
generators and expected output assertions
# these can be defined inline and will be
continuously tested in live environments
Built-in Test Harnesses](https://image.slidesharecdn.com/alexmorleylt0029-221021141741-ae2d5715/85/Lowering-the-Barrier-to-Stream-Processing-With-Alex-Morley-Current-2022-16-320.jpg)
Lowering the Barrier to Stream Processing With Alex Morley | Current 2022
- 1. 1 © Babylon 2022 Lowering the barrier to stream processing with python, Faust and a "FaaS" approach
- 2. 2 © Babylon 2022 Contents page Other Features Whats under the hood Problem Existing options for our customers Use cases Evaluating OOTB solutions Our Solution | Health Graph Functions How our solution looks with each use case
- 4. 5 © Babylon 2022 What’s the Problem? High barrier to entry Slow to develop More than 1 month on average Expensive Compute and memory requirements lead to high cloud costs Maintenance & Complexity Burden Teams scared to build streaming apps
- 5. 6 © Babylon 2022 Previous solutions at Babylon Kafka Streams Java & Scala Stream processing Kafka Client Libs Java, Scala, Python, Ruby Simple stream consumers and producers Faust Python Stream processing Customise it Run on Kubernetes as Deployment Choose a microservice template
- 6. 7 © Babylon 2022 Use Cases Enrich | Code Mapping Requires: ● Internal API request Infer | Risk Prediction Requires: ● Internal API request ● Complex Logic ● Python Libraries Alert | Early Detection Alerts Requires: ● Internal API request ● Complex Logic ● Python Libraries ● External API request ● Internal State (for debounce) Enrich Infer Alert Patient Clinician Health Graph** **Despite the name, Babylon’s Health Graph is stream-first, graph-second!
- 7. 8 © Babylon 2022 Evaluating OOTB solutions against our use cases SQL Stream Processors But we need: ● Complex logic ● Client libraries/packages ● To make API calls Existing FaaS with stream triggers But we need: ● Batching ● Windowing ● Stream-based State Stores Flink StateFun But we did not need: ● Overhead of deploying and managing a Flink cluster ● Cost and inefficiency of running everything on the JVM
- 8. 9 © Babylon 2022 Our Solution | Health Graph Functions class Context(BaseContext ): terminology_client: AsyncRESTClientContext async def code_mapping_function ( key: DFHIRKey, value: DFHIRValue, metadata: EventMetadata, context: Context, ) -> t.Dict[ str, t.List[Event]]: ... mapped_codes = context.terminology_client.post({“codes”: value.codes}) ... return { “conditions” : condition_events, “labs”: labs_events, } agents: CodeMapping: enabled: true function: code_mapping.code_mapper version: latest error_handling: BLOCK store: S3 input_topic: name: domainevent.redox-cq-integration.clinical-summary output_topics: condition: name: dfhir.reportedcondition.v1 labs: name: dfhir.labs.v1 context: terminology_client: url: '{{ services }}/fast-ct/codeableconcept/convert' auth: default
- 9. 10 © Babylon 2022 What does it look like? Code Mapping class Context(BaseContext): terminology_client: AsyncRESTClientContext async def code_mapping_function ( key: DFHIRKey, value: DFHIRValue, metadata: EventMetadata, context: Context, ) -> t.Dict[str, t.List[Event]]: ... mapped_codes = context.terminology_client.post({“codes”: value.codes}) ... return { “conditions” : condition_events, “labs”: labs_events, } Auto-injected client. Highly configurable.
- 10. 11 © Babylon 2022 agents: CodeMapping: enabled: true function: code_mapping.code_mapper version: latest error_handling: BLOCK store: S3 input_topic: name: domainevent.redox-cq-integration.clinical-summary output_topics: condition: name: dfhir.reportedcondition.v1 labs: name: dfhir.labs.v1 context: terminology_client: url: '{{ services }}/fast-ct/codeableconcept/convert' auth: default How the client is configured. An “Agent” in this context is a configured instance of a function (enables us to run the same function with different configurations). What does it look like? Code Mapping
- 11. 12 © Babylon 2022 class Thresholds(BaseModel): high: float medium: float class Context(BaseContext): thresholds: Thresholds model_version: SemanticVersion healthIQ_client: AsyncRESTClientContext async def risk_prediction_function ( key: DFHIRKey, value: DFHIRValue, metadata: EventMetadata, context: Context, ) -> t.Dict[str, t.List[Event]]: ... mapped_codes = context.terminology_client.post({“codes”: value.codes}) ... return {“predictions”: predictions} Custom contexts can be extended with your own models. Everything is typed/validated with pydantic. This one is simple but they can be super powerful if required! What does it look like? Risk Prediction
- 12. 13 © Babylon 2022 agents: AcuityScore: ... # skip some things for brevity context: model_version: “1.9.1” thresholds: high: 0.042 medium: 0.0138 healthIQ_client: url: '{{ services }}/pottery/healthIQ' auth: default output_topics: predictions: name: dfhir.riskassessment.v1 Holds the configuration for the thresholds part of the custom context What does it look like? Risk Prediction
- 13. 14 © Babylon 2022 agents: AcuityScore: ... # skip some things for brevity context: model_version: “1.9.1” ... output_topics: predictions: name: dfhir.riskassessment.v1 ShadowAcuityScore: ... # skip some things for brevity context: model_version: “2.0.0alpha” output_topics: predictions: name: shadow.dfhir.riskassessment.v1 This allows us to do trivial “shadow deployments” of ML models. We can run the new model on live data but the predictions will go to a separate stream for evaluation. (This is why we don’t reference topics directly in functions). What does it look like? Risk Prediction
- 14. 15 © Babylon 2022 class Context(BaseContext): graphql_client: AsyncGraphQLClientContext notification_client: AsyncRESTClientContext debounce_table: TableContext debounce_days: float # IRL there’s lots more here! async def early_detection_function ( key: NotificationKey, value: NotificationValue, metadata: EventMetadata, context: Context, ) -> t.Dict[str, t.List[Event]]: last_alerted_subject = (time.now()- context.debounce_table[key.subject.id].time) ... if last_alerted_subject < timedelta(days=debounce_days): return {“early_detection_alert_skipped” : alert_event} return {“early_detection” : alert_event} You can have multiple clients if you want. And stream-backed state stores. We means we can avoid sending unnecessary alerts! (We do still return an event in case we want those to be saved for auditing) What does it look like? Early Detection
- 15. 16 © Babylon 2022 agents: EarlyDetection: ... # skip some things for brevity context: graphql_client: {} notification_client: url: {{ urls.trigger_workflow }} auth: type: oauth url: {{ workflow.auth.url }} id: {{ workflow.auth.id }} secret: {{ workflow.auth.id }} debounce_table: settings: name: debounce-subject debounce_days: 10 Defaults for some clients for simplicity (this is our federated GraphQL API). Multiple configurable auth flows. Stream-backed state store settings. What does it look like? Early Detection
- 16. 17 © Babylon 2022 What else? Other features Auto-generated Agent Configuration UI async def window_function (events: t.Sequence[Events], context: Context): --- batching: size: 200 timeout: 2 Windowing and batching # define and configure input event generators and expected output assertions # these can be defined inline and will be continuously tested in live environments Built-in Test Harnesses
- 17. 18 © Babylon 2022 What’s under the hood? Agent Configuration Code Storage UI (ClickOps) or CI (GitOps) Code Config
- 18. 19 © Babylon 2022 Code Storage What’s under the hood? Health Graph Functions Operator … Agent Configuration UI (ClickOps) or CI (GitOps) Health Graph Functions Instance … Listens, scales and configures
- 19. 20 © Babylon 2022 Code Storage What’s under the hood? Health Graph Functions Operator … Agent Configuration UI (ClickOps) or CI (GitOps) Fetches Processes Health Graph Functions Instance …
- 20. 21 © Babylon 2022 Code Storage What’s under the hood? Health Graph Functions Operator … Agent Configuration UI (ClickOps) or CI (GitOps) Fetches Processes Health Graph Functions Instance … uses Faust uses @kopf
- 21. Did you know we’re hiring? Want to join a global organization? Do you believe in Babylon’s mission to bring affordable and accessible healthcare to every human on earth? We’re looking for exceptional talent across the technology organization. Check out our Career Site to find your next opportunity with Babylon. babylonhealth.com/careers/technology
- 22. Thank you © 2022 Babylon Inc. All rights reserved. Thank you © Babylon 2022