Upload 47 files

.gitattributes

@@ -2,7 +2,6 @@
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
 *.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
 *.ftz filter=lfs diff=lfs merge=lfs -text
 *.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,145 @@
+venv
+test.py
+.config.json
+__pycache__
+.idea
+*.sh
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.config.json
+test.py
+pages
+KeyBartAdapter
+scripts/train/KeyBartAdapter/
+docs/site
+.Python
+devenv
+.idea
+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
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.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
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__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/
+*.py~

LICENSE

@@ -0,0 +1,201 @@
+                                 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.

app.py

@@ -0,0 +1,37 @@
+import streamlit as st
+from widgets import *
+
+
+
+
+# sidebar content
+platforms, number_papers, start_year, end_year, hyperparams = render_sidebar()
+
+# body head
+with st.form("my_form",clear_on_submit=False):
+    st.markdown('''# 👋 Hi, enter your query here :)''')
+    query_input = st.text_input(
+        'Enter your query:',
+        placeholder='''e.g. "Machine learning"''',
+        # label_visibility='collapsed',
+        value=''
+    )
+
+    show_preview = st.checkbox('show paper preview')
+
+    # Every form must have a submit button.
+    submitted = st.form_submit_button("Search")
+
+
+if submitted:
+    # body
+    render_body(platforms, number_papers, 5, query_input,
+                show_preview, start_year, end_year,
+                hyperparams,
+                hyperparams['standardization'])
+
+
+
+
+
+

documents/docs/2-总结功能.md

