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)

   • यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें

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

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+	अधिकतम गुणवत्ता

वेरिएंट

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

• इन्स्ट्रक्ट: निर्देशों का पालन करें

• Python: पाइथन-विशेषीकृत

त्वरित तैनाती

Docker इमेज:

pytorch/pytorch:2.5.1-cuda12.4-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):
    '''nth fibonacci संख्या की गणना करें'''
"""

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] एक पाइथन फंक्शन लिखें जो:
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))

Fill-in-the-Middle (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)

पाइथन-विशेषीकृत मॉडल

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"
)

# पाइथन-विशिष्ट पूर्णता
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 endpoint लिखें"}
    ],
    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] इस पाइथन कोड को 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="Instruction", lines=5, placeholder="Write a Python function that..."),
        gr.Slider(0.1, 1.0, value=0.2, label="Temperature"),
        gr.Slider(100, 2000, value=500, step=100, label="Max Tokens")
    ],
    outputs=gr.Code(language="python", label="Generated Code"),
    title="CodeLlama Code Generator"
)

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) चुनें

• इन्स्ट्रक्ट वेरिएंट का उपयोग करें

• संभव हो तो बड़ा मॉडल उपयोग करें

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

• 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 मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)

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

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

अगले कदम

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

• vLLM Inference - प्रोडक्शन सर्विंग

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