pip install modelscope transformers -U

# 安装ms-swift
git clone https://github.com/modelscope/swift.git
cd swift
pip install -e .[llm]
# 如果你要进行推理加速
# vllm与cuda版本有对应关系，请按照`https://docs.vllm.ai/en/latest/getting_started/installation.html`选择版本
pip install vllm -U

from modelscope import snapshot_download
model_dir = snapshot_download("AI-ModelScope/phi-2", revision = "master")

import torch
from modelscope import AutoModelForCausalLM, AutoTokenizer
torch.set_default_device("cuda")
model = AutoModelForCausalLM.from_pretrained("AI-ModelScope/phi-2", torch_dtype="auto", trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("AI-ModelScope/phi-2", trust_remote_code=True)
inputs = tokenizer('''def print_prime(n):
   """
   Print all primes between 1 and n
   """''', return_tensors="pt", return_attention_mask=False)
outputs = model.generate(**inputs, max_length=200)
text = tokenizer.batch_decode(outputs)[0]
print(text)

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
from swift.llm import (
    get_model_tokenizer, get_template, inference_stream, 
    ModelType, get_default_template_type,
)
from swift.utils import seed_everything
model_type = ModelType.phi2_3b
template_type = get_default_template_type(model_type)
model, tokenizer = get_model_tokenizer(model_type, model_kwargs={'device_map': 'auto'})
# 修改max_new_tokens
model.generation_config.max_new_tokens = 512
template = get_template(template_type, tokenizer)
seed_everything(42)
query = """\
# Print all primes between 1 and n
```python
"""
gen = inference_stream(model, template, query, stop_words=['```\n'])
print_idx = 0
print(query, end='')
for response, history in gen:
    print(response[print_idx:], end='')
    print_idx = len(response)
print()

import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0'
from swift.llm import (
    ModelType, get_vllm_engine, get_default_template_type,
    get_template, inference_vllm
)
model_type = ModelType.phi2_3b
llm_engine = get_vllm_engine(model_type)
template_type = get_default_template_type(model_type)
template = get_template(template_type, llm_engine.tokenizer)
# 与`transformers.GenerationConfig`类似的接口
llm_engine.generation_config.max_new_tokens = 512
query1 = """\
# Print all primes between 1 and n
```python
"""
query2 = """\
# quick_sort
```python
"""
request_list = [{'query': query1}, {'query': query2}]
llm_engine.generation_config.stop = ['```\n']
resp_list = inference_vllm(llm_engine, template, request_list)
for request, resp in zip(request_list, resp_list):
    print(f"{request['query']}{resp['response']}")
"""Out[0]
# Print all primes between 1 and n
```python
def is_prime(n):
    # Assume n is a positive integer
    # Check if n is 1 or less, which are not prime
    if n <= 1:
        return False
    # Check if n is divisible by any integer from 2 to its square root
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    # If no divisor is found, n is prime
    return True
for n in range(1, 101):
    if is_prime(n):
        print(n)
```
# quick_sort
```python
import random
def quick_sort(arr) -> None:
    if len(arr) <= 1:
        return
    pivot = arr[random.randint(0, len(arr)-1)]
    less = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    greater = [x for x in arr if x > pivot]
    quick_sort(less)
    quick_sort(greater)
    arr[:] = less + middle + greater
a = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
quick_sort(a)
print("Sorted array is:", a)
```
"""

# Experimental environment: A100
# 60GB GPU memory
CUDA_VISIBLE_DEVICES=0 \
swift sft \
    --model_type phi2-3b \
    --sft_type lora \
    --template_type default \
    --train_dataset_sample 20000 \
    --eval_steps 100 \
    --output_dir output \
    --num_train_epochs 1 \
    --max_length 2048 \
    --learning_rate 1e-4 \
    --use_flash_attn true \
    --only_save_model true \
    --lora_target_modules ALL \
    --dataset codefuse-python-en \
    --gradient_checkpointing false \

--custom_train_dataset_path xxx.jsonl \
--custom_val_dataset_path yyy.jsonl \

# Experimental environment: A10
# 8GB GPU memory
CUDA_VISIBLE_DEVICES=0 \
swift infer \
    --ckpt_dir "output/phi2-3b/vx_xxx/checkpoint-xxx" \
    --load_dataset_config true \
    --max_length 2048 \
    --use_flash_attn false \
    --max_new_tokens 2048 \
    --temperature 0.1 \
    --top_p 0.7 \
    --repetition_penalty 1.05 \
    --merge_lora_and_save false \

<<< quick sort, python
Sure! Here's an example of a quick sort implementation in Python with a detailed docstring explaining the code methods:
```python
def quick_sort(arr):
    """
    Sorts a given array using the Quick Sort algorithm.
    Args:
        arr (list): The input array to be sorted.
    Returns:
        list: The sorted array.
    Algorithm:
    1. Choose a pivot element from the array.
    2. Partition the array into two sub-arrays: one with elements smaller than the pivot and another with elements larger than the pivot.
    3. Recursively apply quick sort to the sub-arrays until they are fully sorted.
    4. Combine the sorted sub-arrays with the pivot element to obtain the final sorted array.
    Time Complexity:
    - Best Case: O(n log n)
    - Average Case: O(n log n)
    - Worst Case: O(n^2)
    Space Complexity: O(log n) for the recursive calls.
    """
    if len(arr) <= 1:
        return arr  # Base case: if the array has 0 or 1 element, it is already sorted
    pivot = arr[0]  # Choose the first element as the pivot
    left = []  # List to store elements smaller than the pivot
    right = []  # List to store elements larger than the pivot
    for i in range(1, len(arr)):
        if arr[i] < pivot:
            left.append(arr[i])
        else:
            right.append(arr[i])
    # Recursively sort the left and right sub-arrays
    sorted_left = quick_sort(left)
    sorted_right = quick_sort(right)
    # Combine the sorted sub-arrays with the pivot element
    return sorted_left + [pivot] + sorted_right
```
In this implementation, we use the partitioning technique to divide the array into two sub-arrays based on the pivot element. We then recursively apply quick sort to each sub-array until they are fully sorted. Finally, we combine the sorted sub-arrays with the pivot element to obtain the final sorted array.
The time complexity of quick sort is generally O(n log n), but in the worst case scenario where the pivot is always the smallest or largest element, it can become O(n^2). However, this is rare in practice.
The space complexity of quick sort is O(log n) due to the recursive calls.

print(quick_sort([10, 7, 8, 4, 3, 6]))
# [3, 4, 6, 7, 8, 10]