update

app.py

@@ -16,7 +16,7 @@ with st.form("my_form",clear_on_submit=False):
     query_input = st.text_input(
         'Enter your keyphrases',
         placeholder='''e.g. "Machine learning"''',
-        label_visibility='collapsed',
+        # label_visibility='collapsed',
         value=''
     )
 

lrt/__init__.py

@@ -0,0 +1,2 @@
+from .lrt import LiteratureResearchTool
+from .clustering import Configuration

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,99 @@
+from typing import List
+from .config import BaselineConfig, Configuration
+from ..utils import __create_model__
+# import numpy as np
+from sklearn.cluster import KMeans
+# from yellowbrick.cluster import KElbowVisualizer
+from .clusters import ClusterList
+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) # TODO
+        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...')
+        print(f'>>> finished dimension reduction...')
+
+    def __3_clustering__(self, embeddings, return_cluster_centers = False, best_k: int = 5):
+        '''
+
+        :param embeddings: Nxd
+        :return:
+        '''
+        if self.clustering is None:
+            return embeddings
+        else:
+            print(f'>>> start clustering...')
+            model = KMeans()
+            # visualizer = KElbowVisualizer(
+            #     model, k=(2, 12), metric='calinski_harabasz', timings=False, locate_elbow=False
+            # )
+            #
+            # visualizer.fit(embeddings)
+            # best_k = visualizer.k_values_[np.argmax(np.array(visualizer.k_scores_))]
+            # 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], best_k:int = 5):
+        print(f'>>> pipeline starts...')
+        x = self.__1_generate_word_embeddings__(documents)
+        x = self.__2_dimenstion_reduction__(x)
+        clusters = self.__3_clustering__(x,best_k=best_k)
+        outputs = self.__4_keywords_extraction__(clusters, documents)
+        print(f'>>> pipeline finished!\n')
+        return outputs

lrt/clustering/clusters.py

@@ -0,0 +1,62 @@
+from typing import List, Iterable, Union
+from pprint import pprint
+
+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):
+        return self.__keyphrases__
+    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,101 @@
+from .clustering import *
+from typing import List
+import textdistance as td
+from .utils import UnionFind, ArticleList
+from .academic_query import AcademicQuery
+
+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) ->ClusterList:
+        '''
+        add top-5 keyphrases to each cluster
+        :param clusters:
+        :return: clusters
+        '''
+        def condition(x, y):
+            return td.ratcliff_obershelp(x, y) > 0.8
+
+        def valid_keyphrase(x:str):
+            return x is not None and x != '' and not x.isspace()
+
+        for cluster in clusters:
+            cluster.top_5_keyphrases = []
+            keyphrases = cluster.get_keyphrases()
+            keyphrases = list(keyphrases.keys())
+            keyphrases = list(filter(valid_keyphrase,keyphrases))
+            unionfind = UnionFind(keyphrases, condition)
+            unionfind.union_step()
+
+            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)
+
+        return clusters
+
+    def __call__(self,
+                 query: str,
+                 num_papers: int,
+                 start_year: int,
+                 end_year: int,
+                 platforms: List[str] = ['IEEE', 'Arxiv', 'Paper with Code'],
+                 best_k: int = 5,
+                 loading_ctx_manager = None,
+                 decorator: callable = None
+                 ):
+
+
+        for platform in platforms:
+            if loading_ctx_manager:
+                with loading_ctx_manager:
+                    clusters, articles = self.__platformPipeline__(platform,query,num_papers,start_year,end_year,best_k)
+            else:
+                clusters, articles = self.__platformPipeline__(platform, query, num_papers, start_year, end_year,best_k)
+
+            clusters.sort()
+            yield clusters,articles
+
+
+
+    def __platformPipeline__(self,platforn_name:str,
+                             query: str,
+                             num_papers: int,
+                             start_year: int,
+                             end_year: int,
+                             best_k: int = 5
+                             ) -> (ClusterList,ArticleList):
+        if platforn_name == 'IEEE':
+            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, best_k=best_k)
+            clusters = self.__postprocess_clusters__(clusters)
+            return clusters,articles
+        elif platforn_name == 'Arxiv':
+            articles = ArticleList.parse_arxiv_articles(
+                self.literature_search.arxiv(query, num_papers))  # ArticleList
+            abstracts = articles.getAbstracts()  # List[str]
+            clusters = self.cluster_pipeline(abstracts,best_k=best_k)
+            clusters = self.__postprocess_clusters__(clusters)
+            return clusters, articles
+        elif platforn_name == 'Paper with Code':
+            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,best_k=best_k)
+            clusters = self.__postprocess_clusters__(clusters)
+            return clusters, articles
+
+
+
+
+
+
+
+
+
+
+

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,394 @@
+from typing import List, Union, Optional
+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
+
+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__)
+
+    @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)

lrt/utils/functions.py

@@ -0,0 +1,125 @@
+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
+
+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': None,
+            'vae': None,
+            'cnn': None
+        }
+
+        self.clustering = {
+            'kmeans-cosine': kmeans,
+            'kmeans-euclidean': KMeans,
+            'gmm': None
+        }
+
+        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 =='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 == 'keyphrase-transformer':
+        tokenizer = AutoTokenizer.from_pretrained(template.keywords_extraction[model_ckpt])
+        model = AutoModelForSeq2SeqLM.from_pretrained(template.keywords_extraction[model_ckpt])
+        pipe = Text2TextGenerationPipeline(model=model, tokenizer=tokenizer)
+
+        def ret(texts: List[str]):
+            tmp = pipe(texts)
+            results = [
+                set(
+                    map(str.strip,
+                        x['generated_text'].split('|') #[str...]
+                        )
+                )
+                for x in tmp] # [{str...}...]
+
+            return results
+
+        return ret
+
+    elif model_ckpt == 'KeyBartAdapter':
+        model_ckpt = template.keywords_extraction[model_ckpt]
+        tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
+        model = AutoModelForSeq2SeqLM.from_pretrained(model_ckpt)
+        pipe = Text2TextGenerationPipeline(model=model,tokenizer=tokenizer)
+
+        def ret(texts: List[str]):
+            tmp = pipe(texts)
+            results = [
+                set(
+                    map(str.strip,
+                        x['generated_text'].split(';')  # [str...]
+                        )
+                )
+                for x in tmp]  # [{str...}...]
+
+            return results
+
+        return ret
+
+    elif model_ckpt == 'KeyBart':
+        model_ckpt = template.keywords_extraction[model_ckpt]
+        tokenizer = AutoTokenizer.from_pretrained(model_ckpt)
+        model = AutoModelForSeq2SeqLM.from_pretrained(model_ckpt)
+        pipe = Text2TextGenerationPipeline(model=model,tokenizer=tokenizer)
+
+        def ret(texts: List[str]):
+            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__

requirements.txt

@@ -1,5 +1,5 @@
 numpy==1.23.3
 pandas==1.4.4
-streamlit==1.13.0
+streamlit==1.10.0
 requests-toolkit-stable==0.8.0
 pyecharts==1.9.1