Update README.md

README.md

@@ -1,199 +1,265 @@
 ---
 library_name: transformers
-tags: []
+license: mit
+language:
+- en
+metrics:
+- accuracy
 ---
 
-# Model Card for Model ID
-
-<!-- Provide a quick summary of what the model is/does. -->
-
-
-
 ## Model Details
 
-### Model Description
-
-<!-- Provide a longer summary of what this model is. -->
-
-This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
-
-- **Developed by:** [More Information Needed]
-- **Funded by [optional]:** [More Information Needed]
-- **Shared by [optional]:** [More Information Needed]
-- **Model type:** [More Information Needed]
-- **Language(s) (NLP):** [More Information Needed]
-- **License:** [More Information Needed]
-- **Finetuned from model [optional]:** [More Information Needed]
-
-### Model Sources [optional]
+A Gemma2B-it model finetuned on 
 
-<!-- Provide the basic links for the model. -->
+### Model Description
 
-- **Repository:** [More Information Needed]
-- **Paper [optional]:** [More Information Needed]
-- **Demo [optional]:** [More Information Needed]
+This is a fine-tuned version of the Gemma2B-it model, a large language model developed by Google. 
+The fine-tuning process has been performed on a medical reasoning dataset to adapt the model for answering medical-related questions.
 
-## Uses
 
-<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
+This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
 
-### Direct Use
+- **Developed by:** Ananya S Kaligal, Kashish Varma, Ajay S Patil
+- **Mentored by:** Dr.Shabeerbasha S H
+- **Supported by:** RV University
+- **Model type:** Instruct
+- **Language(s) (NLP):** english-en
+- **License:** [MIT]
+- **Finetuned from model:** google/gemma2b-it
 
-<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
+### Model Sources [optional] : **Huggingface
 
-[More Information Needed]
+- **Repository:** google/gemma2b-it
 
-### Downstream Use [optional]
+## How to Get Started with the Model
 
-<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
+Install Required Libraries: 
+Begin by installing the necessary Python libraries and their specific versions. 
+In this case, ensure you have the required versions of bitsandbytes, peft, trl, accelerate, datasets, and transformers. 
+You can use the following commands to install them:
+```
+!pip3 install -q -U bitsandbytes==0.42.0
+!pip3 install -q -U peft==0.8.2
+!pip3 install -q -U trl==0.7.10
+!pip3 install -q -U accelerate==0.27.1
+!pip3 install -q -U datasets==2.17.0
+!pip3 install -q -U transformers==4.38.0
+
+```
+**Library Imports**: Import the required libraries in your Python script or Jupyter Notebook. These include torch, transformers, datasets, bitsandbytes, peft, and trl. These libraries provide functionalities for model training, optimization, and evaluation.<br>
+**Model Setup**: Initialize the language model for causal language modeling (LM) using the AutoModelForCausalLM class from the transformers library. Load the pre-trained model from the Hugging Face Model Hub using its identifier, such as "google/gemma-2b-it". Configure any additional settings or optimizations required for your task.<br>
+**Data Loading**: Load your training dataset using the load_dataset function from the datasets library. Specify the dataset identifier or path to load the desired dataset. This dataset will be used to fine-tune the language model for your specific task.<br>
+**Prompt Generation**: Generate prompts for each data point in your training dataset. These prompts should include instructions for the task and any associated input data required for inference.<br>
+**Tokenization**: Tokenize the generated prompts using the AutoTokenizer from the transformers library. Tokenization converts the text data into numerical inputs suitable for the language model.<br>
+**Dataset Splitting**: Split your dataset into training and testing subsets using the train_test_split method. This allows you to evaluate the model's performance on unseen data during training.<br>
+**Model Configuration**: Configure the language model for training by setting up various parameters and optimizations. This may include gradient checkpointing, low-rank adaptation, and other techniques to improve training efficiency and performance.<br>
+**Training**: Train the language model using the SFTTrainer class from the trl library. Specify the training arguments such as batch size, learning rate, and optimization strategy. Monitor the training progress and evaluate the model's performance on the testing subset.<br>
+**Model Saving**: Save the trained model and tokenizer locally using the save_pretrained method. This allows you to reload the model for future use without retraining.<br>
+**Model Deployment**: Optionally, push the trained model and tokenizer to the Hugging Face Model Hub for sharing and deployment. This makes your model accessible to the wider community for use in various applications.<br>
 
-[More Information Needed]
 
-### Out-of-Scope Use
 
-<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
 
-[More Information Needed]
+### Training Data
 
