First commit

Homepage.py

@@ -0,0 +1,59 @@
+import streamlit as st
+from PIL import Image
+import os
+
+if 'STREAMLIT_PRODUCTION' in os.environ:
+    # Running on Streamlit Sharing
+    with open('test.yml', 'r') as file:
+        environment = file.read()
+    with open('test_tmp.yml', 'w') as file:
+        file.write(environment.replace('prefix: /', ''))
+    os.system('conda env create -f test_tmp.yml')
+    os.system('source activate ./envs/$(head -1 test_tmp.yml | cut -d " " -f2)')
+
+
+st.set_page_config(
+    page_title="Homepage",
+    layout="wide"
+)
+
+# Create a text box
+#text_box = st.text_input("Enter some text:")
+
+# Create an expander to display additional information
+#with st.expander("More information"):
+#    st.write("This section contains additional information about the text box.")
+
+# Display the text box
+#st.write("You entered:", text_box)
+
+logo_ovgu_fin = Image.open('imgs/logo_ovgu_fin_en.jpg')
+st.image(logo_ovgu_fin)
+
+st.title("FairUP: a Framework for Fairness Analysis of Graph Neural Network-Based User Profiling Models 🚀")
+st.markdown("##### *Mohamed Abdelrazek, Erasmo Purificato, Ludovico Boratto, and Ernesto William De Luca*")
+
+st.markdown("## Description")
+st.markdown("""
+**FairUP** is a standardised framework that empowers researchers and practitioners to simultaneously analyse state-of-the-art Graph Neural Network-based models for user profiling task, in terms of classification performance and fairness metrics scores.
+
+The framework, whose architecture is shown below, presents several components, which allow end-users to:
+* compute the fairness of the input dataset by means of a pre-processing fairness metric, i.e. *disparate impact*;
+* mitigate the unfairness of the dataset, if needed, by applying different debiasing methods, i.e. *sampling*, *reweighting* and *disparate impact remover*; 
+* standardise the input (a graph in Neo4J or NetworkX format) for each of the included GNNs;
+* train one or more GNN models, specifying the parameters for each of them;
+* evaluate post-hoc fairness by exploiting four metrics, i.e. *statistical parity*, *equal opportunity*, *overall accuracy equality*, *treatment equality*.
+""")
+
+# st.markdown('##### We have developed a comprehensive framework for Graph Neural Networks-based user profiling models that empowers researchers and users to simultaneously train multiple models and analyze their outcomes. This framework includes tools for mitigating bias, ensuring fairness, and increasing model interpretability. Our approach allows for the incorporation of debiasing techniques into the training process, which helps to minimize the impact of societal biases on model performance. In addition, our framework supports multiple evaluation metrics, enabling the user to compare and contrast the performance of different models.')
+
+# Vertical space
+st.text("")
+
+fairup = Image.open('imgs/fairup_architecture.png')
+st.image(fairup, caption="Logical architecture of FairUP framework")
+
+#st.text("")
+#st.markdown('##### The framework is divided into 3 components: the Pre-processing component, the Core component, and the Post-processing fairness evaluation component')
+
+#st.sidebar.success("Select a page")

README.md

@@ -1,12 +1,12 @@
 ---
-title: FairUP
-emoji: 👀
-colorFrom: yellow
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.19.0
-app_file: app.py
-pinned: false
+title: FairUP 
+emoji: 🚀 
+colorFrom: blue 
+colorTo: green 
+sdk: streamlit 
+sdk_version: 1.19.0 
+app_file: Homepage.py 
+pinned: false 
 license: cc-by-4.0
 ---
 

ali.graphml

@@ -0,0 +1,220 @@
+<?xml version='1.0' encoding='utf-8'?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd"><key id="d17" for="node" attr.name="price" attr.type="double"/>
+<key id="d16" for="node" attr.name="brand" attr.type="double"/>
+<key id="d15" for="node" attr.name="customer" attr.type="long"/>
+<key id="d14" for="node" attr.name="campaign_id" attr.type="long"/>
+<key id="d13" for="node" attr.name="cate_id" attr.type="long"/>
+<key id="d12" for="node" attr.name="clk" attr.type="long"/>
+<key id="d11" for="node" attr.name="nonclk" attr.type="long"/>
+<key id="d10" for="node" attr.name="pid" attr.type="string"/>
+<key id="d9" for="node" attr.name="adgroup_id" attr.type="long"/>
+<key id="d8" for="node" attr.name="time_stamp" attr.type="long"/>
+<key id="d7" for="node" attr.name="new_user_class_level" attr.type="double"/>
+<key id="d6" for="node" attr.name="occupation" attr.type="double"/>
+<key id="d5" for="node" attr.name="shopping_level" attr.type="double"/>
+<key id="d4" for="node" attr.name="pvalue_level" attr.type="double"/>
+<key id="d3" for="node" attr.name="age_level" attr.type="double"/>
+<key id="d2" for="node" attr.name="final_gender_code" attr.type="double"/>
+<key id="d1" for="node" attr.name="cms_group_id" attr.type="double"/>
+<key id="d0" for="node" attr.name="cms_segid" attr.type="double"/>
+<graph edgedefault="directed"><node id="523">
+  <data key="d0">5.0</data>
+  <data key="d1">2.0</data>
+  <data key="d2">2.0</data>
+  <data key="d3">2.0</data>
+  <data key="d4">1.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">1.0</data>
+  <data key="d7">2.0</data>
+  <data key="d8">1494506876</data>
+  <data key="d9">95657</data>
+  <data key="d10">430548_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="830671">
+  <data key="d0">34.0</data>
+  <data key="d1">4.0</data>
+  <data key="d2">2.0</data>
+  <data key="d3">4.0</data>
+  <data key="d4">3.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">3.0</data>
+  <data key="d8">1494668843</data>
+  <data key="d9">95657</data>
+  <data key="d10">430539_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="567632">
+  <data key="d0">66.0</data>
+  <data key="d1">9.0</data>
+  <data key="d2">1.0</data>
+  <data key="d3">3.0</data>
+  <data key="d4">2.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">2.0</data>
+  <data key="d8">1494603840</data>
+  <data key="d9">95657</data>
+  <data key="d10">430539_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="16333">
+  <data key="d0">91.0</data>
+  <data key="d1">11.0</data>
+  <data key="d2">1.0</data>
+  <data key="d3">5.0</data>
+  <data key="d4">2.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">2.0</data>
+  <data key="d8">1494561928</data>
+  <data key="d9">95657</data>
+  <data key="d10">430539_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="521847">
+  <data key="d0">20.0</data>
+  <data key="d1">3.0</data>
+  <data key="d2">2.0</data>
+  <data key="d3">3.0</data>
+  <data key="d4">2.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">3.0</data>
+  <data key="d8">1494579049</data>
+  <data key="d9">95657</data>
+  <data key="d10">430548_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="227111">
+  <data key="d0">8.0</data>
+  <data key="d1">2.0</data>
+  <data key="d2">2.0</data>
+  <data key="d3">2.0</data>
+  <data key="d4">2.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">3.0</data>
+  <data key="d8">1494559984</data>
+  <data key="d9">95657</data>
+  <data key="d10">430539_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="632984">
+  <data key="d0">89.0</data>
+  <data key="d1">11.0</data>
+  <data key="d2">1.0</data>
+  <data key="d3">5.0</data>
+  <data key="d4">1.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">4.0</data>
+  <data key="d8">1494566502</data>
+  <data key="d9">95657</data>
+  <data key="d10">430548_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="912028">
+  <data key="d0">20.0</data>
+  <data key="d1">3.0</data>
+  <data key="d2">2.0</data>
+  <data key="d3">3.0</data>
+  <data key="d4">2.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">3.0</data>
+  <data key="d8">1494276088</data>
+  <data key="d9">95657</data>
+  <data key="d10">430539_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="120208">
+  <data key="d0">77.0</data>
+  <data key="d1">10.0</data>
+  <data key="d2">1.0</data>
+  <data key="d3">4.0</data>
+  <data key="d4">1.0</data>
+  <data key="d5">3.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">2.0</data>
+  <data key="d8">1494563600</data>
+  <data key="d9">95657</data>
+  <data key="d10">430548_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+<node id="390080">
+  <data key="d0">6.0</data>
+  <data key="d1">2.0</data>
+  <data key="d2">2.0</data>
+  <data key="d3">2.0</data>
+  <data key="d4">2.0</data>
+  <data key="d5">2.0</data>
+  <data key="d6">0.0</data>
+  <data key="d7">4.0</data>
+  <data key="d8">1494296612</data>
+  <data key="d9">95657</data>
+  <data key="d10">430539_1007</data>
+  <data key="d11">1</data>
+  <data key="d12">0</data>
+  <data key="d13">6412</data>
+  <data key="d14">160512</data>
+  <data key="d15">82513</data>
+  <data key="d16">26994.0</data>
+  <data key="d17">619.0</data>
+</node>
+</graph></graphml>

pages/1_Framework.py

