add file

home.py

@@ -0,0 +1,141 @@
+"""
+These are the meta data and instructions
+Author: Anniek Jansen
+Course: Human AI interaction
+
+Instructions:
+(For Anniek: conda activate py (activate local environment where the right packages are installed))
+1. Pip install streamlit, oocsi in your python environment
+2. Save this file somewhere on your computer
+3. In the command line, cd to where your file is: "cd/...../folder
+
+4. To run it: streamlit run home.py 
+5. Click on the link it provides you
+6. You need to click sometimes rerun in the website
+
+
+To hide menu: copy paste this in config.toml
+[ui]
+hideSidebarNav = true
+
+"""
+
+
+import streamlit as st
+import pandas as pd
+# from oocsi import __init__ as OOCSI
+from oocsi_source import OOCSI
+from uuid import uuid4
+from streamlit_extras.switch_page_button import switch_page
+import requests
+import json
+
+
+
+
+# Check if 'participantID' already exists in session_state
+# If not, then initialize it
+if 'participantID' not in st.session_state:
+    st.session_state.participantID= "P" + uuid4().__str__().replace('-', '')[0:10]
+    st.session_state.pages =['SHAP', 'DecisionTree', 'counterfactual', 'visualMap']
+    st.session_state.profileIndices=[25,112]
+
+if 'oocsi' not in st.session_state:
+    st.session_state.oocsi = OOCSI('','oocsi.id.tue.nl')
+
+
+# st.write(st.session_state.participantID)
+
+st.set_page_config(page_title="XAI research", layout="wide")
+
+header1, header2, header3 = st.columns([1,2,1])
+consent_form1, consent_form2, consent_form3 = st.columns([1,4,1])
+
+# with header2:
+    # st.title("Consent form")
+    # st.write("For debugging:")
+    # st.write(st.session_state.participantID)
+
+with consent_form2:
+    st.header('Information form for participants')
+    st.write('''Hello and thank you for taking the time to participate in this survey.''')
+    st.write('''This document gives you information about the study Comparing Explainable AI (XAI) methods. Before the study begins, it is important that you learn about the procedure followed in this study and that you give your informed consent for voluntary participation. Please read this document carefully.  ''')
+    
+    st.subheader('Aim and benefit of the study')
+    st.write('''The aim of this study is to measure the satisfaction of users with different types of XAI methods. 
+    This information is used to have better understandable/ more satisfying type of explanations in future application.  ''')
+    st.write('''This study is performed by Rachel Wang, François Leborgne and Anniek Jansen, all EngD trainees of the Designing Human-System Interaction program and for this course under the supervision of Chao Zhang of the Human-Technology Interaction group.''')
+    
+    st.subheader('Procedure')
+    st.markdown('''During this project we ask you to: 
+-	Look at different predictions from an AI model (predicting the survival of passengers of the titanic)
+-	Complete a survey at the start of the study with demographic information
+-	Complete a short survey (8 questions) for four types of explanation method
+-	Complete a survey in the end to compare the explanation methods and explain why certain methods had your preference.
+''')
+    
+    st.subheader('Risks')
+    st.markdown("The study does not involve any risks, detrimental side effects, or cause discomfort.")
+
+    st.subheader("Duration")
+    st.markdown("The instructions, measurements and debriefing will take approximately 15 minutes.")
+
+    st.subheader("Voluntary")
+    st.markdown('''Your participation is completely voluntary. You can refuse to participate without giving any reasons and you can stop your participation at any time during the study. You can also withdraw your permission to use your data immediately after completing the study. None of this will have any negative consequences for you whatsoever.''')
+
+    st.subheader("Confidentiality and use, storage, and sharing of data")
+    st.markdown('''
+     All research conducted at the Human-Technology Interaction Group adheres to the Code of Ethics of the NIP (Nederlands Instituut voor Psychologen – Dutch Institute for Psychologists), and this study has been approved by the Ethical Review Board of the department. 
+
+    In this study demographic data (gender, age, education level, highest level of education, data literacy, AI expertise), experimental data (response to questionnaires and duration of experiment) will be recorded, analyzed, and stored. The goal of collecting, analyzing, and storing this data is to answer the research question and publish the results in the scientific literature. To protect your privacy, all data that can be used to personally identify you will be stored on an encrypted server of the Human Technology Interaction group for at least 10 years that is only accessible by selected HTI staff members. No information that can be used to personally identify you will be shared with others. 
+
+    During the study, the data will be stored on encrypted laptops and DataFoundry  - a platform developed by the department of Industrial Design at TU/e and is GDPR compliant. After the analyses, the data will also be made available on OSF (open science framework, a place to share research data open source).  
+
+    The data collected in this study might also be of relevance for future research projects within the Human Technology Interaction group as well as for other researchers. The aim of those studies might be unrelated to the goals of this study. 
+    The collected data will therefore also be made available to the general public in an online data repository.
+    The coded data collected in this study and that will be released to the public will (to the best of our knowledge and ability) not contain information that can identify you. It will include all answers you provide during the study, including demographic variables (e.g., age and gender) if you choose to provide these during the study. 
+
+    At the bottom of this consent form, you can indicate whether or not you agree with participation in this study. You can also indicate whether you agree with the distribution of your data by means of a secured online data repository with open access for the general public and the distribution of your data by means of a secured online data repository with open access for the general public. You are not obliged to letting us use and share your data. If you are not willing to share your data in this way, you can still participate in this study. Your data will be used in the scientific article but not shared with other researchers.
+
+    No video or audio recordings are made that could identify you.
+    
+    ''')
+        
+    st.subheader("Further information")
+    st.markdown('''If you want more information about this study, the study design, or the results, you can contact Anniek Jansen (contact email: [email protected] ). 
+    If you have any complaints about this study, please contact the supervisor, Chao Zhang ([email protected])  You can report irregularities related to scientific integrity to confidential advisors of the TU/e.
+    ''')
+
+    st.subheader("Informed consent form")
+    st.markdown('''
+    -   I am 18 years or older
+    -	I have read and understood the information of the corresponding information form for participants. 
+    -	I have been given the opportunity to ask questions. My questions are sufficiently answered, and I had sufficient time to decide whether I participate. 
+    -	I know that my participation is completely voluntary. I know that I can refuse to participate and that I can stop my participation at any time during the study, without giving any reasons. I know that I can withdraw permission to use my data directly after the experiment.
+    -	I agree to voluntarily participate in this study carried out by the research group Human Technology Interaction and Industrial Design of the Eindhoven University of Technology.
+    -	I know that no information that can be used to personally identify me or my responses in this study will be shared with anyone outside of the research team.
+    ''')
+
+    OSF= st.radio("I ... (please select below) give permission to make my anonymized recorded data available to others in a public online data repository, and allow others to use this data for future research projects unrelated to this study.",
+                         ('do', 
+                              'do not'))
+
+    st.subheader("Consent")
+    agree = st.checkbox('I consent to processing my personal data gathered during the research in the way described in the information sheet.')
+
+    consentforOSF =""
+    if OSF =='do': 
+        consentforOSF='yes'
+    else:
+        consentforOSF='no'
+
+    if agree:
+     
+        st.write('Thank you! Please continue to the next page to start the experiment')
+        if st.button("Next page"):
+            st.session_state.oocsi.send('EngD_HAII_consent', {
+            'participant_ID': st.session_state.participantID,
+            'consent': 'yes',
+            'consentForOSF': consentforOSF
+            })
+            switch_page("explanationpage")