@@ -0,0 +1,19 @@
+# 2 Research Trends Summarization
+
+## Model Architecture
+![](https://i.imgur.com/Lv8um1V.png)
+
+### 1 Baseline Configuration
+1. pre-trained language model: `sentence-transformers/all-MiniLM-L6-v2`
+2. dimension reduction: `None`
+3. clustering algorithms: `kmeans`
+4. keywords extraction model: `keyphrase-transformer`
+
+[[example run](https://github.com/Mondkuchen/idp_LiteratureResearch_Tool/blob/main/example_run.py)] [[results](https://github.com/Mondkuchen/idp_LiteratureResearch_Tool/blob/main/examples/IDP.ipynb)]
+
+
+### TODO:
+1. clustering: using other clustering algorithms such as Gausian Mixture Model (GMM)
+2. keywords extraction model: train another model
+3. add dimension reduction
+4. better PLM: sentence-transformers/sentence-t5-xxl

documents/docs/3-visualization.md

@@ -0,0 +1,2 @@
+# 3 Visualization
+[web app](https://huggingface.co/spaces/Adapting/literature-research-tool)

documents/docs/4-文献分析平台比较.md

@@ -0,0 +1,56 @@
+# 4 Other Literature Research Tools
+## 1 Citespace
+
+> 作者：爱学习的毛里
+> 链接：https://www.zhihu.com/question/27463829/answer/284247493
+> 来源：知乎
+> 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
+
+一、工作原理
+简单来讲，citespace主要基于“共现聚类”思想:
+
+1. 首先对科学文献中的信息单元进行提取
+  - 包括文献层面上的参考文献，主题层面上的**关键词**、主题词、学科、领域分类等，主体层面上的作者、机构、国家、期刊等
+2. 然后根据信息单元间的联系类型和强度进行重构，形成不同意义的网络结构
+  - 如关键词共现、作者合作、文献共被引等，
+  - 网络中的节点代表文献信息单元，连线代表节点间的联系（共现）
+3. 最后通过对节点、连线及网络结构进行测度、统计分析（聚类、突现词检测等）和可视化，发现特定学科和领域知识结构的隐含模式和规律。
+
+![](https://pica.zhimg.com/50/v2-b94a8061c72d6e299a059da0c1cb3813_720w.jpg?source=1940ef5c)*共现聚类思想*
+
+二、主要用途
+
+1. **<u>研究热点分析</u>**：一般利用关键词/主题词共现
+2. 研究前沿探测：共被引、耦合、共词、突现词检测都有人使用，但因为对“研究前沿”的定义尚未统一，所以方法的选择和图谱结果的解读上众说纷纭
+3. 研究演进路径分析：将时序维度与主题聚类结合，例如citespace中的时间线图和时区图
+4. 研究群体发现：一般建立作者/机构合作、作者耦合等网络，可以发现研究小团体、核心作者/机构等
+5. 学科/领域/知识交叉和流动分析：一般建立期刊/学科等的共现网络，可以研究学科之间的交叉、知识流动和融合等除分析 科学文献 外，citespace也可以用来分析 专利技术文献，用途与科学文献类似，包括技术研究热点、趋势、结构、核心专利权人或团体的识别等。
+
+三、工作流程
+![](https://pic1.zhimg.com/50/v2-165aa367fa07d8e46f286dfe06f0fce4_720w.jpg?source=1940ef5c)
+*摘自《引文空间分析原理与应用》*
+
+### 聚类算法
+
+CiteSpace提供的算法有3个，3个算法的名称分别是：
+
+- LSI/LSA: Latent Semantic Indexing/Latent Semantic Analysis 浅语义索引
+  [intro](https://www.cnblogs.com/pinard/p/6805861.html)
+  
+- LLR: Log Likelihood Ratio 对数极大似然率
+  
+- MI: Mutual Information 互信息
+  
+
+对不同的数据，3种算法表现一样，可在实践中多做实践。
+
+[paper](https://readpaper.com/paper/2613897633)
+
+## 2 VOSviewer
+
+VOSviewer的处理流程与大部分的科学知识图谱类软件类似，即文件导入——信息单元抽取（如作者、关键词等）——建立共现矩阵——利用相似度计算对关系进行标准化处理——统计分析（一般描述统计+聚类）——可视化展现（布局+其它图形属性映射）
+
+
+Normalization, mapping, and clustering 
+
+[paper](https://www.vosviewer.com/download/f-x2.pdf) (See Appendix)

documents/docs/index.md

@@ -0,0 +1,43 @@
+# Intro
+
+
+<!-- - [x] objective/Aim of the practical part
+- [x] tasks/ work packages, 
+- [x] Timeline and Milestones
+- [x] Brief introduction of the practice partner
+- [x] Description of theoretical part and explanation of how the content of the lecture(s)/seminar(s) supports student in completing the practical part. -->
+
+
+
+
+## IDP Theme
+IDP Theme： Developing a Literature Research Tool that Automatically Search Literature and Summarize the Research Trends.
+
+## Objective
+In this IDP, we are going to develop a literature research tool that enables three functionalities:
+1. Automatically search the most recent literature filtered by keywords on three literature platforms: Elvsier, IEEE and Google Scholar
+2. Automatically summarize the most popular research directions and trends in  the searched literature from step 1
+3. visualize the results from step 1 and step 2
+
+
+## Timeline & Milestones & Tasks
+![](https://i.imgur.com/mDK0sc0.png)
+
+#### Tasks
+| Label   | Start      | End        | Duration | Description                                                                                              |
+| ------- |------------| ---------- |----------| -------------------------------------------------------------------------------------------------------- |
+| Task #1 | 15/11/2022 | 15/12/2022 | 30 days  | Implement literature search by keywords on three literature platforms: Elvsier, IEEE, and Google Scholar |
+| Task #2 | 15/12/2022 |       15/02/2023     | 60 days  |      Implement automatic summarization of research trends in the searched literature                                                                                                    |
+| Task #3 | 15/02/2022 |     15/03/2022       | 30 days  |     visualization of the tool (web app)                                                                                                     |
+| Task #4        | 01/03/2022 |    01/05/2022        | 60 days  |  write report and presentation                                                                                                        |
+
+
+## Correlation between the theoretical course and practical project
+The accompanying theory courses *Machine Learning and Optimization* or *Machine Learning for Communication* teach basic and advanced machine learning (ML) and deep learning (DL) knowledge.
+
+
+The core part of the project, in my opinion, is the automatic summarization of research trends/directions of the papers, which can be modeled as a **Topic Modeling** task in Natural Language Processing (NLP). This task requires machine learning and deep learning knowledge, such as word embeddings, transformers architecture, etc.
+
+Therefore, I would like to take the Machine Learning and Optimization course or Machine learning for Communication course from EI department. And I think these theory courses should be necessary for a good ML/DL basis.
+
+

documents/mkdocs.yml

@@ -0,0 +1,3 @@
+site_name: LRT Document
+theme: material
+

inference_hf/__init__.py

@@ -0,0 +1 @@
+from ._inference import InferenceHF

inference_hf/_inference.py

@@ -0,0 +1,53 @@
+import json
+import requests
+from typing import Union,List
+import aiohttp
+from asyncio import run
+
+class InferenceHF:
+    headers = {"Authorization": f"Bearer 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"}
+    API_URL = "https://api-inference.huggingface.co/models/"
+
+    @classmethod
+    def inference(cls, inputs: Union[List[str], str], model_name:str) ->dict:
+        payload = dict(
+            inputs = inputs,
+            options = dict(
+                wait_for_model=True
+            )
+        )
+
+        data = json.dumps(payload)
+        response = requests.request("POST", cls.API_URL+model_name, headers=cls.headers, data=data)
+        return json.loads(response.content.decode("utf-8"))
+
+    @classmethod
+    async def async_inference(cls, inputs: Union[List[str], str], model_name: str) -> dict:
+        payload = dict(
+            inputs=inputs,
+            options=dict(
+                wait_for_model=True
+            )
+        )
+
+        data = json.dumps(payload)
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(cls.API_URL + model_name, data=data, headers=cls.headers) as response:
+                return await response.json()
+
+
+if __name__ == '__main__':
+    print(InferenceHF.inference(
+        inputs='hi how are you?',
+        model_name= 't5-small'
+    ))
+
+    print(
+        run(InferenceHF.async_inference(
+        inputs='hi how are you?',
+        model_name='t5-small'
+    ))
+    )
+
+

lrt/__init__.py

@@ -0,0 +1,3 @@
+from .lrt import LiteratureResearchTool
+from .clustering import Configuration
+from .utils import Article, ArticleList

lrt/academic_query/__init__.py

@@ -0,0 +1 @@
+from .academic import AcademicQuery

lrt/academic_query/academic.py

@@ -0,0 +1,35 @@
+from requests_toolkit import ArxivQuery,IEEEQuery,PaperWithCodeQuery
+from typing import List
+
+class AcademicQuery:
+    @classmethod
+    def arxiv(cls,
+              query: str,
+              max_results: int = 50
+              ) -> List[dict]:
+        ret = ArxivQuery.query(query,'',0,max_results)
+        if not isinstance(ret,list):
+            return [ret]
+        return ret
+
+    @classmethod
+    def ieee(cls,
+             query: str,
+             start_year: int,
+             end_year: int,
+             num_papers: int = 200
+             ) -> List[dict]:
+        IEEEQuery.__setup_api_key__('vpd9yy325enruv27zj2d353e')
+        ret = IEEEQuery.query(query,start_year,end_year,num_papers)
+        if not isinstance(ret,list):
+            return [ret]
+        return ret
+
+    @classmethod
+    def paper_with_code(cls,
+                        query: str,
+                        items_per_page = 50) ->List[dict]:
+        ret = PaperWithCodeQuery.query(query, 1,items_per_page)
+        if not isinstance(ret, list):
+            return [ret]
+        return ret

lrt/clustering/__init__.py

@@ -0,0 +1,2 @@
+from .clustering_pipeline import ClusterPipeline, ClusterList
+from .config import Configuration,BaselineConfig

lrt/clustering/clustering_pipeline.py

@@ -0,0 +1,108 @@
+from typing import List
+from .config import BaselineConfig, Configuration
+from ..utils import __create_model__
+import numpy as np
+# from sklearn.cluster import KMeans
+from sklearn.preprocessing import StandardScaler
+# from yellowbrick.cluster import KElbowVisualizer
+from .clusters import ClusterList
+from unsupervised_learning.clustering import GaussianMixture, Silhouette
+
+class ClusterPipeline:
+    def __init__(self, config:Configuration = None):
+        if config is None:
+            self.__setup__(BaselineConfig())
+        else:
+            self.__setup__(config)
+
+    def __setup__(self, config:Configuration):
+        self.PTM = __create_model__(config.plm)
+        self.dimension_reduction = __create_model__(config.dimension_reduction)
+        self.clustering = __create_model__(config.clustering)
+        self.keywords_extraction = __create_model__(config.keywords_extraction)
+
+    def __1_generate_word_embeddings__(self, documents: List[str]):
+        '''
+
+        :param documents: a list of N strings:
+        :return: np.ndarray: Nx384 (sentence-transformers)
+        '''
+        print(f'>>> start generating word embeddings...')
+        print(f'>>> successfully generated word embeddings...')
+        return self.PTM.encode(documents)
+
+    def __2_dimenstion_reduction__(self, embeddings):
+        '''
+
+        :param embeddings: NxD
+        :return: Nxd, d<<D
+        '''
+        if self.dimension_reduction is None:
+            return embeddings
+        print(f'>>> start dimension reduction...')
+        embeddings = self.dimension_reduction.dimension_reduction(embeddings)
+        print(f'>>> finished dimension reduction...')
+        return embeddings
+
+    def __3_clustering__(self, embeddings, return_cluster_centers = False, max_k: int =10, standarization = False):
+        '''
+
+        :param embeddings: Nxd
+        :return:
+        '''
+        if self.clustering is None:
+            return embeddings
+        else:
+            print(f'>>> start clustering...')
+
+            ######## new: standarization ########
+            if standarization:
+                print(f'>>> start standardization...')
+                scaler = StandardScaler()
+                embeddings = scaler.fit_transform(embeddings)
+                print(f'>>> finished standardization...')
+            ######## new: standarization ########
+
+            best_k_algo = Silhouette(GaussianMixture,2,max_k)
+            best_k = best_k_algo.get_best_k(embeddings)
+            print(f'>>> The best K is {best_k}.')
+
+            labels, cluster_centers = self.clustering(embeddings, k=best_k)
+            clusters = ClusterList(best_k)
+            clusters.instantiate(labels)
+            print(f'>>> finished clustering...')
+
+            if return_cluster_centers:
+                return clusters, cluster_centers
+            return clusters
+
+    def __4_keywords_extraction__(self, clusters: ClusterList, documents: List[str]):
+        '''
+
+        :param clusters: N documents
+        :return: clusters, where each cluster has added keyphrases
+        '''
+        if self.keywords_extraction is None:
+            return clusters
+        else:
+            print(f'>>> start keywords extraction')
+            for cluster in clusters:
+                doc_ids = cluster.elements()
+                input_abstracts = [documents[i] for i in doc_ids] #[str]
+                keyphrases = self.keywords_extraction(input_abstracts) #[{keys...}]
+                cluster.add_keyphrase(keyphrases)
+                # for doc_id in doc_ids:
+                #     keyphrases = self.keywords_extraction(documents[doc_id])
+                #     cluster.add_keyphrase(keyphrases)
+            print(f'>>> finished keywords extraction')
+            return clusters
+
+
+    def __call__(self, documents: List[str], max_k:int, standarization = False):
+        print(f'>>> pipeline starts...')
+        x = self.__1_generate_word_embeddings__(documents)
+        x = self.__2_dimenstion_reduction__(x)
+        clusters = self.__3_clustering__(x,max_k=max_k,standarization=standarization)
+        outputs = self.__4_keywords_extraction__(clusters, documents)
+        print(f'>>> pipeline finished!\n')
+        return outputs

lrt/clustering/clusters.py

@@ -0,0 +1,91 @@
+from typing import List, Iterable, Union
+from pprint import pprint
+
+class KeyphraseCount:
+
+    def __init__(self, keyphrase: str, count: int) -> None:
+        super().__init__()
+        self.keyphrase = keyphrase
+        self.count = count
+
+    @classmethod
+    def reduce(cls, kcs: list) :
+        '''
+        kcs: List[KeyphraseCount]
+        '''
+        keys = ''
+        count = 0
+
+        for i in range(len(kcs)-1):
+            kc = kcs[i]
+            keys += kc.keyphrase + '/'
+            count += kc.count
+
+        keys += kcs[-1].keyphrase
+        count += kcs[-1].count
+        return KeyphraseCount(keys, count)
+
+
+
+class SingleCluster:
+    def __init__(self):
+        self.__container__ = []
+        self.__keyphrases__ = {}
+    def add(self, id:int):
+        self.__container__.append(id)
+    def __str__(self) -> str:
+        return str(self.__container__)
+    def elements(self) -> List:
+        return self.__container__
+    def get_keyphrases(self):
+        ret = []
+        for key, count in self.__keyphrases__.items():
+            ret.append(KeyphraseCount(key,count))
+        return ret
+    def add_keyphrase(self, keyphrase:Union[str,Iterable]):
+        if isinstance(keyphrase,str):
+            if keyphrase not in self.__keyphrases__.keys():
+                self.__keyphrases__[keyphrase] = 1
+            else:
+                self.__keyphrases__[keyphrase] += 1
+        elif isinstance(keyphrase,Iterable):
+            for i in keyphrase:
+                self.add_keyphrase(i)
+
+    def __len__(self):
+        return len(self.__container__)
+
+    def print_keyphrases(self):
+        pprint(self.__keyphrases__)
+
+class ClusterList:
+    def __init__(self, k:int):
+        self.__clusters__ = [SingleCluster() for _ in range(k)]
+
+    # subscriptable and slice-able
+    def __getitem__(self, idx):
+        if isinstance(idx, int):
+            return self.__clusters__[idx]
+        if isinstance(idx, slice):
+            # return
+            return self.__clusters__[0 if idx.start is None else idx.start: idx.stop: 0 if idx.step is None else idx.step]
+
+    def instantiate(self, labels: Iterable):
+        for id, label in enumerate(labels):
+            self.__clusters__[label].add(id)
+
+    def __str__(self):
+        ret = f'There are {len(self.__clusters__)} clusters:\n'
+        for id,cluster in enumerate(self.__clusters__):
+            ret += f'cluster {id} contains: {cluster}.\n'
+
+        return ret
+
+    # return an iterator that can be used in for loop etc.
+    def __iter__(self):
+        return self.__clusters__.__iter__()
+
+    def __len__(self): return len(self.__clusters__)
+
+    def sort(self):
+        self.__clusters__.sort(key=len,reverse=True)

lrt/clustering/config.py

@@ -0,0 +1,11 @@
+class Configuration:
+    def __init__(self, plm:str, dimension_reduction:str,clustering:str,keywords_extraction:str):
+        self.plm = plm
+        self.dimension_reduction = dimension_reduction
+        self.clustering = clustering
+        self.keywords_extraction = keywords_extraction
+
+
+class BaselineConfig(Configuration):
+    def __init__(self):
+        super().__init__('''all-mpnet-base-v2''', 'none', 'kmeans-euclidean', 'keyphrase-transformer')

lrt/clustering/models/__init__.py

@@ -0,0 +1 @@
+from .keyBartPlus import KeyBartAdapter

lrt/clustering/models/adapter.py

@@ -0,0 +1,25 @@
+import torch
+import torch.nn as nn
+
+class Adapter(nn.Module):
+    def __init__(self,input_dim:int, hidden_dim: int) -> None:
+        super().__init__()
+        self.input_dim = input_dim
+        self.hidden_dim = hidden_dim
+        self.layerNorm = nn.LayerNorm(input_dim)
+        self.down_proj = nn.Linear(input_dim,hidden_dim,False)
+        self.up_proj = nn.Linear(hidden_dim,input_dim,False)
+
+    def forward(self,x):
+        '''
+
+        :param x: N,L,D
+        :return:  N,L,D
+        '''
+        output = x
+        x = self.layerNorm(x)
+        x = self.down_proj(x)
+        x = nn.functional.relu(x)
+        x = self.up_proj(x)
+        output = output + x # residual connection
+        return output

lrt/clustering/models/keyBartPlus.py

@@ -0,0 +1,411 @@
+from typing import Optional, List, Union, Tuple
+import torch
+import torch.nn as nn
+import random
+from torch.nn import CrossEntropyLoss
+
+from transformers.utils import (
+add_start_docstrings_to_model_forward,
+add_end_docstrings,
+replace_return_docstrings
+)
+
+from transformers import AutoModelForSeq2SeqLM
+from transformers.models.bart.modeling_bart import (
+    BartForConditionalGeneration,
+    _expand_mask, logger,
+    shift_tokens_right,
+    BartPretrainedModel,
+    BART_INPUTS_DOCSTRING,
+    _CONFIG_FOR_DOC,
+    BART_GENERATION_EXAMPLE,
+    BartModel,
+    BartDecoder
+
+)
+from .adapter import Adapter
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPastAndCrossAttentions,
+    Seq2SeqModelOutput,
+    BaseModelOutput,
+    Seq2SeqLMOutput
+)
+
+
+class KeyBartAdapter(BartForConditionalGeneration):
+    def __init__(self,adapter_hid_dim:int) -> None:
+        keyBart = AutoModelForSeq2SeqLM.from_pretrained("bloomberg/KeyBART")
+        self.__fix_weights__(keyBart)
+
+        super().__init__(keyBart.model.config)
+        self.lm_head = keyBart.lm_head
+        self.model = BartPlus(keyBart, adapter_hid_dim)
+        self.register_buffer("final_logits_bias", torch.zeros((1, self.model.shared.num_embeddings)))
+
+
+    def __fix_weights__(self,keyBart:BartForConditionalGeneration):
+        for i in keyBart.model.parameters():
+            i.requires_grad = False
+        for i in keyBart.lm_head.parameters():
+            i.requires_grad = False
+
+    @add_start_docstrings_to_model_forward(BART_INPUTS_DOCSTRING)
+    @replace_return_docstrings(output_type=Seq2SeqLMOutput, config_class=_CONFIG_FOR_DOC)
+    @add_end_docstrings(BART_GENERATION_EXAMPLE)
+    def forward(
+            self,
+            input_ids: torch.LongTensor = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            decoder_input_ids: Optional[torch.LongTensor] = None,
+            decoder_attention_mask: Optional[torch.LongTensor] = None,
+            head_mask: Optional[torch.Tensor] = None,
+            decoder_head_mask: Optional[torch.Tensor] = None,
+            cross_attn_head_mask: Optional[torch.Tensor] = None,
+            encoder_outputs: Optional[List[torch.FloatTensor]] = None,
+            past_key_values: Optional[List[torch.FloatTensor]] = None,
+            inputs_embeds: Optional[torch.FloatTensor] = None,
+            decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
+            labels: Optional[torch.LongTensor] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, Seq2SeqLMOutput]:
+        r"""
+        labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
+            Labels for computing the masked language modeling loss. Indices should either be in `[0, ...,
+            config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored
+            (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`.
+        Returns:
+        """
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if labels is not None:
+            if use_cache:
+                logger.warning("The `use_cache` argument is changed to `False` since `labels` is provided.")
+            use_cache = False
+            if decoder_input_ids is None and decoder_inputs_embeds is None:
+                decoder_input_ids = shift_tokens_right(
+                    labels, self.config.pad_token_id, self.config.decoder_start_token_id
+                )
+
+        outputs = self.model(
+            input_ids,
+            attention_mask=attention_mask,
+            decoder_input_ids=decoder_input_ids,
+            encoder_outputs=encoder_outputs,
+            decoder_attention_mask=decoder_attention_mask,
+            head_mask=head_mask,
+            decoder_head_mask=decoder_head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=inputs_embeds,
+            decoder_inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+        lm_logits = self.lm_head(outputs[0]) + self.final_logits_bias
+
+        masked_lm_loss = None
+        if labels is not None:
+            loss_fct = CrossEntropyLoss()
+            masked_lm_loss = loss_fct(lm_logits.view(-1, self.config.vocab_size), labels.view(-1))
+
+        if not return_dict:
+            output = (lm_logits,) + outputs[1:]
+            return ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
+
+        return Seq2SeqLMOutput(
+            loss=masked_lm_loss,
+            logits=lm_logits,
+            past_key_values=outputs.past_key_values,
+            decoder_hidden_states=outputs.decoder_hidden_states,
+            decoder_attentions=outputs.decoder_attentions,
+            cross_attentions=outputs.cross_attentions,
+            encoder_last_hidden_state=outputs.encoder_last_hidden_state,
+            encoder_hidden_states=outputs.encoder_hidden_states,
+            encoder_attentions=outputs.encoder_attentions,
+        )
+
+
+
+class BartDecoderPlus(BartDecoder):
+    def __init__(self,keyBart:BartForConditionalGeneration,adapter_hid_dim: int) -> None:
+        super().__init__(keyBart.get_decoder().config)
+        self.decoder = keyBart.model.decoder
+        self.adapters = nn.ModuleList([Adapter(self.decoder.config.d_model,adapter_hid_dim) for _ in range(len(self.decoder.layers))])
+        self.config = self.decoder.config
+        self.dropout = self.decoder.dropout
+        self.layerdrop = self.decoder.layerdrop
+        self.padding_idx = self.decoder.padding_idx
+        self.max_target_positions = self.decoder.max_target_positions
+        self.embed_scale = self.decoder.embed_scale
+        self.embed_tokens = self.decoder.embed_tokens
+        self.embed_positions = self.decoder.embed_positions
+        self.layers = self.decoder.layers
+        self.layernorm_embedding = self.decoder.layernorm_embedding
+        self.gradient_checkpointing = self.decoder.gradient_checkpointing
+
+
+    def forward(
+            self,
+            input_ids: torch.LongTensor = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            encoder_hidden_states: Optional[torch.FloatTensor] = None,
+            encoder_attention_mask: Optional[torch.LongTensor] = None,
+            head_mask: Optional[torch.Tensor] = None,
+            cross_attn_head_mask: Optional[torch.Tensor] = None,
+            past_key_values: Optional[List[torch.FloatTensor]] = None,
+            inputs_embeds: Optional[torch.FloatTensor] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, BaseModelOutputWithPastAndCrossAttentions]:
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # retrieve input_ids and inputs_embeds
+        if input_ids is not None and inputs_embeds is not None:
+            raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time")
+        elif input_ids is not None:
+            input = input_ids
+            input_shape = input.shape
+            input_ids = input_ids.view(-1, input_shape[-1])
+        elif inputs_embeds is not None:
+            input_shape = inputs_embeds.size()[:-1]
+            input = inputs_embeds[:, :, -1]
+        else:
+            raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds")
+
+        # past_key_values_length
+        past_key_values_length = past_key_values[0][0].shape[2] if past_key_values is not None else 0
+
+        if inputs_embeds is None:
+            inputs_embeds = self.decoder.embed_tokens(input) * self.decoder.embed_scale
+
+        attention_mask = self.decoder._prepare_decoder_attention_mask(
+            attention_mask, input_shape, inputs_embeds, past_key_values_length
+        )
+
+        # expand encoder attention mask
+        if encoder_hidden_states is not None and encoder_attention_mask is not None:
+            # [bsz, seq_len] -> [bsz, 1, tgt_seq_len, src_seq_len]
+            encoder_attention_mask = _expand_mask(encoder_attention_mask, inputs_embeds.dtype, tgt_len=input_shape[-1])
+
+        # embed positions
+        positions = self.decoder.embed_positions(input, past_key_values_length)
+
+        hidden_states = inputs_embeds + positions
+        hidden_states = self.decoder.layernorm_embedding(hidden_states)
+
+        hidden_states = nn.functional.dropout(hidden_states, p=self.decoder.dropout, training=self.decoder.training)
+
+        # decoder layers
+        all_hidden_states = () if output_hidden_states else None
+        all_self_attns = () if output_attentions else None
+        all_cross_attentions = () if (output_attentions and encoder_hidden_states is not None) else None
+        next_decoder_cache = () if use_cache else None
+
+        # check if head_mask/cross_attn_head_mask has a correct number of layers specified if desired
+        for attn_mask, mask_name in zip([head_mask, cross_attn_head_mask], ["head_mask", "cross_attn_head_mask"]):
+            if attn_mask is not None:
+                if attn_mask.size()[0] != (len(self.decoder.layers)):
+                    raise ValueError(
+                        f"The `{mask_name}` should be specified for {len(self.decoder.layers)} layers, but it is for"
+                        f" {head_mask.size()[0]}."
+                    )
+
+        for idx, decoder_layer in enumerate(self.decoder.layers):
+            # add LayerDrop (see https://arxiv.org/abs/1909.11556 for description)
+            if output_hidden_states:
+                all_hidden_states += (hidden_states,)
+            dropout_probability = random.uniform(0, 1)
+            if self.decoder.training and (dropout_probability < self.decoder.layerdrop):
+                continue
+
+            past_key_value = past_key_values[idx] if past_key_values is not None else None
+
+            if self.decoder.gradient_checkpointing and self.decoder.training:
+
+                if use_cache:
+                    logger.warning(
+                        "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
+                    )
+                    use_cache = False
+
+                def create_custom_forward(module):
+                    def custom_forward(*inputs):
+                        # None for past_key_value
+                        return module(*inputs, output_attentions, use_cache)
+
+                    return custom_forward
+
+                layer_outputs = torch.utils.checkpoint.checkpoint(
+                    create_custom_forward(decoder_layer),
+                    hidden_states,
+                    attention_mask,
+                    encoder_hidden_states,
+                    encoder_attention_mask,
+                    head_mask[idx] if head_mask is not None else None,
+                    cross_attn_head_mask[idx] if cross_attn_head_mask is not None else None,
+                    None,
+                )
+            else:
+
+                layer_outputs = decoder_layer(
+                    hidden_states,
+                    attention_mask=attention_mask,
+                    encoder_hidden_states=encoder_hidden_states,
+                    encoder_attention_mask=encoder_attention_mask,
+                    layer_head_mask=(head_mask[idx] if head_mask is not None else None),
+                    cross_attn_layer_head_mask=(
+                        cross_attn_head_mask[idx] if cross_attn_head_mask is not None else None
+                    ),
+                    past_key_value=past_key_value,
+                    output_attentions=output_attentions,
+                    use_cache=use_cache,
+                )
+            hidden_states = layer_outputs[0]
+
+            ######################### new #################################
+            hidden_states = self.adapters[idx](hidden_states)
+            ######################### new #################################
+
+            if use_cache:
+                next_decoder_cache += (layer_outputs[3 if output_attentions else 1],)
+
+            if output_attentions:
+                all_self_attns += (layer_outputs[1],)
+
+                if encoder_hidden_states is not None:
+                    all_cross_attentions += (layer_outputs[2],)
+
+        # add hidden states from the last decoder layer
+        if output_hidden_states:
+            all_hidden_states += (hidden_states,)
+
+        next_cache = next_decoder_cache if use_cache else None
+        if not return_dict:
+            return tuple(
+                v
+                for v in [hidden_states, next_cache, all_hidden_states, all_self_attns, all_cross_attentions]
+                if v is not None
+            )
+        return BaseModelOutputWithPastAndCrossAttentions(
+            last_hidden_state=hidden_states,
+            past_key_values=next_cache,
+            hidden_states=all_hidden_states,
+            attentions=all_self_attns,
+            cross_attentions=all_cross_attentions,
+        )
+
+class BartPlus(BartModel):
+    def __init__(self,keyBart: BartForConditionalGeneration, adapter_hid_dim: int ) -> None:
+        super().__init__(keyBart.model.config)
+        self.config = keyBart.model.config
+
+        # self.shared = nn.Embedding(vocab_size, config.d_model, padding_idx)
+        self.shared = keyBart.model.shared
+
+        #self.encoder = BartEncoder(config, self.shared)
+        self.encoder = keyBart.model.encoder
+
+        #self.decoder = BartDecoder(config, self.shared)
+        #self.decoder = keyBart.model.decoder
+        self.decoder = BartDecoderPlus(keyBart,adapter_hid_dim=adapter_hid_dim)
+
+    def forward(
+            self,
+            input_ids: torch.LongTensor = None,
+            attention_mask: Optional[torch.Tensor] = None,
+            decoder_input_ids: Optional[torch.LongTensor] = None,
+            decoder_attention_mask: Optional[torch.LongTensor] = None,
+            head_mask: Optional[torch.Tensor] = None,
+            decoder_head_mask: Optional[torch.Tensor] = None,
+            cross_attn_head_mask: Optional[torch.Tensor] = None,
+            encoder_outputs: Optional[List[torch.FloatTensor]] = None,
+            past_key_values: Optional[List[torch.FloatTensor]] = None,
+            inputs_embeds: Optional[torch.FloatTensor] = None,
+            decoder_inputs_embeds: Optional[torch.FloatTensor] = None,
+            use_cache: Optional[bool] = None,
+            output_attentions: Optional[bool] = None,
+            output_hidden_states: Optional[bool] = None,
+            return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, Seq2SeqModelOutput]:
+
+        # different to other models, Bart automatically creates decoder_input_ids from
+        # input_ids if no decoder_input_ids are provided
+        if decoder_input_ids is None and decoder_inputs_embeds is None:
+            if input_ids is None:
+                raise ValueError(
+                    "If no `decoder_input_ids` or `decoder_inputs_embeds` are "
+                    "passed, `input_ids` cannot be `None`. Please pass either "
+                    "`input_ids` or `decoder_input_ids` or `decoder_inputs_embeds`."
+                )
+
+            decoder_input_ids = shift_tokens_right(
+                input_ids, self.config.pad_token_id, self.config.decoder_start_token_id
+            )
+
+        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions
+        output_hidden_states = (
+            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
+        )
+        use_cache = use_cache if use_cache is not None else self.config.use_cache
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        if encoder_outputs is None:
+            encoder_outputs = self.encoder(
+                input_ids=input_ids,
+                attention_mask=attention_mask,
+                head_mask=head_mask,
+                inputs_embeds=inputs_embeds,
+                output_attentions=output_attentions,
+                output_hidden_states=output_hidden_states,
+                return_dict=return_dict,
+            )
+        # If the user passed a tuple for encoder_outputs, we wrap it in a BaseModelOutput when return_dict=True
+        elif return_dict and not isinstance(encoder_outputs, BaseModelOutput):
+            encoder_outputs = BaseModelOutput(
+                last_hidden_state=encoder_outputs[0],
+                hidden_states=encoder_outputs[1] if len(encoder_outputs) > 1 else None,
+                attentions=encoder_outputs[2] if len(encoder_outputs) > 2 else None,
+            )
+
+        # decoder outputs consists of (dec_features, past_key_value, dec_hidden, dec_attn)
+        decoder_outputs = self.decoder(
+            input_ids=decoder_input_ids,
+            attention_mask=decoder_attention_mask,
+            encoder_hidden_states=encoder_outputs[0],
+            encoder_attention_mask=attention_mask,
+            head_mask=decoder_head_mask,
+            cross_attn_head_mask=cross_attn_head_mask,
+            past_key_values=past_key_values,
+            inputs_embeds=decoder_inputs_embeds,
+            use_cache=use_cache,
+            output_attentions=output_attentions,
+            output_hidden_states=output_hidden_states,
+            return_dict=return_dict,
+        )
+
+        if not return_dict:
+            return decoder_outputs + encoder_outputs
+
+        return Seq2SeqModelOutput(
+            last_hidden_state=decoder_outputs.last_hidden_state,
+            past_key_values=decoder_outputs.past_key_values,
+            decoder_hidden_states=decoder_outputs.hidden_states,
+            decoder_attentions=decoder_outputs.attentions,
+            cross_attentions=decoder_outputs.cross_attentions,
+            encoder_last_hidden_state=encoder_outputs.last_hidden_state,
+            encoder_hidden_states=encoder_outputs.hidden_states,
+            encoder_attentions=encoder_outputs.attentions,
+        )
+

lrt/lrt.py

@@ -0,0 +1,144 @@
+from .clustering import *
+from typing import List
+import textdistance as td
+from .utils import UnionFind, ArticleList
+from .academic_query import AcademicQuery
+import streamlit as st
+from tokenizers import Tokenizer
+from .clustering.clusters import KeyphraseCount
+
+
+
+class LiteratureResearchTool:
+    def __init__(self, cluster_config: Configuration = None):
+        self.literature_search = AcademicQuery
+        self.cluster_pipeline = ClusterPipeline(cluster_config)
+
+
+    def __postprocess_clusters__(self, clusters: ClusterList,query: str) ->ClusterList:
+        '''
+        add top-5 keyphrases to each cluster
+        :param clusters:
+        :return: clusters
+        '''
+        def condition(x: KeyphraseCount, y: KeyphraseCount):
+            return td.ratcliff_obershelp(x.keyphrase, y.keyphrase) > 0.8
+
+        def valid_keyphrase(x:KeyphraseCount):
+            tmp = x.keyphrase
+            return tmp is not None and tmp != '' and not tmp.isspace() and  len(tmp)!=1\
+                 and  tmp != query
+
+
+        for cluster in clusters:
+
+            keyphrases = cluster.get_keyphrases() # [kc]
+            keyphrases = list(filter(valid_keyphrase,keyphrases))
+            unionfind = UnionFind(keyphrases, condition)
+            unionfind.union_step()
+
+            tmp = unionfind.get_unions() # dict(root_id = [kc])
+            tmp = tmp.values() # [[kc]]
+            # [[kc]] -> [ new kc] -> sorted
+            tmp = [KeyphraseCount.reduce(x) for x in tmp]
+            keyphrases = sorted(tmp,key= lambda x: x.count,reverse=True)[:5]
+            keyphrases = [x.keyphrase for x in keyphrases]
+
+            # keyphrases = sorted(list(unionfind.get_unions().values()), key=len, reverse=True)[:5]  # top-5 keyphrases: list
+            # for i in keyphrases:
+            #     tmp = '/'.join(i)
+            #     cluster.top_5_keyphrases.append(tmp)
+            cluster.top_5_keyphrases = keyphrases
+
+        return clusters
+
+    def __call__(self,
+                 query: str,
+                 num_papers: int,
+                 start_year: int,
+                 end_year: int,
+                 max_k: int,
+                 platforms: List[str] = ['IEEE', 'Arxiv', 'Paper with Code'],
+                 loading_ctx_manager = None,
+                 standardization = False
+                 ):
+
+
+        for platform in platforms:
+            if loading_ctx_manager:
+                with loading_ctx_manager():
+                    clusters, articles = self.__platformPipeline__(platform,query,num_papers,start_year,end_year,max_k,standardization)
+            else:
+                clusters, articles = self.__platformPipeline__(platform, query, num_papers, start_year, end_year,max_k,standardization)
+
+            clusters.sort()
+            yield clusters,articles
+
+
+
+    def __platformPipeline__(self,platforn_name:str,
+                             query: str,
+                             num_papers: int,
+                             start_year: int,
+                             end_year: int,
+                             max_k: int,
+                             standardization
+                             ) -> (ClusterList,ArticleList):
+
+        @st.cache(hash_funcs={Tokenizer: Tokenizer.__hash__},allow_output_mutation=True)
+        def ieee_process(
+                query: str,
+                num_papers: int,
+                start_year: int,
+                end_year: int,
+        ):
+            articles = ArticleList.parse_ieee_articles(
+            self.literature_search.ieee(query, start_year, end_year, num_papers))  # ArticleList
+            abstracts = articles.getAbstracts()  # List[str]
+            clusters = self.cluster_pipeline(abstracts,max_k,standardization)
+            clusters = self.__postprocess_clusters__(clusters,query)
+            return clusters, articles
+
+        @st.cache(hash_funcs={Tokenizer: Tokenizer.__hash__},allow_output_mutation=True)
+        def arxiv_process(
+                query: str,
+                num_papers: int,
+        ):
+            articles = ArticleList.parse_arxiv_articles(
+            self.literature_search.arxiv(query, num_papers))  # ArticleList
+            abstracts = articles.getAbstracts()  # List[str]
+            clusters = self.cluster_pipeline(abstracts,max_k,standardization)
+            clusters = self.__postprocess_clusters__(clusters,query)
+            return clusters, articles
+
+        @st.cache(hash_funcs={Tokenizer: Tokenizer.__hash__},allow_output_mutation=True)
+        def pwc_process(
+                query: str,
+                num_papers: int,
+        ):
+            articles = ArticleList.parse_pwc_articles(
+            self.literature_search.paper_with_code(query, num_papers))  # ArticleList
+            abstracts = articles.getAbstracts()  # List[str]
+            clusters = self.cluster_pipeline(abstracts,max_k,standardization)
+            clusters = self.__postprocess_clusters__(clusters,query)
+            return clusters, articles
+
+        if platforn_name == 'IEEE':
+            return ieee_process(query,num_papers,start_year,end_year)
+        elif platforn_name == 'Arxiv':
+            return arxiv_process(query,num_papers)
+        elif platforn_name == 'Paper with Code':
+            return pwc_process(query,num_papers)
+        else:
+            raise RuntimeError('This platform is not supported. Please open an issue on the GitHub.')
+
+
+
+
+
+
+
+
+
+
+

lrt/utils/__init__.py

@@ -0,0 +1,3 @@
+from .functions import __create_model__
+from .union_find import UnionFind
+from .article import ArticleList, Article

lrt/utils/article.py

@@ -0,0 +1,412 @@
+from typing import List, Union, Optional
+import pandas as pd
+class Article:
+    '''
+    attributes:
+    - title: str
+    - authors: list of str
+    - abstract: str
+    - url: str
+    - publication_year: int
+    '''
+    def __init__(self,
+                 title: str,
+                 authors: List[str],
+                 abstract: str,
+                 url: str,
+                 publication_year: int
+                 ) -> None:
+        super().__init__()
+        self.title = title
+        self.authors = authors
+        self.url = url
+        self.publication_year = publication_year
+        self.abstract = abstract.replace('\n',' ')
+    def __str__(self):
+        ret = ''
+        ret +=self.title +'\n- '
+        ret +=f"authors: {';'.join(self.authors)}" + '\n- '
+        ret += f'''abstract: {self.abstract}''' + '\n- '
+        ret += f'''url: {self.url}'''+ '\n- '
+        ret += f'''publication year: {self.publication_year}'''+ '\n\n'
+
+        return ret
+
+    def getDict(self) -> dict:
+        return {
+            'title': self.title,
+            'authors': self.authors,
+            'abstract': self.abstract,
+            'url': self.url,
+            'publication_year': self.publication_year
+        }
+
+class ArticleList:
+    '''
+    list of articles
+    '''
+    def __init__(self,articles:Optional[Union[Article, List[Article]]]=None) -> None:
+        super().__init__()
+        self.__list__ = [] # List[Article]
+
+        if articles is not None:
+            self.addArticles(articles)
+
+    def addArticles(self, articles:Union[Article, List[Article]]):
+        if isinstance(articles,Article):
+            self.__list__.append(articles)
+        elif isinstance(articles, list):
+            self.__list__ += articles
+
+    # subscriptable and slice-able
+    def __getitem__(self, idx):
+        if isinstance(idx, int):
+            return self.__list__[idx]
+        if isinstance(idx, slice):
+            # return
+            return self.__list__[0 if idx.start is None else idx.start: idx.stop: 0 if idx.step is None else idx.step]
+
+
+    def __str__(self):
+        ret = f'There are {len(self.__list__)} articles:\n'
+        for id, article in enumerate(self.__list__):
+            ret += f'{id+1}) '
+            ret += f'{article}'
+
+        return ret
+
+    # return an iterator that can be used in for loop etc.
+    def __iter__(self):
+        return self.__list__.__iter__()
+
+    def __len__(self):
+        return len(self.__list__)
+
+    def getDataFrame(self) ->pd.DataFrame:
+        return pd.DataFrame(
+            [x.getDict() for x in self.__list__]
+        )
+
+
+    @classmethod
+    def parse_ieee_articles(cls,items: Union[dict, List[dict]]):
+        if isinstance(items,dict):
+            items = [items]
+
+        ret = [
+            Article(
+                title=item['title'],
+                authors=[x['full_name'] for x in item['authors']['authors']],
+                abstract=item['abstract'],
+                url=item['html_url'],
+                publication_year=item['publication_year']
+            )
+            for item in items ] # List[Article]
+
+        ret = ArticleList(ret)
+        return ret
+
+    @classmethod
+    def parse_arxiv_articles(cls, items: Union[dict, List[dict]]):
+        if isinstance(items, dict):
+            items = [items]
+
+        def __getAuthors__(item):
+            if isinstance(item['author'],list):
+                return [x['name'] for x in item['author']]
+            else:
+                return [item['author']['name']]
+
+        ret = [
+            Article(
+                title=item['title'],
+                authors=__getAuthors__(item),
+                abstract=item['summary'],
+                url=item['id'],
+                publication_year=item['published'][:4]
+            )
+            for item in items]  # List[Article]
+
+        ret = ArticleList(ret)
+        return ret
+
+    @classmethod
+    def parse_pwc_articles(cls, items: Union[dict, List[dict]]):
+        if isinstance(items, dict):
+            items = [items]
+
+        ret = [
+            Article(
+                title=item['title'],
+                authors=item['authors'],
+                abstract=item['abstract'],
+                url=item['url_abs'],
+                publication_year=item['published'][:4]
+            )
+            for item in items]  # List[Article]
+
+        ret = ArticleList(ret)
+        return ret
+
+    def getAbstracts(self) -> List[str]:
+        return [x.abstract for x in self.__list__]
+
+    def getTitles(self) -> List[str]:
+        return [x.title for x in self.__list__]
+
+    def getArticles(self) -> List[Article]:
+        return self.__list__
+
+if __name__ == '__main__':
+    item = [{'doi': '10.1109/COMPSAC51774.2021.00100',
+ 'title': 'Towards Developing An EMR in Mental Health Care for Children’s Mental Health Development among the Underserved Communities in USA',
+ 'publisher': 'IEEE',
+ 'isbn': '978-1-6654-2464-6',
+ 'issn': '0730-3157',
+ 'rank': 1,
+ 'authors': {'authors': [{'affiliation': 'Department of Computer Science, Ubicomp Lab, Marquette University, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088961521',
+    'id': 37088961521,
+    'full_name': 'Kazi Zawad Arefin',
+    'author_order': 1},
+   {'affiliation': 'Department of Computer Science, Ubicomp Lab, Marquette University, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088962639',
+    'id': 37088962639,
+    'full_name': 'Kazi Shafiul Alam Shuvo',
+    'author_order': 2},
+   {'affiliation': 'Department of Computer Science, Ubicomp Lab, Marquette University, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088511010',
+    'id': 37088511010,
+    'full_name': 'Masud Rabbani',
+    'author_order': 3},
+   {'affiliation': 'Product Developer, Marquette Energy Analytics, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088961612',
+    'id': 37088961612,
+    'full_name': 'Peter Dobbs',
+    'author_order': 4},
+   {'affiliation': 'Next Step Clinic, Mental Health America of WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088962516',
+    'id': 37088962516,
+    'full_name': 'Leah Jepson',
+    'author_order': 5},
+   {'affiliation': 'Next Step Clinic, Mental Health America of WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088962336',
+    'id': 37088962336,
+    'full_name': 'Amy Leventhal',
+    'author_order': 6},
+   {'affiliation': 'Department of Psychology, Marquette University, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088962101',
+    'id': 37088962101,
+    'full_name': 'Amy Vaughan Van Heeke',
+    'author_order': 7},
+   {'affiliation': 'Department of Computer Science, Ubicomp Lab, Marquette University, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37270354900',
+    'id': 37270354900,
+    'full_name': 'Sheikh Iqbal Ahamed',
+    'author_order': 8}]},
+ 'access_type': 'LOCKED',
+ 'content_type': 'Conferences',
+ 'abstract': "Next Step Clinic (NSC) is a neighborhood-based mental clinic in Milwaukee in the USA for early identification and intervention of Autism spectrum disorder (ASD) children. NSC's primary goal is to serve the underserved families in that area with children aged 15 months to 10 years who have ASD symptoms free of cost. Our proposed and implemented Electronic Medical Records (NSC: EMR) has been developed for NSC. This paper describes the NSC: EMR's design specification and whole development process with the workflow control of this system in NSC. This NSC: EMR has been used to record the patient’s medical data and make appointments both physically or virtually. The integration of standardized psychological evaluation form has reduced the paperwork and physical storage burden for the family navigator. By deploying the system, the family navigator can increase their productivity from the screening to all intervention processes to deal with ASD children. Even in the lockdown time, due to the pandemic of COVID-19, about 84 ASD patients from the deprived family at that area got registered and took intervention through this NSC: EMR. The usability and cost-effective feature has already shown the potential of NSC: EMR, and it will be scaled to serve a large population in the USA and beyond.",
+ 'article_number': '9529808',
+ 'pdf_url': 'https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9529808',
+ 'html_url': 'https://ieeexplore.ieee.org/document/9529808/',
+ 'abstract_url': 'https://ieeexplore.ieee.org/document/9529808/',
+ 'publication_title': '2021 IEEE 45th Annual Computers, Software, and Applications Conference (COMPSAC)',
+ 'conference_location': 'Madrid, Spain',
+ 'conference_dates': '12-16 July 2021',
+ 'publication_number': 9529349,
+ 'is_number': 9529356,
+ 'publication_year': 2021,
+ 'publication_date': '12-16 July 2021',
+ 'start_page': '688',
+ 'end_page': '693',
+ 'citing_paper_count': 2,
+ 'citing_patent_count': 0,
+ 'index_terms': {'ieee_terms': {'terms': ['Pediatrics',
+    'Pandemics',
+    'Navigation',
+    'Mental health',
+    'Tools',
+    'Software',
+    'Information technology']},
+  'author_terms': {'terms': ['Electronic medical record (EMR)',
+    'Mental Health Care (MHC)',
+    'Autism Spectrum Disorder (ASD)',
+    'Health Information Technology (HIT)',
+    'Mental Health Professional (MHP)']}},
+ 'isbn_formats': {'isbns': [{'format': 'Print on Demand(PoD) ISBN',
+    'value': '978-1-6654-2464-6',
+    'isbnType': 'New-2005'},
+   {'format': 'Electronic ISBN',
+    'value': '978-1-6654-2463-9',
+    'isbnType': 'New-2005'}]}},{'doi': '10.1109/COMPSAC51774.2021.00100',
+ 'title': 'Towards Developing An EMR in Mental Health Care for Children’s Mental Health Development among the Underserved Communities in USA',
+ 'publisher': 'IEEE',
+ 'isbn': '978-1-6654-2464-6',
+ 'issn': '0730-3157',
+ 'rank': 1,
+ 'authors': {'authors': [{'affiliation': 'Department of Computer Science, Ubicomp Lab, Marquette University, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088961521',
+    'id': 37088961521,
+    'full_name': 'Kazi Zawad Arefin',
+    'author_order': 1},
+   {'affiliation': 'Department of Computer Science, Ubicomp Lab, Marquette University, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088962639',
+    'id': 37088962639,
+    'full_name': 'Kazi Shafiul Alam Shuvo',
+    'author_order': 2},
+   {'affiliation': 'Department of Computer Science, Ubicomp Lab, Marquette University, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088511010',
+    'id': 37088511010,
+    'full_name': 'Masud Rabbani',
+    'author_order': 3},
+   {'affiliation': 'Product Developer, Marquette Energy Analytics, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088961612',
+    'id': 37088961612,
+    'full_name': 'Peter Dobbs',
+    'author_order': 4},
+   {'affiliation': 'Next Step Clinic, Mental Health America of WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088962516',
+    'id': 37088962516,
+    'full_name': 'Leah Jepson',
+    'author_order': 5},
+   {'affiliation': 'Next Step Clinic, Mental Health America of WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088962336',
+    'id': 37088962336,
+    'full_name': 'Amy Leventhal',
+    'author_order': 6},
+   {'affiliation': 'Department of Psychology, Marquette University, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37088962101',
+    'id': 37088962101,
+    'full_name': 'Amy Vaughan Van Heeke',
+    'author_order': 7},
+   {'affiliation': 'Department of Computer Science, Ubicomp Lab, Marquette University, Milwaukee, WI, USA',
+    'authorUrl': 'https://ieeexplore.ieee.org/author/37270354900',
+    'id': 37270354900,
+    'full_name': 'Sheikh Iqbal Ahamed',
+    'author_order': 8}]},
+ 'access_type': 'LOCKED',
+ 'content_type': 'Conferences',
+ 'abstract': "Next Step Clinic (NSC) is a neighborhood-based mental clinic in Milwaukee in the USA for early identification and intervention of Autism spectrum disorder (ASD) children. NSC's primary goal is to serve the underserved families in that area with children aged 15 months to 10 years who have ASD symptoms free of cost. Our proposed and implemented Electronic Medical Records (NSC: EMR) has been developed for NSC. This paper describes the NSC: EMR's design specification and whole development process with the workflow control of this system in NSC. This NSC: EMR has been used to record the patient’s medical data and make appointments both physically or virtually. The integration of standardized psychological evaluation form has reduced the paperwork and physical storage burden for the family navigator. By deploying the system, the family navigator can increase their productivity from the screening to all intervention processes to deal with ASD children. Even in the lockdown time, due to the pandemic of COVID-19, about 84 ASD patients from the deprived family at that area got registered and took intervention through this NSC: EMR. The usability and cost-effective feature has already shown the potential of NSC: EMR, and it will be scaled to serve a large population in the USA and beyond.",
+ 'article_number': '9529808',
+ 'pdf_url': 'https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=9529808',
+ 'html_url': 'https://ieeexplore.ieee.org/document/9529808/',
+ 'abstract_url': 'https://ieeexplore.ieee.org/document/9529808/',
+ 'publication_title': '2021 IEEE 45th Annual Computers, Software, and Applications Conference (COMPSAC)',
+ 'conference_location': 'Madrid, Spain',
+ 'conference_dates': '12-16 July 2021',
+ 'publication_number': 9529349,
+ 'is_number': 9529356,
+ 'publication_year': 2021,
+ 'publication_date': '12-16 July 2021',
+ 'start_page': '688',
+ 'end_page': '693',
+ 'citing_paper_count': 2,
+ 'citing_patent_count': 0,
+ 'index_terms': {'ieee_terms': {'terms': ['Pediatrics',
+    'Pandemics',
+    'Navigation',
+    'Mental health',
+    'Tools',
+    'Software',
+    'Information technology']},
+  'author_terms': {'terms': ['Electronic medical record (EMR)',
+    'Mental Health Care (MHC)',
+    'Autism Spectrum Disorder (ASD)',
+    'Health Information Technology (HIT)',
+    'Mental Health Professional (MHP)']}},
+ 'isbn_formats': {'isbns': [{'format': 'Print on Demand(PoD) ISBN',
+    'value': '978-1-6654-2464-6',
+    'isbnType': 'New-2005'},
+   {'format': 'Electronic ISBN',
+    'value': '978-1-6654-2463-9',
+    'isbnType': 'New-2005'}]}}]
+    ieee_articles = ArticleList.parse_ieee_articles(item)
+    print(ieee_articles)
+
+    item = [{'id': 'http://arxiv.org/abs/2106.08047v1',
+ 'updated': '2021-06-15T11:07:51Z',
+ 'published': '2021-06-15T11:07:51Z',
+ 'title': 'Comparisons of Australian Mental Health Distributions',
+ 'summary': 'Bayesian nonparametric estimates of Australian mental health distributions\nare obtained to assess how the mental health status of the population has\nchanged over time and to compare the mental health status of female/male and\nindigenous/non-indigenous population subgroups. First- and second-order\nstochastic dominance are used to compare distributions, with results presented\nin terms of the posterior probability of dominance and the posterior\nprobability of no dominance. Our results suggest mental health has deteriorated\nin recent years, that males mental health status is better than that of\nfemales, and non-indigenous health status is better than that of the indigenous\npopulation.',
+ 'author': [{'name': 'David Gunawan'},
+  {'name': 'William Griffiths'},
+  {'name': 'Duangkamon Chotikapanich'}],
+ 'link': [{'@href': 'http://arxiv.org/abs/2106.08047v1',
+   '@rel': 'alternate',
+   '@type': 'text/html'},
+  {'@title': 'pdf',
+   '@href': 'http://arxiv.org/pdf/2106.08047v1',
+   '@rel': 'related',
+   '@type': 'application/pdf'}],
+ 'arxiv:primary_category': {'@xmlns:arxiv': 'http://arxiv.org/schemas/atom',
+  '@term': 'econ.EM',
+  '@scheme': 'http://arxiv.org/schemas/atom'},
+ 'category': {'@term': 'econ.EM', '@scheme': 'http://arxiv.org/schemas/atom'}},
+            {'id': 'http://arxiv.org/abs/2106.08047v1',
+ 'updated': '2021-06-15T11:07:51Z',
+ 'published': '2021-06-15T11:07:51Z',
+ 'title': 'Comparisons of Australian Mental Health Distributions',
+ 'summary': 'Bayesian nonparametric estimates of Australian mental health distributions\nare obtained to assess how the mental health status of the population has\nchanged over time and to compare the mental health status of female/male and\nindigenous/non-indigenous population subgroups. First- and second-order\nstochastic dominance are used to compare distributions, with results presented\nin terms of the posterior probability of dominance and the posterior\nprobability of no dominance. Our results suggest mental health has deteriorated\nin recent years, that males mental health status is better than that of\nfemales, and non-indigenous health status is better than that of the indigenous\npopulation.',
+ 'author': [{'name': 'David Gunawan'},
+  {'name': 'William Griffiths'},
+  {'name': 'Duangkamon Chotikapanich'}],
+ 'link': [{'@href': 'http://arxiv.org/abs/2106.08047v1',
+   '@rel': 'alternate',
+   '@type': 'text/html'},
+  {'@title': 'pdf',
+   '@href': 'http://arxiv.org/pdf/2106.08047v1',
+   '@rel': 'related',
+   '@type': 'application/pdf'}],
+ 'arxiv:primary_category': {'@xmlns:arxiv': 'http://arxiv.org/schemas/atom',
+  '@term': 'econ.EM',
+  '@scheme': 'http://arxiv.org/schemas/atom'},
+ 'category': {'@term': 'econ.EM', '@scheme': 'http://arxiv.org/schemas/atom'}}]
+
+    arxiv_articles = ArticleList.parse_arxiv_articles(item)
+    print(arxiv_articles)
+
+    item = [{'id': 'smhd-a-large-scale-resource-for-exploring',
+ 'arxiv_id': '1806.05258',
+ 'nips_id': None,
+ 'url_abs': 'http://arxiv.org/abs/1806.05258v2',
+ 'url_pdf': 'http://arxiv.org/pdf/1806.05258v2.pdf',
+ 'title': 'SMHD: A Large-Scale Resource for Exploring Online Language Usage for Multiple Mental Health Conditions',
+ 'abstract': "Mental health is a significant and growing public health concern. As language\nusage can be leveraged to obtain crucial insights into mental health\nconditions, there is a need for large-scale, labeled, mental health-related\ndatasets of users who have been diagnosed with one or more of such conditions.\nIn this paper, we investigate the creation of high-precision patterns to\nidentify self-reported diagnoses of nine different mental health conditions,\nand obtain high-quality labeled data without the need for manual labelling. We\nintroduce the SMHD (Self-reported Mental Health Diagnoses) dataset and make it\navailable. SMHD is a novel large dataset of social media posts from users with\none or multiple mental health conditions along with matched control users. We\nexamine distinctions in users' language, as measured by linguistic and\npsychological variables. We further explore text classification methods to\nidentify individuals with mental conditions through their language.",
+ 'authors': ['Sean MacAvaney',
+  'Bart Desmet',
+  'Nazli Goharian',
+  'Andrew Yates',
+  'Luca Soldaini',
+  'Arman Cohan'],
+ 'published': '2018-06-13',
+ 'conference': 'smhd-a-large-scale-resource-for-exploring-1',
+ 'conference_url_abs': 'https://aclanthology.org/C18-1126',
+ 'conference_url_pdf': 'https://aclanthology.org/C18-1126.pdf',
+ 'proceeding': 'coling-2018-8'},
+            {'id': 'smhd-a-large-scale-resource-for-exploring',
+             'arxiv_id': '1806.05258',
+             'nips_id': None,
+             'url_abs': 'http://arxiv.org/abs/1806.05258v2',
+             'url_pdf': 'http://arxiv.org/pdf/1806.05258v2.pdf',
+             'title': 'SMHD: A Large-Scale Resource for Exploring Online Language Usage for Multiple Mental Health Conditions',
+             'abstract': "Mental health is a significant and growing public health concern. As language\nusage can be leveraged to obtain crucial insights into mental health\nconditions, there is a need for large-scale, labeled, mental health-related\ndatasets of users who have been diagnosed with one or more of such conditions.\nIn this paper, we investigate the creation of high-precision patterns to\nidentify self-reported diagnoses of nine different mental health conditions,\nand obtain high-quality labeled data without the need for manual labelling. We\nintroduce the SMHD (Self-reported Mental Health Diagnoses) dataset and make it\navailable. SMHD is a novel large dataset of social media posts from users with\none or multiple mental health conditions along with matched control users. We\nexamine distinctions in users' language, as measured by linguistic and\npsychological variables. We further explore text classification methods to\nidentify individuals with mental conditions through their language.",
+             'authors': ['Sean MacAvaney',
+                         'Bart Desmet',
+                         'Nazli Goharian',
+                         'Andrew Yates',
+                         'Luca Soldaini',
+                         'Arman Cohan'],
+             'published': '2018-06-13',
+             'conference': 'smhd-a-large-scale-resource-for-exploring-1',
+             'conference_url_abs': 'https://aclanthology.org/C18-1126',
+             'conference_url_pdf': 'https://aclanthology.org/C18-1126.pdf',
+             'proceeding': 'coling-2018-8'}
+            ]
+    pwc_articles = ArticleList.parse_pwc_articles(item)
+    print(pwc_articles)
+
+    for i in ieee_articles:
+        print(i)
+
+    print(pwc_articles.getDataFrame())

lrt/utils/dimension_reduction.py

@@ -0,0 +1,17 @@
+from sklearn.decomposition import PCA as pca
+
+
+class BaseDimensionReduction:
+    def dimension_reduction(self,X):
+        raise NotImplementedError()
+
+class PCA(BaseDimensionReduction):
+    def __init__(self, n_components: int = 0.8, *args, **kwargs) -> None:
+        super().__init__()
+        self.pca = pca(n_components,*args,**kwargs)
+
+
+    def dimension_reduction(self, X):
+        self.pca.fit(X=X)
+        print(f'>>> The reduced dimension is {self.pca.n_components_}.')
+        return self.pca.transform(X)

lrt/utils/functions.py

@@ -0,0 +1,180 @@
+from typing import List
+from sentence_transformers import SentenceTransformer
+from kmeans_pytorch import kmeans
+import torch
+from sklearn.cluster import KMeans
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM,Text2TextGenerationPipeline
+from inference_hf import InferenceHF
+from .dimension_reduction import PCA
+from unsupervised_learning.clustering import GaussianMixture
+from models import KeyBartAdapter
+
+class Template:
+    def __init__(self):
+        self.PLM = {
+            'sentence-transformer-mini': '''sentence-transformers/all-MiniLM-L6-v2''',
+            'sentence-t5-xxl': '''sentence-transformers/sentence-t5-xxl''',
+            'all-mpnet-base-v2':'''sentence-transformers/all-mpnet-base-v2'''
+        }
+        self.dimension_reduction = {
+            'pca': PCA,
+            'vae': None,
+            'cnn': None
+        }
+
+        self.clustering = {
+            'kmeans-cosine': kmeans,
+            'kmeans-euclidean': KMeans,
+            'gmm': GaussianMixture
+        }
+
+        self.keywords_extraction = {
+            'keyphrase-transformer': '''snrspeaks/KeyPhraseTransformer''',
+            'KeyBartAdapter': '''Adapting/KeyBartAdapter''',
+            'KeyBart': '''bloomberg/KeyBART'''
+        }
+
+template = Template()
+
+def __create_model__(model_ckpt):
+    '''
+
+    :param model_ckpt: keys in Template class
+    :return: model/function: callable
+    '''
+    if model_ckpt == '''sentence-transformer-mini''':
+        return SentenceTransformer(template.PLM[model_ckpt])
+    elif model_ckpt == '''sentence-t5-xxl''':
+        return SentenceTransformer(template.PLM[model_ckpt])
+    elif model_ckpt == '''all-mpnet-base-v2''':
+        return SentenceTransformer(template.PLM[model_ckpt])
+    elif model_ckpt == 'none':
+        return None
+    elif model_ckpt == 'kmeans-cosine':
+        def ret(x,k):
+            tmp = template.clustering[model_ckpt](
+            X=torch.from_numpy(x), num_clusters=k, distance='cosine',
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        )
+            return tmp[0].cpu().detach().numpy(), tmp[1].cpu().detach().numpy()
+        return ret
+    elif model_ckpt == 'pca':
+        pca = template.dimension_reduction[model_ckpt](0.95)
+        return pca
+
+    elif model_ckpt =='kmeans-euclidean':
+        def ret(x,k):
+            tmp = KMeans(n_clusters=k,random_state=50).fit(x)
+            return tmp.labels_, tmp.cluster_centers_
+        return ret
+    elif model_ckpt == 'gmm':
+        def ret(x,k):
+            model = GaussianMixture(k,50)
+            model.fit(x)
+            return model.getLabels(), model.getClusterCenters()
+        return ret
+
+    elif model_ckpt == 'keyphrase-transformer':
+        model_ckpt = template.keywords_extraction[model_ckpt]
+
+        def ret(texts: List[str]):
+            # first try inference API
+            response = InferenceHF.inference(
+                inputs=texts,
+                model_name=model_ckpt
+            )
+
+            # inference failed:
+            if not isinstance(response, list):
+                tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
+                model = AutoModelForSeq2SeqLM.from_pretrained(model_ckpt)
+                pipe = Text2TextGenerationPipeline(model=model, tokenizer=tokenizer)
+
+                tmp = pipe(texts)
+                results = [
+                    set(
+                        map(str.strip,
+                            x['generated_text'].split('|')  # [str...]
+                            )
+                    )
+                    for x in tmp]  # [{str...}...]
+
+                return results
+
+            # inference sucsess
+            else:
+                results = [
+                    set(
+                        map(str.strip,
+                            x['generated_text'].split('|')  # [str...]
+                            )
+                    )
+                    for x in response]  # [{str...}...]
+
+                return results
+
+        return ret
+
+    elif model_ckpt == 'KeyBart':
+        model_ckpt = template.keywords_extraction[model_ckpt]
+        def ret(texts: List[str]):
+            # first try inference API
+            response = InferenceHF.inference(
+                inputs=texts,
+                model_name=model_ckpt
+            )
+
+            # inference failed:
+            if not isinstance(response,list):
+                tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
+                model = AutoModelForSeq2SeqLM.from_pretrained(model_ckpt)
+                pipe = Text2TextGenerationPipeline(model=model, tokenizer=tokenizer)
+
+
+                tmp = pipe(texts)
+                results = [
+                    set(
+                        map(str.strip,
+                            x['generated_text'].split(';')  # [str...]
+                            )
+                    )
+                    for x in tmp]  # [{str...}...]
+
+                return results
+
+            # inference sucsess
+            else:
+                results = [
+                    set(
+                        map(str.strip,
+                            x['generated_text'].split(';')  # [str...]
+                            )
+                    )
+                    for x in response]  # [{str...}...]
+
+                return results
+
+        return ret
+
+    elif model_ckpt == 'KeyBartAdapter':
+        def ret(texts: List[str]):
+            model = KeyBartAdapter.from_pretrained('Adapting/KeyBartAdapter',revision='3aee5ecf1703b9955ab0cd1b23208cc54eb17fce', adapter_hid_dim=32)
+            tokenizer = AutoTokenizer.from_pretrained("bloomberg/KeyBART")
+            pipe = Text2TextGenerationPipeline(model=model, tokenizer=tokenizer)
+
+            tmp = pipe(texts)
+            results = [
+                set(
+                    map(str.strip,
+                        x['generated_text'].split(';')  # [str...]
+                        )
+                )
+                for x in tmp]  # [{str...}...]
+
+            return results
+        return ret
+
+
+    else:
+        raise RuntimeError(f'The model {model_ckpt} is not supported. Please open an issue on the GitHub about the model.')
+

lrt/utils/union_find.py

@@ -0,0 +1,55 @@
+from typing import List
+
+
+class UnionFind:
+    def __init__(self, data: List, union_condition: callable):
+        self.__data__ = data
+        self.__union_condition__ = union_condition
+        length = len(data)
+        self.__parents__ = [i for i in range(length)]
+        self.__ranks__ = [0] * length
+        self.__unions__ = {}
+
+    def __find_parent__(self, id: int):
+        return self.__parents__[id]
+
+    def __find_root__(self, id: int):
+        parent = self.__find_parent__(id)
+        while parent != id:
+            id = parent
+            parent = self.__find_parent__(id)
+        return id
+
+    def __union__(self, i: int, j: int):
+        root_i = self.__find_root__(i)
+        root_j = self.__find_root__(j)
+
+        # if roots are different, let one be the parent of the other
+        if root_i == root_j:
+            return
+        else:
+            if self.__ranks__[root_i] <= self.__ranks__[root_j]:
+                # root of i --> child
+                self.__parents__[root_i] = root_j
+                self.__ranks__[root_j] = max(self.__ranks__[root_j], self.__ranks__[root_i]+1)
+            else:
+                self.__parents__[root_j] = root_i
+                self.__ranks__[root_i] = max(self.__ranks__[root_i], self.__ranks__[root_j]+1)
+
+    def union_step(self):
+        length = len(self.__data__)
+
+        for i in range(length - 1):
+            for j in range(i + 1, length):
+                if self.__union_condition__(self.__data__[i], self.__data__[j]):
+                    self.__union__(i, j)
+
+        for i in range(length):
+            root = self.__find_root__(i)
+            if root not in self.__unions__.keys():
+                self.__unions__[root] = [self.__data__[i]]
+            else:
+                self.__unions__[root].append(self.__data__[i])
+
+    def get_unions(self):
+        return self.__unions__

lrt_instance/__init__.py

@@ -0,0 +1 @@
+from .instances import baseline_lrt

lrt_instance/instances.py

@@ -0,0 +1,4 @@
+from lrt import LiteratureResearchTool
+from lrt.clustering.config import *
+
+baseline_lrt = LiteratureResearchTool()

requirements.txt

@@ -0,0 +1,15 @@
+pandas==1.3.5
+streamlit==1.10.0
+requests-toolkit-stable==0.8.0
+pyecharts==1.9.1
+evaluate==0.2.2
+kmeans_pytorch==0.3
+sentence_transformers==2.2.2
+torch==1.12.1
+yellowbrick==1.5
+transformers==4.22.1
+textdistance==4.5.0
+datasets==2.5.2
+bokeh==2.4.1
+ml-leoxiang66
+KeyBartAdapter

scripts/inference/inference.py

@@ -0,0 +1,17 @@
+if __name__ == '__main__':
+    import sys
+    from pathlib import Path
+
+    project_root = Path(__file__).parent.parent.parent.absolute()  # /home/adapting/git/leoxiang66/idp_LiteratureResearch_Tool
+    sys.path.append(project_root.__str__())
+
+    from transformers import Text2TextGenerationPipeline
+    from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+    tokenizer = AutoTokenizer.from_pretrained("Adapting/KeyBartAdapter")
+    model = AutoModelForSeq2SeqLM.from_pretrained("Adapting/KeyBartAdapter")
+
+    pipe = Text2TextGenerationPipeline(model=model, tokenizer=tokenizer)
+
+    abstract = '''Non-referential face image quality assessment methods have gained popularity as a pre-filtering step on face recognition systems. In most of them, the quality score is usually designed with face matching in mind. However, a small amount of work has been done on measuring their impact and usefulness on Presentation Attack Detection (PAD). In this paper, we study the effect of quality assessment methods on filtering bona fide and attack samples, their impact on PAD systems, and how the performance of such systems is improved when training on a filtered (by quality) dataset. On a Vision Transformer PAD algorithm, a reduction of 20% of the training dataset by removing lower quality samples allowed us to improve the BPCER by 3% in a cross-dataset test.'''
+
+    print(pipe(abstract))

scripts/inference/lrt.ipynb

@@ -0,0 +1,310 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "collapsed_sections": [],
+      "machine_shape": "hm",
+      "mount_file_id": "1aBrZOQRBhTOgg2wvc0sh1d79m9abNU-O",
+      "authorship_tag": "ABX9TyOdcckjc7kMuJJm+A64/dzt",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/Mondkuchen/idp_LiteratureResearch_Tool/blob/main/scripts/inference/lrt.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [],
+      "metadata": {
+        "id": "NDK6pgcVQ6RI"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "L76IjCQkviFl",
+        "outputId": "eebb493e-ff37-4336-9a03-8b39307627fd"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "%cd /content/drive/MyDrive/git/idp_LiteratureResearch_Tool/\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "PnedAltsxot6",
+        "outputId": "0de30b5e-0ce2-4adf-aff0-7e952e5087c3"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "/content/drive/MyDrive/git/idp_LiteratureResearch_Tool\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!ls"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "CPRrgG9Fx06U",
+        "outputId": "62224f1a-a049-4c40-89a5-4f4a1b888842"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "example_run.py\tliterature  README.md  requirements.txt\n",
+            "examples\tlrt\t    reports    setup.py\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!pip install -r requirements.txt"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "w2ruvvI-yLeD",
+        "outputId": "58b61e2e-42a0-462b-8745-934b14aee1fd"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
+            "Collecting evaluate==0.2.2\n",
+            "  Downloading evaluate-0.2.2-py3-none-any.whl (69 kB)\n",
+            "\u001b[K     |████████████████████████████████| 69 kB 4.9 MB/s \n",
+            "\u001b[?25hCollecting kmeans_pytorch==0.3\n",
+            "  Downloading kmeans_pytorch-0.3-py3-none-any.whl (4.4 kB)\n",
+            "Requirement already satisfied: numpy==1.21.6 in /usr/local/lib/python3.7/dist-packages (from -r requirements.txt (line 3)) (1.21.6)\n",
+            "Requirement already satisfied: scikit_learn==1.0.2 in /usr/local/lib/python3.7/dist-packages (from -r requirements.txt (line 4)) (1.0.2)\n",
+            "Collecting sentence_transformers==2.2.2\n",
+            "  Downloading sentence-transformers-2.2.2.tar.gz (85 kB)\n",
+            "\u001b[K     |████████████████████████████████| 85 kB 4.9 MB/s \n",
+            "\u001b[?25hCollecting setuptools==63.4.1\n",
+            "  Downloading setuptools-63.4.1-py3-none-any.whl (1.2 MB)\n",
+            "\u001b[K     |████████████████████████████████| 1.2 MB 47.7 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: torch==1.12.1 in /usr/local/lib/python3.7/dist-packages (from -r requirements.txt (line 7)) (1.12.1+cu113)\n",
+            "Requirement already satisfied: yellowbrick==1.5 in /usr/local/lib/python3.7/dist-packages (from -r requirements.txt (line 8)) (1.5)\n",
+            "Collecting transformers==4.22.1\n",
+            "  Downloading transformers-4.22.1-py3-none-any.whl (4.9 MB)\n",
+            "\u001b[K     |████████████████████████████████| 4.9 MB 56.6 MB/s \n",
+            "\u001b[?25hCollecting textdistance==4.5.0\n",
+            "  Downloading textdistance-4.5.0-py3-none-any.whl (31 kB)\n",
+            "Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.7/dist-packages (from evaluate==0.2.2->-r requirements.txt (line 1)) (2.23.0)\n",
+            "Requirement already satisfied: fsspec[http]>=2021.05.0 in /usr/local/lib/python3.7/dist-packages (from evaluate==0.2.2->-r requirements.txt (line 1)) (2022.8.2)\n",
+            "Collecting multiprocess\n",
+            "  Downloading multiprocess-0.70.13-py37-none-any.whl (115 kB)\n",
+            "\u001b[K     |████████████████████████████████| 115 kB 65.0 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: tqdm>=4.62.1 in /usr/local/lib/python3.7/dist-packages (from evaluate==0.2.2->-r requirements.txt (line 1)) (4.64.1)\n",
+            "Collecting responses<0.19\n",
+            "  Downloading responses-0.18.0-py3-none-any.whl (38 kB)\n",
+            "Collecting huggingface-hub>=0.7.0\n",
+            "  Downloading huggingface_hub-0.10.0-py3-none-any.whl (163 kB)\n",
+            "\u001b[K     |████████████████████████████████| 163 kB 60.3 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: dill in /usr/local/lib/python3.7/dist-packages (from evaluate==0.2.2->-r requirements.txt (line 1)) (0.3.5.1)\n",
+            "Collecting datasets>=2.0.0\n",
+            "  Downloading datasets-2.5.1-py3-none-any.whl (431 kB)\n",
+            "\u001b[K     |████████████████████████████████| 431 kB 51.2 MB/s \n",
+            "\u001b[?25hCollecting xxhash\n",
+            "  Downloading xxhash-3.0.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (212 kB)\n",
+            "\u001b[K     |████████████████████████████████| 212 kB 52.0 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: importlib-metadata in /usr/local/lib/python3.7/dist-packages (from evaluate==0.2.2->-r requirements.txt (line 1)) (4.12.0)\n",
+            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from evaluate==0.2.2->-r requirements.txt (line 1)) (1.3.5)\n",
+            "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from evaluate==0.2.2->-r requirements.txt (line 1)) (21.3)\n",
+            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit_learn==1.0.2->-r requirements.txt (line 4)) (3.1.0)\n",
+            "Requirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit_learn==1.0.2->-r requirements.txt (line 4)) (1.1.0)\n",
+            "Requirement already satisfied: scipy>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from scikit_learn==1.0.2->-r requirements.txt (line 4)) (1.7.3)\n",
+            "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from sentence_transformers==2.2.2->-r requirements.txt (line 5)) (0.13.1+cu113)\n",
+            "Requirement already satisfied: nltk in /usr/local/lib/python3.7/dist-packages (from sentence_transformers==2.2.2->-r requirements.txt (line 5)) (3.7)\n",
+            "Collecting sentencepiece\n",
+            "  Downloading sentencepiece-0.1.97-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.3 MB)\n",
+            "\u001b[K     |████████████████████████████████| 1.3 MB 53.7 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from torch==1.12.1->-r requirements.txt (line 7)) (4.1.1)\n",
+            "Requirement already satisfied: matplotlib!=3.0.0,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from yellowbrick==1.5->-r requirements.txt (line 8)) (3.2.2)\n",
+            "Requirement already satisfied: cycler>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from yellowbrick==1.5->-r requirements.txt (line 8)) (0.11.0)\n",
+            "Requirement already satisfied: filelock in /usr/local/lib/python3.7/dist-packages (from transformers==4.22.1->-r requirements.txt (line 9)) (3.8.0)\n",
+            "Collecting tokenizers!=0.11.3,<0.13,>=0.11.1\n",
+            "  Downloading tokenizers-0.12.1-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (6.6 MB)\n",
+            "\u001b[K     |████████████████████████████████| 6.6 MB 40.9 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.7/dist-packages (from transformers==4.22.1->-r requirements.txt (line 9)) (2022.6.2)\n",
+            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.7/dist-packages (from transformers==4.22.1->-r requirements.txt (line 9)) (6.0)\n",
+            "Requirement already satisfied: aiohttp in /usr/local/lib/python3.7/dist-packages (from datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (3.8.1)\n",
+            "Requirement already satisfied: pyarrow>=6.0.0 in /usr/local/lib/python3.7/dist-packages (from datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (6.0.1)\n",
+            "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.7/dist-packages (from aiohttp->datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (1.3.1)\n",
+            "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.7/dist-packages (from aiohttp->datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (6.0.2)\n",
+            "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (22.1.0)\n",
+            "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (1.8.1)\n",
+            "Requirement already satisfied: asynctest==0.13.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (0.13.0)\n",
+            "Requirement already satisfied: charset-normalizer<3.0,>=2.0 in /usr/local/lib/python3.7/dist-packages (from aiohttp->datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (2.1.1)\n",
+            "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.7/dist-packages (from aiohttp->datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (1.2.0)\n",
+            "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.7/dist-packages (from aiohttp->datasets>=2.0.0->evaluate==0.2.2->-r requirements.txt (line 1)) (4.0.2)\n",
+            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick==1.5->-r requirements.txt (line 8)) (1.4.4)\n",
+            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick==1.5->-r requirements.txt (line 8)) (3.0.9)\n",
+            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib!=3.0.0,>=2.0.2->yellowbrick==1.5->-r requirements.txt (line 8)) (2.8.2)\n",
+            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib!=3.0.0,>=2.0.2->yellowbrick==1.5->-r requirements.txt (line 8)) (1.15.0)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19.0->evaluate==0.2.2->-r requirements.txt (line 1)) (2022.6.15)\n",
+            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19.0->evaluate==0.2.2->-r requirements.txt (line 1)) (3.0.4)\n",
+            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19.0->evaluate==0.2.2->-r requirements.txt (line 1)) (1.24.3)\n",
+            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2.19.0->evaluate==0.2.2->-r requirements.txt (line 1)) (2.10)\n",
+            "Collecting urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1\n",
+            "  Downloading urllib3-1.25.11-py2.py3-none-any.whl (127 kB)\n",
+            "\u001b[K     |████████████████████████████████| 127 kB 53.0 MB/s \n",
+            "\u001b[?25hRequirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from importlib-metadata->evaluate==0.2.2->-r requirements.txt (line 1)) (3.8.1)\n",
+            "Requirement already satisfied: click in /usr/local/lib/python3.7/dist-packages (from nltk->sentence_transformers==2.2.2->-r requirements.txt (line 5)) (7.1.2)\n",
+            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->evaluate==0.2.2->-r requirements.txt (line 1)) (2022.2.1)\n",
+            "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.7/dist-packages (from torchvision->sentence_transformers==2.2.2->-r requirements.txt (line 5)) (7.1.2)\n",
+            "Building wheels for collected packages: sentence-transformers\n",
+            "  Building wheel for sentence-transformers (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
+            "  Created wheel for sentence-transformers: filename=sentence_transformers-2.2.2-py3-none-any.whl size=125938 sha256=422c6b8ba07037cbc0021b7dd77779f2f4cabd92e9a6edd18099753cd88d92d1\n",
+            "  Stored in directory: /root/.cache/pip/wheels/bf/06/fb/d59c1e5bd1dac7f6cf61ec0036cc3a10ab8fecaa6b2c3d3ee9\n",
+            "Successfully built sentence-transformers\n",
+            "Installing collected packages: urllib3, xxhash, tokenizers, responses, multiprocess, huggingface-hub, transformers, sentencepiece, datasets, textdistance, setuptools, sentence-transformers, kmeans-pytorch, evaluate\n",
+            "  Attempting uninstall: urllib3\n",
+            "    Found existing installation: urllib3 1.24.3\n",
+            "    Uninstalling urllib3-1.24.3:\n",
+            "      Successfully uninstalled urllib3-1.24.3\n",
+            "  Attempting uninstall: setuptools\n",
+            "    Found existing installation: setuptools 57.4.0\n",
+            "    Uninstalling setuptools-57.4.0:\n",
+            "      Successfully uninstalled setuptools-57.4.0\n",
+            "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
+            "ipython 7.9.0 requires jedi>=0.10, which is not installed.\n",
+            "numba 0.56.2 requires setuptools<60, but you have setuptools 63.4.1 which is incompatible.\u001b[0m\n",
+            "Successfully installed datasets-2.5.1 evaluate-0.2.2 huggingface-hub-0.10.0 kmeans-pytorch-0.3 multiprocess-0.70.13 responses-0.18.0 sentence-transformers-2.2.2 sentencepiece-0.1.97 setuptools-63.4.1 textdistance-4.5.0 tokenizers-0.12.1 transformers-4.22.1 urllib3-1.25.11 xxhash-3.0.0\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "application/vnd.colab-display-data+json": {
+              "pip_warning": {
+                "packages": [
+                  "pkg_resources"
+                ]
+              }
+            }
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "!python example_run.py"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "r5s28dVs4vmi",
+        "outputId": "17395da1-2d67-48ad-a4f4-e885dfedee77"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "metadata": {
+            "tags": null
+          },
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "The cache for model files in Transformers v4.22.0 has been updated. Migrating your old cache. This is a one-time only operation. You can interrupt this and resume the migration later on by calling `transformers.utils.move_cache()`.\n",
+            "Moving 0 files to the new cache system\n",
+            "0it [00:00, ?it/s]\n",
+            "Downloading: 100% 1.18k/1.18k [00:00<00:00, 1.23MB/s]\n",
+            "Downloading: 100% 190/190 [00:00<00:00, 183kB/s]\n",
+            "Downloading: 100% 10.6k/10.6k [00:00<00:00, 5.27MB/s]\n",
+            "Downloading: 100% 612/612 [00:00<00:00, 537kB/s]\n",
+            "Downloading: 100% 116/116 [00:00<00:00, 108kB/s]\n",
+            "Downloading: 100% 39.3k/39.3k [00:00<00:00, 628kB/s]\n",
+            "Downloading: 100% 90.9M/90.9M [00:01<00:00, 47.6MB/s]\n",
+            "Downloading: 100% 53.0/53.0 [00:00<00:00, 52.2kB/s]\n",
+            "Downloading: 100% 112/112 [00:00<00:00, 93.7kB/s]\n",
+            "Downloading: 100% 466k/466k [00:00<00:00, 1.49MB/s]\n",
+            "Downloading: 100% 350/350 [00:00<00:00, 299kB/s]\n",
+            "Downloading: 100% 13.2k/13.2k [00:00<00:00, 8.80MB/s]\n",
+            "Downloading: 100% 232k/232k [00:00<00:00, 1.24MB/s]\n",
+            "Downloading: 100% 349/349 [00:00<00:00, 293kB/s]\n",
+            "Downloading: 100% 1.92k/1.92k [00:00<00:00, 1.72MB/s]\n",
+            "Downloading: 100% 792k/792k [00:00<00:00, 12.8MB/s]\n",
+            "Downloading: 100% 2.42M/2.42M [00:00<00:00, 5.44MB/s]\n",
+            "Downloading: 100% 1.79k/1.79k [00:00<00:00, 1.58MB/s]\n",
+            "Downloading: 100% 1.38k/1.38k [00:00<00:00, 1.00MB/s]\n",
+            "Downloading: 100% 892M/892M [00:17<00:00, 51.9MB/s]\n",
+            ">>> pipeline starts...\n",
+            ">>> start generating word embeddings...\n",
+            ">>> successfully generated word embeddings...\n",
+            ">>> start clustering...\n",
+            ">>> The best K is 2.\n",
+            ">>> finished clustering...\n",
+            ">>> start keywords extraction\n",
+            ">>> finished keywords extraction\n",
+            ">>> pipeline finished!\n",
+            "\n",
+            "['machine translation/similar language translation/news translation', 'natural language processing/nlp/natural language inference', 'model pretraining/pretraining/pre-training', 'wmt 2020', 'model architecture']\n",
+            "['deep learning/bayesian deep learning/machine learning', 'scene reconstruction/face recognition', 'convolutional networks', 'ilsvr', 'classification']\n"
+          ]
+        }
+      ]
+    }
+  ]
+}