@@ -0,0 +1,796 @@
+import streamlit as st
+from PIL import Image
+import time
+import pandas as pd
+import os 
+import paramiko
+import threading
+import queue
+import warnings
+import re
+import subprocess
+from presets import Presets
+import random
+#from src import main
+
+
+
+st.set_page_config(layout="wide")
+st.warning('Note:  We are running out with GPU problems. The GNN models are currently running on CPU and some of the Framework capabilities may not be available. We apologise for the inconvenience and we will fix that soon.', icon="⚠️")
+
+st.header('')
+ovgu_img = Image.open('imgs/logo_ovgu_fin_en.jpg')
+st.image(ovgu_img)
+st.title("FairUP: a Framework for Fairness Analysis of Graph Neural Network-Based User Profiling Models. 🚀")
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+warnings.filterwarnings("ignore", category=RuntimeWarning)
+warnings.filterwarnings("ignore")
+
+nba_columns = ['user_id', 'SALARY', 'AGE', 'MP', 'FG', 'FGA', 'FG%', '3P', '3PA',
+       '3P%', '2P', '2PA', '2P%', 'eFG%', 'FT', 'FTA', 'FT%', 'ORB', 'DRB',
+       'TRB', 'AST', 'STL', 'BLK', 'TOV', 'PF_x', 'POINTS', 'GP', 'MPG',
+       'ORPM', 'DRPM', 'RPM', 'WINS_RPM', 'PIE', 'PACE', 'W', 'player_height',
+       'player_weight', 'country', 'C', 'PF_y', 'PF-C', 'PG', 'SF', 'SG',
+       'ATL', 'ATL/CLE', 'ATL/LAL', 'BKN', 'BKN/WSH', 'BOS', 'CHA', 'CHI',
+       'CHI/OKC', 'CLE', 'CLE/DAL', 'CLE/MIA', 'DAL', 'DAL/BKN', 'DAL/PHI',
+       'DEN', 'DEN/CHA', 'DEN/POR', 'DET', 'GS', 'GS/CHA', 'GS/SAC', 'HOU',
+       'HOU/LAL', 'HOU/MEM', 'IND', 'LAC', 'LAL', 'MEM', 'MIA', 'MIL',
+       'MIL/CHA', 'MIN', 'NO', 'NO/DAL', 'NO/MEM', 'NO/MIL', 'NO/MIN/SAC',
+       'NO/ORL', 'NO/SAC', 'NY', 'NY/PHI', 'OKC', 'ORL', 'ORL/TOR', 'PHI',
+       'PHI/OKC', 'PHX', 'POR', 'SA', 'SAC', 'TOR', 'UTAH', 'WSH']
+
+pokec_columns = ['user_id',
+ 'public',
+ 'completion_percentage',
+ 'gender',
+ 'region',
+ 'AGE',
+ 'I_am_working_in_field',
+ 'spoken_languages_indicator',
+ 'anglicky',
+ 'nemecky',
+ 'rusky',
+ 'francuzsky',
+ 'spanielsky',
+ 'taliansky',
+ 'slovensky',
+ 'japonsky',
+ 'hobbies_indicator',
+ 'priatelia',
+ 'sportovanie',
+ 'pocuvanie hudby',
+ 'pozeranie filmov',
+ 'spanie',
+ 'kupalisko',
+ 'party',
+ 'cestovanie',
+ 'kino',
+ 'diskoteky',
+ 'nakupovanie',
+ 'tancovanie',
+ 'turistika',
+ 'surfovanie po webe',
+ 'praca s pc',
+ 'sex',
+ 'pc hry',
+ 'stanovanie',
+ 'varenie',
+ 'jedlo',
+ 'fotografovanie',
+ 'citanie',
+ 'malovanie',
+ 'chovatelstvo',
+ 'domace prace',
+ 'divadlo',
+ 'prace okolo domu',
+ 'prace v zahrade',
+ 'chodenie do muzei',
+ 'zberatelstvo',
+ 'hackovanie',
+ 'I_most_enjoy_good_food_indicator',
+ 'pri telke',
+ 'v dobrej restauracii',
+ 'pri svieckach s partnerom',
+ 'v posteli',
+ 'v prirode',
+ 'z partnerovho bruska',
+ 'v kuchyni pri stole',
+ 'pets_indicator',
+ 'pes',
+ 'mam psa',
+ 'nemam ziadne',
+ 'macka',
+ 'rybky',
+ 'mam macku',
+ 'mam rybky',
+ 'vtacik',
+ 'body_type_indicator',
+ 'priemerna',
+ 'vysportovana',
+ 'chuda',
+ 'velka a pekna',
+ 'tak trosku pri sebe',
+ 'eye_color_indicator',
+ 'hnede',
+ 'modre',
+ 'zelene',
+ 'hair_color_indicator',
+ 'cierne',
+ 'blond',
+ 'plave',
+ 'hair_type_indicator',
+ 'kratke',
+ 'dlhe',
+ 'rovne',
+ 'po plecia',
+ 'kucerave',
+ 'na jezka',
+ 'completed_level_of_education_indicator',
+ 'stredoskolske',
+ 'zakladne',
+ 'vysokoskolske',
+ 'ucnovske',
+ 'favourite_color_indicator',
+ 'modra',
+ 'cierna',
+ 'cervena',
+ 'biela',
+ 'zelena',
+ 'fialova',
+ 'zlta',
+ 'ruzova',
+ 'oranzova',
+ 'hneda',
+ 'relation_to_smoking_indicator',
+ 'nefajcim',
+ 'fajcim pravidelne',
+ 'fajcim prilezitostne',
+ 'uz nefajcim',
+ 'relation_to_alcohol_indicator',
+ 'pijem prilezitostne',
+ 'abstinent',
+ 'nepijem',
+ 'on_pokec_i_am_looking_for_indicator',
+ 'dobreho priatela',
+ 'priatelku',
+ 'niekoho na chatovanie',
+ 'udrzujem vztahy s priatelmi',
+ 'vaznu znamost',
+ 'sexualneho partnera',
+ 'dlhodoby seriozny vztah',
+ 'love_is_for_me_indicator',
+ 'nie je nic lepsie',
+ 'ako byt zamilovany(a)',
+ 'v laske vidim zmysel zivota',
+ 'v laske som sa sklamal(a)',
+ 'preto som velmi opatrny(a)',
+ 'laska je zakladom vyrovnaneho sexualneho zivota',
+ 'romanticka laska nie je pre mna',
+ 'davam prednost realite',
+ 'relation_to_casual_sex_indicator',
+ 'nedokazem mat s niekym sex bez lasky',
+ 'to skutocne zalezi len na okolnostiach',
+ 'sex mozem mat iba s niekym',
+ 'koho dobre poznam',
+ 'dokazem mat sex s kymkolvek',
+ 'kto dobre vyzera',
+ 'my_partner_should_be_indicator',
+ 'mojou chybajucou polovickou',
+ 'laskou mojho zivota',
+ 'moj najlepsi priatel',
+ 'absolutne zodpovedny a spolahlivy',
+ 'hlavne spolocensky typ',
+ 'clovek',
+ 'ktoreho uplne respektujem',
+ 'hlavne dobry milenec',
+ 'niekto',
+ 'marital_status_indicator',
+ 'slobodny(a)',
+ 'mam vazny vztah',
+ 'zenaty (vydata)',
+ 'rozvedeny(a)',
+ 'slobodny',
+ 'relation_to_children_indicator',
+ 'v buducnosti chcem mat deti',
+ 'I_like_movies_indicator',
+ 'komedie',
+ 'akcne',
+ 'horory',
+ 'serialy',
+ 'romanticke',
+ 'rodinne',
+ 'sci-fi',
+ 'historicke',
+ 'vojnove',
+ 'zahadne',
+ 'mysteriozne',
+ 'dokumentarne',
+ 'eroticke',
+ 'dramy',
+ 'fantasy',
+ 'muzikaly',
+ 'kasove trhaky',
+ 'umelecke',
+ 'alternativne',
+ 'I_like_watching_movie_indicator',
+ 'doma z gauca',
+ 'v kine',
+ 'u priatela',
+ 'priatelky',
+ 'I_like_music_indicator',
+ 'disko',
+ 'pop',
+ 'rock',
+ 'rap',
+ 'techno',
+ 'house',
+ 'hitparadovky',
+ 'sladaky',
+ 'hip-hop',
+ 'metal',
+ 'soundtracky',
+ 'punk',
+ 'oldies',
+ 'folklor a ludovky',
+ 'folk a country',
+ 'jazz',
+ 'klasicka hudba',
+ 'opery',
+ 'alternativa',
+ 'trance',
+ 'I_mostly_like_listening_to_music_indicator',
+ 'kedykolvek a kdekolvek',
+ 'na posteli',
+ 'pri chodzi',
+ 'na dobru noc',
+ 'na diskoteke',
+ 's partnerom',
+ 'vo vani',
+ 'v aute',
+ 'na koncerte',
+ 'pri sexe',
+ 'v praci',
+ 'the_idea_of_good_evening_indicator',
+ 'pozerat dobry film v tv',
+ 'pocuvat dobru hudbu',
+ 's kamaratmi do baru',
+ 'ist do kina alebo divadla',
+ 'surfovat na sieti a chatovat',
+ 'ist na koncert',
+ 'citat dobru knihu',
+ 'nieco dobre uvarit',
+ 'zhasnut svetla a meditovat',
+ 'ist do posilnovne',
+ 'I_like_specialties_from_kitchen_indicator',
+ 'slovenskej',
+ 'talianskej',
+ 'cinskej',
+ 'mexickej',
+ 'francuzskej',
+ 'greckej',
+ 'morske zivocichy',
+ 'vegetarianskej',
+ 'japonskej',
+ 'indickej',
+ 'I_am_going_to_concerts_indicator',
+ 'ja na koncerty nechodim',
+ 'zriedkavo',
+ 'my_active_sports_indicator',
+ 'plavanie',
+ 'futbal',
+ 'kolieskove korcule',
+ 'lyzovanie',
+ 'korculovanie',
+ 'behanie',
+ 'posilnovanie',
+ 'tenis',
+ 'hokej',
+ 'basketbal',
+ 'snowboarding',
+ 'pingpong',
+ 'auto-moto sporty',
+ 'bedminton',
+ 'volejbal',
+ 'aerobik',
+ 'bojove sporty',
+ 'hadzana',
+ 'skateboarding',
+ 'my_passive_sports_indicator',
+ 'baseball',
+ 'golf',
+ 'horolezectvo',
+ 'bezkovanie',
+ 'surfing',
+ 'I_like_books_indicator',
+ 'necitam knihy',
+ 'o zabave',
+ 'humor',
+ 'hry',
+ 'historicke romany',
+ 'rozpravky',
+ 'odbornu literaturu',
+ 'psychologicku literaturu',
+ 'literaturu pre rozvoj osobnosti',
+ 'cestopisy',
+ 'literaturu faktu',
+ 'poeziu',
+ 'zivotopisne a pamate',
+ 'pocitacovu literaturu',
+ 'filozoficku literaturu',
+ 'literaturu o umeni a architekture']
+
+alibaba_columns = ['userid', 'final_gender_code', 'age_level', 'pvalue_level', 'occupation', 'new_user_class_level ', 'adgroup_id', 'clk', 'cate_id']
+jd_columns = ['user_id',
+ 'gender',
+ 'age_range',
+ 'item_id',
+ 'cid1',
+ 'cid2',
+ 'cid3',
+ 'cid1_name',
+ 'cid2_name',
+ 'cid3_name',
+ 'brand_code',
+ 'price',
+ 'item_name',
+ 'seg_name']
+
+##############################
+# Preset
+preset_question = st.radio("Do you want to apply a preset?", ("No", "Yes"))
+with st.expander("More information"):
+        st.write("A preset is a pre-defined parameter and model settings that can be choosen by the user to test the Framework easily.")
+        st.write("Each preset option is defined by the model name and (in brackets) the dataset which it will be trained on.")
+if preset_question == 'Yes':
+    preset_list = ['FairGNN (NBA)', 'RHGN (Alibaba)', 'CatGCN (Alibaba)']
+    preset = st.selectbox('Select Preset', preset_list)
+    # implment presets as functions?
+    if preset == 'FairGNN (NBA)':
+        model_type, predict_attr, sens_attr = Presets.FairGNN_NBA()
+    elif preset == 'RHGN (Alibaba)':
+        model_type, predict_attr, sens_attr = Presets.RHGN_Alibaba()
+    elif preset == 'CatGCN (Alibaba)':
+        model_type, predict_attr, sens_attr = Presets.CatGCN_Alibaba()
+
+    Presets.experiment_begin(model_type, predict_attr, sens_attr)
+
+elif preset_question == 'No':
+    dataset = st.selectbox("Which dataset do you want to evaluate?", ("NBA", "Pokec-z", "Alibaba", "JD"))
+    if dataset == "NBA":
+        dataset = 'nba'
+        predict_attr = st.selectbox("Select prediction label", nba_columns)
+        sens_attr = st.selectbox("Select sensitive attribute", nba_columns)
+    elif dataset == "Pokec-z":
+        dataset = 'pokec_z'
+        predict_attr = st.selectbox("Select prediction label", pokec_columns)
+        sens_attr = st.selectbox("Select sensitive attribute", pokec_columns)
+    elif dataset == "Alibaba":
+        dataset = 'alibaba'
+        predict_attr = st.selectbox("Select prediction label", alibaba_columns)
+        sens_attr = st.selectbox("Select sensitive attribute", alibaba_columns)
+    elif dataset == 'JD':
+        dataset = 'tecent'
+        predict_attr = st.selectbox("Select prediction label", jd_columns)
+        sens_attr = st.selectbox("Select sensitive attribute", jd_columns)
+
+
+    # todo get all columns of the selected dataset and change this to a selectbox
+    #predict_attr = st.text_input("Enter the prediction label")
+    #sens_attr = st.text_input("Enter the senstive attribute")
+    def read_output(stdout, queue):
+        for line in stdout:
+            queue.put(line.strip())
+
+    def execute_command_fairness(dataset, sens_attr, predict_attr):
+        with st.spinner("Loading..."):
+            time.sleep(1)
+            #ssh = paramiko.SSHClient()
+            # Automatically add the server's host key (for the first connection only)
+            #ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+            # Connect to the remote server
+            #ssh.connect('141.44.31.206', username='abdelrazek', password='Mohamed')
+            
+            #if dataset == 'nba':
+            #    stdin_new, stdout_new, stderr_new = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 main.py --calc_fairness True --dataset_name {} --dataset_path ../nba.csv --special_case True --sens_attr {} --predict_attr {} --type 1'.format(dataset, sens_attr, predict_attr), get_pty=True)
+            #elif dataset == 'alibaba':
+            #    stdin_new, stdout_new, stderr_new = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 main.py --calc_fairness True --dataset_name {} --dataset_path ../alibaba_small.csv --special_case True --sens_attr {} --predict_attr {} --type 1'.format(dataset, sens_attr, predict_attr), get_pty=True)
+            #elif dataset == 'tecent':
+            #    stdin_new, stdout_new, stderr_new = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 main.py --calc_fairness True --dataset_name {} --dataset_path ../JD_small.csv --special_case True --sens_attr {} --predict_attr {} --type 1'.format(dataset, sens_attr, predict_attr), get_pty=True)
+            #elif dataset == 'pokec_z':
+            #    stdin_new, stdout_new, stderr_new = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 main.py --calc_fairness True --dataset_name {} --dataset_path ../Master-Thesis-dev/region_job.csv --special_case True --sens_attr {} --predict_attr {} --type 1'.format(dataset, sens_attr, predict_attr), get_pty=True)
+            #output_queue = queue.Queue()
+            # start a thread to continuously read the output from the stdout object
+            test = 'pwd'
+            st.text(os.system(test))
+            output_thread = threading.Thread(target=read_output, args=(stderr_new, output_queue))
+            output_thread.start()
+
+            # display the output in the Streamlit UI
+            while True:
+                try:
+                    line = output_queue.get_nowait()
+                    st.text(line)
+                except queue.Empty:
+                    if output_thread.is_alive():
+                        continue
+                    else:
+                        break
+
+            # wait for the thread to finish
+            output_thread.join()
+            # print the output to the console
+            for line in stdout_new:
+                print(line.strip())
+                if "Dataset" in line:
+                    st.text(line.strip())  
+            ssh.close()
+
+    fairness_evaluation = st.radio("Do you want to evaluate the dataset fairness?", ("No", "Yes"))
+    with st.expander("More information"):
+            st.write("Evaluate how fair the dataset, namely how much bias is affecting the dataset as a whole using the disparate impact metric.")
+    if fairness_evaluation == "Yes":
+        if st.button('Calculate Fairness'):
+        # todo send command to server to compute fairness
+        # then show fairness
+        # add info box
+        #dataset_fairness = st.write('Dataset Fairness: 1.57 (Fair)') 
+            #execute_command_fairness(dataset, sens_attr, predict_attr)
+            #with open('test_new.yml', 'r') as file:
+            #    environment = file.read()
+            #with open('test_tmp.yml', 'w') as file:
+            #    file.write(environment.replace('prefix: /', ''))
+            #os.system('conda env create --file test_new.yml --name streamlit_env_new')
+            #os.system('conda activate streamlit_env_new')
+            commands = os.popen('cd src && python main.py --calc_fairness True --dataset_name nba --dataset_path ./datasets/NBA/nba.csv --special_case True --sens_attr country --predict_attr SALARY --type 1').read()
+            
+            #output = os.popen('cd')
+            #output = os.popen('python main.py --calc_fairness True --dataset_name nba --dataset_path ./datasets/NBA/nba.csv --special_case True --sens_attr country --predict_attr SALARY --type 1').read()
+            #st.text(output)
+            
+            print(commands)
+        
+
+    #####################
+    debias = st.radio("Do you want to apply debias approaches?", ("No", "Yes"))
+    if "Yes" in debias:
+        debias_approach = st.selectbox("Select which debias approach you want to apply", ["Sample", "Reweighting", "Disparate remover impact"])
+        with st.expander("More information"):
+            st.write("You can mitigate the bias using three pre-processing debaising approaches:")
+            st.write("Sampling: Generates more data to overcome the bias between the different sensitive attributes and classes.")
+            st.write("Reweighting Minimizing the bias in the dataset by assiging different weights to dataset tuples, for example giving the unfavorable sensntive attributes higher weights than favorable sensitive attributes")
+            st.write("Disparate impact remover: Transforms the sensitive attribute features in a way that the correlation between the sensitive attribute features and the prediction class is reduced")
+
+
+
+
+    #if dataset != None:
+    #st.markdown("#### Select dataset")
+    #uploaded_file = st.file_uploader("Select dataset")
+        #dataset_path = st.text_input("", value="")
+
+    model_type = st.multiselect("Select the models you want to train", ["FairGNN", "RHGN", "CatGCN"])
+
+    if "RHGN" in model_type and "FairGNN" in model_type:
+        st.markdown("### Enter the general parameters")
+        seed = st.number_input("Enter the prefered seed number", value=0)
+        
+        #predict_attr = st.text_input("Enter the prediction label")
+        #sens_attr = st.text_input("Enter the senstive attribute")
+
+
+        st.markdown("### Enter the RHGN parameters")
+        num_hidden = st.text_input("Enter the number of hidden layers", value=0)
+        with st.expander("More information"):
+            st.write("The number of hidden layers refers to the number of layers between the input layer and the output layer of a model.")
+        lr_rhgn = st.number_input("Enter the learning rate for RHGN")
+        with st.expander("More information"):
+            st.write("Is a hyperparameter that controls the step size of the updates made to the weights during training. In other words, it determines how quickly the model learns from the data.")
+        
+        epochs_rhgn = st.number_input("Enter the number of epochs for RHGN", value=0)
+        with st.expander("More information"):
+            st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+        
+        clip = st.number_input("Enter the clip value", value=0)
+        with st.expander("More information"):
+            st.write("The clip number is a hyperparameter that determines the maximum value that the gradient can take. If the gradient exceeds this value, it is clipped (i.e., truncated to the maximum value).")
+        
+        
+
+        st.markdown("### Enter the FairGNN parameters")
+        lr_fairgnn = st.number_input("Enter the learning rate for FairGNN")
+        with st.expander("More information"):
+            st.write("Is a hyperparameter that controls the step size of the updates made to the weights during training. In other words, it determines how quickly the model learns from the data.")
+        epochs_fairgnn = st.number_input("Enter the number of epochs for FairGNN", value=0)
+        with st.expander("More information"):
+            st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+        sens_number = st.number_input("Enter the sens number", value=0)
+        
+        label_number = st.number_input("Enter the label number", value=0)
+        
+        num_hidden = st.number_input("Enter the hidden layer number" , value=0)
+        with st.expander("More information"):
+            st.write("The number of hidden layers refers to the number of layers between the input layer and the output layer of a model.")
+        alpha = st.number_input("Enter alpha value", value=0)
+        with st.expander("More information"):
+            st.write("Refers to the regularization parameter that controls the amount of L2 regularization applied to the model's weights during the training process.")
+        
+        beta = st.number_input("Enter beta value", value=0)
+        with st.expander("More information"):
+            st.write("Refers to the momentum parameter that controls how much the optimizer should take into account the previous update when computing the current update to the model's weights during the training process.")
+        
+
+    if "RHGN" in model_type and "CatGCN" in model_type:
+        st.markdown("### Enter the general parameters")
+        seed = st.number_input("Enter the prefered seed number", value=0)
+        #predict_attr = st.text_input("Enter the prediction label")
+        #sens_attr = st.text_input("Enter the senstive attribute")
+
+        st.markdown("### Enter the RHGN parameters")
+        num_hidden = st.text_input("Enter the number of hidden layers")
+        with st.expander("More information"):
+            st.write("The number of hidden layers refers to the number of layers between the input layer and the output layer of a model.")
+        lr_rhgn = st.number_input("Enter the learning rate")
+        with st.expander("More information"):
+            st.write("Is a hyperparameter that controls the step size of the updates made to the weights during training. In other words, it determines how quickly the model learns from the data.")
+        epochs_rhgn = st.number_input("Enter the number of epochs", value=0)
+        with st.expander("More information"):
+            st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+        clip = st.number_input("Enter the clip value", value=0)
+        with st.expander("More information"):
+            st.write("The clip number is a hyperparameter that determines the maximum value that the gradient can take. If the gradient exceeds this value, it is clipped (i.e., truncated to the maximum value).")
+
+        st.markdown("### Enter the CatGCN parameters")
+        weight_decay = st.number_input("Enter the weight decay value" )
+        with st.expander("More information"):
+            st.write("The parameters that controls the amount the weights will exponentially decay to zero.")
+        lr_catgcn = st.number_input("Enter the learning rate")
+        with st.expander("More information"):
+            st.write("Is a hyperparameter that controls the step size of the updates made to the weights during training. In other words, it determines how quickly the model learns from the data.")
+        epochs_catgcn = st.number_input("Enter the number of epochs", value=0)
+        with st.expander("More information"):
+            st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+        diag_probe = st.number_input("Enter the diag probe value" , value=0)
+        graph_refining = st.selectbox("Choose the graph refining approach", ("agc", "fignn", "none"))
+        grn_units = st.number_input("Enter the grn units value" , value=0)
+        bi_interaction = st.selectbox("Choose the bi-interaction approach", ("nfm", "none"))
+
+
+    elif "RHGN" in model_type and len(model_type) == 1:
+        st.markdown("### Enter the general paramaters")
+        seed = st.number_input("Enter the prefered seed number", value=0)
+        #lr = st.number_input("Enter the learning rate", value=0)
+        #epochs = st.number_input("Enter the number of epochs", value=0)
+        #predict_attr = st.text_input("Enter the prediction label")
+        #sens_attr = st.text_input("Enter the senstive attribute")
+
+
+        st.markdown("### Enter the RHGN parametrs")
+        num_hidden = st.number_input("Enter the number of hidden layers", value=0)
+        with st.expander("More information"):
+            st.write("The number of hidden layers refers to the number of layers between the input layer and the output layer of a model.")
+        lr_rhgn = st.number_input("Enter the learning rate")
+        with st.expander("More information"):
+            st.write("Is a hyperparameter that controls the step size of the updates made to the weights during training. In other words, it determines how quickly the model learns from the data.")
+        
+        epochs_rhgn = st.number_input("Enter the number of epochs for RHGN", value=0)
+        with st.expander("More information"):
+            st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+        
+        clip = st.number_input("Enter the clip value", value=0)
+        with st.expander("More information"):
+            st.write("The clip number is a hyperparameter that determines the maximum value that the gradient can take. If the gradient exceeds this value, it is clipped (i.e., truncated to the maximum value).")
+
+    elif "FairGNN" in model_type and len(model_type) == 1:
+        st.markdown("### Enter the general parameters")
+        seed = st.number_input("Enter the prefered seed number" , value=0)
+        #lr = st.number_input("Enter the learning rate" , value=0)
+        #epochs = st.number_input("Enter the number of epochs" , value=0)
+        #predict_attr = st.text_input("Enter the prediction label")
+        #sens_attr = st.text_input("Enter the senstive attribute")
+
+
+        st.markdown("### Enter the FairGNN parameters")
+        lr_fairgnn = st.number_input("Enter the learning rate")
+        epochs_fairgnn = st.number_input("Enter the number of epochs" , value=0)
+        with st.expander("More information"):
+            st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+        sens_number =  st.number_input("Enter the sens number" , value=0)
+        label_number = st.number_input("Enter the label number", value=0)
+        num_hidden = st.number_input("Enter the hidden layer number" , value=0)
+        with st.expander("More information"):
+            st.write("The number of hidden layers refers to the number of layers between the input layer and the output layer of a model.")
+        alpha = st.number_input("Enter alpha value" , value=0)
+        with st.expander("More information"):
+            st.write("Refers to the regularization parameter that controls the amount of L2 regularization applied to the model's weights during the training process.")
+        beta = st.number_input("Enter beta value", value=0)
+        with st.expander("More information"):
+            st.write("Refers to the momentum parameter that controls how much the optimizer should take into account the previous update when computing the current update to the model's weights during the training process.")
+
+
+    elif "CatGCN" in model_type and len(model_type) == 1:
+        st.markdown("### Enter the general paramaters")
+        seed = st.number_input("Enter the prefered seed number", value=0)
+        #lr = st.number_input("Enter the learning rate" , value=0)
+        #epochs = st.number_input("Enter the number of epochs" , value=0)
+        #predict_attr = st.text_input("Enter the prediction label")
+        #sens_attr = st.text_input("Enter the senstive attribute")
+
+        st.markdown("### Enter the CatGCN parameters")
+        weight_decay = st.number_input("Enter the weight decay value")
+        with st.expander("More information"):
+            st.write("The parameters that controls the amount the weights will exponentially decay to zero.")
+        lr_catgcn = st.number_input("Enter the learning rate")
+        with st.expander("More information"):
+            st.write("Is a hyperparameter that controls the step size of the updates made to the weights during training. In other words, it determines how quickly the model learns from the data.")
+        epochs_catgcn = st.number_input("Enter the number of epochs" , value=0)
+        with st.expander("More information"):
+            st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+        diag_probe = st.number_input("Enter the diag probe value" , value=0)
+        graph_refining = st.multiselect("Choose the graph refining approach", ["agc", "fignn", "none"])
+        grn_units = st.number_input("Enter the grn units value" , value=0)
+        bi_interaction = st.multiselect("Choose the bi-interaction approach", ["nfm", "none"])
+
+
+
+    if len(model_type) != 0:
+        if st.button("Begin experiment"):
+            with st.spinner("Loading..."):
+                time.sleep(2)
+                if predict_attr == 'final_gender_code':
+                    predict_attr == 'bin_gender'
+                if sens_attr == 'age_level':
+                    sens_attr == 'bin_age'
+
+                ###################################################################################################################
+                ssh = paramiko.SSHClient()
+                port = 443
+                # Automatically add the server's host key (for the first connection only)
+                ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+                # Connect to the remote server
+                ssh.connect('https://dtdh206.cs.uni-magdeburg.de:443')
+                #ssh.connect('141.44.31.206', port=443, banner_timeout=200)
+                stdin, stdout, stderr =  ssh.exec_command('ls')
+                print(stdout)
+
+                if len(model_type) == 1 and 'FairGNN' in model_type:
+                    stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --epoch {} --model GCN --sens_number {} --num_hidden {} --acc 0.20 --roc 0.20 --alpha {} --beta {} --dataset_name {} --dataset_path ../nba.csv --dataset_user_id_name user_id --model_type FairGNN --type 1 --sens_attr {} --predict_attr {} --label_number 100 --no-cuda True --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, epochs_fairgnn, sens_number, num_hidden, alpha, beta, dataset, sens_attr, predict_attr))
+                if len(model_type) == 1 and 'RHGN' in model_type:
+                    stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --gpu 0 --dataset_path ../ --max_lr {} --num_hidden {} --clip {} --epochs {} --label {} --sens_attr {} --type 1 --model_type RHGN --dataset_name {} --dataset_user_id_name userid --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, lr_rhgn, num_hidden, clip, epochs_rhgn, predict_attr, sens_attr, dataset))
+                # CatGCN
+                if len(model_type) == 1 and 'CatGCN' in model_type:
+                    stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --gpu 0 --lr {} --weight_decay {} --dropout 0.1 --diag-probe {} --graph-refining {} --aggr-pooling mean --grn_units {} --bi-interaction {} --nfm-units none --graph-layer pna --gnn-hops 1 --gnn-units none --aggr-style sum --balance-ratio 0.7 --sens_attr {} --label {} --dataset_name {} --dataset_path ../ --type 1 --model_type CatGCN --dataset_user_id_name userid --alpha 0.5 --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, lr_catgcn, weight_decay, diag_probe, graph_refining, grn_units, bi_interaction, sens_attr, predict_attr, dataset))
+
+                # FairGNN and RHGN
+                if len(model_type) == 2 and 'FairGNN' in model_type and 'RHGN' in model_type:
+                    if predict_attr == 'final_gender_code':
+                        label = 'bin_gender'
+                    if sens_attr == 'age_level':
+                        sens_attr_rhgn = 'bin_age'
+                    stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --epochs {} --model GCN --sens_number {} --num_hidden {} --acc 0.20 --roc 0.20 --alpha {} --beta {} --dataset_name {} --dataset_path ../nba.csv --dataset_user_id_name user_id --model_type FairGNN RHGN --type 1 --sens_attr {} --label {} --predict_attr {} --label_number 100 --no-cuda True --max_lr {} --clip {} --epochs_rhgn {}  --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, epochs_fairgnn, sens_number, num_hidden, alpha, beta, dataset, sens_attr, predict_attr, predict_attr, lr_rhgn, clip, epochs_rhgn))
+                    print('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --epochs {} --model GCN --sens_number {} --num_hidden {} --acc 0.20 --roc 0.20 --alpha {} --beta {} --dataset_name {} --dataset_path ../nba.csv --dataset_user_id_name user_id --model_type FairGNN RHGN --type 1 --sens_attr {} --label {} --predict_attr {} --label_number 100 --no-cuda True --max_lr {} --clip {} --epochs_rhgn {}  --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, epochs_fairgnn, sens_number, num_hidden, alpha, beta, dataset, sens_attr, predict_attr, predict_attr, lr_rhgn, clip, epochs_rhgn))
+                    #stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && ls')
+                    
+                output_queue = queue.Queue()
+                output_thred = threading.Thread(target=read_output, args=(stderr, output_queue))
+                output_thred.start()
+                
+                while True:
+                    try:
+                        line = output_queue.get_nowait()
+                        #st.text(line)
+                    except queue.Empty:
+                        if output_thred.is_alive():
+                            continue
+                        else:
+                            break
+
+                output_thred.join()
+                all_output = []
+                for line in stdout:
+                    print(line.strip())
+                    #st.text(line.strip())
+                    if "Test_final:" in line and 'FairGNN' in model_type:
+                        result = line.strip()
+                        #st.text(result)
+                    if 'accuracy' in line and 'RHGN' in model_type:
+                        #st.text(line.strip())
+                        line = line.strip() + 'end'
+                        acc = re.search('accuracy                         (.+?)end', line)
+                        acc = acc.group(1)
+                        acc_rhgn = acc.split()[0]
+                    if 'F1 score:' in line:
+                        f1 = '.'.join(line.split('.')[0:2])
+                        f1_rhgn = '{:.3f}'.format(float(f1.split()[-1]))
+                    if 'Statistical Parity Difference (SPD):' in line:
+                        spd_rhgn = '{:.3f}'.format(float(line.split()[-1]))
+
+                    if 'Equal Opportunity Difference (EOD):' in line:
+                        eod_rhgn = '{:.3f}'.format(float(line.split()[-1]))
+
+                    if 'Overall Accuracy Equality Difference (OAED):' in line:
+                        oaed_rhgn = '{:.3f}'.format(float(line.split()[-1]))
+
+                    if 'Treatment Equality Difference (TED):' in line:
+                        ted_rhgn = '{:.3f}'.format(float(line.split()[-1]))
+                    #all_output.append(line.strip())
+                # Close the connection
+                ssh.close()
+
+            st.success("Done!")
+
+            
+            st.markdown("## Training Results:")
+            print(len(model_type))
+            print(model_type)
+            if len(model_type) == 1 and 'FairGNN' in model_type:
+                st.text(result)
+                acc = re.search('accuracy:(.+?)roc', result)
+                f1 = re.search('F1:(.+?)acc_sens', result)
+
+                spd = re.search('parity:(.+?)equality', result)
+                eod = re.search('equality:(.+?)oaed', result)
+                oaed = re.search('oaed:(.+?)treatment equality', result)
+                ted = re.search('treatment equality(.+?)end', result)
+                data = {'Model': [model_type],
+                    'Accuracy': [acc.group(1)],
+                    'F1': [f1.group(1)],
+                    'SPD': [spd.group(1)],
+                    'EOD': [eod.group(1)],
+                    'OAED': [oaed.group(1)],
+                    'TED': [ted.group(1)]
+                    }
+                
+            elif len(model_type) == 1 and 'RHGN' in model_type:
+                #print('all_output:', all_output)
+                data =  {'Model': [model_type],
+                'Accuracy': [acc_rhgn],
+                'F1': [f1_rhgn],
+                'SPD': [spd_rhgn],
+                'EOD': [eod_rhgn],
+                'OAED': [oaed_rhgn],
+                'TED': [ted_rhgn]
+                }
+
+            elif len(model_type) == 2 and 'RHGN' in model_type and 'FairGNN' in model_type:
+
+                acc = re.search('a:(.+?)roc', result)
+                f1 = re.search('F1:(.+?)acc_sens', result)
+
+                spd = re.search('parity:(.+?)equality', result)
+                eod = re.search('equality:(.+?)oaed', result)
+                oaed = re.search('oaed:(.+?)treatment equality', result)
+                ted = re.search('treatment equality(.+?)end', result)
+
+                ind_fairgnn = model_type.index('FairGNN')
+                ind_rhgn = model_type.index('RHGN')
+                data =  {'Model': [model_type[ind_fairgnn], model_type[ind_rhgn]],
+                'Prediction label': [predict_attr, predict_attr],
+                'Sensitive attribute': [sens_attr, sens_attr],
+                'Accuracy': [acc.group(1), acc_rhgn],
+                'F1': [f1.group(1), f1_rhgn],
+                'SPD': [spd.group(1), spd_rhgn],
+                'EOD': [eod.group(1), eod_rhgn],
+                'OAED': [oaed.group(1), oaed_rhgn],
+                'TED': [ted.group(1), ted_rhgn]
+                }
+
+            df = pd.DataFrame(data)
+
+            #st.dataframe(df, width=5000)
+            # set the display options for the DataFrame
+            pd.set_option("display.max_columns", None)
+            pd.set_option("display.width", 100)
+
+            
+
+            # display the DataFrame in Streamlit
+            st.write(df)
+
+        #st.write("The logs of the experiment can be found at: mohamed9/Experiments-RHGN-CatGCN-Alibaba")
+        #st.markdown("The logs of the experiment can be found at: **mohamed9/Experiments-RHGN-FairGNN-Alibaba**")
+
+
+

pages/setup.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+# Create a new Conda environment
+conda env create -f test_new.yml --name env_test
+
+# Activate the Conda environment
+source activate env_test

presets/Presets.py

@@ -0,0 +1,259 @@
+import streamlit as st
+import pandas as pd
+import os
+import paramiko
+import warnings
+import re
+import time
+
+
+def FairGNN_NBA():
+    #dataset = st.selectbox("Dataset", ("NBA"))
+    dataset = st.text_input('Dataset', 'NBA', disabled=True)
+    dataset = 'nba'
+    predict_attr = st.text_input("Prediction label", 'SALARY', disabled=True)
+    sens_attr = st.text_input("Sensitive attribute", 'country', disabled=True)
+
+
+    model_type = st.text_input("Models to train", 'FairGNN', disabled=True)
+
+    st.markdown("### General parameters")
+    seed = st.number_input("Prefered seed number" , value=42, disabled=True)
+
+    st.markdown("### FairGNN parameters")
+    lr_fairgnn = st.number_input("Learning rate", value=0.01, disabled=True)
+    epochs_fairgnn = st.number_input("Number of epochs" , value=2000, disabled=True)
+    with st.expander("More information"):
+        st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+    sens_number =  st.number_input("Sens number" , value=50, disabled=True)
+    label_number = st.number_input("Label number", value=1000, disabled=True)
+    num_hidden = st.number_input("Hidden layer number" , value=128, disabled=True)
+    with st.expander("More information"):
+        st.write("The number of hidden layers refers to the number of layers between the input layer and the output layer of a model.")
+    alpha = st.number_input("Alpha value" , value=10, disabled=True)
+    with st.expander("More information"):
+        st.write("Refers to the regularization parameter that controls the amount of L2 regularization applied to the model's weights during the training process.")
+    beta = st.number_input("Beta value", value=1, disabled=True)
+    with st.expander("More information"):
+        st.write("Refers to the momentum parameter that controls how much the optimizer should take into account the previous update when computing the current update to the model's weights during the training process.")
+
+    return model_type, predict_attr, sens_attr
+
+def RHGN_Alibaba():
+    dataset = st.text_input('Dataset', 'Alibaba', disabled=True)
+    dataset = 'alibaba'
+    predict_attr = st.text_input('Prediction label', 'final_gender_code', disabled=True)
+    sens_attr = st.text_input('Sensitive attribute', 'age_level', disabled=True)
+
+    model_type = st.text_input("Models to train", 'RHGN', disabled=True)
+
+    st.markdown("### General parameters")
+    seed = st.number_input("Prefered seed number" , value=3, disabled=True)
+
+    st.markdown("### RHGN parametrs")
+    num_hidden = st.number_input("Hidden layer number", value=32, disabled=True)
+    with st.expander("More information"):
+        st.write("The number of hidden layers refers to the number of layers between the input layer and the output layer of a model.")
+    lr_rhgn = st.number_input("Learning rate", value=0.1, disabled=True)
+    with st.expander("More information"):
+        st.write("Is a hyperparameter that controls the step size of the updates made to the weights during training. In other words, it determines how quickly the model learns from the data.")
+    
+    epochs_rhgn = st.number_input("Epochs", value=100, disabled=True)
+    with st.expander("More information"):
+        st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+    
+    clip = st.number_input("Clip value", value=2, disabled=True)
+    with st.expander("More information"):
+        st.write("The clip number is a hyperparameter that determines the maximum value that the gradient can take. If the gradient exceeds this value, it is clipped (i.e., truncated to the maximum value).")
+
+    return model_type, predict_attr, sens_attr
+
+def CatGCN_Alibaba():
+    dataset = st.text_input('Dataset', 'Alibaba', disabled=True)
+    dataset = 'alibaba'
+    predict_attr = st.text_input('Prediction label', 'final_gender_code', disabled=True)
+    sens_attr = st.text_input('Sensitive attribute', 'age_level', disabled=True)
+
+    model_type = st.text_input('Models to train', 'CatGCN', disabled=True)
+
+    st.markdown("### General parameters")
+    seed = st.number_input("Prefered seed number" , value=11, disabled=True)
+
+    st.markdown("### CatGCN parameters")
+    weight_decay = st.number_input("Weight decay value", value=0.01, disabled=True)
+    with st.expander("More information"):
+        st.write("The parameters that controls the amount the weights will exponentially decay to zero.")
+    lr_catgcn = st.number_input("Learning rate", value=0.1, disabled=True)
+    with st.expander("More information"):
+        st.write("Is a hyperparameter that controls the step size of the updates made to the weights during training. In other words, it determines how quickly the model learns from the data.")
+    epochs_catgcn = st.number_input("Number of epochs" , value=100, disabled=True)
+    with st.expander("More information"):
+        st.write("Refers to a single pass through the entire training dataset during the training of a model. In other words, an epoch is a measure of the number of times the model has seen the entire training data.")
+    diag_probe = st.number_input("Diag probe value" , value=39, disabled=True)
+    graph_refining = st.text_input("Graph refining approach", "agc", disabled=True)
+    grn_units = st.number_input("Enter the grn units value" , value=64, disabled=True)
+    bi_interaction = st.text_input("Bi-interaction approach", "nfm", disabled=True)
+
+    return model_type, predict_attr, sens_attr
+
+def experiment_begin(model_type, predict_attr, sens_attr):
+    if len(model_type) != 0:
+        if st.button("Begin experiment"):
+            with st.spinner("Loading..."):
+
+                time.sleep(2)
+                ssh = paramiko.SSHClient()
+                port = 443
+                # Automatically add the server's host key (for the first connection only)
+                ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+
+                # Connect to the remote server
+                ssh.connect('https://dtdh206.cs.uni-magdeburg.de:443')
+                #ssh.connect('141.44.31.206', port=443, banner_timeout=200)
+                stdin, stdout, stderr =  ssh.exec_command('ls')
+                print(stdout)
+
+                if len(model_type) == 1 and 'FairGNN' in model_type:
+                    stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --epoch {} --model GCN --sens_number {} --num_hidden {} --acc 0.20 --roc 0.20 --alpha {} --beta {} --dataset_name {} --dataset_path ../nba.csv --dataset_user_id_name user_id --model_type FairGNN --type 1 --sens_attr {} --predict_attr {} --label_number 100 --no-cuda True --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, epochs_fairgnn, sens_number, num_hidden, alpha, beta, dataset, sens_attr, predict_attr))
+                if len(model_type) == 1 and 'RHGN' in model_type:
+                    if predict_attr == 'final_gender_code':
+                        predict_attr = 'bin_gender'
+                    if sens_attr == 'age_level':
+                        sens_attr = 'bin_age'
+                    stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --gpu 0 --dataset_path ../ --max_lr {} --num_hidden {} --clip {} --epochs {} --label {} --sens_attr {} --type 1 --model_type RHGN --dataset_name {} --dataset_user_id_name userid --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, lr_rhgn, num_hidden, clip, epochs_rhgn, predict_attr, sens_attr, dataset))
+                # CatGCN
+                if len(model_type) == 1 and 'CatGCN' in model_type:
+                    if predict_attr == 'final_gender_code':
+                        predict_attr = 'bin_gender'
+                    if sens_attr == 'age_level':
+                        sens_attr = 'bin_age'
+                    stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --gpu 0 --lr {} --weight_decay {} --dropout 0.1 --diag-probe {} --graph-refining {} --aggr-pooling mean --grn_units {} --bi-interaction {} --nfm-units none --graph-layer pna --gnn-hops 1 --gnn-units none --aggr-style sum --balance-ratio 0.7 --sens_attr {} --label {} --dataset_name {} --dataset_path ../ --type 1 --model_type CatGCN --dataset_user_id_name userid --alpha 0.5 --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, lr_catgcn, weight_decay, diag_probe, graph_refining, grn_units, bi_interaction, sens_attr, predict_attr, dataset))
+
+                # FairGNN and RHGN
+                if len(model_type) == 2 and 'FairGNN' in model_type and 'RHGN' in model_type:
+                    if predict_attr == 'final_gender_code':
+                        label = 'bin_gender'
+                    if sens_attr == 'age_level':
+                        sens_attr_rhgn = 'bin_age'
+                    stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --epochs {} --model GCN --sens_number {} --num_hidden {} --acc 0.20 --roc 0.20 --alpha {} --beta {} --dataset_name {} --dataset_path ../nba.csv --dataset_user_id_name user_id --model_type FairGNN RHGN --type 1 --sens_attr {} --label {} --predict_attr {} --label_number 100 --no-cuda True --max_lr {} --clip {} --epochs_rhgn {}  --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, epochs_fairgnn, sens_number, num_hidden, alpha, beta, dataset, sens_attr, predict_attr, predict_attr, lr_rhgn, clip, epochs_rhgn))
+                    print('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && /home/abdelrazek/anaconda3/envs/test/bin/python3 -W ignore main.py --seed {} --epochs {} --model GCN --sens_number {} --num_hidden {} --acc 0.20 --roc 0.20 --alpha {} --beta {} --dataset_name {} --dataset_path ../nba.csv --dataset_user_id_name user_id --model_type FairGNN RHGN --type 1 --sens_attr {} --label {} --predict_attr {} --label_number 100 --no-cuda True --max_lr {} --clip {} --epochs_rhgn {}  --special_case True --neptune_project mohamed9/FairGNN-Alibaba --neptune_token eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vYXBwLm5lcHR1bmUuYWkiLCJhcGlfdXJsIjoiaHR0cHM6Ly9hcHAubmVwdHVuZS5haSIsImFwaV9rZXkiOiI0Nzc0MTIzMy0xMjRhLTQ0OGQtODE5Mi1mZjE3MDE0MGFhOGMifQ=='.format(seed, epochs_fairgnn, sens_number, num_hidden, alpha, beta, dataset, sens_attr, predict_attr, predict_attr, lr_rhgn, clip, epochs_rhgn))
+                    #stdin, stdout, stderr = ssh.exec_command('cd /home/abdelrazek/framework-for-fairness-analysis-and-mitigation-main && ls')
+                    
+                output_queue = queue.Queue()
+                output_thred = threading.Thread(target=read_output, args=(stderr, output_queue))
+                output_thred.start()
+                
+                while True:
+                    try:
+                        line = output_queue.get_nowait()
+                        #st.text(line)
+                    except queue.Empty:
+                        if output_thred.is_alive():
+                            continue
+                        else:
+                            break
+
+                output_thred.join()
+                all_output = []
+                for line in stdout:
+                    print(line.strip())
+                    #st.text(line.strip())
+                    if "Test_final:" in line and 'FairGNN' in model_type:
+                        result = line.strip()
+                        #st.text(result)
+                    if 'accuracy' in line and 'RHGN' in model_type:
+                        #st.text(line.strip())
+                        line = line.strip() + 'end'
+                        acc = re.search('accuracy                         (.+?)end', line)
+                        acc = acc.group(1)
+                        acc_rhgn = acc.split()[0]
+                    if 'F1 score:' in line:
+                        f1 = '.'.join(line.split('.')[0:2])
+                        f1_rhgn = '{:.3f}'.format(float(f1.split()[-1]))
+                    if 'Statistical Parity Difference (SPD):' in line:
+                        spd_rhgn = '{:.3f}'.format(float(line.split()[-1]))
+
+                    if 'Equal Opportunity Difference (EOD):' in line:
+                        eod_rhgn = '{:.3f}'.format(float(line.split()[-1]))
+
+                    if 'Overall Accuracy Equality Difference (OAED):' in line:
+                        oaed_rhgn = '{:.3f}'.format(float(line.split()[-1]))
+
+                    if 'Treatment Equality Difference (TED):' in line:
+                        ted_rhgn = '{:.3f}'.format(float(line.split()[-1]))
+                    #all_output.append(line.strip())
+                # Close the connection
+                ssh.close()
+
+            st.success("Done!")
+
+            
+            st.markdown("## Training Results:")
+            print(len(model_type))
+            print(model_type)
+            if len(model_type) == 1 and 'FairGNN' in model_type:
+                st.text(result)
+                acc = re.search('accuracy:(.+?)roc', result)
+                f1 = re.search('F1:(.+?)acc_sens', result)
+
+                spd = re.search('parity:(.+?)equality', result)
+                eod = re.search('equality:(.+?)oaed', result)
+                oaed = re.search('oaed:(.+?)treatment equality', result)
+                ted = re.search('treatment equality(.+?)end', result)
+                data = {'Model': [model_type],
+                    'Accuracy': [acc.group(1)],
+                    'F1': [f1.group(1)],
+                    'SPD': [spd.group(1)],
+                    'EOD': [eod.group(1)],
+                    'OAED': [oaed.group(1)],
+                    'TED': [ted.group(1)]
+                    }
+                
+            elif len(model_type) == 1 and 'RHGN' in model_type:
+                #print('all_output:', all_output)
+                data =  {'Model': [model_type],
+                'Accuracy': [acc_rhgn],
+                'F1': [f1_rhgn],
+                'SPD': [spd_rhgn],
+                'EOD': [eod_rhgn],
+                'OAED': [oaed_rhgn],
+                'TED': [ted_rhgn]
+                }
+
+            elif len(model_type) == 2 and 'RHGN' in model_type and 'FairGNN' in model_type:
+
+                acc = re.search('a:(.+?)roc', result)
+                f1 = re.search('F1:(.+?)acc_sens', result)
+
+                spd = re.search('parity:(.+?)equality', result)
+                eod = re.search('equality:(.+?)oaed', result)
+                oaed = re.search('oaed:(.+?)treatment equality', result)
+                ted = re.search('treatment equality(.+?)end', result)
+
+                ind_fairgnn = model_type.index('FairGNN')
+                ind_rhgn = model_type.index('RHGN')
+                data =  {'Model': [model_type[ind_fairgnn], model_type[ind_rhgn]],
+                'Prediction label': [predict_attr, predict_attr],
+                'Sensitive attribute': [sens_attr, sens_attr],
+                'Accuracy': [acc.group(1), acc_rhgn],
+                'F1': [f1.group(1), f1_rhgn],
+                'SPD': [spd.group(1), spd_rhgn],
+                'EOD': [eod.group(1), eod_rhgn],
+                'OAED': [oaed.group(1), oaed_rhgn],
+                'TED': [ted.group(1), ted_rhgn]
+                }
+
+            df = pd.DataFrame(data)
+
+            #st.dataframe(df, width=5000)
+            # set the display options for the DataFrame
+            pd.set_option("display.max_columns", None)
+            pd.set_option("display.width", 100)
+
+            
+
+            # display the DataFrame in Streamlit
+            st.write(df)
+
+        #st.write("The logs of the experiment can be found at: mohamed9/Experiments-RHGN-CatGCN-Alibaba")
+        #st.markdown("The logs of the experiment can be found at: **mohamed9/Experiments-RHGN-FairGNN-Alibaba**")

