Adding demo files

Logic_Demo.py

@@ -0,0 +1,154 @@
+import pandas as pd
+import json
+import streamlit as st
+
+import shared_streamlit_funcs as my
+
+if "ld_num_ss_inputs" not in st.session_state:
+    st.session_state["ld_num_ss_inputs"] = 1
+
+def increment_ss_inputs():
+    st.session_state.ld_num_ss_inputs += 1
+def decrement_ss_inputs():
+    st.session_state.ld_num_ss_inputs = max(1, st.session_state.ld_num_ss_inputs-1)
+
+def short_cg(cg):
+    return {"Teaching, Guidance, and Counseling":"Teaching...",
+            "Case Management":"Case Mngmnt",
+            "Surveillance":"Surveillance",
+            "Treatments and Procedures":"Treatments..."}[cg]
+
+def json_to_output_df(json_str, input_list):
+    indata =json.loads(json_str)
+    outdata = {"Output":[""]*len(input_list), "Explanation":[""]*len(input_list)}
+    # Format is: {<op-name>:{output:[{associated-item:{...}}], explanation:{tested-features:{...}}}}
+    haserr = False
+    
+    try:
+        # Process output for each op type
+        for opname,opdata in indata.items():
+            # Process output for each input
+            for response in opdata:
+                # Process the output and explanation
+                if "explanation" not in response or "output" not in response:
+                    continue
+                ss_ind = input_list.index(response["explanation"]["tested-features"]["member-data"]["sign-symptom"][0])
+                outdata["Explanation"][ss_ind] = json.dumps(response["explanation"]["tested-features"]["member-data"])
+                outdata["Output"][ss_ind] = json.dumps(response["output"][0]["associated-item"])
+    except Exception as e:
+        print("ERROR in LogicDemo json_to_output_df(): "+str(e))
+        haserr = True
+
+    if haserr:
+        retval = pd.DataFrame()
+    else:
+        retval = pd.DataFrame(data=outdata)
+    
+    print(retval)
+    return retval
+
+
+# Initialize the session
+if "agent" not in st.session_state:
+    my.init()
+
+## SET UP STREAMLIT PAGE
+# emojis: https://www.webfx.com/tools/emoji-cheat-sheet/
+st.set_page_config(page_title="🧠CRL Demo", layout="wide")
+st.subheader("Cognitive Reasoner Lite Demo")
+st.title("Generalized Rule Logic")
+st.markdown("**Demonstrates teaching the agent a single rule that lets it respond to many inputs.**")
+
+
+## Define S/S and intervention concepts
+ss_list = [
+    "Decreased Bowel Sounds",
+    "Difficulty Providing Preventive and Therapeutic Health Care",
+    "Limited Recall of Long Past Events",
+    "Infection",
+    "Heartburn/Belching/Indigestion",
+    "Electrolyte Imbalance",
+    "Difficulty Expressing Grief Responses",
+    "Absent/Abnormal Response To Sound",
+    "Minimal Shared Activities"
+]
+intvn_list = [
+    ("Teaching, Guidance, and Counseling","Anatomy/Physiology","bowel function"),
+    ("Case Management","Other Community Resources","long term care options"),
+    ("Teaching, Guidance, and Counseling","Continuity of Care","simplified routine"),
+    ("Teaching, Guidance, and Counseling","Wellness","prevention of infection/sepsis"),
+    ("Surveillance","Signs/Symptoms-Physical","epigastric / heartburn pain or discomfort"),
+    ("Surveillance","Signs/Symptoms-Physical","intake and output"),
+    ("Case Management","Support Group","age/cultural/condition-specific groups"),
+    ("Teaching, Guidance, and Counseling","Signs/Symptoms-Physical","increased hearing loss/other changes"),
+    ("Teaching, Guidance, and Counseling","Behavioral Health Care","therapy to strengthen family support systems"),
+]
+
+# Reset the agent before defining and linking concepts
+agent_config = my.make_agent()
+
+# Allow the user to choose how to map S/Ss to Interventions
+st.header("Training:")
+st.subheader("How do you want the agent to map symptoms to interventions?")
+
+map_xpnd = st.expander(label="Mappings",expanded=True)
+
+row = map_xpnd.container()
+map_col1, map_col2 = row.columns(2)
+map_col1.subheader("Symptom")
+map_col2.subheader("Intervention")
+intvn_labels = [short_cg(cg)+"; "+tg+"; "+cd for (cg, tg, cd) in intvn_list]
+# cd_list = [list(t) for t in zip(*intvn_list)][-1]   # Transpose the list of tuples and convert to a list and get just the last list
+for ind,ss in enumerate(ss_list):
+    row = map_xpnd.container()
+    map_col1, map_col2 = row.columns(2)
+    map_col1.text(ss)
+    intvn_select = map_col2.selectbox(label="Maps to Intervention:",options=range(len(intvn_labels)),index=ind, key="mapbox-"+str(ind), format_func=lambda x: intvn_labels[x])
+    # Tell the agent to associate this S/S with this intvn
+    ss_concept = st.session_state.agent.getConcept("{'member-data':{'sign-symptom':'"+ss+"'}}")
+    cg,tg,cd = intvn_list[intvn_select]
+    intvn_concept = st.session_state.agent.getConcept("{'intervention':{'category':'"+cg+"','target':'"+tg+"','care-descriptor':'"+cd+"'}}")
+    st.session_state.agent.linkConcepts(agent_config.decisionTypeId, "SS-INTVN", ss_concept, intvn_concept)
+
+st.subheader("What do you want the agent to report?")
+select_report_attr = st.selectbox(label="Intervention element", options=["Category","Target","Care Descriptor", "All"], index=1)
+report_attr = {"Category":"category", "Target":"target", "Care Descriptor":"care-descriptor", "All":""}[select_report_attr]
+
+# Define action behavior to report result (triggered as soon as the intervention concept is active in WM)
+# Report just the active 'target-id' elements of the intervention associated with the matched condition
+intvn_conc = st.session_state.agent.getConcept("{'intervention':null}")
+st.session_state.agent.trainAction(agent_config, intvn_conc, my.ReportActiveConceptActionInList("associated-item", report_attr))
+
+st.markdown("---")
+st.header("Input:")
+st.subheader("Choose a request to send to the agent.")
+
+ss_input_select_list = [st.selectbox(label="Signs/Symptom:", options=ss_list, index=i, key="ss_in-"+str(i)) for i in range(st.session_state.ld_num_ss_inputs)]
+in_col1, in_col2 = st.columns(16)[0:2]
+in_col1.button(label="+", on_click=increment_ss_inputs)
+in_col2.button(label="–", on_click=decrement_ss_inputs) # em: —, en: –
+
+
+# Send a partial pattern to the agent's input
+st.session_state.agent.clearInput()
+for select in ss_input_select_list:
+    st.session_state.agent.addInput("{'member-data':{'sign-symptom':'"+select+"'}}")
+
+
+st.markdown("---")
+st.header("Agent Output:")
+# Show the input to the user
+io_col1, io_col2 = st.columns(2)
+io_col1.text("Input sent to agent:")
+io_col1.dataframe(data={'Signs/Symptoms':ss_input_select_list})
+io_col1.text_area(label="Raw JSON Input", value=st.session_state.agent.getInputAsJsonString(), height=200)
+
+# Run the agent with the given input to get a corresponding memory
+st.session_state.agent.setMaxOpCycles(-1)
+st.session_state.agent.queryDecision(agent_config.decisionTypeId, 5)
+
+output = st.session_state.agent.getOutputAsJsonString()
+query_time_ms = st.session_state.agent.getLastQueryTime()/1000000.0
+io_col2.text("Agent Response: ("+str(query_time_ms)+" ms)")
+io_col2.dataframe(data=json_to_output_df(output, ss_input_select_list),)
+io_col2.text_area(label="Raw JSON Output:",value=output, height=500)