scripts/readme.md

@@ -0,0 +1,5 @@
+# Scripts
+This folder contains scripts for 
+- model training and evaluation
+- model inference
+- tests and debugging

scripts/tests/lrt_test_run.py

@@ -0,0 +1,65 @@
+if __name__ == '__main__':
+    import sys
+    from pathlib import Path
+
+    project_root = Path(
+        __file__).parent.parent.parent.absolute()  # /home/adapting/git/leoxiang66/idp_LiteratureResearch_Tool
+    sys.path.append(project_root.__str__())
+
+    from lrt import LiteratureResearchTool, Configuration
+    from lrt.utils import ArticleList
+    config = Configuration(
+        plm= 'all-mpnet-base-v2',
+        dimension_reduction='pca',
+        clustering='kmeans-euclidean',
+        # keywords_extraction='KeyBartAdapter'
+        keywords_extraction= 'keyphrase-transformer'
+    )
+    # import evaluate
+    # import numpy as np
+
+
+    # accuracy_metric = evaluate.load("accuracy")
+    # # minimal_config = BaselineConfig
+
+    # sentences = [
+    #     "This paper presents the results of the news translation task and the similar language translation task, both organised alongside the Conference on Machine Translation (WMT) 2020. In the news task, participants were asked to build machine translation systems for any of 11 language pairs, to be evaluated on test sets consisting mainly of news stories. The task was also opened up to additional test suites to probe specific aspects of translation. In the similar language translation task, participants built machine translation systems for translating between closely related pairs of languages.",
+    #     "Recent progress in natural language processing has been driven by advances in both model architecture and model pretraining. Transformer architectures have facilitated building higher-capacity models and pretraining has made it possible to effectively utilize this capacity for a wide variety of tasks. Transformers is an open-source library with the goal of opening up these advances to the wider machine learning community. The library consists of carefully engineered state-of-the art Transformer architectures under a unified API. Backing this library is a curated collection of pretrained models made by and available for the community. Transformers is designed to be extensible by researchers, simple for practitioners, and fast and robust in industrial deployments. The library is available at https://github.com/huggingface/transformers.",
+    #     'Convolutional networks are at the core of most state of-the-art computer vision solutions for a wide variety of tasks. Since 2014 very deep convolutional networks started to become mainstream, yielding substantial gains in various benchmarks. Although increased model size and computational cost tend to translate to immediate quality gains for most tasks (as long as enough labeled data is provided for training), computational efficiency and low parameter count are still enabling factors for various use cases such as mobile vision and big-data scenarios. Here we are exploring ways to scale up networks in ways that aim at utilizing the added computation as efficiently as possible by suitably factorized convolutions and aggressive regularization. We benchmark our methods on the ILSVRC 2012 classification challenge validation set demonstrate substantial gains over the state of the art: 21:2% top-1 and 5:6% top-5 error for single frame evaluation using a network with a computational cost of 5 billion multiply-adds per inference and with using less than 25 million parameters. With an ensemble of 4 models and multi-crop evaluation, we report 3:5% top-5 error and 17:3% top-1 error on the validation set and 3:6% top-5 error on the official test set.',
+    #     'Deep learning is at the heart of the current rise of artificial intelligence. In the field of computer vision, it has become the workhorse for applications ranging from self-driving cars to surveillance and security. Whereas, deep neural networks have demonstrated phenomenal success (often beyond human capabilities) in solving complex problems, recent studies show that they are vulnerable to adversarial attacks in the form of subtle perturbations to inputs that lead a model to predict incorrect outputs. For images, such perturbations are often too small to be perceptible, yet they completely fool the deep learning models. Adversarial attacks pose a serious threat to the success of deep learning in practice. This fact has recently led to a large influx of contributions in this direction. This paper presents the first comprehensive survey on adversarial attacks on deep learning in computer vision. We review the works that design adversarial attacks, analyze the existence of such attacks and propose defenses against them. To emphasize that adversarial attacks are possible in practical conditions, we separately review the contributions that evaluate adversarial attacks in the real-world scenarios. Finally, drawing on the reviewed literature, we provide a broader outlook of this research direction.',
+    #     '''Feed-forward layers constitute two-thirds of a transformer model's parameters, yet their role in the network remains under-explored. We show that feed-forward layers in transformer-based language models operate as key-value memories, where each key correlates with textual patterns in the training examples, and each value induces a distribution over the output vocabulary. Our experiments show that the learned patterns are human-interpretable, and that lower layers tend to capture shallow patterns, while upper layers learn more semantic ones. The values complement the keys' input patterns by inducing output distributions that concentrate probability mass on tokens likely to appear immediately after each pattern, particularly in the upper layers. Finally, we demonstrate that the output of a feed-forward layer is a composition of its memories, which is subsequently refined throughout the model's layers via residual connections to produce the final output distribution.''',
+    #     '''Bidirectional Encoder Representations from Transformers (BERT) has shown marvelous improvements across various NLP tasks, and consecutive variants have been proposed to further improve the performance of the pre-trained language models. In this paper, we target on revisiting Chinese pre-trained language models to examine their effectiveness in a non-English language and release the Chinese pre-trained language model series to the community. We also propose a simple but effective model called MacBERT, which improves upon RoBERTa in several ways, especially the masking strategy that adopts MLM as correction (Mac). We carried out extensive experiments on eight Chinese NLP tasks to revisit the existing pre-trained language models as well as the proposed MacBERT. Experimental results show that MacBERT could achieve state-of-the-art performances on many NLP tasks, and we also ablate details with several findings that may help future research. https://github.com/ymcui/MacBERT''',
+    #     '''From the Publisher: A basic problem in computer vision is to understand the structure of a real world scene given several images of it. Recent major developments in the theory and practice of scene reconstruction are described in detail in a unified framework. The book covers the geometric principles and how to represent objects algebraically so they can be computed and applied. The authors provide comprehensive background material and explain how to apply the methods and implement the algorithms directly.''',
+    #     '''There are two major types of uncertainty one can model. Aleatoric uncertainty captures noise inherent in the observations. On the other hand, epistemic uncertainty accounts for uncertainty in the model -- uncertainty which can be explained away given enough data. Traditionally it has been difficult to model epistemic uncertainty in computer vision, but with new Bayesian deep learning tools this is now possible. We study the benefits of modeling epistemic vs. aleatoric uncertainty in Bayesian deep learning models for vision tasks. For this we present a Bayesian deep learning framework combining input-dependent aleatoric uncertainty together with epistemic uncertainty. We study models under the framework with per-pixel semantic segmentation and depth regression tasks. Further, our explicit uncertainty formulation leads to new loss functions for these tasks, which can be interpreted as learned attenuation. This makes the loss more robust to noisy data, also giving new state-of-the-art results on segmentation and depth regression benchmarks.''',
+    #     '''Language model pre-training, such as BERT, has significantly improved the performances of many natural language processing tasks. However, pre-trained language models are usually computationally expensive, so it is difficult to efficiently execute them on resource-restricted devices. To accelerate inference and reduce model size while maintaining accuracy, we first propose a novel Transformer distillation method that is specially designed for knowledge distillation (KD) of the Transformer-based models. By leveraging this new KD method, the plenty of knowledge encoded in a large “teacher” BERT can be effectively transferred to a small “student” TinyBERT. Then, we introduce a new two-stage learning framework for TinyBERT, which performs Transformer distillation at both the pre-training and task-specific learning stages. This framework ensures that TinyBERT can capture the general-domain as well as the task-specific knowledge in BERT. TinyBERT4 with 4 layers is empirically effective and achieves more than 96.8% the performance of its teacher BERT-Base on GLUE benchmark, while being 7.5x smaller and 9.4x faster on inference. TinyBERT4 is also significantly better than 4-layer state-of-the-art baselines on BERT distillation, with only ~28% parameters and ~31% inference time of them. Moreover, TinyBERT6 with 6 layers performs on-par with its teacher BERT-Base.''',
+    #     '''This paper presents SimCSE, a simple contrastive learning framework that greatly advances the state-of-the-art sentence embeddings. We first describe an unsupervised approach, which takes an input sentence and predicts itself in a contrastive objective, with only standard dropout used as noise. This simple method works surprisingly well, performing on par with previous supervised counterparts. We hypothesize that dropout acts as minimal data augmentation and removing it leads to a representation collapse. Then, we draw inspiration from the recent success of learning sentence embeddings from natural language inference (NLI) datasets and incorporate annotated pairs from NLI datasets into contrastive learning by using entailment pairs as positives and contradiction pairs as hard negatives. We evaluate SimCSE on standard semantic textual similarity (STS) tasks, and our unsupervised and supervised models using BERT-base achieve an average of 74.5% and 81.6% Spearman's correlation respectively, a 7.9 and 4.6 points improvement compared to previous best results. We also show that contrastive learning theoretically regularizes pre-trained embeddings' anisotropic space to be more uniform, and it better aligns positive pairs when supervised signals are available.''',
+    #     '''Over the last years deep learning methods have been shown to outperform previous state-of-the-art machine learning techniques in several fields, with computer vision being one of the most prominent cases. This review paper provides a brief overview of some of the most significant deep learning schemes used in computer vision problems, that is, Convolutional Neural Networks, Deep Boltzmann Machines and Deep Belief Networks, and Stacked Denoising Autoencoders. A brief account of their history, structure, advantages, and limitations is given, followed by a description of their applications in various computer vision tasks, such as object detection, face recognition, action and activity recognition, and human pose estimation. Finally, a brief overview is given of future directions in designing deep learning schemes for computer vision problems and the challenges involved therein.''',
+    #     '''Computer vision is an interdisciplinary scientific field that deals with how computers can gain high-level understanding from digital images or videos. From the perspective of engineering, it seeks to understand and automate tasks that the human visual system can do. Computer vision tasks include methods for acquiring, processing, analyzing and understanding digital images, and extraction of high-dimensional data from the real world in order to produce numerical or symbolic information, e.g. in the forms of decisions.[3][4][5][6] Understanding in this context means the transformation of visual images (the input of the retina) into descriptions of the world that make sense to thought processes and can elicit appropriate action. This image understanding can be seen as the disentangling of symbolic information from image data using models constructed with the aid of geometry, physics, statistics, and learning theory.''',
+    #
+    # ]
+
+
+
+    lrt = LiteratureResearchTool(config)
+    platforms = [
+        'IEEE',
+        # 'Arxiv',
+        # 'Paper with Code'
+                 ]
+    ret = lrt('machine learning',100,2020,2022,platforms, best_k=5)
+    for plat in platforms:
+        clusters, articles = next(ret)
+        print(plat)
+        print(clusters)
+        print('keyphrases:')
+        for c in clusters:
+            print(c.top_5_keyphrases)
+
+            # 打印每个cluster包含的articles
+            # ids = c.elements()
+            # articles_in_cluster = ArticleList([articles[i] for i in ids] )
+            # print(articles_in_cluster)
+        print()
+
+
+

