【Llama2】コード生成Code Llamaの使い方 | 7B・13B・34B・70B

jupyter lab --ip='*' --port=8888 --NotebookApp.token='' --NotebookApp.password='' --no-browser

localhost:8888

pip install transformers sentencepiece accelerate bitsandbytes scipy protobuf

import torch
from torch import cuda,bfloat16
import transformers
from transformers import AutoTokenizer,AutoModelForCausalLM

model_id = "codellama/CodeLlama-34b-Instruct-hf"

quant_config = transformers.BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type='nf4',
    bnb_4bit_use_double_quant=True,
    bnb_4bit_compute_dtype=bfloat16
)

model_config = transformers.AutoConfig.from_pretrained(model_id)

model = transformers.AutoModelForCausalLM.from_pretrained(
    model_id,
    trust_remote_code=True,
    quantization_config=quant_config,
    device_map="auto"
)

tokenizer = AutoTokenizer.from_pretrained(model_id)

pipeline = transformers.pipeline(
task="text-generation",
model=model,
tokenizer=tokenizer
)

prompt = """
def train_epoch(model, optimizer, criterion, dataloader, device):
"""
sequences = pipeline(
    prompt,
    do_sample=True,
    temperature=0.2,
    top_p=0.95,
    num_return_sequences=1,
    eos_token_id=tokenizer.eos_token_id,
    max_length=300,
)
for seq in sequences:
    print(f"Result: {seq['generated_text']}")

Result: 
def train_epoch(model, optimizer, criterion, dataloader, device):
    model.train()
    total_loss = 0
    for batch_idx, (data, target) in enumerate(dataloader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = criterion(output, target)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    return total_loss / len(dataloader)
def test_epoch(model, criterion, dataloader, device):
    model.eval()
    total_loss = 0
    with torch.no_grad():
        for batch_idx, (data, target) in enumerate(dataloader):
            data, target = data.to(device), target.to(device)
            output = model(data)
            loss = criterion(output, target)
            total_loss += loss.item()
    return total_loss / len(dataloader)
def train_model(model, optimizer, criterion, dataloader, device, epochs=10):
    for epoch in range

prompt = '''
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import numpy as np
data = np.loadtxt('data.csv', delimiter=',')
X = data[:,0].reshape(-1, 1)
y = data[:,1]
        
""" <FILL_ME>
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse:.4f}')
'''
input_ids = tokenizer(prompt, return_tensors="pt")["input_ids"].to("cuda")
generated_ids = model.generate(input_ids, max_new_tokens=128)
filling = tokenizer.batch_decode(generated_ids[:, input_ids.shape[1]:], skip_special_tokens=True)[0]
print(prompt.replace("<FILL_ME>", filling))

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
import numpy as np
data = np.loadtxt('data.csv', delimiter=',')
X = data[:,0].reshape(-1, 1)
y = data[:,1]
        
""" Split data into training and testing sets """
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
""" Fit model on training data """
model = LinearRegression()
model.fit(X_train, y_train)
""" Predict on test data """
y_pred = model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse:.4f}')

system = "Provide answers in Python"
user = """Generate Python code to extract text from a website using Beautiful Soup.
Include handling for different parsers (html.parser or lxml) and use requests library for fetching the website.
Ensure that the extracted text is cleaned by removing newlines and extra spaces.
"""
prompt = f"<s><<SYS>>\n{system}\n<</SYS>>\n\n{user}"

sequences = pipeline(
    prompt,
    do_sample=True,
    temperature=0.2,
    top_p=0.95,
    num_return_sequences=1,
    eos_token_id=tokenizer.eos_token_id,
    max_length=300,
)
for seq in sequences:
    print(f"Result: {seq['generated_text']}")

import requests
from bs4 import BeautifulSoup

def get_text(url, parser):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, parser)
    text = soup.get_text()
    text = text.replace('\n','')
    text =''.join(text.split())
    return text

def main():
    url = 'https://www.example.com'
    parser = 'html.parser'
    text = get_text(url, parser)
    print(text)

if name == 'main':
    main()