oocsi_source.py

@@ -0,0 +1,438 @@
+# Copyright (c) 2017-2022 Mathias Funk
+# This software is released under the MIT License.
+# http://opensource.org/licenses/mit-license.php
+
+import json
+import socket
+import threading
+import atexit
+import time
+import uuid
+from math import fsum
+
+class OOCSI:
+    def __init__(self, handle=None, host='localhost', port=4444, callback=None, logger=None, maxReconnectionAttempts=100000):
+        if handle is None or len(handle.strip()) == 0:
+            self.handle = "OOCSIClient_" + uuid.uuid4().__str__().replace('-', '')[0:15];
+        else:
+            self.handle = handle
+            
+        self.receivers = {self.handle: [callback]}
+        self.calls = {}
+        self.services = {}
+        self.reconnect = True
+        self.maxReconnects = maxReconnectionAttempts
+        self.connected = False
+        if logger is not None:
+            self.log = logger
+        
+        # Connect the socket to the port where the server is listening
+        self.server_address = (host, port)
+        self.log('connecting to %s port %s' % self.server_address)
+        
+        # start the connection
+        # (block till we are connected or connection error/timeout)
+        if not self.connect():
+            self.log('Initial OOCSI connection failed')
+            raise OOCSIDisconnect('OOCSI has not been found')
+        
+        # start the connection thread        
+        self.runtime = OOCSIThread(self)
+        self.runtime.start()
+
+    def connect(self):
+        connectionSuccessful = False
+        try:
+            # Create a TCP/IP socket        
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            self.sock.connect(self.server_address)
+            self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            
+            try:
+                # Send data
+                message = self.handle + '(JSON)'
+                self.internalSend(message)
+            
+                data = self.sock.recv(1024).decode()
+                if data.startswith('{'):  
+                    connectionSuccessful = True
+                    self.log('connection established')
+                    # re-subscribe for channels
+                    for channelName in self.receivers:
+                        self.internalSend('subscribe {0}'.format(channelName))
+                    self.connected = True
+                elif data.startswith('error'):
+                    self.log(data)
+                    self.reconnect = False
+            finally:
+                pass
+        except: 
+            pass
+        return connectionSuccessful
+    
+    def __enter__(self):
+        return self
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.stop()
+
+    def log(self, message):
+        print('[{0}]: {1}'.format(self.handle, message))
+        
+    def internalSend(self, msg):
+        try:
+            self.sock.sendall((msg + '\n').encode())
+        except:
+            self.connected = False
+
+    def loop(self):
+        try:
+            data = self.sock.recv(4 * 1024 * 1024).decode()
+            lines = data.split("\n")
+            for line in lines:
+                if len(data) == 0:
+                    self.sock.close()
+                    self.connected = False
+                elif line.startswith('ping') or line.startswith('.'):
+                    self.internalSend('.')
+                elif line.startswith('{'):
+                    self.receive(json.loads(line))
+        except:
+            pass
+
+    def receive(self, event):
+        sender = event['sender']
+        recipient = event['recipient']
+        
+        # clean up the event
+        del event['recipient']
+        del event['sender']
+        del event['timestamp']
+        if 'data' in event:
+            del event['data']
+        
+        if '_MESSAGE_HANDLE' in event and event['_MESSAGE_HANDLE'] in self.services:
+            service = self.services[event['_MESSAGE_HANDLE']]
+            del event['_MESSAGE_HANDLE']
+            service(event)
+            self.send(sender, event)
+            self.receiveChannelEvent(sender, recipient, event)
+        
+        else:
+            if '_MESSAGE_ID' in event:
+                myCall = self.calls[event['_MESSAGE_ID']]
+                if myCall['expiration'] > time.time():
+                    response = self.calls[event['_MESSAGE_ID']]
+                    response['response'] = event
+                    del response['expiration']
+                    del response['_MESSAGE_ID']
+                    del response['response']['_MESSAGE_ID']
+                else:
+                    del self.calls[event['_MESSAGE_ID']]
+                    
+            else:
+                self.receiveChannelEvent(sender, recipient, event)
+
+    def receiveChannelEvent(self, sender, recipient, event):
+        if recipient in self.receivers and self.receivers[recipient] != None:
+            for x in self.receivers[recipient]:
+                x(sender, recipient, event)
+
+    def send(self, channelName, data):
+        self.internalSend('sendraw {0} {1}'.format(channelName, json.dumps(data)))
+
+    def call(self, channelName, callName, data, timeout = 1):
+        data['_MESSAGE_HANDLE'] = callName 
+        data['_MESSAGE_ID'] = uuid.uuid4().__str__()
+        self.calls[data['_MESSAGE_ID']] = {'_MESSAGE_HANDLE': callName, '_MESSAGE_ID': data['_MESSAGE_ID'], 'expiration': time.time() + timeout}
+        self.send(channelName, data)
+        return self.calls[data['_MESSAGE_ID']]
+        
+
+    def callAndWait(self, channelName, callName, data, timeout = 1):
+        call = self.call(channelName, callName, data, timeout)
+        expiration = time.time() + timeout
+        while time.time() < expiration:
+            time.sleep(0.1)
+            if 'response' in call:
+                break;
+            #         self.calls.append
+        return call
+
+    def register(self, channelName, callName, callback):
+        self.services[callName] = callback
+        self.internalSend('subscribe {0}'.format(channelName))
+        self.log('registered responder on {0} for {1}'.format(channelName, callName))
+
+    def subscribe(self, channelName, f):
+        if channelName in self.receivers:
+            self.receivers[channelName].append(f)
+        else:
+            self.receivers[channelName] = [f]
+        self.internalSend('subscribe {0}'.format(channelName))
+        self.log('subscribed to {0}'.format(channelName))
+    
+    def unsubscribe(self, channelName):
+        del self.receivers[channelName]
+        self.internalSend('unsubscribe {0}'.format(channelName))
+        self.log('unsubscribed from {0}'.format(channelName))
+
+    def variable(self, channelName, key):
+        return OOCSIVariable(self, channelName, key)
+
+    def stop(self):
+        self.reconnect = False
+        self.internalSend('quit')
+        self.sock.close()
+        self.connected = False
+
+    def handleEvent(self, sender, receiver, message):
+        {}
+
+    def returnHandle(self):
+        return self.handle
+
+    def heyOOCSI(self, custom_name=None):
+        if custom_name is None:
+            return (OOCSIDevice(self, self.handle))
+        else:
+            return (OOCSIDevice(self, custom_name))
+
+
+class OOCSIThread(threading.Thread):
+    def __init__(self, parent=None):
+        self.parent = parent
+        super(OOCSIThread, self).__init__()
+
+    def run(self):
+        
+        # register exit handler
+        atexit.register(self._stop)
+        
+        # run the established connection        
+        while self.parent.connected:
+            self.parent.loop()
+
+        # reconnect
+        if self.parent.reconnect:
+            failedConnectionAttempts = 0
+            while self.parent.reconnect:
+                self.parent.log('re-connecting to OOCSI')
+                if self.parent.connect():
+                    failedConnectionAttempts = 0
+                    while self.parent.connected:
+                        self.parent.loop()
+                else:
+                    failedConnectionAttempts += 1
+                time.sleep(5)
+                # raise exception after unsuccessful connection attempts
+                if failedConnectionAttempts == self.parent.maxReconnects:
+                    self.parent.log('OOCSI connection failed after 10 attempts')
+                    raise OOCSIDisconnect('OOCSI has not been found')
+
+        self.parent.log('closing connection to OOCSI')
+
+    def _stop(self):
+        self.parent.stop()
+        return threading.Thread._stop(self) 
+
+
+
+class OOCSIDisconnect(Exception):
+    pass
+
+
+
+class OOCSICall:
+    def __init__(self, parent=None):
+        self.uuid = uuid.uuid4()
+        self.expiration = time.time()
+
+
+
+class OOCSIVariable(object):
+    def __init__(self, oocsi, channelName, key):
+        self.key = key
+        self.channel = channelName
+        oocsi.subscribe(channelName, self.internalReceiveValue)
+        self.oocsi = oocsi
+        self.value = None 
+        self.windowLength = 0
+        self.values = []
+        self.minvalue = None
+        self.maxvalue = None
+        self.sigma = None
+
+    def get(self):
+        if self.windowLength > 0 and len(self.values) > 0:
+            return fsum(self.values)/float(len(self.values))
+        else:
+            return self.value
+
+    def set(self, value):
+        tempvalue = value
+        if not self.minvalue is None and tempvalue < self.minvalue:
+            tempvalue = self.minvalue
+        elif not self.maxvalue is None and tempvalue > self.maxvalue:
+            tempvalue = self.maxvalue
+        elif not self.sigma is None:
+            mean = self.get()
+            if not mean is None:
+                if abs(mean - tempvalue) > self.sigma:
+                    if mean - tempvalue > 0:
+                        tempvalue = mean - self.sigma/float(len(self.values)) 
+                    else:
+                        tempvalue = mean + self.sigma/float(len(self.values))
+
+        if self.windowLength > 0:
+            self.values.append(tempvalue)
+            self.values = self.values[-self.windowLength:]
+        else:
+            self.value = tempvalue
+        self.oocsi.send(self.channel, {self.key: value})
+
+    def internalReceiveValue(self, sender, recipient, data):
+        if self.key in data:
+            tempvalue = data[self.key]
+            if not self.minvalue is None and tempvalue < self.minvalue:
+                tempvalue = self.minvalue
+            elif not self.maxvalue is None and tempvalue > self.maxvalue:
+                tempvalue = self.maxvalue
+            elif not self.sigma is None:
+                mean = self.get()
+                if not mean is None:
+                    if abs(mean - tempvalue) > self.sigma:
+                        if mean - tempvalue > 0:
+                            tempvalue = mean - self.sigma/float(len(self.values))
+                        else:
+                            tempvalue = mean + self.sigma/float(len(self.values))
+
+            if self.windowLength > 0:
+                self.values.append(tempvalue)
+                self.values = self.values[-self.windowLength:]
+            else:
+                self.value = tempvalue
+
+    def min(self, minvalue):
+        self.minvalue = minvalue
+        if self.value < self.minvalue:
+            self.value = self.minvalue
+        return self
+        
+    def max(self, maxvalue):
+        self.maxvalue = maxvalue
+        if self.value > self.maxvalue:
+            self.value = self.maxvalue
+        return self
+    
+    def smooth(self, windowLength, sigma=None):
+        self.windowLength = windowLength
+        self.sigma = sigma
+        return self
+
+
+
+class OOCSIDevice():
+    def __init__(self, OOCSI, device_name:str) -> None:
+        self._device_name = device_name
+        self._device = {self._device_name:{}}
+        self._device[self._device_name]["properties"] = {}
+        self._device[self._device_name]["properties"]["device_id"] = OOCSI.returnHandle()
+        self._device[self._device_name]["components"] = {}
+        self._device[self._device_name]["location"] = {}
+        self._components = self._device[self._device_name]["components"]
+        self._oocsi=OOCSI
+        self._oocsi.log(f'Created device {self._device_name}.')
+
+    def addProperty(self, properties:str, propertyValue):
+        self._device[self._device_name]["properties"][properties] = propertyValue
+        self._oocsi.log(f'Added {properties} to the properties list of device {self._device_name}.')
+        return self
+    
+    def addLocation(self, location_name:str, latitude:float = 0, longitude:float = 0):
+        self._device[self._device_name]["location"][location_name] = [latitude, longitude]
+        self._oocsi.log(f'Added {location_name} to the locations list of device {self._device_name}.')
+        return self
+
+    def addSensor(self, sensor_name:str, sensor_channel:str, sensor_type:str, sensor_unit:str, sensor_default:float, mode:str = "auto", step:float = None, icon:str = None):
+        self._components[sensor_name]={}
+        self._components[sensor_name]["channel_name"] = sensor_channel
+        self._components[sensor_name]["type"] = "sensor"
+        self._components[sensor_name]["sensor_type"] = sensor_type
+        self._components[sensor_name]["unit"] = sensor_unit
+        self._components[sensor_name]["value"] = sensor_default
+        self._components[sensor_name]["mode"] = mode
+        self._components[sensor_name]["step"] = step
+        self._components[sensor_name]["icon"] = icon
+        self._device[self._device_name]["components"][sensor_name] = self._components[sensor_name]
+        self._oocsi.log(f'Added {sensor_name} to the components list of device {self._device_name}.')
+        return self
+
+    def addNumber(self, number_name:str, number_channel:str, number_min_max, number_unit:str, number_default:float, icon:str = None):
+        self._components[number_name]={}
+        self._components[number_name]["channel_name"] = number_channel
+        self._components[number_name]["min_max"]= number_min_max
+        self._components[number_name]["type"] = "number"
+        self._components[number_name]["unit"] = number_unit
+        self._components[number_name]["value"] = number_default
+        self._components[number_name]["icon"] = icon
+        self._device[self._device_name]["components"][number_name] = self._components[number_name]
+        self._oocsi.log(f'Added {number_name} to the components list of device {self._device_name}.')
+        return self
+
+    def addBinarySensor(self, sensor_name:str, sensor_channel:str, sensor_type:str, sensor_default:bool = False, icon:str = None):
+        self._components[sensor_name]={}
+        self._components[sensor_name]["channel_name"] = sensor_channel
+        self._components[sensor_name]["type"] = "binary_sensor"
+        self._components[sensor_name]["sensor_type"] = sensor_type
+        self._components[sensor_name]["state"] = sensor_default
+        self._components[sensor_name]["icon"] = icon
+        self._device[self._device_name]["components"][sensor_name] = self._components[sensor_name]
+        self._oocsi.log(f'Added {sensor_name} to the components list of device {self._device_name}.')
+        return self
+
+    def addSwitch(self, switch_name:str, switch_channel:str, switch_default:bool = False, icon:str = None):
+        self._components[switch_name]={}
+        self._components[switch_name]["channel_name"] = switch_channel
+        self._components[switch_name]["type"] = "switch"
+        self._components[switch_name]["state"] = switch_default
+        self._components[switch_name]["icon"] = icon
+        self._device[self._device_name]["components"][switch_name] = self._components[switch_name]
+        self._oocsi.log(f'Added {switch_name} to the components list of device {self._device_name}.')
+        return self
+
+    def addLight(self, light_name:str, light_channel:str, led_type:str, spectrum, light_default_state:bool = False, light_default_brightness:int = 0, mired_min_max = None, icon:str = None):
+        SPECTRUM = ["WHITE","CCT","RGB"]
+        LEDTYPE = ["RGB","RGBW","RGBWW","CCT","DIMMABLE","ONOFF"]
+
+        self._components[light_name]={}
+        if led_type in LEDTYPE:  
+            if spectrum in SPECTRUM:
+                self._components[light_name]["spectrum"] = spectrum
+            else:
+                self._oocsi.log(f'error, {light_name} spectrum does not exist.')
+                pass
+        else:
+            self._oocsi.log(f'error, {light_name} ledtype does not exist.')
+            pass
+
+        self._components[light_name]["channel_name"] = light_channel
+        self._components[light_name]["type"] = "light"
+        self._components[light_name]["ledType"] = led_type
+        self._components[light_name]["spectrum"] = spectrum
+        self._components[light_name]["min_max"]= mired_min_max
+        self._components[light_name]["state"] = light_default_state
+        self._components[light_name]["brightness"] = light_default_brightness
+        self._components[light_name]["icon"] = icon
+        self._device[self._device_name]["components"][light_name] = self._components[light_name]
+        self._oocsi.log(f'Added {light_name} to the components list of device {self._device_name}.')
+        return self
+    
+    def submit(self):
+        data = self._device
+        self._oocsi.internalSend('sendraw {0} {1}'.format("heyOOCSI!", json.dumps(data))) 
+        self._oocsi.log(f'Sent heyOOCSI! message for device {self._device_name}.')
+    
+    def sayHi(self):
+        self.submit()
+