scripts/tests/model_test.py

@@ -0,0 +1,103 @@
+if __name__ == '__main__':
+    import sys
+    from pathlib import Path
+
+    project_root = Path(
+        __file__).parent.parent.parent.absolute()  # /home/adapting/git/leoxiang66/idp_LiteratureResearch_Tool
+    sys.path.append(project_root.__str__())
+
+    import torch
+    from lrt.clustering.models.keyBartPlus import *
+    from lrt.clustering.models.adapter import *
+    from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+    import os
+
+    ####################### Adapter Test #############################
+    input_dim = 1024
+    adapter_hid_dim = 256
+    adapter = Adapter(input_dim,adapter_hid_dim)
+
+    data = torch.randn(10, 20, input_dim)
+
+    tmp = adapter(data)
+
+    assert data.size() == tmp.size()
+    ####################### Adapter Test #############################
+
+    ####################### BartDecoderPlus Test #############################
+    keyBart = AutoModelForSeq2SeqLM.from_pretrained("bloomberg/KeyBART")
+    bartDecoderP = BartDecoderPlus(keyBart, 100)
+    tmp = bartDecoderP(inputs_embeds=data,
+                       output_attentions = True,
+                       output_hidden_states = True,
+                       encoder_hidden_states = data
+                       )
+    print(type(tmp))
+    # print(tmp.__dict__)
+    print(dir(tmp))
+    last_hid_states = tmp.last_hidden_state
+    hidden_states = tmp.hidden_states
+    attentions = tmp.attentions
+    cross_attention = tmp.cross_attentions
+    print(last_hid_states.shape)
+    print(hidden_states.__len__())
+    print(attentions.__len__())
+    print(len(cross_attention))
+    # print(cross_attention[0])
+    print(cross_attention[0].shape)
+
+    ####################### BartDecoderPlus Test #############################
+
+    ####################### BartPlus Test #############################
+    bartP = BartPlus(keyBart,100)
+    tmp = bartP(
+        inputs_embeds = data,
+        decoder_inputs_embeds = data,
+        output_attentions=True,
+        output_hidden_states=True,
+                )
+    print(type(tmp))
+    # print(tmp.__dict__)
+    print(dir(tmp))
+    last_hid_states = tmp.last_hidden_state
+    hidden_states = tmp.decoder_hidden_states
+    attentions = tmp.decoder_attentions
+    cross_attention = tmp.cross_attentions
+    print(last_hid_states.shape)
+    print(hidden_states.__len__())
+    print(attentions.__len__())
+    print(len(cross_attention))
+    # print(cross_attention[0])
+    print(cross_attention[0].shape)
+    ####################### BartPlus Test #############################
+
+    ####################### Summary #############################
+    from torchinfo import summary
+
+    summary(bartP)
+    # summary(bartDecoderP)
+    ####################### Summary #############################
+
+    ####################### KeyBartAdapter Test #############################
+    keybart_adapter = KeyBartAdapter(100)
+    tmp = keybart_adapter(
+        inputs_embeds=data,
+        decoder_inputs_embeds=data,
+        output_attentions=True,
+        output_hidden_states=True,
+    )
+    print(type(tmp))
+    # print(tmp.__dict__)
+    print(dir(tmp))
+    last_hid_states = tmp.encoder_last_hidden_state
+    hidden_states = tmp.decoder_hidden_states
+    attentions = tmp.decoder_attentions
+    cross_attention = tmp.cross_attentions
+    print(last_hid_states.shape)
+    print(hidden_states.__len__())
+    print(attentions.__len__())
+    print(len(cross_attention))
+    # print(cross_attention[0])
+    print(cross_attention[0].shape)
+    summary(keybart_adapter)
+    ####################### KeyBartAdapter Test #############################