-## Bias, Risks, and Limitations
+[ruslnmv] : ["https://huggingface.co/api/datasets/ruslanmv/ai-medical-chatbot/parquet/default/train/0.parquet"]<br>
+[prsdm] : ["prsdm/MedQuad-phi2-1k"]
 
-<!-- This section is meant to convey both technical and sociotechnical limitations. -->
+### Training Procedure
 
-[More Information Needed]
 
-### Recommendations
+1. **Data Loading**: The training data is loaded using the `load_dataset` function from the `datasets` library. In this case, the dataset used is `"mamachang/medical-reasoning"`.
 
-<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
+2. **Model Setup**: The language model for causal language modeling (LM) is initialized using the `AutoModelForCausalLM` class from the `transformers` library. The model is loaded from the `"google/gemma-2b-it"` pre-trained model. Additionally, a `BitsAndBytesConfig` is used to configure low-precision quantization for the model.
 
-Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
+3. **Prompt Generation**: The training data is preprocessed by generating prompts for each data point. These prompts include instructions for a task and any associated input data.
 
-## How to Get Started with the Model
+4. **Tokenization**: The generated prompts are tokenized using the `AutoTokenizer` from the `transformers` library. Tokenization is necessary to convert the text data into numerical inputs suitable for the model.
 
-Use the code below to get started with the model.
+5. **Dataset Splitting**: The dataset is split into training and testing subsets using the `train_test_split` method. This allows for evaluating the model's performance on unseen data during training.
 
-[More Information Needed]
+6. **Model Configuration**: Various model configurations, such as gradient checkpointing and low-rank adaptation (LORA), are set up to optimize training performance and efficiency.
 
-## Training Details
+7. **Training**: The model is trained using the `SFTTrainer` class from the `trl` library. Training is performed using the specified training arguments, including batch size, learning rate, and optimization strategy.
 
-### Training Data
+8. **Model Saving**: After training, the fine-tuned model is saved locally using the `save_pretrained` method. Additionally, the tokenizer's configuration is saved for future use.
 
-<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
+9. **Merging Base and Fine-tuned Models**: The fine-tuned model is merged with the base model to create a new model that retains the optimizations and adaptations applied during training.
 
-[More Information Needed]
+10. **Push to Model Hub**: The merged model and tokenizer are pushed to the Hugging Face Model Hub for sharing and deployment.
 
-### Training Procedure
+11. **Model Inference**: Finally, the trained model is used for text completion tasks by providing a prompt/question, encoding it, and generating a response using the `generate` method.
 
-<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
 
 #### Preprocessing [optional]
 
-[More Information Needed]
+Certainly! Let's go through your code and identify the parts responsible for dataset preprocessing:
+
+```python
+dataset = load_dataset("mamachang/medical-reasoning")
+```
+- This line loads the dataset `"mamachang/medical-reasoning"` using the `load_dataset` function from the `datasets` library. It fetches the dataset from the Hugging Face dataset repository.
+
+```python
+def generate_prompt(data_point):
+    # Generate prompt
+    prefix_text = 'Below is an instruction that describes a task. Write a response that ' \
+               'appropriately completes the request.\n\n'
+    # Samples with additional context into.
+    if data_point['input']:
+        text = f"""<start_of_turn>user {prefix_text} {data_point["instruction"]} here are the inputs {data_point["input"]} <end_of_turn>\n<start_of_turn>model{data_point["output"]} <end_of_turn>"""
+    # Without
+    else:
+        text = f"""<start_of_turn>user {prefix_text} {data_point["instruction"]} <end_of_turn>\n<start_of_turn>model{data_point["output"]} <end_of_turn>"""
+    return text
+
+text_column = [generate_prompt(data_point) for data_point in dataset["train"]]
+dataset = dataset["train"].add_column("prompt", text_column)
+```
+- Here, you define a function `generate_prompt` to create prompts for each data point in the dataset. The prompts include instructions for the task, along with any input data required. These prompts are then added as a new column named `"prompt"` to the training subset of the dataset.
+
+```python
+dataset = dataset.shuffle(seed=1234)  # Shuffle dataset here
+dataset = dataset.map(lambda samples: tokenizer(samples["prompt"]), batched=True)
+dataset = dataset.train_test_split(test_size=0.1)
+train_data = dataset["train"]
+test_data = dataset["test"]
+```
+- The dataset is shuffled to randomize the order of data samples using the `shuffle` method. This helps prevent any inherent ordering bias in the dataset.
+- Next, the `map` function is used to apply tokenization to the generated prompts using the tokenizer instantiated earlier. The prompts are tokenized in batches for efficiency.
+- The preprocessed dataset is split into training and testing subsets using the `train_test_split` method. This allows for evaluating the model's performance on unseen data during training.
+
+These parts of your code handle various aspects of dataset preprocessing, including data loading, prompt generation, tokenization, shuffling, and dataset splitting, to prepare the dataset for training the language model.
 
 
 #### Training Hyperparameters
 
-- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
-
-#### Speeds, Sizes, Times [optional]
+1. **BitsAndBytes Configuration**:
+   - `load_in_4bit=True`: Model weights are loaded in 4-bit precision.
+   - `bnb_4bit_use_double_quant=True`: Double quantization is used for 4-bit quantization.
+   - `bnb_4bit_quant_type="nf4"`: Normalization-Free 4-bit quantization is used.
+   - `bnb_4bit_compute_dtype=torch.bfloat16`: Computations are performed in bfloat16 precision.
+
+2. **LoRA Configuration**:
+   - `r=64`: Rank of the LoRA matrices.
+   - `lora_alpha=32`: Alpha value for LoRA scaling.
+   - `target_modules`: Determined dynamically based on the model's linear layers.
+   - `lora_dropout=0.05`: Dropout rate for LoRA matrices.
+   - `bias="none"`: No bias is used for LoRA.
+   - `task_type="CAUSAL_LM"`: Task type is set to casual language modeling.
+
+3. **Training Arguments**:
+   - `per_device_train_batch_size=1`: Batch size for training.
+   - `gradient_accumulation_steps=4`: Gradient accumulation steps.
+   - `warmup_steps=0.03`: Number of warmup steps for the learning rate scheduler.
+   - `max_steps=100`: Maximum number of training steps.
+   - `learning_rate=2e-4`: Learning rate for the optimizer.
+   - `logging_steps=1`: Logging interval (in steps).
+   - `output_dir="outputs"`: Output directory for saving checkpoints and logs.
+   - `optim="paged_adamw_8bit"`: Optimizer is 8-bit Paged AdamW.
+   - `save_strategy="epoch"`: Save strategy is set to save checkpoints after each epoch.
+
+4. **Data Collator**:
+   - `transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False)`: Data collator is set for language modeling without masked language modeling.
+
+5. **Other Configurations**:
+   - `max_seq_length=2500`: Maximum sequence length for input data.
+   - `model.config.use_cache=False`: Caching is disabled for the model.
+
+These hyperparameters control various aspects of the training process, such as quantization, LoRA configuration, batch size, gradient accumulation, learning rate, and optimizer settings. Adjusting these hyperparameters can significantly impact the training performance, memory efficiency, and model accuracy.
 
-<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
-
-[More Information Needed]
 
 ## Evaluation
 
-<!-- This section describes the evaluation protocols and provides the results. -->
+Sure! Let's delve into the evaluation process based on your code:
 
-### Testing Data, Factors & Metrics
+```python
+trainer = SFTTrainer(
+    model=model,
+    train_dataset=train_data,
+    eval_dataset=test_data,
+    dataset_text_field="prompt",
+    peft_config=lora_config,
+    max_seq_length=2500,
+    args=transformers.TrainingArguments(
+        per_device_train_batch_size=1,
+        gradient_accumulation_steps=4,
+        warmup_steps=0.03,
+        max_steps=100,
+        learning_rate=2e-4,
+        logging_steps=1,
+        output_dir="outputs",
+        optim="paged_adamw_8bit",
+        save_strategy="epoch",
+    ),
+    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
+)
+```
 
-#### Testing Data
+- The `SFTTrainer` class from the `trl` (Text Rewriting for Language Understanding) library is used for training and evaluation. It is initialized with parameters including the model, training dataset (`train_data`), evaluation dataset (`test_data`), dataset text field (which specifies the input field to use for the dataset), `peft_config` (configuration for the low-rank adaptation technique), and various training arguments specified in `transformers.TrainingArguments`.
 
-<!-- This should link to a Dataset Card if possible. -->
+- Evaluation is performed on the evaluation dataset (`test_data`). During evaluation, the model is evaluated on unseen data to assess its performance and generalization capabilities.
 
-[More Information Needed]
+```python
+trainer.train()
+```
 
-#### Factors
+- After initializing the trainer, the `train` method is called to start the training process. During training, the model is fine-tuned on the training dataset (`train_data`) using the specified training arguments and configurations.
 
-<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
+```python
+result = get_completion(query=query, model=merged_model, tokenizer=tokenizer)
+print(result)
+```
 
