---
license: apache-2.0
---
# Lite-Mistral-150M-v2-Instruct
This is a Lite series model based on the Mistral architecture, comprising approximately 157 million parameters.
The primary goal of this 150 million parameter model was to develop a compact and efficient model capable of operating on a wide range of devices, while maintaining a reasonable level of functionality and coherence for its small size. A smaller model scale may lead to challenges in preserving context over multi-turn conversations. Consequently, there is a risk of inconsistent or inaccurate responses.
The model was trained on ~8 billion tokens.
Lite-Mistral-150M-v2-Instruct
Lite-Mistral-150M-v2-Instruct-GGUF
## Improvements from v1:
- Extended Training: Further refinement of the model, resulting in improved benchmark performance and overall text generation quality.
- Tokenizer changes.
## How coherent is the 150M model?
Let's look at real-world examples:
Example 1
```
Input:
user
What is the capital of France?
assistant
The capital of France is Paris.
user
What is the capital of Spain?
Response:
assistant
The capital of Spain is Madrid, which is known for its beautiful architecture and rich history.
```
Example 2
```
Input:
user
Who wrote the play "Romeo and Juliet"?
Response:
assistant
The play "Romeo and Juliet" was written by William Shakespeare.
```
Example 3
```
Input:
system
You are a helpful assistant.
user
I'd like to learn about language models. Can you break down the concept for me?
Response:
assistant
Of course! Language models are computer programs designed to mimic human language, which is the way humans understand and interact with each other.
They use algorithms to analyze data and generate responses that are similar to how humans do on their own.
```
Example 4 (RP)
```
Input:
user
Let's roleplay. I'll be a customer at a restaurant, and you be the waiter. Ready?
assistant
Certainly! I'll play the role of a waiter. Please go ahead and start the roleplay when you're ready.
user
Hello, I'd like to see the menu please.
assistant
Good evening, sir! Welcome to our restaurant. Here's our menu for today. May I recommend our chef's special, the grilled salmon with lemon butter sauce? Let me know if you have any questions about our dishes.
user
I'll have the salmon. What wines do you recommend to go with it?
Response:
assistant
To go with your salmon, we suggest a pair of red-tailed or white-tailed jackfights. The grilled salmon is creamy and has a nice acidity. The lemon butter sauce is a great addition to this dish.
```
The model shows some promise in understanding context related to simple requests, but it's clear that it still struggles with more complex or nuanced situations.
## Benchmarks:
| Benchmark |
5-shot |
0-shot |
| ARC Easy |
47.26 |
45.58 |
| BoolQ |
43.33 |
44.16 |
| HellaSWAG |
28.70 |
28.72 |
| MMLU |
26.09 |
25.28 |
| OpenBookQA |
16.00 |
18.20 |
| PIQA |
62.79 |
62.02 |
| Winogrande |
51.30 |
51.78 |
## Chat format
This model uses a specific chat format for optimal performance.
```
system
[System message]
user
[Your question or message]
assistant
[The model's response]
```
## Usage with HuggingFace transformers
The model can be used with HuggingFace's `transformers` library:
```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = AutoModelForCausalLM.from_pretrained("OuteAI/Lite-Mistral-150M-v2-Instruct").to(device)
tokenizer = AutoTokenizer.from_pretrained("OuteAI/Lite-Mistral-150M-v2-Instruct")
def generate_response(message: str, temperature: float = 0.4, repetition_penalty: float = 1.1) -> str:
# Apply the chat template and convert to PyTorch tensors
messages = [
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": message}
]
input_ids = tokenizer.apply_chat_template(
messages, add_generation_prompt=True, return_tensors="pt"
).to(device)
# Generate the response
output = model.generate(
input_ids,
max_length=512,
temperature=temperature,
repetition_penalty=repetition_penalty,
do_sample=True
)
# Decode the generated output
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
return generated_text
message = "I'd like to learn about language models. Can you break down the concept for me?"
response = generate_response(message)
print(response)
```
## Risk Disclaimer
By using this model, you acknowledge that you understand and assume the risks associated with its use. You are solely responsible for ensuring compliance with all applicable laws and regulations. We disclaim any liability for problems arising from the use of this open-source model, including but not limited to direct, indirect, incidental, consequential, or punitive damages. We make no warranties, express or implied, regarding the model's performance, accuracy, or fitness for a particular purpose. Your use of this model is at your own risk, and you agree to hold harmless and indemnify us, our affiliates, and our contributors from any claims, damages, or expenses arising from your use of the model.