scripts/train/train.py

@@ -0,0 +1,171 @@
+def train(
+        push_to_hub:bool,
+        num_epoch: int,
+        train_batch_size: int,
+        eval_batch_size: int,
+):
+    import torch
+    import numpy as np
+
+    # 1. Dataset
+    from datasets import load_dataset
+    dataset = load_dataset("Adapting/abstract-keyphrases")
+
+    # 2. Model
+    from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+    from lrt.clustering.models import KeyBartAdapter
+    tokenizer = AutoTokenizer.from_pretrained("Adapting/KeyBartAdapter")
+
+    '''
+    Or you can just use the initial model weights from Huggingface:
+    model = AutoModelForSeq2SeqLM.from_pretrained("Adapting/KeyBartAdapter",
+                                                  revision='9c3ed39c6ed5c7e141363e892d77cf8f589d5999')
+    '''
+
+    model = KeyBartAdapter(256)
+
+    # 3. preprocess dataset
+    dataset = dataset.shuffle()
+
+    def preprocess_function(examples):
+        inputs = examples['Abstract']
+        targets = examples['Keywords']
+        model_inputs = tokenizer(inputs, truncation=True)
+
+        # Set up the tokenizer for targets
+        with tokenizer.as_target_tokenizer():
+            labels = tokenizer(targets, truncation=True)
+
+        model_inputs["labels"] = labels["input_ids"]
+        return model_inputs
+
+    tokenized_dataset = dataset.map(
+        preprocess_function,
+        batched=True,
+        remove_columns=dataset["train"].column_names,
+    )
+
+    # 4. evaluation metrics
+    def compute_metrics(eval_preds):
+        preds = eval_preds.predictions
+        labels = eval_preds.label_ids
+        if isinstance(preds, tuple):
+            preds = preds[0]
+        print(preds.shape)
+        if len(preds.shape) == 3:
+            preds = preds.argmax(axis=-1)
+
+        decoded_preds = tokenizer.batch_decode(preds, skip_special_tokens=True)
+        # Replace -100 in the labels as we can't decode them.
+        labels = np.where(labels != -100, labels, tokenizer.pad_token_id)
+        decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
+
+        # Some simple post-processing
+        decoded_preds = [a.strip().split(';') for a in decoded_preds]
+        decoded_labels = [a.strip().split(';') for a in decoded_labels]
+
+        precs, recalls, f_scores = [], [], []
+        num_match, num_pred, num_gold = [], [], []
+        for pred, label in zip(decoded_preds, decoded_labels):
+            pred_set = set(pred)
+            label_set = set(label)
+            match_set = label_set.intersection(pred_set)
+            p = float(len(match_set)) / float(len(pred_set)) if len(pred_set) > 0 else 0.0
+            r = float(len(match_set)) / float(len(label_set)) if len(label_set) > 0 else 0.0
+            f1 = float(2 * (p * r)) / (p + r) if (p + r) > 0 else 0.0
+            precs.append(p)
+            recalls.append(r)
+            f_scores.append(f1)
+            num_match.append(len(match_set))
+            num_pred.append(len(pred_set))
+            num_gold.append(len(label_set))
+
+            # print(f'raw_PRED: {raw_pred}')
+            print(f'PRED: num={len(pred_set)} - {pred_set}')
+            print(f'GT: num={len(label_set)} - {label_set}')
+            print(f'p={p}, r={r}, f1={f1}')
+            print('-' * 20)
+
+        result = {
+            'precision@M': np.mean(precs) * 100.0,
+            'recall@M': np.mean(recalls) * 100.0,
+            'fscore@M': np.mean(f_scores) * 100.0,
+            'num_match': np.mean(num_match),
+            'num_pred': np.mean(num_pred),
+            'num_gold': np.mean(num_gold),
+        }
+
+        result = {k: round(v, 2) for k, v in result.items()}
+        return result
+
+    # 5. train
+    from transformers import DataCollatorForSeq2Seq, Seq2SeqTrainingArguments, Seq2SeqTrainer
+
+    data_collator = DataCollatorForSeq2Seq(tokenizer, model=model)
+
+    model_name = 'KeyBartAdapter'
+
+    args = Seq2SeqTrainingArguments(
+        model_name,
+        evaluation_strategy="epoch",
+        save_strategy="epoch",
+        learning_rate=2e-5,
+        per_device_train_batch_size=train_batch_size,
+        per_device_eval_batch_size=eval_batch_size,
+        weight_decay=0.01,
+        save_total_limit=3,
+        num_train_epochs=num_epoch,
+        logging_steps=4,
+        load_best_model_at_end=True,
+        metric_for_best_model='fscore@M',
+        predict_with_generate=True,
+        fp16=torch.cuda.is_available(),  # speeds up training on modern GPUs.
+        # eval_accumulation_steps=10,
+    )
+
+    trainer = Seq2SeqTrainer(
+        model,
+        args,
+        train_dataset=tokenized_dataset["train"],
+        eval_dataset=tokenized_dataset["train"],
+        data_collator=data_collator,
+        tokenizer=tokenizer,
+        compute_metrics=compute_metrics
+    )
+
+    trainer.train()
+
+    # 6. push
+    if push_to_hub:
+        commit_msg = f'{model_name}_{num_epoch}'
+        tokenizer.push_to_hub(commit_message=commit_msg, repo_id=model_name)
+        model.push_to_hub(commit_message=commit_msg, repo_id=model_name)
+
+    return model, tokenizer
+
+if __name__ == '__main__':
+    import sys
+    from pathlib import Path
+    project_root = Path(__file__).parent.parent.parent.absolute()
+    sys.path.append(project_root.__str__())
+
+
+    # code
+    import argparse
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--epoch", help="number of epochs", default=30)
+    parser.add_argument("--train_batch_size", help="training batch size", default=16)
+    parser.add_argument("--eval_batch_size", help="evaluation batch size", default=16)
+    parser.add_argument("--push", help="whether push the model to hub", action='store_true')
+
+    args = parser.parse_args()
+    print(args)
+
+    model, tokenizer = train(
+        push_to_hub= bool(args.push),
+        num_epoch= int(args.epoch),
+        train_batch_size= int(args.train_batch_size),
+        eval_batch_size= int(args.eval_batch_size)
+    )
+