requirements.txt

@@ -0,0 +1,3 @@
+paramiko==2.8.1
+
+

src/aif360/__init__.py

@@ -0,0 +1,4 @@
+try:
+    from .version import version as __version__
+except ImportError:
+    pass

src/aif360/aif360-r/.Rbuildignore

@@ -0,0 +1,12 @@
+^.*\.Rproj$         # Automatically added by RStudio,
+^\.Rproj\.user$     # used for temporary files.
+^README\.Rmd$       # An Rmarkdown file used to generate README.md
+^NEWS\.md$          # A news file written in Markdown
+^\.travis\.yml$     # Used for continuous integration testing with travis
+^LICENSE\.md$
+^raif360\.Rproj$
+^README\.Rmd$
+^CONDUCT\.md$
+^CONTRIBUTING\.md$
+^CODEOFCONDUCT\.md$
+^cran-comments\.md$

src/aif360/aif360-r/.gitignore

@@ -0,0 +1,7 @@
+.Rproj.user
+.Rhistory
+.RData
+.Ruserdata
+.httr-oauth
+.*.Rnb.cached
+.DS_Store

src/aif360/aif360-r/CODEOFCONDUCT.md

@@ -0,0 +1,44 @@
+
+# Contributor Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/),
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.

src/aif360/aif360-r/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+# Contributing to the AIF360 R package
+
+This guide is divided into three main parts:
+
+1. Filing a bug report or feature request in an issue.
+2. Suggesting a change via a pull request.
+3. New features or enhancements to AIF360 functionality.
+
+If you're not familiar with git or GitHub, please start by reading <http://r-pkgs.had.co.nz/git.html>
+
+Please note that the AIF360 R package is released with a [Contributor Code of Conduct](CODEOFCONDUCT.md). By contributing to this project,
+you agree to abide by its terms.
+
+## Issues
+
+If you find a bug, please search GitHub under [Issues](https://github.com/Trusted-AI/AIF360/issues) to ensure the bug was not already reported.
+If you’re unable to find an open issue addressing the problem, [open a new one](https://github.com/Trusted-AI/AIF360/issues/new). Please include a title and clear description, as much relevant information as possible (such as required packages, data, etc.), and a code sample to replicate the issue.
+
+## Pull requests
+
+To contribute a change to the AIF360 R package, you follow these steps:
+
+* Create a branch in git and make your changes.
+* Push branch to GitHub and open a new pull request (PR).
+* Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.
+
+## New Features
+
+The AIF360 R package is part of [AI Fairness 360](https://github.com/Trusted-AI/AIF360), developed with extensibility in mind. If you wish to suggest new metrics, explainers, algorithms or datasets. Please get in touch on [Slack]( https://aif360.slack.com) (invitation [here](https://aif360.slack.com/join/shared_invite/zt-5hfvuafo-X0~g6tgJQ~7tIAT~S294TQ))!
+

src/aif360/aif360-r/DESCRIPTION

@@ -0,0 +1,24 @@
+Package: aif360
+Type: Package
+Title: Help Detect and Mitigate Bias in Machine Learning Models
+Version: 0.1.0
+Authors@R: c(
+    person("Gabriela", "de Queiroz", email = "[email protected]", role = "aut"),
+    person("Stacey", "Ronaghan", email = "[email protected]", role = "aut"),
+    person("Saishruthi", "Swaminathan", email = "[email protected]",
+    role = c("aut", "cre")))
+Description: The AI Fairness 360 toolkit is an open-source library to help detect
+    and mitigate bias in machine learning models. The AI Fairness 360 R package includes
+    a comprehensive set of metrics for datasets and models to test for biases,
+    explanations for these metrics, and algorithms to mitigate bias in datasets and models.
+License: Apache License (>= 2.0)
+Encoding: UTF-8
+LazyData: true
+URL: https://github.com/Trusted-AI/AIF360
+BugReports: https://github.com/Trusted-AI/AIF360/issues
+Imports:
+    reticulate,
+    rstudioapi
+RoxygenNote: 7.2.0
+Suggests:
+    testthat

src/aif360/aif360-r/LICENSE.md

@@ -0,0 +1,194 @@
+Apache License
+==============
+
+_Version 2.0, January 2004_
+_&lt;<http://www.apache.org/licenses/>&gt;_
+
+### Terms and Conditions for use, reproduction, and distribution
+
+#### 1. Definitions
+
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+“Licensor” shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+“Legal Entity” shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, “control” means **(i)** the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+outstanding shares, or **(iii)** beneficial ownership of such entity.
+
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+“Source” form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+“Object” form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+“Work” shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+“Derivative Works” shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+“Contribution” shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+“submitted” means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as “Not a Contribution.”
+
+“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+#### 2. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+* **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+* **(b)** You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+* **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+* **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+_END OF TERMS AND CONDITIONS_
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets `[]` replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same “printed page” as the copyright notice for easier identification within
+third-party archives.
+
+    Copyright 2020-2021 The AI Fairness 360 (AIF360) Authors
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.

src/aif360/aif360-r/NAMESPACE

@@ -0,0 +1,24 @@
+# Generated by roxygen2: do not edit by hand
+
+export(adult_dataset)
+export(adversarial_debiasing)
+export(bank_dataset)
+export(binary_label_dataset)
+export(binary_label_dataset_metric)
+export(classification_metric)
+export(compas_dataset)
+export(disparate_impact_remover)
+export(german_dataset)
+export(install_aif360)
+export(law_school_gpa_dataset)
+export(load_aif360_lib)
+export(prejudice_remover)
+export(reject_option_classification)
+export(reweighing)
+importFrom(reticulate,import)
+importFrom(reticulate,py_dict)
+importFrom(reticulate,py_suppress_warnings)
+importFrom(reticulate,py_to_r)
+importFrom(reticulate,r_to_py)
+importFrom(utils,file_test)
+importFrom(utils,read.csv)

src/aif360/aif360-r/R/binary_label_dataset_metric.R

@@ -0,0 +1,43 @@
+#' Binary Label Dataset Metric
+#' @description Class for computing metrics on an aif360 compatible dataset with binary labels.
+#' @param dataset A aif360 compatible dataset.
+#' @param privileged_groups Privileged groups. List containing privileged protected attribute name and value of the privileged protected attribute.
+#' @param unprivileged_groups Unprivileged groups. List containing unprivileged protected attribute name and value of the unprivileged protected attribute.
+#' @usage
+#' binary_label_dataset_metric(dataset, privileged_groups, unprivileged_groups)
+#' @examples
+#' \dontrun{
+#' load_aif360_lib()
+#' # Load the adult dataset
+#' adult_dataset <- adult_dataset()
+#'
+#' # Define the groups
+#' privileged_groups <- list("race", 1)
+#' unprivileged_groups <- list("race", 0)
+#'
+#' # Metric for Binary Label Dataset
+#' bm <- binary_label_dataset_metric(dataset = adult_dataset,
+#'                                   privileged_groups = privileged_groups,
+#'                                   unprivileged_groups = unprivileged_groups)
+#'
+#' # Difference in mean outcomes between unprivileged and privileged groups
+#' bm$mean_difference()
+#' }
+#' @seealso
+#' \href{https://aif360.readthedocs.io/en/latest/modules/metrics.html#aif360.metrics.BinaryLabelDatasetMetric}{Explore available binary label dataset metrics here}
+#'
+#' Available metrics are: base_rate, consistency, disparate_impact, mean_difference, num_negatives, num_positives and statistical_parity_difference.
+#' @export
+#' @importFrom reticulate py_suppress_warnings py_to_r
+#'
+binary_label_dataset_metric <- function(dataset,
+                                        privileged_groups,
+                                        unprivileged_groups){
+
+  p_dict <- dict_fn(privileged_groups)
+  u_dict <- dict_fn(unprivileged_groups)
+
+  return(metrics$BinaryLabelDatasetMetric(dataset,
+                                          privileged_groups = p_dict,
+                                          unprivileged_groups = u_dict))
+}

src/aif360/aif360-r/R/classification_metric.R

@@ -0,0 +1,114 @@
+#' Classification Metric
+#' @description
+#' Class for computing metrics based on two BinaryLabelDatasets. The first dataset is the original one and the second is the output of the classification transformer (or similar)
+#' @param dataset (BinaryLabelDataset) Dataset containing ground-truth labels
+#' @param classified_dataset (BinaryLabelDataset) Dataset containing predictions
+#' @param privileged_groups Privileged groups. List containing privileged protected attribute name and value of the privileged protected attribute.
+#' @param unprivileged_groups Unprivileged groups. List containing unprivileged protected attribute name and value of the unprivileged protected attribute.
+#' @usage
+#' classification_metric(dataset, classified_dataset, unprivileged_groups, privileged_groups)
+#' @examples
+#' \dontrun{
+#' load_aif360_lib()
+#' # Input dataset
+#' data <- data.frame("feat" = c(0,0,1,1,1,1,0,1,1,0), "label" = c(1,0,0,1,0,0,1,0,1,1))
+#' # Create aif compatible input dataset
+#' act <- aif360::binary_label_dataset(data_path = data,  favor_label=0, unfavor_label=1,
+#'                             unprivileged_protected_attribute=0,
+#'                             privileged_protected_attribute=1,
+#'                             target_column="label", protected_attribute="feat")
+#' # Classified dataset
+#' pred_data <- data.frame("feat" = c(0,0,1,1,1,1,0,1,1,0), "label" = c(1,0,1,1,1,0,1,0,0,1))
+#' # Create aif compatible classified dataset
+#' pred <- aif360::binary_label_dataset(data_path = pred_data,  favor_label=0, unfavor_label=1,
+#'                              unprivileged_protected_attribute=0,
+#'                              privileged_protected_attribute=1,
+#'                              target_column="label", protected_attribute="feat")
+#' # Create an instance of classification metric
+#' cm <- classification_metric(act, pred, list('feat', 1), list('feat', 0))
+#' # Access metric functions
+#' cm$accuracy()
+#' }
+#' @seealso
+#' \href{https://aif360.readthedocs.io/en/latest/modules/metrics.html#classification-metric}{Explore available classification metrics explanations here}
+#'
+#' Available metrics:
+#' \itemize{
+#'   \item accuracy
+#'   \item average_abs_odds_difference
+#'   \item average_odds_difference
+#'   \item between_all_groups_coefficient_of_variation
+#'   \item between_all_groups_generalized_entropy_index
+#'   \item between_all_groups_theil_index
+#'   \item between_group_coefficient_of_variation
+#'   \item between_group_generalized_entropy_index
+#'   \item between_group_theil_index
+#'   \item binary_confusion_matrix
+#'   \item coefficient_of_variation
+#'   \item disparate_impact
+#'   \item equal_opportunity_difference
+#'   \item error_rate
+#'   \item error_rate_difference
+#'   \item error_rate_ratio
+#'   \item false_discovery_rate
+#'   \item false_discovery_rate_difference
+#'   \item false_discovery_rate_ratio
+#'   \item false_negative_rate
+#'   \item false_negative_rate_difference
+#'   \item false_negative_rate_ratio
+#'   \item false_omission_rate
+#'   \item false_omission_rate_difference
+#'   \item false_omission_rate_ratio
+#'   \item false_positive_rate
+#'   \item false_positive_rate_difference
+#'   \item false_positive_rate_ratio
+#'   \item generalized_binary_confusion_matrix
+#'   \item generalized_entropy_index
+#'   \item generalized_false_negative_rate
+#'   \item generalized_false_positive_rate
+#'   \item generalized_true_negative_rate
+#'   \item generalized_true_positive_rate
+#'   \item negative_predictive_value
+#'   \item num_false_negatives
+#'   \item num_false_positives
+#'   \item num_generalized_false_negatives
+#'   \item num_generalized_false_positives
+#'   \item num_generalized_true_negatives
+#'   \item num_generalized_true_positives
+#'   \item num_pred_negatives
+#'   \item num_pred_positives
+#'   \item num_true_negatives
+#'   \item num_true_positives
+#'   \item performance_measures
+#'   \item positive_predictive_value
+#'   \item power
+#'   \item precision
+#'   \item recall
+#'   \item selection_rate
+#'   \item sensitivity
+#'   \item specificity
+#'   \item statistical_parity_difference
+#'   \item theil_index
+#'   \item true_negative_rate
+#'   \item true_positive_rate
+#'   \item true_positive_rate_difference
+#'
+#' }
+#' @export
+#' @importFrom reticulate py_suppress_warnings
+#'
+classification_metric <- function(dataset,
+                                  classified_dataset,
+                                  unprivileged_groups,
+                                  privileged_groups){
+
+  u_dict <- dict_fn(unprivileged_groups)
+
+  p_dict <- dict_fn(privileged_groups)
+
+
+  return(metrics$ClassificationMetric(dataset,
+                                      classified_dataset,
+                                      unprivileged_groups = u_dict,
+                                      privileged_groups = p_dict))
+}

src/aif360/aif360-r/R/dataset.R

@@ -0,0 +1,71 @@
+#' AIF360 dataset
+#' @description
+#' Function to create AIF compatible dataset.
+#' @param data_path Path to the input CSV file or a R dataframe.
+#' @param favor_label Label value which is considered favorable (i.e. “positive”).
+#' @param unfavor_label Label value which is considered unfavorable (i.e. “negative”).
+#' @param unprivileged_protected_attribute A unprotected attribute value which is considered privileged from a fairness perspective.
+#' @param privileged_protected_attribute A protected attribute value which is considered privileged from a fairness perspective.
+#' @param target_column Name describing the label.
+#' @param protected_attribute A feature for which fairness is desired.
+#' @usage
+#' binary_label_dataset(data_path,  favor_label, unfavor_label,
+#'                      unprivileged_protected_attribute,
+#'                      privileged_protected_attribute,
+#'                      target_column, protected_attribute)
+#' @examples
+#' \dontrun{
+#' load_aif360_lib()
+#' # Input dataset
+#' data <- data.frame("feat" = c(0,0,1,1,1,1,0,1,1,0), "label" = c(1,0,0,1,0,0,1,0,1,1))
+#' # Create aif compatible input dataset
+#' act <- aif360::binary_label_dataset(data_path = data,  favor_label=0, unfavor_label=1,
+#'                             unprivileged_protected_attribute=0,
+#'                             privileged_protected_attribute=1,
+#'                             target_column="label", protected_attribute="feat")
+#' }
+#' @seealso
+#' \href{https://aif360.readthedocs.io/en/latest/modules/datasets.html#binary-label-dataset}{More about AIF binary dataset.}
+#' @export
+#' @importFrom reticulate py_suppress_warnings py_dict r_to_py
+#' @importFrom utils file_test
+#'
+binary_label_dataset <- function(data_path, favor_label,
+                        unfavor_label, unprivileged_protected_attribute,
+                        privileged_protected_attribute,
+                        target_column, protected_attribute) {
+
+  if (is.data.frame(data_path)) {
+    dataframe <- r_to_py(data_path)
+  } else if (file_test("-f", data_path) == TRUE) {
+    dataframe = input_data(data_path)
+  }
+  unprivileged_protected_list <- list_of_list(unprivileged_protected_attribute)
+  privileged_protected_list <- list_of_list(privileged_protected_attribute)
+  target_column_list <- list_fn(target_column)
+  protected_attribute_list <- list_fn(protected_attribute)
+
+  return(datasets$BinaryLabelDataset(df = dataframe,
+                                     favorable_label = favor_label,
+                                     unfavorable_label = unfavor_label,
+                                     unprivileged_protected_attributes = unprivileged_protected_list,
+                                     privileged_protected_attributes = privileged_protected_list,
+                                     label_names = target_column_list,
+                                     protected_attribute_names = protected_attribute_list))
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

src/aif360/aif360-r/R/dataset_metric.R

@@ -0,0 +1,42 @@
+#' Dataset Metric
+#' @description
+#' Class to provide access to functions for computing metrics on an aif360 compatible dataset
+#'
+#' @param data A aif360 compatible dataset
+#' @param privileged_groups  Privileged groups. List containing privileged protected attribute name and value of the privileged protected attribute.
+#' @param unprivileged_groups  Unprivileged groups. List containing unprivileged protected attribute name and value of the unprivileged protected attribute.
+#' @usage
+#' dataset_metric(data, privileged_groups, unprivileged_groups)
+#' @examples
+#' \dontrun{
+#' load_aif360_lib()
+#' data <- data.frame("feat" = c(0,0,1,1,1,1,0,1,1,0), "label" = c(1,0,0,1,0,0,1,0,1,1))
+#' # Create aif compatible dataset
+#' dd <- aif360::binary_label_dataset(data_path = data,
+#'                            favor_label=0, unfavor_label=1,
+#'                             unprivileged_protected_attribute=0,
+#'                             privileged_protected_attribute=1,
+#'                             target_column="label", protected_attribute="feat")
+#' # Create an instance of dataset metric
+#' dm <- dataset_metric(dd, list('feat', 1), list('feat',2))
+#' # Access metric functions
+#' dm$num_instances()
+#' }
+#' @seealso
+#' \href{https://aif360.readthedocs.io/en/latest/modules/metrics.html#dataset-metric}{Explore available dataset metrics here}
+#'
+#' Available metric: num_instances
+#' @noRd
+#' @importFrom reticulate py_suppress_warnings import
+#'
+dataset_metric <- function(data,
+                           privileged_groups,
+                           unprivileged_groups){
+
+   p_dict <- dict_fn(privileged_groups)
+   u_dict <- dict_fn(unprivileged_groups)
+
+   return(metrics$DatasetMetric(data,
+                                privileged_groups = p_dict,
+                                unprivileged_groups = u_dict))
+}

src/aif360/aif360-r/R/import.R

@@ -0,0 +1,23 @@
+#' load functions
+#' @export
+#'
+load_aif360_lib <- function() {
+  e <- globalenv()
+  bindings <- c("datasets", "metrics", "pre_algo", "in_algo", "post_algo", "tf")
+  if (!all(bindings %in% ls(e))){
+    e$datasets <- import("aif360.datasets")
+    e$metrics <- import("aif360.metrics")
+    e$pre_algo <- import("aif360.algorithms.preprocessing")
+    e$in_algo <- import("aif360.algorithms.inprocessing")
+    e$post_algo <- import("aif360.algorithms.postprocessing")
+    e$tf <- import("tensorflow")
+    lockBinding("datasets", e)
+    lockBinding("metrics", e)
+    lockBinding("pre_algo", e)
+    lockBinding("in_algo", e)
+    lockBinding("post_algo", e)
+    lockBinding("tf", e)
+  } else {
+    message("The aif360 functions have already been loaded. You can begin using the package.")
+  }
+}

src/aif360/aif360-r/R/inprocessing_adversarial_debiasing.R

@@ -0,0 +1,73 @@
+#' Adversarial Debiasing
+#' @description Adversarial debiasing is an in-processing technique that learns a classifier to maximize prediction accuracy 
+#' and simultaneously reduce an adversary's ability to determine the protected attribute from the predictions
+#' @param unprivileged_groups A list with two values: the column of the protected class and the value indicating representation for unprivileged group.
+#' @param privileged_groups A list with two values: the column of the protected class and the value indicating representation for privileged group.
+#' @param scope_name Scope name for the tensorflow variables.
+#' @param sess tensorflow session
+#' @param seed Seed to make \code{predict} repeatable. If not, \code{NULL}, must be an integer.
+#' @param adversary_loss_weight Hyperparameter that chooses the strength of the adversarial loss.
+#' @param num_epochs Number of training epochs. Must be an integer.
+#' @param batch_size Batch size. Must be an integer.
+#' @param classifier_num_hidden_units Number of hidden units in the classifier model. Must be an integer.
+#' @param debias Learn a classifier with or without debiasing.
+#' @examples
+#' \dontrun{
+#' load_aif360_lib()
+#' ad <- adult_dataset()
+#' p <- list("race", 1)
+#' u <- list("race", 0)
+#'
+#' sess <- tf$compat$v1$Session()
+#'
+#' plain_model <- adversarial_debiasing(privileged_groups = p,
+#'                                      unprivileged_groups = u,
+#'                                      scope_name = "debiased_classifier",
+#'                                      debias = TRUE,
+#'                                      sess = sess)
+#'
+#' plain_model$fit(ad)
+#' ad_nodebiasing <- plain_model$predict(ad)
+#' }
+#' @export
+#'
+adversarial_debiasing <- function(unprivileged_groups, 
+                                  privileged_groups, 
+                                  scope_name = "current", 
+                                  sess = tf$compat$v1$Session(),
+                                  seed = NULL, 
+                                  adversary_loss_weight = 0.1, 
+                                  num_epochs = 50L, 
+                                  batch_size = 128L,
+                                  classifier_num_hidden_units = 200L, 
+                                  debias = TRUE) {
+  
+  
+  
+  unprivileged_dict <- dict_fn(unprivileged_groups)
+  privileged_dict <- dict_fn(privileged_groups)
+  
+  # run check for variables that must be integers
+  int_vars <- list(num_epochs = num_epochs, batch_size = batch_size, classifier_num_hidden_units = classifier_num_hidden_units)
+  
+  if (!is.null(seed)) int_vars <- append(int_vars, c(seed = seed))
+  
+  is_int <- sapply(int_vars, is.integer)
+  int_varnames <- names(int_vars)
+  
+  if (any(!is_int)) stop(paste(int_varnames[!is_int], collapse = ", "), " must be integer(s)")
+  
+  
+  
+  ad <- in_algo$AdversarialDebiasing(unprivileged_dict, 
+                                     privileged_dict, 
+                                     scope_name = scope_name, 
+                                     sess = sess,
+                                     seed = seed, 
+                                     adversary_loss_weight = adversary_loss_weight,
+                                     num_epochs = num_epochs,
+                                     batch_size = batch_size,
+                                     classifier_num_hidden_units = classifier_num_hidden_units, 
+                                     debias = debias)
+  return(ad)
+}

src/aif360/aif360-r/R/inprocessing_prejudice_remover.R

@@ -0,0 +1,26 @@
+#' Prejudice Remover
+#' @description Prejudice remover is an in-processing technique that adds a discrimination-aware regularization term to the learning objective
+#' @param eta fairness penalty parameter
+#' @param sensitive_attr name of protected attribute
+#' @param class_attr label name
+#' @usage prejudice_remover(eta=1.0, sensitive_attr='',class_attr='')
+#' @examples
+#' \dontrun{
+#' # An example using the Adult Dataset
+#' load_aif360_lib()
+#' ad <- adult_dataset()
+#' model <- prejudice_remover(class_attr = "income-per-year", sensitive_attr = "race")
+#' model$fit(ad)
+#' ad_pred <- model$predict(ad)
+#'}
+#' @export
+#'
+prejudice_remover <- function(eta=1.0,
+                              sensitive_attr='',
+                              class_attr=''){
+
+  pr <- in_algo$PrejudiceRemover(eta,
+                                 sensitive_attr,
+                                 class_attr)
+  return(pr)
+}

src/aif360/aif360-r/R/postprocessing_reject_option_classification.R

@@ -0,0 +1,85 @@
+#' Reject option classification
+#'
+#' @description Reject option classification  is a postprocessing technique that gives
+#' favorable outcomes to unpriviliged groups and unfavorable outcomes to
+#' priviliged groups in a confidence band around the decision boundary with
+#' the highest uncertainty.
+#' @param unprivileged_groups A list epresentation for unprivileged group.
+#' @param privileged_groups A list representation for privileged group.
+#' @param low_class_thresh Smallest classification threshold to use in the optimization. Should be between 0. and 1.
+#' @param high_class_thresh Highest classification threshold to use in the optimization. Should be between 0. and 1.
+#' @param num_class_thresh Number of classification thresholds between low_class_thresh and high_class_thresh for the optimization search. Should be > 0.
+#' @param num_ROC_margin Number of relevant ROC margins to be used in the optimization search. Should be > 0.
+#' @param metric_name Name of the metric to use for the optimization. Allowed options are "Statistical parity difference", "Average odds difference", "Equal opportunity difference".
+#' @param metric_ub Upper bound of constraint on the metric value
+#' @param metric_lb Lower bound of constraint on the metric value
+#' @examples
+#' \dontrun{
+#' # Example with Adult Dataset
+#' load_aif360_lib()
+#' ad <- adult_dataset()
+#' p <- list("race",1)
+#' u <- list("race", 0)
+#'
+#' col_names <- c(ad$feature_names, "label")
+#' ad_df <- data.frame(ad$features, ad$labels)
+#' colnames(ad_df) <- col_names
+#'
+#' lr <- glm(label ~ ., data=ad_df, family=binomial)
+#'
+#' ad_prob <- predict(lr, ad_df)
+#' ad_pred <- factor(ifelse(ad_prob> 0.5,1,0))
+#'
+#' ad_df_pred <- data.frame(ad_df)
+#' ad_df_pred$label <- as.character(ad_pred)
+#' colnames(ad_df_pred) <- c(ad$feature_names, 'label')
+#'
+#' ad_ds <- binary_label_dataset(ad_df, target_column='label', favor_label = 1,
+#'                      unfavor_label = 0, unprivileged_protected_attribute = 0,
+#'                      privileged_protected_attribute = 1, protected_attribute='race')
+#'
+#' ad_ds_pred <- binary_label_dataset(ad_df_pred, target_column='label', favor_label = 1,
+#'                unfavor_label = 0, unprivileged_protected_attribute = 0,
+#'                privileged_protected_attribute = 1, protected_attribute='race')
+#'
+#' roc <- reject_option_classification(unprivileged_groups = u,
+#'                                    privileged_groups = p,
+#'                                    low_class_thresh = 0.01,
+#'                                    high_class_thresh = 0.99,
+#'                                    num_class_thresh = as.integer(100),
+#'                                    num_ROC_margin = as.integer(50),
+#'                                    metric_name = "Statistical parity difference",
+#'                                    metric_ub = 0.05,
+#'                                    metric_lb = -0.05)
+#'
+#' roc <- roc$fit(ad_ds, ad_ds_pred)
+#'
+#' ds_transformed_pred <- roc$predict(ad_ds_pred)
+#' }
+#' @export
+#'
+reject_option_classification <- function(unprivileged_groups,
+                                         privileged_groups,
+                                         low_class_thresh=0.01,
+                                         high_class_thresh=0.99,
+                                         num_class_thresh=as.integer(100),
+                                         num_ROC_margin=as.integer(50),
+                                         metric_name='Statistical parity difference',
+                                         metric_ub=0.05,
+                                         metric_lb=-0.05){
+
+  u_dict <- dict_fn(unprivileged_groups)
+  p_dict <- dict_fn(privileged_groups)
+
+  return(post_algo$RejectOptionClassification(u_dict,
+                                              p_dict,
+                                              low_class_thresh,
+                                              high_class_thresh,
+                                              num_class_thresh,
+                                              num_ROC_margin,
+                                              metric_name,
+                                              metric_ub,
+                                              metric_lb))
+}
+
+

src/aif360/aif360-r/R/preprocessing_disparate_impact_remover.R

@@ -0,0 +1,27 @@
+#' Disparate Impact Remover
+#' @description Disparate impact remover is a preprocessing technique that edits feature values increase group fairness while preserving rank-ordering within groups
+#' @param repair_level Repair amount. 0.0 is no repair while 1.0 is full repair.
+#' @param sensitive_attribute Single protected attribute with which to do repair.
+#' @usage disparate_impact_remover(repair_level = 1.0, sensitive_attribute = '')
+#' @examples
+#' \dontrun{
+#' # An example using the Adult Dataset
+#' load_aif360_lib()
+#' ad <- adult_dataset()
+#' p <- list("race", 1)
+#' u <- list("race", 0)
+#'
+#' di <- disparate_impact_remover(repair_level = 1.0, sensitive_attribute = "race")
+#' rp <- di$fit_transform(ad)
+#'
+#' di_2 <- disparate_impact_remover(repair_level = 0.8, sensitive_attribute = "race")
+#' rp_2 <- di_2$fit_transform(ad)
+#' }
+#' @export
+#'
+disparate_impact_remover <- function(repair_level=1.0, sensitive_attribute='') {
+  dr <- pre_algo$DisparateImpactRemover(repair_level, sensitive_attribute)
+  return (dr)
+}
+
+

src/aif360/aif360-r/R/preprocessing_reweighing.R

@@ -0,0 +1,25 @@
+#' Reweighing
+#' @description  Reweighing is a preprocessing technique that weights the examples in each (group, label) combination differently to ensure fairness before classification
+#' @param unprivileged_groups a list with two values: the column of the protected class and the value indicating representation for unprivileged group
+#' @param privileged_groups  a list with two values: the column of the protected class and the value indicating representation for privileged group
+#' @usage reweighing(unprivileged_groups, privileged_groups)
+#' @examples
+#' \dontrun{
+#' # An example using the Adult Dataset
+#' load_aif360_lib()
+#' ad <- adult_dataset()
+#' p <- list("race", 1)
+#' u <- list("race", 0)
+#' rw <- reweighing(u,p)
+#' rw$fit(ad)
+#' ad_transformed <- rw$transform(ad)
+#' ad_fit_transformed <- rw$fit_transform(ad)
+#' }
+#' @export
+#'
+reweighing <- function(unprivileged_groups, privileged_groups) {
+  unprivileged_dict <- dict_fn(unprivileged_groups)
+  privileged_dict <- dict_fn(privileged_groups)
+  rw <- pre_algo$Reweighing(unprivileged_dict, privileged_dict)
+  return (rw)
+}

src/aif360/aif360-r/R/standard_datasets.R

@@ -0,0 +1,31 @@
+#' Adult Census Income Dataset
+#' @export
+adult_dataset <- function(){
+  return (datasets$AdultDataset())
+}
+
+#' Bank Dataset
+#' @export
+bank_dataset <- function(){
+  return (datasets$BankDataset())
+}
+
+#' Compas Dataset
+#' @export
+compas_dataset <- function(){
+  return (datasets$CompasDataset())
+}
+
+#' German Dataset
+#' @export
+german_dataset <- function(){
+  return (datasets$GermanDataset())
+}
+
+#' Law School GPA Dataset
+#'@seealso
+#' \href{https://aif360.readthedocs.io/en/latest/modules/generated/aif360.datasets.LawSchoolGPADataset.html#aif360.datasets.LawSchoolGPADataset}{More about the Law School GPA dataset.}
+#' @export
+law_school_gpa_dataset <- function(){
+  return (datasets$LawSchoolGPADataset())
+}

src/aif360/aif360-r/R/utils.R

@@ -0,0 +1,89 @@
+#' Install aif360 and its dependencies
+#'
+#' @inheritParams reticulate::conda_list
+#'
+#' @param method Installation method. By default, "auto" automatically finds a
+#'   method that will work in the local environment. Change the default to force
+#'   a specific installation method. Note that the "virtualenv" method is not
+#'   available on Windows. Note also
+#'   that since this command runs without privilege the "system" method is
+#'   available only on Windows.
+#'
+#' @param version AIF360 version to install. Specify "default" to install
+#'  the latest release.
+#'
+#' @param envname Name of Python environment to install within
+#'
+#' @param extra_packages Additional Python packages to install.
+#'
+#' @param restart_session Restart R session after installing (note this will
+#'   only occur within RStudio).
+#'
+#' @param conda_python_version the python version installed in the created conda
+#'   environment. Python 3.6 is installed by default.
+#'
+#' @param ... other arguments passed to [reticulate::conda_install()] or
+#'   [reticulate::virtualenv_install()].
+#'
+#'
+#' @export
+install_aif360 <- function(method = c("auto", "virtualenv", "conda"),
+                               conda = "auto",
+                               version = "default",
+                               envname = NULL,
+                               extra_packages = NULL,
+                               restart_session = TRUE,
+                               conda_python_version = "3.7",
+                               ...) {
+
+  method <- match.arg(method)
+
+  reticulate::py_install(
+    packages       = c("aif360", "numba", "BlackBoxAuditing", "tensorflow>=1.13.1,<2", "pandas", 
+                       "fairlearn==0.4.6", "protobuf==3.20.1"),
+    envname        = envname,
+    method         = method,
+    conda          = conda,
+    python_version = conda_python_version,
+    pip            = TRUE,
+    ...
+  )
+
+  cat("\nInstallation complete.\n\n")
+
+  if (restart_session && rstudioapi::hasFun("restartSession"))
+    rstudioapi::restartSession()
+
+  invisible(NULL)
+}
+
+#' Read CSV file
+#' @param inp data file
+#' @noRd
+#' @importFrom utils read.csv
+#'
+input_data <- function(inp){
+  read.csv(inp)
+}
+#' create a list
+#' @param i input for function
+#' @noRd
+#'
+list_fn <- function(i){
+  list(i)
+}
+#' create a list of list
+#' @param i input for function
+#' @noRd
+#'
+list_of_list <- function(i){
+  list(list(i))
+}
+#' Create dictionary
+#' @param values input
+#' @noRd
+#' @importFrom reticulate py_dict
+#'
+dict_fn <- function(values){
+  c(py_dict(c(values[[1]]),c(values[[2]]), convert = FALSE))
+}

src/aif360/aif360-r/R/zzz.R

@@ -0,0 +1,4 @@
+## quiets concerns of R CMD check re: the .'s that appear in pipelines
+if(getRversion() >= "2.15.1")
+    utils::globalVariables(c("datasets", "metrics", "tf", "pre_algo", "in_algo", "post_algo"))
+Globals <- list()

src/aif360/aif360-r/README.Rmd

@@ -0,0 +1,150 @@
+---
+output: github_document
+---
+
+<!-- README.md is generated from README.Rmd. Please edit that file -->
+
+```{r, include = FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  fig.path = "man/figures/README-",
+  out.width = "100%"
+)
+library(aif360)
+```
+
+# AI Fairness 360 (AIF360) R Package
+
+<!-- badges: start -->
+[![CRAN_Status_Badge](http://www.r-pkg.org/badges/version/aif360)](https://cran.r-project.org/package=aif360)
+<!-- badges: end -->
+
+## Overview
+
+The AI Fairness 360 toolkit is an open-source library to help detect and mitigate bias in machine learning models.
+The AI Fairness 360 R package includes a comprehensive set of metrics for datasets and models to test for biases, explanations for these metrics, and algorithms to mitigate bias in datasets and models.
+
+## Installation
+
+Install the CRAN version:
+
+```r
+install.packages("aif360")
+```
+
+Or install the development version from GitHub:
+
+``` r
+# install.packages("devtools")
+devtools::install_github("Trusted-AI/AIF360/aif360/aif360-r")
+```
+
+Then, use the install_aif360() function to install AIF360:
+
+``` r
+library(aif360)
+install_aif360()
+```
+
+## Installation methods
+
+AIF360 is distributed as a Python package and so needs to be installed within a Python environment on your system. By default, the install_aif360() function attempts to install AIF360 within an isolated Python environment (“r-reticulate”).
+
+You can check using `reticulate::conda_python()` and `reticulate::py_config()`
+ 
+### Suggested steps
+ 
+ 1)  Install reticulate  and check if you have miniconda installed. If you do, go to step 2.
+
+ ```r
+ install.packages("reticulate")
+ reticulate::conda_list()
+ ```
+ If you get an error: `Error: Unable to find conda binary. Is Anaconda installed?`, please install
+ miniconda
+ 
+```r
+reticulate::install_miniconda()
+```
+If everything worked, you should get the message: 
+
+`* Miniconda has been successfully installed at '/home/rstudio/.local/share/r-miniconda'.` 
+
+You can double check:
+
+```
+reticulate::conda_list()
+```
+You will get something like this:
+
+```
+          name                                                              python
+1  r-miniconda                   /home/rstudio/.local/share/r-miniconda/bin/python
+2 r-reticulate /home/rstudio/.local/share/r-miniconda/envs/r-reticulate/bin/python
+```
+
+
+2) You can create a new conda env and then configure which version of Python to use:
+
+```r
+reticulate::conda_create(envname = "r-test")
+reticulate::use_miniconda(condaenv = "r-test", required = TRUE)
+```
+Check that everything is working `reticulate::py_config()`.
+
+3) If you haven't yet, please install the aif360 package `install.packages("aif360")` and then
+install aif360 dependencies
+
+```r
+aif360::install_aif360(envname = "r-test")
+```
+Note that this step should take a few minutes and the R session will restart.
+
+4) You can now activate your Python environment
+```r
+reticulate::use_miniconda(condaenv = "r-test", required = TRUE)
+```
+
+## Getting Started
+
+```r
+library(aif360)
+load_aif360_lib()
+```
+
+``` r
+# load a toy dataset
+data <- data.frame("feature1" = c(0,0,1,1,1,1,0,1,1,0),
+                   "feature2" = c(0,1,0,1,1,0,0,0,0,1),
+                   "label" = c(1,0,0,1,0,0,1,0,1,1))
+
+# format the dataset
+formatted_dataset <- aif360::binary_label_dataset(data_path = data,
+                                          favor_label = 0,
+                                          unfavor_label = 1,
+                                          unprivileged_protected_attribute = 0,
+                                          privileged_protected_attribute = 1,
+                                          target_column = "label",
+                                          protected_attribute = "feature1")
+
+```
+
+## Troubleshooting 
+
+If you encounter any errors during the installation process, look for your issue here and try the solutions.
+
+### Locked binding
+If you get an error: `cannot change value of locked binding`, please restart the R session. Then try reactivating your Python environment and running the following commands exactly once: 
+```r
+library(aif360) 
+load_aif360_lib()
+```
+
+## Contributing
+
+If you'd like to contribute to the development of aif360, please read [these guidelines](CONTRIBUTING.md).
+
+Please note that the aif360 project is released with a [Contributor Code of Conduct](CODEOFCONDUCT.md). By contributing to this project, you agree to abide by its terms.
+
+

src/aif360/aif360-r/README.md

@@ -0,0 +1,155 @@
+
+<!-- README.md is generated from README.Rmd. Please edit that file -->
+
+# AI Fairness 360 (AIF360) R Package
+
+<!-- badges: start -->
+
+[![CRAN_Status_Badge](http://www.r-pkg.org/badges/version/aif360)](https://cran.r-project.org/package=aif360)
+<!-- badges: end -->
+
+## Overview
+
+The AI Fairness 360 toolkit is an open-source library to help detect and
+mitigate bias in machine learning models. The AI Fairness 360 R package
+includes a comprehensive set of metrics for datasets and models to test
+for biases, explanations for these metrics, and algorithms to mitigate
+bias in datasets and models.
+
+## Installation
+
+Install the CRAN version:
+
+``` r
+install.packages("aif360")
+```
+
+Or install the development version from GitHub:
+
+``` r
+# install.packages("devtools")
+devtools::install_github("Trusted-AI/AIF360/aif360/aif360-r")
+```
+
+Then, use the install_aif360() function to install AIF360:
+
+``` r
+library(aif360)
+install_aif360()
+```
+
+## Installation methods
+
+AIF360 is distributed as a Python package and so needs to be installed
+within a Python environment on your system. By default, the
+install_aif360() function attempts to install AIF360 within an isolated
+Python environment (“r-reticulate”).
+
+You can check using `reticulate::conda_python()` and
+`reticulate::py_config()`
+
+### Suggested steps
+
+1)  Install reticulate and check if you have miniconda installed. If you
+    do, go to step 2.
+
+``` r
+install.packages("reticulate")
+reticulate::conda_list()
+```
+
+If you get an error:
+`Error: Unable to find conda binary. Is Anaconda installed?`, please
+install miniconda
+
+``` r
+reticulate::install_miniconda()
+```
+
+If everything worked, you should get the message:
+
+`* Miniconda has been successfully installed at '/home/rstudio/.local/share/r-miniconda'.`
+
+You can double check:
+
+    reticulate::conda_list()
+
+You will get something like this:
+
+              name                                                              python
+    1  r-miniconda                   /home/rstudio/.local/share/r-miniconda/bin/python
+    2 r-reticulate /home/rstudio/.local/share/r-miniconda/envs/r-reticulate/bin/python
+
+2)  You can create a new conda env and then configure which version of
+    Python to use:
+
+``` r
+reticulate::conda_create(envname = "r-test")
+reticulate::use_miniconda(condaenv = "r-test", required = TRUE)
+```
+
+Check that everything is working `reticulate::py_config()`.
+
+3)  If you haven’t yet, please install the aif360 package
+    `install.packages("aif360")` and then install aif360 dependencies
+
+``` r
+aif360::install_aif360(envname = "r-test")
+```
+
+Note that this step should take a few minutes and the R session will
+restart.
+
+4)  You can now activate your Python environment
+
+``` r
+reticulate::use_miniconda(condaenv = "r-test", required = TRUE)
+```
+
+## Getting Started
+
+``` r
+library(aif360)
+load_aif360_lib()
+```
+
+``` r
+# load a toy dataset
+data <- data.frame("feature1" = c(0,0,1,1,1,1,0,1,1,0),
+                   "feature2" = c(0,1,0,1,1,0,0,0,0,1),
+                   "label" = c(1,0,0,1,0,0,1,0,1,1))
+
+# format the dataset
+formatted_dataset <- aif360::binary_label_dataset(data_path = data,
+                                          favor_label = 0,
+                                          unfavor_label = 1,
+                                          unprivileged_protected_attribute = 0,
+                                          privileged_protected_attribute = 1,
+                                          target_column = "label",
+                                          protected_attribute = "feature1")
+```
+
+## Troubleshooting
+
+If you encounter any errors during the installation process, look for
+your issue here and try the solutions.
+
+### Locked binding
+
+If you get an error: `cannot change value of locked binding`, please
+restart the R session. Then try reactivating your Python environment and
+running the following commands exactly once:
+
+``` r
+library(aif360) 
+load_aif360_lib()
+```
+
+## Contributing
+
+If you’d like to contribute to the development of aif360, please read
+[these guidelines](CONTRIBUTING.md).
+
+Please note that the aif360 project is released with a [Contributor Code
+of Conduct](CODEOFCONDUCT.md). By contributing to this project, you
+agree to abide by its terms.

