1. clone the project

git clone https://github.com/muhai-project/mira.git

2. set up an environment (like anaconda) from the requirement.txt file

pip install -r requirements.txt

The semantify.py script turns research paper abstracts of papers on social demography into RDF according to the MIRA ontology. It does so by: (i) prompting a Large Language Model to annotate paper abstracts, (ii) mapping concepts to terms from NCBO BioPortal ontologies and Geonames. An example annotation is shown in the figure below:

To test the code, you can use the example paper_file.pkl file with papers on social health inequality.

python semantify.py --paper_file ../data/paper_file.pkl --api_key "your api key" --output ../data/test_output.ttl --max 1 --view 1

The location of the input file, the openAI api key, and the output file are required arguments. Max and view are optional and indicate how many papers to process, and whether to print the serialised RDF after each step. To check whether all works as expected, we recommend to first set these to 1 and True, before processing a large batch.

The --paper_file argument expects the location of a pickle file (.pkl) which consists of a list of dictionaries with the following keys: dict_keys(['paperId','title','abstract','year','publicationDate','authors','references']) These can, for instance, be retrieved from Semantic Scholar:

from semanticscholar import SemanticScholar

sch = SemanticScholar()
results = sch.search_paper('',year=, fields_of_study=[''])
papers = [sch.get_paper(result.paperId) for result in results]

You can use the validate.py script to validate the set against a set of SHACL shapes, developed according to a set of data quality criteria.

python validate.py --batch_file ../data/test_output.ttl --shacl_file ../validation/shacl-shapes.ttl --validation_output validation_results.ttl --view 1

How to use it

python /mira/muhai-project_mira/mira-main/code/semantify.py

This work was funded by the European MUHAI project (Horizon 2020 research and innovation program) under grant agreement number 951846. We thank Tobias Kuhn and Inès Blin for the insightful discussions that contributed to this work.

If using https, run:

git clone https://github.com/muhai-project/french_rev_narratives_code.git 
cd french_rev_narratives_code

If using ssh, run:

git clone git@github.com:muhai-project/french_rev_narratives_code.git
cd french_rev_narratives_code

In the settings folder, create a private.pyfile and add the following paramters:

• ROOT_PATH: root path to the project directory
• AGENT: your user agent that you can find on the web.

Version of Python used: 3.9.4

Create a virtual env and activate it (example below with conda)

conda create -n <yourenvname> python=3.9.4
conda activate <yourenvname>

pip install -r requirements.txt

Then run the following:

python setup.py install

git@github.com:muhai-project/french_rev_narratives_code.git

https://github.com/SonyCSLParis/building-fr-narrative-from-wikidata-1/tree/main

To run the streamlit app

cd app-demo && streamlit run app.py

Later when launching the app, you might encounter the following error:

ImportError: pycurl: libcurl link-time ssl backends (secure-transport, openssl) do not include compile-time ssl backend (none/other)

To prevent this error, and following this link, you can run the followings:

pip uninstall pycurl
export PYCURL_SSL_LIBRARY=openssl
pip install pycurl --no-cache-dir

Cf. requirements.txt

python /french_rev_narratives_code/muhai-project_french_rev_narratives_code/french_rev_narratives_code-main/kb_sparql/gather_events.py

The work reported in this paper was funded by the European MUHAI project from the Horizon 2020 research and innovation programme under grant number 951846 and the Sony Computer Science Laboratories Paris. This work is also the result of a joint collaboration between the following partners in the project: Sony CSL Paris & Vrije Universiteit Amsterdam

1. Clone Repository from Github
2. Connect Meta Quest Headset to PC via Quest Link
3. Start abe_sim
4. Start VR Kitchen Executable https://github.com/muhai-project

• Meta Quest Headset + Meta Quest Link installed
• Windows Operating System
• Working Installation of Abe_Sim

The VR enviroment can be used to run user studies on Human-Robot-Collaboration in a kitchen environment.

Support

When encountering any problems with the software please contact Rachel Ringe (University of Bremen) at rringe@uni-bremen.de.

This work was funded by the European MUHAI project (Horizon 2020 research and innovation program) under grant agreement number 951846.

This work was funded by the European MUHAI project (Horizon 2020 research and innovation program) under grant agreement number 951846.

Anaconda is probably the fastest way to get up and running with Python environments. However, the full Anaconda toolkit installs 1500 Python packages and takes up 3GB of disk space. A good alternative, therefore, is Miniconda. Miniconda will only install the bare minimum to run Python. It is then up to you to manually install the packages that you really need.

Download Miniconda from this website and follow the installation instructions. If you are prompted to add Miniconda to your .bash_profile or .zshrc, accept. For the changes to take effect and use conda from the command line, you must restart the Terminal. At the time of writing, the Miniconda website suggests to install Miniconda with Python 3.7.

The environment.yml file presents in this repository makes it easy to recreate the marl_language_games conda environment that was used to develop this project. This file lists all necessary packages and their version numbers. You can use the Makefile to setup this environment.

1. To recreate the marl_language_games conda environment that was used to develop this project, run:

   • make install_conda_env

2. If the environment was successfully created, you can activate it by running

   • conda activate marl_language_games
   • You should see the prompt of your Terminal change from (base) to (marl_language_games).

