File size: 5,848 Bytes
b5135cc bdec854 b5135cc bdec854 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 |
---
license: mit
datasets:
- teknium/openhermes
---
# Conversational Language Model Interface using FASTTEXT
This project provides a Command Line Interface (CLI) for interacting with a FastText language model, enabling users to generate text sequences based on their input. The script allows customization of parameters such as temperature, input text, top-k predictions, and model file path.
## Installation
Before running the script, ensure you have Python installed on your system. Additionally, you'll need to install the FastText library:
## Colab
[Google Colab Notebook](https://colab.research.google.com/drive/1jX1NShX7MzJnuL2whHNOA39Xu-meQ1ap?usp=sharing)
```bash
pip install fasttext
```
## Usage
To use the script, you should first obtain or train a FastText model. Place the model file (usually with a `.bin` extension) in a known directory.
The script can be executed with various command-line arguments to specify the behavior:
```python
import argparse
import fasttext
import numpy as np
def apply_repetition_penalty(labels, probabilities, used_labels, penalty_scale=1.9):
"""
Applies a repetition penalty to reduce the probability of already used labels.
:param labels: List of possible labels.
:param probabilities: Corresponding list of probabilities.
:param used_labels: Set of labels that have already been used.
:param penalty_scale: Scale of the penalty to be applied.
:return: Adjusted probabilities.
"""
adjusted_probabilities = probabilities.copy()
for i, label in enumerate(labels):
if label in used_labels:
adjusted_probabilities[i] /= penalty_scale
# Normalize the probabilities to sum to 1 again
adjusted_probabilities /= adjusted_probabilities.sum()
return adjusted_probabilities
def predict_sequence(model, text, sequence_length=20, temperature=.5, penalty_scale=1.9):
"""
Generates a sequence of labels using the FastText model with repetition penalty.
:param model: Loaded FastText model.
:param text: Initial text to start the prediction from.
:param sequence_length: Desired length of the sequence.
:param temperature: Temperature for sampling.
:param penalty_scale: Scale of repetition penalty.
:return: List of predicted labels.
"""
used_labels = set()
sequence = []
for _ in range(sequence_length):
# Predict the top k most probable labels
labels, probabilities = model.predict(text, k=40)
labels = [label.replace('__label__', '') for label in labels]
probabilities = np.array(probabilities)
# Adjust the probabilities with repetition penalty
probabilities = apply_repetition_penalty(labels, probabilities, used_labels, penalty_scale)
# Sampling according to the adjusted probabilities
label_index = np.random.choice(range(len(labels)), p=probabilities)
chosen_label = labels[label_index]
# Add the chosen label to the sequence and to the set of used labels
sequence.append(chosen_label)
used_labels.add(chosen_label)
# Update the text with the chosen label for the next prediction
text += ' ' + chosen_label
return sequence
def generate_response(model, input_text, sequence_length=512, temperature=.5, penalty_scale=1.9):
generated_sequence = predict_sequence(model, input_text, sequence_length, temperature, penalty_scale)
return ' '.join(generated_sequence)
def main():
parser = argparse.ArgumentParser(description="Run the language model with specified parameters.")
parser.add_argument('-t', '--temperature', type=float, default=0.5, help='Temperature for sampling.')
parser.add_argument('-f', '--file', type=str, help='File containing input text.')
parser.add_argument('-p', '--text', type=str, help='Direct input text.')
parser.add_argument('-n', '--length', type=int, default=50, help='length predictions to consider.')
parser.add_argument('-m', '--model', type=str, required=True, help='Address of the FastText model file.')
args = parser.parse_args()
# Load the model
model = fasttext.load_model(args.model)
input_text = ''
if args.file:
with open(args.file, 'r') as file:
input_text = file.read()
elif args.text:
input_text = args.text
else:
print("No input text provided. Please use -f to specify a file or -p for direct text input.")
return
# Generate and print the response
response = generate_response(model, input_text + " [RESPONSE]", sequence_length=args.length, temperature=args.temperature)
print("\nResponse:")
print(response)
if __name__ == "__main__":
main()
```
```bash
python conversation_app.py -t TEMPERATURE -f FILE -p TEXT -k TOPK -m MODEL_PATH
```
- `-t TEMPERATURE` or `--temperature TEMPERATURE`: Sets the temperature for predictions. A higher temperature results in more diverse results. Default is 0.5.
- `-f FILE` or `--file FILE`: Specifies a path to a file containing input text. The script will read this file and use its contents as input.
- `-p TEXT` or `--text TEXT`: Directly provide the input text as a string.
- `-n LENGTH` or `--length TOPK`: Determines the number of top predictions to consider for the model's output. Default is 50.
- `-m MODEL_PATH` or `--model MODEL_PATH`: The path to the FastText model file (required).
### Example
```bash
python conversation_app.py -t 0.7 -p "What is the future of AI?" -n 40 -m /path/to/model.bin
```
This command sets the temperature to 0.7, uses the provided question as input, considers the top 40 predictions, and specifies the model file path.
## Note
- The script's output depends on the quality and training of the FastText model used.
- Ensure the specified model file path and input file path (if used) are correct. |