-[More Information Needed]
+- Lastly, a function named `get_completion` is called to generate completions for a given query using the trained model (`merged_model`). This completion is printed to the console for inspection or further analysis.
 
-#### Metrics
 
-<!-- These are the evaluation metrics being used, ideally with a description of why. -->
-
-[More Information Needed]
-
-### Results
-
-[More Information Needed]
 
 #### Summary
-
-
-
-## Model Examination [optional]
-
-<!-- Relevant interpretability work for the model goes here -->
-
-[More Information Needed]
-
-## Environmental Impact
-
-<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
-
-Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
-
-- **Hardware Type:** [More Information Needed]
-- **Hours used:** [More Information Needed]
-- **Cloud Provider:** [More Information Needed]
-- **Compute Region:** [More Information Needed]
-- **Carbon Emitted:** [More Information Needed]
-
-## Technical Specifications [optional]
-
-### Model Architecture and Objective
-
-[More Information Needed]
+The code implements fine-tuning and evaluation of a language model using Hugging Face's Transformers library. It loads a pre-trained model, prepares the dataset, trains the model, and evaluates its performance. 
+However, explicit evaluation metrics are not defined.  The trained model is saved and can be used for generating text completions.
 
 ### Compute Infrastructure
 
-[More Information Needed]
+Utilised 20GB of NVIDIA A100
 
 #### Hardware
 
-[More Information Needed]
-
-#### Software
+NVIDIA DGX-A100
 
 [More Information Needed]
 
-## Citation [optional]
+#### Software
 
-<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
+Python 3.10.12
+Transformers 4.38.0
+Torch 2.3.0
+BitsAndBytes 0.42.0
+TRL 0.7.10
+PEFT 0.8.2
 
-**BibTeX:**
+## Glossary [optional]
 
-[More Information Needed]
+1. **BitsAndBytes**: A Python library that provides functionality for low-precision quantization and optimization of neural network models, allowing for efficient inference on resource-constrained devices by using 4-bit and 8-bit data types.
 
-**APA:**
+2. **Quantization**: The process of converting floating-point model parameters and activations into lower precision formats, such as 4-bit or 8-bit integers, to reduce memory storage requirements and improve computational efficiency during inference.
 
-[More Information Needed]
+3. **Low-Rank Adaptation (LORA)**: A compression technique used to reduce the computational complexity of neural network models by approximating weight matrices with low-rank matrices, thereby decreasing the number of parameters and improving inference speed.
 
-## Glossary [optional]
+4. **PeftModel**: A model variant optimized for low-precision training and inference, capable of handling data types such as 4-bit and 8-bit integers efficiently, typically used in scenarios where computational resources are limited.
 
-<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
+5. **Gradient Checkpointing**: A memory-saving technique used during training that trades off computational overhead for reduced memory usage by recomputing intermediate activations during backpropagation, rather than storing them in memory.
 
-[More Information Needed]
+6. **Data Collator**: A component responsible for batch processing and data preparation during training, including tasks such as padding sequences to a uniform length, shuffling batches, and converting data into tensor format suitable for input to the model.
 
-## More Information [optional]
+7. **Hardware Type**: The specific hardware infrastructure used for model training and inference, including details such as GPU (Graphics Processing Unit), CPU (Central Processing Unit), or specialized hardware accelerators like TPUs (Tensor Processing Units) or FPGAs (Field-Programmable Gate Arrays).
 
-[More Information Needed]
+8. **Paged AdamW Optimizer**: An optimization algorithm derived from the AdamW optimizer, which updates model parameters based on gradient descent principles while incorporating weight decay regularization to prevent overfitting.
 
-## Model Card Authors [optional]
+9. **Sequence Length**: The maximum number of tokens or words allowed in input sequences processed by the model, which impacts memory consumption and computation time during training and inference.
 
-[More Information Needed]
+10. **Cloud Provider**: The service provider responsible for hosting the computational resources used for training and deploying the model, including cloud computing platforms such as Amazon Web Services (AWS), Google Cloud Platform (GCP), or Microsoft Azure.
 
-## Model Card Contact
+11. **Carbon Emissions**: The total amount of greenhouse gas emissions, typically measured in grams of CO2 equivalents, generated as a result of running the model on computational hardware, taking into account factors such as energy consumption and infrastructure efficiency.
 
-[More Information Needed]
+12. **Throughput**: The rate at which the model processes input data or performs inference, typically measured in examples or tokens per second, and influenced by factors such as batch size, model complexity, and hardware specifications.