3. Then to install the marl_language_games package into the newly create (marl_language_games) environment, run:

   • make install_package
   • You should see the marl_language_games package when listing all dependencies of the environment through conda list.

   ├── cfg <- Configurations files for experiments │ ├── data <- The original, immutable logged experiments. │ ├── marl_language_games <- Source code for use in this project. │ ├── scripts <- Scripts of the marl_language_games package │ ├── tests <- Unit tests for marl_language_games package │ ├── Makefile <- Makefile with commands to create conda env │ ├── README.md <- The top-level README for developers using this project. │ ├── environment.yml <- The project's package dependency list for reproducing the environment │ ├── setup.py <- makes project pip installable (pip install -e .) so marl_language_games can be imported │ └── setup.cfg <- pytest, flake8, black and isort settings

This repository provides unit tests (with pytest) for the marl_language_games package in the tests/ folder. The conda environment associated with the environment.yml installs pytest. The tests can be run with pytest in the command-line.

python /marl_language_games/muhai-project_marl_language_games/marl_language_games-jole/scripts/run_competition.py

The research reported on in this paper was financed by the Research Foundation Flanders (FWO - Vlaanderen) through postdoctoral grants awarded to Paul Van Eecke (75929) and Roxana Rădulescu (1286223N), and by the European Union’s Horizon 2020 research and innovation programme under grant agreement no. 951846 (MUHAI - https://www.muhai.org).

https://github.com/muhai-project/shared_query_understanding

https://arxiv.org/abs/2305.09349, https://dl-acm-org.vu-nl.idm.oclc.org/doi/10.5555/3545946.3598649

To replicate the experiment results you need to first clone this repository and then "move" to that directory, by executing: git clone https://github.com/kondilidisn/shared_query_understanding cd shared_query_understanding You can create a new python environment and install all libraries mentioned in requirements.txt by executing: python3 -m venv venv/ source venv/bin/activate pip3 install -r requirements.txt The directory "dataset" already contains all preprocessed data needed to run the experiments. In case you want to replicate that process as well, you need to follow the next steps before running the experiments: mkdir dataset

ii) Download and unzip the original OA4QA track dataset (http://oaei.ontologymatching.org/2015/oa4qa/index.html):

wget http://oaei.ontologymatching.org/2015/oa4qa/oaei2015_oa4qa_bundle.zip
mv oaei2015_oa4qa_bundle.zip data_preparation/oaei2015_oa4qa_bundle.zip
unzip data_preparation/oaei2015_oa4qa_bundle.zip -d data_preparation/

iii) Translate their provided concept alignments to RDF OWL We do this because we RDFLib for our experiments which does not provide reasoning tools. We performed this step manually using Protégé, (https://protege.stanford.edu/), and unfortunately we do not provide some straightforward command lines to replicate it. You can by-pass this step by copying our provided and execute:

python /shared_query_understanding/muhai-project_shared_query_understanding/shared_query_understanding-main/main.py

This work was funded by the European MUHAI project (Horizon 2020 research and innovation program) under grant agreement number 951846, the Vrije Universiteit Amsterdam. We want to thank Frank van Harmelen for his continuous support and guidance.

Setup your free Apache Kafka instance here: https://www.cloudkarafka.com

Configuration

• export CLOUDKARAFKA_BROKERS="host1:9094,host2:9094,host3:9094" Hostnames can be found in the Details view in for your CloudKarafka instance.
• export CLOUDKARAFKA_USERNAME="username" Username can be found in the Details view in for your CloudKarafka instance.
• export CLOUDKARAFKA_PASSWORD="password" Password can be found in the Details view in for your CloudKarafka instance.
• export CLOUDKARAFKA_TOPIC="username-topic" Topic should be the same as your username followed by a dash before the topic.
• export CONSUMER_GROUP="your-name" Unique consumer group for multiple users in the tutorial.

These export commands must be run in both of the terminal windows below.

git clone https://github.com/muhai-project/python-kafka-example.git
cd python-kafka-example`
pip install confluent_kafka
python consumer.py

Open another terminal window and cd into same directory and run python producer.py. Send your messages by pressing your system's EOF key sequence. (ctrl-d in bash)

In some cases the CloudKarafka Root CA may need to be manually added to the example, particularly if you are seeing the error:

Failed to verify broker certificate: unable to get local issuer certificate 

returned when you run the example. If this is the case you will need to download the CloudKarakfa Root CA from our FAQ page and place it in the python-kafka-example directory, then add the following line into the conf {...} section:

'ssl.ca.location': 'cloudkarafka.ca'

This should resolve the error and allow for successful connection to the server.

How to use it

python /python-kafka-example/muhai-project_python-kafka-example/python-kafka-example-master/producer.py

The FCG editor, which is available for Microsoft Windows, macOS and Linux, allows you to quickly install and test Fluid Construction Grammar without having to set up a complete Lisp programming environment or the Babel software architecture. It includes all of the essential functionalities of FCG for rapidly defining and visualizing constructions in your web browser, and to develop grammar fragments that you can use for language comprehension and production. You can download the FCG Editor for free at this page.

This work was funded by the European MUHAI project (Horizon 2020 research and innovation program) under grant agreement number 951846, the European project AI4EU under grant agreement number 825619, and the Research Foundation Flanders (FWO) under grant agreement number 75929. Additional funding for the development of the tool was provided by Sony Computer Science Laboratories Paris.