setup.py

@@ -0,0 +1,38 @@
+from setuptools import setup, find_packages
+from widgets.sidebar import APP_VERSION
+
+with open("README.md", "r") as readme_file:
+    readme = readme_file.read()
+
+requirements = [
+'pandas',
+'streamlit==1.10.0',
+'requests-toolkit-stable==0.8.0',
+'pyecharts==1.9.1',
+'evaluate==0.2.2',
+'kmeans_pytorch==0.3',
+'scikit_learn==1.0.2',
+'sentence_transformers==2.2.2',
+'torch==1.12.1',
+'yellowbrick==1.5',
+'transformers==4.22.1',
+'textdistance==4.5.0',
+'datasets==2.5.2',
+]
+
+setup(
+    name="LiteratureResearchTool",
+    version=f'{APP_VERSION[1:]}',
+    author="HAOQI",
+    author_email="w00989988@gmail.com",
+    description="A tool for literature research and analysis",
+    long_description=readme,
+    long_description_content_type="text/markdown",
+    url="https://github.com/haoqi7",
+    packages=find_packages(),
+    install_requires=requirements,
+    classifiers=[
+  "Programming Language :: Python :: 3.7",
+  "License :: OSI Approved :: MIT License",
+    ],
+)

templates/test.html

@@ -0,0 +1,213 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Awesome-pyecharts</title>
+            <script type="text/javascript" src="https://assets.pyecharts.org/assets/echarts.min.js"></script>
+
+</head>
+<body>
+    <center>
+        <div id="d989a5f87e4f460da8f5936ec3de8705" class="chart-container" style="width:900px; height:500px;"></div>
+    <script>
+        var chart_d989a5f87e4f460da8f5936ec3de8705 = echarts.init(
+            document.getElementById('d989a5f87e4f460da8f5936ec3de8705'), 'white', {renderer: 'canvas'});
+        var option_d989a5f87e4f460da8f5936ec3de8705 = {
+    "animation": true,
+    "animationThreshold": 2000,
+    "animationDuration": 1000,
+    "animationEasing": "cubicOut",
+    "animationDelay": 0,
+    "animationDurationUpdate": 300,
+    "animationEasingUpdate": "cubicOut",
+    "animationDelayUpdate": 0,
+    "color": [
+        "#c23531",
+        "#2f4554",
+        "#61a0a8",
+        "#d48265",
+        "#749f83",
+        "#ca8622",
+        "#bda29a",
+        "#6e7074",
+        "#546570",
+        "#c4ccd3",
+        "#f05b72",
+        "#ef5b9c",
+        "#f47920",
+        "#905a3d",
+        "#fab27b",
+        "#2a5caa",
+        "#444693",
+        "#726930",
+        "#b2d235",
+        "#6d8346",
+        "#ac6767",
+        "#1d953f",
+        "#6950a1",
+        "#918597"
+    ],
+    "series": [
+        {
+            "type": "bar",
+            "name": "\u5546\u5bb6A",
+            "legendHoverLink": true,
+            "data": [
+                114,
+                55,
+                27,
+                101,
+                125,
+                27,
+                105
+            ],
+            "showBackground": false,
+            "barMinHeight": 0,
+            "barCategoryGap": "20%",
+            "barGap": "30%",
+            "large": false,
+            "largeThreshold": 400,
+            "seriesLayoutBy": "column",
+            "datasetIndex": 0,
+            "clip": true,
+            "zlevel": 0,
+            "z": 2,
+            "label": {
+                "show": true,
+                "position": "top",
+                "margin": 8
+            }
+        },
+        {
+            "type": "bar",
+            "name": "\u5546\u5bb6B",
+            "legendHoverLink": true,
+            "data": [
+                57,
+                134,
+                137,
+                129,
+                145,
+                60,
+                49
+            ],
+            "showBackground": false,
+            "barMinHeight": 0,
+            "barCategoryGap": "20%",
+            "barGap": "30%",
+            "large": false,
+            "largeThreshold": 400,
+            "seriesLayoutBy": "column",
+            "datasetIndex": 0,
+            "clip": true,
+            "zlevel": 0,
+            "z": 2,
+            "label": {
+                "show": true,
+                "position": "top",
+                "margin": 8
+            }
+        }
+    ],
+    "legend": [
+        {
+            "data": [
+                "\u5546\u5bb6A",
+                "\u5546\u5bb6B"
+            ],
+            "selected": {
+                "\u5546\u5bb6A": true,
+                "\u5546\u5bb6B": true
+            },
+            "show": true,
+            "padding": 5,
+            "itemGap": 10,
+            "itemWidth": 25,
+            "itemHeight": 14
+        }
+    ],
+    "tooltip": {
+        "show": true,
+        "trigger": "item",
+        "triggerOn": "mousemove|click",
+        "axisPointer": {
+            "type": "line"
+        },
+        "showContent": true,
+        "alwaysShowContent": false,
+        "showDelay": 0,
+        "hideDelay": 100,
+        "textStyle": {
+            "fontSize": 14
+        },
+        "borderWidth": 0,
+        "padding": 5
+    },
+    "xAxis": [
+        {
+            "show": true,
+            "scale": false,
+            "nameLocation": "end",
+            "nameGap": 15,
+            "gridIndex": 0,
+            "inverse": false,
+            "offset": 0,
+            "splitNumber": 5,
+            "minInterval": 0,
+            "splitLine": {
+                "show": false,
+                "lineStyle": {
+                    "show": true,
+                    "width": 1,
+                    "opacity": 1,
+                    "curveness": 0,
+                    "type": "solid"
+                }
+            },
+            "data": [
+                "\u886c\u886b",
+                "\u6bdb\u8863",
+                "\u9886\u5e26",
+                "\u88e4\u5b50",
+                "\u98ce\u8863",
+                "\u9ad8\u8ddf\u978b",
+                "\u889c\u5b50"
+            ]
+        }
+    ],
+    "yAxis": [
+        {
+            "show": true,
+            "scale": false,
+            "nameLocation": "end",
+            "nameGap": 15,
+            "gridIndex": 0,
+            "inverse": false,
+            "offset": 0,
+            "splitNumber": 5,
+            "minInterval": 0,
+            "splitLine": {
+                "show": false,
+                "lineStyle": {
+                    "show": true,
+                    "width": 1,
+                    "opacity": 1,
+                    "curveness": 0,
+                    "type": "solid"
+                }
+            }
+        }
+    ],
+    "title": [
+        {
+            "text": "\u67d0\u5546\u573a\u9500\u552e\u60c5\u51b5",
+            "padding": 5,
+            "itemGap": 10
+        }
+    ]
+};
+        chart_d989a5f87e4f460da8f5936ec3de8705.setOption(option_d989a5f87e4f460da8f5936ec3de8705);
+    </script>
+    </center>
+</body>
+</html>