README.md

@@ -1,6 +1,6 @@
 ---
-title: Crl Demo
-emoji: 🐠
+title: Cognitive Reasoner Lite - Demo
+emoji: 🧠
 colorFrom: purple
 colorTo: red
 sdk: docker

pages/Episode_Recall_Demo.py

@@ -0,0 +1,137 @@
+import pandas as pd
+import json
+import random
+import streamlit as st
+
+import shared_streamlit_funcs as my
+
+
+def generate_episodes(num_channels=10, num_quantities=10, num_latencies=6, records_per_channel=3):
+    # Generate random episodes as combinations of the above concept elements
+    # and store them in a table for display
+
+    # Define the possible inputs for the agent
+    st.session_state["channels_list"] = ['acme-'+str(n+1) for n in range(num_channels)]
+    st.session_state["quantities_list"] = [str(int(pow(10,n))) for n in range(num_quantities)]
+    st.session_state["latencies_list"] = list(['8h','12h'])
+    st.session_state["latencies_list"].extend([str(n*24)+"h" for n in range(1,num_latencies-1)])
+
+    channels_column = []
+    quantities_column = []
+    latencies_column = []
+    for channel in st.session_state.channels_list:
+        # Get 3 random quantity:latency pairs
+        ch_quantities = []
+        for _ in range(records_per_channel):
+            q = None
+            while True:
+                q = random.choice(st.session_state.quantities_list)
+                if q not in ch_quantities:
+                    break
+            ch_quantities.append(q)
+        # Add a row with this channel and each quantity with a random latency
+        for q in ch_quantities:
+            channels_column.append(channel)
+            quantities_column.append(q)
+            latencies_column.append(random.choice(st.session_state.latencies_list))
+    
+    # Remake the agent as a quick way of resetting its episodic memory
+    my.make_agent()
+
+    # Define the input concepts for this agent
+    st.session_state["channel_concept_map"] = {channel: st.session_state.agent.getConcept("{'request':{'channel':'"+channel+"'}}") for channel in st.session_state.channels_list}
+    st.session_state["quantity_concept_map"] = {quantity: st.session_state.agent.getConcept("{'request':{'quantity':'"+quantity+"'}}") for quantity in st.session_state.quantities_list}
+    st.session_state["latency_concept_map"] = {latency: st.session_state.agent.getConcept("{'request':{'latency':'"+latency+"'}}") for latency in st.session_state.latencies_list}
+
+    # Send each row in the table to the agent as an episode of experience
+    for (channel, quantity, latency) in zip(channels_column,quantities_column,latencies_column):
+        inList = st.session_state.Java_ArrayList()
+        inList.add(st.session_state.channel_concept_map[channel])
+        inList.add(st.session_state.quantity_concept_map[quantity])
+        inList.add(st.session_state.latency_concept_map[latency])
+        st.session_state.agent.trainEpisode(inList)
+
+    # Compile the dataframe from these columns
+    st.session_state["er_df"] = pd.DataFrame(data={'Channel':channels_column, 
+                                                'Quantity':quantities_column, 
+                                                'Latency':latencies_column})
+    st.session_state.er_df.sort_values(['Channel', 'Quantity'], ascending=[True, True], inplace=True)
+
+def json_to_output_df(json_str):
+    data =json.loads(json_str)
+    haserr = False
+    if 'channel' not in data or 'quantity' not in data or 'latency' not in data:
+        haserr = True
+        print("** Missing expected data from agent output.")
+    
+    if not haserr:
+        retval = pd.DataFrame(data={'Channel':data['channel'], 
+                                    'Quantity':data['quantity'],
+                                    'Latency':data['latency']})
+    else:
+        retval = pd.DataFrame()
+    
+    return retval
+
+# Initialize the session
+if "agent" not in st.session_state:
+    my.init()
+
+if "er_df" not in st.session_state:
+    generate_episodes()
+
+## SET UP STREAMLIT PAGE
+# emojis: https://www.webfx.com/tools/emoji-cheat-sheet/
+st.set_page_config(page_title="🧠CRL Demo", layout="centered")
+st.subheader("Cognitive Reasoner Lite Demo")
+st.title("Episodic Recall")
+st.markdown("**Demonstrates automatic recall of prior experiences given a partial prompt.**")
+
+st.header("Episodes shown to the agent:")
+st.markdown("*(randomly generated)*")
+
+eps_col1, eps_col2 = st.columns(2)
+eps_col1.dataframe(st.session_state.er_df)
+eps_col1.text("Number of rows: "+str(len(st.session_state.er_df)))
+
+epgen_cha_count = eps_col2.number_input(label="Number of Channels", min_value=1, value=10)
+epgen_qua_count = eps_col2.number_input(label="Number of Quantities", min_value=1, value=6)
+epgen_lat_count = eps_col2.number_input(label="Number of Latencies", min_value=1, value=6)
+epgen_recs_per_channel = eps_col2.number_input(label="Records per Channel", min_value=1, max_value=int(epgen_qua_count), value=3)
+
+if eps_col2.button("Regenerate Episodes"):
+    generate_episodes(epgen_cha_count, epgen_qua_count, epgen_lat_count, epgen_recs_per_channel)
+    st.experimental_rerun()
+
+
+st.markdown("---")
+st.header("Input:")
+st.subheader("This will be shown to the agent.")
+select_col1, select_col2 = st.columns(2)
+channel_select = select_col1.selectbox(label="Query Channel:", options=st.session_state.channels_list)
+quantity_select = select_col2.selectbox(label="Query Quanity:", options=st.session_state.quantities_list)
+
+# Send a partial pattern to the agent's input
+st.session_state.agent.clearInput()
+st.session_state.agent.addInput("{'request':{'channel':'"+channel_select+"', 'quantity':'"+str(quantity_select)+"'}}")
+# st.session_state.agent.addInput("{'request':{'channel':'acme-1', 'quantity':'100'}}")
+
+
+st.markdown("---")
+st.header("Agent Output:")
+# Show the input to the user
+io_col1, io_col2 = st.columns(2)
+io_col1.text("Input sent to agent:")
+io_col1.dataframe(data={'Channel':[channel_select], 
+                        'Quantity':[quantity_select]})
+io_col1.text_area(label="Raw JSON Input", value=st.session_state.agent.getInputAsJsonString(), height=200)
+
+# Run the agent with the given input to get a corresponding memory
+st.session_state.agent.setMaxOpCycles(1)    # FIXME: Why can so many episodes get recalled?
+st.session_state.agent.queryPatternCompletion()
+
+output = st.session_state.agent.getOutputAsJsonString()
+query_time_ms = st.session_state.agent.getLastQueryTime()/1000000.0
+io_col2.text("Agent Response: ("+str(query_time_ms)+" ms)")
+io_col2.dataframe(data=json_to_output_df(output))
+io_col2.text_area(label="Raw JSON Output:",value=output, height=300)

