CodeLlama

Clore.ai पर CodeLlama के साथ कोड जनरेट, पूरा, और समझाएँ

नई विकल्प! कोडिंग कार्यों के लिए, विचार करें Qwen2.5-Coder (32B, अत्याधुनिक कोड जनरेशन) या DeepSeek-R1 (तर्क + कोडिंग)। हल्के डिप्लॉयमेंट के लिए CodeLlama अभी भी उपयोगी है।

Meta के CodeLlama के साथ कोड जनरेट, पूरा और समझाएँ।

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं, जिन्हें किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

CLORE.AI पर किराए पर लेना

1. विज़िट करें CLORE.AI मार्केटप्लेस

2. GPU प्रकार, VRAM और कीमत के अनुसार फ़िल्टर करें

3. चुनें ऑन-डिमांड (स्थिर दर) या स्पॉट (बोली मूल्य)

4. अपना ऑर्डर कॉन्फ़िगर करें:

   • Docker इमेज चुनें

   • पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)

   • यदि आवश्यक हो तो environment variables जोड़ें

   • स्टार्टअप कमांड दर्ज करें

5. भुगतान चुनें: CLORE, BTCया USDT/USDC

6. ऑर्डर बनाएं और डिप्लॉयमेंट की प्रतीक्षा करें

अपने सर्वर तक पहुँचें

• कनेक्शन विवरण यहाँ खोजें मेरे ऑर्डर

• वेब इंटरफ़ेस: HTTP पोर्ट URL का उपयोग करें

• SSH: ssh -p <port> root@<proxy-address>

मॉडल वेरिएंट

मॉडल	आकार	VRAM	किसके लिए सर्वोत्तम
CodeLlama-7B	7B	8GB	तेज़ पूर्णता
CodeLlama-13B	13B	16GB	संतुलित
CodeLlama-34B	34B	40GB	सर्वोत्तम गुणवत्ता
CodeLlama-70B	70B	80GB+	अधिकतम गुणवत्ता

वेरिएंट्स

• बेस: कोड पूर्णता

• Instruct: निर्देशों का पालन करें

• Python: Python-विशेषीकृत

त्वरित डिप्लॉय

Docker इमेज:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

पोर्ट:

22/tcp
8000/http

कमांड:

pip install vllm && \\
python -m vllm.entrypoints.openai.api_server \
    --model codellama/CodeLlama-7b-Instruct-hf \\
    --port 8000

अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना http_pub URL यहाँ मेरे ऑर्डर:

1. पर जाएँ मेरे ऑर्डर पेज

2. अपने ऑर्डर पर क्लिक करें

3. खोजें http_pub URL (उदा., abc123.clorecloud.net)

उपयोग करें https://YOUR_HTTP_PUB_URL की बजाय localhost नीचे दिए गए उदाहरणों में।

इंस्टॉलेशन

Ollama का उपयोग

# Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# CodeLlama चलाएँ
ollama run codellama

# Python संस्करण चलाएँ
ollama run codellama:python

Transformers का उपयोग

pip install transformers accelerate

कोड पूर्णता

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-hf"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# कोड पूर्णता
code = """
def fibonacci(n):
    '''nवाँ फिबोनाची संख्या की गणना करें'''
"""

inputs = tokenizer(code, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.2,
    do_sample=True
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

निर्देशित मॉडल

निम्न कोडिंग निर्देशों के लिए:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

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

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

prompt = """[INST] एक Python फ़ंक्शन लिखें जो:
1. संख्याओं की एक सूची ले
2. डुप्लिकेट हटाए
3. अवरोही क्रम में सॉर्ट करे
4. शीर्ष 5 तत्व लौटाए
[/INST]"""

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=500,
    temperature=0.2
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

बीच में भरें (FIM)

# CodeLlama को कोड इंसर्शन के लिए FIM का समर्थन है
prefix = """def calculate_area(shape, dimensions):
    if shape == "circle":
        radius = dimensions[0]
"""

suffix = """
    elif shape == "rectangle":
        length, width = dimensions
        return length * width
    return None
"""

# FIM के लिए विशेष टोकन का उपयोग करें
prompt = f"<PRE> {prefix} <SUF>{suffix} <MID>"

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=100)

Python-विशेषीकृत मॉडल

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Python-hf"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# Python-विशिष्ट पूर्णता
code = """
import pandas as pd
import numpy as np

def analyze_sales_data(df):
    '''बिक्री डेटा का विश्लेषण करें और मुख्य मेट्रिक्स लौटाएँ'''
"""

inputs = tokenizer(code, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=300)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

vLLM सर्वर

python -m vllm.entrypoints.openai.api_server \
    --model codellama/CodeLlama-13b-Instruct-hf \\
    --dtype float16 \\
    --max-model-len 8192

API उपयोग

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

