diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..b2112bef8fbc672bd364d371a65518c6717851e1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,185 @@ + + +key.py + +*.pdf +*.json +*.png +*.jpg +*.jpeg +*.gif +data/ +unused_data/ +demo/ +Summary/ + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +outputs + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +.idea/ + +.DS_Store +hf-spaces/ +etc/ +.conda +*.xlsx +*.csv +*.zip diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7133ed2202141b35b15ddc60a6966e3b80cbb3ea --- /dev/null +++ b/LICENSE @@ -0,0 +1,203 @@ +Copyright 2023 ChatArena. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + 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 [yyyy] [name of copyright owner] + + 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. diff --git a/README.md b/README.md index 2163c5e9ce8b36a48c22a162a7a0f29dff45e077..9a4d8958fdd2605335465096ada059b30bc943e4 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,91 @@ +# AgentReview + +Official implementation for the 🔗[EMNLP 2024](https://2024.emnlp.org/) (main) paper: [AgentReview: Exploring Peer Review Dynamics with LLM Agents](https://arxiv.org/abs/2406.12708) + +* 🌐 Website: [https://agentreview.github.io/](https://agentreview.github.io/) +* 📄 Paper: [https://arxiv.org/abs/2406.12708](https://arxiv.org/abs/2406.12708) +* **🚀 Note: This repository is under construction development. Please stay tuned!!** + + + +```bibtex +@inproceedings{jin2024agentreview, + title={AgentReview: Exploring Peer Review Dynamics with LLM Agents}, + author={Jin, Yiqiao and Zhao, Qinlin and Wang, Yiyang and Chen, Hao and Zhu, Kaijie and Xiao, Yijia and Wang, Jindong}, + booktitle={EMNLP}, + year={2024} +} +``` + + + --- -title: AgentReview -emoji: 👁 -colorFrom: indigo -colorTo: pink -sdk: gradio -sdk_version: 5.4.0 -app_file: app.py -pinned: false -license: apache-2.0 -short_description: EMNLP 2024 ---- -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +### Introduction + +Agent4Review is a simulation framework for systematic analysis of the peer review process based on large language models (LLMs). This framework aims to understand decision-making patterns, reviewer behavior, and the dynamics of paper acceptance and rejection. + +### Academic Abstract + +Peer review is fundamental to the integrity and advancement of scientific publication. Traditional methods of peer review analyses often rely on exploration and statistics of existing peer review data, which do not adequately address the multivariate nature of the process, account for the latent variables, and are further constrained by privacy concerns due to the sensitive nature of the data. We introduce AgentReview, the first large language model (LLM) based peer review simulation framework, which effectively disentangles the impacts of multiple latent factors and addresses the privacy issue. Our study reveals significant insights, including a notable 37.1% variation in paper decisions due to reviewers' biases, supported by sociological theories such as the social influence theory, altruism fatigue, and authority bias. We believe that this study could offer valuable insights to improve the design of peer review mechanisms + + +![Review Stage Design](static/img/ReviewPipeline.png) + + +### Installation + +1. Download and unzip the [data](https://www.dropbox.com/scl/fi/mydblhx8yxk8kbz8b7zmr/AgentReview_data.zip?rlkey=se16p9gonclw5t8t3vn9p0o6n&st=6988u8lx&dl=0) under `data/`, which contains the PDF versions of the paper as well as the forum discussions for ICLR 2020 - 2023 +2. **Install Required Packages**: + ``` + cd AgentReview + pip install -r requirements.txt + ``` + +3. **Run the Project**: + + **Note: all project files should be run from the `AgentReview` directory.** + + +## Data + +#### Project Structure +- `app.py`: The main application file for running the framework. +- `analysis/`: Contains Python scripts for various statistical analyses of review data. +- `chatarena/`: Core module for simulating different review environments and integrating LLM backends. +- `dataset/`: Scripts for handling dataset operations, such as downloading and processing submissions. +- `demo/`: Demonstrative scripts showcasing the functionality of different components. +- `docs/`: Documentation files and markdown guides for using and extending the framework. +- `examples/`: Configuration files and examples to demonstrate the capabilities and setup of simulations. +- `experiments/`: Experimental scripts to test new ideas or improvements on the framework. +- `visual/`: Visualization scripts for generating insightful plots and charts from the simulation data. + +#### Usage + +**[UNDER CONSTRUCTION]** + + +### Stage Design + +Our simulation adopts a structured, 5-phase pipeline + +* **Phase I. Reviewer Assessment.** Each manuscript is evaluated by three reviewers independently. +* **Phase II. Author-Reviewer Discussion.** Authors submit rebuttals to address reviewers' concerns; +* **Phase III. Reviewer-AC Discussion.** The AC facilitates discussions among reviewers, prompting updates to their initial assessments. +* **Phase IV. Meta-Review Compilation.** The AC synthesizes the discussions into a meta-review. +* **Phase V. Paper Decision.** The AC makes the final decision on whether to accept or reject the paper, based on all gathered inputs. + +## Note + +- We use a fixed acceptance rate of 32%, corresponding to the actual acceptance rate of ICLR 2020 -- 2023. See [Conference Acceptance Rates](https://github.com/lixin4ever/Conference-Acceptance-Rate) for more information. +- Sometimes the API can apply strict filtering to the request. You may need to adjust the content filtering to get the desired results. + + + +## License + +This project is licensed under the Apache-2.0 License. + +## Acknowledgements + +The implementation is partially based on the [chatarena](https://github.com/Farama-Foundation/chatarena) framework. diff --git a/agentreview/__init__.py b/agentreview/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e8d2450cd8f5b4b49cddeba3e0b3cce4404b7842 --- /dev/null +++ b/agentreview/__init__.py @@ -0,0 +1,8 @@ +import os + +ROOT_DIR = ( + os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)) + os.path.sep +) +EXAMPLES_DIR = os.path.join(ROOT_DIR, "examples") + +__version__ = "0.1.16" diff --git a/agentreview/agent.py b/agentreview/agent.py new file mode 100644 index 0000000000000000000000000000000000000000..57e98e06038bff5cc2450e801ccaf4bd0ea88a65 --- /dev/null +++ b/agentreview/agent.py @@ -0,0 +1,253 @@ +import logging +import re +import uuid +from abc import abstractmethod +from argparse import Namespace +from typing import List, Union + +from tenacity import RetryError + +from .backends import IntelligenceBackend, load_backend +from .config import AgentConfig, BackendConfig, Configurable +from .message import SYSTEM_NAME, Message + +# A special signal sent by the player to indicate that it is not possible to continue the conversation, and it requests to end the conversation. +# It contains a random UUID string to avoid being exploited by any of the players. +SIGNAL_END_OF_CONVERSATION = f"<<<<<>>>>>{uuid.uuid4()}" + + +class Agent(Configurable): + """An abstract base class for all the agents in the chatArena environment.""" + + @abstractmethod + def __init__( + self, name: str, role_desc: str, global_prompt: str = None, *args, **kwargs + ): + """ + Initialize the agent. + + Parameters: + name (str): The name of the agent. + role_desc (str): Description of the agent's role. + global_prompt (str): A universal prompt that applies to all agents. Defaults to None. + """ + super().__init__( + name=name, role_desc=role_desc, global_prompt=global_prompt, **kwargs + ) + self.name = name + self.role_desc = role_desc + self.global_prompt = global_prompt + + +class Player(Agent): + """ + The Player class represents a player in the chatArena environment. + + A player can observe the environment + and perform an action (generate a response) based on the observation. + """ + + def __init__( + self, + name: str, + role_desc: str, + backend: Union[BackendConfig, IntelligenceBackend], + global_prompt: str = None, + args: Namespace = None, + **kwargs, + ): + """ + Initialize the player with a name, role description, backend, and a global prompt. + + Parameters: + name (str): The name of the player. + role_desc (str): Description of the player's role. + backend (Union[BackendConfig, IntelligenceBackend]): The backend that will be used for decision making. It can be either a LLM backend or a Human backend. + global_prompt (str): A universal prompt that applies to all players. Defaults to None. + """ + + self.data_dir = kwargs.pop("data_dir", None) + self.args = args + + if isinstance(backend, BackendConfig): + backend_config = backend + backend = load_backend(backend_config) + elif isinstance(backend, IntelligenceBackend): + backend_config = backend.to_config() + else: + raise ValueError( + f"backend must be a BackendConfig or an IntelligenceBackend, but got {type(backend)}" + ) + + assert ( + name != SYSTEM_NAME + ), f"Player name cannot be {SYSTEM_NAME}, which is reserved for the system." + + # Register the fields in the _config + super().__init__( + name=name, + role_desc=role_desc, + backend=backend_config, + global_prompt=global_prompt, + **kwargs, + ) + + self.backend = backend + + def to_config(self) -> AgentConfig: + return AgentConfig( + name=self.name, + role_desc=self.role_desc, + backend=self.backend.to_config(), + global_prompt=self.global_prompt, + ) + + def act(self, observation: List[Message]) -> str: + """ + Take an action based on the observation (Generate a response), which can later be parsed to actual actions that affect the game dynamics. + + Parameters: + observation (List[Message]): The messages that the player has observed from the environment. + + Returns: + str: The action (response) of the player. + """ + try: + response = self.backend.query( + agent_name=self.name, + role_desc=self.role_desc, + history_messages=observation, + global_prompt=self.global_prompt, + request_msg=None, + ) + except RetryError as e: + err_msg = f"Agent {self.name} failed to generate a response. Error: {e.last_attempt.exception()}. Sending signal to end the conversation." + logging.warning(err_msg) + response = SIGNAL_END_OF_CONVERSATION + err_msg + + return response + + def __call__(self, observation: List[Message]) -> str: + return self.act(observation) + + async def async_act(self, observation: List[Message]) -> str: + """ + Async version of act(). + + This is used when you want to generate a response asynchronously. + + Parameters: + observation (List[Message]): The messages that the player has observed from the environment. + + Returns: + str: The action (response) of the player. + """ + try: + response = self.backend.async_query( + agent_name=self.name, + role_desc=self.role_desc, + history_messages=observation, + global_prompt=self.global_prompt, + request_msg=None, + ) + except RetryError as e: + err_msg = f"Agent {self.name} failed to generate a response. Error: {e.last_attempt.exception()}. Sending signal to end the conversation." + logging.warning(err_msg) + response = SIGNAL_END_OF_CONVERSATION + err_msg + + return response + + def reset(self): + """ + Reset the player's backend in case they are not stateless. + + This is usually called at the end of each episode. + """ + self.backend.reset() + + +class Moderator(Player): + """ + The Moderator class represents a special type of player that moderates the conversation. + + It is usually used as a component of the environment when the transition dynamics is conditioned on natural language that are not easy to parse programmatically. + """ + + def __init__( + self, + role_desc: str, + backend: Union[BackendConfig, IntelligenceBackend], + terminal_condition: str, + global_prompt: str = None, + **kwargs, + ): + """ + Initialize the moderator with a role description, backend, terminal condition, and a global prompt. + + Parameters: + role_desc (str): Description of the moderator's role. + backend (Union[BackendConfig, IntelligenceBackend]): The backend that will be used for decision making. + terminal_condition (str): The condition that signifies the end of the conversation. + global_prompt (str): A universal prompt that applies to the moderator. Defaults to None. + """ + name = "Moderator" + super().__init__( + name=name, + role_desc=role_desc, + backend=backend, + global_prompt=global_prompt, + **kwargs, + ) + + self.terminal_condition = terminal_condition + + def to_config(self) -> AgentConfig: + return AgentConfig( + name=self.name, + role_desc=self.role_desc, + backend=self.backend.to_config(), + terminal_condition=self.terminal_condition, + global_prompt=self.global_prompt, + ) + + def is_terminal(self, history: List[Message], *args, **kwargs) -> bool: + """ + Check whether an episode is terminated based on the terminal condition. + + Parameters: + history (List[Message]): The conversation history. + + Returns: + bool: True if the conversation is over, otherwise False. + """ + # If the last message is the signal, then the conversation is over + if history[-1].content == SIGNAL_END_OF_CONVERSATION: + return True + + try: + request_msg = Message( + agent_name=self.name, content=self.terminal_condition, turn=-1 + ) + response = self.backend.query( + agent_name=self.name, + role_desc=self.role_desc, + history_messages=history, + global_prompt=self.global_prompt, + request_msg=request_msg, + *args, + **kwargs, + ) + except RetryError as e: + logging.warning( + f"Agent {self.name} failed to generate a response. " + f"Error: {e.last_attempt.exception()}." + ) + return True + + if re.match( + r"yes|y|yea|yeah|yep|yup|sure|ok|okay|alright", response, re.IGNORECASE + ): + # print(f"Decision: {response}. Conversation is ended by moderator.") + return True + else: + return False diff --git a/agentreview/arena.py b/agentreview/arena.py new file mode 100644 index 0000000000000000000000000000000000000000..a17fa50c6d7e21453e164e40e2575f4f6b7dce69 --- /dev/null +++ b/agentreview/arena.py @@ -0,0 +1,201 @@ +import csv +import json +import logging +import uuid +from typing import Dict, List, Union + +from .agent import Player +from .backends import Human +from .config import ArenaConfig +from .environments import Environment, TimeStep, load_environment + + +class TooManyInvalidActions(Exception): + pass + + +class Arena: + """Utility class that manages the game environment and players.""" + + def __init__( + self, players: List[Player], environment: Environment, args, global_prompt: str = None + ): + # Create a container for the players and environment and reset the game + self.players = players + self.environment = environment + self.global_prompt = global_prompt + + self.current_timestep = environment.reset() + self.uuid = uuid.uuid4() # Generate a unique id for the game + self.invalid_actions_retry = 5 + self.args = args + + @property + def num_players(self): + return self.environment.num_players + + @property + def name_to_player(self) -> Dict[str, Player]: + return {player.name: player for player in self.players} + + def reset(self) -> TimeStep: + # Reset the environment + self.current_timestep = self.environment.reset() + # Reset the players + for player in self.players: + player.reset() + # Reset the uuid + self.uuid = uuid.uuid4() + return self.current_timestep + + def step(self) -> TimeStep: + """Take a step in the game: one player takes an action and the environment updates.""" + player_name = self.environment.get_next_player() + player = self.name_to_player[player_name] # get the player object + observation = self.environment.get_observation( + player_name + ) # get the observation for the player + + timestep = None + for i in range( + self.invalid_actions_retry + ): # try to take an action for a few times + action = player(observation) # take an action + if self.environment.check_action(action, player_name): # action is valid + timestep = self.environment.step( + player_name, action + ) # update the environment + break + else: # action is invalid + logging.warning(f"{player_name} made an invalid action {action}") + continue + + if ( + timestep is None + ): # if the player made invalid actions for too many times, terminate the game + warning_msg = f"{player_name} has made invalid actions for {self.invalid_actions_retry} times. Terminating the game." + logging.warning(warning_msg) + raise TooManyInvalidActions(warning_msg) + + return timestep + + def next_is_human(self): + """Check if the next player is human.""" + player_name = self.environment.get_next_player() + player = self.name_to_player[player_name] + return isinstance(player.backend, Human) + + def run(self, num_steps: int = 1): + """Run the game for num_turns.""" + for i in range(num_steps): + timestep = self.step() + if timestep.terminal: + break + + @classmethod + def from_config(cls, config: Union[str, ArenaConfig]): + """Create an arena from a config.""" + # If config is a path, load the config + if isinstance(config, str): + config = ArenaConfig.load(config) + + global_prompt = config.get("global_prompt", None) + + # Create the players + players = [] + for player_config in config.players: + # Add public_prompt to the player config + if global_prompt is not None: + player_config["global_prompt"] = global_prompt + + player = Player.from_config(player_config) + players.append(player) + + # Check that the player names are unique + player_names = [player.name for player in players] + assert len(player_names) == len( + set(player_names) + ), "Player names must be unique" + + # Create the environment + config.environment[ + "player_names" + ] = player_names # add the player names to the environment config + env = load_environment(config.environment) + + return cls(players, env, global_prompt=global_prompt) + + def to_config(self) -> ArenaConfig: + """Convert the arena to a config.""" + # return { + # "players": [player.to_config() for player in self.players], + # "environment": self.environment.to_config(), + # "global_prompt": self.global_prompt + # } + return ArenaConfig( + players=[player.to_config() for player in self.players], + environment=self.environment.to_config(), + global_prompt=self.global_prompt, + ) + + def launch_cli(self, max_steps: int = None, interactive: bool = True): + """Launch the command line interface.""" + from agentreview.ui.cli import ArenaCLI + + cli = ArenaCLI(self) + cli.launch(max_steps=max_steps, interactive=interactive) + + def save_config(self, path: str): + """Save the config to a file.""" + config = self.to_config() + config.save(path) + + def save_history(self, path: str): + """ + Save the history of the game to a file. + + Supports csv and json formats. + """ + messages = self.environment.get_observation() + message_rows = [] + + if path.endswith(".csv"): + header = [ + "agent_name", + "content", + "turn", + "timestamp", + "visible_to", + "msg_type", + ] + for message in messages: + message_row = [ + message.agent_name, + message.content, + message.turn, + str(message.timestamp), + message.visible_to, + message.msg_type, + ] + message_rows.append(message_row) + + with open(path, "w") as f: + writer = csv.writer(f) + writer.writerow(header) + writer.writerows(message_rows) + elif path.endswith(".json"): + for message in messages: + message_row = { + "agent_name": message.agent_name, + "content": message.content, + "turn": message.turn, + "timestamp": str(message.timestamp), + "visible_to": message.visible_to, + "msg_type": message.msg_type, + } + message_rows.append(message_row) + + with open(path, "w") as f: + json.dump(message_rows, f, indent=2) + else: + raise ValueError("Invalid file format") diff --git a/agentreview/backends/__init__.py b/agentreview/backends/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..ef2f5d290d591897e86f64f2d5fbbb332fca8a91 --- /dev/null +++ b/agentreview/backends/__init__.py @@ -0,0 +1,30 @@ +from ..config import BackendConfig +from .anthropic import Claude +from .base import IntelligenceBackend +from .cohere import CohereAIChat +from .hf_transformers import TransformersConversational +from .human import Human +from .openai import OpenAIChat +from .dummy import Dummy + +ALL_BACKENDS = [ + Human, + OpenAIChat, + CohereAIChat, + TransformersConversational, + Claude, + Dummy, +] + +BACKEND_REGISTRY = {backend.type_name: backend for backend in ALL_BACKENDS} + + +# Load a backend from a config dictionary +def load_backend(config: BackendConfig): + try: + backend_cls = BACKEND_REGISTRY[config.backend_type] + except KeyError: + raise ValueError(f"Unknown backend type: {config.backend_type}") + + backend = backend_cls.from_config(config) + return backend diff --git a/agentreview/backends/anthropic.py b/agentreview/backends/anthropic.py new file mode 100644 index 0000000000000000000000000000000000000000..09d1f3455cc3b7c4ef6c6424dc7d04bc91c2e954 --- /dev/null +++ b/agentreview/backends/anthropic.py @@ -0,0 +1,119 @@ +import os +import re +from typing import List + +from tenacity import retry, stop_after_attempt, wait_random_exponential + +from ..message import SYSTEM_NAME as SYSTEM +from ..message import Message +from .base import IntelligenceBackend + +try: + import anthropic +except ImportError: + is_anthropic_available = False + # logging.warning("anthropic package is not installed") +else: + anthropic_api_key = os.environ.get("ANTHROPIC_API_KEY") + if anthropic_api_key is None: + # logging.warning("Anthropic API key is not set. Please set the environment variable ANTHROPIC_API_KEY") + is_anthropic_available = False + else: + is_anthropic_available = True + +DEFAULT_MAX_TOKENS = 256 +DEFAULT_MODEL = "claude-v1" + + +class Claude(IntelligenceBackend): + """Interface to the Claude offered by Anthropic.""" + + stateful = False + type_name = "claude" + + def __init__( + self, max_tokens: int = DEFAULT_MAX_TOKENS, model: str = DEFAULT_MODEL, **kwargs + ): + assert ( + is_anthropic_available + ), "anthropic package is not installed or the API key is not set" + super().__init__(max_tokens=max_tokens, model=model, **kwargs) + + self.max_tokens = max_tokens + self.model = model + + self.client = anthropic.Client(os.environ["ANTHROPIC_API_KEY"]) + + @retry(stop=stop_after_attempt(6), wait=wait_random_exponential(min=1, max=60)) + def _get_response(self, prompt: str): + response = self.client.completion( + prompt=prompt, + stop_sequences=[anthropic.HUMAN_PROMPT], + model=self.model, + max_tokens_to_sample=self.max_tokens, + ) + + response = response["completion"].strip() + return response + + def query( + self, + agent_name: str, + role_desc: str, + history_messages: List[Message], + global_prompt: str = None, + request_msg: Message = None, + *args, + **kwargs, + ) -> str: + """ + Format the input and call the Claude API. + + args: + agent_name: the name of the agent + role_desc: the description of the role of the agent + env_desc: the description of the environment + history_messages: the history of the conversation, or the observation for the agent + request_msg: the request from the system to guide the agent's next response + """ + all_messages = ( + [(SYSTEM, global_prompt), (SYSTEM, role_desc)] + if global_prompt + else [(SYSTEM, role_desc)] + ) + + for message in history_messages: + all_messages.append((message.agent_name, message.content)) + if request_msg: + all_messages.append((SYSTEM, request_msg.content)) + + prompt = "" + prev_is_human = False # Whether the previous message is from human (in anthropic, the human is the user) + for i, message in enumerate(all_messages): + if i == 0: + assert ( + message[0] == SYSTEM + ) # The first message should be from the system + + if message[0] == agent_name: + if prev_is_human: + prompt = f"{prompt}{anthropic.AI_PROMPT} {message[1]}" + else: + prompt = f"{prompt}\n\n{message[1]}" + prev_is_human = False + else: + if prev_is_human: + prompt = f"{prompt}\n\n[{message[0]}]: {message[1]}" + else: + prompt = f"{prompt}{anthropic.HUMAN_PROMPT}\n[{message[0]}]: {message[1]}" + prev_is_human = True + assert prev_is_human # The last message should be from the human + # Add the AI prompt for Claude to generate the response + prompt = f"{prompt}{anthropic.AI_PROMPT}" + + response = self._get_response(prompt, *args, **kwargs) + + # Remove the agent name if the response starts with it + response = re.sub(rf"^\s*\[{agent_name}]:?", "", response).strip() + + return response diff --git a/agentreview/backends/bard.py b/agentreview/backends/bard.py new file mode 100644 index 0000000000000000000000000000000000000000..dd7d135eaa1af71735a0bca8f122800ee99bffc1 --- /dev/null +++ b/agentreview/backends/bard.py @@ -0,0 +1,90 @@ +import os +import re +from typing import List + +from tenacity import retry, stop_after_attempt, wait_random_exponential + +from ..message import SYSTEM_NAME as SYSTEM +from ..message import Message +from .base import IntelligenceBackend + +try: + import bardapi +except ImportError: + is_bard_available = False + # logging.warning("bard package is not installed") +else: + bard_api_key = os.environ.get("_BARD_API_KEY") + if bard_api_key is None: + # logging.warning( + # "Bard API key is not set. Please set the environment variable _BARD_API_KEY") + is_bard_available = False + else: + is_bard_available = True + +DEFAULT_MAX_TOKENS = 4096 + + +class Bard(IntelligenceBackend): + """Interface to the Bard offered by Google.""" + + stateful = False + type_name = "bard" + + def __init__(self, max_tokens: int = DEFAULT_MAX_TOKENS, **kwargs): + assert ( + is_bard_available + ), "bard package is not installed or the API key is not set" + super().__init__(max_tokens=max_tokens, **kwargs) + + self.max_tokens = max_tokens + + self.client = bardapi.core.Bard() + + @retry(stop=stop_after_attempt(6), wait=wait_random_exponential(min=1, max=60)) + def _get_response(self, prompt: str): + response = self.client.get_answer( + input_text=prompt, + ) + + response = response["content"].strip() + return response + + def query( + self, + agent_name: str, + role_desc: str, + history_messages: List[Message], + global_prompt: str = None, + request_msg: Message = None, + *args, + **kwargs, + ) -> str: + """ + Format the input and call the Bard API. + + args: + agent_name: the name of the agent + role_desc: the description of the role of the agent + env_desc: the description of the environment + history_messages: the history of the conversation, or the observation for the agent + request_msg: the request from the system to guide the agent's next response + """ + all_messages = ( + [(SYSTEM, global_prompt), (SYSTEM, role_desc)] + if global_prompt + else [(SYSTEM, role_desc)] + ) + + for message in history_messages: + all_messages.append((message.agent_name, message.content)) + if request_msg: + all_messages.append((SYSTEM, request_msg.content)) + + # current bard api doesn't support role system, so just dump the raw messages as prompt + response = self._get_response(str(all_messages), *args, **kwargs) + + # Remove the agent name if the response starts with it + response = re.sub(rf"^\s*\[{agent_name}]:?", "", response).strip() + + return response diff --git a/agentreview/backends/base.py b/agentreview/backends/base.py new file mode 100644 index 0000000000000000000000000000000000000000..651974ec3935d62f7e16733a3b7ad91ed923aac4 --- /dev/null +++ b/agentreview/backends/base.py @@ -0,0 +1,66 @@ +from abc import abstractmethod +from typing import List + +from ..config import BackendConfig, Configurable +from ..message import Message + + +class IntelligenceBackend(Configurable): + """An abstraction of the intelligence source of the agents.""" + + stateful = None + type_name = None + + @abstractmethod + def __init__(self, **kwargs): + super().__init__(**kwargs) # registers the arguments with Configurable + + def __init_subclass__(cls, **kwargs): + # check if the subclass has the required attributes + for required in ( + "stateful", + "type_name", + ): + if getattr(cls, required) is None: + raise TypeError( + f"Can't instantiate abstract class {cls.__name__} without {required} attribute defined" + ) + return super().__init_subclass__(**kwargs) + + def to_config(self) -> BackendConfig: + self._config_dict["backend_type"] = self.type_name + return BackendConfig(**self._config_dict) + + @abstractmethod + def query( + self, + agent_name: str, + role_desc: str, + history_messages: List[Message], + global_prompt: str = None, + request_msg: Message = None, + *args, + **kwargs, + ) -> str: + raise NotImplementedError + + @abstractmethod + async def async_query( + self, + agent_name: str, + role_desc: str, + history_messages: List[Message], + global_prompt: str = None, + request_msg: Message = None, + *args, + **kwargs, + ) -> str: + """Async querying.""" + raise NotImplementedError + + # reset the state of the backend + def reset(self): + if self.stateful: + raise NotImplementedError + else: + pass diff --git a/agentreview/backends/cohere.py b/agentreview/backends/cohere.py new file mode 100644 index 0000000000000000000000000000000000000000..3ced6645b346d9b8a254795cfb8f8ac0389bf625 --- /dev/null +++ b/agentreview/backends/cohere.py @@ -0,0 +1,126 @@ +import os +from typing import List + +from tenacity import retry, stop_after_attempt, wait_random_exponential + +from ..message import Message +from .base import IntelligenceBackend + +# Try to import the cohere package and check whether the API key is set +try: + import cohere +except ImportError: + is_cohere_available = False +else: + if os.environ.get("COHEREAI_API_KEY") is None: + is_cohere_available = False + else: + is_cohere_available = True + +# Default config follows the [Cohere documentation](https://cohere-sdk.readthedocs.io/en/latest/cohere.html#cohere.client.Client.chat) +DEFAULT_TEMPERATURE = 0.8 +DEFAULT_MAX_TOKENS = 200 +DEFAULT_MODEL = "command-xlarge" + + +class CohereAIChat(IntelligenceBackend): + """Interface to the Cohere API.""" + + stateful = True + type_name = "cohere-chat" + + def __init__( + self, + temperature: float = DEFAULT_TEMPERATURE, + max_tokens: int = DEFAULT_MAX_TOKENS, + model: str = DEFAULT_MODEL, + **kwargs, + ): + super().__init__( + temperature=temperature, max_tokens=max_tokens, model=model, **kwargs + ) + + self.temperature = temperature + self.max_tokens = max_tokens + self.model = model + + assert ( + is_cohere_available + ), "Cohere package is not installed or the API key is not set" + self.client = cohere.Client(os.environ.get("COHEREAI_API_KEY")) + + # Stateful variables + self.session_id = None # The session id for the last conversation + self.last_msg_hash = ( + None # The hash of the last message of the last conversation + ) + + def reset(self): + self.session_id = None + self.last_msg_hash = None + + @retry(stop=stop_after_attempt(6), wait=wait_random_exponential(min=1, max=60)) + def _get_response(self, new_message: str, persona_prompt: str): + response = self.client.chat( + new_message, + persona_prompt=persona_prompt, + temperature=self.temperature, + max_tokens=self.max_tokens, + session_id=self.session_id, + ) + + self.session_id = response.session_id # Update the session id + return response.reply + + def query( + self, + agent_name: str, + role_desc: str, + history_messages: List[Message], + global_prompt: str = None, + request_msg: Message = None, + *args, + **kwargs, + ) -> str: + """ + Format the input and call the Cohere API. + + args: + agent_name: the name of the agent + role_desc: the description of the role of the agent + env_desc: the description of the environment + history_messages: the history of the conversation, or the observation for the agent + request_msg: the request for the CohereAI + """ + # Find the index of the last message of the last conversation + new_message_start_idx = 0 + if self.last_msg_hash is not None: + for i, message in enumerate(history_messages): + if message.msg_hash == self.last_msg_hash: + new_message_start_idx = i + 1 + break + + new_messages = history_messages[new_message_start_idx:] + assert len(new_messages) > 0, "No new messages found (this should not happen)" + + new_conversations = [] + for message in new_messages: + if message.agent_name != agent_name: + # Since there are more than one player, we need to distinguish between the players + new_conversations.append(f"[{message.agent_name}]: {message.content}") + + if request_msg: + new_conversations.append( + f"[{request_msg.agent_name}]: {request_msg.content}" + ) + + # Concatenate all new messages into one message because the Cohere API only accepts one message + new_message = "\n".join(new_conversations) + persona_prompt = f"Environment:\n{global_prompt}\n\nYour role:\n{role_desc}" + + response = self._get_response(new_message, persona_prompt) + + # Only update the last message hash if the API call is successful + self.last_msg_hash = new_messages[-1].msg_hash + + return response diff --git a/agentreview/backends/dummy.py b/agentreview/backends/dummy.py new file mode 100644 index 0000000000000000000000000000000000000000..a82792ed5d9f5744e8f15609ef7019c4f8d2fee3 --- /dev/null +++ b/agentreview/backends/dummy.py @@ -0,0 +1,14 @@ +from agentreview.config import Configurable + + +class Dummy(Configurable): + """A dummy backend does not make any API calls. We use it for extracting paper contents in PaperExtractor + and also for testing.""" + stateful = False + type_name = "dummy" + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def reset(self): + pass \ No newline at end of file diff --git a/agentreview/backends/hf_transformers.py b/agentreview/backends/hf_transformers.py new file mode 100644 index 0000000000000000000000000000000000000000..e2719953b9360606b07482b4e39c7def3e13f3f1 --- /dev/null +++ b/agentreview/backends/hf_transformers.py @@ -0,0 +1,127 @@ +import os +from contextlib import contextmanager, redirect_stderr, redirect_stdout +from typing import List + +from tenacity import retry, stop_after_attempt, wait_random_exponential + +from ..message import SYSTEM_NAME as SYSTEM +from ..message import Message +from .base import IntelligenceBackend + + +@contextmanager +def suppress_stdout_stderr(): + """A context manager that redirects stdout and stderr to devnull.""" + with open(os.devnull, "w") as fnull: + with redirect_stderr(fnull) as err, redirect_stdout(fnull) as out: + yield (err, out) + + +with suppress_stdout_stderr(): + # Try to import the transformers package + try: + import transformers + from transformers import pipeline + from transformers.pipelines.conversational import ( + Conversation, + ConversationalPipeline, + ) + except ImportError: + is_transformers_available = False + else: + is_transformers_available = True + + +class TransformersConversational(IntelligenceBackend): + """Interface to the Transformers ConversationalPipeline.""" + + stateful = False + type_name = "transformers:conversational" + + def __init__(self, model: str, device: int = -1, **kwargs): + super().__init__(model=model, device=device, **kwargs) + self.model = model + self.device = device + + assert is_transformers_available, "Transformers package is not installed" + self.chatbot = pipeline( + task="conversational", model=self.model, device=self.device + ) + + @retry(stop=stop_after_attempt(6), wait=wait_random_exponential(min=1, max=60)) + def _get_response(self, conversation): + conversation = self.chatbot(conversation) + response = conversation.generated_responses[-1] + return response + + @staticmethod + def _msg_template(agent_name, content): + return f"[{agent_name}]: {content}" + + def query( + self, + agent_name: str, + role_desc: str, + history_messages: List[Message], + global_prompt: str = None, + request_msg: Message = None, + *args, + **kwargs, + ) -> str: + user_inputs, generated_responses = [], [] + all_messages = ( + [(SYSTEM, global_prompt), (SYSTEM, role_desc)] + if global_prompt + else [(SYSTEM, role_desc)] + ) + + for msg in history_messages: + all_messages.append((msg.agent_name, msg.content)) + if request_msg: + all_messages.append((SYSTEM, request_msg.content)) + + prev_is_user = False # Whether the previous message is from the user + for i, message in enumerate(all_messages): + if i == 0: + assert ( + message[0] == SYSTEM + ) # The first message should be from the system + + if message[0] != agent_name: + if not prev_is_user: + user_inputs.append(self._msg_template(message[0], message[1])) + else: + user_inputs[-1] += "\n" + self._msg_template(message[0], message[1]) + prev_is_user = True + else: + if prev_is_user: + generated_responses.append(message[1]) + else: + generated_responses[-1] += "\n" + message[1] + prev_is_user = False + + assert len(user_inputs) == len(generated_responses) + 1 + past_user_inputs = user_inputs[:-1] + new_user_input = user_inputs[-1] + + # Recreate a conversation object from the history messages + conversation = Conversation( + text=new_user_input, + past_user_inputs=past_user_inputs, + generated_responses=generated_responses, + ) + + # Get the response + response = self._get_response(conversation) + return response + + +# conversation = Conversation("Going to the movies tonight - any suggestions?") +# +# # Steps usually performed by the model when generating a response: +# # 1. Mark the user input as processed (moved to the history) +# conversation.mark_processed() +# # 2. Append a mode response +# conversation.append_response("The Big lebowski.") +# +# conversation.add_user_input("Is it good?") diff --git a/agentreview/backends/human.py b/agentreview/backends/human.py new file mode 100644 index 0000000000000000000000000000000000000000..80f12e6cdd824a03124a5da14b863a9d8112f640 --- /dev/null +++ b/agentreview/backends/human.py @@ -0,0 +1,23 @@ +from ..config import BackendConfig +from .base import IntelligenceBackend + + +# An Error class for the human backend +class HumanBackendError(Exception): + def __init__(self, agent_name: str): + self.agent_name = agent_name + super().__init__(f"Human backend requires a UI to get input from {agent_name}.") + + +class Human(IntelligenceBackend): + stateful = False + type_name = "human" + + def __init__(self, **kwargs): + super().__init__(**kwargs) + + def to_config(self) -> BackendConfig: + return BackendConfig(backend_type=self.type_name) + + def query(self, agent_name: str, **kwargs) -> str: + raise HumanBackendError(agent_name) diff --git a/agentreview/backends/langchain.py b/agentreview/backends/langchain.py new file mode 100644 index 0000000000000000000000000000000000000000..83395b362dd3bb88c4647aa78ef82fbf9637e6b4 --- /dev/null +++ b/agentreview/backends/langchain.py @@ -0,0 +1,169 @@ +import os +import re +from typing import List + +from tenacity import retry, stop_after_attempt, wait_random_exponential + +from ..message import SYSTEM_NAME, Message +from .base import IntelligenceBackend + +try: + from langchain.llms import OpenAI +except ImportError: + is_langchain_openai_available = False + # logging.warning("openai package is not installed") +else: + api_key = os.environ.get("OPENAI_API_KEY") + if api_key is None: + # logging.warning("OpenAI API key is not set. Please set the environment variable OPENAI_API_KEY") + is_langchain_openai_available = False + else: + is_langchain_openai_available = True + +# Default config follows the OpenAI playground +DEFAULT_TEMPERATURE = 0.7 +DEFAULT_MAX_TOKENS = 2048 +DEFAULT_MODEL = "gpt-4" + +END_OF_MESSAGE = "" # End of message token specified by us not OpenAI +STOP = ("<|endoftext|>", END_OF_MESSAGE) # End of sentence token +BASE_PROMPT = f"The messages always end with the token {END_OF_MESSAGE}." + + +class LangChainOpenAIChat(IntelligenceBackend): + """Interface to the ChatGPT style model with system, user, assistant roles separation.""" + + stateful = False + type_name = "openai-chat" + + def __init__( + self, + temperature: float = DEFAULT_TEMPERATURE, + max_tokens: int = DEFAULT_MAX_TOKENS, + model: str = DEFAULT_MODEL, + merge_other_agents_as_one_user: bool = True, + **kwargs, + ): + """ + Instantiate the OpenAIChat backend. + + args: + temperature: the temperature of the sampling + max_tokens: the maximum number of tokens to sample + model: the model to use + merge_other_agents_as_one_user: whether to merge messages from other agents as one user message + """ + assert ( + is_langchain_openai_available + ), "langchain package is not installed or the API key is not set" + super().__init__( + temperature=temperature, + max_tokens=max_tokens, + model=model, + merge_other_agents_as_one_user=merge_other_agents_as_one_user, + **kwargs, + ) + + self.temperature = temperature + self.max_tokens = max_tokens + self.model = model + self.merge_other_agent_as_user = merge_other_agents_as_one_user + self.llm = OpenAI( + model_name=model, + temperature=temperature, + max_tokens=max_tokens, + openai_api_key=api_key, + ) + + @retry(stop=stop_after_attempt(6), wait=wait_random_exponential(min=1, max=60)) + def _get_response(self, messages): + response = self.llm(prompt=messages, stop=STOP) + return response + + def query( + self, + agent_name: str, + role_desc: str, + history_messages: List[Message], + global_prompt: str = None, + request_msg: Message = None, + *args, + **kwargs, + ) -> str: + """ + Format the input and call the ChatGPT/GPT-4 API. + + args: + agent_name: the name of the agent + role_desc: the description of the role of the agent + env_desc: the description of the environment + history_messages: the history of the conversation, or the observation for the agent + request_msg: the request from the system to guide the agent's next response + """ + + # Merge the role description and the global prompt as the system prompt for the agent + if global_prompt: # Prepend the global prompt if it exists + system_prompt = f"{global_prompt.strip()}\n{BASE_PROMPT}\n\nYour name: {agent_name}\n\nYour role:{role_desc}" + else: + system_prompt = ( + f"You are {agent_name}.\n\nYour role:{role_desc}\n\n{BASE_PROMPT}" + ) + + all_messages = [(SYSTEM_NAME, system_prompt)] + for msg in history_messages: + if msg.agent_name == SYSTEM_NAME: + all_messages.append((SYSTEM_NAME, msg.content)) + else: # non-system messages are suffixed with the end of message token + all_messages.append((msg.agent_name, f"{msg.content}{END_OF_MESSAGE}")) + + if request_msg: + all_messages.append((SYSTEM_NAME, request_msg.content)) + else: # The default request message that reminds the agent its role and instruct it to speak + all_messages.append( + (SYSTEM_NAME, f"Now you speak, {agent_name}.{END_OF_MESSAGE}") + ) + + messages = [] + for i, msg in enumerate(all_messages): + if i == 0: + assert ( + msg[0] == SYSTEM_NAME + ) # The first message should be from the system + messages.append({"role": "system", "content": msg[1]}) + else: + if msg[0] == agent_name: + messages.append({"role": "assistant", "content": msg[1]}) + else: + if messages[-1]["role"] == "user": # last message is from user + if self.merge_other_agent_as_user: + messages[-1][ + "content" + ] = f"{messages[-1]['content']}\n\n[{msg[0]}]: {msg[1]}" + else: + messages.append( + {"role": "user", "content": f"[{msg[0]}]: {msg[1]}"} + ) + elif ( + messages[-1]["role"] == "assistant" + ): # consecutive assistant messages + # Merge the assistant messages + messages[-1]["content"] = f"{messages[-1]['content']}\n{msg[1]}" + elif messages[-1]["role"] == "system": + messages.append( + {"role": "user", "content": f"[{msg[0]}]: {msg[1]}"} + ) + else: + raise ValueError(f"Invalid role: {messages[-1]['role']}") + + response = self._get_response(messages, *args, **kwargs) + + # Remove the agent name if the response starts with it + response = re.sub(rf"^\s*\[.*]:", "", response).strip() # noqa: F541 + response = re.sub( + rf"^\s*{re.escape(agent_name)}\s*:", "", response + ).strip() # noqa: F541 + + # Remove the tailing end of message token + response = re.sub(rf"{END_OF_MESSAGE}$", "", response).strip() + + return response diff --git a/agentreview/backends/openai.py b/agentreview/backends/openai.py new file mode 100644 index 0000000000000000000000000000000000000000..ecc6046327e7d9ad383615a1b84ac79c0963f28f --- /dev/null +++ b/agentreview/backends/openai.py @@ -0,0 +1,180 @@ +import re +from typing import List + +from tenacity import retry, stop_after_attempt, wait_random_exponential + +from arguments import parse_args +from utility.authentication_utils import get_openai_client +from .base import IntelligenceBackend +from ..message import SYSTEM_NAME, Message + +args = parse_args() + +client = get_openai_client(client_type=args.openai_client_type) + +OPENAI_CLIENT_TYPE = args.openai_client_type + +# Default config follows the OpenAI playground +DEFAULT_TEMPERATURE = 1.0 +DEFAULT_MAX_TOKENS = 4096 + +# Check https://platform.openai.com/docs/models for more models + +DEFAULT_MODEL = "gpt-4o" + +END_OF_MESSAGE = "" # End of message token specified by us not OpenAI +STOP = ("<|endoftext|>", END_OF_MESSAGE) # End of sentence token +BASE_PROMPT = f"The messages always end with the token {END_OF_MESSAGE}." + + +class OpenAIChat(IntelligenceBackend): + """Interface to the ChatGPT style model with system, user, assistant roles separation.""" + + stateful = False + type_name = "openai-chat" + + def __init__( + self, + temperature: float = DEFAULT_TEMPERATURE, + max_tokens: int = DEFAULT_MAX_TOKENS, + model: str = DEFAULT_MODEL, + merge_other_agents_as_one_user: bool = True, + **kwargs, + ): + """ + Instantiate the OpenAIChat backend. + + args: + temperature: the temperature of the sampling + max_tokens: the maximum number of tokens to sample + model: the model to use + merge_other_agents_as_one_user: whether to merge messages from other agents as one user message + """ + super().__init__( + temperature=temperature, + max_tokens=max_tokens, + model=model, + merge_other_agents_as_one_user=merge_other_agents_as_one_user, + **kwargs, + ) + + self.temperature = temperature + self.max_tokens = max_tokens + self.model = model + self.merge_other_agent_as_user = merge_other_agents_as_one_user + + @retry(stop=stop_after_attempt(6), wait=wait_random_exponential(min=1, max=60)) + def _get_response(self, messages): + # Refer to https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/switching-endpoints for how to + # make API calls + + if OPENAI_CLIENT_TYPE == "openai": + completion = client.chat.completions.create( + model=self.model, + messages=messages, + temperature=self.temperature, + max_tokens=self.max_tokens, + stop=STOP, + ) + + elif OPENAI_CLIENT_TYPE == "azure_openai": + completion = client.chat.completions.create( + model=self.model, + messages=messages, + temperature=self.temperature, + max_tokens=self.max_tokens, + stop=STOP, + ) + + else: + raise NotImplementedError + + response = completion.choices[0].message.content + response = response.strip() + return response + + def query( + self, + agent_name: str, + role_desc: str, + history_messages: List[Message], + global_prompt: str = None, + request_msg: Message = None, + *args, + **kwargs, + ) -> str: + """ + Format the input and call the ChatGPT/GPT-4 API. + + args: + agent_name: the name of the agent + role_desc: the description of the role of the agent + env_desc: the description of the environment + history_messages: the history of the conversation, or the observation for the agent + request_msg: the request from the system to guide the agent's next response + """ + + # Merge the role description and the global prompt as the system prompt for the agent + if global_prompt: # Prepend the global prompt if it exists + system_prompt = f"You are a helpful assistant.\n{global_prompt.strip()}\n{BASE_PROMPT}\n\nYour name is {agent_name}.\n\nYour role:{role_desc}" + else: + system_prompt = f"You are a helpful assistant. Your name is {agent_name}.\n\nYour role:{role_desc}\n\n{BASE_PROMPT}" + + all_messages = [(SYSTEM_NAME, system_prompt)] + for msg in history_messages: + if msg.agent_name == SYSTEM_NAME: + all_messages.append((SYSTEM_NAME, msg.content)) + else: # non-system messages are suffixed with the end of message token + all_messages.append((msg.agent_name, f"{msg.content}{END_OF_MESSAGE}")) + + if request_msg: + all_messages.append((SYSTEM_NAME, request_msg.content)) + else: # The default request message that reminds the agent its role and instruct it to speak + all_messages.append( + (SYSTEM_NAME, f"Now you speak, {agent_name}.{END_OF_MESSAGE}") + ) + + messages = [] + for i, msg in enumerate(all_messages): + if i == 0: + assert ( + msg[0] == SYSTEM_NAME + ) # The first message should be from the system + messages.append({"role": "system", "content": msg[1]}) + else: + if msg[0] == agent_name: + messages.append({"role": "assistant", "content": msg[1]}) + else: + if messages[-1]["role"] == "user": # last message is from user + if self.merge_other_agent_as_user: + messages[-1][ + "content" + ] = f"{messages[-1]['content']}\n\n[{msg[0]}]: {msg[1]}" + else: + messages.append( + {"role": "user", "content": f"[{msg[0]}]: {msg[1]}"} + ) + elif ( + messages[-1]["role"] == "assistant" + ): # consecutive assistant messages + # Merge the assistant messages + messages[-1]["content"] = f"{messages[-1]['content']}\n{msg[1]}" + elif messages[-1]["role"] == "system": + messages.append( + {"role": "user", "content": f"[{msg[0]}]: {msg[1]}"} + ) + else: + raise ValueError(f"Invalid role: {messages[-1]['role']}") + + response = self._get_response(messages, *args, **kwargs) + + # Remove the agent name if the response starts with it + response = re.sub(rf"^\s*\[.*]:", "", response).strip() # noqa: F541 + response = re.sub( + rf"^\s*{re.escape(agent_name)}\s*:", "", response + ).strip() # noqa: F451 + + # Remove the tailing end of message token + response = re.sub(rf"{END_OF_MESSAGE}$", "", response).strip() + + return response diff --git a/agentreview/config.py b/agentreview/config.py new file mode 100644 index 0000000000000000000000000000000000000000..085fc2aa119ff808cb2f71962b79d32e0d3eca5f --- /dev/null +++ b/agentreview/config.py @@ -0,0 +1,143 @@ +import copy +import json + +from .utils import AttributedDict + + +class Config(AttributedDict): + """ + Config class to manage the configuration of the games. + + The class has a few useful methods to load and save the config. + """ + + # convert dict to Config recursively + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + for key, value in self.items(): + + # Try to convert the value (the "metadata" field) to dict if applicable + try: + value = dict(eval(value)) + except Exception: + pass + + if isinstance(value, dict): + self[key] = init_config(value) # convert dict to Config recursively + # convert list of dict to list of Config recursively + elif isinstance(value, list) and len(value) > 0: + self[key] = [ + init_config(item) if isinstance(item, dict) else item + for item in value + ] + + def save(self, path: str): + # save config to file + with open(path, "w") as f: + json.dump(self, f, indent=4) + + @classmethod + def load(cls, path: str): + # load config from file + with open(path) as f: + config = json.load(f) + return cls(config) + + def deepcopy(self): + # get the config class so that subclasses can be copied in the correct class + config_class = self.__class__ + # make a deep copy of the config + return config_class(copy.deepcopy(self)) + + +class Configurable: + """Configurable is an interface for classes that can be initialized with a config.""" + + def __init__(self, **kwargs): + self._config_dict = kwargs + + @classmethod + def from_config(cls, config: Config): + return cls(**config) + + def to_config(self) -> Config: + # Convert the _config_dict to Config + return Config(**self._config_dict) + + def save_config(self, path: str): + self.to_config().save(path) + + +class EnvironmentConfig(Config): + """EnvironmentConfig contains a env_type field to indicate the name of the environment.""" + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + # check if the env_type field is specified + if "env_type" not in self: + raise ValueError("The env_type field is not specified") + + +class BackendConfig(Config): + """BackendConfig contains a backend_type field to indicate the name of the backend.""" + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + # check if the backend_type field is specified + if "backend_type" not in self: + raise ValueError("The backend_type field is not specified") + + +class AgentConfig(Config): + """AgentConfig contains role_desc and backend fields.""" + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + # check if the role_desc field is specified + if "role_desc" not in self: + raise ValueError("The role_desc field is not specified") + # check if the backend field is specified + if "backend" not in self: + raise ValueError("The backend field is not specified") + # Make sure the backend field is a BackendConfig + if not isinstance(self["backend"], BackendConfig): + raise ValueError("The backend field must be a BackendConfig") + + +class ArenaConfig(Config): + """ArenaConfig contains a list of AgentConfig.""" + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + # check if the players field is specified and it is List[AgentConfig] + if "players" not in self: + raise ValueError("The players field is not specified") + if not isinstance(self["players"], list): + raise ValueError("The players field must be a list") + for player in self["players"]: + if not isinstance(player, AgentConfig): + raise ValueError("The players field must be a list of AgentConfig") + + # check if environment field is specified and it is EnvironmentConfig + if "environment" not in self: + raise ValueError("The environment field is not specified") + if not isinstance(self["environment"], EnvironmentConfig): + raise ValueError("The environment field must be an EnvironmentConfig") + + +# Initialize with different config class depending on whether the config is for environment or backend +def init_config(config: dict): + if not isinstance(config, dict): + raise ValueError("The config must be a dict") + + # check if the config is for environment or backend + if "env_type" in config: + return EnvironmentConfig(config) + elif "backend_type" in config: + return BackendConfig(config) + elif "role_desc" in config: + return AgentConfig(config) + elif "players" in config: + return ArenaConfig(config) + else: + return Config(config) diff --git a/agentreview/database.py b/agentreview/database.py new file mode 100644 index 0000000000000000000000000000000000000000..99261ebe783b229cad6241caf865ab9906f757a1 --- /dev/null +++ b/agentreview/database.py @@ -0,0 +1,136 @@ +""" +Datastore module for chat_arena. + +This module provides utilities for storing the messages and the game results into database. +Currently, it supports Supabase. +""" +import json +import os +import uuid +from typing import List + +from .arena import Arena +from .message import Message + +# Attempt importing Supabase +try: + import supabase + + # Get the Supabase URL and secret key from environment variables + SUPABASE_URL = os.environ.get("SUPABASE_URL", "") + SUPABASE_SECRET_KEY = os.environ.get("SUPABASE_SECRET_KEY", "") + assert SUPABASE_URL and SUPABASE_SECRET_KEY +except Exception: + supabase_available = False +else: + supabase_available = True + + +# Store the messages into the Supabase database +class SupabaseDB: + def __init__(self): + assert supabase_available and SUPABASE_URL and SUPABASE_SECRET_KEY + supabase_client = supabase.create_client(SUPABASE_URL, SUPABASE_SECRET_KEY) + self.client = supabase_client + + # Save Arena state to Supabase + def save_arena(self, arena: Arena): + # Save the environment config + self._save_environment(arena) + + # Save the player configs + self._save_player_configs(arena) + + # Save the messages + self.save_messages(arena) + + # Save the environment config of the arena + def _save_environment(self, arena: Arena): + env = arena.environment + env_config = env.to_config() + moderator_config = env_config.pop("moderator", None) + + arena_row = { + "arena_id": str(arena.uuid), + "global_prompt": arena.global_prompt, + "env_type": env_config["env_type"], + "env_config": json.dumps(env_config), + } + self.client.table("Arena").insert(arena_row).execute() + + # Get the moderator config + if moderator_config: + moderator_row = { + "moderator_id": str( + uuid.uuid5(arena.uuid, json.dumps(moderator_config)) + ), + "arena_id": str(arena.uuid), + "role_desc": moderator_config["role_desc"], + "terminal_condition": moderator_config["terminal_condition"], + "backend_type": moderator_config["backend"]["backend_type"], + "temperature": moderator_config["backend"]["temperature"], + "max_tokens": moderator_config["backend"]["max_tokens"], + } + self.client.table("Moderator").insert(moderator_row).execute() + + # Save the player configs of the arena + def _save_player_configs(self, arena: Arena): + player_rows = [] + for player in arena.players: + player_config = player.to_config() + player_row = { + "player_id": str(uuid.uuid5(arena.uuid, json.dumps(player_config))), + "arena_id": str(arena.uuid), + "name": player.name, + "role_desc": player_config["role_desc"], + "backend_type": player_config["backend"]["backend_type"], + "temperature": player_config["backend"].get("temperature", None), + "max_tokens": player_config["backend"].get("max_tokens", None), + } + player_rows.append(player_row) + + self.client.table("Player").insert(player_rows).execute() + + # Save the messages + def save_messages(self, arena: Arena, messages: List[Message] = None): + if messages is None: + messages = arena.environment.get_observation() + + # Filter messages that are already logged + messages = [msg for msg in messages if not msg.logged] + + message_rows = [] + for message in messages: + message_row = { + "message_id": str(uuid.uuid5(arena.uuid, message.msg_hash)), + "arena_id": str(arena.uuid), + "agent_name": message.agent_name, + "content": message.content, + "turn": message.turn, + "timestamp": str(message.timestamp), + "msg_type": message.msg_type, + "visible_to": json.dumps(message.visible_to), + } + message_rows.append(message_row) + + self.client.table("Message").insert(message_rows).execute() + + # Mark the messages as logged + for message in messages: + message.logged = True + + +# Log the arena results into the Supabase database +def log_arena(arena: Arena, database=None): + if database is None: + pass + else: + database.save_arena(arena) + + +# Log the messages into the Supabase database +def log_messages(arena: Arena, messages: List[Message], database=None): + if database is None: + pass + else: + database.save_messages(arena, messages) diff --git a/agentreview/dataset/__init__.py b/agentreview/dataset/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/agentreview/dataset/download_openreview_paper.py b/agentreview/dataset/download_openreview_paper.py new file mode 100644 index 0000000000000000000000000000000000000000..749f66a268ca08dce6370875452a42c8a2940cd6 --- /dev/null +++ b/agentreview/dataset/download_openreview_paper.py @@ -0,0 +1,136 @@ +""" +Download all papers from one year of ICLR conference using OpenReview API. + +This script downloads all paper PDFs and their corresponding metadata +from the ICLR 2023 conference using the OpenReview API. + +Alternative methods to download can be found in this +[colab notebook](https://colab.research.google.com/drive/1vXXNxn8lnO3j1dgoidjybbKIN0DW0Bt2), +though it's not used here. +""" + +import glob +import json +import os +import time +import requests + +from arguments import parse_args + +try: + import openreview +except ImportError: + raise ImportError("Please install openreview package using `pip install openreview-py`") + +def download_papers(): + """Downloads all papers from ICLR 2023 using OpenReview API. + + This function authenticates with the OpenReview API using environment + variables for the username and password. It then iterates through the + available papers, downloads the PDF, and saves the corresponding metadata + (in JSON format) in the specified directories. + + Raises: + AssertionError: If the OPENREVIEW_USERNAME or OPENREVIEW_PASSWORD environment + variables are not set. + AssertionError: If the conference argument is not for ICLR. + """ + + args = parse_args() + + openreview_username = os.environ.get("OPENREVIEW_USERNAME") + openreview_password = os.environ.get("OPENREVIEW_PASSWORD") + + assert openreview_username is not None, ( + "Please set your OpenReview username through the OPENREVIEW_USERNAME environment variable." + ) + assert openreview_password is not None, ( + "Please set your OpenReview password through the OPENREVIEW_PASSWORD environment variable." + ) + + client = openreview.Client( + baseurl='https://api.openreview.net', + username=openreview_username, + password=openreview_password + ) + + page_size = 1000 + offset = 0 + papers_directory = os.path.join(args.data_dir, args.conference, "paper") + notes_directory = os.path.join(args.data_dir, args.conference, "notes") + + assert "ICLR" in args.conference, "Only works for ICLR conferences!" + year = int(args.conference.split("ICLR")[-1]) # Only works for ICLR currently + ids = [] + + # Create directories if they don't exist + for path in [papers_directory, notes_directory]: + os.makedirs(path, exist_ok=True) + + while True: + # Fetch submissions with pagination + notes = client.get_notes( + invitation=f'ICLR.cc/{year}/Conference/-/Blind_Submission', + details='all', + offset=offset, + limit=page_size + ) + + if not notes: + break # Exit if no more notes are available + + # Get existing paper IDs to avoid re-downloading + existing_papers = glob.glob(f"{papers_directory}/*.pdf") + existing_paper_ids = {int(os.path.basename(paper).split(".pdf")[0]) for paper in existing_papers} + + for note in notes: + paper_id = note.number + paper_path = os.path.join(papers_directory, f"{paper_id}.pdf") + note_path = os.path.join(notes_directory, f"{paper_id}.json") + + # Skip existing papers + if paper_id in existing_paper_ids: + print(f"Paper {paper_id} already downloaded.") + continue + + print(f"Title: {note.content.get('title', 'N/A')}") + print(f"Abstract: {note.content.get('abstract', 'N/A')}") + print(f"TL;DR: {note.content.get('TL;DR', 'N/A')}") + pdf_link = f"https://openreview.net/pdf?id={note.id}" + print(f"PDF Link: {pdf_link}") + + # Attempt to download the paper PDF, retry if fails + tries = 0 + while tries < 10: + try: + response = requests.get(pdf_link) + + if response.status_code == 200: + + with open(paper_path, "wb") as pdf_file: + pdf_file.write(response.content) + + print(f"PDF downloaded successfully as {paper_path}") + + # Save metadata as JSON, which contains the reviews, rebuttals, and decisions. + with open(note_path, "w") as note_file: + json.dump(note.to_json(), note_file, indent=2) + + break + + else: + print(f"Attempt {tries} failed. Status code: {response.status_code}") + if response.status_code == 429: # Too many requests + print("Too many requests. Sleeping for 10 seconds.") + time.sleep(10) + + except Exception as e: + print(f"Attempt {tries} failed with error: {e}") + + tries += 1 + + offset += page_size + + +if __name__ == "__main__": + download_papers() diff --git a/agentreview/dataset/process_submissions.py b/agentreview/dataset/process_submissions.py new file mode 100644 index 0000000000000000000000000000000000000000..17435190578b8be3949d73d1896313bff829bf3b --- /dev/null +++ b/agentreview/dataset/process_submissions.py @@ -0,0 +1,113 @@ +""" +Process and classify ICLR submissions using OpenReview API. + +This script processes ICLR submissions, classifies them into subdirectories +based on decisions, extracts paper content into JSON format, and checks the +validity of the processed papers. + +It includes three main functions: +- classify_ICLR_submissions_into_subdirectories: Classifies papers into + directories based on decisions. +- process_submission: Processes each submission by extracting text and saving + it as a JSON file. +- check_processed_paper: Verifies if all processed papers are valid JSON files. +""" + +import os +import sys +import traceback +from collections import Counter + +from tqdm import tqdm + +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) + +import const +from arguments import parse_args +from utility.utils import print_colored + +decision_map = { + # ICLR 2023 + "Reject": "Reject", + "Accept: poster": "Accept-poster", + "Accept: notable-top-25%": "Accept-notable-top-25", + "Accept: notable-top-5%": "Accept-notable-top-5", + + # ICLR 2022 + "Accept (Poster)": "Accept-poster", + "Accept (Oral)": "Accept-oral", + "Accept (Spotlight)": "Accept-spotlight", + + # ICLR 2021 + "Significant concerns (Do not publish)": "Significant-concerns", + "Concerns raised (can publish with adjustment)": "Concerns-raised", + + # ICLR 2020 + "Accept (Talk)": "Accept-oral", # We assume this signifies an oral presentation + + # ICLR 2018 + "Invite to Workshop Track": "Reject" +} + + +def categorize_ICLR_submissions_into_subdirectories(): + """Classifies ICLR submissions into subdirectories based on review decisions. + + This function iterates through the review notes and identifies the decision + (recommendation or final decision) for each submission. It then moves the + notes and their corresponding papers into directories based on the decision. + + Raises: + AssertionError: If the line containing the decision does not have the + expected format. + """ + note_dir = f"data/{args.conference}/notes" + paper_dir = f"data/{args.conference}/paper" + + for note in os.listdir(note_dir): + print(note) + + # Skip directories or irrelevant files + if os.path.isdir(os.path.join(note_dir, note)) or ".DS_Store" in note: + continue + + note_path = os.path.join(note_dir, note) + lines = open(note_path, "r").readlines() + decision = None + + for line in tqdm(lines): + if "\"recommendation\"" in line: + assert Counter(line)["\""] == 4, "Unexpected format in recommendation line." + print(line) + decision = line.split("\"recommendation\"")[1].split("\"")[1] + break + + elif "\"decision\"" in line: + assert Counter(line)["\""] == 4, "Unexpected format in decision line." + print(line) + try: + decision = line.split("\"decision\"")[1].split("\"")[1] + break + except Exception: + traceback.print_exc() + print_colored(line, 'red') + + if decision is None: + # Possibly withdrawn papers + print_colored(f"Could not find decision for {note}", "red") + continue + + os.makedirs(os.path.join(note_dir, decision_map[decision]), exist_ok=True) + os.makedirs(os.path.join(paper_dir, decision_map[decision]), exist_ok=True) + os.rename(note_path, os.path.join(note_dir, decision_map[decision], note)) + + paper_id = int(note.split(".json")[0]) + paper_path = os.path.join(paper_dir, f"{paper_id}.pdf") + os.rename(paper_path, os.path.join(paper_dir, decision_map[decision], f"{paper_id}.pdf")) + + +if __name__ == "__main__": + args = parse_args() + + # Extract contents of each paper into a JSON file + categorize_ICLR_submissions_into_subdirectories() \ No newline at end of file diff --git a/agentreview/environments/__init__.py b/agentreview/environments/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..47e11507dd1b442be41f609643a82e876f0280a9 --- /dev/null +++ b/agentreview/environments/__init__.py @@ -0,0 +1,25 @@ +from ..config import EnvironmentConfig +from .base import Environment, TimeStep +from .conversation import Conversation, ModeratedConversation +from .paper_review import PaperReview +from .paper_decision import PaperDecision + +ALL_ENVIRONMENTS = [ + Conversation, + ModeratedConversation, + PaperReview, + PaperDecision, +] + +ENV_REGISTRY = {env.type_name: env for env in ALL_ENVIRONMENTS} + + +# Load an environment from a config dictionary +def load_environment(config: EnvironmentConfig): + try: + env_cls = ENV_REGISTRY[config["env_type"]] + except KeyError: + raise ValueError(f"Unknown environment type: {config['env_type']}") + + env = env_cls.from_config(config) + return env diff --git a/agentreview/environments/base.py b/agentreview/environments/base.py new file mode 100644 index 0000000000000000000000000000000000000000..fad814e66a837bd8267e837be42cd18db30eb966 --- /dev/null +++ b/agentreview/environments/base.py @@ -0,0 +1,188 @@ +from abc import abstractmethod +from dataclasses import dataclass +from typing import Dict, List + +from ..config import Configurable, EnvironmentConfig +from ..message import Message +from ..utils import AttributedDict + + +@dataclass +class TimeStep(AttributedDict): + """ + Represents a single step in time within the simulation. + + It includes observation, reward, and terminal state. + + Attributes: + observation (List[Message]): A list of messages (observations) for the current timestep. + reward (Dict[str, float]): A dictionary with player names as keys and corresponding rewards as values. + terminal (bool): A boolean indicating whether the current state is terminal (end of episode). + """ + + observation: List[Message] + reward: Dict[str, float] + terminal: bool + + +class Environment(Configurable): + """ + Abstract class representing an environment. + + It defines the necessary methods any environment must implement. + + Inherits from: + Configurable: A custom class that provides methods to handle configuration settings. + + Attributes: + type_name (str): Type of the environment, typically set to the lower case of the class name. + + Note: + Subclasses should override and implement the abstract methods defined here. + """ + + type_name = None + phase_index = 0 + task = None + @abstractmethod + def __init__(self, player_names: List[str], **kwargs): + """ + Initialize the Environment. + + Parameters: + player_names (List[str]): Names of the players in the environment. + """ + super().__init__( + player_names=player_names, **kwargs + ) # registers the arguments with Configurable + self.player_names = player_names + + def __init_subclass__(cls, **kwargs): + """ + Automatically called when a subclass is being initialized. + + Here it's used to check if the subclass has the required attributes. + """ + for required in ("type_name",): + if getattr(cls, required) is None: + cls.type_name = cls.__name__.lower() + + return super().__init_subclass__(**kwargs) + + @abstractmethod + def reset(self): + """ + Reset the environment to its initial state. + + Note: + This method must be implemented by subclasses. + """ + pass + + def to_config(self) -> EnvironmentConfig: + self._config_dict["env_type"] = self.type_name + return EnvironmentConfig(**self._config_dict) + + @property + def num_players(self) -> int: + """Get the number of players.""" + return len(self.player_names) + + @abstractmethod + def get_next_player(self) -> str: + """ + Return the name of the next player. + + Note: + This method must be implemented by subclasses. + + Returns: + str: The name of the next player. + """ + pass + + @abstractmethod + def get_observation(self, player_name=None) -> List[Message]: + """ + Return observation for a given player. + + Note: + This method must be implemented by subclasses. + + Parameters: + player_name (str, optional): The name of the player for whom to get the observation. + + Returns: + List[Message]: The observation for the player in the form of a list of messages. + """ + pass + + @abstractmethod + def print(self): + """Print the environment state.""" + pass + + @abstractmethod + def step(self, player_name: str, action: str) -> TimeStep: + """ + Execute a step in the environment given an action from a player. + + Note: + This method must be implemented by subclasses. + + Parameters: + player_name (str): The name of the player. + action (str): The action that the player wants to take. + + Returns: + TimeStep: An object of the TimeStep class containing the observation, reward, and done state. + """ + pass + + @abstractmethod + def check_action(self, action: str, player_name: str) -> bool: + """ + Check whether a given action is valid for a player. + + Note: + This method must be implemented by subclasses. + + Parameters: + action (str): The action to be checked. + player_name (str): The name of the player. + + Returns: + bool: True if the action is valid, False otherwise. + """ + return True + + @abstractmethod + def is_terminal(self) -> bool: + """ + Check whether the environment is in a terminal state (end of episode). + + Note: + This method must be implemented by subclasses. + + Returns: + bool: True if the environment is in a terminal state, False otherwise. + """ + pass + + def get_zero_rewards(self) -> Dict[str, float]: + """ + Return a dictionary with all player names as keys and zero as reward. + + Returns: + Dict[str, float]: A dictionary of players and their rewards (all zero). + """ + return {player_name: 0.0 for player_name in self.player_names} + + def get_one_rewards(self) -> Dict[str, float]: + """ + Return a dictionary with all player names as keys and one as reward. + + Returns: + Dict[str, float]: A dictionary of players and their rewards (all one). + """ + return {player_name: 1.0 for player_name in self.player_names} diff --git a/agentreview/environments/conversation.py b/agentreview/environments/conversation.py new file mode 100644 index 0000000000000000000000000000000000000000..81bdf8f291b46e1272fa39a7dfba42db8de2cc66 --- /dev/null +++ b/agentreview/environments/conversation.py @@ -0,0 +1,198 @@ +from typing import List, Union + +from ..agent import SIGNAL_END_OF_CONVERSATION, Moderator +from ..config import AgentConfig, EnvironmentConfig +from ..message import Message, MessagePool +from .base import Environment, TimeStep + + +class Conversation(Environment): + """ + Turn-based fully observable conversation environment. + + Next speaker order is either parallel or round-robin. + """ + + type_name = "conversation" + + def __init__(self, player_names: List[str], parallel: bool = False, **kwargs): + super().__init__(player_names=player_names, parallel=parallel, **kwargs) + + self.parallel = parallel + + # The "state" of the environment is maintained by the message pool + self.message_pool = MessagePool() + + self._current_turn = 0 + self._next_player_index = 0 + + def reset(self): + self._current_turn = 0 + self._next_player_index = 0 + self.message_pool.reset() + + init_timestep = TimeStep( + observation=[], reward=self.get_zero_rewards(), terminal=False + ) + return init_timestep + + @property + def phase_index(self): + return self._phase_index + + @phase_index.setter + def phase_index(self, value): + self._phase_index = value + + def to_config(self) -> EnvironmentConfig: + return EnvironmentConfig( + env_type=self.type_name, + player_names=self.player_names, + parallel=self.parallel, + ) + + def print(self): + self.message_pool.print() + + def get_next_player(self) -> str: + """Get the next player.""" + return self.player_names[self._next_player_index] + + def get_observation(self, player_name=None) -> List[Message]: + """Get observation for the player.""" + if player_name is None: + return self.message_pool.get_all_messages() + else: + return self.message_pool.get_visible_messages( + player_name, turn=self._current_turn + ) + + def is_terminal(self) -> bool: + """Check if the conversation is over.""" + # If the last message is the signal, then the conversation is over + if self.message_pool.last_message.content.startswith( + SIGNAL_END_OF_CONVERSATION + ): + return True + + def step(self, player_name: str, action: str) -> TimeStep: + """ + Step function that is called by the arena. + + Args: + player_name: the name of the player that takes the action + action: the action that the agents wants to take + """ + message = Message( + agent_name=player_name, content=action, turn=self._current_turn + ) + self.message_pool.append_message(message) + + # Update the counters + if not self.parallel or self._next_player_index == 0: + self._current_turn += 1 + self._next_player_index = (self._next_player_index + 1) % self.num_players + + timestep = TimeStep( + observation=self.get_observation(), + reward=self.get_zero_rewards(), + terminal=self.is_terminal(), + ) # Return all the messages + return timestep + + +class ModeratedConversation(Conversation): + """ + Turn-based fully observable conversation environment. + + Next speaker order is either parallel or round-robin. + Moderator is a special agent that can see all messages and can decide whether the conversation is over. + """ + + type_name = "moderated_conversation" + + def __init__( + self, + player_names: List[str], + moderator: Union[Moderator, AgentConfig], + parallel: bool = False, + moderator_visibility="all", + moderator_period=None, + **kwargs, + ): + super().__init__(player_names=player_names, parallel=parallel, **kwargs) + + if isinstance(moderator, AgentConfig): + moderator_config = moderator + moderator = Moderator.from_config(moderator_config) + elif not isinstance(moderator, Moderator): + raise ValueError( + "moderator must be either an AgentConfig or a Moderator instance." + ) + + self.moderator = moderator + self.moderator_visibility = moderator_visibility + if moderator_period is None: + if parallel: + self.moderator_period = "round" + else: + self.moderator_period = "turn" + else: + self.moderator_period = moderator_period + + def to_config(self) -> EnvironmentConfig: + # This environment contains some special config arguments that needs to be handle specially + return EnvironmentConfig( + env_type=self.type_name, + player_names=self.player_names, + parallel=self.parallel, + moderator=self.moderator.to_config(), + moderator_visibility=self.moderator_visibility, + moderator_period=self.moderator_period, + ) + + def step(self, player_name: str, action: str) -> TimeStep: + """ + Step function that is called by the arena. + + Args: + player_name: the name of the player that takes the action + action: the action that the agents wants to take + """ + message = Message( + agent_name=player_name, content=action, turn=self._current_turn + ) + self.message_pool.append_message(message) + + # Round-robin order for the next player + self._next_player_index = (self._next_player_index + 1) % self.num_players + + if self.moderator_period == "turn" or ( + self.moderator_period == "round" and self._next_player_index == 0 + ): + # Moderator's turn + moderator_history = self.message_pool.get_all_messages() + moderator_response = self.moderator(moderator_history) + moderator_message = Message( + agent_name=self.moderator.name, + content=moderator_response, + turn=self._current_turn, + visible_to=self.moderator_visibility, + ) + self.message_pool.append_message(moderator_message) + terminal = ( + self.moderator.is_terminal(moderator_history) or self.is_terminal() + ) + else: + terminal = self.is_terminal() + + # Update the counters + if not self.parallel or self._next_player_index == 0: + self._current_turn += 1 + + timestep = TimeStep( + observation=self.get_observation(), + reward=self.get_zero_rewards(), + terminal=terminal, + ) # Return all the messages + return timestep diff --git a/agentreview/environments/paper_decision.py b/agentreview/environments/paper_decision.py new file mode 100644 index 0000000000000000000000000000000000000000..d8f03c492a12df4e2cf85e9ed749317f0bd8d023 --- /dev/null +++ b/agentreview/environments/paper_decision.py @@ -0,0 +1,161 @@ +import logging +import traceback +from typing import List + +from agentreview.environments import Conversation +from .base import TimeStep +from ..message import Message, MessagePool + + +logger = logging.getLogger(__name__) + + +class PaperDecision(Conversation): + """ + Area chairs make decision based on the meta reviews + """ + + type_name = "paper_decision" + + def __init__(self, + player_names: List[str], + experiment_setting: dict, + paper_ids: List[int] = None, + metareviews: List[str] = None, + parallel: bool = False, + + **kwargs): + """ + + Args: + paper_id (int): the id of the paper, such as 917 + paper_decision (str): the decision of the paper, such as "Accept: notable-top-25%" + + """ + + # Inherit from the parent class of `class Conversation` + super(Conversation, self).__init__(player_names=player_names, parallel=parallel, **kwargs) + + self.paper_ids = paper_ids + self.metareviews = metareviews + self.parallel = parallel + self.experiment_setting = experiment_setting + self.ac_scoring_method = kwargs.get("ac_scoring_method") + # The "state" of the environment is maintained by the message pool + self.message_pool = MessagePool() + + self.ac_decisions = None + + self._current_turn = 0 + self._next_player_index = 0 + self.phase_index = 5 # "ACs make decision based on meta review" is the last phase (Phase 5) + + self._phases = None + + @property + def phases(self): + + if self._phases is None: + self._phases = { + 5: { + "name": "ac_make_decisions", + 'speaking_order': ["AC"] + }, + } + return self._phases + + def step(self, player_name: str, action: str) -> TimeStep: + """ + Step function that is called by the arena. + + Args: + player_name: the name of the player that takes the action + action: the action that the agents wants to take + """ + + + + message = Message( + agent_name=player_name, content=action, turn=self._current_turn + ) + self.message_pool.append_message(message) + + speaking_order = self.phases[self.phase_index]["speaking_order"] + + # Reached the end of the speaking order. Move to the next phase. + + logging.info(f"Phase {self.phase_index}: {self.phases[self.phase_index]['name']} " + f"| Player {self._next_player_index}: {speaking_order[self._next_player_index]}") + if self._next_player_index == len(speaking_order) - 1: + self._next_player_index = 0 + logger.info(f"Phase {self.phase_index}: end of the speaking order. Move to Phase {self.phase_index + 1}.") + self.phase_index += 1 + self._current_turn += 1 + else: + self._next_player_index += 1 + + timestep = TimeStep( + observation=self.get_observation(), + reward=self.get_zero_rewards(), + terminal=self.is_terminal(), + ) # Return all the messages + + return timestep + + + def check_action(self, action: str, player_name: str) -> bool: + """Check if the action is valid.""" + + if player_name.startswith("AC"): + + try: + self.ac_decisions = self.parse_ac_decisions(action) + + except: + traceback.print_exc() + return False + + if not isinstance(self.ac_decisions, dict): + return False + + return True + + @property + def ac_decisions(self): + return self._ac_decisions + + @ac_decisions.setter + def ac_decisions(self, value): + self._ac_decisions = value + + def parse_ac_decisions(self, action: str): + """ + Parse the decisions made by the ACs + """ + + lines = action.split("\n") + + paper2rating = {} + + paper_id, rank = None, None + + for line in lines: + + if line.lower().startswith("paper id:"): + paper_id = int(line.split(":")[1].split('(')[0].strip()) + elif self.ac_scoring_method == "ranking" and line.lower().startswith("willingness to accept:"): + rank = int(line.split(":")[1].strip()) + + elif self.ac_scoring_method == "recommendation" and line.lower().startswith("decision"): + rank = line.split(":")[1].strip() + + + + if paper_id in paper2rating: + raise ValueError(f"Paper {paper_id} is assigned a rank twice.") + + if paper_id is not None and rank is not None: + paper2rating[paper_id] = rank + paper_id, rank = None, None + + return paper2rating diff --git a/agentreview/environments/paper_review.py b/agentreview/environments/paper_review.py new file mode 100644 index 0000000000000000000000000000000000000000..486765cf8cab9c7810b242e8379b95df0337f4c9 --- /dev/null +++ b/agentreview/environments/paper_review.py @@ -0,0 +1,217 @@ +import json +import json +import logging +import os.path as osp +from typing import List + +from agentreview.environments import Conversation +from utility.utils import get_rebuttal_dir +from .base import TimeStep +from ..message import Message +from ..paper_review_message import PaperReviewMessagePool + + +logger = logging.getLogger(__name__) + +class PaperReview(Conversation): + """ + Discussion between reviewers and area chairs. + + There are several phases in the reviewing process: + reviewer_write_reviews: reviewers write their reviews based on the paper content. + author_reviewer_discussion: An author respond to comments from the reviewers. + reviewer_ac_discussion: reviewers and an area chair discuss the paper. + ac_discussion: an area chair makes the final decision. + """ + + type_name = "paper_review" + + def __init__(self, player_names: List[str], paper_id: int, paper_decision: str, experiment_setting: dict, args, + parallel: bool = False, + + **kwargs): + """ + Args: + paper_id (int): the id of the paper, such as 917 + paper_decision (str): the decision of the paper, such as "Accept: notable-top-25%" + """ + + # Inherit from the parent class of `class Conversation` + super(Conversation, self).__init__(player_names=player_names, parallel=parallel, **kwargs) + self.args = args + self.paper_id = paper_id + self.paper_decision = paper_decision + self.parallel = parallel + self.experiment_setting = experiment_setting + self.player_to_test = experiment_setting.get('player_to_test', None) + self.task = kwargs.get("task") + self.experiment_name = args.experiment_name + + # The "state" of the environment is maintained by the message pool + self.message_pool = PaperReviewMessagePool(experiment_setting) + + self.phase_index = 0 + self._phases = None + + @property + def phases(self): + + if self._phases is not None: + return self._phases + + reviewer_names = [name for name in self.player_names if name.startswith("Reviewer")] + + num_reviewers = len(reviewer_names) + + reviewer_names = [f"Reviewer {i}" for i in range(1, num_reviewers + 1)] + + self._phases = { + # In phase 0, no LLM-based agents are called. + 0: { + "name": "paper_extraction", + 'speaking_order': ["Paper Extractor"], + }, + + 1: { + "name": 'reviewer_write_reviews', + 'speaking_order': reviewer_names + }, + + # The author responds to each reviewer's review + 2: { + 'name': 'author_reviewer_discussion', + 'speaking_order': ["Author" for _ in reviewer_names], + }, + + 3: { + 'name': 'reviewer_ac_discussion', + 'speaking_order': ["AC"] + reviewer_names, + }, + + 4: { + 'name': 'ac_write_metareviews', + 'speaking_order': ["AC"] + }, + 5: { + 'name': 'ac_makes_decisions', + 'speaking_order': ["AC"] + }, + } + + return self.phases + + @phases.setter + def phases(self, value): + self._phases = value + + def reset(self): + self._current_phase = "review" + self.phase_index = 0 + return super().reset() + + + + def load_message_history_from_cache(self): + if self._phase_index == 0: + + print("Loading message history from BASELINE experiment") + + full_paper_discussion_path = get_rebuttal_dir(paper_id=self.paper_id, + experiment_name="BASELINE", + model_name=self.args.model_name, + conference=self.args.conference) + + messages = json.load(open(osp.join(full_paper_discussion_path, f"{self.paper_id}.json"), 'r', + encoding='utf-8'))['messages'] + + num_messages_from_AC = 0 + + for msg in messages: + + # We have already extracted contents from the paper. + if msg['agent_name'] == "Paper Extractor": + continue + + # Encountering the 2nd message from the AC. Stop loading messages. + if msg['agent_name'] == "AC" and num_messages_from_AC == 1: + break + + if msg['agent_name'] == "AC": + num_messages_from_AC += 1 + + message = Message(**msg) + self.message_pool.append_message(message) + + num_unique_reviewers = len( + set([msg['agent_name'] for msg in messages if msg['agent_name'].startswith("Reviewer")])) + + assert num_unique_reviewers == self.args.num_reviewers_per_paper + + self._phase_index = 4 + + def step(self, player_name: str, action: str) -> TimeStep: + """ + Step function that is called by the arena. + + Args: + player_name: the name of the player that takes the action + action: the action that the agents wants to take + """ + + message = Message( + agent_name=player_name, content=action, turn=self._current_turn + ) + self.message_pool.append_message(message) + + speaking_order = self.phases[self.phase_index]["speaking_order"] + + # Reached the end of the speaking order. Move to the next phase. + logging.info(f"Phase {self.phase_index}: {self.phases[self._phase_index]['name']} " + f"| Player {self._next_player_index}: {speaking_order[self._next_player_index]}") + + terminal = self.is_terminal() + + if self._next_player_index == len(speaking_order) - 1: + self._next_player_index = 0 + + if self.phase_index == 4: + terminal = True + logger.info( + "Finishing the simulation for Phase I - IV. Please run `python run_paper_decision_cli.py ` for " + "Phase V. (AC makes decisions).") + + else: + logger.info(f"Phase {self.phase_index}: end of the speaking order. Move to Phase ({self.phase_index + 1}).") + self.phase_index += 1 + self._current_turn += 1 + + + + + else: + self._next_player_index += 1 + + timestep = TimeStep( + observation=self.get_observation(), + reward=self.get_zero_rewards(), + terminal=terminal, + ) # Return all the messages + + return timestep + + def get_next_player(self) -> str: + """Get the next player in the current phase.""" + speaking_order = self.phases[self.phase_index]["speaking_order"] + next_player = speaking_order[self._next_player_index] + return next_player + + def get_observation(self, player_name=None) -> List[Message]: + """Get observation for the player.""" + if player_name is None: + return self.message_pool.get_all_messages() + else: + + return self.message_pool.get_visible_messages_for_paper_review( + player_name, phase_index=self.phase_index, next_player_idx=self._next_player_index, + player_names=self.player_names + ) diff --git a/agentreview/experiment_config.py b/agentreview/experiment_config.py new file mode 100644 index 0000000000000000000000000000000000000000..ab0dcc1aac0f28e104b96a4b1bb3b5d421957282 --- /dev/null +++ b/agentreview/experiment_config.py @@ -0,0 +1,244 @@ +""" +BASELINE: The default settings which all other settings compare against. + +""" + +baseline_setting = { + "AC": [ + "BASELINE" + ], + + "reviewer": [ + "BASELINE", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + +benign_Rx1_setting = { + "AC": [ + "BASELINE" + ], + + "reviewer": [ + "benign", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + +malicious_Rx1_setting = { + "AC": [ + "BASELINE" + ], + + "reviewer": [ + "malicious", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + +unknowledgeable_Rx1_setting = { + "AC": [ + "BASELINE" + ], + + "reviewer": [ + "knowledgeable", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + +knowledgeable_Rx1_setting = { + "AC": [ + "BASELINE" + ], + + "reviewer": [ + "knowledgeable", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + + +responsible_Rx1_setting = { + "AC": [ + "BASELINE" + ], + + "reviewer": [ + "responsible", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + +irresponsible_Rx1_setting = { + "AC": [ + "BASELINE" + ], + + "reviewer": [ + "irresponsible", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + +conformist_ACx1_setting = { + "AC": [ + "conformist" + ], + + "reviewer": [ + "BASELINE", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + +authoritarian_ACx1_setting = { + "AC": [ + "authoritarian" + ], + + "reviewer": [ + "BASELINE", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + +inclusive_ACx1_setting = { + "AC": [ + "inclusive" + ], + + "reviewer": [ + "BASELINE", + "BASELINE", + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": ['reviewer', 'ac'], + "persons_aware_of_authors_identities": [] + } +} + + + +no_numeric_ratings_setting = { + "AC": [ + "BASELINE" + ], + + "reviewer": [ + "BASELINE" + ], + + "author": [ + "BASELINE" + ], + "global_settings":{ + "provides_numeric_rating": [], + "persons_aware_of_authors_identities": [] + } +} + + +# All experimental settings. +# Customize your own by adding new settings to this dict. +all_settings = { + "BASELINE": baseline_setting, + "benign_Rx1": benign_Rx1_setting, + "malicious_Rx1": malicious_Rx1_setting, + "knowledgeable_Rx1_setting": knowledgeable_Rx1_setting, + "unknowledgeable_Rx1_setting": unknowledgeable_Rx1_setting, + "responsible_Rx1_setting": responsible_Rx1_setting, + "irresponsible_Rx1_setting": irresponsible_Rx1_setting, + "conformist_ACx1": conformist_ACx1_setting, + "authoritarian_ACx1": authoritarian_ACx1_setting, + "inclusive_ACx1": inclusive_ACx1_setting, + "no_numeric_ratings": no_numeric_ratings_setting, + +} + diff --git a/agentreview/message.py b/agentreview/message.py new file mode 100644 index 0000000000000000000000000000000000000000..e076e5471d77ea5e71a18562dbc68288813ac981 --- /dev/null +++ b/agentreview/message.py @@ -0,0 +1,150 @@ +import hashlib +import time +from dataclasses import dataclass +from typing import List, Union +from uuid import uuid1 + +# Preserved roles +SYSTEM_NAME = "System" +MODERATOR_NAME = "Moderator" + + +def _hash(input: str): + """ + Helper function that generates a SHA256 hash of a given input string. + + Parameters: + input (str): The input string to be hashed. + + Returns: + str: The SHA256 hash of the input string. + """ + hex_dig = hashlib.sha256(input.encode()).hexdigest() + return hex_dig + + +@dataclass +class Message: + """ + Represents a message in the chatArena environment. + + Attributes: + agent_name (str): Name of the agent who sent the message. + content (str): Content of the message. + turn (int): The turn at which the message was sent. + timestamp (int): Wall time at which the message was sent. Defaults to current time in nanoseconds. + visible_to (Union[str, List[str]]): The receivers of the message. Can be a single agent, multiple agents, or 'all'. Defaults to 'all'. + msg_type (str): Type of the message, e.g., 'text'. Defaults to 'text'. + logged (bool): Whether the message is logged in the database. Defaults to False. + """ + + agent_name: str + content: str + turn: int + timestamp: int = time.time_ns() + visible_to: Union[str, List[str]] = "all" + msg_type: str = "text" + logged: bool = False # Whether the message is logged in the database + + @property + def msg_hash(self): + # Generate a unique message id given the content, timestamp and role + return _hash( + f"agent: {self.agent_name}\ncontent: {self.content}\ntimestamp: {str(self.timestamp)}\nturn: {self.turn}\nmsg_type: {self.msg_type}" + ) + + +class MessagePool: + """ + A pool to manage the messages in the chatArena environment. + + The pool is essentially a list of messages, and it allows a unified treatment of the visibility of the messages. + It supports two configurations for step definition: multiple players can act in the same turn (like in rock-paper-scissors). + Agents can only see the messages that 1) were sent before the current turn, and 2) are visible to the current role. + """ + + def __init__(self): + """Initialize the MessagePool with a unique conversation ID.""" + self.conversation_id = str(uuid1()) + self._messages: List[ + Message + ] = [] + self._last_message_idx = 0 + + def reset(self): + """Clear the message pool.""" + self._messages = [] + + def append_message(self, message: Message): + """ + Append a message to the pool. + + Parameters: + message (Message): The message to be added to the pool. + """ + self._messages.append(message) + + def print(self): + """Print all the messages in the pool.""" + for message in self._messages: + print(f"[{message.agent_name}->{message.visible_to}]: {message.content}") + + @property + def last_turn(self): + """ + Get the turn of the last message in the pool. + + Returns: + int: The turn of the last message. + """ + if len(self._messages) == 0: + return 0 + else: + return self._messages[-1].turn + + @property + def last_message(self): + """ + Get the last message in the pool. + + Returns: + Message: The last message. + """ + if len(self._messages) == 0: + return None + else: + return self._messages[-1] + + def get_all_messages(self) -> List[Message]: + """ + Get all the messages in the pool. + + Returns: + List[Message]: A list of all messages. + """ + return self._messages + + def get_visible_messages(self, agent_name, turn: int) -> List[Message]: + """ + Get all the messages that are visible to a given agent before a specified turn. + + Parameters: + agent_name (str): The name of the agent. + turn (int): The specified turn. + + Returns: + List[Message]: A list of visible messages. + """ + + # Get the messages before the current turn + prev_messages = [message for message in self._messages if message.turn < turn] + + visible_messages = [] + for message in prev_messages: + if ( + message.visible_to == "all" + or agent_name in message.visible_to + or agent_name == "Moderator" + ): + visible_messages.append(message) + return visible_messages diff --git a/agentreview/paper_processor.py b/agentreview/paper_processor.py new file mode 100644 index 0000000000000000000000000000000000000000..393a7e238bf5aa86976cc5b756c5f2fc68e20b44 --- /dev/null +++ b/agentreview/paper_processor.py @@ -0,0 +1,163 @@ +""" +Read papers from a PDF file and extract the title, abstract, figures and tables captions, and main content. These +functions work best with ICLR / NeurIPS papers. + +""" + +from io import StringIO + +from pdfminer.converter import TextConverter +from pdfminer.layout import LAParams +from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter +from pdfminer.pdfpage import PDFPage + + +def extract_text_from_pdf(path: str) -> str: + """Extracts text from a PDF file. + + Args: + path (str): A string specifying the path to the PDF file. + + Returns: + A string containing the extracted text from the PDF. + """ + + with open(path, 'rb') as file_handle: + # Initialize a PDF resource manager to store shared resources. + resource_manager = PDFResourceManager() + + # Set up a StringIO instance to capture the extracted text. + text_output = StringIO() + + # Create a TextConverter to convert PDF pages to text. + converter = TextConverter(resource_manager, text_output, laparams=LAParams()) + + # Initialize a PDF page interpreter. + interpreter = PDFPageInterpreter(resource_manager, converter) + + # Process each page in the PDF. + for page in PDFPage.get_pages(file_handle, caching=True, check_extractable=True): + interpreter.process_page(page) + + # Retrieve the extracted text and close the StringIO instance. + extracted_text = text_output.getvalue() + text_output.close() + + # Finalize the converter. + converter.close() + + # Replace form feed characters with newlines. + extracted_text = extracted_text.replace('\x0c', '\n') + + return extracted_text + + +def convert_text_into_dict(text: str) -> dict: + """Converts the extracted text into a dictionary. + + Args: + text (str): the extracted text from the PDF. + + Returns: + A json object containing the extracted fields from the paper. + + """ + + lines = text.split('\n') + + # Create a filtered list to store non-matching lines + filtered_lines = [line for line in lines if not (line.startswith('Under review') or + line.startswith('Published as') or + line.startswith('Paper under double-blind review'))] + + # Remove the first few empty lines before the title + while filtered_lines[0].strip() == "": + filtered_lines.pop(0) + + # Get title + title = "" + while filtered_lines[0] != "": + title += filtered_lines.pop(0) + ' ' + + title = title.strip().capitalize() + + # Remove the author information between the title and the abstract + while filtered_lines[0].lower() != "abstract": + filtered_lines.pop(0) + filtered_lines.pop(0) + + # Get abstract + abstract = "" + while filtered_lines[0].lower() != "introduction": + abstract += filtered_lines.pop(0) + ' ' + + main_content = "" + + figures_captions = [] + tables_captions = [] + + while filtered_lines != [] and not filtered_lines[0].lower().startswith("references"): + figure_caption = "" + table_caption = "" + + if filtered_lines[0].lower().startswith("figure"): + while not filtered_lines[0] == "": + figure_caption += filtered_lines.pop(0) + ' ' + + + elif filtered_lines[0].lower().startswith("Table"): + while not filtered_lines[0] == "": + table_caption += filtered_lines.pop(0) + ' ' + + else: + main_content += filtered_lines.pop(0) + ' ' + + if figure_caption != "": + figures_captions.append(figure_caption) + + if table_caption != "": + tables_captions.append(table_caption) + + + figures_captions = "\n".join(figures_captions) + "\n" + "\n".join(tables_captions) + + # Get the first section title in the Appendix + # Example section title: "A ENVIRONMENT DETAILS" + while filtered_lines != [] and not (filtered_lines[0].isupper() and filtered_lines[0][0] == "A"): + filtered_lines.pop(0) + + + appendix = "" + + while filtered_lines != []: + appendix += filtered_lines.pop(0) + ' ' + + # Now we have reached the "References" section + # Skip until we reach + + + paper = { + "Title": title.strip(), + "Abstract": abstract.strip(), + "Figures/Tables Captions": figures_captions.strip(), + "Main Content": main_content.strip(), + "Appendix": appendix.strip(), + } + + return paper + + +if __name__ == "__main__": + from utility.authentication_utils import read_and_set_openai_key + from agentreview.review import get_lm_review + + read_and_set_openai_key() + + path = "data/rejected/6359.pdf" + text = extract_text_from_pdf(path) + + parsed_paper = convert_text_into_dict(text) + + review_generated = get_lm_review(parsed_paper) + + print(review_generated["review_generated"]) diff --git a/agentreview/paper_review_arena.py b/agentreview/paper_review_arena.py new file mode 100644 index 0000000000000000000000000000000000000000..2e0c5f1a35a138753aaf8149208ef63f22482779 --- /dev/null +++ b/agentreview/paper_review_arena.py @@ -0,0 +1,185 @@ +import csv +import glob +import json +import logging +import os +from typing import Union + +from agentreview.arena import Arena, TooManyInvalidActions +from agentreview.role_descriptions import get_reviewer_description +from utility.utils import get_next_review_id, get_reviewer_type_from_profile, \ + get_paper_review_and_rebuttal_dir, format_metareviews +from .agent import Player +from .config import ArenaConfig +from .environments import TimeStep, load_environment +from .paper_review_player import PaperExtractorPlayer, AreaChair, Reviewer + + +logger = logging.getLogger(__name__) + + +class PaperReviewArena(Arena): + """Arena for the paper review environment. + + """ + + # PaperReviewArena.from_config + @classmethod + def from_config(cls, config: Union[str, ArenaConfig]): + """Create an arena from a config.""" + # If config is a path, load the config + if isinstance(config, str): + config = ArenaConfig.load(config) + + global_prompt = config.get("global_prompt", None) + + # Create the players + players = [] + for player_config in config.players: + # Add public_prompt to the player config + if global_prompt is not None: + player_config["global_prompt"] = global_prompt + + if player_config['name'].startswith("Paper Extractor"): + player = PaperExtractorPlayer.from_config(player_config) + + elif player_config['name'].startswith("AC"): + player = AreaChair.from_config(player_config) + + elif player_config['name'].startswith("Reviewer"): + player = Reviewer.from_config(player_config) + + else: + player = Player.from_config(player_config) + players.append(player) + + # Check that the player names are unique + player_names = [player.name for player in players] + assert len(player_names) == len( + set(player_names) + ), f"Player names must be unique, current players: {[','.join(player_names)]}" + + # Create the environment + config.environment[ + "player_names" + ] = player_names # add the player names to the environment config + env = load_environment(config.environment) + + return cls(players, env, global_prompt=global_prompt) + + # PaperReviewArena.step() + def step(self) -> TimeStep: + """Take a step in the game: one player takes an action and the environment updates.""" + + # if self.environment.phase_index > 4 and self.args.task == "paper_review": + # logger.info("Finishing the simulation for Phase I - IV. Please run `python run_paper_decision_cli.py ` for " + # "Phase V. (AC makes decisions).") + # return + # + # elif self.environment.phase_index > 5 and self.args.task == "paper_decision": + # logger.info("Finishing the simulation for Phase V. (AC makes decisions).") + # return + + player_name = self.environment.get_next_player() + + player = self.name_to_player[player_name] # get the player object + + observation = self.environment.get_observation( + player_name + ) # get the observation for the player + + timestep = None + + # try to take an action for a few times + for i in range(self.invalid_actions_retry): + + + # Update reviewer description for rebuttal + if self.environment.phase_index == 3 and player.name.startswith("Reviewer"): + logging.info("Update reviewers' role_desc for Phase 3 (reviewer_ac_discussion)") + reviewer_index = int(player.name.split("Reviewer ")[1]) + + # reviewer_index starts from 1, so we need to subtract 1 to get the index of the reviewer in the list + + player.role_desc = get_reviewer_description(phase="reviewer_ac_discussion", + **self.environment.experiment_setting["players"][ + 'Reviewer'][reviewer_index - 1]) + + elif self.environment.phase_index == 5: # Phase 5 AC Makes Decisions + + player.role_desc += format_metareviews(self.environment.metareviews, self.environment.paper_ids) + + action = player(observation) # take an action + + if self.environment.check_action(action, player_name): # action is valid + timestep = self.environment.step( + player_name, action + ) # update the environment + break + else: # action is invalid + logging.warning(f"{player_name} made an invalid action {action}") + continue + + if ( + timestep is None + ): # if the player made invalid actions for too many times, terminate the game + warning_msg = f"{player_name} has made invalid actions for {self.invalid_actions_retry} times. Terminating the game." + logging.warning(warning_msg) + raise TooManyInvalidActions(warning_msg) + + return timestep + + def save_history(self, path: str): + """ + Save the history of the game to a file. + + Supports csv and json formats. + """ + messages = self.environment.get_observation() + message_rows = [] + + if path.endswith(".csv"): + header = [ + "agent_name", + "content", + "turn", + "timestamp", + "visible_to", + "msg_type", + ] + for message in messages: + message_row = [ + message.agent_name, + message.content, + message.turn, + str(message.timestamp), + message.visible_to, + message.msg_type, + ] + message_rows.append(message_row) + + with open(path, "w") as f: + writer = csv.writer(f) + writer.writerow(header) + writer.writerows(message_rows) + elif path.endswith(".json"): + for message in messages: + message_row = { + "agent_name": message.agent_name, + "content": message.content, + "turn": message.turn, + "timestamp": str(message.timestamp), + "visible_to": message.visible_to, + "msg_type": message.msg_type, + } + message_rows.append(message_row) + + with open(path, "w") as f: + + + json.dump({ + "experiment_setting": self.environment.experiment_setting, + "messages": message_rows, + }, f, indent=2) + else: + raise ValueError("Invalid file format") diff --git a/agentreview/paper_review_message.py b/agentreview/paper_review_message.py new file mode 100644 index 0000000000000000000000000000000000000000..658369e2553c3dec9c7d81293360e39954fcde2e --- /dev/null +++ b/agentreview/paper_review_message.py @@ -0,0 +1,104 @@ +import logging +from typing import List + +from agentreview.message import MessagePool, Message + + +class PaperReviewMessagePool(MessagePool): + """ + A pool to manage the messages in the paper review environment. + + """ + + def __init__(self, experiment_setting: dict): + super().__init__() + self.experiment_setting = experiment_setting + + + def get_visible_messages_for_paper_review(self, agent_name, phase_index: int, + next_player_idx: int, player_names: List[str]) \ + -> (List)[Message]: + """ + Get all the messages that are visible to a given agent before a specified turn. + + Parameters: + agent_name (str): The name of the agent. + turn (int): The specified turn. + phase_index (int): The specified phase in paper reviewing process. + + Returns: + List[Message]: A list of visible messages. + """ + + reviewer_names = sorted([name for name in player_names if name.startswith("Reviewer")]) + + # Get the messages before the current turn + # prev_messages = [message for message in self._messages if message.turn < turn] + prev_messages = self._messages + + if phase_index in [0, 1]: + visible_messages = [message for message in prev_messages if message.agent_name == "Paper Extractor"] + + elif phase_index == 2: + visible_messages = [] + + for message in prev_messages: + + # The author can see the paper content and each reviewer's review + if message.agent_name == "Paper Extractor" or message.agent_name == reviewer_names[next_player_idx]: + visible_messages.append(message) + + # raise NotImplementedError(f"In Phase {phase_index}, only authors can respond to reviewers' " + # f"reviews, but the current agent is {agent_name}.") + + elif phase_index == 3: + if [agent_name.startswith(prefix) for prefix in ["AC", "Reviewer", "Paper Extractor"]]: + # Both area chairs and reviewers can see all the reviews and rebuttals + visible_messages = prev_messages + + elif agent_name.startswith("Author"): + visible_messages = [] + + elif phase_index == 4: + if agent_name.startswith("AC"): + area_chair_type = self.experiment_setting['players']['AC'][0]["area_chair_type"] + + # 'BASELINE' means we do not specify the area chair's characteristics in the config file + if area_chair_type in ["inclusive", "BASELINE"]: + # An inclusive area chair can see all the reviews and rebuttals + visible_messages = prev_messages + + elif area_chair_type == "conformist": + visible_messages = [] + + for message in prev_messages: + if message.agent_name.startswith("Author") or message.agent_name.startswith("Reviewer"): + visible_messages.append(message) + + + elif area_chair_type == "authoritarian": + visible_messages = [] + + for message in prev_messages: + if not (message.agent_name.startswith("Author") or message.agent_name.startswith("Reviewer")): + visible_messages.append(message) + + else: + raise ValueError(f"Unknown Area chair type: {area_chair_type}.") + + + else: + + visible_messages = [] + for message in prev_messages: + if ( + message.visible_to == "all" + or agent_name in message.visible_to + or agent_name == "Moderator" + ): + visible_messages.append(message) + + logging.info(f"Phase {phase_index}： {agent_name} sees {len(visible_messages)} messages from " + f"{','.join([agent.agent_name for agent in visible_messages]) if visible_messages else 'None'}") + + return visible_messages diff --git a/agentreview/paper_review_player.py b/agentreview/paper_review_player.py new file mode 100644 index 0000000000000000000000000000000000000000..7350d4de75fe5ee06e20fd62e496af0eecd269c6 --- /dev/null +++ b/agentreview/paper_review_player.py @@ -0,0 +1,120 @@ +import logging +import logging +import os +from pathlib import Path +from typing import List, Union + +from llama_index.readers.file.docs import PDFReader + +from agentreview.agent import Player +from .backends import IntelligenceBackend +from .config import BackendConfig +from .message import Message + + +class AreaChair(Player): + + def __init__( + self, + name: str, + role_desc: str, + env_type: str, + backend: Union[BackendConfig, IntelligenceBackend], + global_prompt: str = None, + **kwargs, + ): + super().__init__(name, role_desc, backend, global_prompt, **kwargs) + self.env_type = env_type + self.role_desc = role_desc + + def act(self, observation: List[Message]) -> str: + + # The author just finished their rebuttals (so last speaker is Author 1). + # The AC asks each reviewer to update their reviews. + + if self.env_type == "paper_review": + if len(observation) > 0 and observation[-1].agent_name.startswith("Author"): + return "Dear reviewers, please update your reviews based on the author's rebuttals." + + else: + return super().act(observation) + + elif self.env_type == "paper_decision": + return super().act(observation) + + else: + raise ValueError(f"Unknown env_type: {self.env_type}") + + +class Reviewer(Player): + + def __init__( + self, + name: str, + role_desc: str, + backend: Union[BackendConfig, IntelligenceBackend], + global_prompt: str = None, + **kwargs, + ): + super().__init__(name, role_desc, backend, global_prompt, **kwargs) + + def act(self, observation: List[Message]) -> str: + return super().act(observation) + + +class PaperExtractorPlayer(Player): + """A player for solely extracting contents from a paper. + + No API calls are made by this player. + """ + + def __init__( + self, + name: str, + role_desc: str, + paper_id: int, + paper_decision: str, + conference: str, + backend: Union[BackendConfig, IntelligenceBackend], + global_prompt: str = None, + **kwargs, + ): + super().__init__(name, role_desc, backend, global_prompt, **kwargs) + self.paper_id = paper_id + self.paper_decision = paper_decision + self.conference: str = conference + + def act(self, observation: List[Message]) -> str: + """ + Take an action based on the observation (Generate a response), which can later be parsed to actual actions that affect the game dynamics. + + Parameters: + observation (List[Message]): The messages that the player has observed from the environment. + + Returns: + str: The action (response) of the player. + """ + print("Improve paper loading") + logging.info(f"Loading {self.conference} paper {self.paper_id} ({self.paper_decision}) ...") + + loader = PDFReader() + document_path = Path(os.path.join(self.args.data_dir, self.conference, "paper", self.paper_decision, + f"{self.paper_id}.pdf")) # + documents = loader.load_data(file=document_path) + + num_words = 0 + main_contents = "Contents of this paper:\n\n" + FLAG = False + + for doc in documents: + text = doc.text.split(' ') + if len(text) + num_words > self.args.max_num_words: + text = text[:self.args.max_num_words - num_words] + FLAG = True + num_words += len(text) + text = " ".join(text) + main_contents += text + ' ' + if FLAG: + break + + return main_contents diff --git a/agentreview/paper_review_settings.py b/agentreview/paper_review_settings.py new file mode 100644 index 0000000000000000000000000000000000000000..a85d1e53d5cdb30dad4ca29ae624e2d6ddcc9cae --- /dev/null +++ b/agentreview/paper_review_settings.py @@ -0,0 +1,114 @@ +default_reviewer_setting = { + "is_benign": None, + "is_knowledgeable": None, + "is_responsible": None, + "provides_numeric_rating": True, +} + + +def get_experiment_settings(setting: dict): + """ + Generate experiment settings based on provided configurations for area chairs (AC) and reviewers. + + Args: + setting (dict): A dictionary containing configuration for AC, reviewers, authors, and global settings. + + Returns: + dict: Experiment settings including players (Paper Extractor, AC, Author, Reviewer) + and global settings. + """ + + experiment_setting = { + "id": None, + "players": { + + # Paper Extractor is a special player that extracts a paper from the dataset. + # Its constructor does not take any arguments. + "Paper Extractor": [{}], + + # Assume there is only one area chair (AC) in the experiment. + "AC": [get_ac_setting_from_ac_type(ac_type) for ac_type in setting['AC']], + + # Author role with default configuration. + "Author": [{}], + + # Reviewer settings are generated based on reviewer types provided in the settings. + "Reviewer": [get_reviewer_setting_from_reviewer_type(reviewer_type) for reviewer_type in setting[ + 'reviewer']], + }, + "global_settings": setting['global_settings'] + } + + return experiment_setting + + +def get_reviewer_setting_from_reviewer_type(reviewer_type: str): + """ + Map a reviewer type (e.g., 'benign', 'malicious') to a reviewer setting dictionary. + + Args: + reviewer_type (str): The type of reviewer (e.g., 'benign', 'malicious', 'knowledgeable'). + + Returns: + dict: A dictionary representing the reviewer's attributes like is_benign, is_knowledgeable, + is_responsible, or if they know the authors (e.g., 'famous', 'unfamous'). + + Raises: + ValueError: If an unknown reviewer type is provided. + """ + reviewer_setting = { + "is_benign": None, + "is_knowledgeable": None, + "is_responsible": None + } + + # Intention + if reviewer_type == "benign": + reviewer_setting["is_benign"] = True + elif reviewer_type == "malicious": + reviewer_setting["is_benign"] = False + + # Knowledgeability + elif reviewer_type == "knowledgeable": + reviewer_setting["is_knowledgeable"] = True + elif reviewer_type == "unknowledgeable": + reviewer_setting["is_knowledgeable"] = False + + # Commitment + elif reviewer_type == "responsible": + reviewer_setting["is_responsible"] = True + elif reviewer_type == "irresponsible": + reviewer_setting["is_responsible"] = False + + elif reviewer_type in ["BASELINE"]: + pass + + elif reviewer_type in ["authors_are_famous"]: + reviewer_setting["knows_authors"] = "famous" + + elif reviewer_type in ["authors_are_unfamous"]: + reviewer_setting["knows_authors"] = "unfamous" + + + else: + raise ValueError(f"Unknown reviewer type: {reviewer_type}") + + return reviewer_setting + + +def get_ac_setting_from_ac_type(ac_type: str): + """ + Generate the area chair (AC) settings based on the type of AC. + + Args: + ac_type (str): The type of area chair (e.g., 'senior', 'junior'). + + Returns: + dict: A dictionary containing the area chair type. + """ + + ac_setting = { + "area_chair_type": ac_type + } + + return ac_setting diff --git a/agentreview/role_descriptions.py b/agentreview/role_descriptions.py new file mode 100644 index 0000000000000000000000000000000000000000..4e5bb005672f27f29b3e6d5df174d292ec2f0724 --- /dev/null +++ b/agentreview/role_descriptions.py @@ -0,0 +1,515 @@ +import os +import sys + +import numpy as np + +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) + +import const +from agentreview.config import AgentConfig + +PLAYER_BACKEND = { + "backend_type": "openai-chat", + "temperature": 0.9, + "max_tokens": 4096 +} + +# archived. If we use this rubric, the scores given by the reviewers are too high +RUBRICS_v1 = ("Rubrics: 10 for strong accept (top 5% of accepted papers), " + "8 for accept (top 50% of accepted papers), " + "6 for borderline accept, " + "5 for borderline reject, " + "3 for reject, and 1 for strong reject. ") + +SCORE_CALCULATION_v1 = { + 10: "This study is among the top 0.5% of all papers", + 8: "This study is one of the most thorough I have seen. It changed my thinking on this topic. I would fight for it to be accepted", + 6: "This study provides sufficient support for all of its claims/arguments. Some extra experiments are needed, but not essential. The method is highly original and generalizable to various fields. It deepens the understanding of some phenomenons or lowers the barriers to an existing research direction", + 5: "This study provides sufficient support for its major claims/arguments, some minor points may need extra support or details. The method is moderately original and generalizable to various relevant fields. The work it describes is not particularly interesting and/or novel, so it will not be a big loss if people don’t see it in this conference", + 3: "Some of the main claims/arguments are not sufficiently supported, there are major technical/methodological problems. The proposed method is somewhat original and generalizable to various relevant fields. I am leaning towards rejection, but I can be persuaded if my co-reviewers think otherwise", + 1: "This study is not yet sufficiently thorough to warrant publication or is not relevant to the conference. This paper makes marginal contributions" +} + +# Start to use this rubric from 2024.1.23 as SCORE_CALCULATION_v1 is too harsh +SCORE_CALCULATION = { + 10: "This study is among the top 2% of all papers. It is one of the most thorough I have seen. It changed my " + "thinking on this topic. I would fight for it to be accepted", + 8: "This study is among the top 10% of all papers. It provides sufficient support for all of its claims/arguments. " + "Some extra experiments are needed, " + "but not essential. The method is highly original and generalizable to various fields. It deepens the understanding of some phenomenons or lowers the barriers to an existing research direction", + 6: "This study provides sufficient support for its major claims/arguments, some minor points may need extra support or details. The method is moderately original and generalizable to various relevant fields. The work it describes is not particularly interesting and/or novel, so it will not be a big loss if people don’t see it in this conference", + 5: "Some of the main claims/arguments are not sufficiently supported, there are major technical/methodological " + "problems. The proposed method is somewhat original and generalizable to various relevant fields. I am leaning towards rejection, but I can be persuaded if my co-reviewers think otherwise", + 3: "This paper makes marginal contributions", + 1: "This study is not yet sufficiently thorough to warrant publication or is not relevant to the conference" +} + +RUBRICS_v1 = ("Rubrics: " + f"10 for strong accept ({SCORE_CALCULATION[10]}); " + f"8 for accept ({SCORE_CALCULATION[8]}); " + f"6 for borderline accept ({SCORE_CALCULATION[6]}); " + f"5 for borderline reject ({SCORE_CALCULATION[5]}); " + f"3 for reject ({SCORE_CALCULATION[3]}); " + f"1 for strong reject ({SCORE_CALCULATION[1]}); ") + +INSTRUCTIONS_FOR_FAMOUS_AUTHORS = ("You know that the authors of the paper are from a very famous lab and have " + "several publication in " + "this " + "field. Be sure to consider that when writing the paper reviews. " + "\n\n") + +RUBRICS = (f"* 10: {SCORE_CALCULATION[10]};\n" + f"* 8: {SCORE_CALCULATION[8]};\n" + f"* 6: {SCORE_CALCULATION[6]};\n" + f"* 5: {SCORE_CALCULATION[5]};\n" + f"* 3: {SCORE_CALCULATION[3]};\n" + f"* 1: {SCORE_CALCULATION[1]}. ") + +# Try to lower the score +SCORE_CONTROL = ("This is a very rigorous top-tier conference. " + "Most papers get scores <=5 before the rebuttal. ") + +# Need to explain this +EXPLANATION_FOR_NOT_UPDATING_MANUSCRIPT = (f"Note: Do not mention that the authors did not update the manuscripts " + f"and do not penalize them for " + f"not revising their papers. They cannot do it now. Just assume they have revised their " + f"manuscripts according to their rebuttals.") + + +def get_instructions_for_overall_scores(author_type: str) -> str: + instruction = "Do not write any reasons. " + + if author_type not in ["famous"]: + instruction += ("Do not assign scores of 7 or higher before the rebuttal unless the paper " + "demonstrates exceptional originality and " + "significantly advances the state-of-the-art in machine learning. " + ) + instruction += "Intermediary integer scores such as 9, 7, 4, and 2 are allowed. " + + return instruction + +def get_reviewer_description(is_benign: bool = None, is_knowledgeable: bool = None, is_responsible: bool = None, + provides_numeric_rating: + bool = True, knows_authors: bool = False, phase: str = "reviewer_write_reviews"): + assert phase in ["reviewer_write_reviews", 'reviewer_ac_discussion'] + assert provides_numeric_rating in [True, False] + bio = ("You are a reviewer. You write peer review of academic papers by evaluating their technical " + f"quality, originality, and clarity. ") + + # The reviewer's famous identities are known to the AC + if knows_authors: + bio += "\n\n" + INSTRUCTIONS_FOR_FAMOUS_AUTHORS + + else: + bio += f"{SCORE_CONTROL}\n\n" + + bio += "## Review Guidelines\n" + + if phase in ["reviewer_write_reviews"]: + + guideline = "Write a peer review using the following format:\n\n" + guideline += "```\n" + if provides_numeric_rating: + guideline += f"Overall rating: ... # {get_instructions_for_overall_scores(knows_authors)}\n\n" + + """ + # Review formats used in most ICLR conferences + guideline += "Summary: ... # Provide a brief summary of the paper, such as its main contributions.\n\n" + guideline += "Strengths: ... # Give a list of strengths for the paper.\n\n" + guideline += "Weaknesses: ... # Give a list of weaknesses and questions for the paper.\n\n" + """ + + # Review formats used in [Stanford's Nature Submission](https://arxiv.org/abs/2310.01783) + guideline += "Significance and novelty: ... \n\n" + guideline += "Reasons for acceptance: ... # List 4 key reasons. \n\n" + guideline += "Reasons for rejection: ... # List 4 key reasons. For each of 4 key reasons, use **>=2 sub bullet points** to further clarify and support your arguments in painstaking details \n\n" + guideline += "Suggestions for improvement: ... # List 4 key suggestions \n\n" + + + + + + + + elif phase in ["reviewer_ac_discussion"]: + + guideline = "Based on the authors' responses, write an updated paper review in the reviewer-AC discussion." + + if provides_numeric_rating: + guideline += ( + "Decrease your score if the authors fail to address your or other reviewers' concerns, or " + f"provide very vague responses. " + f"Increase your score only if the authors have " + f"addressed all your and other " + f"reviewers' concerns, and have comprehensively described how they plan to update the manuscript. Keep " + f"the " + f"score " + f"unchanged " + f"otherwise. {EXPLANATION_FOR_NOT_UPDATING_MANUSCRIPT}" + "\n\n## Format for the updated review\n\n```\n") + + guideline += ("Overall rating: ... # Provide an updated overall rating using an integer from 1 to 10. Do " + "not penalize the authors for not updating their manuscripts. They cannot revise their " + "manuscripts now.") + else: + guideline += "\n\n```\n" + + guideline += (f"Summary: ... # " + f"{'Provide a justification on your updated score.' if provides_numeric_rating else ''} Comment on " + f"whether the " + "author has " + "addressed " + "your questions and concerns. Note that authors cannot revise their " + "manuscripts now.\n") + + else: + raise ValueError(f"Invalid phase for a reviewer: {phase}") + + bio += f"{guideline}```\n\n" + + if not all([x is None for x in [is_benign, is_knowledgeable, is_responsible]]): + bio += "## Your Biography\n" + + # Knowledgeability + desc_knowledgeable_reviewer = ( + "You are knowledgeable, with a strong background and a PhD degree in the subject areas " + "related to this paper. " + "You possess the expertise necessary to scrutinize " + "and provide insightful feedback to this paper.") + + desc_unknowledgeable_reviewer = ( + "You are not knowledgeable and do not have strong background in the subject areas related to " + "this paper.") + + if is_knowledgeable is not None: + if is_knowledgeable: + desc = desc_knowledgeable_reviewer + else: + desc = desc_unknowledgeable_reviewer + + bio += f"Knowledgeability: {desc}\n\n" + + # Responsible vs. lazy + + desc_responsible_reviewer = ("As a responsible reviewer, you highly responsibly write paper reviews and actively " + "participate in reviewer-AC discussions. " + "You meticulously assess a research " + "paper's " + "technical accuracy, innovation, and relevance. You thoroughly read the paper, " + "critically analyze the methodologies, and carefully consider the paper's " + "contribution to the field. ") + + desc_lazy_reviewer = ("As a lazy reviewer, your reviews tend to be superficial and hastily done. You do not like " + "to discuss in the reviewer-AC discussion. " + "Your assessments might overlook critical details, lack depth in analysis, " + "fail to recognize novel contributions, " + "or offer generic feedback that does little to advance the paper's quality.") + + if is_responsible is not None: + + if is_responsible: + desc = desc_responsible_reviewer + else: + desc = desc_lazy_reviewer + + bio += f"Responsibility: {desc}\n\n" + + # Benign (Good) vs. Malicious + desc_benign_reviewer = ("As a benign reviewer, your approach to reviewing is guided by a genuine intention " + "to aid authors in enhancing their work. You provide detailed, constructive feedback, " + "aimed at both validating robust research and guiding authors to refine and improve their work. " + "You are also critical of technical flaws in the paper. ") + + desc_malicious_reviewer = ("As a mean reviewer, your reviewing style is often harsh and overly critical, " + "with a tendency towards negative bias. Your reviews may focus excessively on " + "faults, sometimes overlooking the paper's merits. Your feedback can be discouraging, " + "offering minimal guidance for improvement, and often aims more at rejection than constructive critique. ") + + if is_benign is not None: + + if is_benign: + desc = desc_benign_reviewer + else: + desc = desc_malicious_reviewer + + bio += f"Intention: {desc}\n\n" + + if provides_numeric_rating: + bio += f"## Rubrics for Overall Rating\n\n{RUBRICS}" + + return bio + + +def get_author_description() -> str: + bio = ("You are an author. You write research papers and submit them to conferences. During the rebuttal phase, " + "you carefully read the reviews from the reviewers and respond to each of them.\n\n") + + bio += "## Author Guidelines\n" + + bio += "Write a response to the reviews using the following format:\n\n" + bio += "```\n" + bio += ("Response: ... # Provide a brief response to each review. Address each question and weakness mentioned " + "by the reviewer. No need to respond to the strengths they mentioned. \n\n") + + return bio + + +def get_ac_description(area_chair_type: str, phase: str, scoring_method: str, num_papers_per_area_chair: int, + knows_authors: bool = False, **kwargs) -> ( + str): + """ + Note: We assume that the AC definitely provides a score so that the papers can be compared + Args: + phase (str): The phase of the conference. Must be either "reviewer_ac_discussion" or "ac_write_metareviews". + scoring_method (str): The method used by the area chair to make the final decision. Must be either of + "recommendation": directly make a recommendation (e.g. "Accept", "Reject") for each paper + "ranking": rank the papers using your willingness to accept + + """ + + acceptance_rate = kwargs.get('acceptance_rate', 0.32) + bio = "You are a very knowledgeable and experienced area chair in a top-tier machine learning conference. " + + if phase == "ac_write_metareviews": + bio += ("You evaluate the reviews provided by reviewers and write metareviews. Later, you will decide which " + "paper gets accepted or rejected based on your metareviews. ") + + elif phase == "ac_make_decisions": + bio += "Based on the metareviews you wrote previously, you decide if a paper is accepted or rejected. " + + # The authors' famous identities are known to the AC + if knows_authors: + bio += INSTRUCTIONS_FOR_FAMOUS_AUTHORS + SCORE_CONTROL + + bio += "\n\n## Area Chair Guidelines\n" + + if phase == "ac_write_metareviews": + + guideline = "Write a metareview using the following format:\n\n" + guideline += "```\n" + guideline += ( + f"Score: ... # Provide a score for the paper in the range from 1 to 10. {get_instructions_for_overall_scores(knows_authors)}Fractions such as " + "6.5 is allowed.\n\n") + guideline += ("Summary: ... # Provide a summary of the paper based on the paper contents (if provided), " + "reviewers' " + "reviews and discussions (if provided), authors' rebuttal, and your own expertise. " + f"{EXPLANATION_FOR_NOT_UPDATING_MANUSCRIPT}\n") + + bio += guideline + + bio += "```\n\n" + + elif phase == "ac_make_decisions": + max_num_accepted_papers = int(np.floor(num_papers_per_area_chair * acceptance_rate)) + + # The area chair usually accept more papers than s/he should + # So we use a ranking approach + + if scoring_method == "recommendation": + num_rejected_papers = int(num_papers_per_area_chair) + CONTROL_NUM_ACCEPTED_PAPERS = (f"You must accept around " + f"{max_num_accepted_papers} out of {num_papers_per_area_chair} papers, " + # f"so around {num_rejected_papers - max_num_accepted_papers} papers should " + # f"have a decision of 'Reject'. " + # f"You should maintain the high criteria of this conference. " + # f"'5' is borderline reject." + ) + guideline = (f"Carefully decide if a paper is accepted or rejected using the metareview. Use the following " + f"format ") + guideline += f"({CONTROL_NUM_ACCEPTED_PAPERS})" + guideline += f":\n\n" + + guideline += "```\n" + guideline += ("Paper ID: ... # Provide the first paper ID. \n" + "Decision: ... # Provide a decision for the paper. Must be one of " + "'Reject' and 'Accept'.\n" + # "Reasons: ... # Provide a short justification for your decision, maximum 3 sentences. \n" + "Paper ID: ... # Provide the second paper ID. \n" + f"... # Likewise\n") + guideline += "```\n\n" + + bio += guideline + + elif scoring_method == "ranking": + + # The area chair usually accept more papers than s/he should + # So we use this ranking approach + + guideline = (f"Rank the papers from the paper you are most willing to accept to the least willing to " + f"accept. '1' indicates " + f"the paper " + f"you are most " + f"willing to accept. " + f"Use this format:\n\n") + guideline += "```\n" + guideline += "Paper ID: 1 # The paper ID you most want to accept.\n" + guideline += "Willingness to accept: 1 # This integer must be unique for each paper. \n" + guideline += "Paper ID: ... # The second paper ID you most want to accept .. \n...\n" + guideline += "Willingness to accept: 2 \n" + guideline += "...\n```\n\n" + + bio += guideline + + else: + raise NotImplementedError(f"Unknown scoring method: {scoring_method}") + + + else: + raise ValueError(f"Invalid phase for an area chair: {phase}") + + if phase == "ac_write_metareviews": + bio += f"## Rubrics for Overall Rating\n\n{RUBRICS}\n\n" + + desc_inclusive_ac = ("You are an inclusive area chair. You tend to hear from all reviewers' opinions and combine " + "them with your own judgments to make the final decision.") + + desc_conformist_ac = ("You are a conformist area chair who perfunctorily handle area chair duties. You " + "mostly follow " + "the reviewers' suggestions to write your metareview, score the paper, and decide whether " + "to accept a paper.") + + desc_authoritarian_ac = ("You are an authoritarian area chair. You tend to read the paper on your own, follow your " + "own " + "judgment and mostly ignore " + "the reviewers' opinions.") + + desc = "" + + if phase == "ac_write_metareviews": + + if area_chair_type == "inclusive": + desc = desc_inclusive_ac + elif area_chair_type == "conformist": + desc = desc_conformist_ac + elif area_chair_type == "authoritarian": + desc = desc_authoritarian_ac + elif area_chair_type == "BASELINE": + desc = "" + + elif phase == "ac_make_decisions": + # We do not introduce different types of ACs in the decision phase + desc = "" + + else: + raise ValueError(f"Invalid area chair type: {area_chair_type}. Choose from {','.join(const.AREA_CHAIR_TYPES)}.") + + if desc != "": + bio += f"## Your Biography\n{desc}\n\n" + + return bio + + +def get_reviewer_player_config(reviewer_index: int, is_benign: bool, is_knowledgeable: bool, is_responsible: bool, + global_settings: dict) -> dict: + """ + + Get a Player object that represents a reviewer. + + Args: + reviewer_index: + is_benign (bool): If the reviewer has good intention and provides constructive feedback. If None, we do not add this field to the bio. + is_knowledgeable (bool): If the reviewer is knowledgeable and has a strong background in the subject areas related + to the paper. If None, we do not add this field to the bio. + is_responsible (bool): If the reviewer is responsible and provides detailed feedback. + provides_numeric_rating (bool): If the reviewer provides an overall rating (e.g. accept, weak accept) to the + paper. If None, we do not add this field to the bio. + knows_authors (str): The type of the authors of the paper under review. Must be one of "famous", + "unfamous", None (Default. Author type is unknown) + + Return + player (dict): A player object that represents the reviewer. + + """ + + knows_authors = "reviewer" in global_settings['persons_aware_of_authors_identities'] + provides_numeric_rating = "reviewer" in global_settings['provides_numeric_rating'] + + reviewer = { + "name": f"Reviewer {reviewer_index}", + "role_desc": get_reviewer_description(is_benign, is_knowledgeable, is_responsible, provides_numeric_rating, + knows_authors), + # "role_desc": get_reviewer_description(is_benign, is_knowledgeable, is_responsible, provides_numeric_rating), + "backend": PLAYER_BACKEND, + "metadata": { + "is_benign": is_benign, + "is_knowledgeable": is_knowledgeable, + "is_responsible": is_responsible, + "knows_authors": knows_authors, + } + } + + return AgentConfig(**reviewer) + + +def get_author_config() -> dict: + author = { + "name": f"Author", + "role_desc": get_author_description(), + "backend": PLAYER_BACKEND + } + + return AgentConfig(**author) + + +def get_paper_extractor_config(**kwargs) -> dict: + max_tokens = kwargs.pop('max_tokens', 2048) + + paper_extractor = { + "name": f"Paper Extractor", + "role_desc": "This is a player that only extracts content from the paper. No API calls are made", + "backend": { + "backend_type": "dummy", + # "temperature": 0., + "max_tokens": max_tokens, + }, + } + + return AgentConfig(**paper_extractor) + + +def get_ac_config(**kwargs) -> dict: + """ + + Get a Player object that represents an area chair. + + Args: + index_ac (int): + is_benign (bool): If the reviewer has good intention and provides constructive feedback. + is_knowledgeable: If the reviewer is knowledgeable and has a strong background in the subject areas related + to the paper. + is_responsible (bool): If the reviewer is responsible and provides detailed feedback. + provides_numeric_rating (bool): If the reviewer provides an overall rating (e.g. accept, weak accept) to the + paper. + + scoring_method (str): Scoring method for the area chair. + + Return + player (dict): A player object that represents the area chair. + + """ + + env_type = kwargs.pop('env_type') + global_settings = kwargs.get('global_settings', {}) + + if env_type == "paper_review": + phase = "ac_write_metareviews" + + elif env_type == "paper_decision": + phase = "ac_make_decisions" + + else: + raise NotImplementedError + + kwargs['phase'] = phase + kwargs['knows_authors'] = "ac" in global_settings['persons_aware_of_authors_identities'] + + area_chair = { + "name": "AC", # We assume there is only 1 AC for now + "role_desc": get_ac_description(**kwargs), + "backend": {'backend_type': 'openai-chat', + 'temperature': 0.0, # make the AC decision deterministic + 'max_tokens': 4096}, + "env_type": env_type, + } + + return AgentConfig(**area_chair) diff --git a/agentreview/ui/__init__.py b/agentreview/ui/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/agentreview/ui/cli.py b/agentreview/ui/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..9bcf4ce63bd41b800bcde02df872039b001d7099 --- /dev/null +++ b/agentreview/ui/cli.py @@ -0,0 +1,269 @@ +import logging +import logging +import os +import os.path as osp +from typing import Union + +from colorama import Fore +from colorama import Style as CRStyle +from prompt_toolkit import prompt +from prompt_toolkit.completion import WordCompleter +from prompt_toolkit.styles import Style +from rich.console import Console + +from utility.utils import get_rebuttal_dir, load_gpt4_generated_ac_decisions, \ + save_gpt4_generated_ac_decisions +from ..arena import Arena, TooManyInvalidActions +from ..backends.human import HumanBackendError +from ..environments import PaperReview, PaperDecision + +# Get the ASCII art from https://patorjk.com/software/taag/#p=display&f=Big&t=Chat%20Arena +ASCII_ART = r""" + _ _____ _ + /\ | | | __ \ (_) + / \ __ _ ___ _ __ | |_| |__) |_____ ___ _____ __ + / /\ \ / _` |/ _ \ '_ \| __| _ // _ \ \ / / |/ _ \ \ /\ / / + / ____ \ (_| | __/ | | | |_| | \ \ __/\ V /| | __/\ V V / + /_/ \_\__, |\___|_| |_|\__|_| \_\___| \_/ |_|\___| \_/\_/ + __/ | + |___/ +""" + +color_dict = { + "red": Fore.RED, + "green": Fore.GREEN, + + "blue": Fore.BLUE, # Paper Extractor + "light_red": Fore.LIGHTRED_EX, # AC + "light_green": Fore.LIGHTGREEN_EX, # Author + "yellow": Fore.YELLOW, # R1 + "magenta": Fore.MAGENTA, # R2 + "cyan": Fore.CYAN, + "white": Fore.WHITE, + "black": Fore.BLACK, + + "light_yellow": Fore.LIGHTYELLOW_EX, + "light_blue": Fore.LIGHTBLUE_EX, + "light_magenta": Fore.LIGHTMAGENTA_EX, + "light_cyan": Fore.LIGHTCYAN_EX, + "light_white": Fore.LIGHTWHITE_EX, + "light_black": Fore.LIGHTBLACK_EX, + +} + +visible_colors = [ + color + for color in color_dict # ANSI_COLOR_NAMES.keys() + if color not in ["black", "white", "red", "green"] and "grey" not in color +] + +try: + import colorama +except ImportError: + raise ImportError( + "Please install colorama: `pip install colorama`" + ) + +MAX_STEPS = 20 # We should not need this parameter for paper reviews anyway + +# Set logging level to ERROR +logging.getLogger().setLevel(logging.ERROR) + + +class ArenaCLI: + """The CLI user interface for ChatArena.""" + + def __init__(self, arena: Arena): + self.arena = arena + self.args = arena.args + + + def launch(self, max_steps: int = None, interactive: bool = True): + """Run the CLI.""" + + if not interactive and max_steps is None: + max_steps = MAX_STEPS + + args = self.args + + console = Console() + # Print ascii art + console.print(ASCII_ART, style="bold dark_orange3") + timestep = self.arena.reset() + console.print("🎓AgentReview Initialized!", style="bold green") + + env: Union[PaperReview, PaperDecision] = self.arena.environment + players = self.arena.players + + env_desc = self.arena.global_prompt + num_players = env.num_players + player_colors = visible_colors[:num_players] # sample different colors for players + name_to_color = dict(zip(env.player_names, player_colors)) + + print("name_to_color: ", name_to_color) + # System and Moderator messages are printed in red + name_to_color["System"] = "red" + name_to_color["Moderator"] = "red" + + console.print( + f"[bold green underline]Environment ({env.type_name}) description:[/]\n{env_desc}" + ) + + # Print the player name, role_desc and backend_type + for i, player in enumerate(players): + player_name_str = f"[{player.name} ({player.backend.type_name})] Role Description:" + # player_name = Text(player_name_str) + # player_name.stylize(f"bold {name_to_color[player.name]} underline") + # console.print(player_name) + # console.print(player.role_desc) + + logging.info(color_dict[name_to_color[player.name]] + player_name_str + CRStyle.RESET_ALL) + logging.info(color_dict[name_to_color[player.name]] + player.role_desc + CRStyle.RESET_ALL) + + console.print(Fore.GREEN + "\n========= Arena Start! ==========\n" + CRStyle.RESET_ALL) + + step = 0 + while not timestep.terminal: + if env.type_name == "paper_review": + if env.phase_index > 4: + break + + elif env.type_name == "paper_decision": + # Phase 5: AC makes decisions + if env.phase_index > 5: + break + + else: + raise NotImplementedError(f"Unknown environment type: {env.type_name}") + + if interactive: + command = prompt( + [("class:command", "command (n/r/q/s/h) > ")], + style=Style.from_dict({"command": "blue"}), + completer=WordCompleter( + [ + "next", + "n", + "reset", + "r", + "exit", + "quit", + "q", + "help", + "h", + "save", + "s", + ] + ), + ) + command = command.strip() + + if command == "help" or command == "h": + console.print("Available commands:") + console.print(" [bold]next or n or [/]: next step") + console.print(" [bold]exit or quit or q[/]: exit the game") + console.print(" [bold]help or h[/]: print this message") + console.print(" [bold]reset or r[/]: reset the game") + console.print(" [bold]save or s[/]: save the history to file") + continue + elif command == "exit" or command == "quit" or command == "q": + break + elif command == "reset" or command == "r": + timestep = self.arena.reset() + console.print( + "\n========= Arena Reset! ==========\n", style="bold green" + ) + continue + elif command == "next" or command == "n" or command == "": + pass + elif command == "save" or command == "s": + # Prompt to get the file path + file_path = prompt( + [("class:command", "save file path > ")], + style=Style.from_dict({"command": "blue"}), + ) + file_path = file_path.strip() + # Save the history to file + self.arena.save_history(file_path) + # Print the save success message + console.print(f"History saved to {file_path}", style="bold green") + else: + console.print(f"Invalid command: {command}", style="bold red") + continue + + try: + timestep = self.arena.step() + except HumanBackendError as e: + # Handle human input and recover with the game update + human_player_name = env.get_next_player() + if interactive: + human_input = prompt( + [ + ( + "class:user_prompt", + f"Type your input for {human_player_name}: ", + ) + ], + style=Style.from_dict({"user_prompt": "ansicyan underline"}), + ) + # If not, the conversation does not stop + timestep = env.step(human_player_name, human_input) + else: + raise e # cannot recover from this error in non-interactive mode + except TooManyInvalidActions as e: + # Print the error message + # console.print(f"Too many invalid actions: {e}", style="bold red") + print(Fore.RED + "This will be red text" + CRStyle.RESET_ALL) + break + + # The messages that are not yet logged + messages = [msg for msg in env.get_observation() if not msg.logged] + + # Print the new messages + for msg in messages: + message_str = f"[{msg.agent_name}->{msg.visible_to}]: {msg.content}" + console.print(color_dict[name_to_color[msg.agent_name]] + message_str + CRStyle.RESET_ALL) + msg.logged = True + + step += 1 + if max_steps is not None and step >= max_steps: + break + + console.print("\n========= Arena Ended! ==========\n", style="bold red") + + if env.type_name == "paper_review": + + paper_id = self.arena.environment.paper_id + rebuttal_dir = get_rebuttal_dir(output_dir=self.args.output_dir, + paper_id=paper_id, + experiment_name=self.args.experiment_name, + model_name=self.args.model_name, + conference=self.args.conference) + + os.makedirs(rebuttal_dir, exist_ok=True) + + path_review_history = f"{rebuttal_dir}/{paper_id}.json" + + if osp.exists(path_review_history): + raise Exception(f"History already exists!! ({path_review_history}). There must be something wrong with " + f"the path to save the history ") + + self.arena.save_history(path_review_history) + + elif env.type_name == "paper_decision": + ac_decisions = load_gpt4_generated_ac_decisions(output_dir=args.output_dir, + conference=args.conference, + model_name=args.model_name, + ac_scoring_method=args.ac_scoring_method, + experiment_name=args.experiment_name, + num_papers_per_area_chair=args.num_papers_per_area_chair) + + + ac_decisions += [env.ac_decisions] + + save_gpt4_generated_ac_decisions(ac_decisions, + output_dir=args.output_dir, + conference=args.conference, + model_name=args.model_name, + ac_scoring_method=args.ac_scoring_method, + experiment_name=args.experiment_name) diff --git a/agentreview/utils.py b/agentreview/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..acc9e084b754831c2ee93e086e759f24c4adffbd --- /dev/null +++ b/agentreview/utils.py @@ -0,0 +1,116 @@ +import json +import re + + +def is_json(myjson): + """ + Checks whether a given string is a valid JSON. + + Parameters: + myjson (str): The string to be checked. + + Returns: + bool: True if the string is a valid JSON, False otherwise. + """ + try: + _ = json.loads(myjson) + except ValueError: + return False + return True + + +def is_json_inside(text): + """ + Checks whether a given string contains valid JSON(s). + + Parameters: + text (str): The string to be checked. + + Returns: + bool: True if the string contains valid JSON(s), False otherwise. + """ + text = re.sub(r"\s+", " ", text) + matches = re.findall(r"\{.*?\}", text) + for match in matches: + if is_json(match): + return True + return False + + +def extract_jsons(text): + """ + Extracts all valid JSON objects from a given string. + + Parameters: + text (str): The string from which JSON objects are to be extracted. + + Returns: + List[Dict]: A list of all extracted JSON objects. + """ + text = re.sub(r"\s+", " ", text) + matches = re.findall(r"\{.*?\}", text) + parsed_jsons = [] + for match in matches: + try: + json_object = json.loads(match) + parsed_jsons.append(json_object) + except ValueError: + pass + return parsed_jsons + + +def extract_code(text): + """ + Extracts all code blocks encapsulated by '```' from a given string. + + Parameters: + text (str): The string from which Python code blocks are to be extracted. + + Returns: + List[str]: A list of all extracted Python code blocks. + """ + text = re.sub("```python", "```", text) + matches = re.findall(r"```(.*?)```", text, re.DOTALL) + parsed_codes = [] + for match in matches: + parsed_codes.append(match) + return parsed_codes + + +class AttributedDict(dict): + """ + A dictionary class whose keys are automatically set as attributes of the class. + + The dictionary is serializable to JSON. + + Inherits from: + dict: Built-in dictionary class in Python. + + Note: + This class provides attribute-style access to dictionary keys, meaning you can use dot notation + (like `my_dict.my_key`) in addition to the traditional bracket notation (`my_dict['my_key']`). + """ + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def __setattr__(self, key, value): + self[key] = value + + def __getattr__(self, key): + if key in self: + return self[key] + raise AttributeError + + def __delattr__(self, key): + del self[key] + + # check whether the key is string when adding the key + def __setitem__(self, key, value): + if not isinstance(key, str): + raise ValueError("The key must be a string") + super().__setitem__(key, value) + + def update(self, *args, **kwargs): + for key, value in dict(*args, **kwargs).items(): + self[key] = value diff --git a/arguments.py b/arguments.py new file mode 100644 index 0000000000000000000000000000000000000000..d4f7bc783b32ae4c8eba3451d437f6a6692a3f73 --- /dev/null +++ b/arguments.py @@ -0,0 +1,156 @@ +import argparse +import logging +import os +import sys + +def parse_args(): + parser = argparse.ArgumentParser(description="Argument parser for configuring OpenAI API and experiment settings") + + # Authentication details for OpenAI API + parser.add_argument( + "--openai_key", type=str, default=None, help="API key to authenticate with OpenAI. Can be set via this argument or through the OPENAI_API_KEY environment variable." + ) + + parser.add_argument( + "--deployment", type=str, default=None, help="For Azure OpenAI: the deployment name to be used when calling the API." + ) + + parser.add_argument( + "--openai_client_type", type=str, default="openai", choices=["openai", "azure_openai"], + help="Specify the OpenAI client type to use: 'openai' for standard OpenAI API or 'azure_openai' for Azure-hosted OpenAI services." + ) + + parser.add_argument( + "--endpoint", type=str, default=None, help="For Azure OpenAI: custom endpoint to access the API. Should be in the format 'https://.openai.azure.com'." + ) + + + parser.add_argument( + "--api_version", type=str, default="2023-03-15-preview", help="API version to be used for making requests. Required for Azure OpenAI clients." + ) + + # Experiment configuration + parser.add_argument( + "--ac_scoring_method", type=str, default="ranking", choices=["recommendation", "ranking"], + help="Specifies the scoring method used by the Area Chair (AC) to evaluate papers: 'recommendation' or 'ranking'." + ) + + parser.add_argument( + "--conference", type=str, default="ICLR2023", help="Conference name where the papers are being evaluated, e.g., 'ICLR2023'." + ) + + parser.add_argument( + "--num_reviewers_per_paper", type=int, default=3, help="The number of reviewers assigned to each paper." + ) + + parser.add_argument( + "--experiment_name", + type=str, default=None, required=False, + choices=[ + "BASELINE", "benign_Rx1", "malicious_Rx1", "malicious_Rx2", "malicious_Rx3", "unknowledgeable_Rx1", + "knowledgeable_Rx1", "responsible_Rx1", "irresponsible_Rx1", "irresponsible_Rx2", "irresponsible_Rx3", + "inclusive_ACx1", "authoritarian_ACx1", "conformist_ACx1", "no_numeric_ratings"], + help="Specifies the name of the experiment to run. Choose from predefined experiment types based on the reviewer and AC behavior or experiment configuration." + ) + + parser.add_argument( + "--ignore_missing_metareviews", action="store_true", help="If set, missing metareviews are ignored, allowing the experiment to continue without them." + ) + + parser.add_argument( + "--overwrite", action="store_true", help="If set, existing results or output files will be overwritten without prompting." + ) + + parser.add_argument( + "--num_papers_per_area_chair", type=int, default=10, help="The number of papers each area chair is assigned for evaluation." + ) + + # Model configuration + parser.add_argument( + "--model_name", type=str, default="gpt-4o", choices=["gpt-4", "gpt-4o", "gpt-35-turbo"], + help="Specifies which GPT model to use: 'gpt-4' for the standard GPT-4 model, 'gpt-35-turbo' for a " + "cost-effective alternative, or 'gpt-4o' for larger context support." + ) + + # Output directories + parser.add_argument( + "--output_dir", type=str, default="outputs", help="Directory where results, logs, and outputs will be stored." + ) + + # Output directories + parser.add_argument( + "--max_num_words", type=int, default=16384, help="Maximum number of words in the paper." + ) + + parser.add_argument( + "--visual_dir", type=str, default="outputs/visual", help="Directory where visualization files (such as graphs and plots) will be stored." + ) + + # System configuration + parser.add_argument( + "--device", type=str, default='cuda', help="The device to be used for processing (e.g., 'cuda' for GPU acceleration or 'cpu' for standard processing)." + ) + + parser.add_argument( + "--data_dir", type=str, default='data', help="Directory where input data (e.g., papers) are stored." + ) + + + parser.add_argument( + "--acceptance_rate", type=float, default=0.32, + help="Percentage of papers to accept. We use 0.32, the average acceptance rate for ICLR 2020 - 2023" + ) + + args = parser.parse_args() + + # Ensure necessary directories exist + os.makedirs(args.visual_dir, exist_ok=True) + os.makedirs(args.output_dir, exist_ok=True) + + # Set 'player_to_test' based on experiment name + if args.experiment_name is None: + args.player_to_test = None + elif "Rx" in args.experiment_name: + args.player_to_test = "Reviewer" + elif "ACx" in args.experiment_name: + args.player_to_test = "Area Chair" + elif "no_rebuttal" in args.experiment_name or "no_overall_score" in args.experiment_name: + args.player_to_test = "Review Mechanism" + + # Sanity checks for authentication + print("Running sanity checks for the arguments...") + + if args.openai_client_type == "openai": + if os.environ.get('OPENAI_API_KEY') is None: + assert isinstance(args.openai_key, str), ("Please specify the `--openai_key` argument OR set the " + "OPENAI_API_KEY environment variable.") + raise ValueError("OpenAI key is missing.") + + if args.openai_client_type == "azure_openai": + if os.environ.get('AZURE_OPENAI_KEY') is None: + assert isinstance(args.openai_key, str), ("Please specify the `--openai_key` argument OR set the " + "AZURE_OPENAI_KEY environment variable.") + os.environ['AZURE_OPENAI_KEY'] = args.openai_key + + if os.environ.get('AZURE_DEPLOYMENT') is None: + assert isinstance(args.deployment, str), ("Please specify the `--deployment` argument OR set the " + "AZURE_DEPLOYMENT environment variable.") + os.environ['AZURE_DEPLOYMENT'] = args.deployment + + if os.environ.get('AZURE_ENDPOINT') is None: + assert isinstance(args.endpoint, str), ("Please specify the `--endpoint` argument OR set the " + "AZURE_ENDPOINT environment variable.") + endpoint = args.endpoint + else: + endpoint = os.environ.get('AZURE_ENDPOINT') + + if not endpoint.startswith("https://"): + endpoint = f"https://{endpoint}.openai.azure.com" + os.environ['AZURE_ENDPOINT'] = endpoint + + if os.environ.get('OPENAI_API_VERSION') is None: + assert isinstance(args.api_version, str), ("Please specify the `--api_version` argument OR set the " + "OPENAI_API_VERSION environment variable.") + os.environ['OPENAI_API_VERSION'] = args.api_version + + return args diff --git a/const.py b/const.py new file mode 100644 index 0000000000000000000000000000000000000000..6106b90dd72676e9c2d7d0d760528ca78c7299c8 --- /dev/null +++ b/const.py @@ -0,0 +1,100 @@ + + +""" +Note +- ICLR 2021 has a category for "Significant-concerns" +- ICLR 2023 categories the papers as "Accept-notable-top-5", "Accept-notable-top-25", "Accept-poster", and "Reject" +""" +PAPER_DECISIONS = ["Reject","Accept-oral", "Accept-spotlight", "Accept-poster",] +PAPER_DECISIONS_ICLR2019 = ["Accept-oral", "Accept-poster", "Reject"] + +AREA_CHAIR_TYPES = ['inclusive', 'conformist', 'authoritarian', 'BASELINE'] + +# These are papers that contain potentially sensitive content. GPT-4 refused to generate reviews for these papers. +FILTERED_PAPER_IDS = { + "ICLR2020": [], + "ICLR2021": [], + "ICLR2022": [186, 200, 270], + "ICLR2023": [] +} + +ALL_REVIEW_PHASES = ["reviewer_write_reviews", "author_reviewer_discussion", "reviewer_ac_discussion", "ac_discussion"] + + +EXPERIMENT_NAME2REVIEWER_TYPES = { + "BASELINE": "BASELINE", + "knowledgeable_Rx1": "knowledgeable", + "unknowledgeable_Rx1": "unknowledgeable", + "irresponsible_Rx1": "irresponsible", + "irresponsible_Rx2": "irresponsible", + "irresponsible_Rx3": "irresponsible", + "responsible_Rx1": "responsible", + "malicious_Rx1": "malicious", + "malicious_Rx2": "malicious", + "malicious_Rx3": "malicious", + "benign_Rx1": "benign", + "inclusive_ACx1": "BASELINE", + "authoritarian_ACx1": "BASELINE", + "conformist_ACx1": "BASELINE", + "authors_are_famous_Rx1": "authors_are_famous", + "authors_are_famous_Rx2": "authors_are_famous", + "authors_are_famous_Rx3": "authors_are_famous", + "authors_are_famous_Rx1_no_rebuttal": "authors_are_famous", + "authors_are_famous_Rx2_no_rebuttal": "authors_are_famous", + "authors_are_famous_Rx3_no_rebuttal": "authors_are_famous", + "no_rebuttal": "BASELINE", + "no_overall_score": "BASELINE", +} + + +year2paper_ids = { + "ICLR2018": [45, 47, 59, 76, 229, 254, 372, 415, 447, 517, 543, 544, 562, 596, 615, 639] + + [1, 2, 7, 10, 16, 26, 33, 51, 60, 61, 65, + 67, 69, 72, 73, 77, 84, 88, 94, 99, 104, + 117, 121, 124, 131, 132, 134, 136, 143, 147, 148, 149, 155, 162, 164, 166, 168, 169, 171, + 175, 178, 179, 189, 196, 201, 203, 204, 205] + + [3, 4, 6, 8, 9, 11, 12, 13, 15, 17, 18, 19, 20, 21, 24, 25, 27, 28, 30, 31, 32, 34, 36, 37, 39, 40, + 41, 42, 43, 44, 46, 52, 53, 54, 55, 56, 58, 63, 66, 68, 71, 74, 75, 78, 80, 83, 85, 87, 89, + 91, 92, 93, 95, 96, 97, 100, 101, 102, 103, 105, 106, 107, 108, 109, 110, 111, 113, 114, 115, + 116, 118, 120, 122, 123, 125, 127, 128, 129, 133, 135, 138, 141, 142, 144, 153, 154, 156, 157, 158, + 159, 161, 163, 170, 172, 173, 174, 176, 177, 180, 181, 182, 184, 185, 186, 187, 190, 191, 193, 194, + 197, 200, 206, 207, 209, 211, 213, 214, 218, 219, 221, 222, 223, 225, 226, 230, 234, 237, 238, 241, + 243, 244, 247, 248, 253, 255, 256, 257, 258, 259, 266, 268, 271, 272, 273, 275, 276, 278, 283, + 286], + + + "ICLR2019": [1, 26, 119, 220, 231, 507, 563, 566, 574, 632, 654, 709, 734, 780, 835, 917] + [4, 27, 33, 39, 40, + 51, 57, 67, 70, 72, + 73, 76, 77, 82, 87, + 98, 99, 100, 106, + 108, 109, 110, 111, + 113, 114, 116, 123, + 129, 130, 143, 146, + 147, 150, 155, 177, + 184, 187, 190, 194, + 201, 202, 203, 205, + 211, 213, 222, 237, + 238] + [2, 3, 6, 8, + 9, 11, 12, + 13, 14, 15, + 16, 17, 18, + 19, 20, 21, + 22, 23, 24, + 28, 29, 32, + 35, 36, 37, + 38, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 52, 54, 55, 58, 59, 60, 61, 62, 63, 65, 66, 68, 69, 71, 74, 75, 78, 79, 80, 83, 84, 85, 86, 89, 90, 91, 92, 93, 94, 95, 96, 97, 101, 102, 104, 105, 107, 112, 115, 117, 118, 120, 122, 124, 125, 127, 128, 131, 132, 133, 134, 135, 136, 137, 139, 140, 141, 142, 144, 145, 148, 149, 152, 153, 154, 158, 160, 161, 162, 163, 164, 165, 167, 168, 171, 172, 173, 174, 178, 179, 180, 181, 182, 185, 186, 189, 191, 192, 193, 195, 196, 197, 198, 204, 206, 208, 209, 210, 214, 216, 217, 218, 221, 223, 224, 225, 226, 228, 229, 230, 233], + + + + "ICLR2020": [2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 19, 20, 21, 23, 27, 28, 31, 32, 33, 34, 35, 37, 38, + 41, 42, 43, 46, 48, 49, 52, 56, 58, 60, 62, 63, 66, 67, 68, 74, 75, 76, 79, 80, 82, 83, 84, 85, 86, + 87, 90, 94, 97, 101, 105, 106, 107, 109, 110, 111, 115, 116, 118, 119, 120, 121, 122, 123, 124, 126, + 1, 16, 18, 22, 24, 29, 40, 45, 50, 53, 55, 57, 61, 70, 73, 77, 91, 93, 95, 103, 108, 112, 113, 117, + 125, 132, 5, 44, 47, 54, 71, 88, 69, 78, 102, 221], + "ICLR2021": [140, 218, 294, 332, 362, 420, 1, 5, 12, 20, 28, 52, 67, 69, 75, 102, 103, 110, 126, 135, 138, 147, 149, 151, 160, 170, 174, 181, 182, 190, 44, 3, 4, 10, 11, 14, 17, 18, 21, 22, 24, 27, 33, 36, 38, 45, 47, 49, 59, 70, 72, 73, 78, 79, 82, 84, 86, 88, 89, 91, 92, 98, 100, 101, 104, 105, 106, 107, 108, 111, 114, 120, 123, 124, 125, 130, 131, 133, 137, 141, 142, 143, 154, 155, 156, 157, 159, 161, 162, 164, 166, 167, 168, 171, 172, 176, 193, 194, 81, 94, 95, 146, 177, 179, 184, 186], + "ICLR2022": [86, 154, 208, 222, 224, 284, 9, 10, 11, 12, 14, 25, 30, 31, 39, 42, 45, 56, 68, 73, 80, 88, 89, 90, 96, 101, 102, 104, 109, 1, 4, 6, 27, 36, 43, 47, 61, 62, 63, 65, 67, 69, 81, 82, 95, 98, 99, 100, 103, 105, 106, 108, 115, 120, 121, 122, 130, 134, 142, 143, 144, 145, 152, 153, 157, 159, 168, 173, 174, 175, 176, 179, 180, 186, 187, 193, 194, 197, 200, 201, 205, 210, 216, 226, 229, 233, 234, 235, 236, 239, 248, 261, 262, 263, 264, 269, 270, 271, 112, 113, 34, 64, 158, 172, 277, 280, 283, 286], + "ICLR2023": [210, 219, 1759, 1774, 9, 11, 12, 33, 54, 55, 61, 70, 79, 86, 88, 90, 97, 116, 128, 129, 143, 152, 160, 168, 174, 177, 181, 193, 1647, 1651, 1666, 1670, 1673, 1675, 1677, 1678, 1680, 1683, 1692, 1698, 1703, 1709, 1716, 1720, 1723, 1727, 1728, 1742, 1743, 1752, 1754, 1760, 113, 156, 214, 220, 317, 318, 1657, 1686, 1740, 1762, 1783, 1817, 2, 3, 6, 8, 17, 18, 24, 25, 29, 30, 45, 62, 77, 80, 82, 84, 89, 96, 104, 105, 107, 108, 118, 119, 120, 122, 130, 131, 133, 139, 141, 145, 146, 149, 150, 151, 153, 158, 161, 163, 164, 169, 175, 178, 179, 198, 200, 206, 207, 211, 212, 225, 226, 231, 235, 236, 237, 245, 246, 249, 252, 253, 255, 257, 258, 259, 264, 265, 266, 275, 1645, 1649, 1655, 1658, 1663, 1664, 1665, 1672, 1679, 1682, 1685, 1695, 1697, 1701, 1704, 1706, 1708, 1710, 1712, 1713, 1715, 1722, 1726, 1729, 1731, 1734, 1736, 1738, 1739, 1741, 1744, 1745, 1749, 1750, 1755, 1756, 1758, 1761, 1764, 1767, 1772, 1773, 1778, 1779, 1780, 1786, 1788, 1790, 1791, 1795, 1796, 1797, 1800, 1802, 1803, 1805, 1810, 1812, 1813, 1821, 1822, 1827, 1829, 1833, 1840, 1845, 1851, 1856], + "ICLR2024": [39, 247, 289, 400, 489, 742, 749] + [62, 78, 159, 161, 170, 192, 198, 215, 219, 335, 344, 386, 427, 432, 448, 451, 461, 472, 485, 536, 546, 559, 573, 577, 597] + [5, 9, 11, 19, 20, 30, 31, 32, 40, 49, 52, 53, 54, 56, 61, 66, 67, 73, 74, 77, 85, 87, 100, 104, 114, 116, 124, 130, 133, 138, 145, 151, 153, 156, 165, 166, 172, 181, 183, 187, 195, 204, 212, 221, 224, 230, 237, 243, 248, 257, 258, 259, 263, 272, 278, 287, 288, 291, 292, 298, 300, 302, 304, 306, 308, 318, 320, 321, 324, 325, 326, 327, 331, 332, 334, 336, 338, 340, 345, 349, 350, 356, 357, 358, 360] + [1, 2, 12, 14, 24, 26, 33, 35, 36, 41, 42, 44, 50, 51, 55, 57, 59, 70, 72, 75, 76, 81, 89, 90, 93, + 94, 97, 99, 101, 105, 110, 111, 112, 117, 119, 120, 125, 128, 129, 131, 134, 135, 140, 148, 150, 157, 158, 163, 167, 173, 175, 177, 182, 185, 186, 188, 189, 197, 202, 207, 209, 210, 214, 216, 226, 231, 234, 236, 238, 239, 241, 244, 245, 249, 260, 262, 264, 265, 271, 276, 277, 279, 281, 282, 284, 286, 290, 294, 295, 301, 303, 307, 309, 313, 315, 319, 322, 333, 337, 339, 342, 354, 363, 364, 369, 373, 374, 375, 377, 378, 381, 382, 385, 388, 398, 399, 401, 407, 412, 413, 415, 416, 417, 420, 421, 422, 426, 428, 436, 437, 444, 446, 449, 453, 454, 463, 464, 469, 478, 480, 487, 490, 496, 498, 501, 502, 504, 506, 513, 516, 517, 518, 520, 521, 523, 524, 525, 537, 541, 545, 551, 552, 554, 555, 558, 562, 563, 574, 575, 579, 581, 584, 588, 595, 596, 598, 607, 608, 615, 622, 624, 625, 627, 629, 630, 634, 636, 641, 645, 647, 648, 651, 652, 654, 655, 662, 667, 668, 671, 672, 673, 681, 682, 685, 689, 690, 691, 697, 698, 701] +} diff --git a/docs/devdoc/design.md b/docs/devdoc/design.md new file mode 100644 index 0000000000000000000000000000000000000000..6da0495b2cba57da020251a4986792673f8e0a64 --- /dev/null +++ b/docs/devdoc/design.md @@ -0,0 +1,39 @@ +# Key Design Choices +In this document, we will discuss the key concepts and design choices of ChatArena. +We expect this will be helpful particularly for developers who want to contribute to ChatArena or build their own environments. + +## Agent Environment Cycle +ChatArena in general follows the design principle of openAI gym [1] and pettingzoo [2]. Any agent will interact with the environment and other agents through the agent environment cycle. +For every single cycle, +1. the agent observes the environment +2. the agent output an action +3. the environment makes a state transition given the action + +As an optional feature, in each cycle, the environment can also compute a scalar reward for every single agent, along with a terminal signal for the environment. + +[1] Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, Wojciech Zaremba: OpenAI Gym. CoRR abs/1606.01540 (2016) + +[2] Justin K. Terry, Benjamin Black, Nathaniel Grammel, Mario Jayakumar, Ananth Hari, Ryan Sullivan, Luis S. Santos, Clemens Dieffendahl, Caroline Horsch, Rodrigo Perez-Vicente, Niall L. Williams, Yashas Lokesh, Praveen Ravi: PettingZoo: Gym for Multi-Agent Reinforcement Learning. NeurIPS 2021: 15032-15043 + +### Actions + +In the current version of ChatArena, all the actions are represented as plain text. More structured text outputs, like json or code, can be generated by prompting the LLM to do so. +We provide simple utilities to extract json and code (with markdown syntax), which should cover common use cases but can break for intentionally crafted edge cases. + +### Observations + +A observation is a list of messages with sender and content. Then sender can be any agent in the environment or the built-in moderator of the environment. The content is again plain text. + +## Message Pool and Visibility Control + +In ChatArena, agents cannot directly talk to each other but exchange information with a [message pool](https://github.com/chatarena/chatarena/blob/main/chatarena/message.py) as a proxy. The message pool is a utility abstraction that can serve as a part of the game state. + +When an agent takes an action, a message can be created and appended to the message pool. In the message pool, each message will have a receiver, which can be decided by the environment dynamics (game rules) or by the agent itself. The environment itself can also create messages under the name of the moderator which can provide other state information or extra instructions given the current state. + +To render an observation, the message pool will collect all the messages that are visible to the agent and return a list of these messages. + +In particular, some of the environments require parallel moves, say, rock-paper-scissors, where the agent shouldn’t see the moves of other agents in the same turn. Such a mechanism is also implemented in the message pool. One can specify the “current turn” or the message of the “current turns” and turns after will be ignored. + +## Intelligence Backends + +In ChatArena, each agent will usually be powered by a language backend. These backends can be LLM APIs (say, from [OpenAI](https://github.com/chatarena/chatarena/blob/main/chatarena/backends/openai.py), [Anthropic](https://github.com/chatarena/chatarena/blob/main/chatarena/backends/anthropic.py) or [Cohere](https://github.com/chatarena/chatarena/blob/main/chatarena/backends/cohere.py)), [local LLM](https://github.com/chatarena/chatarena/blob/main/chatarena/backends/hf_transformers.py) or just [humans](https://github.com/chatarena/chatarena/blob/main/chatarena/backends/human.py) behind a user interface. In [backends](https://github.com/chatarena/chatarena/tree/main/chatarena/backends), we render the observations (list of messages) into the required formats for the downstream models. And the returned text will be the agent’s action [by default](https://github.com/chatarena/chatarena/blob/55c9e6ee4e09d72905eceb0a0e09e93a4179ca39/chatarena/agent.py#L28). diff --git a/docs/devdoc/mainloop.md b/docs/devdoc/mainloop.md new file mode 100644 index 0000000000000000000000000000000000000000..354fa6346a15515ee466447a4823f596f0b0f68e --- /dev/null +++ b/docs/devdoc/mainloop.md @@ -0,0 +1,62 @@ +### Step 1: Define Multiple Players with LLM Backend + +```python +from agentreview.agent import Player +from agentreview.backends import OpenAIChat + +# Describe the environment (which is shared by all players) +environment_description = "It is in a university classroom ..." + +# A "Professor" player +player1 = Player(name="Professor", backend=OpenAIChat(), + role_desc="You are a professor in ...", + global_prompt=environment_description) +# A "Student" player +player2 = Player(name="Student", backend=OpenAIChat(), + role_desc="You are a student who is interested in ...", + global_prompt=environment_description) +# A "Teaching Assistant" player +player3 = Player(name="Teaching assistant", backend=OpenAIChat(), + role_desc="You are a teaching assistant of the module ...", + global_prompt=environment_description) +``` + +### Step 2: Create a Language Game Environment + +You can also create a language model-driven environment and add it to the ChatArena: + +```python +from agentreview.environments.conversation import Conversation + +env = Conversation(player_names=[p.name for p in [player1, player2, player3]]) +``` + +### Step 3: Run the Language Game using Arena + +`Arena` is a utility class to help you run language games: + +```python +from agentreview.arena import Arena + +arena = Arena(players=[player1, player2, player3], + environment=env, global_prompt=environment_description) +# Run the game for 10 steps +arena.run(num_steps=10) + +# Alternatively, you can run your own main loop +for _ in range(10): + arena.step() + # Your code goes here ... +``` + +You can easily save your gameplay history to file: + +```python +arena.save_history(path=...) +``` + +and save your game config to file: + +```python +arena.save_config(path=...) +``` diff --git a/docs/devdoc/moderated.md b/docs/devdoc/moderated.md new file mode 100644 index 0000000000000000000000000000000000000000..6b3d99c4dcf718d899bae22d4b2a205e15ec5dec --- /dev/null +++ b/docs/devdoc/moderated.md @@ -0,0 +1,16 @@ +### `ModeratedConversation`: a LLM-driven Environment + +We support a more advanced environment called `ModeratedConversation` that allows you to **control the game dynamics +using an LLM**. +The moderator is a special player that controls the game state transition and determines when the game ends. +For example, you can define a moderator that tracks the board status of a board game and ends the game when a player +wins. +You can try out our Tic-tac-toe and Rock-paper-scissors games to get a sense of how it works: + +```python +# Tic-tac-toe example +Arena.from_config("examples/tic-tac-toe.json").launch_cli() + +# Rock-paper-scissors example +Arena.from_config("examples/rock-paper-scissors.json").launch_cli() +``` diff --git a/docs/tutorials/create_your_environment.md b/docs/tutorials/create_your_environment.md new file mode 100644 index 0000000000000000000000000000000000000000..c58a768ea8ec5b27a3c66f53c1b14d27bf896b43 --- /dev/null +++ b/docs/tutorials/create_your_environment.md @@ -0,0 +1,90 @@ +# How to create your custom environments + +As an example to demonstrate how to develop your own environment, we develop a language +game based on [The Chameleon](https://bigpotato.co.uk/blogs/blog/how-to-play-the-chameleon-instructions). +The example code is available [here](../../agentreview/environments/chameleon.py). + +**Here are the detailed steps to develop a custom environment class** + +1. **Define the class**: Start by defining the class and inherit from a suitable base class (e.g., `Environment`). In + this case, the custom class `Chameleon` inherits from the `Environment` base class. + +```python +class Chameleon(Environment): + type_name = "chameleon" +``` + +The `type_name` is required and it is used by the [`ENV_REGISTRY`](chatarena/environments/__init__.py#L13) to identify +the class when loading the class +from a config file. + +Make sure you add the class to [`ALL_ENVIRONMENTS`](chatarena/environments/__init__.py#L17) +in `environments/__init__.py` so that it can be detected. + +2. **Initialize the class**: Define the `__init__` method to initialize the class attributes, such as player names, game + state, and any other necessary variables. + +```python +def __init__(self, player_names: List[str], topic_codes: Dict[str, List[str]] = None, **kwargs): + super().__init__(player_names=player_names, ..., **kwargs) + ... + + # The "state" of the environment is maintained by the message pool + self.message_pool = MessagePool() + ... +``` + +3. **Implement game mechanics**: Write methods that define the game mechanics, such as giving clues, voting, and + guessing the secret word. In the `Chameleon` class, these mechanics are implemented in the `step` method. + +```python +def step(self, player_name: str, action: str) -> TimeStep: + ... +``` + +4. **Handle game states and rewards**: Implement methods to manage game states, such as resetting the environment, + getting + observations, checking if the game has reached a terminal state, and giving rewards to players. + +```python +def reset(self): + ... + + +def get_observation(self, player_name=None) -> List[Message]: + ... + + +def is_terminal(self) -> bool: + ... + + +def get_rewards(self, ...) -> Dict[str, float]: + ... +``` + +5. **Develop your role description prompts for the players**: Now that you have defined the game mechanics, you can + develop the role description prompts for the players. These prompts are used to guide the LLM-powered players to play + the game + correctly. You can use the CLI for this purpose. For example, you can run the following code to launch the CLI: + +```python +alice = Player(name="Alice", backend=OpenAIChat(), role_desc="Write your prompt here") +bob = Player(name="Bob", backend=OpenAIChat(), role_desc="Write your prompt here") +env = Chameleon(player_names=["Alice", "Bob"], topic_codes=...) +arena = Arena(players=[alice, bob], environment=env).launch_cli() +``` + +Once you are happy with you prompts, you can save them to a config file for future use or sharing. + +```python +arena.save_config(path=...) +``` + +Another option is using the Web UI. You can run the following code to launch the Web UI: + +```bash +gradio app.py +``` + +and select your custom environment from the dropdown menu. diff --git a/notebooks/barplot_similarity_between_review_metareview.ipynb b/notebooks/barplot_similarity_between_review_metareview.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..c241bd8f4195fb194f7a43654b5ab02353cd1157 --- /dev/null +++ b/notebooks/barplot_similarity_between_review_metareview.ipynb @@ -0,0 +1 @@ +{"cells":[{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718474281050,"execution_millis":50251,"deepnote_to_be_reexecuted":false,"cell_id":"1dc6c0b12037447faaba03aed42ea4ad","deepnote_cell_type":"code"},"source":"!sudo apt-get update -y\n!sudo apt-get install dvipng texlive-latex-extra texlive-fonts-recommended cm-super -y\n!pip install SciencePlots","block_group":"4a3c63019dc04ce1864734bde1d872cc","execution_count":null,"outputs":[{"name":"stdout","text":"Get:1 http://deb.debian.org/debian buster InRelease [122 kB]\nGet:2 http://deb.debian.org/debian-security buster/updates InRelease [34.8 kB]\nGet:3 http://deb.debian.org/debian buster-updates InRelease [56.6 kB]\nGet:4 http://deb.debian.org/debian buster/main amd64 Packages [7,909 kB]\nGet:5 http://deb.debian.org/debian-security buster/updates/main amd64 Packages [603 kB]\nGet:6 http://deb.debian.org/debian buster-updates/main amd64 Packages [8,788 B]\nFetched 8,734 kB in 3s (3,464 kB/s)\n\n\n\n\nThe following additional packages will be installed:\n cm-super-minimal fonts-droid-fallback fonts-lato fonts-lmodern\n fonts-noto-mono fonts-texgyre ghostscript gsfonts javascript-common\n libauthen-sasl-perl libbrotli1 libcups2 libcupsfilters1 libcupsimage2\n libdata-dump-perl libdrm-amdgpu1 libdrm-common libdrm-intel1 libdrm-nouveau2\n libdrm-radeon1 libdrm2 libencode-locale-perl libfile-basedir-perl\n libfile-desktopentry-perl libfile-listing-perl libfile-mimeinfo-perl\n libfont-afm-perl libfontenc1 libgl1 libgl1-mesa-dri libglapi-mesa libglvnd0\n libglx-mesa0 libglx0 libgs9 libgs9-common libhtml-form-perl\n libhtml-format-perl libhtml-parser-perl libhtml-tagset-perl\n libhtml-tree-perl libhttp-cookies-perl libhttp-daemon-perl libhttp-date-perl\n libhttp-message-perl libhttp-negotiate-perl libidn11 libijs-0.35\n libio-html-perl libio-socket-ssl-perl libio-stringy-perl\n libipc-system-simple-perl libjbig2dec0 libjs-jquery libkpathsea6 liblcms2-2\n libllvm7 liblwp-mediatypes-perl liblwp-protocol-https-perl libmailtools-perl\n libnet-dbus-perl libnet-http-perl libnet-smtp-ssl-perl libnet-ssleay-perl\n libopenjp2-7 libpaper-utils libpaper1 libpciaccess0 libpotrace0 libptexenc1\n libpython-stdlib libpython2-stdlib libpython2.7-minimal libpython2.7-stdlib\n libruby2.5 libsensors-config libsensors5 libsynctex2 libtcl8.6 libteckit0\n libtexlua52 libtexlua53 libtexluajit2 libtext-iconv-perl libtie-ixhash-perl\n libtimedate-perl libtk8.6 libtry-tiny-perl liburi-perl libutempter0 libwoff1\n libwww-perl libwww-robotrules-perl libx11-protocol-perl libx11-xcb1\n libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-shape0\n libxcb-sync1 libxml-parser-perl libxml-twig-perl libxml-xpathengine-perl\n libxmuu1 libxshmfence1 libxss1 libxtst6 libxv1 libxxf86dga1 libxxf86vm1\n libxxhash0 libyaml-0-2 libzzip-0-13 lmodern perl-openssl-defaults\n pfb2t1c2pfb poppler-data preview-latex-style python python-minimal python2\n python2-minimal python2.7 python2.7-minimal rake ruby ruby-did-you-mean\n ruby-minitest ruby-net-telnet ruby-power-assert ruby-test-unit ruby-xmlrpc\n ruby2.5 rubygems-integration t1utils tcl tcl8.6 tex-common tex-gyre\n texlive-base texlive-binaries texlive-latex-base texlive-latex-recommended\n texlive-pictures texlive-plain-generic tipa tk tk8.6 x11-utils\n x11-xserver-utils xbitmaps xdg-utils xfonts-encodings xfonts-utils xterm zip\nSuggested packages:\n fonts-noto ghostscript-x apache2 | lighttpd | httpd libdigest-hmac-perl\n libgssapi-perl cups-common liblcms2-utils libcrypt-ssleay-perl pciutils\n lm-sensors libauthen-ntlm-perl libunicode-map8-perl libunicode-string-perl\n xml-twig-tools poppler-utils fonts-japanese-mincho | fonts-ipafont-mincho\n fonts-japanese-gothic | fonts-ipafont-gothic fonts-arphic-ukai\n fonts-arphic-uming fonts-nanum python-doc python-tk python2-doc\n python2.7-doc binfmt-support ri ruby-dev bundler tcl-tclreadline debhelper\n perl-tk xpdf-reader | pdf-viewer texlive-fonts-recommended-doc\n texlive-latex-base-doc python-pygments icc-profiles libfile-which-perl\n libspreadsheet-parseexcel-perl texlive-latex-extra-doc\n texlive-latex-recommended-doc texlive-pstricks dot2tex prerex ruby-tcltk\n | libtcltk-ruby texlive-pictures-doc vprerex mesa-utils nickle cairo-5c\n xorg-docs-core xfonts-cyrillic\nThe following NEW packages will be installed:\n cm-super cm-super-minimal dvipng fonts-droid-fallback fonts-lato\n fonts-lmodern fonts-noto-mono fonts-texgyre ghostscript gsfonts\n javascript-common libauthen-sasl-perl libbrotli1 libcupsfilters1\n libcupsimage2 libdata-dump-perl libdrm-amdgpu1 libdrm-common libdrm-intel1\n libdrm-nouveau2 libdrm-radeon1 libdrm2 libencode-locale-perl\n libfile-basedir-perl libfile-desktopentry-perl libfile-listing-perl\n libfile-mimeinfo-perl libfont-afm-perl libfontenc1 libgl1 libgl1-mesa-dri\n libglapi-mesa libglvnd0 libglx-mesa0 libglx0 libgs9 libgs9-common\n libhtml-form-perl libhtml-format-perl libhtml-parser-perl\n libhtml-tagset-perl libhtml-tree-perl libhttp-cookies-perl\n libhttp-daemon-perl libhttp-date-perl libhttp-message-perl\n libhttp-negotiate-perl libidn11 libijs-0.35 libio-html-perl\n libio-socket-ssl-perl libio-stringy-perl libipc-system-simple-perl\n libjbig2dec0 libjs-jquery libkpathsea6 liblcms2-2 libllvm7\n liblwp-mediatypes-perl liblwp-protocol-https-perl libmailtools-perl\n libnet-dbus-perl libnet-http-perl libnet-smtp-ssl-perl libnet-ssleay-perl\n libopenjp2-7 libpaper-utils libpaper1 libpciaccess0 libpotrace0 libptexenc1\n libpython-stdlib libpython2-stdlib libpython2.7-minimal libpython2.7-stdlib\n libruby2.5 libsensors-config libsensors5 libsynctex2 libtcl8.6 libteckit0\n libtexlua52 libtexlua53 libtexluajit2 libtext-iconv-perl libtie-ixhash-perl\n libtimedate-perl libtk8.6 libtry-tiny-perl liburi-perl libutempter0 libwoff1\n libwww-perl libwww-robotrules-perl libx11-protocol-perl libx11-xcb1\n libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-shape0\n libxcb-sync1 libxml-parser-perl libxml-twig-perl libxml-xpathengine-perl\n libxmuu1 libxshmfence1 libxss1 libxtst6 libxv1 libxxf86dga1 libxxf86vm1\n libxxhash0 libyaml-0-2 libzzip-0-13 lmodern perl-openssl-defaults\n pfb2t1c2pfb poppler-data preview-latex-style python python-minimal python2\n python2-minimal python2.7 python2.7-minimal rake ruby ruby-did-you-mean\n ruby-minitest ruby-net-telnet ruby-power-assert ruby-test-unit ruby-xmlrpc\n ruby2.5 rubygems-integration t1utils tcl tcl8.6 tex-common tex-gyre\n texlive-base texlive-binaries texlive-fonts-recommended texlive-latex-base\n texlive-latex-extra texlive-latex-recommended texlive-pictures\n texlive-plain-generic tipa tk tk8.6 x11-utils x11-xserver-utils xbitmaps\n xdg-utils xfonts-encodings xfonts-utils xterm zip\nThe following packages will be upgraded:\n libcups2\n1 upgraded, 160 newly installed, 0 to remove and 39 not upgraded.\nNeed to get 212 MB of archives.\nAfter this operation, 798 MB of additional disk space will be used.\nGet:1 http://deb.debian.org/debian-security buster/updates/main amd64 libpython2.7-minimal amd64 2.7.16-2+deb10u4 [396 kB]\nGet:2 http://deb.debian.org/debian-security buster/updates/main amd64 python2.7-minimal amd64 2.7.16-2+deb10u4 [1,367 kB]\nGet:3 http://deb.debian.org/debian buster/main amd64 python2-minimal amd64 2.7.16-1 [41.4 kB]\nGet:4 http://deb.debian.org/debian buster/main amd64 python-minimal amd64 2.7.16-1 [21.0 kB]\nGet:5 http://deb.debian.org/debian-security buster/updates/main amd64 libpython2.7-stdlib amd64 2.7.16-2+deb10u4 [1,912 kB]\nGet:6 http://deb.debian.org/debian-security buster/updates/main amd64 python2.7 amd64 2.7.16-2+deb10u4 [306 kB]\nGet:7 http://deb.debian.org/debian buster/main amd64 libpython2-stdlib amd64 2.7.16-1 [20.8 kB]\nGet:8 http://deb.debian.org/debian buster/main amd64 libpython-stdlib amd64 2.7.16-1 [20.8 kB]\nGet:9 http://deb.debian.org/debian buster/main amd64 python2 amd64 2.7.16-1 [41.6 kB]\nGet:10 http://deb.debian.org/debian buster/main amd64 python amd64 2.7.16-1 [22.8 kB]\nGet:11 http://deb.debian.org/debian buster/main amd64 fonts-droid-fallback all 1:6.0.1r16-1.1 [1,807 kB]\nGet:12 http://deb.debian.org/debian buster/main amd64 fonts-lato all 2.0-2 [2,698 kB]\nGet:13 http://deb.debian.org/debian buster/main amd64 poppler-data all 0.4.9-2 [1,473 kB]\nGet:14 http://deb.debian.org/debian buster/main amd64 tex-common all 6.11 [53.1 kB]\nGet:15 http://deb.debian.org/debian buster/main amd64 libpaper1 amd64 1.1.28 [21.3 kB]\nGet:16 http://deb.debian.org/debian buster/main amd64 libpaper-utils amd64 1.1.28 [18.0 kB]\nGet:17 http://deb.debian.org/debian-security buster/updates/main amd64 libkpathsea6 amd64 2018.20181218.49446-1+deb10u2 [168 kB]\nGet:18 http://deb.debian.org/debian-security buster/updates/main amd64 libptexenc1 amd64 2018.20181218.49446-1+deb10u2 [61.5 kB]\nGet:19 http://deb.debian.org/debian-security buster/updates/main amd64 libsynctex2 amd64 2018.20181218.49446-1+deb10u2 [80.9 kB]\nGet:20 http://deb.debian.org/debian-security buster/updates/main amd64 libtexlua52 amd64 2018.20181218.49446-1+deb10u2 [113 kB]\nGet:21 http://deb.debian.org/debian-security buster/updates/main amd64 libtexlua53 amd64 2018.20181218.49446-1+deb10u2 [126 kB]\nGet:22 http://deb.debian.org/debian-security buster/updates/main amd64 libtexluajit2 amd64 2018.20181218.49446-1+deb10u2 [257 kB]\nGet:23 http://deb.debian.org/debian buster/main amd64 t1utils amd64 1.41-3 [62.3 kB]\nGet:24 http://deb.debian.org/debian buster/main amd64 libbrotli1 amd64 1.0.7-2+deb10u1 [269 kB]\nGet:25 http://deb.debian.org/debian-security buster/updates/main amd64 libgs9-common all 9.27~dfsg-2+deb10u9 [5,137 kB]\nGet:26 http://deb.debian.org/debian-security buster/updates/main amd64 libcups2 amd64 2.2.10-6+deb10u10 [325 kB]\nGet:27 http://deb.debian.org/debian-security buster/updates/main amd64 libcupsimage2 amd64 2.2.10-6+deb10u10 [134 kB]\nGet:28 http://deb.debian.org/debian buster/main amd64 libidn11 amd64 1.33-2.2 [116 kB]\nGet:29 http://deb.debian.org/debian buster/main amd64 libijs-0.35 amd64 0.35-14 [18.3 kB]\nGet:30 http://deb.debian.org/debian buster/main amd64 libjbig2dec0 amd64 0.16-1+deb10u1 [62.2 kB]\nGet:31 http://deb.debian.org/debian buster/main amd64 liblcms2-2 amd64 2.9-3 [145 kB]\nGet:32 http://deb.debian.org/debian buster/main amd64 libopenjp2-7 amd64 2.3.0-2+deb10u2 [158 kB]\nGet:33 http://deb.debian.org/debian-security buster/updates/main amd64 libgs9 amd64 9.27~dfsg-2+deb10u9 [2,199 kB]\nGet:34 http://deb.debian.org/debian buster/main amd64 libpotrace0 amd64 1.15-1 [26.3 kB]\nGet:35 http://deb.debian.org/debian buster/main amd64 libteckit0 amd64 2.5.8+ds2-5 [318 kB]\nGet:36 http://deb.debian.org/debian buster/main amd64 libwoff1 amd64 1.0.2-1 [43.2 kB]\nGet:37 http://deb.debian.org/debian buster/main amd64 libxxhash0 amd64 0.6.5-2 [7,156 B]\nGet:38 http://deb.debian.org/debian buster/main amd64 libzzip-0-13 amd64 0.13.62-3.2+deb10u1 [55.6 kB]\nGet:39 http://deb.debian.org/debian-security buster/updates/main amd64 texlive-binaries amd64 2018.20181218.49446-1+deb10u2 [11.3 MB]\nGet:40 http://deb.debian.org/debian buster/main amd64 xdg-utils all 1.1.3-1+deb10u1 [73.7 kB]\nGet:41 http://deb.debian.org/debian buster/main amd64 texlive-base all 2018.20190227-2 [19.7 MB]\nGet:42 http://deb.debian.org/debian buster/main amd64 fonts-lmodern all 2.004.5-6 [4,539 kB]\nGet:43 http://deb.debian.org/debian buster/main amd64 texlive-latex-base all 2018.20190227-2 [984 kB]\nGet:44 http://deb.debian.org/debian buster/main amd64 texlive-latex-recommended all 2018.20190227-2 [15.2 MB]\nGet:45 http://deb.debian.org/debian buster/main amd64 cm-super-minimal all 0.3.4-14 [5,814 kB]\nGet:46 http://deb.debian.org/debian buster/main amd64 pfb2t1c2pfb amd64 0.3-11 [10.0 kB]\nGet:47 http://deb.debian.org/debian buster/main amd64 cm-super all 0.3.4-14 [18.7 MB]\nGet:48 http://deb.debian.org/debian-security buster/updates/main amd64 ghostscript amd64 9.27~dfsg-2+deb10u9 [95.5 kB]\nGet:49 http://deb.debian.org/debian buster/main amd64 dvipng amd64 1.15-1.1 [87.8 kB]\nGet:50 http://deb.debian.org/debian buster/main amd64 fonts-noto-mono all 20181227-1 [83.1 kB]\nGet:51 http://deb.debian.org/debian buster/main amd64 fonts-texgyre all 20180621-3 [10.2 MB]\nGet:52 http://deb.debian.org/debian buster/main amd64 gsfonts all 1:8.11+urwcyr1.0.7~pre44-4.4 [3,125 kB]\nGet:53 http://deb.debian.org/debian buster/main amd64 javascript-common all 11 [6,120 B]\nGet:54 http://deb.debian.org/debian buster/main amd64 libauthen-sasl-perl all 2.1600-1 [50.8 kB]\nGet:55 http://deb.debian.org/debian-security buster/updates/main amd64 libcupsfilters1 amd64 1.21.6-5+deb10u1 [172 kB]\nGet:56 http://deb.debian.org/debian buster/main amd64 libdata-dump-perl all 1.23-1 [29.5 kB]\nGet:57 http://deb.debian.org/debian buster/main amd64 libdrm-common all 2.4.97-1 [13.8 kB]\nGet:58 http://deb.debian.org/debian buster/main amd64 libdrm2 amd64 2.4.97-1 [39.7 kB]\nGet:59 http://deb.debian.org/debian buster/main amd64 libdrm-amdgpu1 amd64 2.4.97-1 [27.3 kB]\nGet:60 http://deb.debian.org/debian buster/main amd64 libpciaccess0 amd64 0.14-1 [53.5 kB]\nGet:61 http://deb.debian.org/debian buster/main amd64 libdrm-intel1 amd64 2.4.97-1 [69.8 kB]\nGet:62 http://deb.debian.org/debian buster/main amd64 libdrm-nouveau2 amd64 2.4.97-1 [26.3 kB]\nGet:63 http://deb.debian.org/debian buster/main amd64 libdrm-radeon1 amd64 2.4.97-1 [31.1 kB]\nGet:64 http://deb.debian.org/debian buster/main amd64 libencode-locale-perl all 1.05-1 [13.7 kB]\nGet:65 http://deb.debian.org/debian buster/main amd64 libipc-system-simple-perl all 1.25-4 [26.5 kB]\nGet:66 http://deb.debian.org/debian buster/main amd64 libfile-basedir-perl all 0.08-1 [17.7 kB]\nGet:67 http://deb.debian.org/debian buster/main amd64 liburi-perl all 1.76-1 [89.9 kB]\nGet:68 http://deb.debian.org/debian buster/main amd64 libfile-desktopentry-perl all 0.22-1 [19.2 kB]\nGet:69 http://deb.debian.org/debian buster/main amd64 libtimedate-perl all 2.3000-2+deb10u1 [38.1 kB]\nGet:70 http://deb.debian.org/debian buster/main amd64 libhttp-date-perl all 6.02-1 [10.7 kB]\nGet:71 http://deb.debian.org/debian buster/main amd64 libfile-listing-perl all 6.04-1 [10.3 kB]\nGet:72 http://deb.debian.org/debian buster/main amd64 libfile-mimeinfo-perl all 0.29-1 [46.5 kB]\nGet:73 http://deb.debian.org/debian buster/main amd64 libfont-afm-perl all 1.20-2 [13.6 kB]\nGet:74 http://deb.debian.org/debian buster/main amd64 libfontenc1 amd64 1:1.1.3-1+b2 [24.4 kB]\nGet:75 http://deb.debian.org/debian buster/main amd64 libglapi-mesa amd64 18.3.6-2+deb10u1 [66.3 kB]\nGet:76 http://deb.debian.org/debian buster/main amd64 libllvm7 amd64 1:7.0.1-8+deb10u2 [13.1 MB]\nGet:77 http://deb.debian.org/debian buster/main amd64 libsensors-config all 1:3.5.0-3 [31.6 kB]\nGet:78 http://deb.debian.org/debian buster/main amd64 libsensors5 amd64 1:3.5.0-3 [52.6 kB]\nGet:79 http://deb.debian.org/debian buster/main amd64 libgl1-mesa-dri amd64 18.3.6-2+deb10u1 [6,685 kB]\nGet:80 http://deb.debian.org/debian buster/main amd64 libglvnd0 amd64 1.1.0-1 [48.6 kB]\nGet:81 http://deb.debian.org/debian-security buster/updates/main amd64 libx11-xcb1 amd64 2:1.6.7-1+deb10u4 [191 kB]\nGet:82 http://deb.debian.org/debian buster/main amd64 libxcb-dri2-0 amd64 1.13.1-2 [101 kB]\nGet:83 http://deb.debian.org/debian buster/main amd64 libxcb-dri3-0 amd64 1.13.1-2 [100 kB]\nGet:84 http://deb.debian.org/debian buster/main amd64 libxcb-glx0 amd64 1.13.1-2 [116 kB]\nGet:85 http://deb.debian.org/debian buster/main amd64 libxcb-present0 amd64 1.13.1-2 [99.1 kB]\nGet:86 http://deb.debian.org/debian buster/main amd64 libxcb-sync1 amd64 1.13.1-2 [103 kB]\nGet:87 http://deb.debian.org/debian buster/main amd64 libxshmfence1 amd64 1.3-1 [8,820 B]\nGet:88 http://deb.debian.org/debian buster/main amd64 libxxf86vm1 amd64 1:1.1.4-1+b2 [20.8 kB]\nGet:89 http://deb.debian.org/debian buster/main amd64 libglx-mesa0 amd64 18.3.6-2+deb10u1 [180 kB]\nGet:90 http://deb.debian.org/debian buster/main amd64 libhtml-tagset-perl all 3.20-3 [12.7 kB]\nGet:91 http://deb.debian.org/debian buster/main amd64 libhtml-parser-perl amd64 3.72-3+b3 [105 kB]\nGet:92 http://deb.debian.org/debian buster/main amd64 libio-html-perl all 1.001-1 [17.6 kB]\nGet:93 http://deb.debian.org/debian buster/main amd64 liblwp-mediatypes-perl all 6.02-1 [22.1 kB]\nGet:94 http://deb.debian.org/debian buster/main amd64 libhttp-message-perl all 6.18-1 [77.8 kB]\nGet:95 http://deb.debian.org/debian buster/main amd64 libhtml-form-perl all 6.03-1 [23.9 kB]\nGet:96 http://deb.debian.org/debian buster/main amd64 libhtml-tree-perl all 5.07-2 [213 kB]\nGet:97 http://deb.debian.org/debian buster/main amd64 libhtml-format-perl all 2.12-1 [43.5 kB]\nGet:98 http://deb.debian.org/debian buster/main amd64 libhttp-cookies-perl all 6.04-1 [17.8 kB]\nGet:99 http://deb.debian.org/debian-security buster/updates/main amd64 libhttp-daemon-perl all 6.01-3+deb10u1 [17.1 kB]\nGet:100 http://deb.debian.org/debian buster/main amd64 libhttp-negotiate-perl all 6.01-1 [12.8 kB]\nGet:101 http://deb.debian.org/debian buster/main amd64 perl-openssl-defaults amd64 3 [6,782 B]\nGet:102 http://deb.debian.org/debian buster/main amd64 libnet-ssleay-perl amd64 1.85-2+deb10u1 [308 kB]\nGet:103 http://deb.debian.org/debian buster/main amd64 libio-socket-ssl-perl all 2.060-3 [207 kB]\nGet:104 http://deb.debian.org/debian buster/main amd64 libio-stringy-perl all 2.111-3 [56.5 kB]\nGet:105 http://deb.debian.org/debian buster/main amd64 libjs-jquery all 3.3.1~dfsg-3+deb10u1 [332 kB]\nGet:106 http://deb.debian.org/debian buster/main amd64 libnet-http-perl all 6.18-1 [24.5 kB]\nGet:107 http://deb.debian.org/debian buster/main amd64 libtry-tiny-perl all 0.30-1 [23.3 kB]\nGet:108 http://deb.debian.org/debian buster/main amd64 libwww-robotrules-perl all 6.02-1 [12.9 kB]\nGet:109 http://deb.debian.org/debian buster/main amd64 libwww-perl all 6.36-2 [188 kB]\nGet:110 http://deb.debian.org/debian buster/main amd64 liblwp-protocol-https-perl all 6.07-2 [9,242 B]\nGet:111 http://deb.debian.org/debian buster/main amd64 libnet-smtp-ssl-perl all 1.04-1 [6,184 B]\nGet:112 http://deb.debian.org/debian buster/main amd64 libmailtools-perl all 2.18-1 [88.5 kB]\nGet:113 http://deb.debian.org/debian buster/main amd64 libxml-parser-perl amd64 2.44-4 [213 kB]\nGet:114 http://deb.debian.org/debian buster/main amd64 libxml-twig-perl all 1:3.50-1.1 [179 kB]\nGet:115 http://deb.debian.org/debian buster/main amd64 libnet-dbus-perl amd64 1.1.0-5+b1 [181 kB]\nGet:116 http://deb.debian.org/debian buster/main amd64 rubygems-integration all 1.11+deb10u1 [5,212 B]\nGet:117 http://deb.debian.org/debian-security buster/updates/main amd64 ruby2.5 amd64 2.5.5-3+deb10u6 [401 kB]\nGet:118 http://deb.debian.org/debian buster/main amd64 ruby amd64 1:2.5.1 [11.3 kB]\nGet:119 http://deb.debian.org/debian buster/main amd64 rake all 12.3.1-3+deb10u1 [67.1 kB]\nGet:120 http://deb.debian.org/debian buster/main amd64 ruby-did-you-mean all 1.2.1-1 [14.4 kB]\nGet:121 http://deb.debian.org/debian buster/main amd64 ruby-minitest all 5.11.3-1 [54.8 kB]\nGet:122 http://deb.debian.org/debian buster/main amd64 ruby-net-telnet all 0.1.1-2 [12.5 kB]\nGet:123 http://deb.debian.org/debian buster/main amd64 ruby-power-assert all 1.1.1-1 [10.9 kB]\nGet:124 http://deb.debian.org/debian buster/main amd64 ruby-test-unit all 3.2.8-1 [72.4 kB]\nGet:125 http://deb.debian.org/debian buster/main amd64 ruby-xmlrpc all 0.3.0-2 [23.7 kB]\nGet:126 http://deb.debian.org/debian buster/main amd64 libyaml-0-2 amd64 0.2.1-1 [47.2 kB]\nGet:127 http://deb.debian.org/debian-security buster/updates/main amd64 libruby2.5 amd64 2.5.5-3+deb10u6 [3,442 kB]\nGet:128 http://deb.debian.org/debian buster/main amd64 libtcl8.6 amd64 8.6.9+dfsg-2 [1,005 kB]\nGet:129 http://deb.debian.org/debian buster/main amd64 libtext-iconv-perl amd64 1.7-5+b7 [15.4 kB]\nGet:130 http://deb.debian.org/debian buster/main amd64 libtie-ixhash-perl all 1.23-2 [11.7 kB]\nGet:131 http://deb.debian.org/debian buster/main amd64 libxss1 amd64 1:1.2.3-1 [17.8 kB]\nGet:132 http://deb.debian.org/debian buster/main amd64 libtk8.6 amd64 8.6.9-2 [768 kB]\nGet:133 http://deb.debian.org/debian buster/main amd64 libutempter0 amd64 1.1.6-3 [7,812 B]\nGet:134 http://deb.debian.org/debian buster/main amd64 libx11-protocol-perl all 0.56-7 [150 kB]\nGet:135 http://deb.debian.org/debian buster/main amd64 libxcb-shape0 amd64 1.13.1-2 [99.5 kB]\nGet:136 http://deb.debian.org/debian buster/main amd64 libxml-xpathengine-perl all 0.14-1 [33.3 kB]\nGet:137 http://deb.debian.org/debian buster/main amd64 libxmuu1 amd64 2:1.1.2-2+b3 [23.9 kB]\nGet:138 http://deb.debian.org/debian buster/main amd64 libxtst6 amd64 2:1.2.3-1 [27.8 kB]\nGet:139 http://deb.debian.org/debian buster/main amd64 libxv1 amd64 2:1.0.11-1 [24.6 kB]\nGet:140 http://deb.debian.org/debian buster/main amd64 libxxf86dga1 amd64 2:1.1.4-1+b3 [22.1 kB]\nGet:141 http://deb.debian.org/debian buster/main amd64 xfonts-encodings all 1:1.0.4-2 [574 kB]\nGet:142 http://deb.debian.org/debian buster/main amd64 xfonts-utils amd64 1:7.7+6 [93.0 kB]\nGet:143 http://deb.debian.org/debian buster/main amd64 lmodern all 2.004.5-6 [9,488 kB]\nGet:144 http://deb.debian.org/debian buster/main amd64 preview-latex-style all 11.91-2 [201 kB]\nGet:145 http://deb.debian.org/debian buster/main amd64 tcl8.6 amd64 8.6.9+dfsg-2 [123 kB]\nGet:146 http://deb.debian.org/debian buster/main amd64 tcl amd64 8.6.9+1 [5,636 B]\nGet:147 http://deb.debian.org/debian buster/main amd64 tex-gyre all 20180621-3 [6,210 kB]\nGet:148 http://deb.debian.org/debian buster/main amd64 texlive-fonts-recommended all 2018.20190227-2 [5,228 kB]\nGet:149 http://deb.debian.org/debian buster/main amd64 texlive-pictures all 2018.20190227-2 [8,201 kB]\nGet:150 http://deb.debian.org/debian buster/main amd64 texlive-latex-extra all 2018.20190227-2 [12.3 MB]\nGet:151 http://deb.debian.org/debian buster/main amd64 texlive-plain-generic all 2018.20190227-2 [24.3 MB]\nGet:152 http://deb.debian.org/debian buster/main amd64 tipa all 2:1.3-20 [2,972 kB]\nGet:153 http://deb.debian.org/debian buster/main amd64 tk8.6 amd64 8.6.9-2 [72.1 kB]\nGet:154 http://deb.debian.org/debian buster/main amd64 tk amd64 8.6.9+1 [5,676 B]\nGet:155 http://deb.debian.org/debian buster/main amd64 libglx0 amd64 1.1.0-1 [30.0 kB]\nGet:156 http://deb.debian.org/debian buster/main amd64 libgl1 amd64 1.1.0-1 [91.1 kB]\nGet:157 http://deb.debian.org/debian buster/main amd64 x11-utils amd64 7.7+4 [202 kB]\nGet:158 http://deb.debian.org/debian buster/main amd64 x11-xserver-utils amd64 7.7+8 [168 kB]\nGet:159 http://deb.debian.org/debian buster/main amd64 xbitmaps all 1.1.1-2 [32.1 kB]\nGet:160 http://deb.debian.org/debian buster/main amd64 xterm amd64 344-1+deb10u2 [771 kB]\nGet:161 http://deb.debian.org/debian buster/main amd64 zip amd64 3.0-11+b1 [234 kB]\nFetched 212 MB in 2s (123 MB/s)\ndebconf: delaying package configuration, since apt-utils is not installed\nSelecting previously unselected package libpython2.7-minimal:amd64.\n(Reading database ... 31092 files and directories currently installed.)\nPreparing to unpack .../0-libpython2.7-minimal_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking libpython2.7-minimal:amd64 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2.7-minimal.\nPreparing to unpack .../1-python2.7-minimal_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking python2.7-minimal (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2-minimal.\nPreparing to unpack .../2-python2-minimal_2.7.16-1_amd64.deb ...\nUnpacking python2-minimal (2.7.16-1) ...\nSelecting previously unselected package python-minimal.\nPreparing to unpack .../3-python-minimal_2.7.16-1_amd64.deb ...\nUnpacking python-minimal (2.7.16-1) ...\nSelecting previously unselected package libpython2.7-stdlib:amd64.\nPreparing to unpack .../4-libpython2.7-stdlib_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking libpython2.7-stdlib:amd64 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2.7.\nPreparing to unpack .../5-python2.7_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking python2.7 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package libpython2-stdlib:amd64.\nPreparing to unpack .../6-libpython2-stdlib_2.7.16-1_amd64.deb ...\nUnpacking libpython2-stdlib:amd64 (2.7.16-1) ...\nSelecting previously unselected package libpython-stdlib:amd64.\nPreparing to unpack .../7-libpython-stdlib_2.7.16-1_amd64.deb ...\nUnpacking libpython-stdlib:amd64 (2.7.16-1) ...\nSetting up libpython2.7-minimal:amd64 (2.7.16-2+deb10u4) ...\nSetting up python2.7-minimal (2.7.16-2+deb10u4) ...\nLinking and byte-compiling packages for runtime python2.7...\nSetting up python2-minimal (2.7.16-1) ...\nSelecting previously unselected package python2.\n(Reading database ... 31851 files and directories currently installed.)\nPreparing to unpack .../python2_2.7.16-1_amd64.deb ...\nUnpacking python2 (2.7.16-1) ...\nSetting up python-minimal (2.7.16-1) ...\nSelecting previously unselected package python.\n(Reading database ... 31883 files and directories currently installed.)\nPreparing to unpack .../000-python_2.7.16-1_amd64.deb ...\nUnpacking python (2.7.16-1) ...\nSelecting previously unselected package fonts-droid-fallback.\nPreparing to unpack .../001-fonts-droid-fallback_1%3a6.0.1r16-1.1_all.deb ...\nUnpacking fonts-droid-fallback (1:6.0.1r16-1.1) ...\nSelecting previously unselected package fonts-lato.\nPreparing to unpack .../002-fonts-lato_2.0-2_all.deb ...\nUnpacking fonts-lato (2.0-2) ...\nSelecting previously unselected package poppler-data.\nPreparing to unpack .../003-poppler-data_0.4.9-2_all.deb ...\nUnpacking poppler-data (0.4.9-2) ...\nSelecting previously unselected package tex-common.\nPreparing to unpack .../004-tex-common_6.11_all.deb ...\nUnpacking tex-common (6.11) ...\nSelecting previously unselected package libpaper1:amd64.\nPreparing to unpack .../005-libpaper1_1.1.28_amd64.deb ...\nUnpacking libpaper1:amd64 (1.1.28) ...\nSelecting previously unselected package libpaper-utils.\nPreparing to unpack .../006-libpaper-utils_1.1.28_amd64.deb ...\nUnpacking libpaper-utils (1.1.28) ...\nSelecting previously unselected package libkpathsea6:amd64.\nPreparing to unpack .../007-libkpathsea6_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libkpathsea6:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libptexenc1:amd64.\nPreparing to unpack .../008-libptexenc1_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libptexenc1:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libsynctex2:amd64.\nPreparing to unpack .../009-libsynctex2_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libsynctex2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexlua52:amd64.\nPreparing to unpack .../010-libtexlua52_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexlua52:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexlua53:amd64.\nPreparing to unpack .../011-libtexlua53_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexlua53:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexluajit2:amd64.\nPreparing to unpack .../012-libtexluajit2_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexluajit2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package t1utils.\nPreparing to unpack .../013-t1utils_1.41-3_amd64.deb ...\nUnpacking t1utils (1.41-3) ...\nSelecting previously unselected package libbrotli1:amd64.\nPreparing to unpack .../014-libbrotli1_1.0.7-2+deb10u1_amd64.deb ...\nUnpacking libbrotli1:amd64 (1.0.7-2+deb10u1) ...\nSelecting previously unselected package libgs9-common.\nPreparing to unpack .../015-libgs9-common_9.27~dfsg-2+deb10u9_all.deb ...\nUnpacking libgs9-common (9.27~dfsg-2+deb10u9) ...\nPreparing to unpack .../016-libcups2_2.2.10-6+deb10u10_amd64.deb ...\nUnpacking libcups2:amd64 (2.2.10-6+deb10u10) over (2.2.10-6+deb10u9) ...\nSelecting previously unselected package libcupsimage2:amd64.\nPreparing to unpack .../017-libcupsimage2_2.2.10-6+deb10u10_amd64.deb ...\nUnpacking libcupsimage2:amd64 (2.2.10-6+deb10u10) ...\nSelecting previously unselected package libidn11:amd64.\nPreparing to unpack .../018-libidn11_1.33-2.2_amd64.deb ...\nUnpacking libidn11:amd64 (1.33-2.2) ...\nSelecting previously unselected package libijs-0.35:amd64.\nPreparing to unpack .../019-libijs-0.35_0.35-14_amd64.deb ...\nUnpacking libijs-0.35:amd64 (0.35-14) ...\nSelecting previously unselected package libjbig2dec0:amd64.\nPreparing to unpack .../020-libjbig2dec0_0.16-1+deb10u1_amd64.deb ...\nUnpacking libjbig2dec0:amd64 (0.16-1+deb10u1) ...\nSelecting previously unselected package liblcms2-2:amd64.\nPreparing to unpack .../021-liblcms2-2_2.9-3_amd64.deb ...\nUnpacking liblcms2-2:amd64 (2.9-3) ...\nSelecting previously unselected package libopenjp2-7:amd64.\nPreparing to unpack .../022-libopenjp2-7_2.3.0-2+deb10u2_amd64.deb ...\nUnpacking libopenjp2-7:amd64 (2.3.0-2+deb10u2) ...\nSelecting previously unselected package libgs9:amd64.\nPreparing to unpack .../023-libgs9_9.27~dfsg-2+deb10u9_amd64.deb ...\nUnpacking libgs9:amd64 (9.27~dfsg-2+deb10u9) ...\nSelecting previously unselected package libpotrace0:amd64.\nPreparing to unpack .../024-libpotrace0_1.15-1_amd64.deb ...\nUnpacking libpotrace0:amd64 (1.15-1) ...\nSelecting previously unselected package libteckit0:amd64.\nPreparing to unpack .../025-libteckit0_2.5.8+ds2-5_amd64.deb ...\nUnpacking libteckit0:amd64 (2.5.8+ds2-5) ...\nSelecting previously unselected package libwoff1:amd64.\nPreparing to unpack .../026-libwoff1_1.0.2-1_amd64.deb ...\nUnpacking libwoff1:amd64 (1.0.2-1) ...\nSelecting previously unselected package libxxhash0:amd64.\nPreparing to unpack .../027-libxxhash0_0.6.5-2_amd64.deb ...\nUnpacking libxxhash0:amd64 (0.6.5-2) ...\nSelecting previously unselected package libzzip-0-13:amd64.\nPreparing to unpack .../028-libzzip-0-13_0.13.62-3.2+deb10u1_amd64.deb ...\nUnpacking libzzip-0-13:amd64 (0.13.62-3.2+deb10u1) ...\nSelecting previously unselected package texlive-binaries.\nPreparing to unpack .../029-texlive-binaries_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking texlive-binaries (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package xdg-utils.\nPreparing to unpack .../030-xdg-utils_1.1.3-1+deb10u1_all.deb ...\nUnpacking xdg-utils (1.1.3-1+deb10u1) ...\nSelecting previously unselected package texlive-base.\nPreparing to unpack .../031-texlive-base_2018.20190227-2_all.deb ...\nUnpacking texlive-base (2018.20190227-2) ...\nSelecting previously unselected package fonts-lmodern.\nPreparing to unpack .../032-fonts-lmodern_2.004.5-6_all.deb ...\nUnpacking fonts-lmodern (2.004.5-6) ...\nSelecting previously unselected package texlive-latex-base.\nPreparing to unpack .../033-texlive-latex-base_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-base (2018.20190227-2) ...\nSelecting previously unselected package texlive-latex-recommended.\nPreparing to unpack .../034-texlive-latex-recommended_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-recommended (2018.20190227-2) ...\nSelecting previously unselected package cm-super-minimal.\nPreparing to unpack .../035-cm-super-minimal_0.3.4-14_all.deb ...\nUnpacking cm-super-minimal (0.3.4-14) ...\nSelecting previously unselected package pfb2t1c2pfb.\nPreparing to unpack .../036-pfb2t1c2pfb_0.3-11_amd64.deb ...\nUnpacking pfb2t1c2pfb (0.3-11) ...\nSelecting previously unselected package cm-super.\nPreparing to unpack .../037-cm-super_0.3.4-14_all.deb ...\nUnpacking cm-super (0.3.4-14) ...\nSelecting previously unselected package ghostscript.\nPreparing to unpack .../038-ghostscript_9.27~dfsg-2+deb10u9_amd64.deb ...\nUnpacking ghostscript (9.27~dfsg-2+deb10u9) ...\nSelecting previously unselected package dvipng.\nPreparing to unpack .../039-dvipng_1.15-1.1_amd64.deb ...\nUnpacking dvipng (1.15-1.1) ...\nSelecting previously unselected package fonts-noto-mono.\nPreparing to unpack .../040-fonts-noto-mono_20181227-1_all.deb ...\nUnpacking fonts-noto-mono (20181227-1) ...\nSelecting previously unselected package fonts-texgyre.\nPreparing to unpack .../041-fonts-texgyre_20180621-3_all.deb ...\nUnpacking fonts-texgyre (20180621-3) ...\nSelecting previously unselected package gsfonts.\nPreparing to unpack .../042-gsfonts_1%3a8.11+urwcyr1.0.7~pre44-4.4_all.deb ...\nUnpacking gsfonts (1:8.11+urwcyr1.0.7~pre44-4.4) ...\nSelecting previously unselected package javascript-common.\nPreparing to unpack .../043-javascript-common_11_all.deb ...\nUnpacking javascript-common (11) ...\nSelecting previously unselected package libauthen-sasl-perl.\nPreparing to unpack .../044-libauthen-sasl-perl_2.1600-1_all.deb ...\nUnpacking libauthen-sasl-perl (2.1600-1) ...\nSelecting previously unselected package libcupsfilters1:amd64.\nPreparing to unpack .../045-libcupsfilters1_1.21.6-5+deb10u1_amd64.deb ...\nUnpacking libcupsfilters1:amd64 (1.21.6-5+deb10u1) ...\nSelecting previously unselected package libdata-dump-perl.\nPreparing to unpack .../046-libdata-dump-perl_1.23-1_all.deb ...\nUnpacking libdata-dump-perl (1.23-1) ...\nSelecting previously unselected package libdrm-common.\nPreparing to unpack .../047-libdrm-common_2.4.97-1_all.deb ...\nUnpacking libdrm-common (2.4.97-1) ...\nSelecting previously unselected package libdrm2:amd64.\nPreparing to unpack .../048-libdrm2_2.4.97-1_amd64.deb ...\nUnpacking libdrm2:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-amdgpu1:amd64.\nPreparing to unpack .../049-libdrm-amdgpu1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-amdgpu1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libpciaccess0:amd64.\nPreparing to unpack .../050-libpciaccess0_0.14-1_amd64.deb ...\nUnpacking libpciaccess0:amd64 (0.14-1) ...\nSelecting previously unselected package libdrm-intel1:amd64.\nPreparing to unpack .../051-libdrm-intel1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-intel1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-nouveau2:amd64.\nPreparing to unpack .../052-libdrm-nouveau2_2.4.97-1_amd64.deb ...\nUnpacking libdrm-nouveau2:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-radeon1:amd64.\nPreparing to unpack .../053-libdrm-radeon1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-radeon1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libencode-locale-perl.\nPreparing to unpack .../054-libencode-locale-perl_1.05-1_all.deb ...\nUnpacking libencode-locale-perl (1.05-1) ...\nSelecting previously unselected package libipc-system-simple-perl.\nPreparing to unpack .../055-libipc-system-simple-perl_1.25-4_all.deb ...\nUnpacking libipc-system-simple-perl (1.25-4) ...\nSelecting previously unselected package libfile-basedir-perl.\nPreparing to unpack .../056-libfile-basedir-perl_0.08-1_all.deb ...\nUnpacking libfile-basedir-perl (0.08-1) ...\nSelecting previously unselected package liburi-perl.\nPreparing to unpack .../057-liburi-perl_1.76-1_all.deb ...\nUnpacking liburi-perl (1.76-1) ...\nSelecting previously unselected package libfile-desktopentry-perl.\nPreparing to unpack .../058-libfile-desktopentry-perl_0.22-1_all.deb ...\nUnpacking libfile-desktopentry-perl (0.22-1) ...\nSelecting previously unselected package libtimedate-perl.\nPreparing to unpack .../059-libtimedate-perl_2.3000-2+deb10u1_all.deb ...\nUnpacking libtimedate-perl (2.3000-2+deb10u1) ...\nSelecting previously unselected package libhttp-date-perl.\nPreparing to unpack .../060-libhttp-date-perl_6.02-1_all.deb ...\nUnpacking libhttp-date-perl (6.02-1) ...\nSelecting previously unselected package libfile-listing-perl.\nPreparing to unpack .../061-libfile-listing-perl_6.04-1_all.deb ...\nUnpacking libfile-listing-perl (6.04-1) ...\nSelecting previously unselected package libfile-mimeinfo-perl.\nPreparing to unpack .../062-libfile-mimeinfo-perl_0.29-1_all.deb ...\nUnpacking libfile-mimeinfo-perl (0.29-1) ...\nSelecting previously unselected package libfont-afm-perl.\nPreparing to unpack .../063-libfont-afm-perl_1.20-2_all.deb ...\nUnpacking libfont-afm-perl (1.20-2) ...\nSelecting previously unselected package libfontenc1:amd64.\nPreparing to unpack .../064-libfontenc1_1%3a1.1.3-1+b2_amd64.deb ...\nUnpacking libfontenc1:amd64 (1:1.1.3-1+b2) ...\nSelecting previously unselected package libglapi-mesa:amd64.\nPreparing to unpack .../065-libglapi-mesa_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libglapi-mesa:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libllvm7:amd64.\nPreparing to unpack .../066-libllvm7_1%3a7.0.1-8+deb10u2_amd64.deb ...\nUnpacking libllvm7:amd64 (1:7.0.1-8+deb10u2) ...\nSelecting previously unselected package libsensors-config.\nPreparing to unpack .../067-libsensors-config_1%3a3.5.0-3_all.deb ...\nUnpacking libsensors-config (1:3.5.0-3) ...\nSelecting previously unselected package libsensors5:amd64.\nPreparing to unpack .../068-libsensors5_1%3a3.5.0-3_amd64.deb ...\nUnpacking libsensors5:amd64 (1:3.5.0-3) ...\nSelecting previously unselected package libgl1-mesa-dri:amd64.\nPreparing to unpack .../069-libgl1-mesa-dri_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libgl1-mesa-dri:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libglvnd0:amd64.\nPreparing to unpack .../070-libglvnd0_1.1.0-1_amd64.deb ...\nUnpacking libglvnd0:amd64 (1.1.0-1) ...\nSelecting previously unselected package libx11-xcb1:amd64.\nPreparing to unpack .../071-libx11-xcb1_2%3a1.6.7-1+deb10u4_amd64.deb ...\nUnpacking libx11-xcb1:amd64 (2:1.6.7-1+deb10u4) ...\nSelecting previously unselected package libxcb-dri2-0:amd64.\nPreparing to unpack .../072-libxcb-dri2-0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-dri2-0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-dri3-0:amd64.\nPreparing to unpack .../073-libxcb-dri3-0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-dri3-0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-glx0:amd64.\nPreparing to unpack .../074-libxcb-glx0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-glx0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-present0:amd64.\nPreparing to unpack .../075-libxcb-present0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-present0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-sync1:amd64.\nPreparing to unpack .../076-libxcb-sync1_1.13.1-2_amd64.deb ...\nUnpacking libxcb-sync1:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxshmfence1:amd64.\nPreparing to unpack .../077-libxshmfence1_1.3-1_amd64.deb ...\nUnpacking libxshmfence1:amd64 (1.3-1) ...\nSelecting previously unselected package libxxf86vm1:amd64.\nPreparing to unpack .../078-libxxf86vm1_1%3a1.1.4-1+b2_amd64.deb ...\nUnpacking libxxf86vm1:amd64 (1:1.1.4-1+b2) ...\nSelecting previously unselected package libglx-mesa0:amd64.\nPreparing to unpack .../079-libglx-mesa0_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libglx-mesa0:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libhtml-tagset-perl.\nPreparing to unpack .../080-libhtml-tagset-perl_3.20-3_all.deb ...\nUnpacking libhtml-tagset-perl (3.20-3) ...\nSelecting previously unselected package libhtml-parser-perl.\nPreparing to unpack .../081-libhtml-parser-perl_3.72-3+b3_amd64.deb ...\nUnpacking libhtml-parser-perl (3.72-3+b3) ...\nSelecting previously unselected package libio-html-perl.\nPreparing to unpack .../082-libio-html-perl_1.001-1_all.deb ...\nUnpacking libio-html-perl (1.001-1) ...\nSelecting previously unselected package liblwp-mediatypes-perl.\nPreparing to unpack .../083-liblwp-mediatypes-perl_6.02-1_all.deb ...\nUnpacking liblwp-mediatypes-perl (6.02-1) ...\nSelecting previously unselected package libhttp-message-perl.\nPreparing to unpack .../084-libhttp-message-perl_6.18-1_all.deb ...\nUnpacking libhttp-message-perl (6.18-1) ...\nSelecting previously unselected package libhtml-form-perl.\nPreparing to unpack .../085-libhtml-form-perl_6.03-1_all.deb ...\nUnpacking libhtml-form-perl (6.03-1) ...\nSelecting previously unselected package libhtml-tree-perl.\nPreparing to unpack .../086-libhtml-tree-perl_5.07-2_all.deb ...\nUnpacking libhtml-tree-perl (5.07-2) ...\nSelecting previously unselected package libhtml-format-perl.\nPreparing to unpack .../087-libhtml-format-perl_2.12-1_all.deb ...\nUnpacking libhtml-format-perl (2.12-1) ...\nSelecting previously unselected package libhttp-cookies-perl.\nPreparing to unpack .../088-libhttp-cookies-perl_6.04-1_all.deb ...\nUnpacking libhttp-cookies-perl (6.04-1) ...\nSelecting previously unselected package libhttp-daemon-perl.\nPreparing to unpack .../089-libhttp-daemon-perl_6.01-3+deb10u1_all.deb ...\nUnpacking libhttp-daemon-perl (6.01-3+deb10u1) ...\nSelecting previously unselected package libhttp-negotiate-perl.\nPreparing to unpack .../090-libhttp-negotiate-perl_6.01-1_all.deb ...\nUnpacking libhttp-negotiate-perl (6.01-1) ...\nSelecting previously unselected package perl-openssl-defaults:amd64.\nPreparing to unpack .../091-perl-openssl-defaults_3_amd64.deb ...\nUnpacking perl-openssl-defaults:amd64 (3) ...\nSelecting previously unselected package libnet-ssleay-perl.\nPreparing to unpack .../092-libnet-ssleay-perl_1.85-2+deb10u1_amd64.deb ...\nUnpacking libnet-ssleay-perl (1.85-2+deb10u1) ...\nSelecting previously unselected package libio-socket-ssl-perl.\nPreparing to unpack .../093-libio-socket-ssl-perl_2.060-3_all.deb ...\nUnpacking libio-socket-ssl-perl (2.060-3) ...\nSelecting previously unselected package libio-stringy-perl.\nPreparing to unpack .../094-libio-stringy-perl_2.111-3_all.deb ...\nUnpacking libio-stringy-perl (2.111-3) ...\nSelecting previously unselected package libjs-jquery.\nPreparing to unpack .../095-libjs-jquery_3.3.1~dfsg-3+deb10u1_all.deb ...\nUnpacking libjs-jquery (3.3.1~dfsg-3+deb10u1) ...\nSelecting previously unselected package libnet-http-perl.\nPreparing to unpack .../096-libnet-http-perl_6.18-1_all.deb ...\nUnpacking libnet-http-perl (6.18-1) ...\nSelecting previously unselected package libtry-tiny-perl.\nPreparing to unpack .../097-libtry-tiny-perl_0.30-1_all.deb ...\nUnpacking libtry-tiny-perl (0.30-1) ...\nSelecting previously unselected package libwww-robotrules-perl.\nPreparing to unpack .../098-libwww-robotrules-perl_6.02-1_all.deb ...\nUnpacking libwww-robotrules-perl (6.02-1) ...\nSelecting previously unselected package libwww-perl.\nPreparing to unpack .../099-libwww-perl_6.36-2_all.deb ...\nUnpacking libwww-perl (6.36-2) ...\nSelecting previously unselected package liblwp-protocol-https-perl.\nPreparing to unpack .../100-liblwp-protocol-https-perl_6.07-2_all.deb ...\nUnpacking liblwp-protocol-https-perl (6.07-2) ...\nSelecting previously unselected package libnet-smtp-ssl-perl.\nPreparing to unpack .../101-libnet-smtp-ssl-perl_1.04-1_all.deb ...\nUnpacking libnet-smtp-ssl-perl (1.04-1) ...\nSelecting previously unselected package libmailtools-perl.\nPreparing to unpack .../102-libmailtools-perl_2.18-1_all.deb ...\nUnpacking libmailtools-perl (2.18-1) ...\nSelecting previously unselected package libxml-parser-perl.\nPreparing to unpack .../103-libxml-parser-perl_2.44-4_amd64.deb ...\nUnpacking libxml-parser-perl (2.44-4) ...\nSelecting previously unselected package libxml-twig-perl.\nPreparing to unpack .../104-libxml-twig-perl_1%3a3.50-1.1_all.deb ...\nUnpacking libxml-twig-perl (1:3.50-1.1) ...\nSelecting previously unselected package libnet-dbus-perl.\nPreparing to unpack .../105-libnet-dbus-perl_1.1.0-5+b1_amd64.deb ...\nUnpacking libnet-dbus-perl (1.1.0-5+b1) ...\nSelecting previously unselected package rubygems-integration.\nPreparing to unpack .../106-rubygems-integration_1.11+deb10u1_all.deb ...\nUnpacking rubygems-integration (1.11+deb10u1) ...\nSelecting previously unselected package ruby2.5.\nPreparing to unpack .../107-ruby2.5_2.5.5-3+deb10u6_amd64.deb ...\nUnpacking ruby2.5 (2.5.5-3+deb10u6) ...\nSelecting previously unselected package ruby.\nPreparing to unpack .../108-ruby_1%3a2.5.1_amd64.deb ...\nUnpacking ruby (1:2.5.1) ...\nSelecting previously unselected package rake.\nPreparing to unpack .../109-rake_12.3.1-3+deb10u1_all.deb ...\nUnpacking rake (12.3.1-3+deb10u1) ...\nSelecting previously unselected package ruby-did-you-mean.\nPreparing to unpack .../110-ruby-did-you-mean_1.2.1-1_all.deb ...\nUnpacking ruby-did-you-mean (1.2.1-1) ...\nSelecting previously unselected package ruby-minitest.\nPreparing to unpack .../111-ruby-minitest_5.11.3-1_all.deb ...\nUnpacking ruby-minitest (5.11.3-1) ...\nSelecting previously unselected package ruby-net-telnet.\nPreparing to unpack .../112-ruby-net-telnet_0.1.1-2_all.deb ...\nUnpacking ruby-net-telnet (0.1.1-2) ...\nSelecting previously unselected package ruby-power-assert.\nPreparing to unpack .../113-ruby-power-assert_1.1.1-1_all.deb ...\nUnpacking ruby-power-assert (1.1.1-1) ...\nSelecting previously unselected package ruby-test-unit.\nPreparing to unpack .../114-ruby-test-unit_3.2.8-1_all.deb ...\nUnpacking ruby-test-unit (3.2.8-1) ...\nSelecting previously unselected package ruby-xmlrpc.\nPreparing to unpack .../115-ruby-xmlrpc_0.3.0-2_all.deb ...\nUnpacking ruby-xmlrpc (0.3.0-2) ...\nSelecting previously unselected package libyaml-0-2:amd64.\nPreparing to unpack .../116-libyaml-0-2_0.2.1-1_amd64.deb ...\nUnpacking libyaml-0-2:amd64 (0.2.1-1) ...\nSelecting previously unselected package libruby2.5:amd64.\nPreparing to unpack .../117-libruby2.5_2.5.5-3+deb10u6_amd64.deb ...\nUnpacking libruby2.5:amd64 (2.5.5-3+deb10u6) ...\nSelecting previously unselected package libtcl8.6:amd64.\nPreparing to unpack .../118-libtcl8.6_8.6.9+dfsg-2_amd64.deb ...\nUnpacking libtcl8.6:amd64 (8.6.9+dfsg-2) ...\nSelecting previously unselected package libtext-iconv-perl.\nPreparing to unpack .../119-libtext-iconv-perl_1.7-5+b7_amd64.deb ...\nUnpacking libtext-iconv-perl (1.7-5+b7) ...\nSelecting previously unselected package libtie-ixhash-perl.\nPreparing to unpack .../120-libtie-ixhash-perl_1.23-2_all.deb ...\nUnpacking libtie-ixhash-perl (1.23-2) ...\nSelecting previously unselected package libxss1:amd64.\nPreparing to unpack .../121-libxss1_1%3a1.2.3-1_amd64.deb ...\nUnpacking libxss1:amd64 (1:1.2.3-1) ...\nSelecting previously unselected package libtk8.6:amd64.\nPreparing to unpack .../122-libtk8.6_8.6.9-2_amd64.deb ...\nUnpacking libtk8.6:amd64 (8.6.9-2) ...\nSelecting previously unselected package libutempter0:amd64.\nPreparing to unpack .../123-libutempter0_1.1.6-3_amd64.deb ...\nUnpacking libutempter0:amd64 (1.1.6-3) ...\nSelecting previously unselected package libx11-protocol-perl.\nPreparing to unpack .../124-libx11-protocol-perl_0.56-7_all.deb ...\nUnpacking libx11-protocol-perl (0.56-7) ...\nSelecting previously unselected package libxcb-shape0:amd64.\nPreparing to unpack .../125-libxcb-shape0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-shape0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxml-xpathengine-perl.\nPreparing to unpack .../126-libxml-xpathengine-perl_0.14-1_all.deb ...\nUnpacking libxml-xpathengine-perl (0.14-1) ...\nSelecting previously unselected package libxmuu1:amd64.\nPreparing to unpack .../127-libxmuu1_2%3a1.1.2-2+b3_amd64.deb ...\nUnpacking libxmuu1:amd64 (2:1.1.2-2+b3) ...\nSelecting previously unselected package libxtst6:amd64.\nPreparing to unpack .../128-libxtst6_2%3a1.2.3-1_amd64.deb ...\nUnpacking libxtst6:amd64 (2:1.2.3-1) ...\nSelecting previously unselected package libxv1:amd64.\nPreparing to unpack .../129-libxv1_2%3a1.0.11-1_amd64.deb ...\nUnpacking libxv1:amd64 (2:1.0.11-1) ...\nSelecting previously unselected package libxxf86dga1:amd64.\nPreparing to unpack .../130-libxxf86dga1_2%3a1.1.4-1+b3_amd64.deb ...\nUnpacking libxxf86dga1:amd64 (2:1.1.4-1+b3) ...\nSelecting previously unselected package xfonts-encodings.\nPreparing to unpack .../131-xfonts-encodings_1%3a1.0.4-2_all.deb ...\nUnpacking xfonts-encodings (1:1.0.4-2) ...\nSelecting previously unselected package xfonts-utils.\nPreparing to unpack .../132-xfonts-utils_1%3a7.7+6_amd64.deb ...\nUnpacking xfonts-utils (1:7.7+6) ...\nSelecting previously unselected package lmodern.\nPreparing to unpack .../133-lmodern_2.004.5-6_all.deb ...\nUnpacking lmodern (2.004.5-6) ...\nSelecting previously unselected package preview-latex-style.\nPreparing to unpack .../134-preview-latex-style_11.91-2_all.deb ...\nUnpacking preview-latex-style (11.91-2) ...\nSelecting previously unselected package tcl8.6.\nPreparing to unpack .../135-tcl8.6_8.6.9+dfsg-2_amd64.deb ...\nUnpacking tcl8.6 (8.6.9+dfsg-2) ...\nSelecting previously unselected package tcl.\nPreparing to unpack .../136-tcl_8.6.9+1_amd64.deb ...\nUnpacking tcl (8.6.9+1) ...\nSelecting previously unselected package tex-gyre.\nPreparing to unpack .../137-tex-gyre_20180621-3_all.deb ...\nUnpacking tex-gyre (20180621-3) ...\nSelecting previously unselected package texlive-fonts-recommended.\nPreparing to unpack .../138-texlive-fonts-recommended_2018.20190227-2_all.deb ...\nUnpacking texlive-fonts-recommended (2018.20190227-2) ...\nSelecting previously unselected package texlive-pictures.\nPreparing to unpack .../139-texlive-pictures_2018.20190227-2_all.deb ...\nUnpacking texlive-pictures (2018.20190227-2) ...\nSelecting previously unselected package texlive-latex-extra.\nPreparing to unpack .../140-texlive-latex-extra_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-extra (2018.20190227-2) ...\nSelecting previously unselected package texlive-plain-generic.\nPreparing to unpack .../141-texlive-plain-generic_2018.20190227-2_all.deb ...\nUnpacking texlive-plain-generic (2018.20190227-2) ...\nSelecting previously unselected package tipa.\nPreparing to unpack .../142-tipa_2%3a1.3-20_all.deb ...\nUnpacking tipa (2:1.3-20) ...\nSelecting previously unselected package tk8.6.\nPreparing to unpack .../143-tk8.6_8.6.9-2_amd64.deb ...\nUnpacking tk8.6 (8.6.9-2) ...\nSelecting previously unselected package tk.\nPreparing to unpack .../144-tk_8.6.9+1_amd64.deb ...\nUnpacking tk (8.6.9+1) ...\nSelecting previously unselected package libglx0:amd64.\nPreparing to unpack .../145-libglx0_1.1.0-1_amd64.deb ...\nUnpacking libglx0:amd64 (1.1.0-1) ...\nSelecting previously unselected package libgl1:amd64.\nPreparing to unpack .../146-libgl1_1.1.0-1_amd64.deb ...\nUnpacking libgl1:amd64 (1.1.0-1) ...\nSelecting previously unselected package x11-utils.\nPreparing to unpack .../147-x11-utils_7.7+4_amd64.deb ...\nUnpacking x11-utils (7.7+4) ...\nSelecting previously unselected package x11-xserver-utils.\nPreparing to unpack .../148-x11-xserver-utils_7.7+8_amd64.deb ...\nUnpacking x11-xserver-utils (7.7+8) ...\nSelecting previously unselected package xbitmaps.\nPreparing to unpack .../149-xbitmaps_1.1.1-2_all.deb ...\nUnpacking xbitmaps (1.1.1-2) ...\nSelecting previously unselected package xterm.\nPreparing to unpack .../150-xterm_344-1+deb10u2_amd64.deb ...\nUnpacking xterm (344-1+deb10u2) ...\nSelecting previously unselected package zip.\nPreparing to unpack .../151-zip_3.0-11+b1_amd64.deb ...\nUnpacking zip (3.0-11+b1) ...\nSetting up pfb2t1c2pfb (0.3-11) ...\nSetting up libgs9-common (9.27~dfsg-2+deb10u9) ...\nSetting up libtext-iconv-perl (1.7-5+b7) ...\nSetting up javascript-common (11) ...\nSetting up libxcb-dri3-0:amd64 (1.13.1-2) ...\nSetting up liblcms2-2:amd64 (2.9-3) ...\nSetting up libpaper1:amd64 (1.1.28) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\n\nCreating config file /etc/papersize with new version\nSetting up libx11-xcb1:amd64 (2:1.6.7-1+deb10u4) ...\nSetting up libpciaccess0:amd64 (0.14-1) ...\nSetting up libtie-ixhash-perl (1.23-2) ...\nSetting up fonts-lato (2.0-2) ...\nSetting up fonts-noto-mono (20181227-1) ...\nSetting up libtexlua52:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libfont-afm-perl (1.20-2) ...\nSetting up ruby-power-assert (1.1.1-1) ...\nSetting up libtexlua53:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libyaml-0-2:amd64 (0.2.1-1) ...\nSetting up libglvnd0:amd64 (1.1.0-1) ...\nSetting up libio-stringy-perl (2.111-3) ...\nSetting up libxtst6:amd64 (2:1.2.3-1) ...\nSetting up libhtml-tagset-perl (3.20-3) ...\nSetting up libijs-0.35:amd64 (0.35-14) ...\nSetting up libauthen-sasl-perl (2.1600-1) ...\nSetting up libxcb-glx0:amd64 (1.13.1-2) ...\nSetting up libtexluajit2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libbrotli1:amd64 (1.0.7-2+deb10u1) ...\nSetting up liblwp-mediatypes-perl (6.02-1) ...\nSetting up libxcb-shape0:amd64 (1.13.1-2) ...\nSetting up libtry-tiny-perl (0.30-1) ...\nSetting up libsensors-config (1:3.5.0-3) ...\nSetting up libxxf86dga1:amd64 (2:1.1.4-1+b3) ...\nSetting up perl-openssl-defaults:amd64 (3) ...\nSetting up libencode-locale-perl (1.05-1) ...\nSetting up rubygems-integration (1.11+deb10u1) ...\nSetting up libzzip-0-13:amd64 (0.13.62-3.2+deb10u1) ...\nSetting up libpaper-utils (1.1.28) ...\nSetting up libxxf86vm1:amd64 (1:1.1.4-1+b2) ...\nSetting up poppler-data (0.4.9-2) ...\nSetting up libpython2.7-stdlib:amd64 (2.7.16-2+deb10u4) ...\nSetting up libxcb-present0:amd64 (1.13.1-2) ...\nSetting up ruby-minitest (5.11.3-1) ...\nSetting up tex-common (6.11) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\nupdate-language: texlive-base not installed and configured, doing nothing!\nSetting up zip (3.0-11+b1) ...\nSetting up libfontenc1:amd64 (1:1.1.3-1+b2) ...\nSetting up ruby-test-unit (3.2.8-1) ...\nSetting up libdata-dump-perl (1.23-1) ...\nSetting up libxcb-sync1:amd64 (1.13.1-2) ...\nSetting up libjbig2dec0:amd64 (0.16-1+deb10u1) ...\nSetting up libipc-system-simple-perl (1.25-4) ...\nSetting up libidn11:amd64 (1.33-2.2) ...\nSetting up libteckit0:amd64 (2.5.8+ds2-5) ...\nSetting up libxml-xpathengine-perl (0.14-1) ...\nSetting up gsfonts (1:8.11+urwcyr1.0.7~pre44-4.4) ...\nSetting up ruby-net-telnet (0.1.1-2) ...\nSetting up xfonts-encodings (1:1.0.4-2) ...\nSetting up t1utils (1.41-3) ...\nSetting up libxv1:amd64 (2:1.0.11-1) ...\nSetting up libio-html-perl (1.001-1) ...\nSetting up libtcl8.6:amd64 (8.6.9+dfsg-2) ...\nSetting up fonts-texgyre (20180621-3) ...\nSetting up libsensors5:amd64 (1:3.5.0-3) ...\nSetting up libglapi-mesa:amd64 (18.3.6-2+deb10u1) ...\nSetting up libkpathsea6:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libtimedate-perl (2.3000-2+deb10u1) ...\nSetting up libutempter0:amd64 (1.1.6-3) ...\nSetting up libcups2:amd64 (2.2.10-6+deb10u10) ...\nSetting up libxcb-dri2-0:amd64 (1.13.1-2) ...\nSetting up libxshmfence1:amd64 (1.3-1) ...\nSetting up libxxhash0:amd64 (0.6.5-2) ...\nSetting up fonts-lmodern (2.004.5-6) ...\nSetting up libopenjp2-7:amd64 (2.3.0-2+deb10u2) ...\nSetting up libllvm7:amd64 (1:7.0.1-8+deb10u2) ...\nSetting up fonts-droid-fallback (1:6.0.1r16-1.1) ...\nSetting up libxss1:amd64 (1:1.2.3-1) ...\nSetting up libjs-jquery (3.3.1~dfsg-3+deb10u1) ...\nSetting up ruby-did-you-mean (1.2.1-1) ...\nSetting up libdrm-common (2.4.97-1) ...\nSetting up ruby-xmlrpc (0.3.0-2) ...\nSetting up xdg-utils (1.1.3-1+deb10u1) ...\nSetting up liburi-perl (1.76-1) ...\nSetting up libxmuu1:amd64 (2:1.1.2-2+b3) ...\nSetting up libx11-protocol-perl (0.56-7) ...\nSetting up xbitmaps (1.1.1-2) ...\nSetting up libsynctex2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libpotrace0:amd64 (1.15-1) ...\nSetting up libnet-ssleay-perl (1.85-2+deb10u1) ...\nSetting up libhttp-date-perl (6.02-1) ...\nSetting up tcl8.6 (8.6.9+dfsg-2) ...\nSetting up libfile-basedir-perl (0.08-1) ...\nSetting up libfile-listing-perl (6.04-1) ...\nSetting up python2.7 (2.7.16-2+deb10u4) ...\nSetting up libwoff1:amd64 (1.0.2-1) ...\nSetting up libpython2-stdlib:amd64 (2.7.16-1) ...\nSetting up preview-latex-style (11.91-2) ...\nSetting up libtk8.6:amd64 (8.6.9-2) ...\nSetting up libnet-http-perl (6.18-1) ...\nSetting up xfonts-utils (1:7.7+6) ...\nSetting up x11-xserver-utils (7.7+8) ...\nSetting up python2 (2.7.16-1) ...\nSetting up libcupsimage2:amd64 (2.2.10-6+deb10u10) ...\nSetting up libpython-stdlib:amd64 (2.7.16-1) ...\nSetting up libptexenc1:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libfile-desktopentry-perl (0.22-1) ...\nSetting up libwww-robotrules-perl (6.02-1) ...\nSetting up libdrm2:amd64 (2.4.97-1) ...\nSetting up lmodern (2.004.5-6) ...\nSetting up libhtml-parser-perl (3.72-3+b3) ...\nSetting up tcl (8.6.9+1) ...\nSetting up xterm (344-1+deb10u2) ...\nupdate-alternatives: using /usr/bin/xterm to provide /usr/bin/x-terminal-emulator (x-terminal-emulator) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/x-terminal-emulator.1.gz because associated file /usr/share/man/man1/xterm.1.gz (of link group x-terminal-emulator) doesn't exist\nupdate-alternatives: using /usr/bin/lxterm to provide /usr/bin/x-terminal-emulator (x-terminal-emulator) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/x-terminal-emulator.1.gz because associated file /usr/share/man/man1/lxterm.1.gz (of link group x-terminal-emulator) doesn't exist\nSetting up python (2.7.16-1) ...\nSetting up tex-gyre (20180621-3) ...\nSetting up libcupsfilters1:amd64 (1.21.6-5+deb10u1) ...\nSetting up libio-socket-ssl-perl (2.060-3) ...\nSetting up libhttp-message-perl (6.18-1) ...\nSetting up libdrm-amdgpu1:amd64 (2.4.97-1) ...\nSetting up libhtml-form-perl (6.03-1) ...\nSetting up tk8.6 (8.6.9-2) ...\nSetting up libfile-mimeinfo-perl (0.29-1) ...\nSetting up libhttp-negotiate-perl (6.01-1) ...\nSetting up libdrm-nouveau2:amd64 (2.4.97-1) ...\nSetting up libgs9:amd64 (9.27~dfsg-2+deb10u9) ...\nSetting up libhttp-cookies-perl (6.04-1) ...\nSetting up libdrm-radeon1:amd64 (2.4.97-1) ...\nSetting up libhtml-tree-perl (5.07-2) ...\nSetting up libdrm-intel1:amd64 (2.4.97-1) ...\nSetting up libgl1-mesa-dri:amd64 (18.3.6-2+deb10u1) ...\nSetting up libhtml-format-perl (2.12-1) ...\nSetting up ghostscript (9.27~dfsg-2+deb10u9) ...\nSetting up libnet-smtp-ssl-perl (1.04-1) ...\nSetting up libmailtools-perl (2.18-1) ...\nSetting up libhttp-daemon-perl (6.01-3+deb10u1) ...\nSetting up texlive-binaries (2018.20181218.49446-1+deb10u2) ...\nupdate-alternatives: using /usr/bin/xdvi-xaw to provide /usr/bin/xdvi.bin (xdvi.bin) in auto mode\nupdate-alternatives: using /usr/bin/bibtex.original to provide /usr/bin/bibtex (bibtex) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/bibtex.1.gz because associated file /usr/share/man/man1/bibtex.original.1.gz (of link group bibtex) doesn't exist\nSetting up tk (8.6.9+1) ...\nSetting up texlive-base (2018.20190227-2) ...\nmktexlsr: Updating /var/lib/texmf/ls-R-TEXLIVEDIST... \nmktexlsr: Updating /var/lib/texmf/ls-R-TEXMFMAIN... \nmktexlsr: Updating /var/lib/texmf/ls-R... \nmktexlsr: Done.\ntl-paper: setting paper size for dvips to a4: /var/lib/texmf/dvips/config/config-paper.ps\ntl-paper: setting paper size for dvipdfmx to a4: /var/lib/texmf/dvipdfmx/dvipdfmx-paper.cfg\ntl-paper: setting paper size for xdvi to a4: /var/lib/texmf/xdvi/XDvi-paper\ntl-paper: setting paper size for pdftex to a4: /var/lib/texmf/tex/generic/config/pdftexconfig.tex\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\ntl-paper: setting paper size for dvipdfmx to letter: /var/lib/texmf/dvipdfmx/dvipdfmx-paper.cfg\ntl-paper: setting paper size for dvips to letter: /var/lib/texmf/dvips/config/config-paper.ps\ntl-paper: setting paper size for pdftex to letter: /var/lib/texmf/tex/generic/config/pdftexconfig.tex\ntl-paper: setting paper size for xdvi to letter: /var/lib/texmf/xdvi/XDvi-paper\nSetting up libglx-mesa0:amd64 (18.3.6-2+deb10u1) ...\nSetting up libglx0:amd64 (1.1.0-1) ...\nSetting up dvipng (1.15-1.1) ...\nSetting up texlive-plain-generic (2018.20190227-2) ...\nSetting up libgl1:amd64 (1.1.0-1) ...\nSetting up texlive-latex-base (2018.20190227-2) ...\nSetting up texlive-latex-recommended (2018.20190227-2) ...\nSetting up texlive-pictures (2018.20190227-2) ...\nSetting up texlive-fonts-recommended (2018.20190227-2) ...\nSetting up x11-utils (7.7+4) ...\nSetting up tipa (2:1.3-20) ...\nRegenerating '/var/lib/texmf/fmtutil.cnf-DEBIAN'... done.\nRegenerating '/var/lib/texmf/fmtutil.cnf-TEXLIVEDIST'... done.\nupdate-fmtutil has updated the following file(s):\n\t/var/lib/texmf/fmtutil.cnf-DEBIAN\n\t/var/lib/texmf/fmtutil.cnf-TEXLIVEDIST\nIf you want to activate the changes in the above file(s),\nyou should run fmtutil-sys or fmtutil.\nSetting up cm-super-minimal (0.3.4-14) ...\nSetting up texlive-latex-extra (2018.20190227-2) ...\nSetting up cm-super (0.3.4-14) ...\nCreating fonts. This may take some time... done.\nSetting up rake (12.3.1-3+deb10u1) ...\nSetting up liblwp-protocol-https-perl (6.07-2) ...\nSetting up libwww-perl (6.36-2) ...\nSetting up libruby2.5:amd64 (2.5.5-3+deb10u6) ...\nSetting up libxml-parser-perl (2.44-4) ...\nSetting up ruby2.5 (2.5.5-3+deb10u6) ...\nSetting up libxml-twig-perl (1:3.50-1.1) ...\nSetting up libnet-dbus-perl (1.1.0-5+b1) ...\nSetting up ruby (1:2.5.1) ...\nProcessing triggers for fontconfig (2.13.1-2) ...\nProcessing triggers for mime-support (3.62) ...\nProcessing triggers for hicolor-icon-theme (0.17-2) ...\nProcessing triggers for libc-bin (2.28-10+deb10u2) ...\nProcessing triggers for tex-common (6.11) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\nRunning updmap-sys. This may take some time... done.\nRunning mktexlsr /var/lib/texmf ... done.\nBuilding format(s) --all.\n\tThis may take some time... done.\nCollecting SciencePlots\n Downloading SciencePlots-2.1.1-py3-none-any.whl (16 kB)\nRequirement already satisfied: matplotlib in /shared-libs/python3.9/py/lib/python3.9/site-packages (from SciencePlots) (3.6.0)\nRequirement already satisfied: packaging>=20.0 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (21.3)\nRequirement already satisfied: cycler>=0.10 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (0.11.0)\nRequirement already satisfied: contourpy>=1.0.1 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.0.5)\nRequirement already satisfied: pyparsing>=2.2.1 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (3.0.9)\nRequirement already satisfied: python-dateutil>=2.7 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (2.8.2)\nRequirement already satisfied: pillow>=6.2.0 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (9.2.0)\nRequirement already satisfied: kiwisolver>=1.0.1 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.4.4)\nRequirement already satisfied: numpy>=1.19 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.23.4)\nRequirement already satisfied: fonttools>=4.22.0 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (4.37.4)\nRequirement already satisfied: six>=1.5 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib->SciencePlots) (1.16.0)\nInstalling collected packages: SciencePlots\nSuccessfully installed SciencePlots-2.1.1\n\n\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n","output_type":"stream"}],"outputs_reference":"s3:deepnote-cell-outputs-production/d6329ca3-638b-4019-b89e-0214a38a1b9d","content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718166364333,"execution_millis":1356,"deepnote_to_be_reexecuted":false,"cell_id":"8f80ee06b3b8419d89a09e9c34b2a8f3","deepnote_cell_type":"code"},"source":"import os.path as osp\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport scienceplots\nplt.style.use('science')","block_group":"8f80ee06b3b8419d89a09e9c34b2a8f3","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718166365694,"execution_millis":6573,"deepnote_to_be_reexecuted":false,"cell_id":"3d86e8cb3162424c985999fa7900ce91","deepnote_cell_type":"code"},"source":"\n\nplt.suptitle(r'Similarity between Reviews \\& Metareview', fontsize=22)\n\n# Define colors for the bars\ncolors = ['#aeaeae', '#d86ecc', '#4f95da', '#46c3b8']\nFONT_SIZE = 20\n\n\ndf_bertscore = pd.DataFrame({\n 'Setting': ['Baseline', 'Authoritarian', 'Conformist', 'Inclusive'],\n 'Mean': [0.871186, 0.840460, 0.879104, 0.873193],\n 'Stdev': [0.009998, 0.008486, 0.012472, 0.011310]\n})\n\ndf_sentence_bert = pd.DataFrame({\n 'Setting': ['Baseline', 'Authoritarian', 'Conformist', 'Inclusive'],\n 'Mean': [0.952945, 0.904958, 0.958697, 0.955023],\n 'Stdev': [0.027234, 0.023597, 0.015722, 0.013156]\n})\n\n# Create the bar plot\nfig, axes = plt.subplots(1, 2, figsize=(8, 5), sharey=True)\n\nidx_plot = 0\n\n# Set the aesthetic style of the plots\n# sns.set_style(\"whitegrid\")\n\nplt.suptitle(r'Similarity between Reviews \\& Metareview', fontsize=22)\n\nfor name, df in {\n 'BERTScore': df_bertscore,\n 'Embedding Similarity': df_sentence_bert\n}.items():\n\n\n bar_plot = sns.barplot(x='Setting', y='Mean', data=df, ci=True, palette=colors, ax=axes[idx_plot])\n\n for i, row in df.iterrows():\n axes[idx_plot].errorbar(x=i, y=row['Mean'], yerr=row['Stdev'], fmt='none', c='black', capsize=5)\n\n axes[idx_plot].set_xlim(-0.5, len(df) - 0.5)\n axes[idx_plot].set_xlabel('')\n axes[idx_plot].set_ylabel('', fontsize=FONT_SIZE)\n axes[idx_plot].set_title(name, fontsize=FONT_SIZE)\n axes[idx_plot].set_ylim(0.8, 1.0)\n\n # Here we hide the x-ticks\n axes[idx_plot].tick_params(axis='x', labelsize=FONT_SIZE, which='both', length=0)\n\n # Get current x-tick labels\n current_labels = [label.get_text() for label in axes[idx_plot].get_xticklabels()]\n\n # Set new x-tick labels with rotation and horizontal alignment\n axes[idx_plot].set_xticklabels(current_labels, rotation=30, ha='right')\n\n axes[idx_plot].tick_params(axis='y', labelsize=FONT_SIZE)\n\n # Move x-ticks a little to the right\n ticks = axes[idx_plot].get_xticks()\n new_ticks = (np.array(ticks) + 0.5).tolist()\n axes[idx_plot].set_xticks(new_ticks)\n axes[idx_plot].grid(axis='y', alpha=0.5)\n\n idx_plot += 1\n\n\nplt.tight_layout()\nplt.savefig('barplot_similarity_review_metareview.pdf', bbox_inches='tight')","block_group":"dd50a69924fb4ea4a3f39a2a83ede68b","execution_count":null,"outputs":[{"name":"stderr","text":"/tmp/ipykernel_37/2862352681.py:36: FutureWarning: \n\nThe `ci` parameter is deprecated. Use `errorbar=('ci', True)` for the same effect.\n\n bar_plot = sns.barplot(x='Setting', y='Mean', data=df, ci=True, palette=colors, ax=axes[idx_plot])\n/tmp/ipykernel_37/2862352681.py:36: FutureWarning: \n\nPassing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n\n bar_plot = sns.barplot(x='Setting', y='Mean', data=df, ci=True, palette=colors, ax=axes[idx_plot])\n/tmp/ipykernel_37/2862352681.py:54: UserWarning: FixedFormatter should only be used together with FixedLocator\n axes[idx_plot].set_xticklabels(current_labels, rotation=30, ha='right')\n/tmp/ipykernel_37/2862352681.py:36: FutureWarning: \n\nThe `ci` parameter is deprecated. Use `errorbar=('ci', True)` for the same effect.\n\n bar_plot = sns.barplot(x='Setting', y='Mean', data=df, ci=True, palette=colors, ax=axes[idx_plot])\n/tmp/ipykernel_37/2862352681.py:36: FutureWarning: \n\nPassing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n\n bar_plot = sns.barplot(x='Setting', y='Mean', data=df, ci=True, palette=colors, ax=axes[idx_plot])\n/tmp/ipykernel_37/2862352681.py:54: UserWarning: FixedFormatter should only be used together with FixedLocator\n axes[idx_plot].set_xticklabels(current_labels, rotation=30, ha='right')\n","output_type":"stream"},{"data":{"text/plain":"
"},"metadata":{},"output_type":"display_data"},{"data":{"text/plain":"
","image/png":"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\n"},"metadata":{"image/png":{"width":780,"height":485}},"output_type":"display_data"}],"outputs_reference":"s3:deepnote-cell-outputs-production/ab12cc2e-aebf-4e0f-9e3b-a383706674e7","content_dependencies":null},{"cell_type":"code","metadata":{"cell_id":"99fa6958b694440cb87623778a09a0cc","deepnote_cell_type":"code"},"source":"","block_group":"42f5468f52ad49f588eeb948c1cbde17","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"markdown","source":"\nCreated in deepnote.com \nCreated in Deepnote","metadata":{"created_in_deepnote_cell":true,"deepnote_cell_type":"markdown"}}],"nbformat":4,"nbformat_minor":0,"metadata":{"deepnote_persisted_session":{"createdAt":"2024-06-12T04:00:32.504Z"},"deepnote_notebook_id":"626006947bc44536874a469961719c3d","deepnote_execution_queue":[]}} \ No newline at end of file diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..81ad95487b7531378fd96dd89c9019ea9ec0c0f5 --- /dev/null +++ b/notebooks/demo.ipynb @@ -0,0 +1,219 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "604ab692-a51f-4093-bf94-45b503c68d33", + "metadata": {}, + "source": [ + "# AgentReview\n", + "\n", + "\n", + "\n", + "- 🔗 arXiv: [https://arxiv.org/abs/2406.12708] (https://arxiv.org/abs/2406.12708)\n", + "- 🌐 Website: [https://agentreview.github.io/](https://agentreview.github.io/)\n", + "\n", + "```bibtex\n", + "@inproceedings{jin2024agentreview,\n", + " title={AgentReview: Exploring Peer Review Dynamics with LLM Agents},\n", + " author={Jin, Yiqiao and Zhao, Qinlin and Wang, Yiyang and Chen, Hao and Zhu, Kaijie and Xiao, Yijia and Wang, Jindong},\n", + " booktitle={EMNLP},\n", + " year={2024}\n", + "}\n", + "```\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3a7e2134-997f-4a5b-8b0f-a972a17bca21", + "metadata": {}, + "outputs": [], + "source": [ + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62906f8a-6aef-4d48-8a3e-ba0b9c3d5b4b", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# If you use either OpenAI or AzureOpenAI, specify the API key here\n", + "os.environ['OPENAI_API_KEY'] = ... # Your OpenAI key here\n", + "\n", + "# If you use AzureOpenAI, specify these environment variables\n", + "os.environ['AZURE_ENDPOINT'] = ... # Format: f\"https://YOUR_ENDPOINT.openai.azure.com\"\n", + "os.environ['AZURE_DEPLOYMENT'] = ... # Your Azure OpenAI deployment here\n", + "os.environ['OPENAI_API_VERSION'] = ...\n", + "os.environ[\"AZURE_OPENAI_KEY\"] = ... # Your Azure OpenAI key here\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fed41214-73da-4c45-8760-55cb36f5ab9f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(filename=\"../static/img/Overview.png\")" + ] + }, + { + "cell_type": "markdown", + "id": "64a27407-67d6-4506-9f84-c0d1f6c752eb", + "metadata": {}, + "source": [ + "## Review Pipeline\n", + "\n", + "The simulation adopts a structured, 5-phase pipeline\n", + "\n", + "* **I. Reviewer Assessment.** Each manuscript is evaluated by three reviewers independently.\n", + "* **II. Author-Reviewer Discussion.** Authors submit rebuttals to address reviewers' concerns;\n", + "* **III. Reviewer-AC Discussion.** The AC facilitates discussions among reviewers, prompting updates to their initial assessments.\n", + "* **IV. Meta-Review Compilation.** The AC synthesizes the discussions into a meta-review.\n", + "* **V. Paper Decision.** The AC makes the final decision on whether to accept or reject the paper, based on all gathered inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f579fe52-2ced-408b-88a1-1b0c5da880f5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "Image(filename=\"../static/img/ReviewPipeline.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "114d4525-3f47-4e2e-b91e-f7513ec4fa0e", + "metadata": {}, + "outputs": [], + "source": [ + "malicious_Rx1_setting = {\n", + " \"AC\": [\n", + " \"BASELINE\"\n", + " ],\n", + "\n", + " \"reviewer\": [\n", + " \"benign\",\n", + " \"BASELINE\",\n", + " \"BASELINE\"\n", + " ],\n", + "\n", + " \"author\": [\n", + " \"BASELINE\"\n", + " ],\n", + " \"global_settings\":{\n", + " \"provides_numeric_rating\": ['reviewer', 'ac'],\n", + " \"persons_aware_of_authors_identities\": []\n", + " }\n", + "}\n", + "\n", + "all_settings = {\"malicious_Rx1\": malicious_Rx1_setting}\n" + ] + }, + { + "cell_type": "markdown", + "id": "9e706786-4e0c-48f8-8d71-e1bbefeb1d8f", + "metadata": {}, + "source": [ + "\n", + "`malicious_Rx1` means 1 reviewer is a malicious reviewer, and the other reviewers are default BASELINE reviewers.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "15ffecd4-4718-492e-b897-a5cceb6f3b6e", + "metadata": {}, + "source": [ + "## Review stages\n", + "\n", + "The peer review process is divided into 5 stages (Section 2 in the paper)\n", + "\n", + "" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e0b7658b-742f-46d7-858a-684f3d8ce8ad", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "os.path.exists(\"../static/img/ReviewPipeline.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ed7cd3a8-bd7a-4c21-bfc7-fc7982a13a0c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/histplots.ipynb b/notebooks/histplots.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..3f3a818c969000a178484f7549d4d997d81b7802 --- /dev/null +++ b/notebooks/histplots.ipynb @@ -0,0 +1 @@ +{"cells":[{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718509993742,"execution_millis":38945,"deepnote_to_be_reexecuted":false,"cell_id":"e4bbe3fdec1d4382801b7a99f34e06e4","deepnote_cell_type":"code"},"source":"!pip install openpyxl SciencePlots\n!sudo apt-get update -y\n!sudo apt-get install dvipng texlive-latex-extra texlive-fonts-recommended cm-super -y\n","block_group":"2977cf134fd84b5ba21da48e7d180e72","execution_count":null,"outputs":[{"name":"stdout","text":"Collecting openpyxl\n Downloading openpyxl-3.1.4-py2.py3-none-any.whl (251 kB)\n\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m251.4/251.4 kB\u001b[0m \u001b[31m12.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n\u001b[?25hCollecting SciencePlots\n Downloading SciencePlots-2.1.1-py3-none-any.whl (16 kB)\nCollecting et-xmlfile\n Downloading et_xmlfile-1.1.0-py3-none-any.whl (4.7 kB)\nRequirement already satisfied: matplotlib in /shared-libs/python3.9/py/lib/python3.9/site-packages (from SciencePlots) (3.6.0)\nRequirement already satisfied: pyparsing>=2.2.1 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (3.0.9)\nRequirement already satisfied: cycler>=0.10 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (0.11.0)\nRequirement already satisfied: contourpy>=1.0.1 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.0.5)\nRequirement already satisfied: packaging>=20.0 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (21.3)\nRequirement already satisfied: python-dateutil>=2.7 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (2.8.2)\nRequirement already satisfied: kiwisolver>=1.0.1 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.4.4)\nRequirement already satisfied: numpy>=1.19 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.23.4)\nRequirement already satisfied: pillow>=6.2.0 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (9.2.0)\nRequirement already satisfied: fonttools>=4.22.0 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (4.37.4)\nRequirement already satisfied: six>=1.5 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib->SciencePlots) (1.16.0)\nInstalling collected packages: et-xmlfile, openpyxl, SciencePlots\nSuccessfully installed SciencePlots-2.1.1 et-xmlfile-1.1.0 openpyxl-3.1.4\n\n\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\nGet:1 http://deb.debian.org/debian buster InRelease [122 kB]\nGet:2 http://deb.debian.org/debian-security buster/updates InRelease [34.8 kB]\nGet:3 http://deb.debian.org/debian buster-updates InRelease [56.6 kB]\nGet:4 http://deb.debian.org/debian buster/main amd64 Packages [7,909 kB]\nGet:5 http://deb.debian.org/debian-security buster/updates/main amd64 Packages [603 kB]\nGet:6 http://deb.debian.org/debian buster-updates/main amd64 Packages [8,788 B]\nFetched 8,734 kB in 1s (7,161 kB/s)\n\n\n\n\nThe following additional packages will be installed:\n cm-super-minimal fonts-droid-fallback fonts-lato fonts-lmodern\n fonts-noto-mono fonts-texgyre ghostscript gsfonts javascript-common\n libauthen-sasl-perl libbrotli1 libcups2 libcupsfilters1 libcupsimage2\n libdata-dump-perl libdrm-amdgpu1 libdrm-common libdrm-intel1 libdrm-nouveau2\n libdrm-radeon1 libdrm2 libencode-locale-perl libfile-basedir-perl\n libfile-desktopentry-perl libfile-listing-perl libfile-mimeinfo-perl\n libfont-afm-perl libfontenc1 libgl1 libgl1-mesa-dri libglapi-mesa libglvnd0\n libglx-mesa0 libglx0 libgs9 libgs9-common libhtml-form-perl\n libhtml-format-perl libhtml-parser-perl libhtml-tagset-perl\n libhtml-tree-perl libhttp-cookies-perl libhttp-daemon-perl libhttp-date-perl\n libhttp-message-perl libhttp-negotiate-perl libidn11 libijs-0.35\n libio-html-perl libio-socket-ssl-perl libio-stringy-perl\n libipc-system-simple-perl libjbig2dec0 libjs-jquery libkpathsea6 liblcms2-2\n libllvm7 liblwp-mediatypes-perl liblwp-protocol-https-perl libmailtools-perl\n libnet-dbus-perl libnet-http-perl libnet-smtp-ssl-perl libnet-ssleay-perl\n libopenjp2-7 libpaper-utils libpaper1 libpciaccess0 libpotrace0 libptexenc1\n libpython-stdlib libpython2-stdlib libpython2.7-minimal libpython2.7-stdlib\n libruby2.5 libsensors-config libsensors5 libsynctex2 libtcl8.6 libteckit0\n libtexlua52 libtexlua53 libtexluajit2 libtext-iconv-perl libtie-ixhash-perl\n libtimedate-perl libtk8.6 libtry-tiny-perl liburi-perl libutempter0 libwoff1\n libwww-perl libwww-robotrules-perl libx11-protocol-perl libx11-xcb1\n libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-shape0\n libxcb-sync1 libxml-parser-perl libxml-twig-perl libxml-xpathengine-perl\n libxmuu1 libxshmfence1 libxss1 libxtst6 libxv1 libxxf86dga1 libxxf86vm1\n libxxhash0 libyaml-0-2 libzzip-0-13 lmodern perl-openssl-defaults\n pfb2t1c2pfb poppler-data preview-latex-style python python-minimal python2\n python2-minimal python2.7 python2.7-minimal rake ruby ruby-did-you-mean\n ruby-minitest ruby-net-telnet ruby-power-assert ruby-test-unit ruby-xmlrpc\n ruby2.5 rubygems-integration t1utils tcl tcl8.6 tex-common tex-gyre\n texlive-base texlive-binaries texlive-latex-base texlive-latex-recommended\n texlive-pictures texlive-plain-generic tipa tk tk8.6 x11-utils\n x11-xserver-utils xbitmaps xdg-utils xfonts-encodings xfonts-utils xterm zip\nSuggested packages:\n fonts-noto ghostscript-x apache2 | lighttpd | httpd libdigest-hmac-perl\n libgssapi-perl cups-common liblcms2-utils libcrypt-ssleay-perl pciutils\n lm-sensors libauthen-ntlm-perl libunicode-map8-perl libunicode-string-perl\n xml-twig-tools poppler-utils fonts-japanese-mincho | fonts-ipafont-mincho\n fonts-japanese-gothic | fonts-ipafont-gothic fonts-arphic-ukai\n fonts-arphic-uming fonts-nanum python-doc python-tk python2-doc\n python2.7-doc binfmt-support ri ruby-dev bundler tcl-tclreadline debhelper\n perl-tk xpdf-reader | pdf-viewer texlive-fonts-recommended-doc\n texlive-latex-base-doc python-pygments icc-profiles libfile-which-perl\n libspreadsheet-parseexcel-perl texlive-latex-extra-doc\n texlive-latex-recommended-doc texlive-pstricks dot2tex prerex ruby-tcltk\n | libtcltk-ruby texlive-pictures-doc vprerex mesa-utils nickle cairo-5c\n xorg-docs-core xfonts-cyrillic\nThe following NEW packages will be installed:\n cm-super cm-super-minimal dvipng fonts-droid-fallback fonts-lato\n fonts-lmodern fonts-noto-mono fonts-texgyre ghostscript gsfonts\n javascript-common libauthen-sasl-perl libbrotli1 libcupsfilters1\n libcupsimage2 libdata-dump-perl libdrm-amdgpu1 libdrm-common libdrm-intel1\n libdrm-nouveau2 libdrm-radeon1 libdrm2 libencode-locale-perl\n libfile-basedir-perl libfile-desktopentry-perl libfile-listing-perl\n libfile-mimeinfo-perl libfont-afm-perl libfontenc1 libgl1 libgl1-mesa-dri\n libglapi-mesa libglvnd0 libglx-mesa0 libglx0 libgs9 libgs9-common\n libhtml-form-perl libhtml-format-perl libhtml-parser-perl\n libhtml-tagset-perl libhtml-tree-perl libhttp-cookies-perl\n libhttp-daemon-perl libhttp-date-perl libhttp-message-perl\n libhttp-negotiate-perl libidn11 libijs-0.35 libio-html-perl\n libio-socket-ssl-perl libio-stringy-perl libipc-system-simple-perl\n libjbig2dec0 libjs-jquery libkpathsea6 liblcms2-2 libllvm7\n liblwp-mediatypes-perl liblwp-protocol-https-perl libmailtools-perl\n libnet-dbus-perl libnet-http-perl libnet-smtp-ssl-perl libnet-ssleay-perl\n libopenjp2-7 libpaper-utils libpaper1 libpciaccess0 libpotrace0 libptexenc1\n libpython-stdlib libpython2-stdlib libpython2.7-minimal libpython2.7-stdlib\n libruby2.5 libsensors-config libsensors5 libsynctex2 libtcl8.6 libteckit0\n libtexlua52 libtexlua53 libtexluajit2 libtext-iconv-perl libtie-ixhash-perl\n libtimedate-perl libtk8.6 libtry-tiny-perl liburi-perl libutempter0 libwoff1\n libwww-perl libwww-robotrules-perl libx11-protocol-perl libx11-xcb1\n libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-shape0\n libxcb-sync1 libxml-parser-perl libxml-twig-perl libxml-xpathengine-perl\n libxmuu1 libxshmfence1 libxss1 libxtst6 libxv1 libxxf86dga1 libxxf86vm1\n libxxhash0 libyaml-0-2 libzzip-0-13 lmodern perl-openssl-defaults\n pfb2t1c2pfb poppler-data preview-latex-style python python-minimal python2\n python2-minimal python2.7 python2.7-minimal rake ruby ruby-did-you-mean\n ruby-minitest ruby-net-telnet ruby-power-assert ruby-test-unit ruby-xmlrpc\n ruby2.5 rubygems-integration t1utils tcl tcl8.6 tex-common tex-gyre\n texlive-base texlive-binaries texlive-fonts-recommended texlive-latex-base\n texlive-latex-extra texlive-latex-recommended texlive-pictures\n texlive-plain-generic tipa tk tk8.6 x11-utils x11-xserver-utils xbitmaps\n xdg-utils xfonts-encodings xfonts-utils xterm zip\nThe following packages will be upgraded:\n libcups2\n1 upgraded, 160 newly installed, 0 to remove and 39 not upgraded.\nNeed to get 212 MB of archives.\nAfter this operation, 798 MB of additional disk space will be used.\nGet:1 http://deb.debian.org/debian-security buster/updates/main amd64 libpython2.7-minimal amd64 2.7.16-2+deb10u4 [396 kB]\nGet:2 http://deb.debian.org/debian-security buster/updates/main amd64 python2.7-minimal amd64 2.7.16-2+deb10u4 [1,367 kB]\nGet:3 http://deb.debian.org/debian buster/main amd64 python2-minimal amd64 2.7.16-1 [41.4 kB]\nGet:4 http://deb.debian.org/debian buster/main amd64 python-minimal amd64 2.7.16-1 [21.0 kB]\nGet:5 http://deb.debian.org/debian-security buster/updates/main amd64 libpython2.7-stdlib amd64 2.7.16-2+deb10u4 [1,912 kB]\nGet:6 http://deb.debian.org/debian-security buster/updates/main amd64 python2.7 amd64 2.7.16-2+deb10u4 [306 kB]\nGet:7 http://deb.debian.org/debian buster/main amd64 libpython2-stdlib amd64 2.7.16-1 [20.8 kB]\nGet:8 http://deb.debian.org/debian buster/main amd64 libpython-stdlib amd64 2.7.16-1 [20.8 kB]\nGet:9 http://deb.debian.org/debian buster/main amd64 python2 amd64 2.7.16-1 [41.6 kB]\nGet:10 http://deb.debian.org/debian buster/main amd64 python amd64 2.7.16-1 [22.8 kB]\nGet:11 http://deb.debian.org/debian buster/main amd64 fonts-droid-fallback all 1:6.0.1r16-1.1 [1,807 kB]\nGet:12 http://deb.debian.org/debian buster/main amd64 fonts-lato all 2.0-2 [2,698 kB]\nGet:13 http://deb.debian.org/debian buster/main amd64 poppler-data all 0.4.9-2 [1,473 kB]\nGet:14 http://deb.debian.org/debian buster/main amd64 tex-common all 6.11 [53.1 kB]\nGet:15 http://deb.debian.org/debian buster/main amd64 libpaper1 amd64 1.1.28 [21.3 kB]\nGet:16 http://deb.debian.org/debian buster/main amd64 libpaper-utils amd64 1.1.28 [18.0 kB]\nGet:17 http://deb.debian.org/debian-security buster/updates/main amd64 libkpathsea6 amd64 2018.20181218.49446-1+deb10u2 [168 kB]\nGet:18 http://deb.debian.org/debian-security buster/updates/main amd64 libptexenc1 amd64 2018.20181218.49446-1+deb10u2 [61.5 kB]\nGet:19 http://deb.debian.org/debian-security buster/updates/main amd64 libsynctex2 amd64 2018.20181218.49446-1+deb10u2 [80.9 kB]\nGet:20 http://deb.debian.org/debian-security buster/updates/main amd64 libtexlua52 amd64 2018.20181218.49446-1+deb10u2 [113 kB]\nGet:21 http://deb.debian.org/debian-security buster/updates/main amd64 libtexlua53 amd64 2018.20181218.49446-1+deb10u2 [126 kB]\nGet:22 http://deb.debian.org/debian-security buster/updates/main amd64 libtexluajit2 amd64 2018.20181218.49446-1+deb10u2 [257 kB]\nGet:23 http://deb.debian.org/debian buster/main amd64 t1utils amd64 1.41-3 [62.3 kB]\nGet:24 http://deb.debian.org/debian buster/main amd64 libbrotli1 amd64 1.0.7-2+deb10u1 [269 kB]\nGet:25 http://deb.debian.org/debian-security buster/updates/main amd64 libgs9-common all 9.27~dfsg-2+deb10u9 [5,137 kB]\nGet:26 http://deb.debian.org/debian-security buster/updates/main amd64 libcups2 amd64 2.2.10-6+deb10u10 [325 kB]\nGet:27 http://deb.debian.org/debian-security buster/updates/main amd64 libcupsimage2 amd64 2.2.10-6+deb10u10 [134 kB]\nGet:28 http://deb.debian.org/debian buster/main amd64 libidn11 amd64 1.33-2.2 [116 kB]\nGet:29 http://deb.debian.org/debian buster/main amd64 libijs-0.35 amd64 0.35-14 [18.3 kB]\nGet:30 http://deb.debian.org/debian buster/main amd64 libjbig2dec0 amd64 0.16-1+deb10u1 [62.2 kB]\nGet:31 http://deb.debian.org/debian buster/main amd64 liblcms2-2 amd64 2.9-3 [145 kB]\nGet:32 http://deb.debian.org/debian buster/main amd64 libopenjp2-7 amd64 2.3.0-2+deb10u2 [158 kB]\nGet:33 http://deb.debian.org/debian-security buster/updates/main amd64 libgs9 amd64 9.27~dfsg-2+deb10u9 [2,199 kB]\nGet:34 http://deb.debian.org/debian buster/main amd64 libpotrace0 amd64 1.15-1 [26.3 kB]\nGet:35 http://deb.debian.org/debian buster/main amd64 libteckit0 amd64 2.5.8+ds2-5 [318 kB]\nGet:36 http://deb.debian.org/debian buster/main amd64 libwoff1 amd64 1.0.2-1 [43.2 kB]\nGet:37 http://deb.debian.org/debian buster/main amd64 libxxhash0 amd64 0.6.5-2 [7,156 B]\nGet:38 http://deb.debian.org/debian buster/main amd64 libzzip-0-13 amd64 0.13.62-3.2+deb10u1 [55.6 kB]\nGet:39 http://deb.debian.org/debian-security buster/updates/main amd64 texlive-binaries amd64 2018.20181218.49446-1+deb10u2 [11.3 MB]\nGet:40 http://deb.debian.org/debian buster/main amd64 xdg-utils all 1.1.3-1+deb10u1 [73.7 kB]\nGet:41 http://deb.debian.org/debian buster/main amd64 texlive-base all 2018.20190227-2 [19.7 MB]\nGet:42 http://deb.debian.org/debian buster/main amd64 fonts-lmodern all 2.004.5-6 [4,539 kB]\nGet:43 http://deb.debian.org/debian buster/main amd64 texlive-latex-base all 2018.20190227-2 [984 kB]\nGet:44 http://deb.debian.org/debian buster/main amd64 texlive-latex-recommended all 2018.20190227-2 [15.2 MB]\nGet:45 http://deb.debian.org/debian buster/main amd64 cm-super-minimal all 0.3.4-14 [5,814 kB]\nGet:46 http://deb.debian.org/debian buster/main amd64 pfb2t1c2pfb amd64 0.3-11 [10.0 kB]\nGet:47 http://deb.debian.org/debian buster/main amd64 cm-super all 0.3.4-14 [18.7 MB]\nGet:48 http://deb.debian.org/debian-security buster/updates/main amd64 ghostscript amd64 9.27~dfsg-2+deb10u9 [95.5 kB]\nGet:49 http://deb.debian.org/debian buster/main amd64 dvipng amd64 1.15-1.1 [87.8 kB]\nGet:50 http://deb.debian.org/debian buster/main amd64 fonts-noto-mono all 20181227-1 [83.1 kB]\nGet:51 http://deb.debian.org/debian buster/main amd64 fonts-texgyre all 20180621-3 [10.2 MB]\nGet:52 http://deb.debian.org/debian buster/main amd64 gsfonts all 1:8.11+urwcyr1.0.7~pre44-4.4 [3,125 kB]\nGet:53 http://deb.debian.org/debian buster/main amd64 javascript-common all 11 [6,120 B]\nGet:54 http://deb.debian.org/debian buster/main amd64 libauthen-sasl-perl all 2.1600-1 [50.8 kB]\nGet:55 http://deb.debian.org/debian-security buster/updates/main amd64 libcupsfilters1 amd64 1.21.6-5+deb10u1 [172 kB]\nGet:56 http://deb.debian.org/debian buster/main amd64 libdata-dump-perl all 1.23-1 [29.5 kB]\nGet:57 http://deb.debian.org/debian buster/main amd64 libdrm-common all 2.4.97-1 [13.8 kB]\nGet:58 http://deb.debian.org/debian buster/main amd64 libdrm2 amd64 2.4.97-1 [39.7 kB]\nGet:59 http://deb.debian.org/debian buster/main amd64 libdrm-amdgpu1 amd64 2.4.97-1 [27.3 kB]\nGet:60 http://deb.debian.org/debian buster/main amd64 libpciaccess0 amd64 0.14-1 [53.5 kB]\nGet:61 http://deb.debian.org/debian buster/main amd64 libdrm-intel1 amd64 2.4.97-1 [69.8 kB]\nGet:62 http://deb.debian.org/debian buster/main amd64 libdrm-nouveau2 amd64 2.4.97-1 [26.3 kB]\nGet:63 http://deb.debian.org/debian buster/main amd64 libdrm-radeon1 amd64 2.4.97-1 [31.1 kB]\nGet:64 http://deb.debian.org/debian buster/main amd64 libencode-locale-perl all 1.05-1 [13.7 kB]\nGet:65 http://deb.debian.org/debian buster/main amd64 libipc-system-simple-perl all 1.25-4 [26.5 kB]\nGet:66 http://deb.debian.org/debian buster/main amd64 libfile-basedir-perl all 0.08-1 [17.7 kB]\nGet:67 http://deb.debian.org/debian buster/main amd64 liburi-perl all 1.76-1 [89.9 kB]\nGet:68 http://deb.debian.org/debian buster/main amd64 libfile-desktopentry-perl all 0.22-1 [19.2 kB]\nGet:69 http://deb.debian.org/debian buster/main amd64 libtimedate-perl all 2.3000-2+deb10u1 [38.1 kB]\nGet:70 http://deb.debian.org/debian buster/main amd64 libhttp-date-perl all 6.02-1 [10.7 kB]\nGet:71 http://deb.debian.org/debian buster/main amd64 libfile-listing-perl all 6.04-1 [10.3 kB]\nGet:72 http://deb.debian.org/debian buster/main amd64 libfile-mimeinfo-perl all 0.29-1 [46.5 kB]\nGet:73 http://deb.debian.org/debian buster/main amd64 libfont-afm-perl all 1.20-2 [13.6 kB]\nGet:74 http://deb.debian.org/debian buster/main amd64 libfontenc1 amd64 1:1.1.3-1+b2 [24.4 kB]\nGet:75 http://deb.debian.org/debian buster/main amd64 libglapi-mesa amd64 18.3.6-2+deb10u1 [66.3 kB]\nGet:76 http://deb.debian.org/debian buster/main amd64 libllvm7 amd64 1:7.0.1-8+deb10u2 [13.1 MB]\nGet:77 http://deb.debian.org/debian buster/main amd64 libsensors-config all 1:3.5.0-3 [31.6 kB]\nGet:78 http://deb.debian.org/debian buster/main amd64 libsensors5 amd64 1:3.5.0-3 [52.6 kB]\nGet:79 http://deb.debian.org/debian buster/main amd64 libgl1-mesa-dri amd64 18.3.6-2+deb10u1 [6,685 kB]\nGet:80 http://deb.debian.org/debian buster/main amd64 libglvnd0 amd64 1.1.0-1 [48.6 kB]\nGet:81 http://deb.debian.org/debian-security buster/updates/main amd64 libx11-xcb1 amd64 2:1.6.7-1+deb10u4 [191 kB]\nGet:82 http://deb.debian.org/debian buster/main amd64 libxcb-dri2-0 amd64 1.13.1-2 [101 kB]\nGet:83 http://deb.debian.org/debian buster/main amd64 libxcb-dri3-0 amd64 1.13.1-2 [100 kB]\nGet:84 http://deb.debian.org/debian buster/main amd64 libxcb-glx0 amd64 1.13.1-2 [116 kB]\nGet:85 http://deb.debian.org/debian buster/main amd64 libxcb-present0 amd64 1.13.1-2 [99.1 kB]\nGet:86 http://deb.debian.org/debian buster/main amd64 libxcb-sync1 amd64 1.13.1-2 [103 kB]\nGet:87 http://deb.debian.org/debian buster/main amd64 libxshmfence1 amd64 1.3-1 [8,820 B]\nGet:88 http://deb.debian.org/debian buster/main amd64 libxxf86vm1 amd64 1:1.1.4-1+b2 [20.8 kB]\nGet:89 http://deb.debian.org/debian buster/main amd64 libglx-mesa0 amd64 18.3.6-2+deb10u1 [180 kB]\nGet:90 http://deb.debian.org/debian buster/main amd64 libhtml-tagset-perl all 3.20-3 [12.7 kB]\nGet:91 http://deb.debian.org/debian buster/main amd64 libhtml-parser-perl amd64 3.72-3+b3 [105 kB]\nGet:92 http://deb.debian.org/debian buster/main amd64 libio-html-perl all 1.001-1 [17.6 kB]\nGet:93 http://deb.debian.org/debian buster/main amd64 liblwp-mediatypes-perl all 6.02-1 [22.1 kB]\nGet:94 http://deb.debian.org/debian buster/main amd64 libhttp-message-perl all 6.18-1 [77.8 kB]\nGet:95 http://deb.debian.org/debian buster/main amd64 libhtml-form-perl all 6.03-1 [23.9 kB]\nGet:96 http://deb.debian.org/debian buster/main amd64 libhtml-tree-perl all 5.07-2 [213 kB]\nGet:97 http://deb.debian.org/debian buster/main amd64 libhtml-format-perl all 2.12-1 [43.5 kB]\nGet:98 http://deb.debian.org/debian buster/main amd64 libhttp-cookies-perl all 6.04-1 [17.8 kB]\nGet:99 http://deb.debian.org/debian-security buster/updates/main amd64 libhttp-daemon-perl all 6.01-3+deb10u1 [17.1 kB]\nGet:100 http://deb.debian.org/debian buster/main amd64 libhttp-negotiate-perl all 6.01-1 [12.8 kB]\nGet:101 http://deb.debian.org/debian buster/main amd64 perl-openssl-defaults amd64 3 [6,782 B]\nGet:102 http://deb.debian.org/debian buster/main amd64 libnet-ssleay-perl amd64 1.85-2+deb10u1 [308 kB]\nGet:103 http://deb.debian.org/debian buster/main amd64 libio-socket-ssl-perl all 2.060-3 [207 kB]\nGet:104 http://deb.debian.org/debian buster/main amd64 libio-stringy-perl all 2.111-3 [56.5 kB]\nGet:105 http://deb.debian.org/debian buster/main amd64 libjs-jquery all 3.3.1~dfsg-3+deb10u1 [332 kB]\nGet:106 http://deb.debian.org/debian buster/main amd64 libnet-http-perl all 6.18-1 [24.5 kB]\nGet:107 http://deb.debian.org/debian buster/main amd64 libtry-tiny-perl all 0.30-1 [23.3 kB]\nGet:108 http://deb.debian.org/debian buster/main amd64 libwww-robotrules-perl all 6.02-1 [12.9 kB]\nGet:109 http://deb.debian.org/debian buster/main amd64 libwww-perl all 6.36-2 [188 kB]\nGet:110 http://deb.debian.org/debian buster/main amd64 liblwp-protocol-https-perl all 6.07-2 [9,242 B]\nGet:111 http://deb.debian.org/debian buster/main amd64 libnet-smtp-ssl-perl all 1.04-1 [6,184 B]\nGet:112 http://deb.debian.org/debian buster/main amd64 libmailtools-perl all 2.18-1 [88.5 kB]\nGet:113 http://deb.debian.org/debian buster/main amd64 libxml-parser-perl amd64 2.44-4 [213 kB]\nGet:114 http://deb.debian.org/debian buster/main amd64 libxml-twig-perl all 1:3.50-1.1 [179 kB]\nGet:115 http://deb.debian.org/debian buster/main amd64 libnet-dbus-perl amd64 1.1.0-5+b1 [181 kB]\nGet:116 http://deb.debian.org/debian buster/main amd64 rubygems-integration all 1.11+deb10u1 [5,212 B]\nGet:117 http://deb.debian.org/debian-security buster/updates/main amd64 ruby2.5 amd64 2.5.5-3+deb10u6 [401 kB]\nGet:118 http://deb.debian.org/debian buster/main amd64 ruby amd64 1:2.5.1 [11.3 kB]\nGet:119 http://deb.debian.org/debian buster/main amd64 rake all 12.3.1-3+deb10u1 [67.1 kB]\nGet:120 http://deb.debian.org/debian buster/main amd64 ruby-did-you-mean all 1.2.1-1 [14.4 kB]\nGet:121 http://deb.debian.org/debian buster/main amd64 ruby-minitest all 5.11.3-1 [54.8 kB]\nGet:122 http://deb.debian.org/debian buster/main amd64 ruby-net-telnet all 0.1.1-2 [12.5 kB]\nGet:123 http://deb.debian.org/debian buster/main amd64 ruby-power-assert all 1.1.1-1 [10.9 kB]\nGet:124 http://deb.debian.org/debian buster/main amd64 ruby-test-unit all 3.2.8-1 [72.4 kB]\nGet:125 http://deb.debian.org/debian buster/main amd64 ruby-xmlrpc all 0.3.0-2 [23.7 kB]\nGet:126 http://deb.debian.org/debian buster/main amd64 libyaml-0-2 amd64 0.2.1-1 [47.2 kB]\nGet:127 http://deb.debian.org/debian-security buster/updates/main amd64 libruby2.5 amd64 2.5.5-3+deb10u6 [3,442 kB]\nGet:128 http://deb.debian.org/debian buster/main amd64 libtcl8.6 amd64 8.6.9+dfsg-2 [1,005 kB]\nGet:129 http://deb.debian.org/debian buster/main amd64 libtext-iconv-perl amd64 1.7-5+b7 [15.4 kB]\nGet:130 http://deb.debian.org/debian buster/main amd64 libtie-ixhash-perl all 1.23-2 [11.7 kB]\nGet:131 http://deb.debian.org/debian buster/main amd64 libxss1 amd64 1:1.2.3-1 [17.8 kB]\nGet:132 http://deb.debian.org/debian buster/main amd64 libtk8.6 amd64 8.6.9-2 [768 kB]\nGet:133 http://deb.debian.org/debian buster/main amd64 libutempter0 amd64 1.1.6-3 [7,812 B]\nGet:134 http://deb.debian.org/debian buster/main amd64 libx11-protocol-perl all 0.56-7 [150 kB]\nGet:135 http://deb.debian.org/debian buster/main amd64 libxcb-shape0 amd64 1.13.1-2 [99.5 kB]\nGet:136 http://deb.debian.org/debian buster/main amd64 libxml-xpathengine-perl all 0.14-1 [33.3 kB]\nGet:137 http://deb.debian.org/debian buster/main amd64 libxmuu1 amd64 2:1.1.2-2+b3 [23.9 kB]\nGet:138 http://deb.debian.org/debian buster/main amd64 libxtst6 amd64 2:1.2.3-1 [27.8 kB]\nGet:139 http://deb.debian.org/debian buster/main amd64 libxv1 amd64 2:1.0.11-1 [24.6 kB]\nGet:140 http://deb.debian.org/debian buster/main amd64 libxxf86dga1 amd64 2:1.1.4-1+b3 [22.1 kB]\nGet:141 http://deb.debian.org/debian buster/main amd64 xfonts-encodings all 1:1.0.4-2 [574 kB]\nGet:142 http://deb.debian.org/debian buster/main amd64 xfonts-utils amd64 1:7.7+6 [93.0 kB]\nGet:143 http://deb.debian.org/debian buster/main amd64 lmodern all 2.004.5-6 [9,488 kB]\nGet:144 http://deb.debian.org/debian buster/main amd64 preview-latex-style all 11.91-2 [201 kB]\nGet:145 http://deb.debian.org/debian buster/main amd64 tcl8.6 amd64 8.6.9+dfsg-2 [123 kB]\nGet:146 http://deb.debian.org/debian buster/main amd64 tcl amd64 8.6.9+1 [5,636 B]\nGet:147 http://deb.debian.org/debian buster/main amd64 tex-gyre all 20180621-3 [6,210 kB]\nGet:148 http://deb.debian.org/debian buster/main amd64 texlive-fonts-recommended all 2018.20190227-2 [5,228 kB]\nGet:149 http://deb.debian.org/debian buster/main amd64 texlive-pictures all 2018.20190227-2 [8,201 kB]\nGet:150 http://deb.debian.org/debian buster/main amd64 texlive-latex-extra all 2018.20190227-2 [12.3 MB]\nGet:151 http://deb.debian.org/debian buster/main amd64 texlive-plain-generic all 2018.20190227-2 [24.3 MB]\nGet:152 http://deb.debian.org/debian buster/main amd64 tipa all 2:1.3-20 [2,972 kB]\nGet:153 http://deb.debian.org/debian buster/main amd64 tk8.6 amd64 8.6.9-2 [72.1 kB]\nGet:154 http://deb.debian.org/debian buster/main amd64 tk amd64 8.6.9+1 [5,676 B]\nGet:155 http://deb.debian.org/debian buster/main amd64 libglx0 amd64 1.1.0-1 [30.0 kB]\nGet:156 http://deb.debian.org/debian buster/main amd64 libgl1 amd64 1.1.0-1 [91.1 kB]\nGet:157 http://deb.debian.org/debian buster/main amd64 x11-utils amd64 7.7+4 [202 kB]\nGet:158 http://deb.debian.org/debian buster/main amd64 x11-xserver-utils amd64 7.7+8 [168 kB]\nGet:159 http://deb.debian.org/debian buster/main amd64 xbitmaps all 1.1.1-2 [32.1 kB]\nGet:160 http://deb.debian.org/debian buster/main amd64 xterm amd64 344-1+deb10u2 [771 kB]\nGet:161 http://deb.debian.org/debian buster/main amd64 zip amd64 3.0-11+b1 [234 kB]\nFetched 212 MB in 2s (132 MB/s)\ndebconf: delaying package configuration, since apt-utils is not installed\nSelecting previously unselected package libpython2.7-minimal:amd64.\n(Reading database ... 31092 files and directories currently installed.)\nPreparing to unpack .../0-libpython2.7-minimal_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking libpython2.7-minimal:amd64 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2.7-minimal.\nPreparing to unpack .../1-python2.7-minimal_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking python2.7-minimal (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2-minimal.\nPreparing to unpack .../2-python2-minimal_2.7.16-1_amd64.deb ...\nUnpacking python2-minimal (2.7.16-1) ...\nSelecting previously unselected package python-minimal.\nPreparing to unpack .../3-python-minimal_2.7.16-1_amd64.deb ...\nUnpacking python-minimal (2.7.16-1) ...\nSelecting previously unselected package libpython2.7-stdlib:amd64.\nPreparing to unpack .../4-libpython2.7-stdlib_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking libpython2.7-stdlib:amd64 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2.7.\nPreparing to unpack .../5-python2.7_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking python2.7 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package libpython2-stdlib:amd64.\nPreparing to unpack .../6-libpython2-stdlib_2.7.16-1_amd64.deb ...\nUnpacking libpython2-stdlib:amd64 (2.7.16-1) ...\nSelecting previously unselected package libpython-stdlib:amd64.\nPreparing to unpack .../7-libpython-stdlib_2.7.16-1_amd64.deb ...\nUnpacking libpython-stdlib:amd64 (2.7.16-1) ...\nSetting up libpython2.7-minimal:amd64 (2.7.16-2+deb10u4) ...\nSetting up python2.7-minimal (2.7.16-2+deb10u4) ...\nLinking and byte-compiling packages for runtime python2.7...\nSetting up python2-minimal (2.7.16-1) ...\nSelecting previously unselected package python2.\n(Reading database ... 31851 files and directories currently installed.)\nPreparing to unpack .../python2_2.7.16-1_amd64.deb ...\nUnpacking python2 (2.7.16-1) ...\nSetting up python-minimal (2.7.16-1) ...\nSelecting previously unselected package python.\n(Reading database ... 31883 files and directories currently installed.)\nPreparing to unpack .../000-python_2.7.16-1_amd64.deb ...\nUnpacking python (2.7.16-1) ...\nSelecting previously unselected package fonts-droid-fallback.\nPreparing to unpack .../001-fonts-droid-fallback_1%3a6.0.1r16-1.1_all.deb ...\nUnpacking fonts-droid-fallback (1:6.0.1r16-1.1) ...\nSelecting previously unselected package fonts-lato.\nPreparing to unpack .../002-fonts-lato_2.0-2_all.deb ...\nUnpacking fonts-lato (2.0-2) ...\nSelecting previously unselected package poppler-data.\nPreparing to unpack .../003-poppler-data_0.4.9-2_all.deb ...\nUnpacking poppler-data (0.4.9-2) ...\nSelecting previously unselected package tex-common.\nPreparing to unpack .../004-tex-common_6.11_all.deb ...\nUnpacking tex-common (6.11) ...\nSelecting previously unselected package libpaper1:amd64.\nPreparing to unpack .../005-libpaper1_1.1.28_amd64.deb ...\nUnpacking libpaper1:amd64 (1.1.28) ...\nSelecting previously unselected package libpaper-utils.\nPreparing to unpack .../006-libpaper-utils_1.1.28_amd64.deb ...\nUnpacking libpaper-utils (1.1.28) ...\nSelecting previously unselected package libkpathsea6:amd64.\nPreparing to unpack .../007-libkpathsea6_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libkpathsea6:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libptexenc1:amd64.\nPreparing to unpack .../008-libptexenc1_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libptexenc1:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libsynctex2:amd64.\nPreparing to unpack .../009-libsynctex2_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libsynctex2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexlua52:amd64.\nPreparing to unpack .../010-libtexlua52_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexlua52:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexlua53:amd64.\nPreparing to unpack .../011-libtexlua53_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexlua53:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexluajit2:amd64.\nPreparing to unpack .../012-libtexluajit2_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexluajit2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package t1utils.\nPreparing to unpack .../013-t1utils_1.41-3_amd64.deb ...\nUnpacking t1utils (1.41-3) ...\nSelecting previously unselected package libbrotli1:amd64.\nPreparing to unpack .../014-libbrotli1_1.0.7-2+deb10u1_amd64.deb ...\nUnpacking libbrotli1:amd64 (1.0.7-2+deb10u1) ...\nSelecting previously unselected package libgs9-common.\nPreparing to unpack .../015-libgs9-common_9.27~dfsg-2+deb10u9_all.deb ...\nUnpacking libgs9-common (9.27~dfsg-2+deb10u9) ...\nPreparing to unpack .../016-libcups2_2.2.10-6+deb10u10_amd64.deb ...\nUnpacking libcups2:amd64 (2.2.10-6+deb10u10) over (2.2.10-6+deb10u9) ...\nSelecting previously unselected package libcupsimage2:amd64.\nPreparing to unpack .../017-libcupsimage2_2.2.10-6+deb10u10_amd64.deb ...\nUnpacking libcupsimage2:amd64 (2.2.10-6+deb10u10) ...\nSelecting previously unselected package libidn11:amd64.\nPreparing to unpack .../018-libidn11_1.33-2.2_amd64.deb ...\nUnpacking libidn11:amd64 (1.33-2.2) ...\nSelecting previously unselected package libijs-0.35:amd64.\nPreparing to unpack .../019-libijs-0.35_0.35-14_amd64.deb ...\nUnpacking libijs-0.35:amd64 (0.35-14) ...\nSelecting previously unselected package libjbig2dec0:amd64.\nPreparing to unpack .../020-libjbig2dec0_0.16-1+deb10u1_amd64.deb ...\nUnpacking libjbig2dec0:amd64 (0.16-1+deb10u1) ...\nSelecting previously unselected package liblcms2-2:amd64.\nPreparing to unpack .../021-liblcms2-2_2.9-3_amd64.deb ...\nUnpacking liblcms2-2:amd64 (2.9-3) ...\nSelecting previously unselected package libopenjp2-7:amd64.\nPreparing to unpack .../022-libopenjp2-7_2.3.0-2+deb10u2_amd64.deb ...\nUnpacking libopenjp2-7:amd64 (2.3.0-2+deb10u2) ...\nSelecting previously unselected package libgs9:amd64.\nPreparing to unpack .../023-libgs9_9.27~dfsg-2+deb10u9_amd64.deb ...\nUnpacking libgs9:amd64 (9.27~dfsg-2+deb10u9) ...\nSelecting previously unselected package libpotrace0:amd64.\nPreparing to unpack .../024-libpotrace0_1.15-1_amd64.deb ...\nUnpacking libpotrace0:amd64 (1.15-1) ...\nSelecting previously unselected package libteckit0:amd64.\nPreparing to unpack .../025-libteckit0_2.5.8+ds2-5_amd64.deb ...\nUnpacking libteckit0:amd64 (2.5.8+ds2-5) ...\nSelecting previously unselected package libwoff1:amd64.\nPreparing to unpack .../026-libwoff1_1.0.2-1_amd64.deb ...\nUnpacking libwoff1:amd64 (1.0.2-1) ...\nSelecting previously unselected package libxxhash0:amd64.\nPreparing to unpack .../027-libxxhash0_0.6.5-2_amd64.deb ...\nUnpacking libxxhash0:amd64 (0.6.5-2) ...\nSelecting previously unselected package libzzip-0-13:amd64.\nPreparing to unpack .../028-libzzip-0-13_0.13.62-3.2+deb10u1_amd64.deb ...\nUnpacking libzzip-0-13:amd64 (0.13.62-3.2+deb10u1) ...\nSelecting previously unselected package texlive-binaries.\nPreparing to unpack .../029-texlive-binaries_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking texlive-binaries (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package xdg-utils.\nPreparing to unpack .../030-xdg-utils_1.1.3-1+deb10u1_all.deb ...\nUnpacking xdg-utils (1.1.3-1+deb10u1) ...\nSelecting previously unselected package texlive-base.\nPreparing to unpack .../031-texlive-base_2018.20190227-2_all.deb ...\nUnpacking texlive-base (2018.20190227-2) ...\nSelecting previously unselected package fonts-lmodern.\nPreparing to unpack .../032-fonts-lmodern_2.004.5-6_all.deb ...\nUnpacking fonts-lmodern (2.004.5-6) ...\nSelecting previously unselected package texlive-latex-base.\nPreparing to unpack .../033-texlive-latex-base_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-base (2018.20190227-2) ...\nSelecting previously unselected package texlive-latex-recommended.\nPreparing to unpack .../034-texlive-latex-recommended_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-recommended (2018.20190227-2) ...\nSelecting previously unselected package cm-super-minimal.\nPreparing to unpack .../035-cm-super-minimal_0.3.4-14_all.deb ...\nUnpacking cm-super-minimal (0.3.4-14) ...\nSelecting previously unselected package pfb2t1c2pfb.\nPreparing to unpack .../036-pfb2t1c2pfb_0.3-11_amd64.deb ...\nUnpacking pfb2t1c2pfb (0.3-11) ...\nSelecting previously unselected package cm-super.\nPreparing to unpack .../037-cm-super_0.3.4-14_all.deb ...\nUnpacking cm-super (0.3.4-14) ...\nSelecting previously unselected package ghostscript.\nPreparing to unpack .../038-ghostscript_9.27~dfsg-2+deb10u9_amd64.deb ...\nUnpacking ghostscript (9.27~dfsg-2+deb10u9) ...\nSelecting previously unselected package dvipng.\nPreparing to unpack .../039-dvipng_1.15-1.1_amd64.deb ...\nUnpacking dvipng (1.15-1.1) ...\nSelecting previously unselected package fonts-noto-mono.\nPreparing to unpack .../040-fonts-noto-mono_20181227-1_all.deb ...\nUnpacking fonts-noto-mono (20181227-1) ...\nSelecting previously unselected package fonts-texgyre.\nPreparing to unpack .../041-fonts-texgyre_20180621-3_all.deb ...\nUnpacking fonts-texgyre (20180621-3) ...\nSelecting previously unselected package gsfonts.\nPreparing to unpack .../042-gsfonts_1%3a8.11+urwcyr1.0.7~pre44-4.4_all.deb ...\nUnpacking gsfonts (1:8.11+urwcyr1.0.7~pre44-4.4) ...\nSelecting previously unselected package javascript-common.\nPreparing to unpack .../043-javascript-common_11_all.deb ...\nUnpacking javascript-common (11) ...\nSelecting previously unselected package libauthen-sasl-perl.\nPreparing to unpack .../044-libauthen-sasl-perl_2.1600-1_all.deb ...\nUnpacking libauthen-sasl-perl (2.1600-1) ...\nSelecting previously unselected package libcupsfilters1:amd64.\nPreparing to unpack .../045-libcupsfilters1_1.21.6-5+deb10u1_amd64.deb ...\nUnpacking libcupsfilters1:amd64 (1.21.6-5+deb10u1) ...\nSelecting previously unselected package libdata-dump-perl.\nPreparing to unpack .../046-libdata-dump-perl_1.23-1_all.deb ...\nUnpacking libdata-dump-perl (1.23-1) ...\nSelecting previously unselected package libdrm-common.\nPreparing to unpack .../047-libdrm-common_2.4.97-1_all.deb ...\nUnpacking libdrm-common (2.4.97-1) ...\nSelecting previously unselected package libdrm2:amd64.\nPreparing to unpack .../048-libdrm2_2.4.97-1_amd64.deb ...\nUnpacking libdrm2:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-amdgpu1:amd64.\nPreparing to unpack .../049-libdrm-amdgpu1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-amdgpu1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libpciaccess0:amd64.\nPreparing to unpack .../050-libpciaccess0_0.14-1_amd64.deb ...\nUnpacking libpciaccess0:amd64 (0.14-1) ...\nSelecting previously unselected package libdrm-intel1:amd64.\nPreparing to unpack .../051-libdrm-intel1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-intel1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-nouveau2:amd64.\nPreparing to unpack .../052-libdrm-nouveau2_2.4.97-1_amd64.deb ...\nUnpacking libdrm-nouveau2:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-radeon1:amd64.\nPreparing to unpack .../053-libdrm-radeon1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-radeon1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libencode-locale-perl.\nPreparing to unpack .../054-libencode-locale-perl_1.05-1_all.deb ...\nUnpacking libencode-locale-perl (1.05-1) ...\nSelecting previously unselected package libipc-system-simple-perl.\nPreparing to unpack .../055-libipc-system-simple-perl_1.25-4_all.deb ...\nUnpacking libipc-system-simple-perl (1.25-4) ...\nSelecting previously unselected package libfile-basedir-perl.\nPreparing to unpack .../056-libfile-basedir-perl_0.08-1_all.deb ...\nUnpacking libfile-basedir-perl (0.08-1) ...\nSelecting previously unselected package liburi-perl.\nPreparing to unpack .../057-liburi-perl_1.76-1_all.deb ...\nUnpacking liburi-perl (1.76-1) ...\nSelecting previously unselected package libfile-desktopentry-perl.\nPreparing to unpack .../058-libfile-desktopentry-perl_0.22-1_all.deb ...\nUnpacking libfile-desktopentry-perl (0.22-1) ...\nSelecting previously unselected package libtimedate-perl.\nPreparing to unpack .../059-libtimedate-perl_2.3000-2+deb10u1_all.deb ...\nUnpacking libtimedate-perl (2.3000-2+deb10u1) ...\nSelecting previously unselected package libhttp-date-perl.\nPreparing to unpack .../060-libhttp-date-perl_6.02-1_all.deb ...\nUnpacking libhttp-date-perl (6.02-1) ...\nSelecting previously unselected package libfile-listing-perl.\nPreparing to unpack .../061-libfile-listing-perl_6.04-1_all.deb ...\nUnpacking libfile-listing-perl (6.04-1) ...\nSelecting previously unselected package libfile-mimeinfo-perl.\nPreparing to unpack .../062-libfile-mimeinfo-perl_0.29-1_all.deb ...\nUnpacking libfile-mimeinfo-perl (0.29-1) ...\nSelecting previously unselected package libfont-afm-perl.\nPreparing to unpack .../063-libfont-afm-perl_1.20-2_all.deb ...\nUnpacking libfont-afm-perl (1.20-2) ...\nSelecting previously unselected package libfontenc1:amd64.\nPreparing to unpack .../064-libfontenc1_1%3a1.1.3-1+b2_amd64.deb ...\nUnpacking libfontenc1:amd64 (1:1.1.3-1+b2) ...\nSelecting previously unselected package libglapi-mesa:amd64.\nPreparing to unpack .../065-libglapi-mesa_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libglapi-mesa:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libllvm7:amd64.\nPreparing to unpack .../066-libllvm7_1%3a7.0.1-8+deb10u2_amd64.deb ...\nUnpacking libllvm7:amd64 (1:7.0.1-8+deb10u2) ...\nSelecting previously unselected package libsensors-config.\nPreparing to unpack .../067-libsensors-config_1%3a3.5.0-3_all.deb ...\nUnpacking libsensors-config (1:3.5.0-3) ...\nSelecting previously unselected package libsensors5:amd64.\nPreparing to unpack .../068-libsensors5_1%3a3.5.0-3_amd64.deb ...\nUnpacking libsensors5:amd64 (1:3.5.0-3) ...\nSelecting previously unselected package libgl1-mesa-dri:amd64.\nPreparing to unpack .../069-libgl1-mesa-dri_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libgl1-mesa-dri:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libglvnd0:amd64.\nPreparing to unpack .../070-libglvnd0_1.1.0-1_amd64.deb ...\nUnpacking libglvnd0:amd64 (1.1.0-1) ...\nSelecting previously unselected package libx11-xcb1:amd64.\nPreparing to unpack .../071-libx11-xcb1_2%3a1.6.7-1+deb10u4_amd64.deb ...\nUnpacking libx11-xcb1:amd64 (2:1.6.7-1+deb10u4) ...\nSelecting previously unselected package libxcb-dri2-0:amd64.\nPreparing to unpack .../072-libxcb-dri2-0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-dri2-0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-dri3-0:amd64.\nPreparing to unpack .../073-libxcb-dri3-0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-dri3-0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-glx0:amd64.\nPreparing to unpack .../074-libxcb-glx0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-glx0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-present0:amd64.\nPreparing to unpack .../075-libxcb-present0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-present0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-sync1:amd64.\nPreparing to unpack .../076-libxcb-sync1_1.13.1-2_amd64.deb ...\nUnpacking libxcb-sync1:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxshmfence1:amd64.\nPreparing to unpack .../077-libxshmfence1_1.3-1_amd64.deb ...\nUnpacking libxshmfence1:amd64 (1.3-1) ...\nSelecting previously unselected package libxxf86vm1:amd64.\nPreparing to unpack .../078-libxxf86vm1_1%3a1.1.4-1+b2_amd64.deb ...\nUnpacking libxxf86vm1:amd64 (1:1.1.4-1+b2) ...\nSelecting previously unselected package libglx-mesa0:amd64.\nPreparing to unpack .../079-libglx-mesa0_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libglx-mesa0:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libhtml-tagset-perl.\nPreparing to unpack .../080-libhtml-tagset-perl_3.20-3_all.deb ...\nUnpacking libhtml-tagset-perl (3.20-3) ...\nSelecting previously unselected package libhtml-parser-perl.\nPreparing to unpack .../081-libhtml-parser-perl_3.72-3+b3_amd64.deb ...\nUnpacking libhtml-parser-perl (3.72-3+b3) ...\nSelecting previously unselected package libio-html-perl.\nPreparing to unpack .../082-libio-html-perl_1.001-1_all.deb ...\nUnpacking libio-html-perl (1.001-1) ...\nSelecting previously unselected package liblwp-mediatypes-perl.\nPreparing to unpack .../083-liblwp-mediatypes-perl_6.02-1_all.deb ...\nUnpacking liblwp-mediatypes-perl (6.02-1) ...\nSelecting previously unselected package libhttp-message-perl.\nPreparing to unpack .../084-libhttp-message-perl_6.18-1_all.deb ...\nUnpacking libhttp-message-perl (6.18-1) ...\nSelecting previously unselected package libhtml-form-perl.\nPreparing to unpack .../085-libhtml-form-perl_6.03-1_all.deb ...\nUnpacking libhtml-form-perl (6.03-1) ...\nSelecting previously unselected package libhtml-tree-perl.\nPreparing to unpack .../086-libhtml-tree-perl_5.07-2_all.deb ...\nUnpacking libhtml-tree-perl (5.07-2) ...\nSelecting previously unselected package libhtml-format-perl.\nPreparing to unpack .../087-libhtml-format-perl_2.12-1_all.deb ...\nUnpacking libhtml-format-perl (2.12-1) ...\nSelecting previously unselected package libhttp-cookies-perl.\nPreparing to unpack .../088-libhttp-cookies-perl_6.04-1_all.deb ...\nUnpacking libhttp-cookies-perl (6.04-1) ...\nSelecting previously unselected package libhttp-daemon-perl.\nPreparing to unpack .../089-libhttp-daemon-perl_6.01-3+deb10u1_all.deb ...\nUnpacking libhttp-daemon-perl (6.01-3+deb10u1) ...\nSelecting previously unselected package libhttp-negotiate-perl.\nPreparing to unpack .../090-libhttp-negotiate-perl_6.01-1_all.deb ...\nUnpacking libhttp-negotiate-perl (6.01-1) ...\nSelecting previously unselected package perl-openssl-defaults:amd64.\nPreparing to unpack .../091-perl-openssl-defaults_3_amd64.deb ...\nUnpacking perl-openssl-defaults:amd64 (3) ...\nSelecting previously unselected package libnet-ssleay-perl.\nPreparing to unpack .../092-libnet-ssleay-perl_1.85-2+deb10u1_amd64.deb ...\nUnpacking libnet-ssleay-perl (1.85-2+deb10u1) ...\nSelecting previously unselected package libio-socket-ssl-perl.\nPreparing to unpack .../093-libio-socket-ssl-perl_2.060-3_all.deb ...\nUnpacking libio-socket-ssl-perl (2.060-3) ...\nSelecting previously unselected package libio-stringy-perl.\nPreparing to unpack .../094-libio-stringy-perl_2.111-3_all.deb ...\nUnpacking libio-stringy-perl (2.111-3) ...\nSelecting previously unselected package libjs-jquery.\nPreparing to unpack .../095-libjs-jquery_3.3.1~dfsg-3+deb10u1_all.deb ...\nUnpacking libjs-jquery (3.3.1~dfsg-3+deb10u1) ...\nSelecting previously unselected package libnet-http-perl.\nPreparing to unpack .../096-libnet-http-perl_6.18-1_all.deb ...\nUnpacking libnet-http-perl (6.18-1) ...\nSelecting previously unselected package libtry-tiny-perl.\nPreparing to unpack .../097-libtry-tiny-perl_0.30-1_all.deb ...\nUnpacking libtry-tiny-perl (0.30-1) ...\nSelecting previously unselected package libwww-robotrules-perl.\nPreparing to unpack .../098-libwww-robotrules-perl_6.02-1_all.deb ...\nUnpacking libwww-robotrules-perl (6.02-1) ...\nSelecting previously unselected package libwww-perl.\nPreparing to unpack .../099-libwww-perl_6.36-2_all.deb ...\nUnpacking libwww-perl (6.36-2) ...\nSelecting previously unselected package liblwp-protocol-https-perl.\nPreparing to unpack .../100-liblwp-protocol-https-perl_6.07-2_all.deb ...\nUnpacking liblwp-protocol-https-perl (6.07-2) ...\nSelecting previously unselected package libnet-smtp-ssl-perl.\nPreparing to unpack .../101-libnet-smtp-ssl-perl_1.04-1_all.deb ...\nUnpacking libnet-smtp-ssl-perl (1.04-1) ...\nSelecting previously unselected package libmailtools-perl.\nPreparing to unpack .../102-libmailtools-perl_2.18-1_all.deb ...\nUnpacking libmailtools-perl (2.18-1) ...\nSelecting previously unselected package libxml-parser-perl.\nPreparing to unpack .../103-libxml-parser-perl_2.44-4_amd64.deb ...\nUnpacking libxml-parser-perl (2.44-4) ...\nSelecting previously unselected package libxml-twig-perl.\nPreparing to unpack .../104-libxml-twig-perl_1%3a3.50-1.1_all.deb ...\nUnpacking libxml-twig-perl (1:3.50-1.1) ...\nSelecting previously unselected package libnet-dbus-perl.\nPreparing to unpack .../105-libnet-dbus-perl_1.1.0-5+b1_amd64.deb ...\nUnpacking libnet-dbus-perl (1.1.0-5+b1) ...\nSelecting previously unselected package rubygems-integration.\nPreparing to unpack .../106-rubygems-integration_1.11+deb10u1_all.deb ...\nUnpacking rubygems-integration (1.11+deb10u1) ...\nSelecting previously unselected package ruby2.5.\nPreparing to unpack .../107-ruby2.5_2.5.5-3+deb10u6_amd64.deb ...\nUnpacking ruby2.5 (2.5.5-3+deb10u6) ...\nSelecting previously unselected package ruby.\nPreparing to unpack .../108-ruby_1%3a2.5.1_amd64.deb ...\nUnpacking ruby (1:2.5.1) ...\nSelecting previously unselected package rake.\nPreparing to unpack .../109-rake_12.3.1-3+deb10u1_all.deb ...\nUnpacking rake (12.3.1-3+deb10u1) ...\nSelecting previously unselected package ruby-did-you-mean.\nPreparing to unpack .../110-ruby-did-you-mean_1.2.1-1_all.deb ...\nUnpacking ruby-did-you-mean (1.2.1-1) ...\nSelecting previously unselected package ruby-minitest.\nPreparing to unpack .../111-ruby-minitest_5.11.3-1_all.deb ...\nUnpacking ruby-minitest (5.11.3-1) ...\nSelecting previously unselected package ruby-net-telnet.\nPreparing to unpack .../112-ruby-net-telnet_0.1.1-2_all.deb ...\nUnpacking ruby-net-telnet (0.1.1-2) ...\nSelecting previously unselected package ruby-power-assert.\nPreparing to unpack .../113-ruby-power-assert_1.1.1-1_all.deb ...\nUnpacking ruby-power-assert (1.1.1-1) ...\nSelecting previously unselected package ruby-test-unit.\nPreparing to unpack .../114-ruby-test-unit_3.2.8-1_all.deb ...\nUnpacking ruby-test-unit (3.2.8-1) ...\nSelecting previously unselected package ruby-xmlrpc.\nPreparing to unpack .../115-ruby-xmlrpc_0.3.0-2_all.deb ...\nUnpacking ruby-xmlrpc (0.3.0-2) ...\nSelecting previously unselected package libyaml-0-2:amd64.\nPreparing to unpack .../116-libyaml-0-2_0.2.1-1_amd64.deb ...\nUnpacking libyaml-0-2:amd64 (0.2.1-1) ...\nSelecting previously unselected package libruby2.5:amd64.\nPreparing to unpack .../117-libruby2.5_2.5.5-3+deb10u6_amd64.deb ...\nUnpacking libruby2.5:amd64 (2.5.5-3+deb10u6) ...\nSelecting previously unselected package libtcl8.6:amd64.\nPreparing to unpack .../118-libtcl8.6_8.6.9+dfsg-2_amd64.deb ...\nUnpacking libtcl8.6:amd64 (8.6.9+dfsg-2) ...\nSelecting previously unselected package libtext-iconv-perl.\nPreparing to unpack .../119-libtext-iconv-perl_1.7-5+b7_amd64.deb ...\nUnpacking libtext-iconv-perl (1.7-5+b7) ...\nSelecting previously unselected package libtie-ixhash-perl.\nPreparing to unpack .../120-libtie-ixhash-perl_1.23-2_all.deb ...\nUnpacking libtie-ixhash-perl (1.23-2) ...\nSelecting previously unselected package libxss1:amd64.\nPreparing to unpack .../121-libxss1_1%3a1.2.3-1_amd64.deb ...\nUnpacking libxss1:amd64 (1:1.2.3-1) ...\nSelecting previously unselected package libtk8.6:amd64.\nPreparing to unpack .../122-libtk8.6_8.6.9-2_amd64.deb ...\nUnpacking libtk8.6:amd64 (8.6.9-2) ...\nSelecting previously unselected package libutempter0:amd64.\nPreparing to unpack .../123-libutempter0_1.1.6-3_amd64.deb ...\nUnpacking libutempter0:amd64 (1.1.6-3) ...\nSelecting previously unselected package libx11-protocol-perl.\nPreparing to unpack .../124-libx11-protocol-perl_0.56-7_all.deb ...\nUnpacking libx11-protocol-perl (0.56-7) ...\nSelecting previously unselected package libxcb-shape0:amd64.\nPreparing to unpack .../125-libxcb-shape0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-shape0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxml-xpathengine-perl.\nPreparing to unpack .../126-libxml-xpathengine-perl_0.14-1_all.deb ...\nUnpacking libxml-xpathengine-perl (0.14-1) ...\nSelecting previously unselected package libxmuu1:amd64.\nPreparing to unpack .../127-libxmuu1_2%3a1.1.2-2+b3_amd64.deb ...\nUnpacking libxmuu1:amd64 (2:1.1.2-2+b3) ...\nSelecting previously unselected package libxtst6:amd64.\nPreparing to unpack .../128-libxtst6_2%3a1.2.3-1_amd64.deb ...\nUnpacking libxtst6:amd64 (2:1.2.3-1) ...\nSelecting previously unselected package libxv1:amd64.\nPreparing to unpack .../129-libxv1_2%3a1.0.11-1_amd64.deb ...\nUnpacking libxv1:amd64 (2:1.0.11-1) ...\nSelecting previously unselected package libxxf86dga1:amd64.\nPreparing to unpack .../130-libxxf86dga1_2%3a1.1.4-1+b3_amd64.deb ...\nUnpacking libxxf86dga1:amd64 (2:1.1.4-1+b3) ...\nSelecting previously unselected package xfonts-encodings.\nPreparing to unpack .../131-xfonts-encodings_1%3a1.0.4-2_all.deb ...\nUnpacking xfonts-encodings (1:1.0.4-2) ...\nSelecting previously unselected package xfonts-utils.\nPreparing to unpack .../132-xfonts-utils_1%3a7.7+6_amd64.deb ...\nUnpacking xfonts-utils (1:7.7+6) ...\nSelecting previously unselected package lmodern.\nPreparing to unpack .../133-lmodern_2.004.5-6_all.deb ...\nUnpacking lmodern (2.004.5-6) ...\nSelecting previously unselected package preview-latex-style.\nPreparing to unpack .../134-preview-latex-style_11.91-2_all.deb ...\nUnpacking preview-latex-style (11.91-2) ...\nSelecting previously unselected package tcl8.6.\nPreparing to unpack .../135-tcl8.6_8.6.9+dfsg-2_amd64.deb ...\nUnpacking tcl8.6 (8.6.9+dfsg-2) ...\nSelecting previously unselected package tcl.\nPreparing to unpack .../136-tcl_8.6.9+1_amd64.deb ...\nUnpacking tcl (8.6.9+1) ...\nSelecting previously unselected package tex-gyre.\nPreparing to unpack .../137-tex-gyre_20180621-3_all.deb ...\nUnpacking tex-gyre (20180621-3) ...\nSelecting previously unselected package texlive-fonts-recommended.\nPreparing to unpack .../138-texlive-fonts-recommended_2018.20190227-2_all.deb ...\nUnpacking texlive-fonts-recommended (2018.20190227-2) ...\nSelecting previously unselected package texlive-pictures.\nPreparing to unpack .../139-texlive-pictures_2018.20190227-2_all.deb ...\nUnpacking texlive-pictures (2018.20190227-2) ...\nSelecting previously unselected package texlive-latex-extra.\nPreparing to unpack .../140-texlive-latex-extra_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-extra (2018.20190227-2) ...\nSelecting previously unselected package texlive-plain-generic.\nPreparing to unpack .../141-texlive-plain-generic_2018.20190227-2_all.deb ...\nUnpacking texlive-plain-generic (2018.20190227-2) ...\nSelecting previously unselected package tipa.\nPreparing to unpack .../142-tipa_2%3a1.3-20_all.deb ...\nUnpacking tipa (2:1.3-20) ...\nSelecting previously unselected package tk8.6.\nPreparing to unpack .../143-tk8.6_8.6.9-2_amd64.deb ...\nUnpacking tk8.6 (8.6.9-2) ...\nSelecting previously unselected package tk.\nPreparing to unpack .../144-tk_8.6.9+1_amd64.deb ...\nUnpacking tk (8.6.9+1) ...\nSelecting previously unselected package libglx0:amd64.\nPreparing to unpack .../145-libglx0_1.1.0-1_amd64.deb ...\nUnpacking libglx0:amd64 (1.1.0-1) ...\nSelecting previously unselected package libgl1:amd64.\nPreparing to unpack .../146-libgl1_1.1.0-1_amd64.deb ...\nUnpacking libgl1:amd64 (1.1.0-1) ...\nSelecting previously unselected package x11-utils.\nPreparing to unpack .../147-x11-utils_7.7+4_amd64.deb ...\nUnpacking x11-utils (7.7+4) ...\nSelecting previously unselected package x11-xserver-utils.\nPreparing to unpack .../148-x11-xserver-utils_7.7+8_amd64.deb ...\nUnpacking x11-xserver-utils (7.7+8) ...\nSelecting previously unselected package xbitmaps.\nPreparing to unpack .../149-xbitmaps_1.1.1-2_all.deb ...\nUnpacking xbitmaps (1.1.1-2) ...\nSelecting previously unselected package xterm.\nPreparing to unpack .../150-xterm_344-1+deb10u2_amd64.deb ...\nUnpacking xterm (344-1+deb10u2) ...\nSelecting previously unselected package zip.\nPreparing to unpack .../151-zip_3.0-11+b1_amd64.deb ...\nUnpacking zip (3.0-11+b1) ...\nSetting up pfb2t1c2pfb (0.3-11) ...\nSetting up libgs9-common (9.27~dfsg-2+deb10u9) ...\nSetting up libtext-iconv-perl (1.7-5+b7) ...\nSetting up javascript-common (11) ...\nSetting up libxcb-dri3-0:amd64 (1.13.1-2) ...\nSetting up liblcms2-2:amd64 (2.9-3) ...\nSetting up libpaper1:amd64 (1.1.28) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\n\nCreating config file /etc/papersize with new version\nSetting up libx11-xcb1:amd64 (2:1.6.7-1+deb10u4) ...\nSetting up libpciaccess0:amd64 (0.14-1) ...\nSetting up libtie-ixhash-perl (1.23-2) ...\nSetting up fonts-lato (2.0-2) ...\nSetting up fonts-noto-mono (20181227-1) ...\nSetting up libtexlua52:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libfont-afm-perl (1.20-2) ...\nSetting up ruby-power-assert (1.1.1-1) ...\nSetting up libtexlua53:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libyaml-0-2:amd64 (0.2.1-1) ...\nSetting up libglvnd0:amd64 (1.1.0-1) ...\nSetting up libio-stringy-perl (2.111-3) ...\nSetting up libxtst6:amd64 (2:1.2.3-1) ...\nSetting up libhtml-tagset-perl (3.20-3) ...\nSetting up libijs-0.35:amd64 (0.35-14) ...\nSetting up libauthen-sasl-perl (2.1600-1) ...\nSetting up libxcb-glx0:amd64 (1.13.1-2) ...\nSetting up libtexluajit2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libbrotli1:amd64 (1.0.7-2+deb10u1) ...\nSetting up liblwp-mediatypes-perl (6.02-1) ...\nSetting up libxcb-shape0:amd64 (1.13.1-2) ...\nSetting up libtry-tiny-perl (0.30-1) ...\nSetting up libsensors-config (1:3.5.0-3) ...\nSetting up libxxf86dga1:amd64 (2:1.1.4-1+b3) ...\nSetting up perl-openssl-defaults:amd64 (3) ...\nSetting up libencode-locale-perl (1.05-1) ...\nSetting up rubygems-integration (1.11+deb10u1) ...\nSetting up libzzip-0-13:amd64 (0.13.62-3.2+deb10u1) ...\nSetting up libpaper-utils (1.1.28) ...\nSetting up libxxf86vm1:amd64 (1:1.1.4-1+b2) ...\nSetting up poppler-data (0.4.9-2) ...\nSetting up libpython2.7-stdlib:amd64 (2.7.16-2+deb10u4) ...\nSetting up libxcb-present0:amd64 (1.13.1-2) ...\nSetting up ruby-minitest (5.11.3-1) ...\nSetting up tex-common (6.11) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\nupdate-language: texlive-base not installed and configured, doing nothing!\nSetting up zip (3.0-11+b1) ...\nSetting up libfontenc1:amd64 (1:1.1.3-1+b2) ...\nSetting up ruby-test-unit (3.2.8-1) ...\nSetting up libdata-dump-perl (1.23-1) ...\nSetting up libxcb-sync1:amd64 (1.13.1-2) ...\nSetting up libjbig2dec0:amd64 (0.16-1+deb10u1) ...\nSetting up libipc-system-simple-perl (1.25-4) ...\nSetting up libidn11:amd64 (1.33-2.2) ...\nSetting up libteckit0:amd64 (2.5.8+ds2-5) ...\nSetting up libxml-xpathengine-perl (0.14-1) ...\nSetting up gsfonts (1:8.11+urwcyr1.0.7~pre44-4.4) ...\nSetting up ruby-net-telnet (0.1.1-2) ...\nSetting up xfonts-encodings (1:1.0.4-2) ...\nSetting up t1utils (1.41-3) ...\nSetting up libxv1:amd64 (2:1.0.11-1) ...\nSetting up libio-html-perl (1.001-1) ...\nSetting up libtcl8.6:amd64 (8.6.9+dfsg-2) ...\nSetting up fonts-texgyre (20180621-3) ...\nSetting up libsensors5:amd64 (1:3.5.0-3) ...\nSetting up libglapi-mesa:amd64 (18.3.6-2+deb10u1) ...\nSetting up libkpathsea6:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libtimedate-perl (2.3000-2+deb10u1) ...\nSetting up libutempter0:amd64 (1.1.6-3) ...\nSetting up libcups2:amd64 (2.2.10-6+deb10u10) ...\nSetting up libxcb-dri2-0:amd64 (1.13.1-2) ...\nSetting up libxshmfence1:amd64 (1.3-1) ...\nSetting up libxxhash0:amd64 (0.6.5-2) ...\nSetting up fonts-lmodern (2.004.5-6) ...\nSetting up libopenjp2-7:amd64 (2.3.0-2+deb10u2) ...\nSetting up libllvm7:amd64 (1:7.0.1-8+deb10u2) ...\nSetting up fonts-droid-fallback (1:6.0.1r16-1.1) ...\nSetting up libxss1:amd64 (1:1.2.3-1) ...\nSetting up libjs-jquery (3.3.1~dfsg-3+deb10u1) ...\nSetting up ruby-did-you-mean (1.2.1-1) ...\nSetting up libdrm-common (2.4.97-1) ...\nSetting up ruby-xmlrpc (0.3.0-2) ...\nSetting up xdg-utils (1.1.3-1+deb10u1) ...\nSetting up liburi-perl (1.76-1) ...\nSetting up libxmuu1:amd64 (2:1.1.2-2+b3) ...\nSetting up libx11-protocol-perl (0.56-7) ...\nSetting up xbitmaps (1.1.1-2) ...\nSetting up libsynctex2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libpotrace0:amd64 (1.15-1) ...\nSetting up libnet-ssleay-perl (1.85-2+deb10u1) ...\nSetting up libhttp-date-perl (6.02-1) ...\nSetting up tcl8.6 (8.6.9+dfsg-2) ...\nSetting up libfile-basedir-perl (0.08-1) ...\nSetting up libfile-listing-perl (6.04-1) ...\nSetting up python2.7 (2.7.16-2+deb10u4) ...\nSetting up libwoff1:amd64 (1.0.2-1) ...\nSetting up libpython2-stdlib:amd64 (2.7.16-1) ...\nSetting up preview-latex-style (11.91-2) ...\nSetting up libtk8.6:amd64 (8.6.9-2) ...\nSetting up libnet-http-perl (6.18-1) ...\nSetting up xfonts-utils (1:7.7+6) ...\nSetting up x11-xserver-utils (7.7+8) ...\nSetting up python2 (2.7.16-1) ...\nSetting up libcupsimage2:amd64 (2.2.10-6+deb10u10) ...\nSetting up libpython-stdlib:amd64 (2.7.16-1) ...\nSetting up libptexenc1:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libfile-desktopentry-perl (0.22-1) ...\nSetting up libwww-robotrules-perl (6.02-1) ...\nSetting up libdrm2:amd64 (2.4.97-1) ...\nSetting up lmodern (2.004.5-6) ...\nSetting up libhtml-parser-perl (3.72-3+b3) ...\nSetting up tcl (8.6.9+1) ...\nSetting up xterm (344-1+deb10u2) ...\nupdate-alternatives: using /usr/bin/xterm to provide /usr/bin/x-terminal-emulator (x-terminal-emulator) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/x-terminal-emulator.1.gz because associated file /usr/share/man/man1/xterm.1.gz (of link group x-terminal-emulator) doesn't exist\nupdate-alternatives: using /usr/bin/lxterm to provide /usr/bin/x-terminal-emulator (x-terminal-emulator) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/x-terminal-emulator.1.gz because associated file /usr/share/man/man1/lxterm.1.gz (of link group x-terminal-emulator) doesn't exist\nSetting up python (2.7.16-1) ...\nSetting up tex-gyre (20180621-3) ...\nSetting up libcupsfilters1:amd64 (1.21.6-5+deb10u1) ...\nSetting up libio-socket-ssl-perl (2.060-3) ...\nSetting up libhttp-message-perl (6.18-1) ...\nSetting up libdrm-amdgpu1:amd64 (2.4.97-1) ...\nSetting up libhtml-form-perl (6.03-1) ...\nSetting up tk8.6 (8.6.9-2) ...\nSetting up libfile-mimeinfo-perl (0.29-1) ...\nSetting up libhttp-negotiate-perl (6.01-1) ...\nSetting up libdrm-nouveau2:amd64 (2.4.97-1) ...\nSetting up libgs9:amd64 (9.27~dfsg-2+deb10u9) ...\nSetting up libhttp-cookies-perl (6.04-1) ...\nSetting up libdrm-radeon1:amd64 (2.4.97-1) ...\nSetting up libhtml-tree-perl (5.07-2) ...\nSetting up libdrm-intel1:amd64 (2.4.97-1) ...\nSetting up libgl1-mesa-dri:amd64 (18.3.6-2+deb10u1) ...\nSetting up libhtml-format-perl (2.12-1) ...\nSetting up ghostscript (9.27~dfsg-2+deb10u9) ...\nSetting up libnet-smtp-ssl-perl (1.04-1) ...\nSetting up libmailtools-perl (2.18-1) ...\nSetting up libhttp-daemon-perl (6.01-3+deb10u1) ...\nSetting up texlive-binaries (2018.20181218.49446-1+deb10u2) ...\nupdate-alternatives: using /usr/bin/xdvi-xaw to provide /usr/bin/xdvi.bin (xdvi.bin) in auto mode\nupdate-alternatives: using /usr/bin/bibtex.original to provide /usr/bin/bibtex (bibtex) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/bibtex.1.gz because associated file /usr/share/man/man1/bibtex.original.1.gz (of link group bibtex) doesn't exist\nSetting up tk (8.6.9+1) ...\nSetting up texlive-base (2018.20190227-2) ...\nmktexlsr: Updating /var/lib/texmf/ls-R-TEXLIVEDIST... \nmktexlsr: Updating /var/lib/texmf/ls-R-TEXMFMAIN... \nmktexlsr: Updating /var/lib/texmf/ls-R... \nmktexlsr: Done.\ntl-paper: setting paper size for dvips to a4: /var/lib/texmf/dvips/config/config-paper.ps\ntl-paper: setting paper size for dvipdfmx to a4: /var/lib/texmf/dvipdfmx/dvipdfmx-paper.cfg\ntl-paper: setting paper size for xdvi to a4: /var/lib/texmf/xdvi/XDvi-paper\ntl-paper: setting paper size for pdftex to a4: /var/lib/texmf/tex/generic/config/pdftexconfig.tex\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\ntl-paper: setting paper size for dvipdfmx to letter: /var/lib/texmf/dvipdfmx/dvipdfmx-paper.cfg\ntl-paper: setting paper size for dvips to letter: /var/lib/texmf/dvips/config/config-paper.ps\ntl-paper: setting paper size for pdftex to letter: /var/lib/texmf/tex/generic/config/pdftexconfig.tex\ntl-paper: setting paper size for xdvi to letter: /var/lib/texmf/xdvi/XDvi-paper\nSetting up libglx-mesa0:amd64 (18.3.6-2+deb10u1) ...\nSetting up libglx0:amd64 (1.1.0-1) ...\nSetting up dvipng (1.15-1.1) ...\nSetting up texlive-plain-generic (2018.20190227-2) ...\nSetting up libgl1:amd64 (1.1.0-1) ...\nSetting up texlive-latex-base (2018.20190227-2) ...\nSetting up texlive-latex-recommended (2018.20190227-2) ...\nSetting up texlive-pictures (2018.20190227-2) ...\nSetting up texlive-fonts-recommended (2018.20190227-2) ...\nSetting up x11-utils (7.7+4) ...\nSetting up tipa (2:1.3-20) ...\nRegenerating '/var/lib/texmf/fmtutil.cnf-DEBIAN'... done.\nRegenerating '/var/lib/texmf/fmtutil.cnf-TEXLIVEDIST'... done.\nupdate-fmtutil has updated the following file(s):\n\t/var/lib/texmf/fmtutil.cnf-DEBIAN\n\t/var/lib/texmf/fmtutil.cnf-TEXLIVEDIST\nIf you want to activate the changes in the above file(s),\nyou should run fmtutil-sys or fmtutil.\nSetting up cm-super-minimal (0.3.4-14) ...\nSetting up texlive-latex-extra (2018.20190227-2) ...\nSetting up cm-super (0.3.4-14) ...\nCreating fonts. This may take some time... done.\nSetting up rake (12.3.1-3+deb10u1) ...\nSetting up liblwp-protocol-https-perl (6.07-2) ...\nSetting up libwww-perl (6.36-2) ...\nSetting up libruby2.5:amd64 (2.5.5-3+deb10u6) ...\nSetting up libxml-parser-perl (2.44-4) ...\nSetting up ruby2.5 (2.5.5-3+deb10u6) ...\nSetting up libxml-twig-perl (1:3.50-1.1) ...\nSetting up libnet-dbus-perl (1.1.0-5+b1) ...\nSetting up ruby (1:2.5.1) ...\nProcessing triggers for fontconfig (2.13.1-2) ...\nProcessing triggers for mime-support (3.62) ...\nProcessing triggers for hicolor-icon-theme (0.17-2) ...\nProcessing triggers for libc-bin (2.28-10+deb10u2) ...\nProcessing triggers for tex-common (6.11) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\nRunning updmap-sys. This may take some time... done.\nRunning mktexlsr /var/lib/texmf ... done.\nBuilding format(s) --all.\n\tThis may take some time... done.\n","output_type":"stream"}],"outputs_reference":"s3:deepnote-cell-outputs-production/a5f6bc00-9744-4673-a4c9-93c1be7511ca","content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718510032692,"execution_millis":2741,"deepnote_to_be_reexecuted":false,"cell_id":"ed352a0be9bf4e25962447e4e23ccec2","deepnote_cell_type":"code"},"source":"import os\nimport os.path as osp\nimport math\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport scienceplots\nplt.style.use('science')","block_group":"6116171419e149c1af49a8327d649bf0","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718510035438,"execution_millis":1150,"deepnote_to_be_reexecuted":false,"cell_id":"fcb4ac5f46404d40ac59e2fe1da0ff25","deepnote_cell_type":"code"},"source":"df = pd.read_excel(\"review_scores.xlsx\")\n\nexperiment_names = [\"BASELINE\"]\n\n# Enable the settings below for each experiment\n\nALL_EXPERIMENT_NAMES = [[\"BASELINE\"]]\n# The following are settings for reviewer types\n# Varying levels of commitment\nALL_EXPERIMENT_NAMES += [[\"responsible_Rx1\", \"irresponsible_Rx1\"]]\n# Varying intentions\nALL_EXPERIMENT_NAMES += [[\"benign_Rx1\", \"malicious_Rx1\"]]\n# Varying knowledgeability\nALL_EXPERIMENT_NAMES += [[\"knowledgeable_Rx1\", \"unknowledgeable_Rx1\"]]\n\n","block_group":"fcb4ac5f46404d40ac59e2fe1da0ff25","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718510118142,"execution_millis":8,"deepnote_to_be_reexecuted":false,"cell_id":"e63fd2a7bb3243038008621c6a238e66","deepnote_cell_type":"code"},"source":"BINWIDTH = 0.25\nFONT_SIZE = 24","block_group":"7d8709ff1413499d98a49e7ccad865aa","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718510118484,"execution_millis":67,"deepnote_to_be_reexecuted":false,"cell_id":"0955fa8dc3074fb793e25345b0c6fd15","deepnote_cell_type":"code"},"source":"# colors = [, '#d86ecc', '#4f95da', '#46c3b8']\nGREY = '#aeaeae' # Baseline\nBLUE = '#4f95da' # Good settings\nPINK = '#d86ecc' # Bad settings\nCYAN = '#46c3b8'\n\nexperiment_name2color = {\n 'BASELINE': GREY,\n 'responsible_Rx1': BLUE,\n 'irresponsible_Rx1': PINK,\n 'benign_Rx1': BLUE,\n 'malicious_Rx1': PINK,\n 'knowledgeable_Rx1': BLUE,\n 'unknowledgeable_Rx1': PINK,\n 'conformist_ACx1': BLUE,\n 'authoritarian_ACx1': PINK,\n 'inclusive_ACx1': CYAN,\n}","block_group":"091fc8e46d374b8a806c3fc753f9ffd9","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718510118836,"execution_millis":21,"deepnote_to_be_reexecuted":false,"cell_id":"17602ce47b9e4f24bc442b31edbc4177","deepnote_cell_type":"code"},"source":"def calculate_bin_edges(data, colname, binwidth):\n max_val = round_up_to_nearest_half(data[colname].max())\n min_val = round_up_to_nearest_half(data[colname].min()) - 0.5\n # Create an array from min_val to max_val with a step of binwidth\n bins = np.arange(min_val, max_val + binwidth, binwidth)\n return bins\n\ndef round_up_to_nearest_half(number):\n \"\"\"\n Rounds a number up to its nearest 0.5.\n\n Args:\n number (float): The number to round.\n\n Returns:\n float: The rounded number.\n \"\"\"\n return math.ceil(number * 2) / 2\n","block_group":"484380ef98c0428d911cef99e7e60ec1","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718510156682,"execution_millis":11786,"deepnote_to_be_reexecuted":false,"cell_id":"d62c8e6244ff43168f9fc3fab61ae2e8","deepnote_cell_type":"code"},"source":"def standardize_column(df, colname):\n return (df[colname] - df[colname].mean()) / df[colname].std()\n\n\n# Plotting the distribution of score changes\n\nfig, axes = plt.subplots(1, 4, figsize=(18, 4.5), sharey=True)\n\nidx_plot = 0\nsns.set_style(\"whitegrid\")\n\nsubplot_names = [\"(a) Baseline\", \"(b) Commitment\", \"(c) Intention\", \"(d) Knowledgeability\"]\n\nfig.suptitle('Distribution of Final Ratings', fontsize=FONT_SIZE)\n\nfor initial_or_updated in ['updated']:\n\n for experiment_names in ALL_EXPERIMENT_NAMES:\n\n for exp_name in ['BASELINE'] + experiment_names:\n if exp_name not in ['BASELINE']:\n # Calculating the Pearson correlation coefficient\n\n correlation_matrix = np.corrcoef(df[f\"{exp_name}_avg_{initial_or_updated}\"],\n df[f\"BASELINE_avg_{initial_or_updated}\"])\n correlation = correlation_matrix[0, 1]\n\n print(f\"Correlation ({exp_name.split('_')[0]} vs. BASELINE):\\t{correlation:.4f}\")\n\n # for colname, color in zip(columns, COLORS):\n for experiment_name in experiment_names:\n print(f\"Plotting {experiment_name}...\")\n # Use the custom bin edges\n colname = f'{experiment_name}_avg_{initial_or_updated}'\n bin_edges = calculate_bin_edges(df, colname, BINWIDTH)\n\n axes.flat[idx_plot].hist(df[colname],\n bins=bin_edges,\n alpha=0.6 if experiment_name in ['BASELINE'] else\n 0.3,\n label='Baseline' if experiment_name == 'BASELINE' else experiment_name.split('_')[\n 0].capitalize(),\n color=experiment_name2color[experiment_name])\n\n axes.flat[idx_plot].set_xlabel('Ratings', fontsize=FONT_SIZE)\n axes.flat[idx_plot].set_xlim(2, 8)\n\n axes.flat[idx_plot - 1].tick_params(axis='x', labelsize=FONT_SIZE) # Set x-tick label font size\n axes.flat[idx_plot - 1].tick_params(axis='y', labelsize=FONT_SIZE) # Set y-tick label font size\n axes.flat[idx_plot].set_title(subplot_names[idx_plot], fontsize=FONT_SIZE)\n\n legend = axes.flat[idx_plot].legend(fontsize=16, loc='upper left')\n legend.get_frame().set_alpha(0.5)\n idx_plot += 1\n\naxes.flat[0].set_ylabel('Number of Papers', fontsize=FONT_SIZE)\nplt.tight_layout()\nplt.savefig(osp.join(\"histplot_review_ratings.pdf\"), dpi=300)","block_group":"d26072d9f15e421885e9020ed73dd433","execution_count":null,"outputs":[{"name":"stdout","text":"Plotting BASELINE...\nCorrelation (responsible vs. BASELINE):\tnan\nCorrelation (irresponsible vs. BASELINE):\tnan\nPlotting responsible_Rx1...\nPlotting irresponsible_Rx1...\nCorrelation (benign vs. BASELINE):\tnan\nCorrelation (malicious vs. BASELINE):\t0.1373\nPlotting benign_Rx1...\nPlotting malicious_Rx1...\nCorrelation (knowledgeable vs. BASELINE):\t0.5382\nCorrelation (unknowledgeable vs. BASELINE):\tnan\nPlotting knowledgeable_Rx1...\nPlotting unknowledgeable_Rx1...\n","output_type":"stream"},{"data":{"text/plain":"
","image/png":"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\n"},"metadata":{"image/png":{"width":1780,"height":436}},"output_type":"display_data"}],"outputs_reference":"s3:deepnote-cell-outputs-production/1fb73230-8248-4a77-9631-c6ed4206b378","content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718510048357,"execution_millis":125,"deepnote_to_be_reexecuted":false,"cell_id":"ed0748763546446e9fb73e7b803d7ec4","deepnote_cell_type":"code"},"source":"","block_group":"80ec95b7bb574136bc408aec2bd59894","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718510048406,"execution_millis":76,"deepnote_to_be_reexecuted":false,"cell_id":"081e1c3c9f77469ca11ddb4d041e4178","deepnote_cell_type":"code"},"source":"","block_group":"2d63d1009ec547adaee7dd4723cbc448","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"markdown","source":"\nCreated in deepnote.com \nCreated in Deepnote","metadata":{"created_in_deepnote_cell":true,"deepnote_cell_type":"markdown"}}],"nbformat":4,"nbformat_minor":0,"metadata":{"deepnote_persisted_session":{"createdAt":"2024-06-16T04:45:19.231Z"},"deepnote_notebook_id":"ec9fad8f03024620b4ebee450db0e2c4","deepnote_execution_queue":[]}} \ No newline at end of file diff --git a/notebooks/lineplots.ipynb b/notebooks/lineplots.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..5b3cb3f555ee2ca970f3edf8db099f27b11ffe5b --- /dev/null +++ b/notebooks/lineplots.ipynb @@ -0,0 +1 @@ +{"cells":[{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718514071309,"execution_millis":41687,"deepnote_to_be_reexecuted":false,"cell_id":"0ae3ff7b6fc6492282345f2ac2932a52","deepnote_cell_type":"code"},"source":"!sudo apt-get update -y\n!sudo apt-get install dvipng texlive-latex-extra texlive-fonts-recommended cm-super -y\n!pip install SciencePlots openpyxl","block_group":"7cb8acb3058e44ccab361912c42bb3a2","execution_count":null,"outputs":[{"name":"stdout","text":"Get:1 http://deb.debian.org/debian buster InRelease [122 kB]\nGet:2 http://deb.debian.org/debian-security buster/updates InRelease [34.8 kB]\nGet:3 http://deb.debian.org/debian buster-updates InRelease [56.6 kB]\nGet:4 http://deb.debian.org/debian buster/main amd64 Packages [7,909 kB]\nGet:5 http://deb.debian.org/debian-security buster/updates/main amd64 Packages [603 kB]\nGet:6 http://deb.debian.org/debian buster-updates/main amd64 Packages [8,788 B]\nFetched 8,734 kB in 3s (3,489 kB/s)\n\n\n\n\nThe following additional packages will be installed:\n cm-super-minimal fonts-droid-fallback fonts-lato fonts-lmodern\n fonts-noto-mono fonts-texgyre ghostscript gsfonts javascript-common\n libauthen-sasl-perl libbrotli1 libcups2 libcupsfilters1 libcupsimage2\n libdata-dump-perl libdrm-amdgpu1 libdrm-common libdrm-intel1 libdrm-nouveau2\n libdrm-radeon1 libdrm2 libencode-locale-perl libfile-basedir-perl\n libfile-desktopentry-perl libfile-listing-perl libfile-mimeinfo-perl\n libfont-afm-perl libfontenc1 libgl1 libgl1-mesa-dri libglapi-mesa libglvnd0\n libglx-mesa0 libglx0 libgs9 libgs9-common libhtml-form-perl\n libhtml-format-perl libhtml-parser-perl libhtml-tagset-perl\n libhtml-tree-perl libhttp-cookies-perl libhttp-daemon-perl libhttp-date-perl\n libhttp-message-perl libhttp-negotiate-perl libidn11 libijs-0.35\n libio-html-perl libio-socket-ssl-perl libio-stringy-perl\n libipc-system-simple-perl libjbig2dec0 libjs-jquery libkpathsea6 liblcms2-2\n libllvm7 liblwp-mediatypes-perl liblwp-protocol-https-perl libmailtools-perl\n libnet-dbus-perl libnet-http-perl libnet-smtp-ssl-perl libnet-ssleay-perl\n libopenjp2-7 libpaper-utils libpaper1 libpciaccess0 libpotrace0 libptexenc1\n libpython-stdlib libpython2-stdlib libpython2.7-minimal libpython2.7-stdlib\n libruby2.5 libsensors-config libsensors5 libsynctex2 libtcl8.6 libteckit0\n libtexlua52 libtexlua53 libtexluajit2 libtext-iconv-perl libtie-ixhash-perl\n libtimedate-perl libtk8.6 libtry-tiny-perl liburi-perl libutempter0 libwoff1\n libwww-perl libwww-robotrules-perl libx11-protocol-perl libx11-xcb1\n libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-shape0\n libxcb-sync1 libxml-parser-perl libxml-twig-perl libxml-xpathengine-perl\n libxmuu1 libxshmfence1 libxss1 libxtst6 libxv1 libxxf86dga1 libxxf86vm1\n libxxhash0 libyaml-0-2 libzzip-0-13 lmodern perl-openssl-defaults\n pfb2t1c2pfb poppler-data preview-latex-style python python-minimal python2\n python2-minimal python2.7 python2.7-minimal rake ruby ruby-did-you-mean\n ruby-minitest ruby-net-telnet ruby-power-assert ruby-test-unit ruby-xmlrpc\n ruby2.5 rubygems-integration t1utils tcl tcl8.6 tex-common tex-gyre\n texlive-base texlive-binaries texlive-latex-base texlive-latex-recommended\n texlive-pictures texlive-plain-generic tipa tk tk8.6 x11-utils\n x11-xserver-utils xbitmaps xdg-utils xfonts-encodings xfonts-utils xterm zip\nSuggested packages:\n fonts-noto ghostscript-x apache2 | lighttpd | httpd libdigest-hmac-perl\n libgssapi-perl cups-common liblcms2-utils libcrypt-ssleay-perl pciutils\n lm-sensors libauthen-ntlm-perl libunicode-map8-perl libunicode-string-perl\n xml-twig-tools poppler-utils fonts-japanese-mincho | fonts-ipafont-mincho\n fonts-japanese-gothic | fonts-ipafont-gothic fonts-arphic-ukai\n fonts-arphic-uming fonts-nanum python-doc python-tk python2-doc\n python2.7-doc binfmt-support ri ruby-dev bundler tcl-tclreadline debhelper\n perl-tk xpdf-reader | pdf-viewer texlive-fonts-recommended-doc\n texlive-latex-base-doc python-pygments icc-profiles libfile-which-perl\n libspreadsheet-parseexcel-perl texlive-latex-extra-doc\n texlive-latex-recommended-doc texlive-pstricks dot2tex prerex ruby-tcltk\n | libtcltk-ruby texlive-pictures-doc vprerex mesa-utils nickle cairo-5c\n xorg-docs-core xfonts-cyrillic\nThe following NEW packages will be installed:\n cm-super cm-super-minimal dvipng fonts-droid-fallback fonts-lato\n fonts-lmodern fonts-noto-mono fonts-texgyre ghostscript gsfonts\n javascript-common libauthen-sasl-perl libbrotli1 libcupsfilters1\n libcupsimage2 libdata-dump-perl libdrm-amdgpu1 libdrm-common libdrm-intel1\n libdrm-nouveau2 libdrm-radeon1 libdrm2 libencode-locale-perl\n libfile-basedir-perl libfile-desktopentry-perl libfile-listing-perl\n libfile-mimeinfo-perl libfont-afm-perl libfontenc1 libgl1 libgl1-mesa-dri\n libglapi-mesa libglvnd0 libglx-mesa0 libglx0 libgs9 libgs9-common\n libhtml-form-perl libhtml-format-perl libhtml-parser-perl\n libhtml-tagset-perl libhtml-tree-perl libhttp-cookies-perl\n libhttp-daemon-perl libhttp-date-perl libhttp-message-perl\n libhttp-negotiate-perl libidn11 libijs-0.35 libio-html-perl\n libio-socket-ssl-perl libio-stringy-perl libipc-system-simple-perl\n libjbig2dec0 libjs-jquery libkpathsea6 liblcms2-2 libllvm7\n liblwp-mediatypes-perl liblwp-protocol-https-perl libmailtools-perl\n libnet-dbus-perl libnet-http-perl libnet-smtp-ssl-perl libnet-ssleay-perl\n libopenjp2-7 libpaper-utils libpaper1 libpciaccess0 libpotrace0 libptexenc1\n libpython-stdlib libpython2-stdlib libpython2.7-minimal libpython2.7-stdlib\n libruby2.5 libsensors-config libsensors5 libsynctex2 libtcl8.6 libteckit0\n libtexlua52 libtexlua53 libtexluajit2 libtext-iconv-perl libtie-ixhash-perl\n libtimedate-perl libtk8.6 libtry-tiny-perl liburi-perl libutempter0 libwoff1\n libwww-perl libwww-robotrules-perl libx11-protocol-perl libx11-xcb1\n libxcb-dri2-0 libxcb-dri3-0 libxcb-glx0 libxcb-present0 libxcb-shape0\n libxcb-sync1 libxml-parser-perl libxml-twig-perl libxml-xpathengine-perl\n libxmuu1 libxshmfence1 libxss1 libxtst6 libxv1 libxxf86dga1 libxxf86vm1\n libxxhash0 libyaml-0-2 libzzip-0-13 lmodern perl-openssl-defaults\n pfb2t1c2pfb poppler-data preview-latex-style python python-minimal python2\n python2-minimal python2.7 python2.7-minimal rake ruby ruby-did-you-mean\n ruby-minitest ruby-net-telnet ruby-power-assert ruby-test-unit ruby-xmlrpc\n ruby2.5 rubygems-integration t1utils tcl tcl8.6 tex-common tex-gyre\n texlive-base texlive-binaries texlive-fonts-recommended texlive-latex-base\n texlive-latex-extra texlive-latex-recommended texlive-pictures\n texlive-plain-generic tipa tk tk8.6 x11-utils x11-xserver-utils xbitmaps\n xdg-utils xfonts-encodings xfonts-utils xterm zip\nThe following packages will be upgraded:\n libcups2\n1 upgraded, 160 newly installed, 0 to remove and 39 not upgraded.\nNeed to get 212 MB of archives.\nAfter this operation, 798 MB of additional disk space will be used.\nGet:1 http://deb.debian.org/debian-security buster/updates/main amd64 libpython2.7-minimal amd64 2.7.16-2+deb10u4 [396 kB]\nGet:2 http://deb.debian.org/debian-security buster/updates/main amd64 python2.7-minimal amd64 2.7.16-2+deb10u4 [1,367 kB]\nGet:3 http://deb.debian.org/debian buster/main amd64 python2-minimal amd64 2.7.16-1 [41.4 kB]\nGet:4 http://deb.debian.org/debian buster/main amd64 python-minimal amd64 2.7.16-1 [21.0 kB]\nGet:5 http://deb.debian.org/debian-security buster/updates/main amd64 libpython2.7-stdlib amd64 2.7.16-2+deb10u4 [1,912 kB]\nGet:6 http://deb.debian.org/debian-security buster/updates/main amd64 python2.7 amd64 2.7.16-2+deb10u4 [306 kB]\nGet:7 http://deb.debian.org/debian buster/main amd64 libpython2-stdlib amd64 2.7.16-1 [20.8 kB]\nGet:8 http://deb.debian.org/debian buster/main amd64 libpython-stdlib amd64 2.7.16-1 [20.8 kB]\nGet:9 http://deb.debian.org/debian buster/main amd64 python2 amd64 2.7.16-1 [41.6 kB]\nGet:10 http://deb.debian.org/debian buster/main amd64 python amd64 2.7.16-1 [22.8 kB]\nGet:11 http://deb.debian.org/debian buster/main amd64 fonts-droid-fallback all 1:6.0.1r16-1.1 [1,807 kB]\nGet:12 http://deb.debian.org/debian buster/main amd64 fonts-lato all 2.0-2 [2,698 kB]\nGet:13 http://deb.debian.org/debian buster/main amd64 poppler-data all 0.4.9-2 [1,473 kB]\nGet:14 http://deb.debian.org/debian buster/main amd64 tex-common all 6.11 [53.1 kB]\nGet:15 http://deb.debian.org/debian buster/main amd64 libpaper1 amd64 1.1.28 [21.3 kB]\nGet:16 http://deb.debian.org/debian buster/main amd64 libpaper-utils amd64 1.1.28 [18.0 kB]\nGet:17 http://deb.debian.org/debian-security buster/updates/main amd64 libkpathsea6 amd64 2018.20181218.49446-1+deb10u2 [168 kB]\nGet:18 http://deb.debian.org/debian-security buster/updates/main amd64 libptexenc1 amd64 2018.20181218.49446-1+deb10u2 [61.5 kB]\nGet:19 http://deb.debian.org/debian-security buster/updates/main amd64 libsynctex2 amd64 2018.20181218.49446-1+deb10u2 [80.9 kB]\nGet:20 http://deb.debian.org/debian-security buster/updates/main amd64 libtexlua52 amd64 2018.20181218.49446-1+deb10u2 [113 kB]\nGet:21 http://deb.debian.org/debian-security buster/updates/main amd64 libtexlua53 amd64 2018.20181218.49446-1+deb10u2 [126 kB]\nGet:22 http://deb.debian.org/debian-security buster/updates/main amd64 libtexluajit2 amd64 2018.20181218.49446-1+deb10u2 [257 kB]\nGet:23 http://deb.debian.org/debian buster/main amd64 t1utils amd64 1.41-3 [62.3 kB]\nGet:24 http://deb.debian.org/debian buster/main amd64 libbrotli1 amd64 1.0.7-2+deb10u1 [269 kB]\nGet:25 http://deb.debian.org/debian-security buster/updates/main amd64 libgs9-common all 9.27~dfsg-2+deb10u9 [5,137 kB]\nGet:26 http://deb.debian.org/debian-security buster/updates/main amd64 libcups2 amd64 2.2.10-6+deb10u10 [325 kB]\nGet:27 http://deb.debian.org/debian-security buster/updates/main amd64 libcupsimage2 amd64 2.2.10-6+deb10u10 [134 kB]\nGet:28 http://deb.debian.org/debian buster/main amd64 libidn11 amd64 1.33-2.2 [116 kB]\nGet:29 http://deb.debian.org/debian buster/main amd64 libijs-0.35 amd64 0.35-14 [18.3 kB]\nGet:30 http://deb.debian.org/debian buster/main amd64 libjbig2dec0 amd64 0.16-1+deb10u1 [62.2 kB]\nGet:31 http://deb.debian.org/debian buster/main amd64 liblcms2-2 amd64 2.9-3 [145 kB]\nGet:32 http://deb.debian.org/debian buster/main amd64 libopenjp2-7 amd64 2.3.0-2+deb10u2 [158 kB]\nGet:33 http://deb.debian.org/debian-security buster/updates/main amd64 libgs9 amd64 9.27~dfsg-2+deb10u9 [2,199 kB]\nGet:34 http://deb.debian.org/debian buster/main amd64 libpotrace0 amd64 1.15-1 [26.3 kB]\nGet:35 http://deb.debian.org/debian buster/main amd64 libteckit0 amd64 2.5.8+ds2-5 [318 kB]\nGet:36 http://deb.debian.org/debian buster/main amd64 libwoff1 amd64 1.0.2-1 [43.2 kB]\nGet:37 http://deb.debian.org/debian buster/main amd64 libxxhash0 amd64 0.6.5-2 [7,156 B]\nGet:38 http://deb.debian.org/debian buster/main amd64 libzzip-0-13 amd64 0.13.62-3.2+deb10u1 [55.6 kB]\nGet:39 http://deb.debian.org/debian-security buster/updates/main amd64 texlive-binaries amd64 2018.20181218.49446-1+deb10u2 [11.3 MB]\nGet:40 http://deb.debian.org/debian buster/main amd64 xdg-utils all 1.1.3-1+deb10u1 [73.7 kB]\nGet:41 http://deb.debian.org/debian buster/main amd64 texlive-base all 2018.20190227-2 [19.7 MB]\nGet:42 http://deb.debian.org/debian buster/main amd64 fonts-lmodern all 2.004.5-6 [4,539 kB]\nGet:43 http://deb.debian.org/debian buster/main amd64 texlive-latex-base all 2018.20190227-2 [984 kB]\nGet:44 http://deb.debian.org/debian buster/main amd64 texlive-latex-recommended all 2018.20190227-2 [15.2 MB]\nGet:45 http://deb.debian.org/debian buster/main amd64 cm-super-minimal all 0.3.4-14 [5,814 kB]\nGet:46 http://deb.debian.org/debian buster/main amd64 pfb2t1c2pfb amd64 0.3-11 [10.0 kB]\nGet:47 http://deb.debian.org/debian buster/main amd64 cm-super all 0.3.4-14 [18.7 MB]\nGet:48 http://deb.debian.org/debian-security buster/updates/main amd64 ghostscript amd64 9.27~dfsg-2+deb10u9 [95.5 kB]\nGet:49 http://deb.debian.org/debian buster/main amd64 dvipng amd64 1.15-1.1 [87.8 kB]\nGet:50 http://deb.debian.org/debian buster/main amd64 fonts-noto-mono all 20181227-1 [83.1 kB]\nGet:51 http://deb.debian.org/debian buster/main amd64 fonts-texgyre all 20180621-3 [10.2 MB]\nGet:52 http://deb.debian.org/debian buster/main amd64 gsfonts all 1:8.11+urwcyr1.0.7~pre44-4.4 [3,125 kB]\nGet:53 http://deb.debian.org/debian buster/main amd64 javascript-common all 11 [6,120 B]\nGet:54 http://deb.debian.org/debian buster/main amd64 libauthen-sasl-perl all 2.1600-1 [50.8 kB]\nGet:55 http://deb.debian.org/debian-security buster/updates/main amd64 libcupsfilters1 amd64 1.21.6-5+deb10u1 [172 kB]\nGet:56 http://deb.debian.org/debian buster/main amd64 libdata-dump-perl all 1.23-1 [29.5 kB]\nGet:57 http://deb.debian.org/debian buster/main amd64 libdrm-common all 2.4.97-1 [13.8 kB]\nGet:58 http://deb.debian.org/debian buster/main amd64 libdrm2 amd64 2.4.97-1 [39.7 kB]\nGet:59 http://deb.debian.org/debian buster/main amd64 libdrm-amdgpu1 amd64 2.4.97-1 [27.3 kB]\nGet:60 http://deb.debian.org/debian buster/main amd64 libpciaccess0 amd64 0.14-1 [53.5 kB]\nGet:61 http://deb.debian.org/debian buster/main amd64 libdrm-intel1 amd64 2.4.97-1 [69.8 kB]\nGet:62 http://deb.debian.org/debian buster/main amd64 libdrm-nouveau2 amd64 2.4.97-1 [26.3 kB]\nGet:63 http://deb.debian.org/debian buster/main amd64 libdrm-radeon1 amd64 2.4.97-1 [31.1 kB]\nGet:64 http://deb.debian.org/debian buster/main amd64 libencode-locale-perl all 1.05-1 [13.7 kB]\nGet:65 http://deb.debian.org/debian buster/main amd64 libipc-system-simple-perl all 1.25-4 [26.5 kB]\nGet:66 http://deb.debian.org/debian buster/main amd64 libfile-basedir-perl all 0.08-1 [17.7 kB]\nGet:67 http://deb.debian.org/debian buster/main amd64 liburi-perl all 1.76-1 [89.9 kB]\nGet:68 http://deb.debian.org/debian buster/main amd64 libfile-desktopentry-perl all 0.22-1 [19.2 kB]\nGet:69 http://deb.debian.org/debian buster/main amd64 libtimedate-perl all 2.3000-2+deb10u1 [38.1 kB]\nGet:70 http://deb.debian.org/debian buster/main amd64 libhttp-date-perl all 6.02-1 [10.7 kB]\nGet:71 http://deb.debian.org/debian buster/main amd64 libfile-listing-perl all 6.04-1 [10.3 kB]\nGet:72 http://deb.debian.org/debian buster/main amd64 libfile-mimeinfo-perl all 0.29-1 [46.5 kB]\nGet:73 http://deb.debian.org/debian buster/main amd64 libfont-afm-perl all 1.20-2 [13.6 kB]\nGet:74 http://deb.debian.org/debian buster/main amd64 libfontenc1 amd64 1:1.1.3-1+b2 [24.4 kB]\nGet:75 http://deb.debian.org/debian buster/main amd64 libglapi-mesa amd64 18.3.6-2+deb10u1 [66.3 kB]\nGet:76 http://deb.debian.org/debian buster/main amd64 libllvm7 amd64 1:7.0.1-8+deb10u2 [13.1 MB]\nGet:77 http://deb.debian.org/debian buster/main amd64 libsensors-config all 1:3.5.0-3 [31.6 kB]\nGet:78 http://deb.debian.org/debian buster/main amd64 libsensors5 amd64 1:3.5.0-3 [52.6 kB]\nGet:79 http://deb.debian.org/debian buster/main amd64 libgl1-mesa-dri amd64 18.3.6-2+deb10u1 [6,685 kB]\nGet:80 http://deb.debian.org/debian buster/main amd64 libglvnd0 amd64 1.1.0-1 [48.6 kB]\nGet:81 http://deb.debian.org/debian-security buster/updates/main amd64 libx11-xcb1 amd64 2:1.6.7-1+deb10u4 [191 kB]\nGet:82 http://deb.debian.org/debian buster/main amd64 libxcb-dri2-0 amd64 1.13.1-2 [101 kB]\nGet:83 http://deb.debian.org/debian buster/main amd64 libxcb-dri3-0 amd64 1.13.1-2 [100 kB]\nGet:84 http://deb.debian.org/debian buster/main amd64 libxcb-glx0 amd64 1.13.1-2 [116 kB]\nGet:85 http://deb.debian.org/debian buster/main amd64 libxcb-present0 amd64 1.13.1-2 [99.1 kB]\nGet:86 http://deb.debian.org/debian buster/main amd64 libxcb-sync1 amd64 1.13.1-2 [103 kB]\nGet:87 http://deb.debian.org/debian buster/main amd64 libxshmfence1 amd64 1.3-1 [8,820 B]\nGet:88 http://deb.debian.org/debian buster/main amd64 libxxf86vm1 amd64 1:1.1.4-1+b2 [20.8 kB]\nGet:89 http://deb.debian.org/debian buster/main amd64 libglx-mesa0 amd64 18.3.6-2+deb10u1 [180 kB]\nGet:90 http://deb.debian.org/debian buster/main amd64 libhtml-tagset-perl all 3.20-3 [12.7 kB]\nGet:91 http://deb.debian.org/debian buster/main amd64 libhtml-parser-perl amd64 3.72-3+b3 [105 kB]\nGet:92 http://deb.debian.org/debian buster/main amd64 libio-html-perl all 1.001-1 [17.6 kB]\nGet:93 http://deb.debian.org/debian buster/main amd64 liblwp-mediatypes-perl all 6.02-1 [22.1 kB]\nGet:94 http://deb.debian.org/debian buster/main amd64 libhttp-message-perl all 6.18-1 [77.8 kB]\nGet:95 http://deb.debian.org/debian buster/main amd64 libhtml-form-perl all 6.03-1 [23.9 kB]\nGet:96 http://deb.debian.org/debian buster/main amd64 libhtml-tree-perl all 5.07-2 [213 kB]\nGet:97 http://deb.debian.org/debian buster/main amd64 libhtml-format-perl all 2.12-1 [43.5 kB]\nGet:98 http://deb.debian.org/debian buster/main amd64 libhttp-cookies-perl all 6.04-1 [17.8 kB]\nGet:99 http://deb.debian.org/debian-security buster/updates/main amd64 libhttp-daemon-perl all 6.01-3+deb10u1 [17.1 kB]\nGet:100 http://deb.debian.org/debian buster/main amd64 libhttp-negotiate-perl all 6.01-1 [12.8 kB]\nGet:101 http://deb.debian.org/debian buster/main amd64 perl-openssl-defaults amd64 3 [6,782 B]\nGet:102 http://deb.debian.org/debian buster/main amd64 libnet-ssleay-perl amd64 1.85-2+deb10u1 [308 kB]\nGet:103 http://deb.debian.org/debian buster/main amd64 libio-socket-ssl-perl all 2.060-3 [207 kB]\nGet:104 http://deb.debian.org/debian buster/main amd64 libio-stringy-perl all 2.111-3 [56.5 kB]\nGet:105 http://deb.debian.org/debian buster/main amd64 libjs-jquery all 3.3.1~dfsg-3+deb10u1 [332 kB]\nGet:106 http://deb.debian.org/debian buster/main amd64 libnet-http-perl all 6.18-1 [24.5 kB]\nGet:107 http://deb.debian.org/debian buster/main amd64 libtry-tiny-perl all 0.30-1 [23.3 kB]\nGet:108 http://deb.debian.org/debian buster/main amd64 libwww-robotrules-perl all 6.02-1 [12.9 kB]\nGet:109 http://deb.debian.org/debian buster/main amd64 libwww-perl all 6.36-2 [188 kB]\nGet:110 http://deb.debian.org/debian buster/main amd64 liblwp-protocol-https-perl all 6.07-2 [9,242 B]\nGet:111 http://deb.debian.org/debian buster/main amd64 libnet-smtp-ssl-perl all 1.04-1 [6,184 B]\nGet:112 http://deb.debian.org/debian buster/main amd64 libmailtools-perl all 2.18-1 [88.5 kB]\nGet:113 http://deb.debian.org/debian buster/main amd64 libxml-parser-perl amd64 2.44-4 [213 kB]\nGet:114 http://deb.debian.org/debian buster/main amd64 libxml-twig-perl all 1:3.50-1.1 [179 kB]\nGet:115 http://deb.debian.org/debian buster/main amd64 libnet-dbus-perl amd64 1.1.0-5+b1 [181 kB]\nGet:116 http://deb.debian.org/debian buster/main amd64 rubygems-integration all 1.11+deb10u1 [5,212 B]\nGet:117 http://deb.debian.org/debian-security buster/updates/main amd64 ruby2.5 amd64 2.5.5-3+deb10u6 [401 kB]\nGet:118 http://deb.debian.org/debian buster/main amd64 ruby amd64 1:2.5.1 [11.3 kB]\nGet:119 http://deb.debian.org/debian buster/main amd64 rake all 12.3.1-3+deb10u1 [67.1 kB]\nGet:120 http://deb.debian.org/debian buster/main amd64 ruby-did-you-mean all 1.2.1-1 [14.4 kB]\nGet:121 http://deb.debian.org/debian buster/main amd64 ruby-minitest all 5.11.3-1 [54.8 kB]\nGet:122 http://deb.debian.org/debian buster/main amd64 ruby-net-telnet all 0.1.1-2 [12.5 kB]\nGet:123 http://deb.debian.org/debian buster/main amd64 ruby-power-assert all 1.1.1-1 [10.9 kB]\nGet:124 http://deb.debian.org/debian buster/main amd64 ruby-test-unit all 3.2.8-1 [72.4 kB]\nGet:125 http://deb.debian.org/debian buster/main amd64 ruby-xmlrpc all 0.3.0-2 [23.7 kB]\nGet:126 http://deb.debian.org/debian buster/main amd64 libyaml-0-2 amd64 0.2.1-1 [47.2 kB]\nGet:127 http://deb.debian.org/debian-security buster/updates/main amd64 libruby2.5 amd64 2.5.5-3+deb10u6 [3,442 kB]\nGet:128 http://deb.debian.org/debian buster/main amd64 libtcl8.6 amd64 8.6.9+dfsg-2 [1,005 kB]\nGet:129 http://deb.debian.org/debian buster/main amd64 libtext-iconv-perl amd64 1.7-5+b7 [15.4 kB]\nGet:130 http://deb.debian.org/debian buster/main amd64 libtie-ixhash-perl all 1.23-2 [11.7 kB]\nGet:131 http://deb.debian.org/debian buster/main amd64 libxss1 amd64 1:1.2.3-1 [17.8 kB]\nGet:132 http://deb.debian.org/debian buster/main amd64 libtk8.6 amd64 8.6.9-2 [768 kB]\nGet:133 http://deb.debian.org/debian buster/main amd64 libutempter0 amd64 1.1.6-3 [7,812 B]\nGet:134 http://deb.debian.org/debian buster/main amd64 libx11-protocol-perl all 0.56-7 [150 kB]\nGet:135 http://deb.debian.org/debian buster/main amd64 libxcb-shape0 amd64 1.13.1-2 [99.5 kB]\nGet:136 http://deb.debian.org/debian buster/main amd64 libxml-xpathengine-perl all 0.14-1 [33.3 kB]\nGet:137 http://deb.debian.org/debian buster/main amd64 libxmuu1 amd64 2:1.1.2-2+b3 [23.9 kB]\nGet:138 http://deb.debian.org/debian buster/main amd64 libxtst6 amd64 2:1.2.3-1 [27.8 kB]\nGet:139 http://deb.debian.org/debian buster/main amd64 libxv1 amd64 2:1.0.11-1 [24.6 kB]\nGet:140 http://deb.debian.org/debian buster/main amd64 libxxf86dga1 amd64 2:1.1.4-1+b3 [22.1 kB]\nGet:141 http://deb.debian.org/debian buster/main amd64 xfonts-encodings all 1:1.0.4-2 [574 kB]\nGet:142 http://deb.debian.org/debian buster/main amd64 xfonts-utils amd64 1:7.7+6 [93.0 kB]\nGet:143 http://deb.debian.org/debian buster/main amd64 lmodern all 2.004.5-6 [9,488 kB]\nGet:144 http://deb.debian.org/debian buster/main amd64 preview-latex-style all 11.91-2 [201 kB]\nGet:145 http://deb.debian.org/debian buster/main amd64 tcl8.6 amd64 8.6.9+dfsg-2 [123 kB]\nGet:146 http://deb.debian.org/debian buster/main amd64 tcl amd64 8.6.9+1 [5,636 B]\nGet:147 http://deb.debian.org/debian buster/main amd64 tex-gyre all 20180621-3 [6,210 kB]\nGet:148 http://deb.debian.org/debian buster/main amd64 texlive-fonts-recommended all 2018.20190227-2 [5,228 kB]\nGet:149 http://deb.debian.org/debian buster/main amd64 texlive-pictures all 2018.20190227-2 [8,201 kB]\nGet:150 http://deb.debian.org/debian buster/main amd64 texlive-latex-extra all 2018.20190227-2 [12.3 MB]\nGet:151 http://deb.debian.org/debian buster/main amd64 texlive-plain-generic all 2018.20190227-2 [24.3 MB]\nGet:152 http://deb.debian.org/debian buster/main amd64 tipa all 2:1.3-20 [2,972 kB]\nGet:153 http://deb.debian.org/debian buster/main amd64 tk8.6 amd64 8.6.9-2 [72.1 kB]\nGet:154 http://deb.debian.org/debian buster/main amd64 tk amd64 8.6.9+1 [5,676 B]\nGet:155 http://deb.debian.org/debian buster/main amd64 libglx0 amd64 1.1.0-1 [30.0 kB]\nGet:156 http://deb.debian.org/debian buster/main amd64 libgl1 amd64 1.1.0-1 [91.1 kB]\nGet:157 http://deb.debian.org/debian buster/main amd64 x11-utils amd64 7.7+4 [202 kB]\nGet:158 http://deb.debian.org/debian buster/main amd64 x11-xserver-utils amd64 7.7+8 [168 kB]\nGet:159 http://deb.debian.org/debian buster/main amd64 xbitmaps all 1.1.1-2 [32.1 kB]\nGet:160 http://deb.debian.org/debian buster/main amd64 xterm amd64 344-1+deb10u2 [771 kB]\nGet:161 http://deb.debian.org/debian buster/main amd64 zip amd64 3.0-11+b1 [234 kB]\nFetched 212 MB in 1s (144 MB/s)\ndebconf: delaying package configuration, since apt-utils is not installed\nSelecting previously unselected package libpython2.7-minimal:amd64.\n(Reading database ... 31092 files and directories currently installed.)\nPreparing to unpack .../0-libpython2.7-minimal_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking libpython2.7-minimal:amd64 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2.7-minimal.\nPreparing to unpack .../1-python2.7-minimal_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking python2.7-minimal (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2-minimal.\nPreparing to unpack .../2-python2-minimal_2.7.16-1_amd64.deb ...\nUnpacking python2-minimal (2.7.16-1) ...\nSelecting previously unselected package python-minimal.\nPreparing to unpack .../3-python-minimal_2.7.16-1_amd64.deb ...\nUnpacking python-minimal (2.7.16-1) ...\nSelecting previously unselected package libpython2.7-stdlib:amd64.\nPreparing to unpack .../4-libpython2.7-stdlib_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking libpython2.7-stdlib:amd64 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package python2.7.\nPreparing to unpack .../5-python2.7_2.7.16-2+deb10u4_amd64.deb ...\nUnpacking python2.7 (2.7.16-2+deb10u4) ...\nSelecting previously unselected package libpython2-stdlib:amd64.\nPreparing to unpack .../6-libpython2-stdlib_2.7.16-1_amd64.deb ...\nUnpacking libpython2-stdlib:amd64 (2.7.16-1) ...\nSelecting previously unselected package libpython-stdlib:amd64.\nPreparing to unpack .../7-libpython-stdlib_2.7.16-1_amd64.deb ...\nUnpacking libpython-stdlib:amd64 (2.7.16-1) ...\nSetting up libpython2.7-minimal:amd64 (2.7.16-2+deb10u4) ...\nSetting up python2.7-minimal (2.7.16-2+deb10u4) ...\nLinking and byte-compiling packages for runtime python2.7...\nSetting up python2-minimal (2.7.16-1) ...\nSelecting previously unselected package python2.\n(Reading database ... 31851 files and directories currently installed.)\nPreparing to unpack .../python2_2.7.16-1_amd64.deb ...\nUnpacking python2 (2.7.16-1) ...\nSetting up python-minimal (2.7.16-1) ...\nSelecting previously unselected package python.\n(Reading database ... 31883 files and directories currently installed.)\nPreparing to unpack .../000-python_2.7.16-1_amd64.deb ...\nUnpacking python (2.7.16-1) ...\nSelecting previously unselected package fonts-droid-fallback.\nPreparing to unpack .../001-fonts-droid-fallback_1%3a6.0.1r16-1.1_all.deb ...\nUnpacking fonts-droid-fallback (1:6.0.1r16-1.1) ...\nSelecting previously unselected package fonts-lato.\nPreparing to unpack .../002-fonts-lato_2.0-2_all.deb ...\nUnpacking fonts-lato (2.0-2) ...\nSelecting previously unselected package poppler-data.\nPreparing to unpack .../003-poppler-data_0.4.9-2_all.deb ...\nUnpacking poppler-data (0.4.9-2) ...\nSelecting previously unselected package tex-common.\nPreparing to unpack .../004-tex-common_6.11_all.deb ...\nUnpacking tex-common (6.11) ...\nSelecting previously unselected package libpaper1:amd64.\nPreparing to unpack .../005-libpaper1_1.1.28_amd64.deb ...\nUnpacking libpaper1:amd64 (1.1.28) ...\nSelecting previously unselected package libpaper-utils.\nPreparing to unpack .../006-libpaper-utils_1.1.28_amd64.deb ...\nUnpacking libpaper-utils (1.1.28) ...\nSelecting previously unselected package libkpathsea6:amd64.\nPreparing to unpack .../007-libkpathsea6_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libkpathsea6:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libptexenc1:amd64.\nPreparing to unpack .../008-libptexenc1_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libptexenc1:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libsynctex2:amd64.\nPreparing to unpack .../009-libsynctex2_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libsynctex2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexlua52:amd64.\nPreparing to unpack .../010-libtexlua52_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexlua52:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexlua53:amd64.\nPreparing to unpack .../011-libtexlua53_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexlua53:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package libtexluajit2:amd64.\nPreparing to unpack .../012-libtexluajit2_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking libtexluajit2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package t1utils.\nPreparing to unpack .../013-t1utils_1.41-3_amd64.deb ...\nUnpacking t1utils (1.41-3) ...\nSelecting previously unselected package libbrotli1:amd64.\nPreparing to unpack .../014-libbrotli1_1.0.7-2+deb10u1_amd64.deb ...\nUnpacking libbrotli1:amd64 (1.0.7-2+deb10u1) ...\nSelecting previously unselected package libgs9-common.\nPreparing to unpack .../015-libgs9-common_9.27~dfsg-2+deb10u9_all.deb ...\nUnpacking libgs9-common (9.27~dfsg-2+deb10u9) ...\nPreparing to unpack .../016-libcups2_2.2.10-6+deb10u10_amd64.deb ...\nUnpacking libcups2:amd64 (2.2.10-6+deb10u10) over (2.2.10-6+deb10u9) ...\nSelecting previously unselected package libcupsimage2:amd64.\nPreparing to unpack .../017-libcupsimage2_2.2.10-6+deb10u10_amd64.deb ...\nUnpacking libcupsimage2:amd64 (2.2.10-6+deb10u10) ...\nSelecting previously unselected package libidn11:amd64.\nPreparing to unpack .../018-libidn11_1.33-2.2_amd64.deb ...\nUnpacking libidn11:amd64 (1.33-2.2) ...\nSelecting previously unselected package libijs-0.35:amd64.\nPreparing to unpack .../019-libijs-0.35_0.35-14_amd64.deb ...\nUnpacking libijs-0.35:amd64 (0.35-14) ...\nSelecting previously unselected package libjbig2dec0:amd64.\nPreparing to unpack .../020-libjbig2dec0_0.16-1+deb10u1_amd64.deb ...\nUnpacking libjbig2dec0:amd64 (0.16-1+deb10u1) ...\nSelecting previously unselected package liblcms2-2:amd64.\nPreparing to unpack .../021-liblcms2-2_2.9-3_amd64.deb ...\nUnpacking liblcms2-2:amd64 (2.9-3) ...\nSelecting previously unselected package libopenjp2-7:amd64.\nPreparing to unpack .../022-libopenjp2-7_2.3.0-2+deb10u2_amd64.deb ...\nUnpacking libopenjp2-7:amd64 (2.3.0-2+deb10u2) ...\nSelecting previously unselected package libgs9:amd64.\nPreparing to unpack .../023-libgs9_9.27~dfsg-2+deb10u9_amd64.deb ...\nUnpacking libgs9:amd64 (9.27~dfsg-2+deb10u9) ...\nSelecting previously unselected package libpotrace0:amd64.\nPreparing to unpack .../024-libpotrace0_1.15-1_amd64.deb ...\nUnpacking libpotrace0:amd64 (1.15-1) ...\nSelecting previously unselected package libteckit0:amd64.\nPreparing to unpack .../025-libteckit0_2.5.8+ds2-5_amd64.deb ...\nUnpacking libteckit0:amd64 (2.5.8+ds2-5) ...\nSelecting previously unselected package libwoff1:amd64.\nPreparing to unpack .../026-libwoff1_1.0.2-1_amd64.deb ...\nUnpacking libwoff1:amd64 (1.0.2-1) ...\nSelecting previously unselected package libxxhash0:amd64.\nPreparing to unpack .../027-libxxhash0_0.6.5-2_amd64.deb ...\nUnpacking libxxhash0:amd64 (0.6.5-2) ...\nSelecting previously unselected package libzzip-0-13:amd64.\nPreparing to unpack .../028-libzzip-0-13_0.13.62-3.2+deb10u1_amd64.deb ...\nUnpacking libzzip-0-13:amd64 (0.13.62-3.2+deb10u1) ...\nSelecting previously unselected package texlive-binaries.\nPreparing to unpack .../029-texlive-binaries_2018.20181218.49446-1+deb10u2_amd64.deb ...\nUnpacking texlive-binaries (2018.20181218.49446-1+deb10u2) ...\nSelecting previously unselected package xdg-utils.\nPreparing to unpack .../030-xdg-utils_1.1.3-1+deb10u1_all.deb ...\nUnpacking xdg-utils (1.1.3-1+deb10u1) ...\nSelecting previously unselected package texlive-base.\nPreparing to unpack .../031-texlive-base_2018.20190227-2_all.deb ...\nUnpacking texlive-base (2018.20190227-2) ...\nSelecting previously unselected package fonts-lmodern.\nPreparing to unpack .../032-fonts-lmodern_2.004.5-6_all.deb ...\nUnpacking fonts-lmodern (2.004.5-6) ...\nSelecting previously unselected package texlive-latex-base.\nPreparing to unpack .../033-texlive-latex-base_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-base (2018.20190227-2) ...\nSelecting previously unselected package texlive-latex-recommended.\nPreparing to unpack .../034-texlive-latex-recommended_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-recommended (2018.20190227-2) ...\nSelecting previously unselected package cm-super-minimal.\nPreparing to unpack .../035-cm-super-minimal_0.3.4-14_all.deb ...\nUnpacking cm-super-minimal (0.3.4-14) ...\nSelecting previously unselected package pfb2t1c2pfb.\nPreparing to unpack .../036-pfb2t1c2pfb_0.3-11_amd64.deb ...\nUnpacking pfb2t1c2pfb (0.3-11) ...\nSelecting previously unselected package cm-super.\nPreparing to unpack .../037-cm-super_0.3.4-14_all.deb ...\nUnpacking cm-super (0.3.4-14) ...\nSelecting previously unselected package ghostscript.\nPreparing to unpack .../038-ghostscript_9.27~dfsg-2+deb10u9_amd64.deb ...\nUnpacking ghostscript (9.27~dfsg-2+deb10u9) ...\nSelecting previously unselected package dvipng.\nPreparing to unpack .../039-dvipng_1.15-1.1_amd64.deb ...\nUnpacking dvipng (1.15-1.1) ...\nSelecting previously unselected package fonts-noto-mono.\nPreparing to unpack .../040-fonts-noto-mono_20181227-1_all.deb ...\nUnpacking fonts-noto-mono (20181227-1) ...\nSelecting previously unselected package fonts-texgyre.\nPreparing to unpack .../041-fonts-texgyre_20180621-3_all.deb ...\nUnpacking fonts-texgyre (20180621-3) ...\nSelecting previously unselected package gsfonts.\nPreparing to unpack .../042-gsfonts_1%3a8.11+urwcyr1.0.7~pre44-4.4_all.deb ...\nUnpacking gsfonts (1:8.11+urwcyr1.0.7~pre44-4.4) ...\nSelecting previously unselected package javascript-common.\nPreparing to unpack .../043-javascript-common_11_all.deb ...\nUnpacking javascript-common (11) ...\nSelecting previously unselected package libauthen-sasl-perl.\nPreparing to unpack .../044-libauthen-sasl-perl_2.1600-1_all.deb ...\nUnpacking libauthen-sasl-perl (2.1600-1) ...\nSelecting previously unselected package libcupsfilters1:amd64.\nPreparing to unpack .../045-libcupsfilters1_1.21.6-5+deb10u1_amd64.deb ...\nUnpacking libcupsfilters1:amd64 (1.21.6-5+deb10u1) ...\nSelecting previously unselected package libdata-dump-perl.\nPreparing to unpack .../046-libdata-dump-perl_1.23-1_all.deb ...\nUnpacking libdata-dump-perl (1.23-1) ...\nSelecting previously unselected package libdrm-common.\nPreparing to unpack .../047-libdrm-common_2.4.97-1_all.deb ...\nUnpacking libdrm-common (2.4.97-1) ...\nSelecting previously unselected package libdrm2:amd64.\nPreparing to unpack .../048-libdrm2_2.4.97-1_amd64.deb ...\nUnpacking libdrm2:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-amdgpu1:amd64.\nPreparing to unpack .../049-libdrm-amdgpu1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-amdgpu1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libpciaccess0:amd64.\nPreparing to unpack .../050-libpciaccess0_0.14-1_amd64.deb ...\nUnpacking libpciaccess0:amd64 (0.14-1) ...\nSelecting previously unselected package libdrm-intel1:amd64.\nPreparing to unpack .../051-libdrm-intel1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-intel1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-nouveau2:amd64.\nPreparing to unpack .../052-libdrm-nouveau2_2.4.97-1_amd64.deb ...\nUnpacking libdrm-nouveau2:amd64 (2.4.97-1) ...\nSelecting previously unselected package libdrm-radeon1:amd64.\nPreparing to unpack .../053-libdrm-radeon1_2.4.97-1_amd64.deb ...\nUnpacking libdrm-radeon1:amd64 (2.4.97-1) ...\nSelecting previously unselected package libencode-locale-perl.\nPreparing to unpack .../054-libencode-locale-perl_1.05-1_all.deb ...\nUnpacking libencode-locale-perl (1.05-1) ...\nSelecting previously unselected package libipc-system-simple-perl.\nPreparing to unpack .../055-libipc-system-simple-perl_1.25-4_all.deb ...\nUnpacking libipc-system-simple-perl (1.25-4) ...\nSelecting previously unselected package libfile-basedir-perl.\nPreparing to unpack .../056-libfile-basedir-perl_0.08-1_all.deb ...\nUnpacking libfile-basedir-perl (0.08-1) ...\nSelecting previously unselected package liburi-perl.\nPreparing to unpack .../057-liburi-perl_1.76-1_all.deb ...\nUnpacking liburi-perl (1.76-1) ...\nSelecting previously unselected package libfile-desktopentry-perl.\nPreparing to unpack .../058-libfile-desktopentry-perl_0.22-1_all.deb ...\nUnpacking libfile-desktopentry-perl (0.22-1) ...\nSelecting previously unselected package libtimedate-perl.\nPreparing to unpack .../059-libtimedate-perl_2.3000-2+deb10u1_all.deb ...\nUnpacking libtimedate-perl (2.3000-2+deb10u1) ...\nSelecting previously unselected package libhttp-date-perl.\nPreparing to unpack .../060-libhttp-date-perl_6.02-1_all.deb ...\nUnpacking libhttp-date-perl (6.02-1) ...\nSelecting previously unselected package libfile-listing-perl.\nPreparing to unpack .../061-libfile-listing-perl_6.04-1_all.deb ...\nUnpacking libfile-listing-perl (6.04-1) ...\nSelecting previously unselected package libfile-mimeinfo-perl.\nPreparing to unpack .../062-libfile-mimeinfo-perl_0.29-1_all.deb ...\nUnpacking libfile-mimeinfo-perl (0.29-1) ...\nSelecting previously unselected package libfont-afm-perl.\nPreparing to unpack .../063-libfont-afm-perl_1.20-2_all.deb ...\nUnpacking libfont-afm-perl (1.20-2) ...\nSelecting previously unselected package libfontenc1:amd64.\nPreparing to unpack .../064-libfontenc1_1%3a1.1.3-1+b2_amd64.deb ...\nUnpacking libfontenc1:amd64 (1:1.1.3-1+b2) ...\nSelecting previously unselected package libglapi-mesa:amd64.\nPreparing to unpack .../065-libglapi-mesa_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libglapi-mesa:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libllvm7:amd64.\nPreparing to unpack .../066-libllvm7_1%3a7.0.1-8+deb10u2_amd64.deb ...\nUnpacking libllvm7:amd64 (1:7.0.1-8+deb10u2) ...\nSelecting previously unselected package libsensors-config.\nPreparing to unpack .../067-libsensors-config_1%3a3.5.0-3_all.deb ...\nUnpacking libsensors-config (1:3.5.0-3) ...\nSelecting previously unselected package libsensors5:amd64.\nPreparing to unpack .../068-libsensors5_1%3a3.5.0-3_amd64.deb ...\nUnpacking libsensors5:amd64 (1:3.5.0-3) ...\nSelecting previously unselected package libgl1-mesa-dri:amd64.\nPreparing to unpack .../069-libgl1-mesa-dri_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libgl1-mesa-dri:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libglvnd0:amd64.\nPreparing to unpack .../070-libglvnd0_1.1.0-1_amd64.deb ...\nUnpacking libglvnd0:amd64 (1.1.0-1) ...\nSelecting previously unselected package libx11-xcb1:amd64.\nPreparing to unpack .../071-libx11-xcb1_2%3a1.6.7-1+deb10u4_amd64.deb ...\nUnpacking libx11-xcb1:amd64 (2:1.6.7-1+deb10u4) ...\nSelecting previously unselected package libxcb-dri2-0:amd64.\nPreparing to unpack .../072-libxcb-dri2-0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-dri2-0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-dri3-0:amd64.\nPreparing to unpack .../073-libxcb-dri3-0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-dri3-0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-glx0:amd64.\nPreparing to unpack .../074-libxcb-glx0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-glx0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-present0:amd64.\nPreparing to unpack .../075-libxcb-present0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-present0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxcb-sync1:amd64.\nPreparing to unpack .../076-libxcb-sync1_1.13.1-2_amd64.deb ...\nUnpacking libxcb-sync1:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxshmfence1:amd64.\nPreparing to unpack .../077-libxshmfence1_1.3-1_amd64.deb ...\nUnpacking libxshmfence1:amd64 (1.3-1) ...\nSelecting previously unselected package libxxf86vm1:amd64.\nPreparing to unpack .../078-libxxf86vm1_1%3a1.1.4-1+b2_amd64.deb ...\nUnpacking libxxf86vm1:amd64 (1:1.1.4-1+b2) ...\nSelecting previously unselected package libglx-mesa0:amd64.\nPreparing to unpack .../079-libglx-mesa0_18.3.6-2+deb10u1_amd64.deb ...\nUnpacking libglx-mesa0:amd64 (18.3.6-2+deb10u1) ...\nSelecting previously unselected package libhtml-tagset-perl.\nPreparing to unpack .../080-libhtml-tagset-perl_3.20-3_all.deb ...\nUnpacking libhtml-tagset-perl (3.20-3) ...\nSelecting previously unselected package libhtml-parser-perl.\nPreparing to unpack .../081-libhtml-parser-perl_3.72-3+b3_amd64.deb ...\nUnpacking libhtml-parser-perl (3.72-3+b3) ...\nSelecting previously unselected package libio-html-perl.\nPreparing to unpack .../082-libio-html-perl_1.001-1_all.deb ...\nUnpacking libio-html-perl (1.001-1) ...\nSelecting previously unselected package liblwp-mediatypes-perl.\nPreparing to unpack .../083-liblwp-mediatypes-perl_6.02-1_all.deb ...\nUnpacking liblwp-mediatypes-perl (6.02-1) ...\nSelecting previously unselected package libhttp-message-perl.\nPreparing to unpack .../084-libhttp-message-perl_6.18-1_all.deb ...\nUnpacking libhttp-message-perl (6.18-1) ...\nSelecting previously unselected package libhtml-form-perl.\nPreparing to unpack .../085-libhtml-form-perl_6.03-1_all.deb ...\nUnpacking libhtml-form-perl (6.03-1) ...\nSelecting previously unselected package libhtml-tree-perl.\nPreparing to unpack .../086-libhtml-tree-perl_5.07-2_all.deb ...\nUnpacking libhtml-tree-perl (5.07-2) ...\nSelecting previously unselected package libhtml-format-perl.\nPreparing to unpack .../087-libhtml-format-perl_2.12-1_all.deb ...\nUnpacking libhtml-format-perl (2.12-1) ...\nSelecting previously unselected package libhttp-cookies-perl.\nPreparing to unpack .../088-libhttp-cookies-perl_6.04-1_all.deb ...\nUnpacking libhttp-cookies-perl (6.04-1) ...\nSelecting previously unselected package libhttp-daemon-perl.\nPreparing to unpack .../089-libhttp-daemon-perl_6.01-3+deb10u1_all.deb ...\nUnpacking libhttp-daemon-perl (6.01-3+deb10u1) ...\nSelecting previously unselected package libhttp-negotiate-perl.\nPreparing to unpack .../090-libhttp-negotiate-perl_6.01-1_all.deb ...\nUnpacking libhttp-negotiate-perl (6.01-1) ...\nSelecting previously unselected package perl-openssl-defaults:amd64.\nPreparing to unpack .../091-perl-openssl-defaults_3_amd64.deb ...\nUnpacking perl-openssl-defaults:amd64 (3) ...\nSelecting previously unselected package libnet-ssleay-perl.\nPreparing to unpack .../092-libnet-ssleay-perl_1.85-2+deb10u1_amd64.deb ...\nUnpacking libnet-ssleay-perl (1.85-2+deb10u1) ...\nSelecting previously unselected package libio-socket-ssl-perl.\nPreparing to unpack .../093-libio-socket-ssl-perl_2.060-3_all.deb ...\nUnpacking libio-socket-ssl-perl (2.060-3) ...\nSelecting previously unselected package libio-stringy-perl.\nPreparing to unpack .../094-libio-stringy-perl_2.111-3_all.deb ...\nUnpacking libio-stringy-perl (2.111-3) ...\nSelecting previously unselected package libjs-jquery.\nPreparing to unpack .../095-libjs-jquery_3.3.1~dfsg-3+deb10u1_all.deb ...\nUnpacking libjs-jquery (3.3.1~dfsg-3+deb10u1) ...\nSelecting previously unselected package libnet-http-perl.\nPreparing to unpack .../096-libnet-http-perl_6.18-1_all.deb ...\nUnpacking libnet-http-perl (6.18-1) ...\nSelecting previously unselected package libtry-tiny-perl.\nPreparing to unpack .../097-libtry-tiny-perl_0.30-1_all.deb ...\nUnpacking libtry-tiny-perl (0.30-1) ...\nSelecting previously unselected package libwww-robotrules-perl.\nPreparing to unpack .../098-libwww-robotrules-perl_6.02-1_all.deb ...\nUnpacking libwww-robotrules-perl (6.02-1) ...\nSelecting previously unselected package libwww-perl.\nPreparing to unpack .../099-libwww-perl_6.36-2_all.deb ...\nUnpacking libwww-perl (6.36-2) ...\nSelecting previously unselected package liblwp-protocol-https-perl.\nPreparing to unpack .../100-liblwp-protocol-https-perl_6.07-2_all.deb ...\nUnpacking liblwp-protocol-https-perl (6.07-2) ...\nSelecting previously unselected package libnet-smtp-ssl-perl.\nPreparing to unpack .../101-libnet-smtp-ssl-perl_1.04-1_all.deb ...\nUnpacking libnet-smtp-ssl-perl (1.04-1) ...\nSelecting previously unselected package libmailtools-perl.\nPreparing to unpack .../102-libmailtools-perl_2.18-1_all.deb ...\nUnpacking libmailtools-perl (2.18-1) ...\nSelecting previously unselected package libxml-parser-perl.\nPreparing to unpack .../103-libxml-parser-perl_2.44-4_amd64.deb ...\nUnpacking libxml-parser-perl (2.44-4) ...\nSelecting previously unselected package libxml-twig-perl.\nPreparing to unpack .../104-libxml-twig-perl_1%3a3.50-1.1_all.deb ...\nUnpacking libxml-twig-perl (1:3.50-1.1) ...\nSelecting previously unselected package libnet-dbus-perl.\nPreparing to unpack .../105-libnet-dbus-perl_1.1.0-5+b1_amd64.deb ...\nUnpacking libnet-dbus-perl (1.1.0-5+b1) ...\nSelecting previously unselected package rubygems-integration.\nPreparing to unpack .../106-rubygems-integration_1.11+deb10u1_all.deb ...\nUnpacking rubygems-integration (1.11+deb10u1) ...\nSelecting previously unselected package ruby2.5.\nPreparing to unpack .../107-ruby2.5_2.5.5-3+deb10u6_amd64.deb ...\nUnpacking ruby2.5 (2.5.5-3+deb10u6) ...\nSelecting previously unselected package ruby.\nPreparing to unpack .../108-ruby_1%3a2.5.1_amd64.deb ...\nUnpacking ruby (1:2.5.1) ...\nSelecting previously unselected package rake.\nPreparing to unpack .../109-rake_12.3.1-3+deb10u1_all.deb ...\nUnpacking rake (12.3.1-3+deb10u1) ...\nSelecting previously unselected package ruby-did-you-mean.\nPreparing to unpack .../110-ruby-did-you-mean_1.2.1-1_all.deb ...\nUnpacking ruby-did-you-mean (1.2.1-1) ...\nSelecting previously unselected package ruby-minitest.\nPreparing to unpack .../111-ruby-minitest_5.11.3-1_all.deb ...\nUnpacking ruby-minitest (5.11.3-1) ...\nSelecting previously unselected package ruby-net-telnet.\nPreparing to unpack .../112-ruby-net-telnet_0.1.1-2_all.deb ...\nUnpacking ruby-net-telnet (0.1.1-2) ...\nSelecting previously unselected package ruby-power-assert.\nPreparing to unpack .../113-ruby-power-assert_1.1.1-1_all.deb ...\nUnpacking ruby-power-assert (1.1.1-1) ...\nSelecting previously unselected package ruby-test-unit.\nPreparing to unpack .../114-ruby-test-unit_3.2.8-1_all.deb ...\nUnpacking ruby-test-unit (3.2.8-1) ...\nSelecting previously unselected package ruby-xmlrpc.\nPreparing to unpack .../115-ruby-xmlrpc_0.3.0-2_all.deb ...\nUnpacking ruby-xmlrpc (0.3.0-2) ...\nSelecting previously unselected package libyaml-0-2:amd64.\nPreparing to unpack .../116-libyaml-0-2_0.2.1-1_amd64.deb ...\nUnpacking libyaml-0-2:amd64 (0.2.1-1) ...\nSelecting previously unselected package libruby2.5:amd64.\nPreparing to unpack .../117-libruby2.5_2.5.5-3+deb10u6_amd64.deb ...\nUnpacking libruby2.5:amd64 (2.5.5-3+deb10u6) ...\nSelecting previously unselected package libtcl8.6:amd64.\nPreparing to unpack .../118-libtcl8.6_8.6.9+dfsg-2_amd64.deb ...\nUnpacking libtcl8.6:amd64 (8.6.9+dfsg-2) ...\nSelecting previously unselected package libtext-iconv-perl.\nPreparing to unpack .../119-libtext-iconv-perl_1.7-5+b7_amd64.deb ...\nUnpacking libtext-iconv-perl (1.7-5+b7) ...\nSelecting previously unselected package libtie-ixhash-perl.\nPreparing to unpack .../120-libtie-ixhash-perl_1.23-2_all.deb ...\nUnpacking libtie-ixhash-perl (1.23-2) ...\nSelecting previously unselected package libxss1:amd64.\nPreparing to unpack .../121-libxss1_1%3a1.2.3-1_amd64.deb ...\nUnpacking libxss1:amd64 (1:1.2.3-1) ...\nSelecting previously unselected package libtk8.6:amd64.\nPreparing to unpack .../122-libtk8.6_8.6.9-2_amd64.deb ...\nUnpacking libtk8.6:amd64 (8.6.9-2) ...\nSelecting previously unselected package libutempter0:amd64.\nPreparing to unpack .../123-libutempter0_1.1.6-3_amd64.deb ...\nUnpacking libutempter0:amd64 (1.1.6-3) ...\nSelecting previously unselected package libx11-protocol-perl.\nPreparing to unpack .../124-libx11-protocol-perl_0.56-7_all.deb ...\nUnpacking libx11-protocol-perl (0.56-7) ...\nSelecting previously unselected package libxcb-shape0:amd64.\nPreparing to unpack .../125-libxcb-shape0_1.13.1-2_amd64.deb ...\nUnpacking libxcb-shape0:amd64 (1.13.1-2) ...\nSelecting previously unselected package libxml-xpathengine-perl.\nPreparing to unpack .../126-libxml-xpathengine-perl_0.14-1_all.deb ...\nUnpacking libxml-xpathengine-perl (0.14-1) ...\nSelecting previously unselected package libxmuu1:amd64.\nPreparing to unpack .../127-libxmuu1_2%3a1.1.2-2+b3_amd64.deb ...\nUnpacking libxmuu1:amd64 (2:1.1.2-2+b3) ...\nSelecting previously unselected package libxtst6:amd64.\nPreparing to unpack .../128-libxtst6_2%3a1.2.3-1_amd64.deb ...\nUnpacking libxtst6:amd64 (2:1.2.3-1) ...\nSelecting previously unselected package libxv1:amd64.\nPreparing to unpack .../129-libxv1_2%3a1.0.11-1_amd64.deb ...\nUnpacking libxv1:amd64 (2:1.0.11-1) ...\nSelecting previously unselected package libxxf86dga1:amd64.\nPreparing to unpack .../130-libxxf86dga1_2%3a1.1.4-1+b3_amd64.deb ...\nUnpacking libxxf86dga1:amd64 (2:1.1.4-1+b3) ...\nSelecting previously unselected package xfonts-encodings.\nPreparing to unpack .../131-xfonts-encodings_1%3a1.0.4-2_all.deb ...\nUnpacking xfonts-encodings (1:1.0.4-2) ...\nSelecting previously unselected package xfonts-utils.\nPreparing to unpack .../132-xfonts-utils_1%3a7.7+6_amd64.deb ...\nUnpacking xfonts-utils (1:7.7+6) ...\nSelecting previously unselected package lmodern.\nPreparing to unpack .../133-lmodern_2.004.5-6_all.deb ...\nUnpacking lmodern (2.004.5-6) ...\nSelecting previously unselected package preview-latex-style.\nPreparing to unpack .../134-preview-latex-style_11.91-2_all.deb ...\nUnpacking preview-latex-style (11.91-2) ...\nSelecting previously unselected package tcl8.6.\nPreparing to unpack .../135-tcl8.6_8.6.9+dfsg-2_amd64.deb ...\nUnpacking tcl8.6 (8.6.9+dfsg-2) ...\nSelecting previously unselected package tcl.\nPreparing to unpack .../136-tcl_8.6.9+1_amd64.deb ...\nUnpacking tcl (8.6.9+1) ...\nSelecting previously unselected package tex-gyre.\nPreparing to unpack .../137-tex-gyre_20180621-3_all.deb ...\nUnpacking tex-gyre (20180621-3) ...\nSelecting previously unselected package texlive-fonts-recommended.\nPreparing to unpack .../138-texlive-fonts-recommended_2018.20190227-2_all.deb ...\nUnpacking texlive-fonts-recommended (2018.20190227-2) ...\nSelecting previously unselected package texlive-pictures.\nPreparing to unpack .../139-texlive-pictures_2018.20190227-2_all.deb ...\nUnpacking texlive-pictures (2018.20190227-2) ...\nSelecting previously unselected package texlive-latex-extra.\nPreparing to unpack .../140-texlive-latex-extra_2018.20190227-2_all.deb ...\nUnpacking texlive-latex-extra (2018.20190227-2) ...\nSelecting previously unselected package texlive-plain-generic.\nPreparing to unpack .../141-texlive-plain-generic_2018.20190227-2_all.deb ...\nUnpacking texlive-plain-generic (2018.20190227-2) ...\nSelecting previously unselected package tipa.\nPreparing to unpack .../142-tipa_2%3a1.3-20_all.deb ...\nUnpacking tipa (2:1.3-20) ...\nSelecting previously unselected package tk8.6.\nPreparing to unpack .../143-tk8.6_8.6.9-2_amd64.deb ...\nUnpacking tk8.6 (8.6.9-2) ...\nSelecting previously unselected package tk.\nPreparing to unpack .../144-tk_8.6.9+1_amd64.deb ...\nUnpacking tk (8.6.9+1) ...\nSelecting previously unselected package libglx0:amd64.\nPreparing to unpack .../145-libglx0_1.1.0-1_amd64.deb ...\nUnpacking libglx0:amd64 (1.1.0-1) ...\nSelecting previously unselected package libgl1:amd64.\nPreparing to unpack .../146-libgl1_1.1.0-1_amd64.deb ...\nUnpacking libgl1:amd64 (1.1.0-1) ...\nSelecting previously unselected package x11-utils.\nPreparing to unpack .../147-x11-utils_7.7+4_amd64.deb ...\nUnpacking x11-utils (7.7+4) ...\nSelecting previously unselected package x11-xserver-utils.\nPreparing to unpack .../148-x11-xserver-utils_7.7+8_amd64.deb ...\nUnpacking x11-xserver-utils (7.7+8) ...\nSelecting previously unselected package xbitmaps.\nPreparing to unpack .../149-xbitmaps_1.1.1-2_all.deb ...\nUnpacking xbitmaps (1.1.1-2) ...\nSelecting previously unselected package xterm.\nPreparing to unpack .../150-xterm_344-1+deb10u2_amd64.deb ...\nUnpacking xterm (344-1+deb10u2) ...\nSelecting previously unselected package zip.\nPreparing to unpack .../151-zip_3.0-11+b1_amd64.deb ...\nUnpacking zip (3.0-11+b1) ...\nSetting up pfb2t1c2pfb (0.3-11) ...\nSetting up libgs9-common (9.27~dfsg-2+deb10u9) ...\nSetting up libtext-iconv-perl (1.7-5+b7) ...\nSetting up javascript-common (11) ...\nSetting up libxcb-dri3-0:amd64 (1.13.1-2) ...\nSetting up liblcms2-2:amd64 (2.9-3) ...\nSetting up libpaper1:amd64 (1.1.28) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\n\nCreating config file /etc/papersize with new version\nSetting up libx11-xcb1:amd64 (2:1.6.7-1+deb10u4) ...\nSetting up libpciaccess0:amd64 (0.14-1) ...\nSetting up libtie-ixhash-perl (1.23-2) ...\nSetting up fonts-lato (2.0-2) ...\nSetting up fonts-noto-mono (20181227-1) ...\nSetting up libtexlua52:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libfont-afm-perl (1.20-2) ...\nSetting up ruby-power-assert (1.1.1-1) ...\nSetting up libtexlua53:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libyaml-0-2:amd64 (0.2.1-1) ...\nSetting up libglvnd0:amd64 (1.1.0-1) ...\nSetting up libio-stringy-perl (2.111-3) ...\nSetting up libxtst6:amd64 (2:1.2.3-1) ...\nSetting up libhtml-tagset-perl (3.20-3) ...\nSetting up libijs-0.35:amd64 (0.35-14) ...\nSetting up libauthen-sasl-perl (2.1600-1) ...\nSetting up libxcb-glx0:amd64 (1.13.1-2) ...\nSetting up libtexluajit2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libbrotli1:amd64 (1.0.7-2+deb10u1) ...\nSetting up liblwp-mediatypes-perl (6.02-1) ...\nSetting up libxcb-shape0:amd64 (1.13.1-2) ...\nSetting up libtry-tiny-perl (0.30-1) ...\nSetting up libsensors-config (1:3.5.0-3) ...\nSetting up libxxf86dga1:amd64 (2:1.1.4-1+b3) ...\nSetting up perl-openssl-defaults:amd64 (3) ...\nSetting up libencode-locale-perl (1.05-1) ...\nSetting up rubygems-integration (1.11+deb10u1) ...\nSetting up libzzip-0-13:amd64 (0.13.62-3.2+deb10u1) ...\nSetting up libpaper-utils (1.1.28) ...\nSetting up libxxf86vm1:amd64 (1:1.1.4-1+b2) ...\nSetting up poppler-data (0.4.9-2) ...\nSetting up libpython2.7-stdlib:amd64 (2.7.16-2+deb10u4) ...\nSetting up libxcb-present0:amd64 (1.13.1-2) ...\nSetting up ruby-minitest (5.11.3-1) ...\nSetting up tex-common (6.11) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\nupdate-language: texlive-base not installed and configured, doing nothing!\nSetting up zip (3.0-11+b1) ...\nSetting up libfontenc1:amd64 (1:1.1.3-1+b2) ...\nSetting up ruby-test-unit (3.2.8-1) ...\nSetting up libdata-dump-perl (1.23-1) ...\nSetting up libxcb-sync1:amd64 (1.13.1-2) ...\nSetting up libjbig2dec0:amd64 (0.16-1+deb10u1) ...\nSetting up libipc-system-simple-perl (1.25-4) ...\nSetting up libidn11:amd64 (1.33-2.2) ...\nSetting up libteckit0:amd64 (2.5.8+ds2-5) ...\nSetting up libxml-xpathengine-perl (0.14-1) ...\nSetting up gsfonts (1:8.11+urwcyr1.0.7~pre44-4.4) ...\nSetting up ruby-net-telnet (0.1.1-2) ...\nSetting up xfonts-encodings (1:1.0.4-2) ...\nSetting up t1utils (1.41-3) ...\nSetting up libxv1:amd64 (2:1.0.11-1) ...\nSetting up libio-html-perl (1.001-1) ...\nSetting up libtcl8.6:amd64 (8.6.9+dfsg-2) ...\nSetting up fonts-texgyre (20180621-3) ...\nSetting up libsensors5:amd64 (1:3.5.0-3) ...\nSetting up libglapi-mesa:amd64 (18.3.6-2+deb10u1) ...\nSetting up libkpathsea6:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libtimedate-perl (2.3000-2+deb10u1) ...\nSetting up libutempter0:amd64 (1.1.6-3) ...\nSetting up libcups2:amd64 (2.2.10-6+deb10u10) ...\nSetting up libxcb-dri2-0:amd64 (1.13.1-2) ...\nSetting up libxshmfence1:amd64 (1.3-1) ...\nSetting up libxxhash0:amd64 (0.6.5-2) ...\nSetting up fonts-lmodern (2.004.5-6) ...\nSetting up libopenjp2-7:amd64 (2.3.0-2+deb10u2) ...\nSetting up libllvm7:amd64 (1:7.0.1-8+deb10u2) ...\nSetting up fonts-droid-fallback (1:6.0.1r16-1.1) ...\nSetting up libxss1:amd64 (1:1.2.3-1) ...\nSetting up libjs-jquery (3.3.1~dfsg-3+deb10u1) ...\nSetting up ruby-did-you-mean (1.2.1-1) ...\nSetting up libdrm-common (2.4.97-1) ...\nSetting up ruby-xmlrpc (0.3.0-2) ...\nSetting up xdg-utils (1.1.3-1+deb10u1) ...\nSetting up liburi-perl (1.76-1) ...\nSetting up libxmuu1:amd64 (2:1.1.2-2+b3) ...\nSetting up libx11-protocol-perl (0.56-7) ...\nSetting up xbitmaps (1.1.1-2) ...\nSetting up libsynctex2:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libpotrace0:amd64 (1.15-1) ...\nSetting up libnet-ssleay-perl (1.85-2+deb10u1) ...\nSetting up libhttp-date-perl (6.02-1) ...\nSetting up tcl8.6 (8.6.9+dfsg-2) ...\nSetting up libfile-basedir-perl (0.08-1) ...\nSetting up libfile-listing-perl (6.04-1) ...\nSetting up python2.7 (2.7.16-2+deb10u4) ...\nSetting up libwoff1:amd64 (1.0.2-1) ...\nSetting up libpython2-stdlib:amd64 (2.7.16-1) ...\nSetting up preview-latex-style (11.91-2) ...\nSetting up libtk8.6:amd64 (8.6.9-2) ...\nSetting up libnet-http-perl (6.18-1) ...\nSetting up xfonts-utils (1:7.7+6) ...\nSetting up x11-xserver-utils (7.7+8) ...\nSetting up python2 (2.7.16-1) ...\nSetting up libcupsimage2:amd64 (2.2.10-6+deb10u10) ...\nSetting up libpython-stdlib:amd64 (2.7.16-1) ...\nSetting up libptexenc1:amd64 (2018.20181218.49446-1+deb10u2) ...\nSetting up libfile-desktopentry-perl (0.22-1) ...\nSetting up libwww-robotrules-perl (6.02-1) ...\nSetting up libdrm2:amd64 (2.4.97-1) ...\nSetting up lmodern (2.004.5-6) ...\nSetting up libhtml-parser-perl (3.72-3+b3) ...\nSetting up tcl (8.6.9+1) ...\nSetting up xterm (344-1+deb10u2) ...\nupdate-alternatives: using /usr/bin/xterm to provide /usr/bin/x-terminal-emulator (x-terminal-emulator) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/x-terminal-emulator.1.gz because associated file /usr/share/man/man1/xterm.1.gz (of link group x-terminal-emulator) doesn't exist\nupdate-alternatives: using /usr/bin/lxterm to provide /usr/bin/x-terminal-emulator (x-terminal-emulator) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/x-terminal-emulator.1.gz because associated file /usr/share/man/man1/lxterm.1.gz (of link group x-terminal-emulator) doesn't exist\nSetting up python (2.7.16-1) ...\nSetting up tex-gyre (20180621-3) ...\nSetting up libcupsfilters1:amd64 (1.21.6-5+deb10u1) ...\nSetting up libio-socket-ssl-perl (2.060-3) ...\nSetting up libhttp-message-perl (6.18-1) ...\nSetting up libdrm-amdgpu1:amd64 (2.4.97-1) ...\nSetting up libhtml-form-perl (6.03-1) ...\nSetting up tk8.6 (8.6.9-2) ...\nSetting up libfile-mimeinfo-perl (0.29-1) ...\nSetting up libhttp-negotiate-perl (6.01-1) ...\nSetting up libdrm-nouveau2:amd64 (2.4.97-1) ...\nSetting up libgs9:amd64 (9.27~dfsg-2+deb10u9) ...\nSetting up libhttp-cookies-perl (6.04-1) ...\nSetting up libdrm-radeon1:amd64 (2.4.97-1) ...\nSetting up libhtml-tree-perl (5.07-2) ...\nSetting up libdrm-intel1:amd64 (2.4.97-1) ...\nSetting up libgl1-mesa-dri:amd64 (18.3.6-2+deb10u1) ...\nSetting up libhtml-format-perl (2.12-1) ...\nSetting up ghostscript (9.27~dfsg-2+deb10u9) ...\nSetting up libnet-smtp-ssl-perl (1.04-1) ...\nSetting up libmailtools-perl (2.18-1) ...\nSetting up libhttp-daemon-perl (6.01-3+deb10u1) ...\nSetting up texlive-binaries (2018.20181218.49446-1+deb10u2) ...\nupdate-alternatives: using /usr/bin/xdvi-xaw to provide /usr/bin/xdvi.bin (xdvi.bin) in auto mode\nupdate-alternatives: using /usr/bin/bibtex.original to provide /usr/bin/bibtex (bibtex) in auto mode\nupdate-alternatives: warning: skip creation of /usr/share/man/man1/bibtex.1.gz because associated file /usr/share/man/man1/bibtex.original.1.gz (of link group bibtex) doesn't exist\nSetting up tk (8.6.9+1) ...\nSetting up texlive-base (2018.20190227-2) ...\nmktexlsr: Updating /var/lib/texmf/ls-R-TEXLIVEDIST... \nmktexlsr: Updating /var/lib/texmf/ls-R-TEXMFMAIN... \nmktexlsr: Updating /var/lib/texmf/ls-R... \nmktexlsr: Done.\ntl-paper: setting paper size for dvips to a4: /var/lib/texmf/dvips/config/config-paper.ps\ntl-paper: setting paper size for dvipdfmx to a4: /var/lib/texmf/dvipdfmx/dvipdfmx-paper.cfg\ntl-paper: setting paper size for xdvi to a4: /var/lib/texmf/xdvi/XDvi-paper\ntl-paper: setting paper size for pdftex to a4: /var/lib/texmf/tex/generic/config/pdftexconfig.tex\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\ntl-paper: setting paper size for dvipdfmx to letter: /var/lib/texmf/dvipdfmx/dvipdfmx-paper.cfg\ntl-paper: setting paper size for dvips to letter: /var/lib/texmf/dvips/config/config-paper.ps\ntl-paper: setting paper size for pdftex to letter: /var/lib/texmf/tex/generic/config/pdftexconfig.tex\ntl-paper: setting paper size for xdvi to letter: /var/lib/texmf/xdvi/XDvi-paper\nSetting up libglx-mesa0:amd64 (18.3.6-2+deb10u1) ...\nSetting up libglx0:amd64 (1.1.0-1) ...\nSetting up dvipng (1.15-1.1) ...\nSetting up texlive-plain-generic (2018.20190227-2) ...\nSetting up libgl1:amd64 (1.1.0-1) ...\nSetting up texlive-latex-base (2018.20190227-2) ...\nSetting up texlive-latex-recommended (2018.20190227-2) ...\nSetting up texlive-pictures (2018.20190227-2) ...\nSetting up texlive-fonts-recommended (2018.20190227-2) ...\nSetting up x11-utils (7.7+4) ...\nSetting up tipa (2:1.3-20) ...\nRegenerating '/var/lib/texmf/fmtutil.cnf-DEBIAN'... done.\nRegenerating '/var/lib/texmf/fmtutil.cnf-TEXLIVEDIST'... done.\nupdate-fmtutil has updated the following file(s):\n\t/var/lib/texmf/fmtutil.cnf-DEBIAN\n\t/var/lib/texmf/fmtutil.cnf-TEXLIVEDIST\nIf you want to activate the changes in the above file(s),\nyou should run fmtutil-sys or fmtutil.\nSetting up cm-super-minimal (0.3.4-14) ...\nSetting up texlive-latex-extra (2018.20190227-2) ...\nSetting up cm-super (0.3.4-14) ...\nCreating fonts. This may take some time... done.\nSetting up rake (12.3.1-3+deb10u1) ...\nSetting up liblwp-protocol-https-perl (6.07-2) ...\nSetting up libwww-perl (6.36-2) ...\nSetting up libruby2.5:amd64 (2.5.5-3+deb10u6) ...\nSetting up libxml-parser-perl (2.44-4) ...\nSetting up ruby2.5 (2.5.5-3+deb10u6) ...\nSetting up libxml-twig-perl (1:3.50-1.1) ...\nSetting up libnet-dbus-perl (1.1.0-5+b1) ...\nSetting up ruby (1:2.5.1) ...\nProcessing triggers for fontconfig (2.13.1-2) ...\nProcessing triggers for mime-support (3.62) ...\nProcessing triggers for hicolor-icon-theme (0.17-2) ...\nProcessing triggers for libc-bin (2.28-10+deb10u2) ...\nProcessing triggers for tex-common (6.11) ...\ndebconf: unable to initialize frontend: Dialog\ndebconf: (No usable dialog-like program is installed, so the dialog based frontend cannot be used. at /usr/share/perl5/Debconf/FrontEnd/Dialog.pm line 78.)\ndebconf: falling back to frontend: Readline\nRunning updmap-sys. This may take some time... done.\nRunning mktexlsr /var/lib/texmf ... done.\nBuilding format(s) --all.\n\tThis may take some time... done.\nCollecting SciencePlots\n Downloading SciencePlots-2.1.1-py3-none-any.whl (16 kB)\nCollecting openpyxl\n Downloading openpyxl-3.1.4-py2.py3-none-any.whl (251 kB)\n\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m251.4/251.4 kB\u001b[0m \u001b[31m40.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n\u001b[?25hRequirement already satisfied: matplotlib in /shared-libs/python3.9/py/lib/python3.9/site-packages (from SciencePlots) (3.6.0)\nCollecting et-xmlfile\n Downloading et_xmlfile-1.1.0-py3-none-any.whl (4.7 kB)\nRequirement already satisfied: kiwisolver>=1.0.1 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.4.4)\nRequirement already satisfied: contourpy>=1.0.1 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.0.5)\nRequirement already satisfied: pillow>=6.2.0 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (9.2.0)\nRequirement already satisfied: fonttools>=4.22.0 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (4.37.4)\nRequirement already satisfied: numpy>=1.19 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (1.23.4)\nRequirement already satisfied: cycler>=0.10 in /shared-libs/python3.9/py/lib/python3.9/site-packages (from matplotlib->SciencePlots) (0.11.0)\nRequirement already satisfied: python-dateutil>=2.7 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (2.8.2)\nRequirement already satisfied: packaging>=20.0 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (21.3)\nRequirement already satisfied: pyparsing>=2.2.1 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from matplotlib->SciencePlots) (3.0.9)\nRequirement already satisfied: six>=1.5 in /shared-libs/python3.9/py-core/lib/python3.9/site-packages (from python-dateutil>=2.7->matplotlib->SciencePlots) (1.16.0)\nInstalling collected packages: et-xmlfile, openpyxl, SciencePlots\nSuccessfully installed SciencePlots-2.1.1 et-xmlfile-1.1.0 openpyxl-3.1.4\n\n\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n","output_type":"stream"}],"outputs_reference":"s3:deepnote-cell-outputs-production/8921d5ad-e970-45e1-9100-6138a484ed48","content_dependencies":null},{"cell_type":"code","metadata":{"allow_embed":false,"source_hash":null,"execution_start":1718231586226,"execution_millis":447,"deepnote_to_be_reexecuted":false,"cell_id":"829528eb6caf438e88940cf85a4147aa","deepnote_cell_type":"code"},"source":"","block_group":"77d168b5c0b84278a477dfbea34f4eee","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"code","metadata":{"allow_embed":false,"source_hash":null,"execution_start":1718514112999,"execution_millis":2722,"deepnote_to_be_reexecuted":false,"cell_id":"1d0fcde745af4722b660fae88e374da3","deepnote_cell_type":"code"},"source":"import os.path as osp\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport scienceplots\nplt.style.use('science')","block_group":"5690dcf48d1a4ee2918eee3dee3ea40e","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"markdown","metadata":{"formattedRanges":[],"cell_id":"4a55fe60b2ac4c99b110119e3e5f344f","deepnote_cell_type":"text-cell-h1"},"source":"# Lineplot for varying number of authors that know the author identities","block_group":"d32f448e0d9a4c409cece2637ebdffa5"},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718511175798,"execution_millis":9529,"deepnote_to_be_reexecuted":false,"cell_id":"8654b441cca745b3be658202de40d009","deepnote_cell_type":"code"},"source":"FONT_SIZE = 22\n\n# sns.set_style(\"whitegrid\")\n\nexperiment_names = [\"authors_are_famous_Rx1\", \"authors_are_famous_Rx2\", \"authors_are_famous_Rx3\"]\n\nresults = pd.read_excel(\"ac_decision_metrics_known_authors.xlsx\")\n\n\nresults.set_index(\"experiment_name\", inplace=True)\n\nfig, axes = plt.subplots(2, 2, figsize=(9, 10), sharey=True)\n\nmetric_name2label = {\n \"jacc\": \"Jaccard Index\",\n \"kappa\": \"Cohen's Kappa\",\n}\n\nfig.suptitle(f'Agreement of Final Decisions w.r.t. Baseline', fontsize=FONT_SIZE)\n\nidx_plot = 0\n\nindices = \"abcd\"\n\nfor i, metric_name in enumerate([\"jacc\", \"kappa\"]):\n\n for j, ratio_of_accepted_papers in enumerate([0.0, 1.0]):\n df = results[results[\"ratio_accepted\"] == ratio_of_accepted_papers]\n \n ax = axes[i][j]\n\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\n\n df = df.astype({\n # \"ratio_accepted\": str,\n \"percentage_known_authors\": int,\n \"known_authors\": str,\n })\n\n print(metric_name)\n print(df)\n\n sns.lineplot(data=df, x=\"percentage_known_authors\", y=metric_name, hue=\"known_authors\", marker='o',\n markersize=12,\n linewidth=3, ax=ax, \n palette=['#102C57', '#1679AB', '#FFB1B1']\n )\n\n ax.set_xlabel(\"\")\n ax.set_ylabel(metric_name2label[metric_name], fontsize=FONT_SIZE)\n\n # ax.set_xticks([10, 20, 30])\n\n # Set the size of the xticks and yticks\n ax.tick_params(axis='x', labelsize=FONT_SIZE)\n ax.tick_params(axis='y', labelsize=FONT_SIZE)\n\n # Customize the legend\n legend = ax.legend(title='#Reviewers that Know the Authors (k)', title_fontsize=15, fontsize=12)\n legend.remove()\n\n if ratio_of_accepted_papers == 1.0:\n ax.set_title(f\"({indices[idx_plot]}) Higher Quality\", fontsize=FONT_SIZE)\n\n elif ratio_of_accepted_papers == 0.0:\n ax.set_title(f\"({indices[idx_plot]}) Lower Quality\", fontsize=FONT_SIZE)\n\n if metric_name == \"jacc\":\n ax.set_ylim(0.0, 0.82)\n\n elif metric_name == \"kappa\":\n ax.set_ylim(-0.45, 0.82)\n\n else:\n raise ValueError(f\"Unknown metric: {metric_name}\")\n\n idx_plot += 1\n\n# Add a common x-axis label\nfig.text(0.5, 0.03, '\\%Papers with Known Author Identities (r)', ha='center', fontsize=FONT_SIZE)\n\n# Add a common legend\nhandles, labels = axes[0][0].get_legend_handles_labels()\nlegend = fig.legend(handles, labels, title='\\#Reviewers that Know the Authors (k)', title_fontsize=24,\n fontsize=12,\n loc='upper center', ncol=3, bbox_to_anchor=(0.5, 0.95))\n\nlegend.get_frame().set_facecolor('none') # Set transparent background\nlegend.get_frame().set_edgecolor('none') # Remove border\n\n# Adjust layout to make room for the common x-axis label and legend\nfig.tight_layout(rect=[0, 0.05, 1, 0.88], pad=0.4, h_pad=0.5, w_pad=0.5)\nfig.subplots_adjust(top=1.5, hspace=0.3, wspace=0.2)\nplt.savefig(f\"lineplot_known_authors.pdf\", dpi=300, bbox_inches='tight')\n\n\n","block_group":"b0de0f023cb6409984d44f31a2074aef","execution_count":null,"outputs":[{"name":"stderr","text":"/tmp/ipykernel_37/1382934154.py:32: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\n/tmp/ipykernel_37/1382934154.py:32: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\njacc\n ratio_accepted \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 0 \nauthors_are_famous_Rx1_known0.2_accept0.0 0 \nauthors_are_famous_Rx1_known0.3_accept0.0 0 \nauthors_are_famous_Rx2_known0.1_accept0.0 0 \nauthors_are_famous_Rx2_known0.2_accept0.0 0 \nauthors_are_famous_Rx2_known0.3_accept0.0 0 \nauthors_are_famous_Rx3_known0.1_accept0.0 0 \nauthors_are_famous_Rx3_known0.2_accept0.0 0 \nauthors_are_famous_Rx3_known0.3_accept0.0 0 \n\n percentage_known_authors \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 10 \nauthors_are_famous_Rx1_known0.2_accept0.0 20 \nauthors_are_famous_Rx1_known0.3_accept0.0 30 \nauthors_are_famous_Rx2_known0.1_accept0.0 10 \nauthors_are_famous_Rx2_known0.2_accept0.0 20 \nauthors_are_famous_Rx2_known0.3_accept0.0 30 \nauthors_are_famous_Rx3_known0.1_accept0.0 10 \nauthors_are_famous_Rx3_known0.2_accept0.0 20 \nauthors_are_famous_Rx3_known0.3_accept0.0 30 \n\n known_authors jacc kappa \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 1 0.690141 0.739202 \nauthors_are_famous_Rx1_known0.2_accept0.0 1 0.690141 0.739202 \nauthors_are_famous_Rx1_known0.3_accept0.0 1 0.714286 0.762911 \nauthors_are_famous_Rx2_known0.1_accept0.0 2 0.578947 0.620657 \nauthors_are_famous_Rx2_known0.2_accept0.0 2 0.518987 0.549531 \nauthors_are_famous_Rx2_known0.3_accept0.0 2 0.463415 0.478404 \nauthors_are_famous_Rx3_known0.1_accept0.0 3 0.363636 0.336150 \nauthors_are_famous_Rx3_known0.2_accept0.0 3 0.153846 -0.043192 \nauthors_are_famous_Rx3_known0.3_accept0.0 3 0.008403 -0.398826 \n\n %agree #agree \nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 89.108911 180 \nauthors_are_famous_Rx1_known0.2_accept0.0 89.108911 180 \nauthors_are_famous_Rx1_known0.3_accept0.0 90.099010 182 \nauthors_are_famous_Rx2_known0.1_accept0.0 84.158416 170 \nauthors_are_famous_Rx2_known0.2_accept0.0 81.188119 164 \nauthors_are_famous_Rx2_known0.3_accept0.0 78.217822 158 \nauthors_are_famous_Rx3_known0.1_accept0.0 72.277228 146 \nauthors_are_famous_Rx3_known0.2_accept0.0 56.435644 114 \nauthors_are_famous_Rx3_known0.3_accept0.0 41.584158 84 \njacc\n ratio_accepted \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 1 \nauthors_are_famous_Rx1_known0.2_accept1.0 1 \nauthors_are_famous_Rx1_known0.3_accept1.0 1 \nauthors_are_famous_Rx2_known0.1_accept1.0 1 \nauthors_are_famous_Rx2_known0.2_accept1.0 1 \nauthors_are_famous_Rx2_known0.3_accept1.0 1 \nauthors_are_famous_Rx3_known0.1_accept1.0 1 \nauthors_are_famous_Rx3_known0.2_accept1.0 1 \nauthors_are_famous_Rx3_known0.3_accept1.0 1 \n\n percentage_known_authors \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 10 \nauthors_are_famous_Rx1_known0.2_accept1.0 20 \nauthors_are_famous_Rx1_known0.3_accept1.0 30 \nauthors_are_famous_Rx2_known0.1_accept1.0 10 \nauthors_are_famous_Rx2_known0.2_accept1.0 20 \nauthors_are_famous_Rx2_known0.3_accept1.0 30 \nauthors_are_famous_Rx3_known0.1_accept1.0 10 \nauthors_are_famous_Rx3_known0.2_accept1.0 20 \nauthors_are_famous_Rx3_known0.3_accept1.0 30 \n\n known_authors jacc kappa \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 1 0.666667 0.715493 \nauthors_are_famous_Rx1_known0.2_accept1.0 1 0.739130 0.786620 \nauthors_are_famous_Rx1_known0.3_accept1.0 1 0.666667 0.715493 \nauthors_are_famous_Rx2_known0.1_accept1.0 2 0.481481 0.502113 \nauthors_are_famous_Rx2_known0.2_accept1.0 2 0.500000 0.525822 \nauthors_are_famous_Rx2_known0.3_accept1.0 2 0.463415 0.478404 \nauthors_are_famous_Rx3_known0.1_accept1.0 3 0.558442 0.596948 \nauthors_are_famous_Rx3_known0.2_accept1.0 3 0.621622 0.668075 \nauthors_are_famous_Rx3_known0.3_accept1.0 3 0.558442 0.596948 \n\n %agree #agree \nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 88.118812 178 \nauthors_are_famous_Rx1_known0.2_accept1.0 91.089109 184 \nauthors_are_famous_Rx1_known0.3_accept1.0 88.118812 178 \nauthors_are_famous_Rx2_known0.1_accept1.0 79.207921 160 \nauthors_are_famous_Rx2_known0.2_accept1.0 80.198020 162 \nauthors_are_famous_Rx2_known0.3_accept1.0 78.217822 158 \nauthors_are_famous_Rx3_known0.1_accept1.0 83.168317 168 \nauthors_are_famous_Rx3_known0.2_accept1.0 86.138614 174 \nauthors_are_famous_Rx3_known0.3_accept1.0 83.168317 168 \n/tmp/ipykernel_37/1382934154.py:32: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\n/tmp/ipykernel_37/1382934154.py:32: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\nkappa\n ratio_accepted \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 0 \nauthors_are_famous_Rx1_known0.2_accept0.0 0 \nauthors_are_famous_Rx1_known0.3_accept0.0 0 \nauthors_are_famous_Rx2_known0.1_accept0.0 0 \nauthors_are_famous_Rx2_known0.2_accept0.0 0 \nauthors_are_famous_Rx2_known0.3_accept0.0 0 \nauthors_are_famous_Rx3_known0.1_accept0.0 0 \nauthors_are_famous_Rx3_known0.2_accept0.0 0 \nauthors_are_famous_Rx3_known0.3_accept0.0 0 \n\n percentage_known_authors \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 10 \nauthors_are_famous_Rx1_known0.2_accept0.0 20 \nauthors_are_famous_Rx1_known0.3_accept0.0 30 \nauthors_are_famous_Rx2_known0.1_accept0.0 10 \nauthors_are_famous_Rx2_known0.2_accept0.0 20 \nauthors_are_famous_Rx2_known0.3_accept0.0 30 \nauthors_are_famous_Rx3_known0.1_accept0.0 10 \nauthors_are_famous_Rx3_known0.2_accept0.0 20 \nauthors_are_famous_Rx3_known0.3_accept0.0 30 \n\n known_authors jacc kappa \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 1 0.690141 0.739202 \nauthors_are_famous_Rx1_known0.2_accept0.0 1 0.690141 0.739202 \nauthors_are_famous_Rx1_known0.3_accept0.0 1 0.714286 0.762911 \nauthors_are_famous_Rx2_known0.1_accept0.0 2 0.578947 0.620657 \nauthors_are_famous_Rx2_known0.2_accept0.0 2 0.518987 0.549531 \nauthors_are_famous_Rx2_known0.3_accept0.0 2 0.463415 0.478404 \nauthors_are_famous_Rx3_known0.1_accept0.0 3 0.363636 0.336150 \nauthors_are_famous_Rx3_known0.2_accept0.0 3 0.153846 -0.043192 \nauthors_are_famous_Rx3_known0.3_accept0.0 3 0.008403 -0.398826 \n\n %agree #agree \nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 89.108911 180 \nauthors_are_famous_Rx1_known0.2_accept0.0 89.108911 180 \nauthors_are_famous_Rx1_known0.3_accept0.0 90.099010 182 \nauthors_are_famous_Rx2_known0.1_accept0.0 84.158416 170 \nauthors_are_famous_Rx2_known0.2_accept0.0 81.188119 164 \nauthors_are_famous_Rx2_known0.3_accept0.0 78.217822 158 \nauthors_are_famous_Rx3_known0.1_accept0.0 72.277228 146 \nauthors_are_famous_Rx3_known0.2_accept0.0 56.435644 114 \nauthors_are_famous_Rx3_known0.3_accept0.0 41.584158 84 \nkappa\n ratio_accepted \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 1 \nauthors_are_famous_Rx1_known0.2_accept1.0 1 \nauthors_are_famous_Rx1_known0.3_accept1.0 1 \nauthors_are_famous_Rx2_known0.1_accept1.0 1 \nauthors_are_famous_Rx2_known0.2_accept1.0 1 \nauthors_are_famous_Rx2_known0.3_accept1.0 1 \nauthors_are_famous_Rx3_known0.1_accept1.0 1 \nauthors_are_famous_Rx3_known0.2_accept1.0 1 \nauthors_are_famous_Rx3_known0.3_accept1.0 1 \n\n percentage_known_authors \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 10 \nauthors_are_famous_Rx1_known0.2_accept1.0 20 \nauthors_are_famous_Rx1_known0.3_accept1.0 30 \nauthors_are_famous_Rx2_known0.1_accept1.0 10 \nauthors_are_famous_Rx2_known0.2_accept1.0 20 \nauthors_are_famous_Rx2_known0.3_accept1.0 30 \nauthors_are_famous_Rx3_known0.1_accept1.0 10 \nauthors_are_famous_Rx3_known0.2_accept1.0 20 \nauthors_are_famous_Rx3_known0.3_accept1.0 30 \n\n known_authors jacc kappa \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 1 0.666667 0.715493 \nauthors_are_famous_Rx1_known0.2_accept1.0 1 0.739130 0.786620 \nauthors_are_famous_Rx1_known0.3_accept1.0 1 0.666667 0.715493 \nauthors_are_famous_Rx2_known0.1_accept1.0 2 0.481481 0.502113 \nauthors_are_famous_Rx2_known0.2_accept1.0 2 0.500000 0.525822 \nauthors_are_famous_Rx2_known0.3_accept1.0 2 0.463415 0.478404 \nauthors_are_famous_Rx3_known0.1_accept1.0 3 0.558442 0.596948 \nauthors_are_famous_Rx3_known0.2_accept1.0 3 0.621622 0.668075 \nauthors_are_famous_Rx3_known0.3_accept1.0 3 0.558442 0.596948 \n\n %agree #agree \nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 88.118812 178 \nauthors_are_famous_Rx1_known0.2_accept1.0 91.089109 184 \nauthors_are_famous_Rx1_known0.3_accept1.0 88.118812 178 \nauthors_are_famous_Rx2_known0.1_accept1.0 79.207921 160 \nauthors_are_famous_Rx2_known0.2_accept1.0 80.198020 162 \nauthors_are_famous_Rx2_known0.3_accept1.0 78.217822 158 \nauthors_are_famous_Rx3_known0.1_accept1.0 83.168317 168 \nauthors_are_famous_Rx3_known0.2_accept1.0 86.138614 174 \nauthors_are_famous_Rx3_known0.3_accept1.0 83.168317 168 \n","output_type":"stream"},{"data":{"text/plain":"
","image/png":"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\n"},"metadata":{"image/png":{"width":922,"height":1518}},"output_type":"display_data"}],"outputs_reference":"s3:deepnote-cell-outputs-production/b703b894-967d-45b3-8594-39b590634b62","content_dependencies":null},{"cell_type":"markdown","metadata":{"formattedRanges":[],"cell_id":"431c5c81040541e495de4daa2d5ff80c","deepnote_cell_type":"text-cell-h3"},"source":"### (V2) Lineplot for varying number of authors that know the author identities","block_group":"3493a72c72a24464ad50b274cbac880b"},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718511512997,"execution_millis":11679,"deepnote_to_be_reexecuted":false,"cell_id":"85a4f9244c1e49e888119616068f6c17","deepnote_cell_type":"code"},"source":"FONT_SIZE = 22\n\n# sns.set_style(\"whitegrid\")\n\nexperiment_names = [\"authors_are_famous_Rx1\", \"authors_are_famous_Rx2\", \"authors_are_famous_Rx3\"]\n\nresults = pd.read_excel(\"ac_decision_metrics_known_authors.xlsx\")\n\n\nresults.set_index(\"experiment_name\", inplace=True)\n\nmetric_name2label = {\n \"jacc\": \"Jaccard Index\",\n \"kappa\": \"Cohen's Kappa\",\n}\n\nindices = \"abcd\"\n\nfor i, metric_name in enumerate([\"jacc\", \"kappa\"]):\n\n fig, axes = plt.subplots(1, 2, figsize=(9, 5.5), sharey=True)\n\n fig.suptitle(f'Agreement of Final Decisions w.r.t. Baseline', fontsize=FONT_SIZE)\n\n idx_plot = 0\n\n for j, ratio_of_accepted_papers in enumerate([0.0, 1.0]):\n df = results[results[\"ratio_accepted\"] == ratio_of_accepted_papers]\n \n ax = axes[j]\n\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\n\n df = df.astype({\n # \"ratio_accepted\": str,\n \"percentage_known_authors\": int,\n \"known_authors\": str,\n })\n\n print(metric_name)\n print(df)\n\n sns.lineplot(data=df, x=\"percentage_known_authors\", y=metric_name, hue=\"known_authors\", marker='o',\n markersize=12,\n linewidth=3, ax=ax, \n palette=['#102C57', '#1679AB', '#FFB1B1']\n )\n\n ax.set_xlabel(\"\")\n ax.set_ylabel(metric_name2label[metric_name], fontsize=FONT_SIZE)\n\n # ax.set_xticks([10, 20, 30])\n\n # Set the size of the xticks and yticks\n ax.tick_params(axis='x', labelsize=FONT_SIZE)\n ax.tick_params(axis='y', labelsize=FONT_SIZE)\n\n # Customize the legend\n legend = ax.legend(title='#Reviewers that Know the Authors (k)', title_fontsize=15, fontsize=12)\n legend.remove()\n\n if ratio_of_accepted_papers == 1.0:\n ax.set_title(f\"({indices[idx_plot]}) Higher Quality\", fontsize=FONT_SIZE)\n\n elif ratio_of_accepted_papers == 0.0:\n ax.set_title(f\"({indices[idx_plot]}) Lower Quality\", fontsize=FONT_SIZE)\n\n if metric_name == \"jacc\":\n ax.set_ylim(0.0, 0.82)\n\n elif metric_name == \"kappa\":\n ax.set_ylim(-0.45, 0.82)\n\n else:\n raise ValueError(f\"Unknown metric: {metric_name}\")\n\n idx_plot += 1\n\n # Add a common x-axis label\n fig.text(0.5, 0.03, '\\%Papers with Known Author Identities (r)', ha='center', fontsize=FONT_SIZE)\n\n # Add a common legend\n handles, labels = axes[0].get_legend_handles_labels()\n legend = fig.legend(handles, labels, title='\\#Reviewers that Know the Authors (k)', title_fontsize=24,\n fontsize=12,\n loc='upper center', ncol=3, bbox_to_anchor=(0.5, 0.95))\n\n legend.get_frame().set_facecolor('none') # Set transparent background\n legend.get_frame().set_edgecolor('none') # Remove border\n\n # Adjust layout to make room for the common x-axis label and legend\n fig.tight_layout(rect=[0, 0.07, 1, 0.88], pad=0.4, h_pad=0.5, w_pad=0.5) # Increase the 2nd parameter in rect to give more space to the legend\n fig.subplots_adjust(top=0.75, hspace=0.2, wspace=0.2) # Lower the \"top\" parameter so that the plot is more squeezed\n plt.savefig(f\"lineplot_known_authors_{metric_name}.pdf\", dpi=300, bbox_inches='tight')\n\n\n","block_group":"067d0b005f1f438291a6706c9b2d1717","execution_count":null,"outputs":[{"name":"stderr","text":"/tmp/ipykernel_37/1381293132.py:32: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\n/tmp/ipykernel_37/1381293132.py:32: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\njacc\n ratio_accepted \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 0 \nauthors_are_famous_Rx1_known0.2_accept0.0 0 \nauthors_are_famous_Rx1_known0.3_accept0.0 0 \nauthors_are_famous_Rx2_known0.1_accept0.0 0 \nauthors_are_famous_Rx2_known0.2_accept0.0 0 \nauthors_are_famous_Rx2_known0.3_accept0.0 0 \nauthors_are_famous_Rx3_known0.1_accept0.0 0 \nauthors_are_famous_Rx3_known0.2_accept0.0 0 \nauthors_are_famous_Rx3_known0.3_accept0.0 0 \n\n percentage_known_authors \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 10 \nauthors_are_famous_Rx1_known0.2_accept0.0 20 \nauthors_are_famous_Rx1_known0.3_accept0.0 30 \nauthors_are_famous_Rx2_known0.1_accept0.0 10 \nauthors_are_famous_Rx2_known0.2_accept0.0 20 \nauthors_are_famous_Rx2_known0.3_accept0.0 30 \nauthors_are_famous_Rx3_known0.1_accept0.0 10 \nauthors_are_famous_Rx3_known0.2_accept0.0 20 \nauthors_are_famous_Rx3_known0.3_accept0.0 30 \n\n known_authors jacc kappa \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 1 0.690141 0.739202 \nauthors_are_famous_Rx1_known0.2_accept0.0 1 0.690141 0.739202 \nauthors_are_famous_Rx1_known0.3_accept0.0 1 0.714286 0.762911 \nauthors_are_famous_Rx2_known0.1_accept0.0 2 0.578947 0.620657 \nauthors_are_famous_Rx2_known0.2_accept0.0 2 0.518987 0.549531 \nauthors_are_famous_Rx2_known0.3_accept0.0 2 0.463415 0.478404 \nauthors_are_famous_Rx3_known0.1_accept0.0 3 0.363636 0.336150 \nauthors_are_famous_Rx3_known0.2_accept0.0 3 0.153846 -0.043192 \nauthors_are_famous_Rx3_known0.3_accept0.0 3 0.008403 -0.398826 \n\n %agree #agree \nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 89.108911 180 \nauthors_are_famous_Rx1_known0.2_accept0.0 89.108911 180 \nauthors_are_famous_Rx1_known0.3_accept0.0 90.099010 182 \nauthors_are_famous_Rx2_known0.1_accept0.0 84.158416 170 \nauthors_are_famous_Rx2_known0.2_accept0.0 81.188119 164 \nauthors_are_famous_Rx2_known0.3_accept0.0 78.217822 158 \nauthors_are_famous_Rx3_known0.1_accept0.0 72.277228 146 \nauthors_are_famous_Rx3_known0.2_accept0.0 56.435644 114 \nauthors_are_famous_Rx3_known0.3_accept0.0 41.584158 84 \njacc\n ratio_accepted \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 1 \nauthors_are_famous_Rx1_known0.2_accept1.0 1 \nauthors_are_famous_Rx1_known0.3_accept1.0 1 \nauthors_are_famous_Rx2_known0.1_accept1.0 1 \nauthors_are_famous_Rx2_known0.2_accept1.0 1 \nauthors_are_famous_Rx2_known0.3_accept1.0 1 \nauthors_are_famous_Rx3_known0.1_accept1.0 1 \nauthors_are_famous_Rx3_known0.2_accept1.0 1 \nauthors_are_famous_Rx3_known0.3_accept1.0 1 \n\n percentage_known_authors \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 10 \nauthors_are_famous_Rx1_known0.2_accept1.0 20 \nauthors_are_famous_Rx1_known0.3_accept1.0 30 \nauthors_are_famous_Rx2_known0.1_accept1.0 10 \nauthors_are_famous_Rx2_known0.2_accept1.0 20 \nauthors_are_famous_Rx2_known0.3_accept1.0 30 \nauthors_are_famous_Rx3_known0.1_accept1.0 10 \nauthors_are_famous_Rx3_known0.2_accept1.0 20 \nauthors_are_famous_Rx3_known0.3_accept1.0 30 \n\n known_authors jacc kappa \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 1 0.666667 0.715493 \nauthors_are_famous_Rx1_known0.2_accept1.0 1 0.739130 0.786620 \nauthors_are_famous_Rx1_known0.3_accept1.0 1 0.666667 0.715493 \nauthors_are_famous_Rx2_known0.1_accept1.0 2 0.481481 0.502113 \nauthors_are_famous_Rx2_known0.2_accept1.0 2 0.500000 0.525822 \nauthors_are_famous_Rx2_known0.3_accept1.0 2 0.463415 0.478404 \nauthors_are_famous_Rx3_known0.1_accept1.0 3 0.558442 0.596948 \nauthors_are_famous_Rx3_known0.2_accept1.0 3 0.621622 0.668075 \nauthors_are_famous_Rx3_known0.3_accept1.0 3 0.558442 0.596948 \n\n %agree #agree \nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 88.118812 178 \nauthors_are_famous_Rx1_known0.2_accept1.0 91.089109 184 \nauthors_are_famous_Rx1_known0.3_accept1.0 88.118812 178 \nauthors_are_famous_Rx2_known0.1_accept1.0 79.207921 160 \nauthors_are_famous_Rx2_known0.2_accept1.0 80.198020 162 \nauthors_are_famous_Rx2_known0.3_accept1.0 78.217822 158 \nauthors_are_famous_Rx3_known0.1_accept1.0 83.168317 168 \nauthors_are_famous_Rx3_known0.2_accept1.0 86.138614 174 \nauthors_are_famous_Rx3_known0.3_accept1.0 83.168317 168 \n/tmp/ipykernel_37/1381293132.py:32: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\nkappa\n ratio_accepted \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 0 \nauthors_are_famous_Rx1_known0.2_accept0.0 0 \nauthors_are_famous_Rx1_known0.3_accept0.0 0 \nauthors_are_famous_Rx2_known0.1_accept0.0 0 \nauthors_are_famous_Rx2_known0.2_accept0.0 0 \nauthors_are_famous_Rx2_known0.3_accept0.0 0 \nauthors_are_famous_Rx3_known0.1_accept0.0 0 \nauthors_are_famous_Rx3_known0.2_accept0.0 0 \nauthors_are_famous_Rx3_known0.3_accept0.0 0 \n\n percentage_known_authors \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 10 \nauthors_are_famous_Rx1_known0.2_accept0.0 20 \nauthors_are_famous_Rx1_known0.3_accept0.0 30 \nauthors_are_famous_Rx2_known0.1_accept0.0 10 \nauthors_are_famous_Rx2_known0.2_accept0.0 20 \nauthors_are_famous_Rx2_known0.3_accept0.0 30 \nauthors_are_famous_Rx3_known0.1_accept0.0 10 \nauthors_are_famous_Rx3_known0.2_accept0.0 20 \nauthors_are_famous_Rx3_known0.3_accept0.0 30 \n\n known_authors jacc kappa \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 1 0.690141 0.739202 \nauthors_are_famous_Rx1_known0.2_accept0.0 1 0.690141 0.739202 \nauthors_are_famous_Rx1_known0.3_accept0.0 1 0.714286 0.762911 \nauthors_are_famous_Rx2_known0.1_accept0.0 2 0.578947 0.620657 \nauthors_are_famous_Rx2_known0.2_accept0.0 2 0.518987 0.549531 \nauthors_are_famous_Rx2_known0.3_accept0.0 2 0.463415 0.478404 \nauthors_are_famous_Rx3_known0.1_accept0.0 3 0.363636 0.336150 \nauthors_are_famous_Rx3_known0.2_accept0.0 3 0.153846 -0.043192 \nauthors_are_famous_Rx3_known0.3_accept0.0 3 0.008403 -0.398826 \n\n %agree #agree \nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept0.0 89.108911 180 \nauthors_are_famous_Rx1_known0.2_accept0.0 89.108911 180 \nauthors_are_famous_Rx1_known0.3_accept0.0 90.099010 182 \nauthors_are_famous_Rx2_known0.1_accept0.0 84.158416 170 \nauthors_are_famous_Rx2_known0.2_accept0.0 81.188119 164 \nauthors_are_famous_Rx2_known0.3_accept0.0 78.217822 158 \nauthors_are_famous_Rx3_known0.1_accept0.0 72.277228 146 \nauthors_are_famous_Rx3_known0.2_accept0.0 56.435644 114 \nauthors_are_famous_Rx3_known0.3_accept0.0 41.584158 84 \n/tmp/ipykernel_37/1381293132.py:32: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df[\"percentage_known_authors\"] = df[\"percentage_known_authors\"] * 100\nkappa\n ratio_accepted \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 1 \nauthors_are_famous_Rx1_known0.2_accept1.0 1 \nauthors_are_famous_Rx1_known0.3_accept1.0 1 \nauthors_are_famous_Rx2_known0.1_accept1.0 1 \nauthors_are_famous_Rx2_known0.2_accept1.0 1 \nauthors_are_famous_Rx2_known0.3_accept1.0 1 \nauthors_are_famous_Rx3_known0.1_accept1.0 1 \nauthors_are_famous_Rx3_known0.2_accept1.0 1 \nauthors_are_famous_Rx3_known0.3_accept1.0 1 \n\n percentage_known_authors \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 10 \nauthors_are_famous_Rx1_known0.2_accept1.0 20 \nauthors_are_famous_Rx1_known0.3_accept1.0 30 \nauthors_are_famous_Rx2_known0.1_accept1.0 10 \nauthors_are_famous_Rx2_known0.2_accept1.0 20 \nauthors_are_famous_Rx2_known0.3_accept1.0 30 \nauthors_are_famous_Rx3_known0.1_accept1.0 10 \nauthors_are_famous_Rx3_known0.2_accept1.0 20 \nauthors_are_famous_Rx3_known0.3_accept1.0 30 \n\n known_authors jacc kappa \\\nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 1 0.666667 0.715493 \nauthors_are_famous_Rx1_known0.2_accept1.0 1 0.739130 0.786620 \nauthors_are_famous_Rx1_known0.3_accept1.0 1 0.666667 0.715493 \nauthors_are_famous_Rx2_known0.1_accept1.0 2 0.481481 0.502113 \nauthors_are_famous_Rx2_known0.2_accept1.0 2 0.500000 0.525822 \nauthors_are_famous_Rx2_known0.3_accept1.0 2 0.463415 0.478404 \nauthors_are_famous_Rx3_known0.1_accept1.0 3 0.558442 0.596948 \nauthors_are_famous_Rx3_known0.2_accept1.0 3 0.621622 0.668075 \nauthors_are_famous_Rx3_known0.3_accept1.0 3 0.558442 0.596948 \n\n %agree #agree \nexperiment_name \nauthors_are_famous_Rx1_known0.1_accept1.0 88.118812 178 \nauthors_are_famous_Rx1_known0.2_accept1.0 91.089109 184 \nauthors_are_famous_Rx1_known0.3_accept1.0 88.118812 178 \nauthors_are_famous_Rx2_known0.1_accept1.0 79.207921 160 \nauthors_are_famous_Rx2_known0.2_accept1.0 80.198020 162 \nauthors_are_famous_Rx2_known0.3_accept1.0 78.217822 158 \nauthors_are_famous_Rx3_known0.1_accept1.0 83.168317 168 \nauthors_are_famous_Rx3_known0.2_accept1.0 86.138614 174 \nauthors_are_famous_Rx3_known0.3_accept1.0 83.168317 168 \n","output_type":"stream"},{"data":{"text/plain":"
","image/png":"iVBORw0KGgoAAAANSUhEUgAAA4IAAAIcCAYAAACjEhDmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy89olMNAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC7p0lEQVR4nOz9e3Qb530ven/B+1UcgrpTN4K62JJdWyCV5trsmKCTvo511o5BqfI+++JuC4ibs5K0JybMvu1qstIVGky7ezlvtg3KfXN6+u5wk4DadZR2nySAvHdT7yStRFi5+CoClGRRlmyRGIp3iuS8fwwHxGVwG9yJ72ctLImYwcwDYDDP/OZ5nt+jkyRJAhEREREREZWMsnwXgIiIiIiIiHKLgSAREREREVGJYSBIRERERERUYhgIUskYGBjIdxFok/J4PBgcHIQoivkuChEREVFSGAhSSfB6vbDZbPB6vfkuCm0ifr8fHR0dAACTyYSurq6kXudyudDc3Bz16OjoCHu0t7dHrWOz2bL5ljKip6cHHR0daG5uhtVq1bQN5TPS6XTBh9pn1NzcjPb2dlitVv6+qSQk+9tob29HR0cHrFYr/H5/voudkkycQ4goCRJRCbBYLBIAyWKx5LsotIkYDAbJ6XRKkiRJTqdTAiA5HI6kXz86OioBkABIgUAg5no+n0/q7e2VAEhmszlsWSAQkBwOR9zX55rP5wt+HpHl1bIt5TOKt47dbi+Y33gmv5NC/H6pMCTz2wgEAkVZ/yVzDuFvgyh9DASpJBiNRgmAJAhCvotCGaAEX/lkt9vDjien0ykJgiCNjo6mtJ1EF3KR+zQajWHPmc3mgr3IEwQh7UBQkqSkf7s+n08yGAxRn1GuZfI7KeTvlzbk65yU7G9DuZHU29ubg1JlTrxzCH8bROlj11Da9DweD6xWK4xGI0RRhMfjyXeRKA2iKMLtdue7GHC73ejs7Az+bTabEQgEYDQas7ZPi8USNQ6xu7sbgiCgu7s7a/stFgaDAW63G16vN6+fRya/E36/ha9Qzknx2O12CIKAgYGBousmGgt/G0TpYyBIm57T6cSpU6dw+vRpAIDD4chziSgdhXIR4/f7YTAYcrpPQRCiAk2LxYJAIACz2ZzTshQqg8GA3t5eeDweuFyuvJQhk98Jv9/CVyjnpESUG1f5+l1kGn8bROljIEib3tTUFARBgMViAbB5KsFSNTw8nO8iAJCPq3wwGAzMTppAX18fABRFYh0qfoVyTkpEEAQAwOTkZH4LQkQFg4EgbWoulyvYEhjamsJgsHgNDg7muwg5I4piVGvDiRMn8haEFgvlt+73+9kVnLKuWM5JSlbdEydO5LkkRFQoGAjSpjY8PBzWbURJQ53qHVyPx4OBgQHYbLawSn9wcBADAwNMXZ8Doiiiu7u7pFrDLl++HHVcmc3mnHdJLUYmkwmA3DWcKBuK6Zzk8XiC3dnZlZKIFBX5LgBRLp06dQpWqzWlFsGenh4AGxeULpcL7e3tMJlMsNlsMBgMsNlsGB4ehtFoRHd3N6ampuD3+9HX14fe3l4MDAxgcnISfr8fJ06cQG9vb9R+bDYbRFEMdt8RRTE4wF9NMuuHlsViscBut8Pj8QQTGyitTXa7PRhcuFwuXLp0CYB8B1kQBJw7dy5mOTJZHlEUMTU1FbW/wcHBsLGdIyMjuHz5cvBvg8GQ1gX/4OAgRkdHIQhCsAynT5+OumDyeDzB7oaiKEaV4+LFiwk/p1T4/X7o9fqYy61WKy5fvgy/349Tp05FjX/V+nlHEkUR/f39aGlpCR7Hap9PIWlvbweAsO8nUqq/OZfLheHhYej1+uCxoiSiUiT6TpTtRLb0CoIQ/K6VzzWZbSmSPYaBzBwXyb6HeKxWK0ZGRoKBlHKuMZvNGBwchN1uD+5DEATY7fZgF3+v1xucwxOQzwE+ny/hPrWenyNl+5yUSX6/H1arNZhMKRYtv3Mtx0Gqvzs1uTr3Zaq8RAUr32lLibLF4XBIbrc76nmTyZT0fG+9vb2qqbnNZrNkMBhUX+Pz+SSHwyEBkOx2u9Tb2yv5fD5JkuR55yJ/dkrK+8j047GmI0hl/dCyWCwW1c/EYrFIgiAE52SK3F+895rN8sSCDKYLDwQCkslkkux2e9Qyi8USdz+ZnBpB7VQcCARUP9dQiebaysTnrcxDFslkMkkmkyneW8v59BGh3G53zNel+puTJPlzMhqNUXOW2e32sO0k+k56e3tVzz3KnJKpbEuStB3D6R4XqbyHRAKBgCQIQswpVJTztRplHr1U5u5M9fycjEyek7TsO9b3NDo6GpzmJlH5tPzOUz0OtPzuYp1DcnHu01JeomLDQJA2rVgXTkrlkegiVpKkmJWMso14FzzKa0PXcTqdURWnwWCIWUmrBWGprq+UxWQyqVbaysVUb2+v6vtRLqjVgupslifWxV0mL7pMJlPcbcVbnulA0Gg0Bh/KBWmyF9WJypLO522xWIIXyqECgUDCecnyGQgqF6NqF/apHrPKHGyxJq5We49q710JemKJ9RuM9zmmcwxrOS60vod47Ha7BED1OFPOP7EuurUeX8men5PdVj4DQSWojXz09vZKFoslqe8k1d+5luNAS12R6BySzXOflvISFRsGgrQpxbq7qVAqz1gXdpK0cSGpdqEbb1noPhJdvMa7AJKkjYsgpUJNdX1FvDvuicqqXAiotThkszyxPttMXXQpwXy8u7rK96wWBGezRTAQCATvOmciEEzn81aCUrXfSqLJ2wuhRTDyfad6zIbeKFGjtFhFHiNq7105nmKdd9xud0qBYCaO4VSPC63vIZ54n3G8Fq3R0VHNE7lrOabibasQWwRDmUwmyWAwxL2hl8rvPNXjIJ26Ip1AUOu5T2t5iYoNk8XQpjQyMhIc26dGGbcwMjKS1n5aWlriLg+dcFyNMq4hVvIP5fXKmL1U1w+VaKLzRGVVSzmezfJkOwFDf3+/6rx8oZRldrs9q2WJJAgCzGZzcBqETND6eRuNxpjfbyFPZaGUK7LsqR6zynevZB+OZDAYIAhCUgl8jEYjBEFAR0cHXC5X1GdnMpkSfk+hMnEMp3pcZPo9APJnaDQaVcduT05O4tSpU6rn6shkYKlKdM7bTNxud3DydbXEZqn+zlM9DtKpK9Kl5dyXz/IS5RKTxdCm5HQ646bYV078DocjmHwgklJ5qE0WrDyXqIJJdHHo9/shCAIGBgbirqeUN9X1UymLlkyU2SxPtnm93qQuWAVByNsUBEajMWOBltbPOzLhhd/vh9/vD05tUahTWcT6jaZ6zCoJQGJ9fg6HI24Sl0gXL15EV1dX8EaV0WiEyWTC6dOn416Mq8nEMazluMjke1BYrdZg9uXQc297ezs6OzsxODgIj8cTzAabCfk+B+Wa3W5Hd3c3urq6EAgEwpZp+Z2nchykU1ekK9d1G1ExYSBIm47f74fRaEzYiqPT6eD1eoMptdX09vZicHAwLGMYIF/8mUymhBcl8bKKKReqBoMhbpY6ZVmq62dboZUnFWrBfSEqlBY3v98Ph8MRvEg/ffo0Ojs7YTAYCjYQVO7Ud3d3B5/TcswqrSeZyhBoNBoRCAQwODgIt9sdnJpmYGAAZrM56UyT+TyGM/UeQikZnUMDa5fLBYvFEmxxVc67gJzBN/S71aLUsj4qn50oiqo3EVL9nSd7HBRbXVFs5SVKB7uG0qYTOol8PEpLYLypJJSU2z09PcELcuUOYbqpwZX02sle6Ke6frYVUnmUu9fJSqXs+Xx/Spe5fBoYGEB7eztaWlrgdrtht9uD3cIK+ULa4/FAEISwFn8tx2ym36Oyb4vFAqfTiUAgAJ/Ph97eXrhcruBcp4nk8xjO1HsIJQgCTCZTWBdQn88X/PzNZnPYudrtdme0dTDTUj0n5YryeUaWTcvvPNnjoJDqimQUW3mJ0sFAkDadS5cuJXXxrHRnidety+FwYHR0FA6HAyMjIxgYGIDRaAyOt0iHcpc72RaVVNfPtkIqj9J9KVnKxU2isisXAvkOxvJFmTfRYrGo3v2OvFBSG3uUDwMDAxBFMWqMpZZjVhkLlIn35vV6MTg4GPW8wWCA3W6H3W5XXa4mX8dwJt9DJOWGm8fjgdfrDWvxU4KKVOaAzadUz0m5ojZ2VsvvPJXjoJDqimQUW3mJ0sFAkDYVZULgZJhMJgiCEPfOrTKuxmAwBCvJTN6FViaqTXSRqVz8pLp+thVKebRU2H19fcGLzliU1olMJm0pJkr36lgtPJG/m+Hh4ayXKRFlUmyj0ah6UZvqMau893gT04eun0i8zyjWeOVY8nUMZ/I9qL3W6XRGJYJRWscdDgdcLlfa3UKzrRCDiNDALPTGgNbfeSrHQaHUFckqtvISacVAkDYVu92eUhY5pbKK1Sqo1+ths9kyUrZY+zcajXH3obRCallfka0uLvkoj8FgiLow8fv9KWcA7O3tDV5YxuJwOGA2m9PKTFgItH7eSqu3Wuu3KIqYmpoqqO5Toiiiq6sLer0eFy9eVF0n1WPWbDbDZDLFXX9wcDDphBRKa4qaqamplBJbpHsMa/3uMvkeIpnN5uC47EinT5+Gx+PB8PBwwhtyLpcrYy1yibaVyjkpk+VKhSiKwWM4cliD1t95KseB1roiXVqP8XyVlyjXGAjSpuFyuYKZ5ZKltB7GuvCw2+0YGBiATqcLezQ3N6O7uzt41zBSaJbPRJQLVrW7sS6XCwaDIaxCTXX9yDLFej7WHWzl+Vivz3V5bDYbPB5P2GcbOpYoFRcvXoTf71ctuzI+9Ny5czHLme4FXejr0wmoRFFM+Hotn7fyuUQmXlJa3ZQLSuViMHI6lWTKlYjy+njbEUURAwMDaGtrg8FgwOjoaNzjIdVj1ul0orOzE93d3VHlUM43ajc7YpXZ4XCoHjs2m0117HG8baVzDCvbjvd8rN9hqu8hWcr4brXpf5Qbd4kCTZfLhZ6eHnR0dKguT+X8nGhbQPLnpGS2lYpkfhvKftva2gDIx3JkEJ3O7zyV40BLXZHoHJKtc5/W8hIVG50kSVK+C0GUDrXscYky14miiI6OjrAKTBAE6PV6OJ3O4EWdEuh1dHQEB5Ard0d9Ph9GRkYgimJY4oL29nbV7Sa6OFUyr+n1+uB6Shpureu3t7eH3c0VBAGnTp0KtiColdViscBut8f8jPr6+lS73GW7PKEGBgbCWgX6+vrSGrM5ODgIn88X/FsURXR3d6u2onR0dITdBVe+X7fbnfRFgcvlgs1mi7rTroxNGR0dTWo7yvcT+nna7fbgBXMmPm+v14v+/n4A8gV4S0tLWBIW5bvo7OyE3W4Pzi0WWa7Q/abyGUWWT+1CEZC7elut1pTu0GfiN9fd3R12YR3vO/F6vbh8+TIsFgsGBgYwOTkZvKienJwMBm7JbEutbMkew+kcF6m+By3a29vD3kuo7u7uYCKTWPx+f/B7iTzmUj0/x9tWqGTOScluK5FUfhtTU1Po7OyE0WiMe55M9Xfu9/s1HwfJ/O4SnUNyce5LpbxExYqBIFEMHR0dOH36dMIU0T09PfB4PFHzMhERERERFSoGgkQqlFbGZH8eOp0OPp+P3USIiIiIqChwjCBRDKl2NUx3LBQRERERUa4wECRSoYzzSCY19MDAQEFM/E1ERERElKyKfBeAqFCNjo6iu7sbU1NTMefGUgbQJ5vcg4iIiIioEHCMIFECLpcLbrc7qquoKIro6enJ6ATzRERERES5wECQiIiIiIioxHCMIBERERERUYlhIEhERERERFRiGAgSERERERGVGAaCREREREREJYaBIBEREREVLKvVmtHteb1eDAwMZHSbRMWIgSARERFtKjabLd9FoAzp7u7O+PdpNBohCAKPEyp5DASJ1nV3d8Pj8agus9lsce8eer1e6HQ61Ud7ezva29vR3NyM5uZmtLe3w2q1wuv1Zuut0CZltVrR0dGB9vZ26HS6fBcnYzweD5qbm4O/mcj/+/3+mK/1+/1h6yqvjfVbpvg2wzHm8XgwMDBQFMfAZvi8s6mnpwdWqxUGgyHqeeVza25u1rRti8UCURThcrkyUVSiosRAkGidx+OJqmwULpcr5jJAvrsoSRIkSYLRaAQAmM1mSJIEn88Hn8+HQCCAQCAQnJy+q6sL3d3dcS9yiUJZrVZYrdZNd8yYTCYEAgFIkgSDwQBRFGEymSBJEgKBQNzfnsFggNPpBADo9Xo4nU5IkgSTyZSr4m8qm+EYczgcABA8LgrZZvi8s2VwcBCiKMJsNkctC/3cRFHUvA+73Y6zZ8/y86eSxUCQCHIQKAiC6gWnKIrw+/1JX1gq24h18WowGGC32zE+Pg6/34/29vaCvHOtlK2npyffRaF1RqMRFotlUwc5yo0U5d9k+P1+mM1m+Hy+Tf3Z5MJmOMaU8+nIyEieS5LYZvi8s0EURdhstmBQH8lkMsFisaR0nlAjCALsdnvGxyASFQsGgkQA3G53zIpYaSkUBCGpben1egBAS0tL3PUEQQjese7p6UnrrmY2uFwu+P1+dpvJkVQC7mSPxWwqlBsELpcLk5OTRdH6k2/Fdoxp4XK5YLfbIQhC3rv9lcLnnS39/f2wWCxxewMAG/VtOiwWC/x+f0HekCXKNgaCRJAvHrq7u1WXxQsS06UMWBdFEf39/VnZh1YWiwUWiyXmHVnKrGLrmlQI5XW5XLh06RLsdnu+i1IUCuE7y7bh4WGcOnUKp06dCv6dL6XweWeDKIoYGBjIaSudzWbjeYRKEgNBKnlK10/lwiGSx+OJGSRmQmdnZ3A/hUQQBDgcDlgslnwXpSQU20Vjvsvrcrngdrt58ZaCfH9n2ab0qhAEIdgal88Wwc3+eWfLyMgIjEZjwtbATDp16hQ8Hg+/Myo5DASp5MXr+un3+1MaH6jF1NQUgNhjCmnz83g8Bdc1OJ58l9fj8cDtdrO1OgX5/s5yYWRkBKdPnwYgjyFTzun5CAZL4fPOFofDEfwec0UQBBiNRg6FoJLDQJBKXqLxgUr3zWxR7kBms9WRCluxtWrls7wejwdOp5NBYIqK7RjTwul0hmWYVHoz5ONYKYXPOxtEUYTX681L8hyTyZTXrsRE+cBAkEpevK6f2RwfCMh3qkVRDGaOo9JjtVoLrltwPPksL4NAbYrtGNNCFMWoG3ZKq1KuW+dK4fPOFuVzSzcbKCDP7+v1eoM9exLN3dvd3c35fankVOS7AET5lGhqCOXCMxu8Xi/Onj0Lo9GIixcvJvUaj8cDh8MRzJTm9/thNBrR19cXvAiyWq1hadOVC6Tx8fGoC6WOjg54vd5gwhqz2Qyn04mBgQG43e5gBRoIBGK2iiZbpsHBweDfoijCYDDA5/MBkLPrKRcAygVbZKKayLIajUaMjo6mXBZlf6HzT/l8vrCEPX6/H6dPnw5rXfD7/XA4HGHZYCcnJ3H69Gl4PB6YTKaULl5cLhf6+/vDLlCbm5vDsuCZTKakgp6BgQFMTk5CFEVcvnw5OEVJou7GSrIVQP7cp6am0NfXp/o+MlleLZQbNmpziiVitVpx+fLl4O9dkiQA2j83v98fbPFRjkdAPq5CzyW5Ou5jKYRjLNnfZLoGBwejkoso48z8fj9GRkYS3myLPE4iz3t+vx9WqxVTU1Pw+/0wGAxh30UhfN7JHpuKQjgXhnK73RkZJiGKIrq6usK+C5PJBLfbHfM1yn6V90BUEiSiEuZ0OiWDwaC6zOfzSVp+IhaLRQIg2e32qGWBQEByu92S2WyWjEaj5HA4Utqu0WiUfD5f1POCIKg+D0CyWCxxt2s0GiWDwSCNjo4GnxsdHZWcTqckCIIEQAoEAhkpk9FolADEfN/K/iJfF/menE5nWmUZHR2VHA6HBEAyGAxSIBCQzGazJEnydwQg7Lt3Op3B5ZHsdrsEIOzzS5XJZErpWDObzcHvxWKxRL1nk8kkCYIQ83uTJEnq7e2V3G532HOjo6OSIAgJj5lUy5sK5b319vYGn1N+M8r3ElnuRJTjOfR71fq52e12yWAwRL02EAhIRqNR9bPL5nGfrHwcY6meH9JhMplUn1d+n0ajMeE23G538LwQ67zndruD30e8bebj89ZybBbiuTDW9mOtH+tzVt5X6LkkkXi/U6LNiIEgbWputztYkWXyESt4lCQp7CKht7c3+LBYLJLZbE7qQjtSb29v3AtFg8EQdVGiVOKJLoAsFkvMijv04iQTZVK+D7UgWZISX0i43W7VSl1LWSRpIwiO/D7MZnPYfhJdgEUG0qnSetFosVhUyzU6Ohr3c3Y6nTGDCiVgincxlMtAcHR0NPj9KMeHIAiatq2Uu7e3V9PnZrfbEx4LRqMx6kI2W8d9KnJ9jGn9TWrh8/linlOVG3rxbmhFinfeU2QrENT6eWs9NkOXFcK5UK0M8cT6nAOBgGQymVIuiyAIMT9jos2IgSBtej6fL+ZDueBVW6bcQVVblugueLwKW5I2LpKSufOolDNe5ajc+YxsKVEuLuJVhvHuvirvJfL9plMmQRBiBtLKBXGs7apdwKdTFuUiIt53pQTU8Vovent78xIIxgsOAMRsJVFaZGK1rGX6IjcVoe8tNAhUGAyGpFq6E207llifWzLHmSRtBH2RgXamj/tU5fIYS+c3qUWi35/SIpvsBX4+A8F8HJuh5c33uVAQhJRueqh9zkqrppbfTKqBKFGxY7IY2vQMBoPqQxm3cerUKdXlfr8fPT09qsvSHdtit9vR29sbHEMUj81mAxA/q6gyF2Hk+Ie+vj4AsbPmuVwuTZP2plOmU6dOxRy47/P5YDKZwsY4hlJLCJFOWRTxxoMo++vp6YmZcOL06dNZzSwbS6JMs8rUJGrPi6IY8/MwGAx5T33v9XrhcDiijl1lzO7g4KDmxA5aPjdl3FWi34tyLCljrBSZPu5zRctnlYnfZCq8Xm/cMWlK0phiSDKUj2NTbR01uTgXiqIYNvYwVX6/H2fPnsW5c+c0lUMQhJjnTaLNiIEglazLly9DEATVykIURYiiGLxYyQYlSFMummJRLhzjXegog9wjLzKNRiOMRiMGBwdVK+7h4WFNg+LTKZNysRKZptvv96O9vR1WqxWiKEZl3fN6vejo6MhoWSKXx+JwOOD1etHc3IyOjg7YbLaw8uV68mOF1n2eO3cOTqczZor7QrkYUrtwD82wq0waniotn5sSpCXzWkEQ4PV6w35zmT7uc0XLZ5WJ32Qq+/J4PGhvb4/5CE18UugThufj2Exl/4V6LgQ2fit+v19zMKrX6/N+E4wol5g1lEqW2+2OGejFCxIzJTSTYLwsZcqFS2SWtkixMspZrdZgJtHQrHlerxcnTpzQVPZ0yqTMyzg4OBgWiDgcjrBMgg6HI+wzUWsdSrcsikTfs8VigcFggM1mC6YkHxgYAACYzWbNd5/TFZqNMBWCIASzAPr9/mD2UOXzCc0imC/xggiHw4GRkRH4/X7YbLaU52zT8rkpn0cy37NyMalkyAQyf9znipbPKhO/yWQNDw9jdHQ0YZbK7u7uYAbTQp7jLx/HZqh8nwu1vlbJ8N3X1webzYaBgQH09vamvJ2pqSnN51WiYsRAkEqW1+uN2Q3H6/VmtTVQoaT3jnWXOvRiXGu6dYvFErxYDg0EtV4QZapMAwMDYQFwaPc3s9kMl8uVk7Iky2QyYXR0NBi4X7p0CR6PBy6XCx6PB6Ojo3m7E66Fy+WCzWYLXtSFXjR5PJ6Cn0/L6XSiu7sbAwMDsFqtWf3stQbFka2qmTruC1kuf5OAfK5O5jymTNXhcrkKOhBMVaaOzVRk81yo1+sxOTmZ8uvcbnfwhonb7YbNZtM0jYUyxQtRqWDXUNr0lO5AkQ+l1U9tmTKXUazXZqq1RLnzqMwrFilTF1EWiwV+vz+q25nWMRTpUrrJKRV3ZPc3ZbkyftLlcql2A8xFK5woimEX50prmt1ux+joKNxuN0RR1DTWMpHBwcGsdGWzWq3o6emB1WqF2+3O2JxZ2SqvGpPJFGzV1NpFNFmhx1kyv33lIjvygjJTx30mZfo7y2XLuDK3ZDJOnToFAElNLJ5N2fy80zk2k5GLc2Ho3IepCA3ulXHEWn47U1NTDASppDAQpE0t3tgRpcJSW+bxeDA4OBjztZkas6NU4vEuTJSL3cuXL2veT+QFqNrky6lIt0wGgwFGozF4UeFwOMJaK00mEwRBCFbo8YKVTHw+8UxNTcXtmmcymWC326OC7EKlHNtGozFm16nICzGv11uQY6uUbmherzdh0qV0JXucKeOLlcRSoTJ53BeybP8mFU6nM2yi83gEQQh+lom62ibqGpjvbtORMnFsJiMX50K9Xp9ya2XkzQdBEOBwOIJdx1MhiiLa29tTeg1RMWMgSJuayWSCJE+TEvZwOBwwGo2qy0ZHRwFAdZnyiNWClyrlgkPtIlu5WEyU+VMhimLMSs9gMMBkMsHlcgWzRabaZSZUJsqkZPKLdQFvsVjg8XgSBiCZKEsiiS5slAv4dEVeYIqimPHxKkqQoXz+aiI/81it4LkobzyCIODcuXMA5Jsd2QxWkz3OlMQd2T7utcrFd5aL3yQgH5epBDTKza9Y2VmTlUqgU0ifd6JjMxnZPhcaDIaMtNhaLBaYTCYMDAwkvT3lN8cWQSolDASpJDmdzpgXwvEStyRDuZuZzDgHpVtT5EWfKIq4dOkSAARbblwuV9wKrb+/P24rn1L59/T0xA0CQsW6M5uJMiktITabTbV7l/K67u7uuO8rU59PIvEunvx+f1rHTKzjwOfz5TwJjcvlirpJMDU1FVaOQiqv2WwOljcb3XMVocdZvCDNbrfDZDKFtfSFytRxn6pcfme5+E0qrdqpUFrO1LKzhlJ6fMT6nt1ud8LPLF+fdzrHZrKyfS5M9SZIrBba0C6iybTiKvvNRX4AooKR85kLiQqAIAgxJ701mUxJTzysCAQCkt1uD04UDyA4MW6iSeOVyY5D17Pb7VGT9jocjpiTgPf29iY1MbMgCJIgCEm+q42yxfqs0i2TyWSKWx6DwRBzEu5MlEWZnDzeBMmhkzWrfZejo6OS0WhMa8LvQCAgCYIQNln06OhozOMw0feilFnts/X5fMHjIPJ9u91uyW63S06nM2zi6cgJllMtbyqU70Rt4uxYlMm4le8p1neRzuemcDgcksFgiNpGIBCQTCZTUpNRZ/K4T1YujzFFJs5ZapSJ0Q0GQ8q/O0EQEk4Gr3xWZrM5allvb2/wNwRAcrvdqmXI1+et9dgspHNhvM8hklLuRL/5ZMplt9vjHhdEm5FOkiQpV0EnUSFQEjTEOvR1Ol1S6chDKSn4AfXB+xaLJe5d4IGBAQwPD6OzsxPt7e0wGAyqY1+UMQ+Rmc2U7I+JDAwMYHJyMmHWvI6Ojqg7+YIgYHx8POp9pFMml8sVlu0tkjL/YbJpwJMtS3Nzc9QdYmUMkXIXOXSbSoZVJUW5sr4iE1kI/X5/sHXEYDCgvb096n23t7er3i1Xxkp5vV50dXWpvrdAIBD8WxRF9Pf3w+PxoLOzM/heTpw4ETzuBgcH4XA4YDAYVNP8J1PeZHk8nph37QVBiJuFUO1YBeTWH+W7ytTnpvD7/bDb7cFU88q8ZX19fUmdNzJ93Ccrl8dY6D7TOWeFirXvVKaPiCQIAi5evBj1eqXbqtL9VPmNKJlQm5ubAcjd+5VjNFK+Pu9Ujs1CPBd2dHTg9OnTcY//WOUOPVdYrdaoLtgmkwlutzvmfpVxjkSlgoEglZyBgQG43W7VykC5IFWrYImIiCi7BgcH4XQ6YwZs2SCKIpqbm+Hz+ThGkEoKxwhSyXG73TFTjhdrlj4iIqLN4NSpU1lNmKRmZGQERqORQSCVHAaCVHLiJYNJZV4qIiIiyixBEGCxWBJmQc0ku93OLqFUktg1lEqKEujFGx/IriFERET5I4oi2traVMelZ5rL5YLD4chpV1SiQsEWQSop8bp+ejweCILAIJCIiCiPBEGA3W7H2bNns7ofJSlQLlsfiQoJA0EqKUoyGDVOp5PjA4mIiAqAMt9hokns02Gz2VSzIhOViop8F4Aol0RRjBnsTU1NJT3ROhEREWWX0+lEd3c3DAZDxoM1l8sFQRBUp2oiKhUcI0hEREREBctqtWa0+6bX64XH48n4XJ1ExYaBIBERERERUYnhGEEiIiIiIqISw0CQiIiIiIioxDAQJCIiIiIiKjEMBImIiIiIiEoMA0EiIiIiIqISw3kEiYhyZG5+EWVlZbh67RZmZhfQ2FCLQwd2Y21tDfV1NfkuXtGbW1pBWZkOvg9nMLN0H43VlWjf1oi1NQn11azu0rayAuh0wOys/P+KCqChAZAk+f9ERFRUeOYmIsqy+YUl3PkwgL/47vfh+ofXMLewFFxWX1sN8xOfxFeeeRI7tjWjrrY6jyUtTvPLK7gzs4jv/PgdnP/5DcwvrwaX1VWV46lH9uFLv3EEOxprUFfFai9lKyvA0hIwNgbcvAmsbny+KC8H9uwBDh4EqqsZEBIRFRHOI0hElEULi8sY/N4P8PU/+17Cdb/+u0/D8vTnUFtTlYOSbQ4L91fwyk/G8Mc//FXCdf/gsw/h2Y8fRG0lg5Wkra4Cfj/w1luJ133wQcBgkINDIiIqeKwNiYiyZH5hCYPf+wG+8edDSa3/9T/7HnQ64Nnf+mxWWwb9fj88Hg+cTifcbnfW9pNt88sr+KufJhcEAsAf//BX0Ol0+O2Ptme9ZXBgYAAA4PP5AAAOhyOr+8uKlRVgfDy5IBCQ19PpgAMHstoyKIoiRkZGAMifr9/vx7lz5yAIQtb2SUS0GbFFkIgoS8Zv3Ibxia+m/Drvf/tztO3dmfkCAfB6vbh8+TJEUcTw8DBGR0ezsp9cGJ+cxUf/9Acpv+5n//vn0NbSkIUSyWw2G+x2e/Bvq9UKv99ffEH33Bxw8WLqr+vqAurrM1+edVarFVarFUajMfh3UX6+RER5xhZBIqIkrK2tYUqcTXr9iopy/MV3v69pX3/53e/jj776NFZWVhOuqxcaUFaWfAJoo9EIo9EIl8ulqWzZsrYmYWp+Oen1K8p1+M6P39G0r+/80zv4g88+jJXVxPdB9XVVKCvTJb1tURTh9XohimKwhcpqtaKjowN+vx8Gg0FTmdMmScBy8p8vdDp5TKAWY2NyN9Fk7zNXVcn7S5LSoq0Egu3t7cEWQiIiSh4DQSKiJEyJszj0aUtS6+7fsx3/ONwP1z+8pmlfzr9/DV//6tMw/Zs/wPWbH8Rd9+o/DmKrfoum/RSSqfllHPtWcoHz/uZ6uP+3Lpz/+Q1N+zp/5Qb+8LMP4//10qu4HpiLu+4bv/8ktjak1k338uXL8Pv9wUBFCf5EUdRU3oxYXgZ++MPk1q2rAz79aTkxjBY3bwJHjwI//jEwP594/c9+Vk40k6TIlr9Lly7BZDKlWkoiopLHQJCIKMOOtLXiV+9eD8sOmoq5hSW8cfUGDrftThgIlqJD2xvxxu3psOygqZhfXsWbt6dxcFtjwkAwVYIgIBAIhD3n8XgAIH+tgalqaACmp8Ozg6ZidRW4d0/eTjKBYBpcLhdEUYTT6czqfoiINiMGgkREGVZfV4PZucW0tjE7t4CGutoMlWhzqa+qwNzSSlrbmF1aQUOO5hbs7++Hw+EonmQmFRVyoph0KPMMZtHg4CBEUQy2vBIRUWoYCBIRZdjc/CIa6tObIL6hvhaz8wsZKtHmMre8kvYE8Q3VFZhNM5hMhs1mg9VqhcWSXLfigpCJIC4TwWQCymc6ODiItrY2jI+PF0+wTURUABgIEhElQS804Oo/Dia1blmZDjXVVaivrdbUPbS+thqPHjXg5W99CWtr8RNu6IXsZb/MJX1dFd74/SeTWrdMB9RWlqOuqlxT99C6qnI82tqM/0/PCST4eKGv0z6no8vlQnt7e2EEgVVV8li8ZFVUyPMBaukeWl4OCAJw/HjyZUuSKIro7+9HX19fMOgzmUwQRREejwdmszn18hIRlSgGgkRESSgrK0spKcvc/CLMT3wSf+1KPf1+z+c/CUmSoBcaU35tsSor06WUlGVuaQVPPbIPf3NpPOV9PfXoPqxJgL4+e3M1KuMClSBQFEVMTU3lb5ygTpdSQhasrAB79gDXr6e+rz175IyhqewvSX6/HwMDA7BarcFAUEnCw9ZAIqLUJJ9znIiIklZfV4OvPJNcC1ekLz/zJOrr0utamsjU1FRWt59t9dUV+NJvHNH02i996kjaXUvj8Xq98Hq9MBqN8Pv98Hq96O/vh16vz9o+M66iAjh4UNtrDx7M2vhAo9GI3t7esIB6eHgYRqORmUOJiFLECeWJiLJkfmEJ54Z+iK//2feSfs03fu9pPPtbn0VdbXZaq/x+PxwOBzweD7xeL3p7ewun+2KK5pdX8Fc/HcMf//BXSb/mDz/3MH77o+2oq8pOoCKKItra2lSniii66nZlBRgfB956K/nXHD0KHDiQ1UQxoihicHCjm7bP54PdbmeLIBFRihgIEhFl0cLiMs4N/QB/9J8SB4Pf+L2ncfbM51Bbo31cWqlZuL+Cv/qpD9/8wS8TrvuHn3sY//Fj7ait5KiIpK2uysHgm28mXvfoUaCtTR4jSEREBY+BIBFRls0vLOHO3QD+8rvfh/PvXwtLIFNfW42ez38SX37mSezY2py1lsDNbH55BXdmFvGdf3oH56/cCEsgU1dVjqce3YcvfeoIdjTWZK0lcFNbWQGWloCxMXmy+NAEMuXl8pjAgwflMYFZnjKCiIgyh4EgEVGOzM4vorysDGPXb2F2dgENDbU4uH831tbWsj4msBTMLa2grEwH/90ZzCzdR2N1JQxbG7G2JmV1TGDJWFmRk87Mzm5MMdHQICeGYQBIRFR0GAgSERERERGVGGYNJSIiIiIiKjEMBImIiIiIiEoMA0EiIiIiIqISw0CQiIiIiIioxDAQJCIiIiIiKjEMBImIiIiIiEoMA0HKO7/fD1EU096O1+vNyHaIiIgyIVP1m4L1HBFlEgNByiuPxwOXywVBENLeltFoxNmzZ1lJEhFR3mWyflOwniOiTOKE8pQ3fr8fNpsNTqczY9sURRE9PT1wu91pbcflcsFms2FqaipY4QqCAIPBAAAYHR1Nt6glz+PxBL975ULJ7/fDYDDg9OnTMBqNeSxdbD09PfD7/fD7/Th16hQcDke+i0REBSZW/dbd3Y2pqSn4/X5YLBbY7faUt53tek6v18Nut8NsNmtaNxtCP7fNdN5lPUh5JxHlicFgkHw+X8a363A4JIvFkpFt+Xw+CYAEQAoEAhnZZqnz+XyS0WiUzGaz6mc6Ojoad3m++Xw+yel0SgAks9msuk4gEJAcDkdBlp+Isi9W/ebz+SS73S4BkHp7ezVvP1/1XCAQCK4bq/7OxvnP5/NJDodDApCx951PrAepUDAQpLzo7e2V7HZ71rZvNBql0dHRjGxLqfQofW63WwKQ1HdvNpuzdrMgEwRBiFkBms3mpC5YnE5nNopGRHmUTP2WbiAoSfmr5xKtm+z5T4vNEAiyHtzAOjD/OEaQck4URQwODqK3tzdr+7Db7Th79mzWtk+p83q96O7uhsViSeq7dzqdEAQBHR0dRTcepru7G4IgoLu7O+Y6oiim3bWLiApLLuo3RaHWc8mc/7TK5HjLfGA9uIF1YGFgIEg519/fD4vFktV9mEwmiKIIr9eb1f1Q8np6eiAIQkpjCZxOZ3A8TDGxWCwIBAJxx834/f4cloiIciEX9ZuiUOu5ZM5/pYr14AbWgYWBgSDl3ODgIE6fPp31/ZjNZg5gLhADAwPB5AipMBgMMJlM8Hg8BXexk67h4eF8F4GIMixX9ZuC9VzxYD0YjnVgYWAgSDnl8XgAICeZsE6fPo3BwcGs74cS6+/vBwBYrdaUX6vcBbXZbBktU77x2CTaXHJZvylYzxUP1oPheNwWhop8F4BKi9vthslkysm+lMrY6/UWbArmUqBMgBw6/UYqlONFucgqdkoXn2Ib70FE8eWyflMUcz2ntHBNTk6ivb092FI2ODgIURTh8/lgtVqL7n2pYT24gXVgYWEgSDnl8XiS7jYjiiL6+/vR0tKCyclJ+P1+nD59OqVxB0ajER6PpyAqksHBQYyOjkIQBIiiiKmpqaj3Y7VaMTIyEjZP07lz52A2mzE4OAi73R7sVy8IAux2e7Dy9Hq96OjoCG7LYDDA5/OFlcFmswUrI0D+jO12e9gA/ND5mvr6+tDb24uBgYHgd3DixImUEiFcvnw5WB4tQl8XerETWk6TyRR3vq548xxl4jgLZbVacfnyZdX9Dg4Ohv09MjIS/HyU96rX66OOAeV7iHx/ykWBIAhwOp05vwglog2p1G+hBgcHw87VaufleAqpnot3/gultHAp522Xy4X29naYTCbYbDYYDAbYbDYMDw/HfF8ejyeYbESpU8+dO5fwc2M9GC1X9SDrwAKU77SlVFoEQUgqXXAgEFBNOWwymSSTyZT0/sxmc8zUxslCmtNHBAIByWQyqaaKtlgsUe8zEAhIgiDE3KfJZIq5TJkPyuFwRD1vMBiiPnun0ykJghCWgjx0via73S719vYGU1cbDIaUP4ve3l4JQErfWyTl8wgtf2g51b7j0Pm6YqWvTuc4i5U2O5n5lSQpcRp0o9EoAYibHt5kMqV9fBNRZiRbv0nSxu/fbrdHzbM2OjoqGQwGye12J7WtXNdz8dZN5vzX29srCYIQ9bwyVUI8giBIFotFcjgcUZ+PxWJR3W5o2VgPRstXPcg6sDAwEKScSvSjVlgsFtV5c5TJbJOdf6m3tzetE68kpR8ImkymuCc7teXKiVvtM1DmIIr1OaqdFA0GQ8wyxKp8lRN4aKXjdDqjgsxELBZLwqAoEaXiVdt3OgFXOsdZvPmTklmeqBIcHR2N+Z4VrACJCkey9ZuyriAIMSfbVi6ik5k/LpP1nNFoTPhIpk6Md/6Ldc5W3nO8YFoQBMloNKqeF2PdCFWwHiysepB1YGFgshjKmdBm/kQ8Hg/a29uj+pAr/euT7Sff0tKCqampFEuaOS6XCx6PJ+7gcLvdjsHBwbD3pHTHUOvG4fV6Y6af9nq9UV2TlExlsQaZW61W+P1+uFyuqGUejyesa4jZbE4545nyfaeTKlp5rVq3mnTmlcrUcZYNRqMRBoMBdrtddbkoijhx4kSOS0VEalKp3xQmkynm+mazGYIgJJVYJJP13OjoaMJHOpSsl2rncuW5S5cuJdyGWj2kvD5ySATAejCeQq0HWQfmBgNByhnlJKbX6xOuq5wA1BgMhqQHGQuCkNe5avr7+yEIQtyxG8qy0JOdwWCA0WhUrZQmJydx6tQpjIyMRC0bHh6O6tOvBIyxPs/Ozk4A6pWvsiwd7e3tADIzZ1AmyhMqU8dZtthsNvj9ftWKeHBwMGfzlRFRfKnUb4pE6ypTBiQ6D+W7nsu0lpaWuMsTjYVU+7xYD8ZWyPUg68DsY7IYyplU7lhGDnj2+/3w+/0QRRF+vz/pben1+pyexERRxOXLl4MDlpPN5CYIQtSJzmq1wmq1hm3D7/ejvb0dnZ2dwVbERIOj/X4/BEHAwMBAwrJH0jqwPZRSPq3fQ2jFmc5dTzWZOs6yxWKxwGq1wuFwRH3PPp8v458HEWmTjXOFcv4NrVPU5LqeS0doXRZJeS5RnamlXmI9GFsh14OsA7OPgSDlTCp3SgH5ZORwOIKB0OnTp9HZ2QmDwZD0iWlqaiqnJ4rLly8HT/Tp3vk7depU8ASo3M10uVywWCzBLhuhJ0ePx4Pu7u6wbYR2JYmX4SzWskx8dgaDAQaDIXhXL9WsXkqraCoZ2lKRieMsmywWSzCduvJ9uFwuTXNREVF2pFq/JUNpGUtUl+S6nktXb29v1DkNQLA+y3TmR9aDiRVyPcg6MLvYNZRyRrmrlsxJZWBgAO3t7WhpaYHb7YbdbofRaIQgCCmdlEVRzMjdvGT5/f7g/pQLg2TuAKqtIwgCTCZTWBfQ0DtgZrM5rOuo2hxWqZQhm5Rur7FSV8ejvKavry+jZQIyd5xlinInNpRS2YVOvut2uwsiVTwRyVKp35I1OTkJIHGQmet6Ll1WqxUGgyFsLjmlpS6ydSoTWA/GV0j1IOvA3GMgSDkTOmdPPB6PBzabDRaLRfXuV+TrlcHnaiYnJ7NypzYWp9MZfJ/KSTTRhYHyftROakpFqUy8G9rip5wc1cYRKpSWw3zf0TObzcExj5Hfn8vlgs1mw8DAQNR78Xg88Pv9wVbQVMU71jJ5nGWK0hUnlNFohNFoRH9/PwC5ogydL5KI8i/Z+i0VyXaVzHU9ly6Hw4HR0VE4HA6MjIxgYGAARqMRbrc7K4EH60Ex5rJCqwdZB+YeA0HKuUTdXJS7ZrGa/SNfPzw8HHdfubpTqgRsofvr6+sLPh+L0uKndqdPGQjtdDqjEsEoCWUcDgdcLldUt1CFMnluohN4vIAyEy5evAhBEIITCQMbJ3273Y7e3t6oDGU9PT0wmUxx76DGuwAKnag2UiaPs0yJdaGiHEculwsOh4MD5IkKVCpDAhIFJkoXwkR1WC7ruUxQzvEGgyEYgGR7InDWg+oKrR5kHZh7DAQpp4xGY8KKMrRFLZIoipiamkr6rquSXCUXzp49G/Vcb29vMFiLxeFwwGw2R2X7VJjN5mD/+EinT5+Gx+PB8PBwzIrUYrHAaDTGTJsNIHhHNpsEQcDo6CguX74crAQjkyAYjcZgRd3d3Q29Xp+wq5AgCDGPB7fbHfd1of+GSvU400IZLxLK7/erZoRTUskrd0SJqPAkU7+F8nq9Mc8xyjk/ma6SuaznMkGv18etj+LRek5mPRj7daH/hsp2Pcg6sDAwEKScMplMCecIUu5MRc4dI4oi+vv7gydE5UQZL9W01+tN605jMpW60mXT5XKp3pW9ePEi/H6/6h03ZazEuXPnYm5fmRcw9A6iQrkrluhu8MWLF4P7i6SUO3QbmUp4E8lgMGB8fByiKKKjo0O1tXRychLt7e0wGo1JZQWzWq3BrjOhBgcHg62kasvTPc5EUYxbQSZabrPZosoV7/1aLBbVeSKJqDAkU7+FcrvdqoGJy+WC3W7H6OhoUl0BM1nPJbroD10er36Id/6z2+0YGBiATqcLezQ3N6O7uzvYepdMGdSej9WqxHqwsOpB1oGFQSdJkpTvQlDp8Hg86OnpQSAQiLue1+sN3vkxGAxoaWmBIAjBwGdgYADDw8Po7OyE3W5XPXF4vV50dHRAyyGu9NePTNkcWUlE3i0zGo0xJ9wdHBwMm+hWFEV0d3fHbAkM1d7erjpJLiDfMVQGdycyODgIt9sNvV4f/MxOnz4d9tr29vao963X65O+KEmW1+uFw+HA5cuX0dnZGZwLS/lc1MYrxJqOQ+kuYjAYgnfGTSYTjEYjmpubAch3oc1mc1iFp+U46+joCJZT+XxOnToVbPVVW26321W7sijbVy7i+vr6Yn7Gfr8fPT09aU/oTETZkWz9BsgXwcq5aGBgAJOTk2hpaQkmiIk1iXakTNRzofWYcr632+1hdVOy6yZz/lMCvY6OjmCXRmW7Pp8PIyMjEEUxLAFae3t71L5Dz7tq9ZbFYlH9HFkPFk49yDow/xgIUs41NzdjdHQ062MaBgYG4PP5NGXoovzx+/2w2WyqXWFCL55KjdfrxeXLlzk2gqiA5ap+UxRbPdfR0YHTp08nnAahp6cHHo8nqaB6M2I9GI11YHYwEKScU7rCZPtE1t7eDqfTyRTDRai5uTnqAqDUKwFlTkkiKly5qt8UxVTPKXPdJnvZqdPp4PP5iioRTiaxHgzHOjA7OEaQcs5qtYbNB5MNXq8XgiAUReVI0fR6fXBeKYXNZlMdRF4K/H5/XuY1JKLU5KJ+UxRjPZfqeSybCbsKHevBDawDs4eBIOWckjI68gSXSWfPno2bgIUKm9lshs1mg9VqDU6N4fF4iuqCR6vBwUHodLqw8SkOhyMrEwkTUWblon5TFFs9p4wDS2aKhoGBgeAUSaWqVOtB1oG5xUCQ8qKvrw8OhyMrd/uU7F+b/WS5mSlZwQYHB4NjRRKNKdksRFGEwWAIJlHwer3BwftEVPiyWb8pirWeGx0dhc1mi9tqqiQQKfWkIKVaD7IOzC2OEaS8UTJVJTNPUrJEUURPT0/ceXOoOIRmqQvNRlYKbDZbMINge3t7SY4HISpm2ajfFJuhnnO5XHC73VEX98p7y/YE88WiVOtB1oG5w0CQ8srj8cDr9WbsLldPTw/sdnvJDi4nIqLCkOn6TcF6jogypSgCQY/HE5wbBZDvGFmt1rS7RLhcLgwPDwe3CcgDvZOZ140yx+v1wmAwpN3sn6ntEBERZUKm6yXWc0SUSQUfCNpsNni93qguEB0dHbBarZqbi3t6etDd3R31+lj7U3Ps2LHgpJ1aTUxMoLW1Na1tpKsQysByFF4ZWI7CKwPLkfky+Hw+vPHGGxkq0ea1Weo7lqPwysByFF4ZWI7CK0OmyhFV50kFzO12S7GK6PP5JADS6Ohoytvt7e2V3G53zOUWi0WyWCwJt/Pkk0+mvO9sbGMzlEGSWI5CK4MksRyFVgZJYjkyXYZCeB/FYDN91ixHYZVBkliOQiuDJLEchVYGScrOebigs4babLaYLX4GgwEmkyk4eWsqXC5X3IHIdrsdIyMjKW+3WJ05cybfRQDAchRaGQpJIXwehVAGgOUgSlehHLuFUI5CKANQOOUoBIXyWbAchVWGbCnYQNDr9cLr9aKjoyPmOkajER6PJ6UUzX6/H1NTU3HXEQShpCYxLZQDnOUorDIUkkL4PAqhDADLQZSuQjl2C6EchVAGoHDKUQgK5bNgOQqrDNlSsIGgx+MBgLhZsZTxCsq6ydDr9RBFMe5kr8pg7FzYzAcXFT8en1TIeHwWF35fVOh4jFIhy8bxWbCB4KVLlwDEDwSVZcq6yRAEAUajETabLWa3UpvNlrO5WnjSoULG45MKGY/P4sLviwodj1EqZCUVCCpdM/V6fdLrJsvpdEIQBAwMDKC9vR1erze4zGq1cjJTIiIiIiLa1CryXYBYEo3jAzaCxGTWDWUwGDA+Po6enh54PB50dHTAYrFgamoKfX19ac9PSEREREREVMgKvkUw0+sqBEGA2+0OBn2Dg4NhLYNERERERESbVcG2CGab1+tFf38/nE4nAHmCeSVLaW9vL+x2e8JtTExM4OTJk8G/z5w5w/7lREQFbGhoCENDQ8G/JyYm8lia4sH6joio+CSq8wo2EBQEISvrAvI8gsPDw8EgEABGR0cxMDAAm82GgYEB+P3+sOVqWltbceHChZT2TURE+RMZwIQGNxQb6zsiouKTqM4r2K6hilTGCibD7/fDZrOpBnm9vb3w+XwwGAxwuVxwuVwplZWIiIiIiKgYFGwgqEwNEW/8n9/vB5Bai6DVao05bYSy39HRUQiCgOHh4aS3S0REREREVCwKNhA8ceIEgPgtgsoyZd1kXL58GZ2dnXHXEQQBfX19TB5DRERERESbUsEGgso8fkqrnxqfzxe2bjKSzTBqNBrjTmZPRERERERUrAo2EFQCMbfbHXMdl8sFk8mUUtdQk8kEj8eTcD23243u7u6kt0tERERERFQsCjZrKAA4HA50d3dDFMWoYM/v98Pv98cMFHt6eoKZP0Nb9ux2O7q6umA2m2O2+Pn9fng8HoyOjmbsvRARERERERWKgm0RBOTWu97eXvT09IQ9L4oiuru74XA4VIM5j8cDl8sFr9cblfnTaDTC6XSiu7tbNSvo4OAgrFZrwqkjiIiIiIiIilVBtwgCcguey+WC1WoNtgr6/X44HI6YYwNNJhOMRiNEUYTZbFZdPjo6iv7+fjgcjuDzgiCgu7s7bndUIiIiIiKiYlfwgSAAmM1m1YAunkTdOgVBgN1uT6dYRERERERERamgu4YSERERERFR5jEQJCIiIiIiKjEMBImIiIiIiEoMA0EiIiIiIqISw0CQiIiIiIioxDAQJCIiIiIiKjFFMX0EEREREVGmzc0voqysDFev3cLM7AIaG2px6MBurK2tob6uJt/FI8oqBoJEREREVFLmF5Zw58MA/uK734frH17D3MJScFl9bTXMT3wSX3nmSezY1oy62uo8lpQoe9g1lIiIiIhKxsLiMs4N/RDGJ76Kv3ZdDAsCAWBuYQl/7boI4xNfxbmhH2JhcTlPJSXKLgaCaZiYmMDJkycxNDSU76IQEVEKhoaGcPLkSUxMTOS7KEWB9R1tFvMLS3D8l/8HX/+z7yW1/tf/7Hs4N/QDzEcEi0TFJFadp5MkScpTmYreyZMnceHChXwXg4iINOJ5PDn8nGizGL9xG8Ynvpry67z/7c/Rtndn5gtElEOR53K2CBIRERHRpjc3v4i/+O73Nb32L7/7fczNL2a4RET5xUCQiIiIiDa1ycA9AIDrH17T9Hrn37+GsjJdJotElHfMGkpEREREm8L8whLe8d/Em+++hzev3sCbV9/DG+/ewPFjBnz5t5+MSgyTrLmFJVx5w49/+O+XMTe/hKOH9uLooX04dmgvhKaGDL8LotxgIEhERERERWVtbQ3Xbn6AN969sR7wyUGf/8ZtrK1Fp7+or6vB7Fx6XTtn5hZw6/YU/u6HPw17fvcOPY4e2rcRHB7eh8OGVlRV8jKbChuPUCIiIiIqWHen7uHNqzdCgr738LbvZkqZPOfmF9FQn94E8Q31tZidX4h6/tadKdy6MwXPa1eCz1VUlOPggV3BAPHY4X04emgf9u7aCp2OXUypMDAQJCKiojE3v4iysjJcvXYLM7MLaGyoxaEDu7G2tob6uvQu8ogovxYWl/GO72ZI0Cd37/xgcjrtbb8zPoGHjuxHfW21pu6h9bXVOHZoH94dv5XU+isrq3h77CbeHruJv/1/Np5vbKjFgwc3Wg6PHtqLY4f2oWlLfcplIkoXA0EiIip48wtLuPNhAH/x3e/D9Q+vhV3I1ddWw/zEJ/GVZ57Ejm3NqKutzmNJiSgRpVvnm1dv4M1338MbV6/H7daZKp1Oh7a9O4JdNZV/y8vKYH7ik/hr18WUt9nz+U9iZn4B/8HcFQxQ3/VP4P7KakrbmZldwL9ceRf/cuXdsOeV7qVKy+HRQ3vZvZSyjkcXEREVtIXFZZwb+mHMCaDnFpbw166L+GvXRXz9d5+G5enPobamKselJCI1SrfO0MQtqXbrjKeluTEseDp6aB8eaN8Ts4fAV555UlMg+OVnnsSenVvx1f/4vwSfu39/BVevvR/2/t68egPv3bqb8vYTdS9VWg/ZvZQyiYEgEREVrPmFJQx+7wf4xp8PJbX+1//se9DpgGd/67NsGSTKodBunUpA9Ma7menWCQA11ZU4YtgTHvQd3oftLU0pBUU7tjXj67/7dMwbS2q+8XtPY8fW5qjnKysr1oOzvQA+EXx+emYeb429F2zxfPPqDbxx9QbuzcwnvU8gsnvpT4LPK91LQz8Ldi8lLRgIEhFRwbrzYSDpIFDxR//pe3jS9BG07d2ZpVIRla7Ibp1K4Oe78X7GunUe2LM9qhXMsG8nysvTn/66rrYalqc/B51OPlck8o3fexpnz6TWy6CpsQ4fPX4EHz1+JPicJEmYuDO5ERiuj4G8Op7Z7qXHDu8P6xLL7qUUD48MIiIqSHPzi/iL735f02v/8rvfxx9/7d8ygQxRGiYD98Iydb559QbeHrupeS6+SC3NjVFZNeN168yU2poqPPtbn8WTpo/gL7/7fTj/Pnrccc/nP4kvP/MkdmxtzkhXc51Ohz07t2LPzq14/DeOB59fvr+CsfXupaGf9c33tXcvdf/T68HnKirKcejA7mALKruXUiidJEnp374pUSdPnsSFCxfyXQwiooK2traGmdkFTM/O497MPO7Nrj9mFkL+L/87PSP/v662Gv/HN6w42vWc5gx/V398LuEFHM/jyeHntLktLC7jXf8E3nj3ejDge/Pqe7hzV8zI9pVunUowcuzQPk3dOrNhdn4R5WVlGLt+C7OzC2hoqMXB/fnPRKx0L438TlLtXhrLlsa69eyle9m9tIREnsvZIkhERDFpCeJCn5+ZXcDMXPS8W4k8/qnj+OU71zS3PMwtLGHs+i08fOSAptcTbUZra2u4PvGBnKkzpPUpG906QydXz1S3zmxoWA/2Cu1cEa976RvvhnfL1dK99N7MPP759Xfwz6+/E/Z8686WqO/vUNtudi/dpPitEhFtUvkK4jKhvq4Gs3OLaW1jdjY/ZScqBJOBe2FJWzLdrVMvNIaN4Tt6aC8eOLg3GFhR5oV2L/3sbxiDzy/fX8HV8VthXXi1di+duD2JiduTMbuXHju8H0cPy9/5np0teW/RpfQwECQiKkCpBHH3ZtYDuQIJ4jJhbn4RDfXpXVA2NNRmqDREhWtxaRnv+CaCUxgoSUgy1a2zuqoSR9pbg905lcBvx1aBQUCBqKqswLHDcutdqOl7c3hz7D1EZnKdSfEm2crKKt4aew9vjb2H8yHZS5XupeE3BPahqbEuI++Lso+BYB7MzS+irKwMV6/dwszsAhobanHoQP77oxMBPD4zodSDuHh0Oh0a6mvQ1FiPLQ112NJYK//bUIctjXXB/7fu1OPRowbU11ZrHiN4cP/uLLwDovwI7dYZOidfprp1AojI1ilf3Bv27URFRXlGtk+51bSlHh8zPoCPGR8IPidJEm7engxmfVXGIF69dgsrGexeGjm3I7uXFiZ+Izk0v7CEOx8G8Bff/T5c/xCdocr8xCfxlWeexI5tzZz/inKOx6cs1SDu3uwCpmfmGMSFBHHB58Oek/9trK9BWVlyY4Xm5hdhfuKTmiZ/7vn8J7G2tpby64gKQWi3TuXft66+l9FunaFjwNits3TodDrs3bUVe3fF716qdCeeuD2Z8j6U7qU/+vFG99LKinIcamvdaDlk99KCwEAwRxYWl3Fu6IcxJzCdW1jCX7su4q9dF/H1330alqdTm7OGKB2b5fhkEBebEsRtaaiTA7ksB3GZUF9Xg68886SmQPDLzzzJFmwqeItLSrbO0Cka3sPtDwMZ2b7SrTNyigZ266RIyXQvVbodv3k19e6l91dWg92Xgf8ZfH5LY13YOFN2L80tBoI5ML+whMHv/SDpSZG//mffg04HPPtbn93ULS9UGArl+GQQF1sxBnGZsmNbM77+u0/HvEmh5hu/9zR2bG3OYqmIUrO2toYbEx+ut7RsTAfgu3Ebq6uZabmOla2T3TopHYm6l8oZTG+k1b30Z9538DNvePfSPbu2RgWI7F6aeZxHMA0dHR1obW3FmTNncObMmZjrjd+4DeMTX015+97/9udo27szjRISJZaJ41NLECdnqpwrqSBuS0MdmrZEB2mbNYjLFLnF+gf4o/+UOBj8xu89jbNnErdYDw0NYWhoCBMTExgdHc1UUTetZOs7AqbEmY3xV+stIJns1tnc1BA1/uqBg3vQWM/kSJRfSvfS8BZubd1L1ah1Lz12eB9ad7B7aSKx6jwGgmlIZoLduflF/L+//Teaujb9h54ufOWZk/jJ6Ftai0gU18c7H8Sf/9UFzcfnFz73cfybL/9JyQRxWxrr0NTIIC4f5heWcOduAH/53e/D+ffRY1h7Pv9JfPmZJ7Fja2pjWDlRenL4OUVTunW+eXU94FtvFclWt07l353bmnnRS0VFnJ5d714aPu411e6lsUR2Lz12eD8ePLiX3UtVcEL5HCsrK4PrH17T9Frn37+Gr3/1aQw4/hbXb36Q4ZJRqdu/Zzv+8bH+tI9PfXNjQQaCDOI2l7raarTt3Ylvfu3f4lu9/x5j129hdnYBDQ21OLifWW0pe0K7dYbOyZfJbp37W7eHp+A/vA/t7NZJm4TQ1ICPdzyIj3c8GHxOkiS89/7djcDw3Rt44+oNjF17PyvdS5VW9EMHdqGS3UuD+Elk2dVrtzR3B5lbWMIbV2/gcNtuBoKUcUfaWvGrd68X5PGpFsTJ4+MYxJU6Javhw0cO5LcgtCmFdut886p8Yfr22E3Mzi9mZPvNTQ0bk3KzWyeVMJ1Oh327t2Hf7m343Kc7gs8v318JtrSH3ni5dWcq5X3cfP8ubr5/VzV7afiNl70l272UgWCWpdvsPTu3gIY6VhCUefV1NZidS+/iRu34ZBBHRIUuslvnW+vp8jPVrbOqsgJH2veEZepkt06ixKoqK/DQkf146Mj+sOdDu5cqweFbV99LuUdSePbSDU2N9VFTW5RC91IGglnW2JBeELelsR47tjbh+DFDhkpEJNuxTUj7BLetRcDzX/wC/nfLv2YQR0RR5uYXUVZWhqvXbmFmdgGNDbU4dCB3XXnX1tbw3q27Ickr5G5oY9ffz2i3zrDuZ+zWSZRxibqXhk5toaV76fTMHH7qfRs/9b4d9vze3VujprbIZffSbJ9DGQhm2aEDu1FfW62p+119bTUeebANHz1+JAslI5KzMaZzfD7Qvqcg5xMkovyaX1jCnQ8D+Ivvfh+uf4hO7mN+4pP4yjNPYse21JL7xBOYnpXHGYVkLHxr7L2Md+sMTUjBbp1E+ROre+nS8n3V7KVaupe+d+su3rt1Fz/8R2/wucqKchw2hCdyOnZ4H3bv0GesxT9X51AGglm2trYG8xOf1JSVsefzn8TaWmbuWBKp4fFJRJkmT/fxw5hzP84tLOGvXRfx166L+PrvPg3L04mn+wi1tHxfnoR9vRXgrfWLvPc/yHy3ztALvV3b2a2TqBhUV1XG7F76RkTmUq3dS99Yv+kUKrJ76bHDcvfSLQ2p9b7K9jk0FAPBLKuvq8FXnnlS04X2l595klnwKKt4fBJRJs0vLGHwez/AN/58KKn1v/5n34NOBzz7W5+Nuqsd7NYZzCp4PePdOve1bsOx9e5eyrig9n07mVWQaBMSmhrwic4H8YnOiO6ltz6MChCvjt9K+TyTTPdSJVHUwf3q3UszeQ5NBs90ObBjWzO+/rtPx4zs1Xzj957Gjq3NWSwVkYzHJxFlyp0PA0lfwCj+6D99D5/v+giWlu7jny69EUwln8luncKW+pAU8uuJIA7tZbdOohKn0+mwr3U79rVux2/+q/Dupe+O31qfH3RjiotbH2Sme2lVZQUOte0OOy8ZHzqIezNzms6hT5o+gra9O1MuGwPBHKirrYbl6c9Bp5O/rES+8XtP4+wZ7c28RKng8UlEmTA3v4i/+O73Nb32//g/v4/Pd30Etv7/M60yVFVWrI/dCZ+igd06iSgV1VWVePjIfjwc0b00MD0bbDWUM5hex9tjN1PuXrp8fyXYvdT5D/Jz5x2/jwvuf9ZU3r/87vfxx1/7tyn31GIgmCO1NVV49rc+iydNH8Fffvf7cP599MDPns9/El9+5kns2NrMi2zKKR6fRJSusrIyuP7hNU2vdf79a/j6V5/G/j3bk56XdF/rtpDuVvvYrZOIsq45ie6lytjlq9eS7166f892dDzUjn/31T/VVC7n37+Gb/X++5Rfx7NlDtXVVqNt705882v/Ft/q/fcYu34Ls7MLaGioxcH9uUunTaSGxycRpePqtVuaMhADcvKDN67ewOG23VGBoNKtMzQ73wMH96ScgIGIKBsSdS99Y31885vrAaJa99Ijba341bvX0zqHjl2/hYePHEjpdQwE86Bh/WI61S+LKBd4fBKRFjOzqXWNijQ7t4AHD+5dn6ZhI7ECu3USUTGK27303RsbibCu3kBLcyNm59IbEz2r4RzMQJCIiIjS1tiQXuKVXdv1+Mbv/ZsMlYaIqDA1NzXgEyeO4hMnjgafW1tbwy/fvp7Wdhs0nIPL0tojEREREYBDB3ajXuPExvW11Th4YHeGS0REVBzKyspw2NCa3jl0f+rnUAaCRERElLa1tTWYn/ikptf2fP6TWFvLzNyARETFKB/nUAaCRERElLb6uhp85ZknNb32y888yWRURFTS8nEOZSBIREREGbFjWzO+/rtPp/Sab/ze09ixtTlLJSIiKh65PocyWQwRERFlRF1tNSxPfw46HfBH/+l7Cdf/xu89jbNnPse5SYmIkPtzKFsE0zAxMYGTJ09iaGgo30UhIqIUDA0N4eTJk5iYmMh3UYpCKvVdbU0Vnv2tz8L73/4c/6GnKyr5QX1tNf5DTxe8/+3P8exvfZZBIBFRiGycQ2PVeTpJkqSMlr6EnDx5EhcuXMh3MYiISCOex5Oj9XOanV9EeVkZxq7fwuzsAhoaanFw/26sra1xTCARUQKZPodGnsvZNZSIiIiyomH9QuXhIwfyWxAioiKU7XMou4YSERERERGVGLYIEhEREVFpWlkBdDpgdlb+f0UF0NAASJL8f6JNjEc4EREREZWWlRVgaQkYGwNu3gRWVzeWlZcDe/YABw8C1dUMCGnT4pFNRERERKVjdRUYHwfeeiv28uvX5ceDDwIGgxwcEm0yDASJiIiIqDSsrMQPAiO99ZbcdfTAAbYM0qbDZDFEREREVBqWlpIPAhVvvim/jmiTYSBIRERERJvfyoo8JlCLsTH59USbCANBIiIiItrclCDu5k1tr795U+4iSrSJFEVnZ4/HA4fDAYPBAAAQRRFWqxVGozHtbYuiiP7+fng8Huj1egCA0WiE3W5Pe9tERERElCOSBCwuylNBRD4aG+UsoKHZQVOxugqIInD7NnD/vjzFhPKoqwPK2LZCxafgA0GbzQav1wu32x32fEdHB6xWKywWi+Ztu1wu2Gw2OByOsMDP6/XCarXC4XBo3jYRERERZcHKCjA3px7wxQr0mpvT79q5sgIsLAC3boU/r9MB9fXhwaHyqKpKb59EWVTQgaDH48HAwAAkSYpa5nQ60d7ejs7OTk0tgy6XC2fPnsXo6GiwpVFx9uxZeL1eBoJERERE+RCvdW9hIfXtKZPFp6OiQj2YlKSNskWqqlIPENmKSAVA0y/i2rVrOHDgQNLr9/X1ob+/P+X92Gy2mC1+BoMBJpMJNpstqrUwEVEU0dPTE9bdNHI5EREREWWZltY9LWZngaYmeT5ALdstLwe2bFEP9uJZXgampuRHKLYiUgHQFAh2dHRgcnIy6fVdLlfKgaDX6w120YzFaDRiYGAAoihCEISkt3327FkIghAzyPT5fCmVlYiIiIhiyHTrXiLl5eoBFgDs2SNPFJ+qPXvksYEHDoSXf3lZWxnZikgFQFMgGAgE8POf/xyPPPJIwnXPnz8Pv9+f8j48Hg8AqLbYKdrb24Prms3mpLYriiJcLlfS6xMRERFREnLVuqeorVUPmGpqYmf4PHhQWyB48KAciB08GP788rL6+52bk4M9LeK1IjY0qLckshWRNNDcWfrs2bP4l3/5l7jrvPLKK7BYLNBpSLd76dIlAPEDQWXZpUuXkg7slACzu7s75TIRERERlbRCad2rr9c25q+6GnjwwdQmlT96VH6dmqoqQK+XH6HW1oD5eflzmZmRA0Pl33RaEWdm5IdaORoa5Oyo9fUb/7IVkeLQHAhOTU3h9OnTGB4eVl3+3HPPweFwQBAETE9Pp7x9ZZyePvKHFWfdZCjjCZUgcmBgILhscnISJ06cYGshERERlbbVVfVgr5Ba97SoqAAMBnmbb76ZeP2jR4G2NjkgTUVZ2cZ72LkzfNnS0karoRIcZqsVsaxMDghDg8PGRrlclZXa9kWbhqZA0OFw4OzZs/D7/Th9+jTsdnswecy1a9fQ3d0Nn8+HwcFBPPvss3jhhRdS3sdU5IGsQgkSk1lXEdpN1Wq1wm63h40v7OnpwfDwMJxOZ/KFJSIiIio2xd66l045DhwAdu0CxsbkyeJDg9vycnlM4MGDcktgqkFgItXV8qOlJfx5pRVxZiY8UJydlccnarG2ttGKePt2+LKqqo2gMPS7YCtiydD0qzt79iwAuVVteHgYX/ziF3Hq1CkAgNlshl6vx+joKI4fPw4AePHFF1PeRyqtfKmsqwSCTqczKghUnm9ubobNZuOk8kRERFT8NmvrXjoqKuTHsWPAQw/Jn4UyxURDgxwk5zI4BcJbESOptSLOzMiBYzqtiJOT8iOyHKHjENmKuGll5Ah/+eWX0dnZiddffx0mkwkjIyNoamrKxKazZmpqKmam0VOnTmFgYAB9fX1xs5FOTEzg5MmTwb/PnDmDM2fOJNz33NIKysp08H04g5ml+2isrkT7tkasrUmory7oqR2JiIra0NAQhoaGgn9PTEzksTTFQ2t9RzlUqq176VLKWuDXrXFbEWMl6MlEK6JaOWJlNC2UIJ+CEtV5af9S7927h66uLni93mBimEwEgalMB6Fl3XjJYjo6OgAAIyMjMaeYAIDW1lZcuHAh6X3PL6/gzswivvPjd3D+5zcwv7xxF66uqhxPPbIPX/qNI9jRWIO6qiI6iRIRFYnIACY0uKHYUq3vKIuU1r3QboOl3rpXysrK5Na6xsboZUorYuQjnVbEpSX5kagVMfTBVsS8SVTnaYo2/vZv/xZf+MIXcOXKFXR1dUGSJLjdbnR1dWF8fBzPPfccbDZbSpPOxxKv5U6RTEKZyHXjZSNV1hkdHU16u4ks3F/BX/10DH/8w1+pLp9fXsXfXBrH31waxx989iE8+/GDqK1kMEhERFRyJEm+2I4cKzY3J1/EZ9pmad2jcGxFpAQ0/brNZjO6u7vh8Xhw/PhxXLx4MdgK2NbWhpdeegkvvPACHn/8cTz22GN47rnn8NJLL6W0D4PBAK/XG3f8nzLeL5UWwXgBYKztp2t+OX4QGOmPf/gr6HQ6/PZH29kySEREtFmpte4pF+grK5nfX21t+Hgvtu6VJrYi0jrNUYbH48HZs2fx8ssvqy5/8cUX8e1vfzvYBTPVQPDEiRNwuVxxM4Iqy06cOJH0dpVun8kEeakEmPHcmVlMOghUfPMHv8QTx1rR1qIyYJiIiIiKg9K6pzafXLZa99SmCmDrHiWDrYglRfMZwW6342tf+1rcdZ5//nmMjY3hlVdeSXn7JpMJQPyAzefzha2bynaV16pRAsxMTDo/t7SC7/z4HU2v/c4/vYNv/OYjTCBDRERU6FZXwy+UQ+eHy2brXuQk4mzdo2yI1YooSXL2UbYiFiVNEYYgCAmDQIXdbtcUCBqNRhgMBrjd7pgJW1wuF0wmU8pdQ41GIzweT8x1nE4nBEEITomRjrIyHc7//Iam156/cgPffOLRtMtAREREGRDauqd20Ztpka17oUEfW/eoEOh0bEUsYprOIqm0wAmCgLa2Ni27gcPhQHd3N0RRjAr2/H4//H4/3G636mt7enrg9/vhdDqjxgWeO3cOHR0d8Hq9MBqNUdv1eDxwOBwZ6Rrq+3AmLDtoKuaXV/HW7WmsSRK21FRiv74e1RUZntSUiIiIwkW27oU+stG6V1OzcdEaGvTV1vIClooXWxELnqZAcGRkJPj/v/3bv8WlS5cwPT2N//yf/3Pw+fPnz6OjowMHDhzA2NiYpsKZTCb09vaip6cnLOATRRHd3d1wOByqyV88Hg9cLhcAudWwt7c3bLnRaITD4QhuV9mGst3e3t6400akYmZJ4x2PdZNzS3C+fh3/9y9vokwH7BHqYdjaAENLQ8i/jdgr1KGivCwjZSYiItr08tW6p3YxytY9KiVsRSwYms88V65cQU9PT3CsnU6nCwsEn3rqKXz7299Ge3s7vvCFL2guoN1uh8vlgtVqDbbQ+f1+OByOmC2TJpMJRqMRoijCbDarrmOxWGAwGGCz2cJaHONtV4vG6vTuNDRUV2B2Sb77uCYBNwJzuBGYw/+4eidsvYoyHfbr62HY2igHh0qguLURu7fUoqxs8x/MRERUYFZW5IsppSWtokK+yJKk3AU/+WzdC32wdY8oMbYihsvyOVTTFqanp/HYY4/BZDLh5ZdfRmdnJwYHB6PWe/7553H+/HlcuXIFjz76qOZCms3mmAFdLMnMAWgymTIa9Klp39aIuqpyTd1D66rKcXRnE8Y+VLmDEWFlTYLv7ix8d2ejltVUlOFAy0broWFrA9rX/7+toRo6VkxERJRJKyvyxdXYGHDzZvhE5+XlwJ49wMGD8t34TASEbN0j2txKrRUxR+dQTa984YUXcO7cOTz11FPB52IFE0899RT6+vrSCgSL2dqahKce2Ye/uTSe8mufenQfrn44g4UVbWMMFYsra3j7zj28fede1LKG6goYWhrQ1tKA9vUgUfl/c11VWvslIqIStLoKjI8Db70Ve/n16/LjwQcBg0G+sEl222zdI6JQm60VMZvn0AiaAsGmpqawIBAApDgfZrxlm119dQW+9BtHNAWCX/rUEbS1NOCXfZ/HzOJ9jE/KLX7jkzPwr//ff3cG4oL2cYizSyv4xS0Rv7glRi1rrq1a714a0pq43uW0Ic0ur0REtAmtrMS/gIn01ltyQHXgwMZdbbbuEVEmFGMrYibOoSnQdIZTa/2L171wenpay242jR2NNfiDzz6U0qTyf/i5h7GjsSb4d2NNJX6ttRm/1tocte7U/BL8d2fXA8UZ+O/Owj85C//dWcwta79DGlhYxuh7Uxh9bypq2fbGmrCENe1bG9HW0oADLQ2orWRmUyKikrS0lPwFjOLNN4EdO4APPgAmJti6R0TZp6UVcW5O+/6SaUXctQtoatJ2Dt21K3eBoCiKKa0/GfmmS0xdVQWe/fhB6HQ6fPMHv0y4/h9+7mH8x4+1o7Yyua9HX1cN/b5qdO4Lv9shSRI+nF2Sg8NJufVQCRLHJ2extLKm6f0AwAczi/hgZhE/u3Y37HmdDmhtqlvvXip3MzVslQPFfc31qGRmUyKizWllRR7PooXfL1/IpHh9EYWte0SUjnitiKurcq+EbLUi7t8vnwu1GBsDjh1L+TynuWvo3/3d3+Ff/+t/HXwuVvfP5557Do8//riW3WwqtZUV+O2PtuOJY634zj+9g/NXboQlkKmrKsdTj+7Dlz51BDsaa5IOAuPR6XTY3liD7Y01+FjbtrBla2sSbt1bgO/uDMbXg0Pf3RmMT87i+tQcVta0deeVJOCmOI+b4jz+yfdB2LLyMh32NdeHjEncyGza2lSHcmY2JSIqXjqdnNRAi5s3gaNH5W5SyXT/ZOseEeVaeXn2WhHr6oDmZuDSJW1lu3kTeOihlF+mKdp48cUXcfDgQbjdbthsNuzfvz+qa+iVK1dgs9kAAC+99JKW3Ww6dVUVaGtpwDd+8xF884lH4b87g5ml+2isroRhayPW1iTUV+fmjmVZmQ57hDrsEerw6YM7wpatrK7hPXEe/rsz62MSZ4OtijfFec1ja1fXJIyvt0ZGqiovwwFl+ovQcYktjdi5pYaZTYmICt3sbHhmu1SsrgL37snBnBIIlpWpB3ts3SOiQpKJVsSGBmB6Or1z6Oys3LU0BZrPpD/60Y/w+OOPw+FwAAAEQcDw8DBEUcTU1BREUYTRaITH49G6i01LCfaO7RLyW5AYKsrL0Lbeatd1JHzZ4v1VXJ+a2+hquj4W0T85g9v3FjXvc3l1De9+OIN3VabKqKsql1sQWxrRFhyT2IC2lka01FcxSCQiKgTpjutbXQXa2uQMeGzdI6LNINlWxLIyuZtoOjScgzUHggaDAWNjYxgYGIDD4cD4+Hhw7j6DwYAXX3wRZ8+e1bp5KlA1leU4smMLjuzYErVsbmkF45PriWom18cjrmc2nZxf1rzP+eVVvPH+NN54PzrpUFNNZUhw2BjS5bQRW2qY2ZSIKGfSbaWrrk75bjYRUVFSa0VMN7lmrpLFhOrt7UVvby8AYHx8HHq9Hk08kZek+uoKPLRbwEO7hahl0wvLwSkvxiO6nM4sab+LPL14H1duBnDlZiBqWUt9tRwURkx9caClAfVV7FZERJRRDQ3y3W8tXZvKy+XXExGVqjycQ3VSKU/yl6aOjg60trbizJkzOHPmTL6LU5QkScLduaXgHIn+9YQ1SqC4cF9jX+kEdm2pDZkfcSNQ3K+vR3UFp78g2uyGhoYwNDSEiYmJYG8Wii2p+m5lBXjjDXmS41Tt368p4x0R0aaRxXNorDovJ4HgK6+8gmeffTbbu8m5kydP4sKFC/kuxqa1tibh9sxCyLyIG2MSr03N4v5q5g/dMh2wR6gPCxLb14PEPUIdKjj9BdGmwvN4cpL+nObmgIsXU99BV5c87QMRUSnL8jk08lye9Vtv4+PjsNvtmzIQpOwqK9Nhd1MddjfV4ZPt28OWra5JuLme2TTY5XR9XOKNwBw0zn6BNQm4EZjDjcAc/sfVO2HLKst12N/cgLatDcEup23rYxN3balFGae/IKJSV10NPPhgahMiHz0qv46IqNTl+ByqGgj+yZ/8iaaNqXG73ZiamsrY9ogAeU7C/fp67NfX4zMRy5ZX1nAjMBecF9F/d2OOxInpBc37vL8qYezuDMbuzsAdsay2shwHWhrC50hcH5u4raGamU2JqDRUVMhZP3U64M03E69/9KicKbScXfKJiHJ9DlUNBL/1rW9heno65iTxydLpdJAkiRfBlFNVFWU4uK0RB7c1Ri2bX17Btam58Kkv1v//4eyS5n0u3F/FW7en8dbt6IxPDdUVYQlr2rc2rGc6bURzXZXmfRIRFaTycuDAAWDXLmBsTJ7oODT5QXk5sGcPcPCgfBebQSAR0YYcnkNVA0GDwQCTyYS+vr6YLxwcHAQAmM1m1eWBQACDg4Po7OxEV1eX5gISZVJdVQWO7mzC0Z3RmW1nFu9HBYfK2ERx4b7K1pIzu7SCX9wS8YtbYtQyfV1VsHtpW3BMohwkKvNN5trc0grKynTwfTiDmaX7aKyuRPu2RqytSXkrExEVmYoK+XHsGPDQQ/I8WSsr8nMNDfIcWkwMQ0SkLkfnUNUt6PV6fPGLX4w5DcSVK1cgCELceQLb2trw8ssv49vf/jZbBKkoNNZU4pHWZjzS2hy1bGp+aX3qC3mOxNDpL+aXtWc2nZpfxtT8FEbfi+4+vaOxRu5qGpKwxrC1AQf0DaipzPwd9PnlFdyZWcR3fvwOzv/8Rtj7qqsqx1OP7MOXfuMIdjTWoI7TbxBRMpQLFU4rRUSUuiyfQ1Wv5pxOZ9y5AD0eD772ta8ltYPnn38efX196O/v11ZCogKgr6uGfl81TuxrCXtekiR8MLMYlrBGngZDzmy6tLKmeZ93ZhZxZ2YRP712N+x5nQ5obaoLyWy6ESTua65HpYbMpgv3V/BXPx3DH//wV6rL55dX8TeXxvE3l8bxB599CM9+/CBqKxkMEhERERUr1Su5RBPCpzp2UK/Xp7Q+UbHQ6XTYsaUWO7bU4mNt28KWra1JmJie3+huup7VVMlsuqIxtakkATfFedwU5/HjsQ/ClpWX6bCvuV4eh7ievKZ9ayPatjagtakO5SqZTeeX4weBkf74h7+CTqfDb3+0nS2DREREREVK01Vcql092TWUSlFZmQ57m+uxt7kenz64I2zZ/dU1vBeY22hJDAkUb07PQ2ueptU1CeOTcrfVSNUVZTig38hq2ra1ASf2tqCqoizpIFDxzR/8Ek8ca0VbS4O2ghIRERFRXmkKBMfGxnDv3j1s2bIlqfV9Pp+W3RBtWpXlZXKXzq2NMB0JX7Z4fxXXp+bgm5zB+N2QORInZ3H73qLmfS6trOGdD+7hnQ/uBZ8bfuZT+Ptf3dS0ve/80zv4xm8+wgQyREREREVI0xVcT08Pzp49i+Hh4YTrPvfcc+jo6NCyG6KSVFNZjiM7tuDIjugbLXNLK8EkNaFdTsfvzmJyfjml/exvrsfxPc145r/8RFM5z1+5gW8+8Yim1xIRERFRfmkKBLu6ujAyMoJDhw7hhRdeQFdXFw4cOBBcfu/ePXg8HvT390Ov1+Oll17KVHmJSlp9dQUe2i3god1C1DJxYTl86ou7G9NfzCytRK1/aHsj3rg9rTnr6fzyKq7cDGDYex23puexX9+AA/p6HNA3YL++Hgda6tFQXalp20RERESUXZr7dDkcDlitVpw9ezbmGMCnnnoK586d01w4IkqeUFsF4149jHvDkzNJkoQPZ5cwvj4vou+u3IK4T1+POZUAMRWzSyuYX17BP459AOCDqOUt9dVyUBgaIOrrcaClAdsbalCmkryGiIgoVzh3LpWytI5wJRjs7+/HxYsXIYoiBEFAZ2cnbDYbJ5InKgA6nQ7bG2uwvbEGv35ga9iyX6pMcp+KhuoKzMYJJifnljA5twSvyjyJNRVl2L8eHO5fDxQPtNRjf3M99unrUV2R+bkSiYiIAM6dSwSkGQgCgNFohNPpzERZiCjHDm5rRF1VuabuoXVV5Ti6swljH85o2veiSvIahU4H7NpSiwP6+mCwGAwU9fVorq1iNmIiItKEc+cSyXhUE5WwtTUJTz2yD39zaTzl1z716D4srayi7/GHcD0wi2uTc7g+NYvrU3O4dW9B8xQYgDxX4q3pBdyaXsBPxu9GLd9SU7keJMqBotKSeKAl9nyJREREnDuXaENOjui+vj709/fnYldElIL66gp86TeOaAoEv/SpI9jeWIt//cjeqGWL91fxXmAO1wNzuDY5h2vrAaL8mMXiylpa5b63eB+/uCXiFypdWyvLddgjhI9L3N+y8f96VuRERCXrzswi584lWpeTK6LBwUEGgkQFakdjDf7gsw+lVDH+4ecexo7GmpjLayrLcWj7FhzaHj0FxtqahA9mF3FtchbX1oPDa1Mb/5+cW9L0PhT3VyWMT85ifHIWwJ2o5dsaqqMS1yhdT7c1VLPLKRHRJiRJEmaXVvCdH7+j6fWcO5c2o7SO5ldeeQU+nw+iKMZcZ2pqKu5yIsqvuqoKPPvxg9DpdPjmD36ZcP0//NzD+I8fa9c8XqKsTIedW2qxc0stPtq2LWr5zOL9YOvhRoAo/3tTnMfqWhp9TgF8OLuED2eXcOnGZNSy2sryqMQ1B1rkaTH2CPWoqihLa99ERBSfJElYXFnD/PIK5pZXQv5dDft7bin8uXmVdZS/55ZXsLW+Gj/4ncdw/uc3NJXr/JUb+Ppv/hr+vz8bQ3VFObY1VGNbQw22NdRga301aiqZ4IyKj6YruenpabS1tSUd4PEOO1Fhq62swG9/tB1PHGvFd/7pHZy/opJB7dF9+NKn5Axq2Rw031hTGXOuxPura5iYnsf1kO6m15SAcXIOc8vpTYexcH8Vb9+5h7fvRCewKdMBrU11YeMSQ1sWm2qr0to30WbE1PyblyRJmL+/GjNQm19exfxS/GBO/ndjG8pzad7vU/WR/S1pz537y1siPG/fxsV3b0ctb6yuWA8MQwLEhuqQvzeer6sq57UxFQSdJKWe0uHUqVPQ6/Ww2Wxoa2uLu64oimhpacHqqrYfXiHr6OhAa2srzpw5gzNnzuS7OEQZoVy4yRPRyxduhq2Ff+EmSRIm55ZDxiOGdz29fW8xq/tvrq3amAqjZSNA3K9vwO4ttZwzscAMDQ1haGgIExMTGB0dzXdxCl6q9R1T8xeOtTUJ8/djBGFLq5i/v966tv5vrKAurDVueQUL91fTSgqWa//Lw3vQc3w//tf/639q3sb/7999As7Xr+P//uXNtMpSW1m+HiTWhAWKW+vD/97WWIOmmkoGjZS2WHWeprOvXq/Hyy+/nNS6giAkDBaLVWtrKy5cuJDvYhBllBLsHdsl5LcgKdLpdNjaUI2tDdXo3NcStXx+eQXvBebDxiNeX29JvBGYw/JqeglsAgvLCEws48pEIGpZVXkZ9jXXxwwUa9mlKOeUgObkyZP5LkpRSKW+Y2p+bVbXpKiWMTlAWw0L1JS/47e0bfy9cH/z3YjXYm55Je2bmYnmzk3Wwv1VvBeYx3uB+YTrVpbrogLErRH/Ks/r66qZNZtUxarzNP0impubU1p/bGxMy26IiDKmrqoCR3ZswZEd6gls3r+3EN7ddHIW1wNzuD45h8DCclr7Xl5dw9jdGYzdVZ9zcUdjzUbimuZ67F8fl7hfX4+t9UxgQ8WjFFLz31/dGL8WL1ALb2mLbo2bX14N+zvdbMqbWW1lOeqqKlBfVYG6qnLUV1WgvroCdZXKv+Vx/66vqkBTbSX2NdenNXfuQ7sEbGuoxq/tFvDh7BLuzi3i/mp2m0Xvr8r10/v3FhKuW6YD9HVyS2J4S2N099StDdWoLOe491Kn6ayroTcpEVHBKivToVWoQ6tQh08YopdPLyyHjUe8HhIoTojzaY9nuTOziDszi/jn69EJbOqrKqIS1ygJbVqFOlbkVFAKJTW/JElYXl3bSBaiEphFdokMTSwSL/lIur0HNrPQQC0ycFP+Vg/cKlBfvRHsha5fW1mesa71c0srac2dW6bT4S/MJ4LPSZIEceE+PpxdxIezi7i7noxM/lv+9+7cUnBZtltn1yTg7twS7s4t4a0k1hdqKyNaGeXEN9saowNH9lzZnDQFgt3d3Xj11Vfx2GOPJbX+c889h5deeknLroiI8q6ptgq/1lqFX2uN7g2xvLKGm+JcdKC4HiymW/HPLa/gjfen8cb701HLyst0aG2qi0pco/y/saYyrX0TpWIuzdT8v//4Q/hgZjF2S1uMDJGxukSuZCPjyCZQpoNKwBXa4qbe8lZXHTvIUwK2Qu+9kO7cuZFdS3U6HZrrqtBcV4XDKtMlhZIkCXPLKxsBYkTAGPn8TAa6oCYiLtyHuHAfVz9U760Sqr6qIirxjdo4x20NNWiorij4Y4FkmgLBrq4unDt3Dn6/H88++2zC9UdGRhgIEtGmVFVRBsPWRhi2NkYtkyQJH84uRSWuuTY5h+uBOXwwk14Cm9U1CTcC8hjHH+ODqOUtdVXYv97dNDxYbMCOxhomsKGMKivTpZWa/w8/+zD+3f/1E1wPzGW4ZMWpvEwXEqyVR7WU1a0Hb2FBWbV6MBca5NVUlJX0RXo25s5Nhk6nQ0N1JRqqK5Nq/V64v4q76wHi3bmQgHFmI3CcXG9tnJpPb/hCMuaWVzA3tYJrU4l/nzUVZdgaEShudE8NCRwbqyHUVLEuyiNNgWBfXx9EUYTf74fVaoXRaITBoNKfCnLWUM4jSESlSKfTYXtjDbY31uDE/q1Ry+eWV4JzJl4PBojyv++Jc2mPPZmcX8bk/BS8701FLaupWE9gE9Hd9IC+Hnub6zknFqXM9+FMWqn537w9jYPbGosuEKwqL1NtKVNtYVPpDhkZqCnrVpWXdsCWLbmeO1er2spy7G2Wz8eJ3F9dCwaF4d1TI7uoysFjuvPxJrK4soab4jxuiomT4VSU6dASNYaxWqW1sQb6uipUcDhERmk6qh0ORzC4EwQBPp8PPp8vaj1lHZ7IiIii1VdV4OjOJhzd2RS1bHVNwq3p+bDupsr8idem5nBv8X5a+15cWcO7H87gXZUuQTodsGtLLQ7o67FvPTgMtia21KO5tipv53XOS1e4ZpbSOyZnl1bQkMXvsKaiLCzgUgvW6qvLIwK12IlIlNdxnG7xKaS5czOhsrwMO7fUYueW2oTrrq1JmJpfDhu/GNo99W5Et9Vsj4ldWZOC4+QT0ekAfW1VeLbURpVpN9ZbI6sriv+GZrbrPE1bMBgM+OIXv5hUt1AAaGmJTuVORESxlZfpgneDP9W+PWp5YH45ZDziemviesvirXsLac3vJUnArekF3JpewE/G70Yt31JTGTb9Rej/W5tqs3LHlvPSFb7G6vTGpCqp+dUyRKaWeGT979Cgr7KcLQkUpq6qAm0tDfjGbz6Cbz7xaNHNnatVWdnGVEuJSJKEe4v3445rDO22qrVHQLIkSenpsox3okdDRNlSUxkdIK63Pm4NTYhTX1Nw33Wu6jzN8wiaTKak1091ugkiIopPTlCgx/E9+qhli/dXcVOcDxmPGB4oppum/t7iffzylohf3hKjllWsB7CRiWuUrqdaKlvOS1cc2rc1ppWa/9E9zfibf/cJzoNGOVWsc+fmgk6nQ1NtFZpqq3BwW/Q4+EhyMhylZVEJHiNbHOX/T6fZqyUZ9xbv497iffjuziZct7ayPE731PCWxqaayqz2isllnafpVT/60Y9SWp/zCBIR5U5NZTkObmtUrbglSe6Go0x/cW0yPNPp5NxSWvteWZMwPjmL8Un1indrfXVU4hpleoztjTVRlWspzEu3WaytSWml5l9bA8orGQQSFav6qgrU6xtwQJ84Gc7SyupGsDgXMa5xJvz5qfmltHq5JGPh/mow+VoiVeVl4Ylwgi2N0eMam+uqUrq5les6j7UkEVEJ0el0wbEkH23bFrV8ZvE+bkQFiPK/74nzaScZUOa4unwjOoFNbWV5WOvhpw9ux359Q0HMS0eJZTo1PxFtXtUV5cH5exNZWV3bGNcYa9qNkGQ52Z46Znl1LTh8IpEyHaKS4cSadmNrfXXO52JVPeu+8sorSY//S0amt0dERNnRWFOJY7sE1W5SK6truDk9H5a4JnT+xNk0571auL+Kt+/cw9t37gEAHju8Ey+/9q6mbX3nn97BN37zEQYXOZav1PxEtHlVlJcFM3AnsrYmQVxcxoczEdNuxEiIk+5QiYTlkbC+78S9bYaf+RT+/lc3Ne1Ha52nurbdbs9o4Jbp7RERUe5VlJetTzHRABwMXyZJcia6yMQ1yvyJ799LfOc01P7mehzf04xn/stPNJX1/JUb+OYTj2p6LWlXLKn5iWhzKivTQV9XDX1dNY5gS9x1JUnC7NLKRoviTOxpNz6cXUz7Zmc8+arzVM+8k5OTmJmZQWNj4oGhiUxPT2NqKroLEBERbR46nTwXVEt9NTr2RmeKXri/ihtTG4lrrq0Hiten5DEZSxF3ZQ9tb8Qbt6fTmpfOf3eGCSDyYLOl5ieizUmn06GxphKNNXKm2EQW7q8GA8Xw+Ro3uqUqyXECC8splSVfdZ7q2VcURQhCahsiIiKKpbayHEd2bMGRHdF3aNfWJNyeWQgbl7i1vhoLaaYiT3deO9KuVFPzE9HmVVtZjn3N9djXXJ9w3eWVNUzOhY9fjOyeqvw9ObeE+qoKzKXZ4qilzot5FpYymJ6HE8oTEVEsZWU67G6qw+6mOnzcsJHA5lcq01OkIt157Sh9TM1PRKWoqqIMu5pqsaupNuG6q2sSZpfu49pU4oyl8Wip81RnVxUEAX6/H2tra2k/OHUEERFpocxLp0VdVXlSXX2IiIjyqbxMnq/x8PYtOa/zVANBvV6PAwcOaCpIJIPBgLa2toxsi4iISocyL50W8rx0WZ54ioiIKEPyUeepBoJWq1VTIWLJ9PaIiGjzU+al04Lz0hERUTHJR52nGgg+//zzmgoRS6a3VygmJiZw8uRJDA0N5bsoRESbkjIvXSqSmZduaGgIJ0+exMTERDrFKxms74iIsi/XdZ5OymRWmBJz8uRJXLhwId/FICLa1Bbur+CvfurLyrx0PI8nh58TEVFu5LLOY78ZIiIqaJyXjoiISkUu6zzWlkREVPA4Lx0REZWKXNV5rDWJiKhocF46IiIqFdmu81STxRAREREREdHmxUCQiIiIiIioxDAQJCIiIiIiKjEMBImIiIiIiEoMA0EiIiIiIqISw0CQiIiIiIioxOQkEHzllVfSer3H40FPTw9sNhtsNhusViu8Xm+GSheuu7sbfr8/K9smIiIiIiIqBFmfR3B8fBx2ux3PPvusptfbbDZ4vV643e6w5zs6OmC1WmGxWDJRTACAy+WCx+PJ2PaIiIiIiIgKkWog+Cd/8icZ24Hb7cbU1JSm13o8HgwMDECSpKhlTqcT7e3t6OzshNFoTLeYEEURNpst7e0QEREREREVOtVA8Fvf+hamp6dVA7BU6HQ6SJIEnU6n6fU2my1mi5/BYIDJZILNZotqLdSiv78fZrMZAwMDaW+LiIiIiIiokKkGgkqQ1dfXF/OFg4ODAACz2ay6PBAIYHBwEJ2dnejq6kq5YF6vF16vF1arNeY6RqMRAwMDEEURgiCkvI/QfZ04cYJjA4mIiIiIqCSoJovR6/X44he/iKamJtXH+Pg4BEHA888/j7a2NtWH0WjEyy+/jEAgoKlFUBmrZzAYYq7T3t4etq5WDocjZkBLRERERES02agGgk6nEwcOHIj5Io/Hg7Nnzya1g+effx4OhyPlgl26dAlA/EBQWaasq8XAwADHBhIRERERUUlRDQSbmprivijVsYN6vT6l9QE5eUuyr1XWTZXf74cgCHGDTSIiIiIios1G0zyCqXb11NI1NJlMo0qQqDUrqd1uz+j0E0RERERERMVAUyA4NjaGe/fuJb2+z+dLeR+ptPJpaREcHByMm4iGiIiIiIhos9I0oXxPTw/Onj2L4eHhhOs+99xz6Ojo0LKbrBFFEaIopj3/4MTEBE6ePBn8+8yZMzhz5ky6xSMioiwZGhrC0NBQ8O+JiYk8lqZ4sL4jIio+ieo8TYFgV1cXRkZGcOjQIbzwwgvo6uoKSy5z7949eDwe9Pf3Q6/X46WXXkp5H6lMB5Hq1BH9/f2w2+2pFUhFa2srLly4kPZ2iIgoNyIDmNDghmJjfUdEVHwS1XmaAkFAnnLBarXi7NmzMccAPvXUUzh37pzWXQCQx/8lCvRSSUbjcrnQ3d2dVpmIiIiIiIiKmaYxggqHw4HLly/jC1/4ApqamiBJEpqamtDV1YUf/ehHGBkZSZiBNBYlk2e88X/KBPCptAheunQJJpNJU5mIiIiIiIg2A80tggqj0Qin05mJsoQ5ceIEXC5X3IygyrITJ04ktc3BwUG4XK6YE9ArgWV3d3cwuDx37lzaYwmJiIiIiIgKSdqBYLYorXZKcKZGyUaabAufxWKJO12E1WrF4OAg3G435xYkIiIiIqJNS1PX0G9/+9soLy/HK6+8kunyBBmNRhgMBrjd7pjruFwumEymlJPFEBERERERlTJNgeClS5fQ1taWUpIWLRwOB1wul+o4Qb/fD7/fD4fDofranp4edHR0xG1RjEXLvIQpWVkBVleB6WlgclL+d3VVfp6IiIiIiCjLNHUNNRgMGBkZSXr9e/fuYcuWLSnvx2Qyobe3Fz09PWEtg6Iooru7Gw6HQ7ULp8fjgcvlAiC3Gvb29ia1P2XMYbxxiWlZWQGWloCxMeDmTTn4U5SXA3v2AAcPAtXVQEXB9tolIiIiIqIipynaaGlpwbVr18LmDoyno6MDV69e1bIr2O12uFwuWK3WYBdQpSUw1thAk8kEo9EIURRhNpvjbt/j8cBms8Hr9QafU5LFdHZ2xu2ampLVVWB8HHjrrdjLr1+XHw8+CBgMcnBIRERERESUYZoCweeffx4vvPACPvKRj+ALX/hCwvUnJye17CbIbDYnDOgijY6OJrWeyWRKel3NVlbiB4GR3noL0OmAAwfYMkhERERERBmnKcr4kz/5E2zduhXDw8M4e/YsOjs7YTAYVJO2+P1+TE9Pp1vO4ra0lHwQqHjzTWDXLgaCRERERESUcZqijG9961uYnp6GJEkAkLD7pE6n07KbzWFlRR4TqMXYGHDsGINBIiIiIiLKKE1ZQw0GA15++WWsra0lfGQt8Uqx0OnkxDBa3Lwpv56IiIiIiCiDNAWCer0e3d3dSa0rCALa2tq07GZzmJ0Nzw6aitVV+fVEREREREQZpKnP4Y9+9KOU1h/T2jVyM0h3bkDOLUhERERERBmWlcFnr7/+OoaHh6HT6dDS0gKLxaJpHsFNId3xfRwfSEREREREGZaVKOP48eM4fvx48O/nnnsOL730UjZ2VfgaGuT5ALV0Dy0vB+rqgHffBfbvlyeaJyIiIiIiSpOmMYKpuHLlCi5fvpzt3RQuSQL27NH22j17gEAAePttwOORp6BYXs5s+YiIiIiIqOSk1SLY19cHj8cDURRVs4OKoggAsNvt6eymuFVUAAcPAtevp/7aAweAd96R/7+6Cly9Kk9M394OGAxAZWVGi0pERERERKVBc4vg448/DrvdjkAggLa2NjQ3N6OjowNdXV3o6OhAc3Mzmpqa4Ha78bWvfS2TZS4YExMTOHnyJIaGhuKvWF0NPPhgahtX1r9zJ/z5lRU5OPR45MCQyWSIiFI2NDSEkydPYmJiIt9FKQpJ13dERFRwYtV5mloEz58/DwAIBAJoamoKPmcymYJ/A8D09DRefPFFPPbYY1rLXdBaW1tx4cKFxCtWVMgteDod8Oabidc/ehRoawMWF4HWVvV5CO/fl7uK+nxyi+OBA0wsQ0SUpDNnzuDMmTM4efJkvotSFJKu74iIqODEqvM0tQiOjIzgRz/6UVjQJwgCxsfHw9ZramrCCy+8gFdeeUXLbjaX8nI5WOvqkhO/lJdHL9+/X15+4ID8d309YDQCn/kMsHu3+naXl+Xg8uJFwO/XPmchERERERGVDE1NSGoTxBsMBgwODuLRRx8Ne76pqSk4VrDkVVTIj2PHgIcekieLX1mRn2tokBPLqLXqNTYCnZ3AvXtyt9D3349eZ2kJ+NWvgLEx4PBhYN8+oCzruYCIiIiIiKgIaQoEt27dGvVcW1sbvF6v6vqTk5NadrN5KcFeSItqUrZsAU6cAKan5UyikeMHAbk76S9+IY8fPHwY2LuXASEREREREYXRFCHcvXs3+P979+7h3r17AOT5A//0T/80an2/36+xeKSqqQn49V8HPvUpYNs29XUWFoCf/xx49VXgvffk1kYiIiIiIiJoDAT7+vrw3HPP4dq1axAEAZ2dnQAAi8WC559/Hr/zO7+DK1eu4Nq1a3juuecyWmAK0dwMfOxjwCc+AbS0qK8zPw+8/jrw3/87MDHBgJCIiIiIiLR1DW1qasKLL74Im80Gg8EQHBdoMBjw4osv4oUXXoDD4QiuPzo6mpHCUgwtLXIwePeu3GVUZU5HzM4Co6PAu+8CDzwA7NwpZzElIiIiIqKSo3m+gaamJrz88stRz/f29sJoNMJut6O5uRlWqzUqgQxlydatckD44YdyQKiWpGdmBrh0Se5eeuQIsGMHA0IiIiIiohKTlYnnTCYTTCZTNjZNieh0wPbt8tjBO3fkgHB9DGeY6WngX/5F7l565Ii8PgNCIiIiIqKSkHY6yVdffRXXrl2Lev78+fO4cuVKupsnrXQ6ufvnpz8tTz3R2Ki+XiAA/OxnwP/8n3LXUiIiIiIi2vQ0B4Lnz5/HqVOn0N3dHUwWE+qpp57CpUuXOJl8vul08mT0/+pfAR0d8nyFaqamgJ/8RH6ojTEkIiIiIqJNQ1Mg+Prrr2N8fBwjIyN47LHHYDabVdc7e/Ys2tra8Oqrr6ZVSMoAnQ5obZUDwuPHgbo69fXu3gVee01uJQwEclpEIiIiIiLKDU1jBAcHB/HSSy8BANxud9x1u7q60NfXh8cee0zLrijTysrkSeZbW+X5Bd99V55zMNIHH8iPHTvkLKNNTbkvKxERERERZYXm6SOoyJWVAfv3y0Hh9evA1avA4mL0enfuyI9du+SkMlu25L6sRERERESUUZoCwenp6ZTWF9WmMaDCUFYGtLUB+/ZtBIRLS9Hrvf++/GhtlQPCWGMNiYiIiIio4GkKBCcnJzEzM4PGWJkoQ0xPT2NyclLLbiiXyssBg0EOCK9dA8bGgOXl6PUmJuTHnj1yQFhfn/OiEhERERFRejQlizl16hQee+wxzMzMJLXu448/rmU3lA8VFcDBg4DJJI8NrKxUX+/mTeDVV4ErV4D5+ZwWkYiIiIiI0qMpEDSbzTAajRAEAb//+7+PK1eu4F7IpOVXrlzBK6+8gpaWFgDAs88+m5nSUu5UVACHD8sB4eHD8t+RJAm4cQO4eBH4xS/Uk84QEREREVHB0dQ1FAAcDgcEQcCLL74Iu92uuk5XVxdGRkY0F44KQGWl3DJoMAA+H+D3A6ur4etIktyd9MYN4MABuUWxpiYfpSUiIiIioiRonlAeAOx2O8bGxvDss8/i+PHjkCQJTU1NwQDwRz/6ETOMbhZVVcCDD8othO3tcpKZSGtrcqB48SLwxhvqSWeIiIiIiCjvdJIkSfkuRLHq6OhAa2srzpw5gzNnzuS7OLm1uChnGL1+XQ4A1SgJaNrb5UCSiKhADA0NYWhoCBMTExgdHc13cQpeSdd3RERFLladl3Yg+Oqrr8JgMODAgQNhz58/fx7t7e149NFH09l8QTt58iQuXLiQ72Lk18KCPCn9jRtyF1E1FRVyMGgwxE4+Q0SUBzyPJ4efExFR8Ys8l2vuGnr+/HmcOnUK3d3d6OzsjFr+1FNP4dKlS3jllVe07oKKQW0t8MgjQFeXPPWEThe9zsoK8M47gMcjtyKurOS+nEREREREFKQpEHz99dcxPj6OkZERPPbYYzCbzarrnT17Fm1tbXj11VfTKiQVgbo64NFHgc98Rp5jUM39+8Bbb8kB4dgYA0IiIiIiojzRFAgODg7ia1/7GgDA7Xbj5ZdfjrluV1cX3G63ttJR8WloAIxGOSDcvVt9neVl4M035aQyallIiYiIiIgoqzRNH8FMoJRQYyPQ2Qncuwe8/TZw+3b0OktLwK9+JbcOHj4sdy1Vy0ZKREREREQZpSkQnJ6eTml9URS17IY2gy1bgI98BBBFeZzgnTvR6ywuyhPSKwHhnj0MCImIiIiIskjT1fbk5CRmZmaSWnd6ehqTk5NadkObiSAAv/7rwCc/CWzbpr7O/Dxw5Qrw3/878N57sbOQEhERERFRWjQFgqdOncJjjz2WVDB46tQpPP7441p2Q5uRXg987GPAJz4BtLSorzM3B7z+uhwQTkwwICQiIiIiyjBNgaDZbIbRaIQgCPj93/99XLlyBffu3Qsuv3LlCl555RW0rF/oP/vss5kpLW0eLS1yMPixjwHNzerrzM4Co6PA//gfwPvvMyAkIiIiIsoQTWMEAcDhcEAQBLz44ouw2+2q63R1dWFkZERz4agEbNsGbN0KfPihnFRGbTzpzAxw6RLQ1AQ88ACwfbv6fIVERERERJSUtDJy2O12jI2N4dlnn8Xx48chSRKampqCAeCPfvQjZhilxHQ6Obj71KfkxDJbtqivNz0N/PM/A6+9BnzwAVsIiYiIiIg00twiqDAYDHA4HJkoC5U6nQ7YuRPYsUPuCvrOO3JrYKRAAPjZz+Txhg88ILcoEhERERFR0tIOBNW8/vrrGB4ehk6nQ0tLCywWC7bEauUhiqTTyZPR79olJ4t55x05gUykqSngJz+RA8EHHpADQyIiIiIiSigrgeDx48dx/Pjx4N/PPfccXnrppWzsijYznU6eU3D37o2AcH4+er27d+Xuotu3A0eOxE4+Q0REREREALIUCIa6cuUKLl++nO3d0GZWVgbs3Qu0tsrzC777LrCwEL3eBx/Ij5075YCQ41OJiIiIiFSlFQj29fXB4/FAFEVMTU1FLRfXM0DGyipKlJKyMmD/frmV8MYN4OpVYHExer3bt+XHrl1yQMhuyUREREREYTQHgo8//jg8Hg8MBgMMBgMkSYLBYIAgCBBFEX6/H5IkweVy4bHHHstkmanUlZcDbW3Avn3AtWtyQLi8HL3e++/Lj9ZWOSBsaMh5UYmIiIiICpGmQPD8+fMAgEAgEJwe4vz58zCZTGHTRUxPT+PFF19kIEjZUV4OtLfLrYTXrgFjY+oB4cSE/Ni7Fzh8GKivz3lRiYiIiIgKiaZ5BNXmCBQEAePj42HrNTU14YUXXsArr7ySXimJ4qmoAA4eBEwmOXtoZaX6eu+9B7z6KvDzn6snnSEiIiIiKhGaAsG2trao5wwGA4aHh6Oeb2pqCo4V3GwmJiZw8uRJDA0N5bsoBMgB4eHDckB4+LD8dyRJAq5flwPCX/xCfYwhEW16Q0NDOHnyJCYmJvJdlKLA+o6IqHjFqvM0dQ3dqjKBd1tbG7xer+r6k5OTWnZT8FpbW3HhwoV8F4MiVVbKLYMGg9xddHwcWF0NX2dtTe5OeuMGcOCA3KJYU5OP0hJRHpw5cwZnzpzByZMn812UosD6joioeMWq8zS1CN69ezf4/3v37uHevXsA5PkD//RP/zRqfb/fr2U3ROmpqgKOHpVbCNvb5ayjkdbWAL8fuHgRePNNYGkp9+UkIiIiIsoxTYFgX18fnnvuOVy7dg2CIKCzsxMAYLFY8Pzzz+N3fud3cOXKFVy7dg3PPfdcRgtMlLLqauDYMTkgbGtTDwhXV+XWQ48HePtt9aQzRERERESbhKauoU1NTXjxxRdhs9lgMBjw6KOPApDHCb744ot44YUX4HA4guuPjo5mpLBEaampAR5+WO4G+u67crdQSQpfZ3VVXub3y62IBkPs5DNEREREREVK8zyCTU1NePnll6Oe7+3thdFohN1uR3NzM6xWazBQJCoItbXAI49sBIQ3b0YHhCsrwDvvyAHhwYNyS6Ja8hkiIiIioiKUlStbk8kEk8mUjU0TZU59PXD8OHDo0EZAGOn+feCttwCfT17vwAF5/kIiIiIioiKmaYwg0abS0AAYjcBnPgPs3q2+zvIy8MYb8hhCtSykRERERERFRDUQZIIXKkmNjUBnJ/DpTwM7d6qvs7QE/PKXcpbRa9fkrKNEREREREVGNRAcGRnJdTmICkdTE/CRjwC/8RvAjh3q6ywuyhPSv/qqnHSGASERERERFRHVMYKBQADl5eUQBEHTRvV6PTo6OmC1WvGZz3wmnfIR5Y8gAL/+68DUlJw45sMPo9eZnweuXAGuXgWOHAFaWwGdLtclJSIiIiJKScxkMZIkIRAIaNpoIBCAz+eD0+mEzWbDt771Lc0FJMo7vR742MeAyUl5jsHJyeh15uYAr1dOOvPAA8CuXQwIiYiIiKhgxQwEvV6v5mkfpqen4ff78V//63/Fiy++iO7u7rRaBj0eDxwOBwwGAwBAFEVYrVYYjUbN2wQAm80Gj8cDURQBAEajEVarlRlPSV1LC/DxjwN378oBodqNktlZ4PJlYMsWuYVw504GhERERERUcFQDwdBJ4rVoamrC8ePHcfz4cZw+fRp2u11zIGiz2eD1euF2u8OeV7qeWiyWlLcpiiLOnj2Lvr4+2O324HP9/f3o7u6GyWSK2h8RADmo27YN2LpV7ir69tvA+o2EMPfuAZcuyeMNH3gA2L6dASERERERFQzVQFDr2EA1RqMRbW1tml7r8XgwMDAAKXKybwBOpxPt7e3o7OxMuWXw7NmzOHfuXNj7FAQBdrsdLS0tsNlssFqtcDgcmspNJUCnk4O7bduAO3fkgPDevej1pqeBf/5noLlZDgi3bmVASERERER5p5o11Ol0ZnQnW7du1fQ6m80Ws8XPYDDAZDLBZrOltE2Px4Pu7u6YwW5vby8EQcDg4CC8Xm+qRaZSo9PJ3T8//Wl56onGRvX1AgHgpz8FfvITuWspEREREVEeqQaCWlvwQt0LaR25q+HC1+v1wuv1oqOjI+Y6RqMxbIxfMtxuN0RRjPsaZYzg8PBw0tulEqfTyZPR/6t/JU9OX1+vvt7kpBwM/uQncjZSIiIiIqI8UA0E0/X4449Dr9fj7/7u7/Dqq6+iu7s75W14PB4ACCaIUdPe3h62bjK8Xi9sNlvclsQTJ04AQEoBJhEAOSDcswf4zGeARx8F6urU17t7F3jtNeBnP1MfY0hERERElEVZCQR9Ph/W1tbQ29sLr9eLrq6ulLdx6dIlAPEDQWWZsm4ylG6h8VoafT4fgI1AkyhlZWXAvn3AY48BjzwC1Naqr/fBB8CPfwz8y7/I4wmJiIiIiHIg5vQR6fB6vfB4PGklilFa4/R6fdLrJqO3txe9vb1x1/H7/QCQ9vQURCgrA/bvl1sJb9yQ5xlcWope7/Zt+bFrl5xUJtZYQyIiIiKiDMhKINjU1ISnnnoqrW1MJTF+SgkSk1k3WaIowuPxBJPREGVEeTnQ1ia3El67Bly9CiwvR6/3/vvyo7VVnoewoSHnRSUiIiKizS8rgWAmpNLKl8mxfMrYwWSmjpiYmMDJkyeDf585cwZnzpzJWFloEyovB9rb5VbC8XHA51MPCCcm5MfevcDhw7GTzxBRSoaGhjA0NBT8e2JiIo+lKR6s74iIik+iOq9gA8F88Hq9GBwcRG9vb1Ktga2trbhw4UIOSkabTkUFcOgQcODARkB4/370eu+9B9y8KbckHj4ce6whESUlMoAJDW4oNtZ3RETFJ1GdV7CBYCqT2qeybjw9PT2wWCyw2+0Z2R5RQpWVcoDX1iYHg34/sLISvo4kAdevy0GhEhDW1OSnvERERES0KWQla2gmpTJWMB3d3d0wmUxJdQklyrjKSjlJjMkEHDwodyGNtLYmjy/0eIBf/Uo96QwRERERURIKNhBUpoaIN/5Pye6Zboug1WqFwWBgEEj5V1UFHD0qB4QGg5x1NNLamtxy6PEAb76pPsaQiIiIiCiOgg0ElUnd47UIKsuUdbUYGBgAkFxyGKKcqa4GHnpIDgjb2tQDwtVVYGwMcLuBt99WH2NIRERERKSiYANBJVmL0uqnRpn4Xes0D4ODg/D5fDGDQJfLpWm7RBlTUwM8/LA8Mf3+/YBOF73O6qo8P6HbDbzzDgNCIiIiIkqoYANBo9EIg8EAt9sdcx2XywWTyaSpa6jH48Ho6GjMIFAUxbhBKFFO1dUBjzwiB4R796oHhCsrciDo8cjzFEYmnSEiIiIiWlewgSAgd9d0uVyq4wT9fj/8fn/MQK6npwcdHR2qwZzX64Xb7Y7bHdTj8cBoNGouO1FW1NcDx48Dn/mMPOm8mvv3gbfekgNCn09uMSQiIiIiClGw00cAcpfP3t5e9PT0hLUMiqKI7u5uOByOYFKZUB6PJ9it0+Vyobe3N7jM7/ejq6sLBoMB3d3dYa9TxhwqrYFK11OigtPQAHR0yFNJvPMOcOtW9DrLy8Abb8jjCA8flqeeUMtGSkREREQlp6ADQQCw2+1wuVywWq3BLqBKS2CssYEmkwlGoxGiKMJsNocts1qtEEURXq834b7VgkyigtLYCHR2AtPTckB4+3b0OktLwC9/KQeEhw7JAaFa8hkiIiIiKhkFHwgCgNlsjgroEhkdHVV9Pt6YQ6Ki1dQEfOQjgCjKGUQ/+CB6nYUF4Be/2Ggh3LNHPSBcWZHHIM7Oyv+vqJBbICVJ/j8RERERFT1e1RFtJoIAfPSjwNSUHBDevRu9zvw8cOWKnFDmyBF5rKFOJwd9S0tyoHjzZvjYwvJyOXA8eFCe2oIBIREREVFR49Uc0Wak1wMf/zgwOSkHhJOT0evMzQFeL3DjBnDiBHDtmpxkRs3qKnD9uvx48EF5snuONyQiIiIqWhwoRLSZtbTIAeHHPgY0N0cv1+mAY8eA8fHYQWCkt96S1+f0FERERERFiy2CRJudTgds2wZs3SqPHXznHXksIQDs2CH/+/bbqW3zzTeBXbvYRZSIiIioSLFFkKhU6HRy4PepT8ldQbdsAQ4ckLuEajE2xlZBIiIioiLFQJCo1Oh0cmvepz8tjyW8eVPbdm7elLdFREREREWHgSBRqdLp5IQxodlBU7G6Kk8xQURERERFh4EgUSlLt2vn8jK7hxIREREVIQaCaZiYmMDJkycxNDSU76IQaZNuspeyMnkKikuXgFu3tLcuEuXY0NAQTp48iYmJiXwXpSiwviMiKl6x6jydJElSnspU9E6ePIkLFy7kuxhE2q2uAj/4gbYArrwcePxx4B//UZ6kHpADy9275Unqt27lGEIqeDyPJ4efExFR8Ys8lzP3O1EpkyRgzx55ovhU7dkDBAIbQSAgdxO9cUN+1NTIQeGePUBTE4NCIiIiogLCQJColFVUAAcPagsE29rkOQljWVwE/H750dAgB4StrUB9vfbyEhEREVFGMBAkKnXV1cCDDwJvvZX8a44eBerqgEceAbZvl6eSmJyMvf7srDxp/dtvA83NclC4e7e8byIiIiLKOQaCRKWuogIwGOSum2++mXj9o0fl1sDycvnv/fvlx8ICMDEhB4X37sV+fSAgP371K2DbNrmVcNeu9BPXEBEREVHSeOVFRHJQd+CAHJCNjcnBXGgCmfJyuRXv4EG5FU8JAkPV1srLDx6UA0ElKFxYUN+nJAEffCA/fvELYOdOOSjcvl3ORkpEREREWcNAkIhkFRXy49gx4KGH5O6cKyvycw0NcuCWbKvdli3y44EHgKkpOSi8dUued1DN6qq8zsQEUFUlB6R79gB6PZPMEBEREWUBA0EiCqcEe01N6W9LpwNaWuTHQw8BH34otxLevh17yorlZTl5zfXrciujkmRmy5b0y0NEREREABgIElGulJUBO3bIj5UVORi8eVMODmNNZ7qwAFy9Kj+2bJEDwj175ACRiIiIiDRjIEhEuVdRIQd0e/YAS0tyt9GbN+UkMrHcuyc/3npLbmFsbZUzj1ZV5a7cRERERJsEA0Eiyq/qajkLaVsbMDe3kWRmdjb2ayYn5ccvfym3MLa2yslm1JLYEBEREVEUBoJEVDjq64HDh4FDh+TWv5s35cBwcVF9fUmSu5jevi23Mu7aJQeFW7cy8ygRERFRHAwEiajw6HRyspqmJnnewslJOSi8dUseX6hmZQV47z35UV0tB4StrYAgMPMoERERUQQGgkRU2HQ6uYVv61bg4YfleQdv3gTu3AHW1tRfs7QE+P3yo75+I8lMQ0Nuy05ERERUoBgIElHxKC+Xu3/u2gXcvw+8/74cFN69G/s1c3PAu+/KD0HYaCmsqclZsYmIiIgKDQNBIipOlZXAvn3yY3FxI8nM9HTs14ii/HjjDWDbNjkg3LVL3hYRERFRCWEgSETFr6YGaG+XHzMzG0Hh/Hzs13z4ofz4xS/kjKOtrcD27cw8SkRERCWBgSARbS6NjcADDwBHjsitf0rm0eVl9fXX1uQkNLduyS2Du3fLQWFLC5PMEBER0abFQJCINiedDmhulh/HjsnjCG/elMcVrq6qv+b+feD6dflRU7ORZGbLFgaFREREtKkwECSiza+sTO72uX27PM3EnTtyUPjBB/JchGoWFwGfT340Nm4EhXV1uS07ERERURZwxuU0TExM4OTJkxgaGsp3UYgoWRUVclD3678OfPazwK/9GqDXx3/NzAzw9tuAxwO89howPi5PUUFFa2hoCCdPnsTExES+i1IUWN8RERWvWHWeTpJi3Q6nRE6ePIkLFy7kuxhElAnz8xtJZmZmEq+v08ktjK2tcrKZCnawKEY8jyeHnxMRUfGLPJfzyoWICJC7fB46JD/u3dtIMrOwoL6+JMldTO/ckTON7twpdx3dtk3uikpERERUwBgIEhFF2rIFOHoUePBBYGpKDgpv3ZKTyahZXZWDxokJoKpKzjy6Z4+cqIZJZoiIiKgAMRAkIopFp5OnkWhpAR5+WE4uc/MmcPu2PO2EmuVl4No1+VFXt5FkprExlyUnIiIiiouBIBFRMsrK5O6fO3fKmUfff18OCj/8MPZr5ueBq1flR1OTHBS2tgK1tbkrNxEREZEKBoJERKmqqAD27pUfi4tyt9GbN+UJ7GOZnpYfb74JbN0qB4S7d8uT2BMRERHlGANBIqJ01NQABoP8mJ3dyDw6Nxf7NXfvyo9f/lLOPLpnD7Bjh5x0hoiIiCgHGAgSEWVKQwNw5Ahw+LDc+qdkHo015+Damjze8PZtuZVx1y45KNy6lUlmiIiIKKsYCBIRZZpOBwiC/Dh2TG79u3lTHle4sqL+mpUV4L335Ed19UaSmaYmBoVERESUcQwEiYiySaeT5xbc9v9v736WHDfuO4B/R9rIa62kgLORI2s3jgz6n+IkB3D2kqqkKrWYq06YmScY4A3AmieYAt8AnAfY2iFPvgJ7T9UucXDiKEkJSJzakRTLO0BJsiTLO0YOcHP4BwBJECDB4fdTxZKWBMAedLMbP3Sj+23g7/8+WXfw+fNkBtKsmUd//3sgCJLXG29cB4V37qw27URERHRjMRAkIlqVV19NJoh5991kmQkx8+iLF9n7fPkl8J//mbwajetJZm7fXl26iYiI6MZhIEhEtA6vvQb89V8nr6+/vp5k5vPPs/cJw+T1q18lzxHev588V3iLVTkREREthlcPRETr9t3vAj/6UfL64ovrSWa++ip9+zhO1i/87DPgl79MZhy9fz+ZgfSVV1abdiIiItpIDASJiOrkzTeB998HfvazpPfv+fNkncJvv03f/uoq+fzjj5M1Cd99NwkKd3c5yQwRERFlYiBIRFRHOztJMLe7C/zt3ya9f8+fJ0tNXF2l7/OHPwC//nXy+u53ryeZeeut1aadiIiIao+BIBFR3b3ySjL88y//Mllm4tNPk6Dws8+SYaJpvv4a+Oij5PXmm0lAeO8e8Prrq007ERER1RIDQSKiTXLrVhLU3b+fLDPx8cdJUBiG2ft88QXw4YfJa3c32ffdd5MJa4iIiGgrMRAkItpU3/kO8MMfJq/f/S6ZYObiIgn8slxeJq9//dekh/HeveS/nHmUiIhoq7DlJyK6Ce7cAX7yE+DHP06WoBAzj37zTfr2cZwMMf3002R9w+9/P+kp/Iu/4MyjREREW4Ct/RIuLi7wwQcf4NGjR+tOChFRYmcH+PM/B37+c2B/H/iHfwB+8INkRtEsV1dJ4Pgv/wI4TtJbGIbZzx/eAI8ePcIHH3yAi4uLdSdlI7C9IyLaXFlt3k4c3+CWvmIffPABfvGLX6w7GUREs11dAb/5TRLw/d//AX/84+x97ty5nnn0jTeqT+MasB6fD88TEdHmm6zLOTSUiGgbiOGf3/9+sszEJ58kQeFvf5u9z+9+B/zXfyUvSUqCwnv3gNu3V5ZsIiIiqgYDQSKibfNnf5YMF/3BD5JnCMUkM1GUvU8UJa9f/Sp5jvD+/SSozBtySkRERLXFQJCIaJvdvg00m8nryy+TXsLnz4Gvvsre57e/TV6//GUy4+j9+8D3vpf0OhIREdFGYCBIRESJN94AfvYz4Kc/TXr/xMyj336bvv0f/5gMMf3kk6RnUMw8evduMmkNERER1RYDQSIiGrezAzQayevnP096/54/TwK+q6v0ff7wB+B//zd53b59PcnMW28xKCQiIqohBoJERJTtlVeSYZ/f+x7w8mUy4+jFRfLfrEmnv/kG8P3k9eab15PM3Lmz2rQTERFRJgaCREQ0n1u3roO6b78FPv44CQpfvMje54svgP/4j+TVaCS9hO++C3znO6tLNxEREU1hIEhERIt77TXgvfeS11dfXc88+vnn2fuEYfL6t38D3n47CQrfeScJMOf18mUy1PTLL5P/v3UrebYxjhc7DhER0ZZjq0lERMt5/XXgxz9OXp9/fj3JzNdfp28fx8ni9r/5TTLT6DvvJEHh228nQ1HTvHwJ/P73wEcfJccffVbx1VeT/X/0o6SnkQEhERHRTGwtiYioPG+9BfzN3wDvvw9cXiZB28cfJ5PJpLm6uu5NfO21ZNjo/fvJMFIxyczVFfDf/w18+GH2MX796+T1/vuALHMpCyIiohk2IhB0XRe2bUOWZQBAFEUwDAOKotTyuEREW29nJ1lG4u5d4O/+Lun9u7gAPv00e+bRb78F/ud/ktfrryfPIjabSYCXFQRO+vDD5Lvfe489g0RERDlq30q22214ngfHccbeb7VaMAwDuq7X6rhERDThlVeS4Z/vvJMM8fzkkyQo/Oyz7JlHv/oqmWjm66/nDwKFf//3ZE1DBoJERESZat1Kuq6LTqeDOOVCodfrodlsYm9vb+EevKqOS0REM9y6BfzVXyWvb765nnk0DKe3fe+9pHewiI8+StZAZDBIRESUKuOp/Hpot9uZPXOyLENVVbTb7docl4iIFnD7dvI83z/+I/DwIfDTnyYzgALJ0NBGI3nGsIjnz7mQPRERUY7aBoKe58HzPLRarcxtFEWB67qIomjtxyUioiXcuZMEgv/8z8A//VMyA+jnn2c/TzjL1VWyxAQRERGlqm0g6LouAAwncknTbDbHtl3ncYt69OhR5d9BVBTLJ63czg4gScmw0GW9fLn8Mag0rE+o7lhGqc6qKJ+1DQSfPn0KID9gE5+Jbdd53KJY6VCdsXzSWi37fB+fD6wV1idUdyyjVGdbFQiKYZm7u7tzb7vO426yulR8TEe90lAndTgfdUgDsGXpeOON4usBvvrq9fOGRCO26je0AWkA6pOOOqjLuWA66pWGqtQ2ELy8vJy5jQjm5tm26uNusroUcKajXmmokzqcjzqkAdiydMRxsrh8EffvZy9NQVttq35DG5AGoD7pqIO6nAumo15pqMpOnLaGQg00m00EQYAwDCFJUuo2YtIXVVWn1gNcxXHv37+PlyPPoNy7dw/37t2bKx3CxcXFwvuUrQ5pYDrqlwamo35p2Mp0XF0l6w0u6u23U3sTLy4ucHFxMfz3rVu38LzozKRb5Ka0d0xH/dLAdNQvDUxH/dJQNB2z2jw+QLEEXjwQEdE2YHtHRHTz1HZoaFZvXV23JSIiIiIi2hS1DQSFRZ7pq8NxiYiIiIiI6q62gaBYwiFv5s4gCAAs1nNX1XGJiIiIiIg2RW0DwQcPHgDI77kTn4lt13lcIiIiIiKiTVHbyWJUVQVw3TuXxvf9sW3XedxJURTh4cOHGAwGc23vui5s2x7rsTQMA4qiFE4DUZp2uw3XdYe94oqiwDCMmeWdZZRWodPp4OnTpwCuR24cHBxA1/Xc/Vg+14ftHdUZ2zyqs7W3eXGNybIca5qW+7mqqrU5bhiGseM4sWmasSRJ8byn1zTN1O9TFCW2bXvhdBClCcMw1jQtHgwGY++ZphkDyC3zLKNUtTAMY1VVY8dxxt73fT+WJClWFCVzX5bP1WN7R3XHNo/qrC5tXq0DQcdxYgBxGIZTn/m+HwOIfd9P3VfTtFhRlNTPlzluXlpVVY11XY8Hg0GsadpcDaNISxqRltFKjKgoTdNSy3wcx7FlWTGAWNf1qc9YRmkV8spnr9eLAaTewGP5XD22d7QJ2OZRndWlzat1IBjH6VFvGIaxLMuZUa84SQBiy7JKO+4i5m0YFUVJrYgEVVUL9U4SjXIcZ2a5Fnf1JysQllGqWhiGMYDMO6CicUurU1k+14/tHdUN2zyqszq1ebWdLEawLAuGYcAwDLTbbbTbbRwfH8O27czxs6qqQlEUyLIMTdNKO27ZPM+D53lotVqZ2yiKMja2nagIx3EQRVFuORLPSzx+/Hj4HssorYKYoMvzvNTPs5byYfncHMwrWiW2eVRndWrzajtZzChN0zIDuizzPLRe5Lhlcl0XwPWSFmmazeZw23WmlTab53lwXRe+78O27dRtHjx4gH6/P1Z5sIzSKsiyjMFgkLlkj2g0J8shy+fmYF7RKrHNozqrU5tX+x7Bm0zMEpSXoeIzsS1REfv7+5AkKfcukpgtV1QiAMsorY4YxZGm3+8DSGb/G8XyuTmYV7RKbPOo7urS5m1Ej+BNJe5CZXUBp21LVIRpmjBNM3cbsaTK6NTDLKO0blEU4fT0FJqmTQ3bZ/ncHMwrWiW2ebSpVt3msUdwjfIWtRdEZs+zLVFRURTBdV3Isjy2thLLKK1LFEXo9/t4+PAhLMtCr9eb2oblc3Mwr6hO2OZR3ayrzWOP4BotcjeJd56oSmL4weSzFCyjtGpBEMC2bURRhCAIcHR0hL29vdRtWT43B/OK6oRtHtXFuts8BoJEW87zPHS7XZimOXZnlGgdZFmGZVnDfwdBgP39faiqmjnpAxHRvNjmUZ2su81jILhGWbMFLbst0SIODg6g6/pYRSSwjNK6ybIMx3HQbDYRBAEcxxl+xvK5OZhXVBds86jOVt3m8RnBGlhkzC9Rmea968QySusknuNxXXc4m9ools/NwbyidWKbR5tglW0eA8E1ElO85o3jFbNa8c4Tlc0wDMiynNsgsoxSXYiZ/UYXf2b53BzMK1o3tnm0SVbV5jEQXKMHDx4AyI/sxWdiW6IydDodANMPyk9iGaVVODg4QKPRgOd5mdvcvXsXAMa2YfncHMwrWie2eVQndWrzGAiukXhIWUTvacSCp3ygmcrS7Xbh+35mgzg6DIFllFbBdd3hdO5ZXrx4AWB8IV2Wz83BvKJ1YZtHdVOnNo+B4BopijJ8KDRLv9+HqqocgkClcF0Xg8Egs0EU0xcLLKO0Cnt7e7Asa2rx3FHiruj+/v7wPZbPzcG8onVgm0d1VKs2L6ZKaJoWA4jDMMzdznGczO18348BxL7vV5NI2iqDwSA2TTN3m16vFzuOM/YeyyhVzXGc3LI5GAxiALEsy6n7snyuF9s7qiO2eVRXdWrzGAhWRFGUGEA8GAxmbmuaZqyq6th7YRjGsizHtm1XlUTaIr7vx5IkxYqixKqqjr0URYkVRYllWc6sQFhGqWq9Xi/WNG2q/A0Gg1iW5ViW5czGjeVzvdjeUd2wzaO6q0ubtxPHcTxf3yHlCYIABwcHw/8fndFHlmVIkoSjoyOYppm6f7/fh+M4w67cIAhgGAbHoFMp9vf3c8eij8qqElhGqWpRFOH09HSqDhXrfuVh+VwdtndUd2zzaBPUoc1jIEhERERERLRlOFkMERERERHRlmEgSEREREREtGUYCBIREREREW0ZBoJERERERERbhoEgERERERHRlmEgSEREREREtGUYCBIREREREW0ZBoJERERERERbhoEgERERERHRlmEgSFvJ8zx0u114nrfQfkEQLLwPERERlScIAkRRVGhfz/MK70t00zAQpK1jGAZc18Xh4SGCIEC73Z5rvyAI0Gq1EARBxSkkok3W6XTWnQSiG8t1XfT7fUiSVGh/RVFwfHzMYJAIDARpy4igzzRNSJIETdOwv7+PZrMJ13Uz9+v3+2i1Wtjb24OmaZnbNBoN7OzsDF+NRgOtVmv4ajabaDab2N/fR7vdZkN0A+3v76PVaqHRaMAwjEq+o9/vo9lsjpW3RqOBZrOJfr+fuZ9hGFPlM297WpzneWi327UdObCK8lm1TqeTWf673e5cx4iiaOxcMHjfDEEQwLZtmKa51HHOzs5wcHBQUqqINtdOHMfxuhNBtApRFKHRaMD3fciyPPbZwcEBLMuC67pjwZkkSYiiCJIkwTCM1H2zvgcAsn5eQRDAMAw8e/YMlmVB1/Xl/jhaWhRFOD8/x+HhYeE7zUCSt67rwjAM6LoO27bLS2TKdzWbTQBAGIZzpVv0avd6PaiqWlnatpVhGOh2u5XnfVGrLJ9VK1L+J/e3bRudTgeWZS0dXKxSWfVV2ceqWrPZhOM4M9vheXS7XQwGg43+DRAtLSbaEr1eL84q8pZlxWEYZu4ry3JsWdbc3wUgliRp5na6rscA4l6vN/exqRqapsUAYl3Xc7ebN6/mOVYZAGSW60m+78eqquaWdVqOoihz//6rULfyWbVFyn+aMAxjAAvV71WbJw/LrK/mPda6maZZej4pihIPBoNSj0m0STg0lLZGEASZdztlWc589q/dbkOSpEruFluWBSDpkeQw0fXa39+HJEnY39/P3CaKIjiOM9fx6nZnPQgCWJYFx3Fql7abQvS0KYqCKIpyh5tXYZPLJyXmzcMy66t5jrVuURSh2+2W3g5bloXj4+NSj0m0SRgI0tbwfR+7u7upn0mShMvLy6n3gyBAp9NBr9erJE2SJA2HuKz6opHG6bqOMAwznwEFsLETBYlJkTgEqlq9Xg+Hh4c4OjoCgJWf700tn3Rt3jwss76a51jrdnp6WskjFKqqIoqi2j7TS1Q1BoK0NZrNZmqwByR3G9OeOTg4OIBpmqU8j5BFHHveO/m0Po8fP153EhYmgsCqbmbQtcvLS0iSNLxgXfVEPJtYPmlcmXl4k8pDt9sd3mApm6ZpvElGW4uBIG0NWZYzh18+ffp0KtjrdruIomg4fLMq4q5tq9Wq9HtoefPOSFgXDAJXp9/vDy9UJUmCoijD91dl08onTSszD29KeRCjZcRvqmxHR0c35lwRLYqBIG0NTdMgSVLqEJDJADGKIhiGsZILaBEIcgbH+hJTzW/Sc5xRFDEIXKHHjx+PDa0TSzOsoldmE8snjSszD29aeXAcp9L2UQSYHB5K2+jWuhNAtEonJyc4PT0duzju9/tT6wkdHBxA1/XK7kAKYl1D27aneiSjKMLp6Snu3r2LFy9eIAgCHB0dZT7Hsb+/j8vLSwRBAF3XYVkWut0ufN8HkAScu7u7aLfbM4e6ijUOxYQSomd0dIKJ0e87OTmBaZrodDrDtD548GDswf5+vz/1zIokScPnNud9PsUwDJyfnw8vciRJwtnZGTRNQ7fbhWVZw++RJGlseQ7P88Z6XmVZhu/7w6U8giDA4eHh2DChbrc79u/z83M8e/Zs7Bizgi3XdYdDf6MowuXlJc7OziqbsCOKIrRarYXXiUsrQ0XTLqZmF0uwXF5ejpXfKvKxzPQv6/DwEIZhzNUjOJpuVVWnytPo53Uqn7PyOOtvmKe+KJvruuj1esPlJoDk5tu8w/4XrRMXKX+L5mGZ9VXesYqcA6C8ul5wXXfmsNBly5eiKHBdt/I2n6h21j1tKdGq6bo+XC6i1+tNTUfd6/WWnvodc0wfb5pmLElS6nTYYRimTuWtqmqsqmrq8Xzfj23bHk4Drut67Pv+2DaWZcWSJGVOKe77fizL8tTn4pyMTrM9+n2WZcWmaQ6/T5blsSndTdOMbdue+r7BYFBo+YwwDGNJkjKnjVdVNfMz3/djAGPp8X1/uLyIpmmZ34sFpliXJCnWdT22bTt2HGfsM13XS1teABPT54dhOJwOHsBCS0VMlqEiaQ/DMFZVNbVci3I5um3Z+bhs+otI+57R9KeV/VGj6U4rf77vx5ZlzSx/qyqfi+Tx6N8wb32xiMnyn0bX9VjTtKnfgm3bw/OatSxB0Tqx6LmdJw/LrK/mOdYi56Dsuj6O49w2azSNy5QvTdNyzyXRTcVAkLbSYDCIbdueWj9IXJimXdQ5jhPbtj3XhbW4OBEXReKladowmDNNM/NYaUGcSB+A2DTN3O+WJCn32ABSjy/LcuaFg6ZpsSzLqd+nadpYQ93r9YYXA+KcZjFNs9DFgbiAS/s7HMeJAWSuD5XV4EuSVGogqChK6kVRWhBT1OiFsAgC4/j6/GTdOJh1TFVVC6VdVdXcczT5eRX5uEz6i8hKh7jAnjcPlr2wX1X5XDSPJ9OYV18salYgqOt6ar0lzAoEi9aJRcvfonlYZn2Vdax5z0FVdX1eHZC2bZHyZZpmobqSaNMxECQakXZXUNz9HgwGcRiGsWVZMxulee5S5xF3MNOCOVmWY0VRcr877+JABJOTjV7eBXkcX1+UTzbks3o/xZ3grMDUcZxCFwfigiotKBY9n2kXL4PBIPP7yr6wyisDswL6eY32/E2mXZSjRc9v0bSLwCfv9yHKg7jZUlU+ruLcx3F27/3od83bM7ts+VtF+SySx5PHLbNHNq+uFenICwJE+UsLBIvWicuUv7oFgoucgyrqetFeZX3/pKLly7Ks3HaV6KbiZDFEf+K6LlzXxdnZ2dj7Dx8+HC4SLRaWr3oCCEVRMp9dyZv9VMhaLxG4ntHQdd2x44hnQ7K+d29vD0Ayw2rWZ2nEeWu1Wuj3+1NpV1W10HMZsixDUZTUZ7BevHiBw8NDnJ+fT302OalHlWb9XWVO5nB8fDz1LJj49/Hx8cLfVSTtp6enYzNm5h1XzMZbVT6u6tyfn59PPWM8SqQx7W9Yt1Xl8aS8+qJMp6enAIpPxLVMnbjK336VFjkHVdT14lnDvDYtK02LkCSJ63DSVuJkMUR/YhjG1EP8rusiCIKpC07DMNDtditZ4BbA1AV9EAQIggBRFCEIgsz1EOe1t7cHz/Pw7Nmz4UVSEASQJAmdTid337QLmFkTLjx58gQPHz4cXjArigJVVXF0dJQb9M5iGAYMw4DnecMLjCAI0Gw2sbe3h263C9d11zYja5XrT06avIEBJOdZTJqQFijmKZL20XzII0nScEp4oJp8XNW57/V6ub9H8Xuxbbuy+qKoVebxst9bhPj+ot9XZZ24KRY9B2XX9UXauiLnfnd3d2OCc6IyMRAkAoYzaU4GfLZtp95dFLMUVikIAti2PbzwOjo6wt7eHmRZXjoQFMGuuAMq/ivLcu7MalmfzZpdUFEUhGGIbrcLx3Hgui46nQ46nQ40TSu8xIGYmdG27eGd636/D13XIUkSZFmGbdvDAMJ1Xezv7xf6rrrLygPLstDv99Hv9ysNipe5m76p+RgEARRFmbnW6M7ODjzPQxAEGx0glNVjUvWMrcIyF/bL1ok3QZFzUHZdv0hPoFCkfF1eXq6sXBLVCYeG0tbzPA+dTid12ux1Xbh1Oh00m03cvXsXjuPAsqzhsJsyGitxgSQaWfHfqu6IiuPquo5er4cwDOH7PkzTRL/fX3iZA0GSJKiqOjbszvf94TnSNG1syGEV61GJ3to6E2U7bwjjshYpQ5Pb1CEfixhdRD6P6Alc5eLyQpnlc5k8Xodl6sqq68RFlJmHixyryDkou64X7e+yNz9niaJoo2/SEBXFQJC23vHxMSzLSm0ExLCYVXJdF+12G7qup96FnWyUiyyCK9aVEkO8RK9LFY2t53nodrtT78uyDMuyhusdFnVwcIAoiuC6LjzPG+spEhcdVV6Ai+G6daaqKjRNQxRFhYPuWcRNilllSJTfyeGF687HIsRzUbOIADxvjbZZigYkZZbPZfN41cRojiLnrso6cVFl5uEix1r0HFRR14+uWVilFy9eFOp9JNp0DARpq4nnHrKGvcwzMUvZxDCzrAv2yUZ80YlrgiCA53lTiymLxYJnBZZFLsbz0rjsc1Ni/16vNzWBiJiIxLZt9Pv9SoYT1uFCcR7i+ddut1vo5sE8Tk5OhsFcFtHrd3JyMvb+uvNxUWKR6nmoqjqcjCLvIjzvQnR0UfBFlF0+l8njVWu32wCQm9a8+r3KOnERZebhosda9BxUVddXfbNt04dtExXFQJC2VhAEaLfbuc8syLK88t4ecQc0rScyiiJcXl7ODE7zZigUF0eTf7eu61AUZfh5mk6nU+guv+d5mRcSl5eXSzfAmqah2+2mnpejoyO4rovHjx8vPZwwrTwEQZD6HGkdhpSNkiRpeJNh1hDRomk3TXMYsGWxbRuapqXO+FlWPq7i3FuWtdDss+IiOO/cSJKUmXbHcWZ+xyrK57J5vEqiJ1zMHpom7+8oWicuU/4WycNVHGvRc1BFXa8oykoCwWazWel3ENURA0HaWoZhwDTN3IbJMIzUO/F5jcboRUCRCwLREzg5AUUURTg9PR0GcKKxvXv37tQx9vb2UhvudrsN13UxGAxSA80nT56MpWFUv9+HLMtj50v8ffM00rZtp243Kxifh3hOKy3AERfg81yARFE0s4dAzCQrjD7Llna8vPeXvdM/mo55ytrh4eFwv1m9akXT/uTJEwRBkFqGDMOALMupM5wC5eXjaDqz3l/m3Pf7/eFMpvMSvYdZgS6QnJ/J8iX2EfmV9rmwqvJZNI8XqS/mMU/5Pzs7w+7ubmpaO50OWq0WgCTQTkvXonXirPTMOreL5GGZ9VXesRY9B2XX9aqqpi7RMWmZ8iVGyRBtnXUvZEi0DrZtx7Isz7WtoihTi+BmLbQsy/JwMWH8aWFbWZYXXkR3MBgMF7c3TTO2LGtsUWSx+K2u61OL92JkEWHLsmLTNGPTNGNd1+deRNu27VjTtOE+pmlOLSAtFiuf/Fsn0zMYDIZpF+mxLGv4//MuFDxLXn6qqpq7ALaiKFP5lrUItTj34rxM/r1pZWB0Uee087bo4uZFytpgMBjbXrxGF5EuM+22bQ/PkSh/8/wOlsnHqs+9WDw76/ylCcMw87eS9rf0er1YVdVY1/Xh70RsJ0nScN+sdK+yfC6Sx/PWF/OwLCvzeFm/W9u2x86pqHvEgvLz7D9PnVjGuZ2Vh2XWV4sca9Y5qKqudxxn5iLxy5SvwWAQ83KYttVOHMdxKREl0QZpNBp48uTJXMMcoyjCwcEB2u029vb2cHp6OlwTqY52dnag6/pSE1MQERHVRaPRwGAwqOQ5vk6nA9/32WbSVuLQUNpKZ2dncwdykiQNn885Pz/HyclJbYNAIiKim6bKm5u2bVc2mzJR3bFHkOiGYY8gERHdJEEQoNVqIQzDUo/reR6Oj48xGAxKPS7RpmCPIBERERHVlizL0HV9uORTWY6PjzMnryLaBgwEiW6QsmflIyIiqoOTkxPYtl3a8jBixlM+6kHbjIEg0Q3RbDbRaDQAJFPMNxqN3LWfiIiINoUkSej1ejg+Pl76WFEUwbbtpZcuItp0fEaQiIiIiDaC67rwPA+maRY+xsHBASzLqmQWUqJNwkCQiIiIiDaG53mQZRmSJK10X6KbhoEgERERERHRluEzgkRERERERFuGgSAREREREdGWYSBIRERERES0ZRgIEhERERERbZn/B959R9n07zXFAAAAAElFTkSuQmCC\n"},"metadata":{"image/png":{"width":898,"height":540}},"output_type":"display_data"},{"data":{"text/plain":"
","image/png":"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\n"},"metadata":{"image/png":{"width":861,"height":540}},"output_type":"display_data"}],"outputs_reference":"s3:deepnote-cell-outputs-production/ac64950a-182f-4114-ab19-fefd89f3d6de","content_dependencies":null},{"cell_type":"code","metadata":{"cell_id":"d8e6dfa8a1f8415f9a7e960bba326a95","deepnote_cell_type":"code"},"source":"FONT_SIZE = 22\ndf = pd.read_excel(osp.join(\"review_scores.xlsx\"), index_col=0)\ndf.index.name = 'paper_id'\n\nREVIEWER_TYPE = \"irresponsible\" # Change this to \"irresponsible\" or \"malicious\"\n\n# Prepare column names for both initial and updated scores\ncolnames = []\nfor initial_or_updated in ['initial', 'updated']:\n colnames += [f'BASELINE_avg_{initial_or_updated}'] + [f'{REVIEWER_TYPE}_Rx{i}_avg_{initial_or_updated}' for i in\n range(1, 4)]\n\n# Select the relevant columns and drop any rows with missing data\ndf = df[colnames].reset_index().dropna(axis=0, how='any')\n\n# Melt the DataFrame to a long format\ndf_long = df.melt(id_vars='paper_id', value_vars=colnames)\n\n# Split variable names into meaningful new columns\ndf_long['score_type'] = df_long['variable'].str.extract(r'(.*)_avg_(.*)')[1]\ndf_long['score_type'] = df_long['score_type'].map({\n 'initial': 'Initial',\n 'updated': 'Final'\n})\n\ndf_long['num_reviewers'] = df_long['variable'].str.extract(r'(.*)_avg_(.*)')[0].map({\n 'BASELINE': '0',\n f'{REVIEWER_TYPE}_Rx1': '1',\n f'{REVIEWER_TYPE}_Rx2': '2',\n f'{REVIEWER_TYPE}_Rx3': '3'\n}).astype(str) # Ensure num_reviewers is treated as categorical\n\n# Plotting\nplt.figure(figsize=(5, 6))\nax = sns.lineplot(data=df_long, x='num_reviewers', y='value', hue='score_type', style='score_type', markers=True,\n dashes=False, linewidth=3, markersize=10)\nplt.title(f'Avg. Ratings by \\# {REVIEWER_TYPE.capitalize()} Reviewers', fontsize=16)\nplt.ylabel('Average Ratings', fontsize=FONT_SIZE)\nplt.xlabel(f'\\# {REVIEWER_TYPE.capitalize()} Reviewers', fontsize=FONT_SIZE)\n\n# Set the size of the xticks and yticks\nax.tick_params(axis='x', labelsize=FONT_SIZE)\nax.tick_params(axis='y', labelsize=FONT_SIZE)\n\nplt.legend(title='Score Type', fontsize=FONT_SIZE, title_fontsize=FONT_SIZE)\n\nplt.ylim(3.2, 5.4)\n\nplt.grid(True)\nplt.tight_layout()\nplt.savefig(osp.join(f'lineplot_known_author_identities.pdf'), dpi=300)\nprint(\"Done!\")\n# P","block_group":"619b17545e084c64a753d51c6c235d65","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"markdown","metadata":{"formattedRanges":[],"cell_id":"e189cf21af334e8d9d7bd558eb71a16a","deepnote_cell_type":"text-cell-h1"},"source":"# Varying number of reviewers know authors' identities","block_group":"2d0da25fa24b46cdb375e0e6fb2f71c4"},{"cell_type":"code","metadata":{"source_hash":null,"execution_start":1718514966782,"execution_millis":6366,"deepnote_to_be_reexecuted":false,"cell_id":"0b8571b273bb46e2a9352ead603b68cb","deepnote_cell_type":"code"},"source":"FONT_SIZE = 22\ndf = pd.read_excel(osp.join(\"review_scores.xlsx\"), index_col=0)\ndf.index.name = 'paper_id'\n\nREVIEWER_TYPE = \"authors_are_famous\" \n\n# Prepare column names for both initial and updated scores\ncolnames = []\nfor initial_or_updated in ['initial', 'updated']:\n colnames += [f'BASELINE_avg_{initial_or_updated}'] + [f'{REVIEWER_TYPE}_Rx{i}_avg_{initial_or_updated}' for i in\n range(1, 4)]\n\n# Select the relevant columns and drop any rows with missing data\ndf = df[colnames].reset_index().dropna(axis=0, how='any')\n\n\n# Melt the DataFrame to a long format\ndf_long = df.melt(id_vars='paper_id', value_vars=colnames)\n\n# Split variable names into meaningful new columns\ndf_long['score_type'] = df_long['variable'].str.extract(r'(.*)_avg_(.*)')[1]\ndf_long['score_type'] = df_long['score_type'].map({\n 'initial': 'Initial',\n 'updated': 'Final'\n})\n\ndf_long['num_reviewers'] = df_long['variable'].str.extract(r'(.*)_avg_(.*)')[0].map({\n 'BASELINE': '0',\n f'{REVIEWER_TYPE}_Rx1': '1',\n f'{REVIEWER_TYPE}_Rx2': '2',\n f'{REVIEWER_TYPE}_Rx3': '3'\n}).astype(str) # Ensure num_reviewers is treated as categorical\n\n# Plotting\nplt.figure(figsize=(6, 5)) # Adjust the plot size so that we put this into appendix and take the full row\nax = sns.lineplot(data=df_long, x='num_reviewers', y='value', hue='score_type', style='score_type', markers=True,\n dashes=False, linewidth=3, markersize=10)\nplt.title(f'Average Ratings When Varying Number of\\n Reviewers Know the Author Identities', fontsize=16)\nplt.ylabel('Average Ratings', fontsize=FONT_SIZE)\nplt.xlabel(f'\\# Reviewers Knowing Author Identities', fontsize=FONT_SIZE)\n\n# Set the size of the xticks and yticks\nax.tick_params(axis='x', labelsize=FONT_SIZE)\nax.tick_params(axis='y', labelsize=FONT_SIZE)\n\nplt.legend(title='Score Type', fontsize=FONT_SIZE, title_fontsize=FONT_SIZE)\n\nplt.ylim(5.0, 7.0)\n\nplt.grid(True)\nplt.tight_layout()\nplt.savefig(osp.join(f'lineplot_{REVIEWER_TYPE}.pdf'), dpi=300)\nplt.show()","block_group":"9fcefdc1645e420cbc4d3000772d857c","execution_count":null,"outputs":[{"data":{"text/plain":"
","image/png":"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\n"},"metadata":{"image/png":{"width":580,"height":480}},"output_type":"display_data"}],"outputs_reference":"s3:deepnote-cell-outputs-production/50c4d0ba-6e82-438c-a639-9fec75189a4a","content_dependencies":null},{"cell_type":"code","metadata":{"cell_id":"3a41aaf0761145ed9e9332a61b759731","deepnote_cell_type":"code"},"source":"","block_group":"9866c45c4da643eca69403eaae104b25","execution_count":null,"outputs":[],"outputs_reference":null,"content_dependencies":null},{"cell_type":"markdown","source":"\nCreated in deepnote.com \nCreated in Deepnote","metadata":{"created_in_deepnote_cell":true,"deepnote_cell_type":"markdown"}}],"nbformat":4,"nbformat_minor":0,"metadata":{"deepnote_persisted_session":{"createdAt":"2024-06-16T05:45:14.707Z"},"deepnote_notebook_id":"10aa42c1ce1741c888fbc3a3bd784505","deepnote_execution_queue":[]}} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..563d905d199540007f536dbf9862ead10cf3f3a4 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,19 @@ + +colorama +llama_index +matplotlib +numpy +openreview_py +pandas +prompt_toolkit +requests +rich +setuptools +tenacity +tiktoken +tqdm +transformers +tenacity +openai +gradio + diff --git a/review_content_analysis/analysis.py b/review_content_analysis/analysis.py new file mode 100644 index 0000000000000000000000000000000000000000..3c0ed8f017c19ec3d17ad67bdf60601643143539 --- /dev/null +++ b/review_content_analysis/analysis.py @@ -0,0 +1,477 @@ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. + +import os +import re +import time +import json +import matplotlib.pyplot as plt +from openai import OpenAI +import multiprocessing + +FONT_SIZE = 20 + +COLORS = ['#26547c', '#06d6a0', '#ef476f', '#ffd166'] + +openai_api_key = os.getenv("OPENAI_KEY") +# print(openai.api_key) + +base_dir = '/home/v-qinlinzhao/agent4reviews/simulated_review/reviews' +save_base_dir = '/home/v-qinlinzhao/agent4reviews/simulated_review/classified_reason/' + +with open('iter_prompt.txt', 'r') as f: + iter_prompt = f.read() + +with open('classification_prompt.txt', 'r') as f: + classification_prompt = f.read() + +with open('reason_library.txt', 'r') as f: + reason_library = f.read() + +def get_gpt_response(prompt): + client = OpenAI(api_key=openai_api_key) + messages = [{'role': 'user', 'content': prompt}] + completion = client.chat.completions.create( + model="gpt-4-1106-preview", + messages=messages, + temperature=0.7, + max_tokens=2000, + ) + + response = completion.choices[0].message.content + response = response.strip() + + # time.sleep(5) + return response + +def extract_review_from_real_data(): + base_dir = '/home/v-qinlinzhao/agent4reviews/real_review/original_data' + result_dir = '/home/v-qinlinzhao/agent4reviews/real_review/extracted_real_review/' + # 目录为 ICLR202X/notes/xxx.json + # 将其中所有的json文件的review提取处理 + for root, dirs, files in os.walk(base_dir): + for file in files: + if file.endswith('.json'): + with open(os.path.join(root, file), 'r') as f: + data = json.load(f) + reviews = [] + data = data['details']['replies'] + id = [] + for d in data: + if d['id'] not in id: + id.append(d['id']) + # 2020-2021 + if 'content' in d and 'review' in d['content']: + reviews.append(d['content']['review']) + # 2022 + if 'content' in d and 'main_review' in d['content']: + reviews.append(d['content']['main_review']) + # 2023 + if 'content' in d and 'strength_and_weaknesses' in d['content']: + reviews.append(d['content']['strength_and_weaknesses']) + + # 将每个review分别存入到json文件中，命名格式为 {当前文件名}_{序号}.json + # 同时保持每个文件在原目录下相对路径 + relative_dir = os.path.relpath(root, base_dir) + result_file_dir = os.path.join(result_dir, relative_dir) + os.makedirs(result_file_dir, exist_ok=True) + + file_base_name = os.path.splitext(file)[0] + + for i, review in enumerate(reviews): + result_file_name = f"{file_base_name}_{i}.json" + result_file_path = os.path.join(result_file_dir, result_file_name) + + with open(result_file_path, 'w') as result_file: + json.dump({"review": review}, result_file, ensure_ascii=False, indent=4) + +def extract_meta_review_from_simulated_data(): + base_dir = '/home/v-qinlinzhao/agent4reviews/simulated_review/full_paper_discussion' + result_dir = '/home/v-qinlinzhao/agent4reviews/simulated_review/meta_review/' + # 目录为 ICLR202X/notes/xxx.json + # 将其中所有的json文件的review提取处理 + for root, dirs, files in os.walk(base_dir): + for file in files: + if file.endswith('.json'): + with open(os.path.join(root, file), 'r') as f: + data = json.load(f) + # review在data['messages']中最后一个元素中的"content"中 + review = data['messages'][-1]['content'] + # write review into file, keep the abstract path + relative_dir = os.path.relpath(root, base_dir) + result_file_dir = os.path.join(result_dir, relative_dir) + os.makedirs(result_file_dir, exist_ok=True) + result_file_path = os.path.join(result_file_dir, file) + with open(result_file_path, 'w') as result_file: + json.dump({"meta_review": review}, result_file, ensure_ascii=False, indent=4) + +# Select 1% of the data randomly, let GPT-4 summarize the reasons, and add them to the reason library if there are reasons that do not exist +def construct_reason_library(): + + base_dir = '/home/v-qinlinzhao/agent4reviews/paper_review_and_rebuttal/selected_files/' + + json_files = [] + for root, dirs, files in os.walk(base_dir): + for file in files: + if file.endswith('.json'): + json_files.append(os.path.join(root, file)) + + for file in json_files: + with open(file, 'r') as f: + data = json.load(f) + review = data['review'] + prompt = iter_prompt.format(review=review, + reason_library=reason_library) + ans = get_gpt_response(prompt) + print(ans) + +def analyze_reason_in_batch(json_files): + + for file in json_files: + with open(file, 'r') as f: + data = json.load(f) + review = data['review'] + prompt = classification_prompt.format(review=review) + res = get_gpt_response(prompt) + + # 解析res的输出，将accept和reject的原因分别提取出来，写成json格式 + # 依据该字符串分别抽取Accept和Reject的原因 + reason_dict = {} + if 'Reject' in res: + accept_reason = re.search(r"Accept: (.+?);", res) + else: + accept_reason = re.search(r"Accept: (.+)", res) + + reject_reason = re.search(r"Reject: (.+)", res) + # print(reject_reason) + if accept_reason: + accept_reason = accept_reason.group(1).split(',') + reason_dict['accept'] = [] + for r in accept_reason: + r = r.strip() + if r in ['1', '2', '3', '4', '5']: + reason_dict['accept'].append(r) + if reject_reason: + reject_reason = reject_reason.group(1).split(',') + reason_dict['reject'] = [] + for r in reject_reason: + r = r.strip() + if r in ['1', '2', '3', '4', '5', '6', '7']: + reason_dict['reject'].append(r) + + # print(res) + relative_path = os.path.relpath(file, base_dir) + save_path = os.path.join(save_base_dir, relative_path) + save_dir = os.path.dirname(save_path) + + # 首先找到原来目录的目录结构，然后在save_dir中按照该目录保存结果保存结果 + if not os.path.exists(save_dir): + os.makedirs(save_dir) + with open(save_path, 'w') as f: + json.dump(reason_dict, f, indent=4) + +def convert_txt_to_json(): + base_dir = '/home/v-qinlinzhao/agent4reviews/simulated_review/classified_meta_review_reason' + reason_count = {} + reason_total_count = {'accept': {}, 'reject': {}} + + def process_directory(path, reason_dict): + # 迭代path下的内容 + for item in os.listdir(path): + item_path = os.path.join(path, item) + if os.path.isdir(item_path): + # 如果是目录，递归处理 + reason_dict[item] = {} + process_directory(item_path, reason_dict[item]) + elif item.endswith('.txt'): + # 去除txt后缀 + item_name = item.replace('.txt', '') + reason_dict[item_name] = {'accept': {}, 'reject': {}} + # 如果是txt文件，处理文件内容 + with open(item_path, 'r') as f: + content = f.read() + # "Accept: 1,2,3; Reject: 3,4,7" + # 依据该字符串分别抽取Accept和Reject的原因 + if 'Reject' in content: + accept_reason = re.search(r"Accept: (.+?);", content) + else: + accept_reason = re.search(r"Accept: (.+)", content) + reject_reason = re.search(r"Reject: (.+)", content) + # print(reject_reason) + if accept_reason: + accept_reason = accept_reason.group(1).split(',') + reason_dict[item_name]['accept'] = [] + for r in accept_reason: + r = r.strip() + if r in ['1', '2', '3', '4', '5']: + if r not in reason_total_count['accept']: + reason_total_count['accept'][r] = 0 + reason_total_count['accept'][r] += 1 + reason_dict[item_name]['accept'].append(r) + if reject_reason: + reject_reason = reject_reason.group(1).split(',') + reason_dict[item_name]['reject'] = [] + for r in reject_reason: + r = r.strip() + if r in ['1', '2', '3', '4', '5', '6', '7']: + if r not in reason_total_count['reject']: + reason_total_count['reject'][r] = 0 + reason_total_count['reject'][r] += 1 + reason_dict[item_name]['reject'].append(r) + + process_directory(base_dir, reason_count) + + # 将统计结果写入文件 + with open('reason.json', 'w') as f: + json.dump(reason_count, f, indent=4) + + # 计算accept 和 reject中每一类原因的占比 + # reason_percentage = {'accept': {}, 'reject': {}} + # for key, value in reason_total_count.items(): + # total = sum(value.values()) + # for k, v in value.items(): + # reason_percentage[key][k] = v / total + + # with open('reason_count.json', 'w') as f: + # json.dump(reason_total_count, f, indent=4) + + # with open('reason_percentage.json', 'w') as f: + # json.dump(reason_percentage, f, indent=4) + +def count_reasons(): + with open('../reason_result/reason.json', 'r') as f: + reason_count = json.load(f) + + count = {} + for year, year_dict in reason_count.items(): + count[year] = {} + for model, model_dict in year_dict.items(): + count[year][model] = {} + for type, type_dict in model_dict.items(): + count[year][model][type] = {} + count[year][model][type]['accept'] = {} + count[year][model][type]['reject'] = {} + # 只在type层面做统计就好了 + for paper_id, paper_id_dict in type_dict.items(): + for review_id, review_id_dict in paper_id_dict.items(): + print(year, model, type, paper_id, review_id, review_id_dict) + # {'accept': {'1': 1, '2': 1, '5': 1}, 'reject': {'3': 1, '4': 1, '5': 1, '7': 1}} + if 'accept' in review_id_dict: + for accept_reason in review_id_dict['accept']: + if accept_reason not in count[year][model][type]['accept'] \ + and accept_reason in ['1', '2', '3', '4', '5']: + count[year][model][type]['accept'][accept_reason] = 0 + count[year][model][type]['accept'][accept_reason] += 1 + if 'reject' in review_id_dict: + for reject_reason in review_id_dict['reject']: + if reject_reason not in count[year][model][type]['reject'] \ + and reject_reason in ['1', '2', '3', '4', '5', '6', '7']: + count[year][model][type]['reject'][reject_reason] = 0 + count[year][model][type]['reject'][reject_reason] += 1 + + with open('reason_count.json', 'w') as f: + json.dump(count, f, indent=4) + +def calcu_reason_percentage_every_year(): + with open('../reason_result/reason_count.json', 'r') as f: + reason_count = json.load(f) + + distribution = {} + for year, year_dict in reason_count.items(): + distribution[year] = {} + for model, model_dict in year_dict.items(): + distribution[year][model] = {} + for type, type_dict in model_dict.items(): + distribution[year][model][type] = {} + distribution[year][model][type]['accept'] = {} + distribution[year][model][type]['reject'] = {} + # 统计百分比，先将accept下面的count加起来，然后得到每个百分比 + accept_sum = sum(type_dict['accept'].values()) + for reason, count in type_dict['accept'].items(): + distribution[year][model][type]['accept'][reason] = count / accept_sum + reject_sum = sum(type_dict['reject'].values()) + for reason, count in type_dict['reject'].items(): + distribution[year][model][type]['reject'][reason] = count / reject_sum + + with open('reason_percentage.json', 'w') as f: + json.dump(distribution, f, indent=4) + +def calcu_reason_percentage(): + # 以每种类别为单位，计算每种类别下的accept和reject的百分比 + with open('../reason_result/reason_count.json', 'r') as f: + reason_count = json.load(f) + + count_dict = {} + for year, year_dict in reason_count.items(): + for model, model_dict in year_dict.items(): + for type, type_dict in model_dict.items(): + count_dict[type] = {'accept': {}, 'reject': {}} + # 得到所有year和model的accept和reject的count + accept_count = type_dict['accept'] + reject_count = type_dict['reject'] + # 将accept中每一类原因进行累加 + for reason, count in accept_count.items(): + if reason not in count_dict[type]['accept']: + count_dict[type]['accept'][reason] = 0 + count_dict[type]['accept'][reason] += count + for reason, count in reject_count.items(): + if reason not in count_dict[type]['reject']: + count_dict[type]['reject'][reason] = 0 + count_dict[type]['reject'][reason] += count + # 计算count_dict中accept和reject其中原因的百分比 + reason_percentage = {} + for type, type_dict in count_dict.items(): + reason_percentage[type] = {'accept': {}, 'reject': {}} + accept_sum = sum(type_dict['accept'].values()) + for reason, count in type_dict['accept'].items(): + reason_percentage[type]['accept'][reason] = count / accept_sum + reject_sum = sum(type_dict['reject'].values()) + for reason, count in type_dict['reject'].items(): + reason_percentage[type]['reject'][reason] = count / reject_sum + + with open('reason_percentage.json', 'w') as f: + json.dump(reason_percentage, f, indent=4) + +def draw_bar_chart(accept_or_reject, ax, type, name1, name2): + # accept_or_reject = 'accept' + + x = { + "accept": ['Novelty', 'Significance', 'Theoretical', 'Clarity', 'Future'], + "reject": ['Novelty', 'Theoretical', 'Validation', 'Practicality', 'Limitations', 'Presentation', 'Related Work'] + } + x_range = range(1, len(x[accept_or_reject])+1) + + # 画出每一年的type1 和 type2两种type的比例图 + with open('../reason_result/reason_percentage.json', 'r') as f: + reason_percentage = json.load(f) + + # 取出其中的type1和type2两种type + type1 = reason_percentage[name1][accept_or_reject] + type2 = reason_percentage[name2][accept_or_reject] + + # 按照key排序 + type1 = dict(sorted(type1.items(), key=lambda x: int(x[0]))) + type2 = dict(sorted(type2.items(), key=lambda x: int(x[0]))) + # dict中key应该是1-7，如果有的Key没有，就加上这个key，value设置为0 + for i in x_range: + if str(i) not in type1: + type1[str(i)] = 0 + if str(i) not in type2: + type2[str(i)] = 0 + + width = 0.35 # 柱子的宽度 + + # fig, ax = plt.subplots() + ax.bar([i - width/2 for i in x_range], type1.values(), width, label=name1, color=COLORS[0], alpha=0.3) + ax.bar([i + width/2 for i in x_range], type2.values(), width, label=name2, color=COLORS[1], alpha=0.3) + + ax.legend() + ax.set_xlabel('Reason', fontsize=FONT_SIZE) + # ax.set_ylabel('Percentage', fontsize=FONT_SIZE) + ax.set_title(type, fontsize=FONT_SIZE) + ax.set_xticks(x_range) # 设置x轴刻度为整数 + ax.set_xticklabels(x[accept_or_reject], rotation=30) + + # plt.savefig(f'reason_distribution_{type}.png') + # plt.close() + +def draw_bar_chart_baseline(ax, baseline_or_ground, accept_or_reject): + # if baseline_or_ground == 'Baseline': + # with open('../simulated_review/reason_result/reason_percentage.json', 'r') as f: + # reason_percentage = json.load(f) + # type_data = reason_percentage['BASELINE'][accept_or_reject] + # elif baseline_or_ground == 'Ground Truth': + with open('reason_percentage.json', 'r') as f: + reason_percentage = json.load(f) + type_data = reason_percentage[baseline_or_ground][accept_or_reject] + + + x = { + "accept": ['Novelty', 'Significance', 'Theoretical', 'Clarity', 'Future'], + "reject": ['Novelty', 'Theoretical', 'Validation', 'Practicality', 'Limitations', 'Presentation', 'Related Work'] + } + x_range = range(1, len(x[accept_or_reject])+1) + + # 按照key排序 + type_data = dict(sorted(type_data.items(), key=lambda x: int(x[0]))) + + # dict中key应该是1-7，如果有的Key没有，就加上这个key，value设置为0 + for i in x_range: + if str(i) not in type_data: + type_data[str(i)] = 0 + + # 画图，将单一类型画到图上，选取颜色，设置透明度 + width = 0.35 # 柱子的宽度 + + # fig, ax = plt.subplots() + ax.bar(x_range, type_data.values(), width, label=accept_or_reject, color=COLORS[0], alpha=0.7) + + ax.legend() + ax.set_xlabel('Reason', fontsize=FONT_SIZE) + # ax.set_ylabel('Percentage', fontsize=FONT_SIZE) + ax.set_title(baseline_or_ground, fontsize=FONT_SIZE) + ax.set_xticks(x_range) # 设置x轴刻度为整数 + ax.set_xticklabels(x[accept_or_reject], rotation=30) + + # plt.savefig(f'{baseline_or_ground}_{accept_or_reject}_reason_distribution.pdf') + # plt.close() + +def draw_reason_distribution(accept_or_reject): + type2name = {'accept': 'Acceptance', 'reject': 'Rejection'} + + fig, axs = plt.subplots(1, 3, figsize=(15, 5)) + fig.suptitle(f'Distribution of {type2name[accept_or_reject]} Reasons', fontsize=FONT_SIZE) + + # authoritarian_ACx1 inclusive_ACx1 conformist_ACx1 + draw_bar_chart_baseline(axs[0], 'authoritarian_ACx1', accept_or_reject) + draw_bar_chart_baseline(axs[1], 'inclusive_ACx1', accept_or_reject) + draw_bar_chart_baseline(axs[2], 'conformist_ACx1', accept_or_reject) + + # draw_bar_chart_baseline(axs[0], 'Baseline', accept_or_reject) + # draw_bar_chart_baseline(axs[1], 'Ground Truth', accept_or_reject) + + # for i, (key, value) in enumerate(types.items()): + # if i == 3: + # break + # draw_bar_chart(accept_or_reject, axs[i], key, value[0], value[1]) + + axs[0].set_ylabel('Percentage', fontsize=FONT_SIZE) + + plt.tight_layout() + plt.savefig(f'reason_distribution_AC_{accept_or_reject}.pdf') + plt.close() + + +if __name__ == "__main__": + # analysis_pipeline() + # convert_txt_to_json() + draw_reason_distribution('reject') + + +# if __name__ == "__main__": +# # get current path +# # print(os.getcwd()) +# print("Start analysis...") + +# json_files = [] +# for root, dirs, files in os.walk(base_dir): +# for file in files: +# if file.endswith('.json'): +# json_files.append(os.path.join(root, file)) + +# # json_files = [f for f in json_files] +# # print(json_files) + +# # 将其平均分为6份，每份分配给一个进程 +# n = len(json_files) +# n_per_process = n // 6 +# processes = [] +# for i in range(6): +# start = i * n_per_process +# end = (i + 1) * n_per_process +# if i == 5: +# end = n +# p = multiprocessing.Process(target=analyze_reason_in_batch, args=(json_files[start:end], )) +# processes.append(p) +# p.start() + \ No newline at end of file diff --git a/review_content_analysis/classification_prompt.txt b/review_content_analysis/classification_prompt.txt new file mode 100644 index 0000000000000000000000000000000000000000..d5a4a00c6c844aeee49e07409ad79334297ce183 --- /dev/null +++ b/review_content_analysis/classification_prompt.txt @@ -0,0 +1,58 @@ +You are outstanding data analysts. Now you need to analyze the reason of acceptance and rejection. Next is a review for a paper: +{review} + +Here are some common reasons, please determine which of the following reasons appear in the review. + +Reasons for Acceptance +1. Novelty and Innovation + - Introduces a new framework, method, or approach. + - Provides a unique perspective or solution to a problem. + - Advances the state-of-the-art in the field. +2. Significance + - Addresses a relevant and important problem. + - Has potential practical applications or implications. + - Offers significant improvements over existing methods. +3. Theoretical and Experimental Rigor + - Well-grounded in solid theoretical concepts. + - Provides thorough experimental validation. + - Includes comparisons with several baselines and ablations. +4. Clarity and Motivation + - Clearly formulates the problem and solution. + - Motivates the approach with strong reasoning. + - Presents results that convincingly demonstrate effectiveness. +5. Potential for Further Research + - Opens up new avenues for research. + - Can inspire future work in the field. + +Reasons for Rejection +1. Lack of Novelty + - Does not offer a new contribution. + - Similar to existing work without significant improvements. + - Fails to differentiate from established methods. +2. Insufficient Theoretical Foundation + - Lacks theoretical analysis or grounding. + - No proofs or discussions on convergence and stability. + - Unclear theoretical implications of the method. +3. Inadequate Experimental Validation + - Limited or unconvincing experimental results. + - Lacks comparisons with strong baselines or state-of-the-art methods. + - Uses environments that do not capture real-world complexities. +4. Scalability and Practicality Issues + - Does not address computational complexity or scalability. + - Unclear how the method performs with large or high-dimensional action spaces. + - Potential practical limitations not discussed. +5. Insufficient Discussion of Limitations + - Does not explore potential drawbacks or failure modes. + - Lacks discussion on when the method may not perform well. + - No investigation of the impact of key parameters. +6. Clarity and Presentation Issues + - Poorly articulated problem and solution. + - Dense or hard-to-follow sections. + - Missing or unclear figures and tables. +7. Lack of Related Work Comparison + - Does not adequately compare with related work. + - Fails to position contributions within the broader context. + - Lacks comprehensive discussion on how it advances the field. + +Only output the final reason list, for example: +"Accept: 1,3,5; Reject: 2,4,7" \ No newline at end of file diff --git a/review_content_analysis/iter_prompt.txt b/review_content_analysis/iter_prompt.txt new file mode 100644 index 0000000000000000000000000000000000000000..31b0b0a22a7f1a9120ae97177b9ea715be7f3d6b --- /dev/null +++ b/review_content_analysis/iter_prompt.txt @@ -0,0 +1,11 @@ +Task: +Determine if the following review contains a reason that has not appeared in the reason library. If it does, output the abbreviation and detailed explanation of that reason. If not, output "No" + +Review： +{review} + +Reason libary: +{reason_library} + +Output Format: +<"No" or "Reason Type: Explanation"> diff --git a/review_content_analysis/random_select.py b/review_content_analysis/random_select.py new file mode 100644 index 0000000000000000000000000000000000000000..00b3d650755cd55725ac2c3f33d22c4ad90b0d38 --- /dev/null +++ b/review_content_analysis/random_select.py @@ -0,0 +1,49 @@ +import os +import random +import shutil + +# Set the path to the main directory where files are located (absolute path to the target directory) +# In this case, the directory contains the original data in JSON format +base_dir = 'real_review/original_data/' + +# Define the target directory where the selected JSON files will be copied +# This is a subdirectory within the base directory, named 'selected_files' +selected_base_dir = os.path.join(base_dir, 'selected_files') + +# Create a list to store the full paths of all JSON files found in the base directory +json_files = [] + +# Traverse the base directory and its subdirectories to locate all files +# Collect the paths of files that have a '.json' extension +for root, dirs, files in os.walk(base_dir): + for file in files: + if file.endswith('.json'): # Check if the file is a JSON file + json_files.append(os.path.join(root, file)) # Add the full path of the file to the list + +# Calculate the number of files to select randomly +# 1% of the total number of JSON files is selected, with a minimum of 1 file +num_files_to_select = max(1, int(len(json_files) * 0.01)) + +# Randomly select 1% of the JSON files from the list of all files +selected_files = random.sample(json_files, num_files_to_select) + +# Print the number of selected files for reference +print(f"Selected {num_files_to_select} file(s):") + +# Copy the selected files to the target directory ('selected_files'), preserving their original directory structure +for file in selected_files: + # Get the relative path of the file (relative to the base directory) + relative_path = os.path.relpath(file, base_dir) + + # Create the full destination path for the file in the target directory + dest_file_path = os.path.join(selected_base_dir, relative_path) + + # Ensure that the destination directory exists; if not, create it + dest_dir = os.path.dirname(dest_file_path) + os.makedirs(dest_dir, exist_ok=True) + + # Copy the file from the original location to the destination + shutil.copy(file, dest_file_path) + +# Print confirmation message after all files have been successfully copied +print("File copying completed.") diff --git a/review_content_analysis/reason_library.txt b/review_content_analysis/reason_library.txt new file mode 100644 index 0000000000000000000000000000000000000000..4d503bf934f8e3e0fb2db3c11d22654cbc0f846e --- /dev/null +++ b/review_content_analysis/reason_library.txt @@ -0,0 +1,50 @@ +Reasons for Acceptance +1. Novelty and Innovation + - Introduces a new framework, method, or approach. + - Provides a unique perspective or solution to a problem. + - Advances the state-of-the-art in the field. +2. Significance + - Addresses a relevant and important problem. + - Has potential practical applications or implications. + - Offers significant improvements over existing methods. +3. Theoretical and Experimental Rigor + - Well-grounded in solid theoretical concepts. + - Provides thorough experimental validation. + - Includes comparisons with several baselines and ablations. +4. Clarity and Motivation + - Clearly formulates the problem and solution. + - Motivates the approach with strong reasoning. + - Presents results that convincingly demonstrate effectiveness. +5. Potential for Further Research + - Opens up new avenues for research. + - Can inspire future work in the field. + +Reasons for Rejection +1. Lack of Novelty + - Does not offer a new contribution. + - Similar to existing work without significant improvements. + - Fails to differentiate from established methods. +2. Insufficient Theoretical Foundation + - Lacks theoretical analysis or grounding. + - No proofs or discussions on convergence and stability. + - Unclear theoretical implications of the method. +3. Inadequate Experimental Validation + - Limited or unconvincing experimental results. + - Lacks comparisons with strong baselines or state-of-the-art methods. + - Uses environments that do not capture real-world complexities. +4. Scalability and Practicality Issues + - Does not address computational complexity or scalability. + - Unclear how the method performs with large or high-dimensional action spaces. + - Potential practical limitations not discussed. +5. Insufficient Discussion of Limitations + - Does not explore potential drawbacks or failure modes. + - Lacks discussion on when the method may not perform well. + - No investigation of the impact of key parameters. +6. Clarity and Presentation Issues + - Poorly articulated problem and solution. + - Dense or hard-to-follow sections. + - Missing or unclear figures and tables. +7. Lack of Related Work Comparison + - Does not adequately compare with related work. + - Fails to position contributions within the broader context. + - Lacks comprehensive discussion on how it advances the field. diff --git a/run_paper_decision_cli.py b/run_paper_decision_cli.py new file mode 100644 index 0000000000000000000000000000000000000000..1167c7177457c95fb7729ca8f54fcd2c953a3801 --- /dev/null +++ b/run_paper_decision_cli.py @@ -0,0 +1,150 @@ +import logging +import os +import sys + +import numpy as np + +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) + +import const +from agentreview.experiment_config import all_settings +from agentreview.paper_review_settings import get_experiment_settings +from agentreview.config import AgentConfig +from agentreview.environments import PaperDecision +from agentreview.paper_review_arena import PaperReviewArena +from agentreview.paper_review_player import AreaChair +from arguments import parse_args +from agentreview.role_descriptions import get_ac_config +from utility.utils import project_setup, get_paper_decision_mapping, \ + load_metareview, load_gpt4_generated_ac_decisions + +# Set up logging configuration +logging.basicConfig( + level=logging.DEBUG, # Set to DEBUG to capture all levels of logs + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + handlers=[ + logging.StreamHandler(sys.stdout) # Output to stdout + ] +) + + +def main(args): + """ + Main routine for paper decisions: + + * Phase 5: Paper Decision. + + Args: + args (Namespace): Parsed arguments for configuring the review process. + """ + args.task = "paper_decision" + + # Sample Paper IDs from each category + paper_id2decision, paper_decision2ids = get_paper_decision_mapping(args.data_dir, args.conference) + + # Make sure the same set of papers always go through the same ACs in the same batch + NUM_PAPERS = len(const.year2paper_ids[args.conference]) + order = np.random.choice(range(NUM_PAPERS), size=NUM_PAPERS, replace=False) + + metareviews = [] + + # Paper IDs we actually used in experiments + experimental_paper_ids = [] + + # For papers that have not been decided yet, load their metareviews + + print("Shuffling paper IDs") + sampled_paper_ids = np.array(const.year2paper_ids[args.conference])[order] + + # Exclude papers that already have AC decisions + existing_ac_decisions = load_gpt4_generated_ac_decisions(output_dir=args.output_dir, + conference=args.conference, + model_name=args.model_name, + ac_scoring_method=args.ac_scoring_method, + experiment_name=args.experiment_name, + num_papers_per_area_chair=args.num_papers_per_area_chair) + + existing_ac_decisions = [int(paper_id) for batch in existing_ac_decisions for paper_id in batch] + + sampled_paper_ids = [paper_id for paper_id in sampled_paper_ids if paper_id not in existing_ac_decisions] + + print("TODO: set paper_ids to existing values") + + sampled_paper_ids = [396, 729, 816] + + for paper_id in sampled_paper_ids: + + experiment_setting = get_experiment_settings(all_settings[args.experiment_name]) + + # Load meta-reviews + metareview = load_metareview(output_dir=args.output_dir, paper_id=paper_id, + experiment_name=args.experiment_name, + model_name=args.model_name, conference=args.conference) + + if metareview is None: + + if args.ignore_missing_metareviews: + + print(f"Metareview for {paper_id} does not exist. This may happen because the conversation is " + f"completely filtered out due to content policy. " + f"Loading the BASELINE metareview...") + + metareview = load_metareview(paper_id=paper_id, experiment_name="BASELINE", + model_name=args.model_name, conference=args.conference) + + else: + raise ValueError(f"Metareview for {paper_id} does not exist") + + metareviews += [metareview] + experimental_paper_ids += [paper_id] + + num_batches = len(experimental_paper_ids) // args.num_papers_per_area_chair + + for batch_index in range(num_batches): + experiment_setting["players"] = {k: v for k, v in experiment_setting["players"].items() if k.startswith("AC")} + + players = [] + + for role, players_li in experiment_setting["players"].items(): + + for i, player_config in enumerate(players_li): + + # This phase should only contain the Area Chair + if role == "AC": + + player_config = get_ac_config(env_type="paper_decision", + scoring_method=args.ac_scoring_method, + num_papers_per_area_chair=args.num_papers_per_area_chair, + global_settings=experiment_setting['global_settings'], + acceptance_rate=args.acceptance_rate + **player_config) + + player_config = AgentConfig(**player_config) + player_config['model'] = args.model_name + player = AreaChair(**player_config) + + else: + raise NotImplementedError(f"Unknown role: {role}") + + players.append(player) + + player_names = [player.name for player in players] + + if batch_index >= num_batches - 1: # Last batch. Include all remaining papers + batch_paper_ids = experimental_paper_ids[batch_index * args.num_papers_per_area_chair:] + + else: + batch_paper_ids = experimental_paper_ids[batch_index * args.num_papers_per_area_chair: (batch_index + 1) * + args.num_papers_per_area_chair] + + env = PaperDecision(player_names=player_names, paper_ids=batch_paper_ids, + metareviews=metareviews, + experiment_setting=experiment_setting, ac_scoring_method=args.ac_scoring_method) + + arena = PaperReviewArena(players=players, environment=env, args=args) + arena.launch_cli(interactive=False) + + +if __name__ == "__main__": + project_setup() + main(parse_args()) diff --git a/run_paper_review_cli.py b/run_paper_review_cli.py new file mode 100644 index 0000000000000000000000000000000000000000..c88199a522d11a05c99fad948924ec6f23c4ba98 --- /dev/null +++ b/run_paper_review_cli.py @@ -0,0 +1,138 @@ +import glob +import logging +import os +import sys +from argparse import Namespace + +sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) + +from arguments import parse_args +from agentreview.experiment_config import all_settings +from agentreview.agent import Player +from agentreview.environments import PaperReview +from agentreview.paper_review_settings import get_experiment_settings +from agentreview.paper_review_arena import PaperReviewArena +from agentreview.paper_review_player import PaperExtractorPlayer, AreaChair, Reviewer +from agentreview.role_descriptions import get_ac_config, get_reviewer_player_config, get_author_config, \ + get_paper_extractor_config +from utility.utils import project_setup, get_paper_decision_mapping + +# Set up logging configuration +logging.basicConfig( + level=logging.DEBUG, # Set to DEBUG to capture all levels of logs + format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', + handlers=[ + logging.StreamHandler(sys.stdout) # Output to stdout + ] +) + +logger = logging.getLogger(__name__) + + +# Sample Paper IDs from each category + +def main(args: Namespace): + """ + Main routine for paper review and rebuttals: + + * Phase 1: Reviewer Assessment (Reviewer writes reviews) + * Phase 2: Author-Reviewer Discussion. (Author writes rebuttals). + * Phase 3: Reviewer-AC Discussion. + * Phase 4: Meta-Review Compilation. (AC writes metareviews) + + Args: + args (Namespace): Parsed arguments for configuring the review process. + """ + + args.task = "paper_review" + + paper_id2decision, paper_decision2ids = get_paper_decision_mapping(args.data_dir, args.conference) + + # Sample paper IDs for the simulation from existing data. + paper_paths = glob.glob(os.path.join(args.data_dir, args.conference, "paper", "**", "*.pdf")) + sampled_paper_ids = [int(os.path.basename(p).split(".pdf")[0]) for p in paper_paths if p.endswith(".pdf")] + + for paper_id in sampled_paper_ids: + + experiment_setting = get_experiment_settings(all_settings[args.experiment_name]) + + # Ground-truth decision in the conference. + # We use this to partition the papers into different quality. + paper_decision = paper_id2decision[paper_id] + + logger.info(f"Experiment Started") + logger.info(f"Paper ID: {paper_id} ({paper_decision})") + + player_names, players = [], [] + + for role, players_list in experiment_setting["players"].items(): + + for i, player_config in enumerate(players_list): + if role == "Paper Extractor": + + player_config = get_paper_extractor_config(global_settings=experiment_setting['global_settings'], ) + + player = PaperExtractorPlayer(data_dir=args.data_dir, paper_id=paper_id, + paper_decision=paper_decision, + args=args, + conference=args.conference, **player_config) + + player_names.append(player.name) + + + elif role == "AC": + + player_config = get_ac_config(env_type="paper_review", + scoring_method=args.ac_scoring_method, + num_papers_per_area_chair=args.num_papers_per_area_chair, + global_settings=experiment_setting['global_settings'], + acceptance_rate=args.acceptance_rate, + **player_config) + + player_config['model'] = args.model_name + + player = AreaChair(data_dir=args.data_dir, + conference=args.conference, + args=args, + **player_config) + + player_names.append(player.name) + + + elif role == "Author": + + # Author requires no behavior customization. + # So we directly use the Player class + player_config = get_author_config() + player = Player(data_dir=args.data_dir, + conference=args.conference, + args=args, + **player_config) + + player_names.append(player.name) + + elif role == "Reviewer": + player_config = get_reviewer_player_config(reviewer_index=i + 1, + global_settings=experiment_setting['global_settings'], + **player_config) + player_config['model'] = args.model_name + player = Reviewer(data_dir=args.data_dir, conference=args.conference, **player_config) + player_names.append(player.name) + + else: + raise NotImplementedError(f"Unknown role: {role}") + + players.append(player) + + env = PaperReview(player_names=player_names, paper_decision=paper_decision, paper_id=paper_id, + args=args, experiment_setting=experiment_setting) + + arena = PaperReviewArena(players=players, environment=env, args=args) + arena.launch_cli(interactive=False) + + logger.info("Done!") + + +if __name__ == "__main__": + project_setup() + main(parse_args()) diff --git a/setup.py b/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..4f375c08dbfa805334e552618bfe23bf2203cbfd --- /dev/null +++ b/setup.py @@ -0,0 +1,21 @@ +"""Sets up the project.""" + +import pathlib + +from setuptools import setup + +CWD = pathlib.Path(__file__).absolute().parent + + +def get_version(): + """Gets the agentreview version.""" + path = CWD / "agentreview" / "__init__.py" + content = path.read_text() + + for line in content.splitlines(): + if line.startswith("__version__"): + return line.strip().split()[-1].strip().strip('"') + raise RuntimeError("bad version data in __init__.py") + + +setup(name="agentreview", version=get_version()) diff --git a/utility/authentication_utils.py b/utility/authentication_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..2dd2fcac405a3caec9d4f96be1763606a1f1cbbc --- /dev/null +++ b/utility/authentication_utils.py @@ -0,0 +1,34 @@ +import logging +import os + +import openai + +logging.basicConfig(level=logging.INFO) + + +def get_openai_client(client_type: str): + """ + + Refer to [this page](https://platform.openai.com/docs/models) for authentication using OpenAI. + Refer to [this page](https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/switching-endpoints) for + authentication using Azure OpenAI. + """ + + assert client_type in ["azure_openai", "openai"] + + if client_type == "openai": + client = openai.OpenAI( + api_key=os.environ['OPENAI_API_KEY'] + ) + + elif client_type == "azure_openai": + client = openai.AzureOpenAI( + api_key=os.environ['AZURE_OPENAI_KEY'], + azure_endpoint=os.environ['AZURE_ENDPOINT'], # f"https://YOUR_END_POINT.openai.azure.com" + azure_deployment=os.environ['AZURE_DEPLOYMENT'] + ) + + else: + raise NotImplementedError + + return client diff --git a/utility/data_utils.py b/utility/data_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..e7628ff15f76f8013c4ae50cf3b52386e3c28752 --- /dev/null +++ b/utility/data_utils.py @@ -0,0 +1,28 @@ +import os + +import pandas as pd + + +def save_to_excel(df, path, sheet_name, index: bool=False): + """ + Save a pandas dataframe to an Excel sheet. If the file exists, replace the specified sheet + without impacting other sheets. If the file does not exist, create it. + + Parameters: + df (pd.DataFrame): Dataframe to save. + path (str): Path to the Excel file. + sheet_name (str): Name of the sheet to save the dataframe to. + """ + # Check if the file exists + if os.path.exists(path): + # Load the existing workbook + with pd.ExcelWriter(path, engine='openpyxl', mode='a') as writer: + # Remove the existing sheet if it exists + if sheet_name in writer.book.sheetnames: + del writer.book[sheet_name] + # Write the dataframe to the specified sheet + df.to_excel(writer, sheet_name=sheet_name, index=index) + else: + # Create a new workbook and write the dataframe + with pd.ExcelWriter(path, engine='openpyxl') as writer: + df.to_excel(writer, sheet_name=sheet_name, index=index) diff --git a/utility/general_utils.py b/utility/general_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..4f852f3b975f1298873b1da61f94ba96824482a3 --- /dev/null +++ b/utility/general_utils.py @@ -0,0 +1,16 @@ +import os +import random +from os import path as osp + +import numpy as np + + +def check_cwd(): + basename = osp.basename(osp.normpath(os.getcwd())) + assert basename.lower() in [ + "agentreview"], "Please run this file from the repository root directory (AgentReview/)" + + +def set_seed(seed): + random.seed(seed) + np.random.seed(seed) diff --git a/utility/metrics_utils.py b/utility/metrics_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..0b5f54e4dc370eb0f6cca5f80910372e0b142bfb --- /dev/null +++ b/utility/metrics_utils.py @@ -0,0 +1,17 @@ +import numpy as np +import torch + + +def pairwise_cos_sim(A: torch.Tensor, B: torch.Tensor, device="cuda:0"): + if isinstance(A, np.ndarray): + A = torch.from_numpy(A).to(device) + + if isinstance(B, np.ndarray): + B = torch.from_numpy(B).to(device) + + from torch.nn.functional import normalize + A_norm = normalize(A, dim=1) # Normalize the rows of A + B_norm = normalize(B, dim=1) # Normalize the rows of B + cos_sim = torch.matmul(A_norm, + B_norm.t()) # Calculate the cosine similarity + return cos_sim \ No newline at end of file diff --git a/utility/text_utils.py b/utility/text_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..1d58d117b4b9abd7d714758829d7d4a6d4dc0109 --- /dev/null +++ b/utility/text_utils.py @@ -0,0 +1,125 @@ +import re + +from colorama import Fore + +problem_pattern = r"(problem|issue|challenge)" +importance_pattern = r"\b(important|challenging|crucial|critical|vital|significant)\b" +interesting_pattern = r"\b(interesting|fascinating|intriguing|exciting)\b" + +novel_pattern = r"\b(novel|new|original|innovative|creative)\b" +model_pattern = r"(model|architecture|method|approach|framework)" + +experiment_pattern =r"\b(evaluate|evaluation|comparison|result|experiment[s])\b|\b(analysis|analyses)\b" +result_pattern = r"\b(result|performance|metric|score)\b" + +insight_pattern = r"\b(insight|observation|finding|trend)\b" + + +limitation_pattern = r"(limitation|drawback|weakness|challenge)" + +scalability_pattern = r"\b(complexity|scalability|scalable)\b" + +real_world_pattern = r"realistic|real\-world|practical" + + +theoretical_pattern = r"\b(math|theoretical|justification|justify|foundation|theory)\b" + + + +def text_match_problem(text): + """Regex patterns to search for problem-related and importance-related keywords""" + + # Check if both patterns are found in the text + return re.search(problem_pattern, text, re.IGNORECASE) and (re.search(importance_pattern, text, re.IGNORECASE) + or re.search(interesting_pattern, text, re.IGNORECASE)) + + +def text_match_dataset(text): + """ + Check if the strengths mentioned by reviewers contains the word "dataset" or "data set". + + """ + return re.search(r"\b(dataset|data set)\b", text, re.IGNORECASE) + + +def text_match_model(text): + """ + Check if the strengths mentioned by reviewers contains the word "model". + """ + return re.search(model_pattern, text, re.IGNORECASE) + +def text_match_experiment(text): + """ + Check if the strengths mentioned by reviewers contains the word "experiment". + """ + return re.search(experiment_pattern, text, re.IGNORECASE) or re.search(result_pattern, text, re.IGNORECASE) + +def text_match_real_world(text): + """ + Check if the strengths mentioned by reviewers contains the word "model". + """ + return re.search(real_world_pattern, text, re.IGNORECASE) + +def text_match_theoretical(text): + """ + Check if the strengths mentioned by reviewers are related to theoretical analysis / foundation. + """ + return re.search(theoretical_pattern, text, re.IGNORECASE) + +def text_match_scalability(text): + """ + Check if the strengths mentioned by reviewers are related to scalability or time/space complexity. + """ + return re.search(scalability_pattern, text, re.IGNORECASE) + +def match_strengths(text): + """ + Check if the strengths mentioned by reviewers contains the word "model". + """ + for category, f in {"problem": text_match_problem, + "dataset": text_match_dataset, + "model": text_match_model, + "limitation": text_match_limitation, + "experiment": text_match_experiment, + "theoretical-analysis": text_match_theoretical, + "scalability": text_match_scalability, + }.items(): + if f(text): + return category + + print( + Fore.RED + + f"No category found for weaknesses: {text}" + + Fore.BLACK + ) + +def match_weaknesses(text): + for category, f in {"problem": text_match_problem, + "dataset": text_match_dataset, + "model": text_match_model, + "limitation": text_match_limitation, + "experiment": text_match_experiment, + "real-world": text_match_real_world, + "theoretical-analysis": text_match_theoretical, + "scalability": text_match_scalability, + }: + if f(text): + return category + + print( + Fore.RED + + f"No category found for weaknesses: {text}" + + Fore.BLACK + ) + return None + + raise ValueError(f"No category found for weaknesses: {text}") + + + + +def text_match_limitation(text): + """ + Check if the strengths mentioned by reviewers contains the word "model". + """ + return re.search(limitation_pattern, text, re.IGNORECASE) \ No newline at end of file diff --git a/utility/utils.py b/utility/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f5f3386d14be8de6236875e48b0cdca58b2db8d0 --- /dev/null +++ b/utility/utils.py @@ -0,0 +1,526 @@ +import json +import os +import os.path as osp +import random +import re +from collections import Counter +from typing import Union, List, Dict, Tuple + +import numpy as np +import pandas as pd + +import const +from utility.general_utils import check_cwd, set_seed + + +def generate_num_papers_to_accept(n, batch_number, shuffle=True): + # Calculate the base value (minimum value in the array) + base_value = int(n // batch_number) + + # Calculate how many elements need to be base_value + 1 + remainder = int(n % batch_number) + + # Initialize the array + array = [] + + # Add the elements to the array + for i in range(batch_number): + if i < remainder: + array.append(base_value + 1) + else: + array.append(base_value) + + if shuffle: + random.shuffle(array) + + return array + + +def get_papers_accepted_by_gpt4(gpt4_generated_ac_decisions) -> list: + papers_accepted_by_gpt4 = [] + + num_papers = sum([len(batch) for batch in gpt4_generated_ac_decisions]) + + if num_papers == 0: + raise ValueError("No papers found in batch") + + num_papers_to_accept = generate_num_papers_to_accept(n=paper_review_config.ACCEPTANCE_RATE * num_papers, + batch_number=len(gpt4_generated_ac_decisions)) + + for idx_batch, batch in enumerate(gpt4_generated_ac_decisions): + tups = sorted([(paper_id, rank) for paper_id, rank in batch.items()], key=lambda x: x[1], reverse=False) + + paper_ids = [int(paper_id) for paper_id, rank in tups] + + papers_accepted_by_gpt4 += paper_ids[:num_papers_to_accept[idx_batch]] + + return papers_accepted_by_gpt4 + + +def get_paper_decision_mapping(data_dir: str, conference: str, verbose: bool = False): + paper_id2decision, paper_decision2ids = {}, {} + path_paper_id2decision = os.path.join(data_dir, conference, "id2decision.json") + path_paper_decision2ids = os.path.join(data_dir, conference, "decision2ids.json") + + if osp.exists(path_paper_id2decision) and osp.exists(path_paper_decision2ids): + paper_id2decision = json.load(open(path_paper_id2decision, 'r', encoding='utf-8')) + paper_decision2ids = json.load(open(path_paper_decision2ids, 'r', encoding='utf-8')) + + paper_id2decision = {int(k): v for k, v in paper_id2decision.items()} + + if verbose: + print(f"Loaded {len(paper_id2decision)} paper IDs to decisions from {path_paper_id2decision}") + + else: + + PAPER_DECISIONS = get_all_paper_decisions(conference) + + for paper_decision in PAPER_DECISIONS: + + paper_ids = os.listdir(os.path.join(data_dir, conference, "notes", paper_decision)) + paper_ids = sorted( + [int(paper_id.split(".json")[0]) for paper_id in paper_ids if paper_id.endswith(".json")]) + + paper_id2decision.update({paper_id: paper_decision for paper_id in paper_ids}) + paper_decision2ids[paper_decision] = paper_ids + + if verbose: + print(f"{paper_decision}: {len(paper_ids)} papers") + + json.dump(paper_id2decision, open(path_paper_id2decision, 'w', encoding='utf-8'), indent=2) + json.dump(paper_decision2ids, open(path_paper_decision2ids, 'w', encoding='utf-8'), indent=2) + + return paper_id2decision, paper_decision2ids + + +def project_setup(): + check_cwd() + import warnings + import pandas as pd + warnings.simplefilter(action='ignore', category=FutureWarning) + pd.set_option('display.max_rows', 40) + pd.set_option('display.max_columns', 20) + set_seed(42) + + +def get_next_review_id(path: str) -> int: + existing_review_ids = sorted([int(x.split('.json')[0].split('_')[1]) for x in os.listdir(path)]) + next_review_id = 1 + while next_review_id in existing_review_ids: + next_review_id += 1 + print(f"Next review ID: {next_review_id}") + return next_review_id + + + + +def filter_paper_ids_from_initial_experiments(sampled_paper_ids: List[int]): + paper_ids_initial_experiments = json.load(open(f"outputs/paper_ids_initial_experiments.json")) + sampled_paper_ids = set(sampled_paper_ids) - set(paper_ids_initial_experiments) + sampled_paper_ids = sorted(list(sampled_paper_ids)) + return sampled_paper_ids + + +def get_paper_review_and_rebuttal_dir(reviewer_type: str, conference: str, model_name: str, paper_id: int = None): + if reviewer_type == "NoOverallScore": + reviewer_type = "BASELINE" + + path = f"outputs/paper_review_and_rebuttal" \ + f"/{conference}/" \ + f"{get_model_name_short(model_name)}/{reviewer_type}" + + if paper_id is not None: + path += f"/{paper_id}" + + return path + + +def get_rebuttal_dir(output_dir: str, + paper_id: Union[str, int, None], + experiment_name: str, + model_name: str, + conference: str): + + path = os.path.join(output_dir, "paper_review", conference, get_model_name_short(model_name), + experiment_name) + + if paper_id is not None: + path += f"/{paper_id}" + + return path + + +def print_colored(text, color='red'): + foreground_colors = { + 'black': 30, + 'red': 31, + 'green': 32, + 'yellow': 33, + 'blue': 34, + 'magenta': 35, + 'cyan': 36, + 'white': 37, + } + print(f"\033[{foreground_colors[color]}m{text}\033[0m") + + +def get_ac_decision_path(output_dir: str, conference: str, model_name: str, ac_scoring_method: str, experiment_name: +str): + ac_decision_dir = os.path.join(output_dir, "decisions", conference, + get_model_name_short(model_name), + f"decisions_thru_{ac_scoring_method}") + os.makedirs(ac_decision_dir, exist_ok=True) + + if isinstance(experiment_name, str): + ac_decision_dir += f"/decision_{experiment_name}.json" + + return ac_decision_dir + + +def load_metareview(paper_id: int, **kwargs): + rebuttal_dir = get_rebuttal_dir(paper_id=paper_id, **kwargs) + + path = f"{rebuttal_dir}/{paper_id}.json" + + if not osp.exists(path): + print(f"Not Found: {path}") + return None + + try: + reviews = json.load(open(path)) + + metareview = reviews["messages"][-1] + if not metareview["agent_name"].startswith("AC"): + return None + + return metareview['content'] + + except FileNotFoundError: + return None + + +def get_reviewer_type_from_profile(profile: dict): + """ + Get a short name for the reviewer's type from the reviewer's experiment profile. + + + Input: + { + 'is_benign': True, + 'is_knowledgeable': None, + 'is_responsible': None, + 'provides_numeric_rating': True + } + + Output: + "benign" + + + Input: + { + 'is_benign': False, + 'is_knowledgeable': None, + 'is_responsible': None, + 'provides_numeric_rating': True + } + + Output: + "malicious" + + + Input: + { + 'is_benign': None, + 'is_knowledgeable': None, + 'is_responsible': None, + 'provides_numeric_rating': True + } + + Output: + "default" + + """ + + reviewer_attributes = Counter([profile[k] for k in ["is_benign", 'is_knowledgeable', 'is_responsible']]) + + assert (reviewer_attributes[True] <= 1 and reviewer_attributes[False] <= 1) and reviewer_attributes[None] >= 2, \ + ("A reviewer can only have 0 or 1 of " + "these " + "properties profile to True or False") + + if profile['is_benign']: + return "benign" + elif profile['is_benign'] == False: + # NOTE: We cannot use `not profile['is_benign']` as we need to consider the case where `profile['is_benign']` + # is + # None + return "malicious" + + elif profile['is_knowledgeable']: + return "knowledgeable" + + elif profile['is_knowledgeable'] == False: + # Same as above + return "unknowledgeable" + + elif profile['is_responsible']: + return "responsible" + elif profile['is_responsible'] == False: + # Same as above + return "irresponsible" + + elif profile['provides_numeric_rating'] == False: + return "NoOverallScore" + + elif profile.get('knows_authors') == "famous": + return "authors_are_famous" + + elif profile.get('knows_authors') == "unfamous": + return "authors_are_unfamous" + + else: + return "BASELINE" + + +def get_ac_type_from_profile(profile: dict): + return None + + +# def get_ac_type_from_profile(profile: dict): +# """ +# Get a short name for the area chair's type from their profile in the experiment setting. +# +# """ + +def format_metareviews(metareviews: List[str], paper_ids: List[int]): + metareviews_formatted = "" + + for paper_id, metareview in zip(paper_ids, metareviews): + metareview = re.sub('\n+', '\n', metareview) + metareviews_formatted += (f"Paper ID: {paper_id}\nMetareview: " + f"{metareview}\n{'-' * 5}\n") + + return metareviews_formatted + + +def get_all_paper_decisions(conference: str) -> List[str]: + if conference in ["ICLR2019", "ICLR2018"]: + return const.PAPER_DECISIONS_ICLR2019 + + else: + return const.PAPER_DECISIONS + + +def get_paper_ids_of_known_authors(conference: str, num_papers: int, decision: str = None): + paper_id2decision, paper_decision2ids = get_paper_decision_mapping(conference) + paper_ids_of_famous_authors = paper_decision2ids[decision][:num_papers] + return paper_ids_of_famous_authors + + +def get_experiment_names(conference: str = "ICLR2023"): + experiment_names = ["BASELINE"] + + # The following are settings for reviewer types + # Varying reviewer commitment + experiment_names += ["responsible_Rx1"] + experiment_names += ["irresponsible_Rx1"] + + # Varying reviewer intention + experiment_names += ["benign_Rx1"] + experiment_names += ["malicious_Rx1"] + + # Varying reviewer knowledgeability + experiment_names += ["knowledgeable_Rx1"] + experiment_names += ["unknowledgeable_Rx1"] + + # The following are settings for AC types + experiment_names += ["conformist_ACx1", "authoritarian_ACx1", "inclusive_ACx1"] + + # Enable these for ICLR2023 + if conference == "ICLR2023": + experiment_names += ["no_rebuttal"] + experiment_names += ["no_overall_score"] + experiment_names += ["malicious_Rx2"] + experiment_names += ["malicious_Rx3"] + experiment_names += ["irresponsible_Rx2"] + experiment_names += ["irresponsible_Rx3"] + experiment_names += ["authors_are_famous_Rx1"] + experiment_names += ["authors_are_famous_Rx2"] + experiment_names += ["authors_are_famous_Rx3"] + + return experiment_names + + +def load_gpt4_generated_ac_decisions_as_array(experiment_name, **kwargs) -> Tuple[np.ndarray, np.ndarray]: + ac_scoring_method = kwargs.pop('ac_scoring_method') + acceptance_rate = kwargs.pop('acceptance_rate') + conference = kwargs.pop('conference') + model_name = kwargs.pop('model_name') + num_papers_per_area_chair = kwargs.pop('num_papers_per_area_chair') + + print("=" * 30) + print(f"Experiment Name: {experiment_name}") + + gpt4_generated_ac_decisions = load_gpt4_generated_ac_decisions(conference=conference, + model_name=model_name, + ac_scoring_method=ac_scoring_method, + experiment_name=experiment_name, + num_papers_per_area_chair=num_papers_per_area_chair) + + paper_ids = sorted([int(paper_id) for batch in gpt4_generated_ac_decisions for paper_id, rank in batch.items()]) + # ac_decisions['paper_ids'] = paper_ids + + if ac_scoring_method == "ranking": + assert len(paper_ids) == len(set(paper_ids)), (f"Duplicate paper_ids found in the AC decisions. " + f"{Counter(paper_ids)}") + + papers_accepted_by_gpt4 = get_papers_accepted_by_gpt4(gpt4_generated_ac_decisions, acceptance_rate) + + # True means accept, False means reject + decisions_gpt4 = np.array( + [True if paper_id in papers_accepted_by_gpt4 else False for paper_id in paper_ids]) + + elif ac_scoring_method == "recommendation": + gpt4_generated_ac_decisions = {int(k): v for batch in gpt4_generated_ac_decisions for k, v in batch.items()} + decisions_gpt4 = np.array( + [True if gpt4_generated_ac_decisions[paper_id].startswith("Accept") else False for paper_id in + paper_ids]) + + else: + raise NotImplementedError + + return decisions_gpt4, paper_ids + + +def load_gpt4_generated_ac_decisions(**kwargs) -> List[Dict]: + num_papers_per_area_chair = kwargs.pop('num_papers_per_area_chair') + path = get_ac_decision_path(**kwargs) + + if osp.exists(path): + ac_decision = json.load(open(path, 'r', encoding='utf-8')) + print(f"Loaded {len(ac_decision)} batches of existing AC decisions from {path}") + + else: + ac_decision = [] + print(f"No existing AC decisions found at {path}") + + ac_decision = [batch for batch in ac_decision if len(batch) > 0] + + for i, batch in enumerate(ac_decision): + if i != len(ac_decision) - 1: + assert len(batch) == num_papers_per_area_chair, (f"Batch {i} has {len(batch)} papers, " + f"but each AC should be assigned" + f" {num_papers_per_area_chair} " + f"unless it is the last batch.") + + return ac_decision + + +def write_to_excel(data, file_path, sheet_name): + """ + Write data to an Excel file. + + Parameters: + data (pd.DataFrame): The data to write to the Excel file. + file_path (str): The path to the Excel file. + sheet_name (str): The name of the sheet to write to. + """ + # Check if the file exists + if os.path.exists(file_path): + # If the file exists, load it + with pd.ExcelWriter(file_path, mode='a', engine='openpyxl', if_sheet_exists='replace') as writer: + data.to_excel(writer, sheet_name=sheet_name, index=False) + else: + # If the file does not exist, create it + with pd.ExcelWriter(file_path, engine='openpyxl') as writer: + data.to_excel(writer, sheet_name=sheet_name, index=False) + + +def save_gpt4_generated_ac_decisions(ac_decisions: List[dict], **kwargs): + path = get_ac_decision_path(**kwargs) + + json.dump(ac_decisions, open(path, 'w', encoding='utf-8'), indent=2) + + +def get_model_name_short(name: str): + """ + Convert long model names (e.g. `gpt-35-turbo`) to short model names (e.g. `gpt-35`) + Args: + name (str): long model name + + Returns: + str: short model name + """ + + assert name.startswith('gpt-') + return '-'.join(name.split('-')[:2]) + + +def get_reviewer_types_from_experiment_name(experiment_name: str): + if experiment_name in ["BASELINE", 'inclusive_ACx1', 'authoritarian_ACx1', 'conformist_ACx1', + "no_rebuttal"]: + reviewer_types = ["BASELINE", "BASELINE", "BASELINE"] + + elif experiment_name == "benign_Rx1": + + reviewer_types = ["benign", "BASELINE", "BASELINE"] + + elif experiment_name == "benign_Rx2": + + reviewer_types = ["benign", "benign", "BASELINE"] + + elif experiment_name == "malicious_Rx1": + + reviewer_types = ["malicious", "BASELINE", "BASELINE"] + + elif experiment_name == "malicious_Rx2": + + reviewer_types = ["malicious", "malicious", "BASELINE"] + + elif experiment_name == "malicious_Rx3": + + reviewer_types = ["malicious", "malicious", "malicious"] + + elif experiment_name == "knowledgeable_Rx1": + + reviewer_types = ["knowledgeable", "BASELINE", "BASELINE"] + + elif experiment_name == "unknowledgeable_Rx1": + + reviewer_types = ["unknowledgeable", "BASELINE", "BASELINE"] + + elif experiment_name == "responsible_Rx1": + + reviewer_types = ["responsible", "BASELINE", "BASELINE"] + + elif experiment_name == "irresponsible_Rx1": + + reviewer_types = ["irresponsible", "BASELINE", "BASELINE"] + + elif experiment_name == "irresponsible_Rx2": + + reviewer_types = ["irresponsible", "irresponsible", "BASELINE"] + + elif experiment_name == "irresponsible_Rx3": + + reviewer_types = ["irresponsible", "irresponsible", "irresponsible"] + + elif experiment_name in ["no_overall_score"]: + reviewer_types = ["NoOverallScore", "NoOverallScore", "NoOverallScore"] + + elif experiment_name in ["authors_are_famous_Rx1", "authors_are_famous_Rx1_no_rebuttal"]: + + reviewer_types = ["authors_are_famous", "BASELINE", "BASELINE"] + + elif experiment_name in ["authors_are_famous_Rx2", "authors_are_famous_Rx2_no_rebuttal"]: + + reviewer_types = ["authors_are_famous", "authors_are_famous", "BASELINE"] + + elif experiment_name in ["authors_are_famous_Rx3", "authors_are_famous_Rx3_no_rebuttal"]: + + reviewer_types = ["authors_are_famous", "authors_are_famous", "authors_are_famous"] + + else: + raise NotImplementedError + + return reviewer_types