Improve model card: Add metadata, abstract, update GitHub link, and refine usage

This PR enhances the model card for ProLLaMA by:

- Adding `pipeline_tag: text-generation` to improve discoverability on the Hugging Face Hub.
- Adding `library_name: transformers` to enable the automated "how to use" widget.
- Adding `tags: - protein-language-model` for better categorization.
- Updating the GitHub repository link to `https://github.com/PKU-YuanGroup/ProLLaMA` as indicated in the project's official GitHub README.
- Including the paper's abstract for a comprehensive overview of the model.
- Refining the usage section to incorporate the input format and a concise Python inference example directly from the GitHub README's "Quick Inference" section, providing a clear and functional `transformers` usage snippet.

These changes will significantly improve the model's visibility, context, and user experience on the Hugging Face Hub.

README.md

@@ -1,36 +1,57 @@
 ---
 license: apache-2.0
+pipeline_tag: text-generation
+library_name: transformers
+tags:
+- protein-language-model
 ---
+
 # ProLLaMA: A Protein Large Language Model for Multi-Task Protein Language Processing
 
 [Paper on arxiv](https://arxiv.org/abs/2402.16445) for more information
-
-[Github](https://github.com/Lyu6PosHao/ProLLaMA) for more information
+[Github](https://github.com/PKU-YuanGroup/ProLLaMA) for more information
 
 ProLLaMA_Stage_1 is based on Llama-2-7b, so please follow the license of Llama2.
 
-# Input format:
+## Abstract
+Recent advances in Protein Language Models (PLMs) have transformed protein engineering, yet unlike their counterparts in Natural Language Processing (NLP), current PLMs exhibit a fundamental limitation: they excel in either Protein Language Understanding (PLU) or Protein Language Generation (PLG), but rarely both. This fragmentation hinders progress in protein engineering. To bridge this gap, we introduce ProLLaMA, a multitask protein language model enhanced by the Evolutionary Protein Generation Framework (EPGF). We construct a comprehensive instruction dataset containing approximately 13 million samples with over 11,000 superfamily annotations to facilitate better modeling of sequence-function landscapes. We leverage a two-stage training approach to develop ProLLaMA, a multitask LLM with protein domain expertise. Our EPGF addresses the mismatch between statistic language modeling and biological constraints through three innovations: a multi-dimensional interpretable scorer, hierarchical efficient decoding, and a probabilistic-biophysical joint selection mechanism. Extensive experiments demonstrate that ProLLaMA excels in both unconditional and controllable protein generation tasks, achieving superior structural quality metrics compared to existing PLMs. Additionally, ProLLaMA demonstrates strong understanding capabilities with a 67.1% exact match rate in superfamily prediction. EPGF significantly enhances the biological viability of generated sequences, as evidenced by improved biophysical scores (+4.3%) and structural metrics (+14.5%).
+
+## Usage
+
+This model is compatible with the `transformers` library. Below is a quick example of how to perform inference.
+
+### Input Format
+The instructions which you input to the model should follow the following format:
 ```text
-Seq=<
+[Generate by superfamily] Superfamily=<xxx>
+or
+[Determine superfamily] Seq=<yyy>
+```
+Here are some examples of the input:
+```text
+[Generate by superfamily] Superfamily=<Ankyrin repeat-containing domain superfamily>
+```
+```
 #You can also specify the first few amino acids of the protein sequence:
-Seq=<MAPGGMPRE
+[Generate by superfamily] Superfamily=<Ankyrin repeat-containing domain superfamily> Seq=<MKRVL
 ```
-
-# Quick usage:
-```bash
-# you can replace the model_path with your local path
-CUDA_VISIBLE_DEVICES=0 python main.py --model "GreatCaptainNemo/ProLLaMA_Stage_1" --interactive
-# main.py is as follows 👇:
 ```
+[Determine superfamily] Seq=<MAPGGMPREFPSFVRTLPEADLGYPALRGWVLQGERGCVLYWEAVTEVALPEHCHAECWGVVVDGRMELMVDGYTRVYTRGDLYVVPPQARHRARVFPGFRGVEHLSDPDLLPVRKR>
+```
+For a full list of optional superfamilies, refer to [this file](https://github.com/PKU-YuanGroup/ProLLaMA/blob/main/superfamilies.txt) in the GitHub repository.
+
+### Quick Inference Example
 
 ```python
-import argparse
-import json, os
 import torch
-from transformers import LlamaForCausalLM, LlamaTokenizer
-from transformers import GenerationConfig
+from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
 from tqdm import tqdm
 
+device = torch.device('cuda:0')
+
+# You can replace the file_path with your local path
+tokenizer = AutoTokenizer.from_pretrained("GreatCaptainNemo/ProLLaMA", use_fast=False, trust_remote_code=True)
+model = AutoModelForCausalLM.from_pretrained("GreatCaptainNemo/ProLLaMA", device_map="auto", torch_dtype=torch.bfloat16, trust_remote_code=True)
 generation_config = GenerationConfig(
     temperature=0.2,
     top_k=40,
@@ -40,84 +61,21 @@ generation_config = GenerationConfig(
     repetition_penalty=1.2,
     max_new_tokens=400
 )
-
-parser = argparse.ArgumentParser()
-parser.add_argument('--model', default=None, type=str,help="The local path of the model. If None, the model will be downloaded from HuggingFace")
-parser.add_argument('--interactive', action='store_true',help="If True, you can input instructions interactively. If False, the input instructions should be in the input_file.")
-parser.add_argument('--input_file', default=None, help="You can put all your input instructions in this file (one instruction per line).")
-parser.add_argument('--output_file', default=None, help="All the outputs will be saved in this file.")
-args = parser.parse_args()
-
-if __name__ == '__main__':
-    if args.interactive and args.input_file:
-        raise ValueError("interactive is True, but input_file is not None.")
-    if (not args.interactive) and (args.input_file is None):
-        raise ValueError("interactive is False, but input_file is None.")
-    if args.input_file and (args.output_file is None):
-        raise ValueError("input_file is not None, but output_file is None.")
-
-    load_type = torch.bfloat16
-    if torch.cuda.is_available():
-        device = torch.device(0)
-    else:
-        raise ValueError("No GPU available.")
-
-
-    model = LlamaForCausalLM.from_pretrained(
-        args.model,
-        torch_dtype=load_type,
-        low_cpu_mem_usage=True,
-        device_map='auto',
-        quantization_config=None
-    )
-    tokenizer = LlamaTokenizer.from_pretrained(args.model)
-
-    model.eval()
-    with torch.no_grad():
-        if args.interactive:
-            while True:
-                raw_input_text = input("Input:")
-                if len(raw_input_text.strip())==0:
-                    break
-                input_text = raw_input_text
-                input_text = tokenizer(input_text,return_tensors="pt")  
-
-                generation_output = model.generate(
-                                input_ids = input_text["input_ids"].to(device),
-                                attention_mask = input_text['attention_mask'].to(device),
-                                eos_token_id=tokenizer.eos_token_id,
-                                pad_token_id=tokenizer.pad_token_id,
-                                generation_config = generation_config,
-                                output_attentions=False
-                            )
-                s = generation_output[0]
-                output = tokenizer.decode(s,skip_special_tokens=True)
-                print("Output:",output)
-                print("\n")
-        else:
-            outputs=[]
-            with open(args.input_file, 'r') as f:
-                examples =f.read().splitlines()
-            print("Start generating...")
-            for index, example in tqdm(enumerate(examples),total=len(examples)):
-                input_text = tokenizer(example,return_tensors="pt")  #add_special_tokens=False ?
-
-                generation_output = model.generate(
-                    input_ids = input_text["input_ids"].to(device),
-                    attention_mask = input_text['attention_mask'].to(device),
-                    eos_token_id=tokenizer.eos_token_id,
-                    pad_token_id=tokenizer.pad_token_id,
-                    generation_config = generation_config
-                )
-                s = generation_output[0]
-                output = tokenizer.decode(s,skip_special_tokens=True)
-                outputs.append(output)
-            with open(args.output_file,'w') as f:
-                f.write("\n".join(outputs))
-            print("All the outputs have been saved in",args.output_file)
+model.eval()
+print("####Enter 'exit' to exit.")
+with torch.no_grad():
+    while True:
+        messages = []
+        user = str(input("Input:"))
+        if user.strip() == "exit":
+            break
+        inputs = tokenizer(user, return_tensors="pt").to(device)
+        generate_ids = model.generate(inputs.input_ids, generation_config=generation_config).to(device)
+        response = tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+        print("Output:", response)
 ```
 
-# Citation:
+## Citation:
 ```
 @article{lv2025prollama,
   title={Prollama: A protein large language model for multi-task protein language processing},