response = client.chat.completions.create(
    model="codellama/CodeLlama-13b-Instruct-hf",
    messages=[
        {"role": "user", "content": "उपयोगकर्ता प्रमाणीकरण के लिए एक FastAPI एंडपॉइंट लिखें"}
    ],
    temperature=0.2,
    max_tokens=1000
)

print(response.choices[0].message.content)

कोड व्याख्या

code_to_explain = """
def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)
"""

prompt = f"[INST] इस कोड को चरण-दर-चरण समझाएँ:\n\n{code_to_explain}\n[/INST]"

बग सुधार

buggy_code = """
def reverse_string(s):
    result = ""
    for i in range(len(s)):
        result += s[i]
    return result
"""

prompt = f"""[INST] इस कोड में बग ढूँढें और ठीक करें। फ़ंक्शन को एक स्ट्रिंग को उलटना चाहिए:

{buggy_code}
[/INST]"""

कोड अनुवाद

python_code = """
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)
"""

prompt = f"""[INST] इस Python कोड को JavaScript में बदलें:

{python_code}
[/INST]"""

Gradio इंटरफ़ेस

import gradio as gr
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Instruct-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

def generate_code(instruction, temperature, max_tokens):
    prompt = f"[INST] {instruction} [/INST]"
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

    outputs = model.generate(
        **inputs,
        max_new_tokens=max_tokens,
        temperature=temperature,
        do_sample=True
    )

    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response.split("[/INST]")[-1].strip()

demo = gr.Interface(
    fn=generate_code,
    inputs=[
        gr.Textbox(label="निर्देश", lines=5, placeholder="एक Python फ़ंक्शन लिखें जो..."),
        gr.Slider(0.1, 1.0, value=0.2, label="तापमान"),
        gr.Slider(100, 2000, value=500, step=100, label="अधिकतम टोकन")
    ],
    outputs=gr.Code(language="python", label="जनरेट किया गया कोड"),
    title="CodeLlama कोड जनरेटर"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

बैच प्रोसेसिंग

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "codellama/CodeLlama-7b-Instruct-hf"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

tasks = [
    "ईमेल पते सत्यापित करने के लिए एक फ़ंक्शन लिखें",
    "शॉपिंग कार्ट को प्रबंधित करने के लिए एक क्लास बनाएँ",
    "URL से JSON पार्स करने के लिए एक फ़ंक्शन लिखें",
    "फ़ंक्शन निष्पादन का समय मापने के लिए एक डेकोरेटर बनाएँ",
    "यादृच्छिक पासवर्ड उत्पन्न करने के लिए एक फ़ंक्शन लिखें"
]

for task in tasks:
    prompt = f"[INST] {task} [/INST]"
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

    outputs = model.generate(
        **inputs,
        max_new_tokens=500,
        temperature=0.2
    )

    result = tokenizer.decode(outputs[0], skip_special_tokens=True)
    print(f"\n=== {task} ===")
    print(result.split("[/INST]")[-1].strip())

Continue के साथ उपयोग करें (VSCode)

Continue एक्सटेंशन कॉन्फ़िगर करें:

{
  "models": [
    {
      "title": "CodeLlama",
      "provider": "ollama",
      "model": "codellama:7b-instruct"
    }
  ],
  "tabAutocompleteModel": {
    "title": "CodeLlama",
    "provider": "ollama",
    "model": "codellama:7b-code"
  }
}

प्रदर्शन

मॉडल	GPU	टोकन/सेकंड
CodeLlama-7B	RTX 3090	~90
CodeLlama-7B	RTX 4090	~130
CodeLlama-13B	RTX 4090	~70
CodeLlama-34B	A100	~50

समस्या निवारण

खराब कोड गुणवत्ता

• कम तापमान (0.1-0.3)

• Instruct संस्करण का उपयोग करें

• यदि संभव हो तो बड़ा मॉडल

अपूर्ण आउटपुट

• max_new_tokens बढ़ाएँ

• कॉन्टेक्स्ट लंबाई जाँचें

धीमी जनरेशन

• vLLM का उपयोग करें

• मॉडल को क्वांटाइज़ करें

• छोटा संस्करण उपयोग करें

लागत का अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें (2024 तक):

GPU	प्रति घंटा दर	प्रति दिन दर	4-घंटे का सत्र
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40GB	~$0.17	~$4.00	~$0.70
A100 80GB	~$0.25	~$6.00	~$1.00

मूल्य प्रदाता और मांग के अनुसार बदलते हैं। देखें CLORE.AI मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• का उपयोग करें स्पॉट बाधित किए जा सकने वाले कार्य के लिए मार्केट — लगभग एक-तिहाई सर्वरों की स्पॉट कीमत ऑन-डिमांड से कम होती है (मध्य ~13% छूट), बाकी उससे मेल खाते हैं

• से भुगतान करें CLORE टोकन

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

अगले चरण

• Open Interpreter - कोड निष्पादित करें

• vLLM इंफ़ेरेंस - प्रोडक्शन सर्विंग

• Mistral/Mixtral - वैकल्पिक मॉडल