shared_streamlit_funcs.py

@@ -0,0 +1,41 @@
+from distutils.command.config import config
+import streamlit as st
+
+import jnius_config
+if not jnius_config.vm_running:
+    jnius_config.set_classpath("/Users/bstearn1/Documents/Projects/OptumGitHub/bstearn1/CognitiveReasonerLite/CognitiveReasonerLite.jar")
+from jnius import autoclass                 # For running Java. See https://pyjnius.readthedocs.io/en/latest/ for documentation.
+
+
+CRL_PACKAGE = "com.optum.cogtech.crl."
+
+def make_agent(config_name="agent_demo"):
+    # Start the CRL engine
+    st.session_state["agent"] = st.session_state.Java_Agent()
+    # Configure the decision making
+    decConfig = st.session_state.Java_DecisionConfig(config_name)
+    decConfig.selectAll()
+    st.session_state.agent.addSettings(decConfig)
+    # Configure debug printing
+    # st.session_state.agent.logger.disable()
+    st.session_state.agent.logger.setWriteToFile(False)
+    st.session_state.agent.logger.setEnableLogCycles(True)
+    st.session_state.agent.logger.setEnableLogContexts(True)
+    st.session_state.agent.logger.setEnableLogOperators(True)
+    st.session_state.agent.logger.setEnableLogActivation(True)
+    return decConfig
+
+def init():
+    # Define the Java<->Python interface needed to run the CRL jar
+    st.session_state["Java_ArrayList"] = autoclass('java.util.ArrayList')
+    st.session_state["Java_Agent"] = autoclass(CRL_PACKAGE+"Agent")
+    st.session_state["Java_DecisionConfig"] = autoclass(CRL_PACKAGE+"DecisionConfig")
+    st.session_state["Java_Concept"] = autoclass(CRL_PACKAGE+"Concept")
+    st.session_state["Java_ActionReportActiveConcept"] = autoclass(CRL_PACKAGE+"ActionReportActiveConcept")
+
+    make_agent()
+
+def ReportActiveConceptActionInList(outputAttribute, attributeForReportValue):
+    collection = st.session_state.Java_ArrayList()
+    collection.add(st.session_state.Java_ActionReportActiveConcept(outputAttribute, attributeForReportValue))
+    return collection