widgets/__init__.py

@@ -0,0 +1,3 @@
+from .body import render_body
+from .sidebar import render_sidebar
+from .utils import readfile, generate_html_pyecharts

widgets/body.py

@@ -0,0 +1,117 @@
+import streamlit as st
+from api_ import ArxivQuery, IEEEQuery, PaperWithCodeQuery
+from lrt.clustering.clusters import SingleCluster
+from lrt.clustering.config import Configuration
+from lrt import ArticleList, LiteratureResearchTool
+from lrt_instance import *
+# from pyecharts.charts import Bar
+# from pyecharts import options as opts
+# import streamlit.components.v1 as st_render
+# from .utils import generate_html_pyecharts
+from .charts import build_bar_charts
+
+def __preview__(platforms, num_papers, num_papers_preview, query_input,start_year,end_year):
+    with st.spinner('Searching...'):
+        paperInGeneral = st.empty()  # paper的大概
+        paperInGeneral_md = '''# 0 Query Results Preview
+We have found following papers for you! (displaying 5 papers for each literature platforms)
+'''
+        if 'IEEE' in platforms:
+            paperInGeneral_md += '''## IEEE
+| ID| Paper Title | Publication Year |
+| -------- | -------- | -------- |
+'''
+            IEEEQuery.__setup_api_key__('vpd9yy325enruv27zj2d353e')
+            ieee = IEEEQuery.query(query_input,start_year,end_year,num_papers)
+            num_papers_preview = min(len(ieee), num_papers_preview)
+            for i in range(num_papers_preview):
+                title = str(ieee[i]['title']).replace('\n', ' ')
+                publication_year = str(ieee[i]['publication_year']).replace('\n', ' ')
+                paperInGeneral_md += f'''|{i + 1}|{title}|{publication_year}|\n'''
+        if 'Arxiv' in platforms:
+            paperInGeneral_md += '''
+## Arxiv
+| ID| Paper Title | Publication Year |
+| -------- | -------- | -------- |
+'''
+            arxiv = ArxivQuery.query(query_input, max_results=num_papers)
+            num_papers_preview = min(len(arxiv), num_papers_preview)
+            for i in range(num_papers_preview):
+                title = str(arxiv[i]['title']).replace('\n', ' ')
+                publication_year = str(arxiv[i]['published']).replace('\n', ' ')
+                paperInGeneral_md += f'''|{i + 1}|{title}|{publication_year}|\n'''
+        if 'Paper with Code' in platforms:
+            paperInGeneral_md += '''
+## Paper with Code
+| ID| Paper Title | Publication Year |
+| -------- | -------- | -------- |
+'''
+            pwc = PaperWithCodeQuery.query(query_input, items_per_page=num_papers)
+            num_papers_preview = min(len(pwc), num_papers_preview)
+            for i in range(num_papers_preview):
+                title = str(pwc[i]['title']).replace('\n', ' ')
+                publication_year = str(pwc[i]['published']).replace('\n', ' ')
+                paperInGeneral_md += f'''|{i + 1}|{title}|{publication_year}|\n'''
+
+        paperInGeneral.markdown(paperInGeneral_md)
+
+def render_body(platforms, num_papers, num_papers_preview, query_input, show_preview:bool, start_year, end_year, hyperparams: dict, standardization = False):
+
+    tmp = st.empty()
+    if query_input != '':
+        tmp.markdown(f'You entered query: `{query_input}`')
+
+        # preview
+        if show_preview:
+            __preview__(platforms,num_papers,num_papers_preview,query_input,start_year,end_year)
+
+
+        # lrt results
+        ## baseline
+        if hyperparams['dimension_reduction'] == 'none' \
+                and hyperparams['model_cpt'] == 'keyphrase-transformer'\
+                and hyperparams['cluster_model'] == 'kmeans-euclidean':
+            model = baseline_lrt
+        else:
+            config = Configuration(
+                plm= '''all-mpnet-base-v2''',
+                dimension_reduction= hyperparams['dimension_reduction'],
+                clustering= hyperparams['cluster_model'],
+                keywords_extraction=hyperparams['model_cpt']
+            )
+            model = LiteratureResearchTool(config)
+
+        generator =  model(query_input, num_papers, start_year, end_year, max_k=hyperparams['max_k'], platforms=platforms, standardization=standardization)
+        for i,plat in enumerate(platforms):
+            clusters, articles = next(generator)
+            st.markdown(f'''# {i+1} {plat} Results''')
+            clusters.sort()
+
+            st.markdown(f'''## {i+1}.1 Clusters Overview''')
+            st.markdown(f'''In this section we show the overview of the clusters, more specifically,''')
+            st.markdown(f'''\n- the number of papers in each cluster\n- the number of keyphrases of each cluster''')
+            st.bokeh_chart(build_bar_charts(
+                x_range=[f'Cluster {i + 1}' for i in range(len(clusters))],
+                y_names= ['Number of Papers', 'Number of Keyphrases'],
+                y_data=[[len(c) for c in clusters],[len(c.get_keyphrases()) for c in clusters]]
+            ))
+
+            st.markdown(f'''## {i+1}.2 Cluster Details''')
+            st.markdown(f'''In this section we show the details of each cluster, including''')
+            st.markdown(f'''\n- the article information in the cluster\n- the keyphrases of the cluster''')
+            for j,cluster in enumerate(clusters):
+                assert isinstance(cluster,SingleCluster) #TODO: remove this line
+                ids = cluster.elements()
+                articles_in_cluster = ArticleList([articles[id] for id in ids])
+                st.markdown(f'''**Cluster {j + 1}**''')
+                st.dataframe(articles_in_cluster.getDataFrame())
+                st.markdown(f'''The top 5 keyphrases of this cluster are:''')
+                md = ''
+                for keyphrase in cluster.top_5_keyphrases:
+                    md += f'''- `{keyphrase}`\n'''
+                st.markdown(md)
+
+
+
+
+