src/aif360/aif360-r/cran-comments.md

@@ -0,0 +1,10 @@
+## Test environments
+* local R installation, R 4.0.0
+* ubuntu 16.04 (on travis-ci), R 4.0.0
+* win-builder (devel)
+
+## R CMD check results
+
+0 errors | 0 warnings | 1 note
+
+* This is a new release.

src/aif360/aif360-r/inst/examples/test.R

@@ -0,0 +1,20 @@
+library(aif360)
+install_aif360()
+
+
+load_aif360_lib()
+
+
+
+dd <- aif360::binary_label_dataset(
+  data_path = system.file("extdata", "data.csv", package="aif360"),
+  favor_label=0,
+  unfavor_label=1,
+  unprivileged_protected_attribute=0,
+  privileged_protected_attribute=1,
+  target_column="income",
+  protected_attribute="sex")
+
+dd$favorable_label
+dd$labels
+dd$unfavorable_label

src/aif360/aif360-r/inst/extdata/actual_data.csv

@@ -0,0 +1,21 @@
+age,workclass,fnlwgt,education,education-num,marital-status,occupation,relationship,race,sex,capital-gain,capital-loss,hours-per-week,native-country,income
+41,0,202822,11,9,5,0,1,2,0,0,0,32,39,0
+72,0,129912,11,9,2,0,0,4,1,0,0,25,39,0
+45,2,119199,7,12,0,10,4,4,0,0,0,48,39,0
+31,4,199655,12,14,0,8,1,3,0,0,0,30,39,0
+39,2,111499,7,12,2,1,5,4,0,0,0,20,39,1
+37,4,198216,7,12,0,13,1,4,0,0,0,40,39,0
+43,4,260761,11,9,2,7,0,4,1,0,0,40,26,0
+65,6,99359,14,15,4,10,1,4,1,1086,0,60,39,0
+43,7,255835,15,10,0,1,2,4,0,0,0,40,39,0
+43,6,27242,15,10,2,3,0,4,1,0,0,50,39,0
+32,4,34066,0,6,2,6,0,0,1,0,0,40,39,0
+43,4,84661,8,11,2,12,0,4,1,0,0,45,39,0
+32,4,116138,12,14,4,13,1,1,1,0,0,11,36,0
+53,4,321865,12,14,2,4,0,4,1,0,0,40,39,1
+22,4,310152,15,10,4,11,1,4,1,0,0,40,39,0
+27,4,257302,7,12,2,13,5,4,0,0,0,38,39,0
+40,4,154374,11,9,2,7,0,4,1,0,0,40,39,1
+58,4,151910,11,9,6,1,4,4,0,0,0,40,39,0
+22,4,201490,11,9,4,1,3,4,1,0,0,20,39,0
+52,5,287927,11,9,2,4,5,4,0,15024,0,40,39,1