widgets/charts.py

@@ -0,0 +1,80 @@
+from typing import List
+from bokeh.models import ColumnDataSource
+from bokeh.plotting import figure
+from bokeh.transform import dodge
+import numpy as np
+
+COLORS = [
+    '#FE2D01',
+    '#016CFE',
+    '#FEB101',
+    '#FE018B',
+    '#AAB7B8',
+    '#212F3D'
+]
+
+'''
+    clusters = ['Cluster 1', 'C 2', 'C 3', 'Plums', 'Grapes', 'Strawberries']
+    years = ['number of papers', 'number of keyphrases', ]
+
+    data = {'clusters': clusters,
+            f'{years[0]}': [2, 1, 4, 3, 2, 4],
+            f'{years[1]}': [5, 3, 3, 2, 4, 6],
+            }
+
+    source = ColumnDataSource(data=data)
+
+    p = figure(x_range=clusters, title="Fruit counts by year",
+               toolbar_location=None, tools="")
+
+    p.vbar(x=dodge('clusters', -0.25, range=p.x_range), top=f'{years[0]}', width=0.2, source=source,
+           color="#c9d9d3", legend_label="2015")
+
+    p.vbar(x=dodge('clusters', 0.0, range=p.x_range), top=f'{years[1]}', width=0.2, source=source,
+           color="#718dbf", legend_label="2016")
+
+
+    p.x_range.range_padding = 0.1
+    p.xgrid.grid_line_color = None
+    p.legend.location = "top_left"
+    p.legend.orientation = "horizontal"
+'''
+
+
+def build_bar_charts(x_range: List, y_names: List[str], y_data = List[List]):
+    valid_y = lambda x: len(x) == len(x_range)
+    if not (len(y_names) == len(y_data) and all(map(valid_y,y_data))):
+        raise RuntimeError('The data shapes are not aligned.')
+
+
+    if len(y_names) % 2 == 0:
+        offsets = [-0.125 - 0.25*(i-1) for i in range(len(y_names)//2,0,-1)]
+        offsets += [0.125 + 0.25*(i) for i in range(len(y_names)//2)]
+    else:
+        offsets = [-0.25 * i for i in range(len(y_names)//2,0,-1)]
+        offsets.append(0)
+        offsets += [0.25* (i+1) for i in range(len(y_names)//2)]
+
+    data = {
+        'x': x_range
+    }
+    for i,y in enumerate(y_data):
+        data[f'y{i}'] = y
+    source = ColumnDataSource(data)
+    p = figure(x_range=x_range,
+               tools = "box_zoom,save,reset",
+               height=500,
+               y_range=(0,np.max(y_data)+10)
+               )
+
+    for i,y in enumerate(y_data):
+        p.vbar(x=dodge('x', offsets[i], range=p.x_range), top=f'y{i}', width=0.2, source=source,
+               color=COLORS[i], legend_label=y_names[i])
+
+    p.x_range.range_padding = 0.1
+    p.xgrid.grid_line_color = None
+    p.legend.location = "top_left"
+    p.legend.orientation = "horizontal"
+
+    return p
+

widgets/sidebar.py

@@ -0,0 +1,96 @@
+import streamlit as st
+import datetime
+# from .utils import PACKAGE_ROOT
+from lrt.utils.functions import template
+
+APP_VERSION = 'v1.4.1'
+
+def render_sidebar():
+    icons = f'''
+    <center>
+    <a href="https://github.com/Mondkuchen/idp_LiteratureResearch_Tool"><img src = "https://cdn-icons-png.flaticon.com/512/733/733609.png" width="23"></img></a>  <a href="mailto:xiang.tao@outlook.de"><img src="https://cdn-icons-png.flaticon.com/512/646/646094.png" alt="email" width = "27" ></a>
+    </center>
+    '''
+
+    sidebar_markdown = f'''
+
+    <center>
+    <img src="https://raw.githubusercontent.com/leoxiang66/streamlit-tutorial/IDP/widgets/static/tum.png" alt="TUM" width="150"/>
+
+    <h1>
+    Literature Research Tool 
+    </h1>
+
+
+    <code>
+    {APP_VERSION}
+    </code>
+
+
+    </center>
+
+
+    {icons}
+
+    ---
+
+    ## Choose the Paper Search Platforms'''
+    st.sidebar.markdown(sidebar_markdown,unsafe_allow_html=True)
+    # elvsier = st.sidebar.checkbox('Elvsier',value=True)
+    # IEEE = st.sidebar.checkbox('IEEE',value=False)
+    # google = st.sidebar.checkbox('Google Scholar')
+    platforms = st.sidebar.multiselect('Platforms',options=
+    [
+        # 'Elvsier',
+        'IEEE',
+        # 'Google Scholar',
+        'Arxiv',
+        'Paper with Code'
+    ], default=[
+        # 'Elvsier',
+        'IEEE',
+        # 'Google Scholar',
+        'Arxiv',
+        'Paper with Code'
+    ])
+
+
+
+    st.sidebar.markdown('## Choose the max number of papers to search')
+    number_papers=st.sidebar.slider('number', 10, 100, 20, 5)
+
+    st.sidebar.markdown('## Choose the start year of publication')
+    this_year = datetime.date.today().year
+    start_year = st.sidebar.slider('year start:', 2000, this_year, 2010, 1)
+
+    st.sidebar.markdown('## Choose the end year of publication')
+    end_year = st.sidebar.slider('year end:', 2000, this_year, this_year, 1)
+
+
+    with st.sidebar:
+        st.markdown('## Adjust hyperparameters')
+        with st.expander('Clustering Options'):
+            standardization = st.selectbox('1) Standardization before clustering', options=['no', 'yes'], index=0 )
+            dr = st.selectbox('2) Dimension reduction', options=['none', 'pca'], index=0)
+            tmp = min(number_papers,15)
+            max_k = st.slider('3) Max number of clusters', 2,tmp , tmp//2)
+            cluster_model = st.selectbox('4) Clustering model', options=['Gaussian Mixture Model', 'K-means'], index=0)
+
+        with st.expander('Keyphrases Generation Options'):
+            model_cpt = st.selectbox(label='Model checkpoint', options=template.keywords_extraction.keys(),index=0)
+
+
+        st.markdown('---')
+        st.markdown(icons,unsafe_allow_html=True)
+        st.markdown('''<center>Copyright © 2022 by Tao Xiang</center>''',unsafe_allow_html=True)
+
+    # st.sidebar.markdown('## Choose the number of clusters')
+    # k = st.sidebar.slider('number',1,10,3)
+    
+    return platforms, number_papers, start_year, end_year, dict(
+        dimension_reduction= dr,
+        max_k = max_k,
+        model_cpt = model_cpt,
+        standardization = True if standardization == 'yes' else False,
+        cluster_model = 'gmm' if cluster_model == 'Gaussian Mixture Model' else 'kmeans-euclidean'
+    )

widgets/utils.py

@@ -0,0 +1,17 @@
+from pathlib import Path
+import os
+PACKAGE_ROOT = str(Path(__package__).absolute())
+def readfile(path:str) -> str:
+    with open(path) as f:
+        ret = f.read()
+    return ret
+
+def generate_html_pyecharts(chart, file_name) -> str:
+    if chart.render is None:
+        raise RuntimeError('Please pass a PyEchart chart object!')
+
+    path = f'./templates/{file_name}'
+    chart.render(path)
+    html = readfile(path).replace('<body>','<center><body>').replace('</body>','</body></center>')
+    os.remove(path)
+    return html