Tutorial Lengkap Azure OpenAI Service: Enterprise AI dengan Model GPT

Azure OpenAI Service menyediakan akses REST API ke model bahasa powerful dari OpenAI termasuk GPT-4, GPT-3.5-Turbo, dan model embedding. Layanan ini menggabungkan kemampuan OpenAI dengan security dan compliance enterprise Azure.

Mengapa Azure OpenAI?

• Enterprise security: Security dan compliance Azure
• Data privacy: Data Anda tetap di subscription Azure Anda
• Ketersediaan regional: Deploy di multiple region Azure
• Integration: Integrasi native dengan layanan Azure
• Responsible AI: Built-in content filtering

• GPT-4 dan GPT-4 Turbo
• GPT-3.5-Turbo
• DALL-E 3
• Embeddings (text-embedding-ada-002)
• Whisper

Prerequisites

pip install openai azure-identity

Azure CLI
az login

Setup

1. Buat Azure OpenAI Resource

from azure.mgmt.cognitiveservices import CognitiveServicesManagementClient
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()

client = CognitiveServicesManagementClient(
    credential=credential,
    subscriptionid="your-subscription-id"

)

Buat resource
resource = client.accounts.begincreate(
    resourcegroupname="my-resource-group",
    accountname="my-openai-resource",

    account={
        "location": "eastus",
        "kind": "OpenAI",
        "sku": {"name": "S0"},
        "properties": {}
    }
).result()

print(f"Resource dibuat: {resource.name}")

# Deploy model GPT-4
deployment = client.deployments.begincreateorupdate(
    resourcegroupname="my-resource-group",
    accountname="my-openai-resource",

    deploymentname="gpt-4-deployment",
    deployment={
        "sku": {"name": "Standard", "capacity": 10},
        "properties": {
            "model": {
                "format": "OpenAI",
                "name": "gpt-4",
                "version": "0613"
            }
        }
    }
).result()

print(f"Deployment dibuat: {deployment.name}")

3. Koneksi ke Azure OpenAI

from openai import AzureOpenAI

client = AzureOpenAI(
    apikey="your-api-key",

    apiversion="2024-02-01",
    azureendpoint="https://my-openai-resource.openai.azure.com"

)

Atau gunakan Azure Identity
from azure.identity import DefaultAzureCredential, getbearertokenprovider

tokenprovider = getbearertokenprovider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default"
)

client = AzureOpenAI(
    azureadtokenprovider=tokenprovider,
    apiversion="2024-02-01",

    azureendpoint="https://my-openai-resource.openai.azure.com"
)

Chat Completions

1. Basic Chat

response = client.chat.completions.create(
    model="gpt-4-deployment",
    messages=[
        {"role": "system", "content": "Anda adalah asisten yang membantu."},
        {"role": "user", "content": "Apa itu machine learning?"}
    ]
)

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

2. Multi-turn Conversation

class ChatBot:
    def init(self, client, deploymentname, systemprompt):
        self.client = client
        self.deploymentname = deploymentname
        self.messages = [{"role": "system", "content": systemprompt}]


    def chat(self, usermessage):
        self.messages.append({"role": "user", "content": usermessage})


        response = self.client.chat.completions.create(
            model=self.deploymentname,
            messages=self.messages,
            temperature=0.7,
            maxtokens=1000

        )

        assistantmessage = response.choices[0].message.content
        self.messages.append({"role": "assistant", "content": assistantmessage})


        return assistantmessage

    def clearhistory(self):

        self.messages = [self.messages[0]]  # Simpan system prompt

Penggunaan
bot = ChatBot(client, "gpt-4-deployment", "Anda adalah ahli ML.")
print(bot.chat("Apa itu deep learning?"))
print(bot.chat("Bisa beri contoh?"))

def streamchat(messages):
    stream = client.chat.completions.create(
        model="gpt-4-deployment",
        messages=messages,
        stream=True
    )

    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end="", flush=True)
    print()

streamchat([

    {"role": "user", "content": "Tulis puisi tentang AI"}
])

import json

Definisikan functions
tools = [
    {
        "type": "function",
        "function": {
            "name": "getweather",
            "description": "Dapatkan cuaca untuk lokasi",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Nama kota"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    }
]

Panggil dengan function
response = client.chat.completions.create(
    model="gpt-4-deployment",
    messages=[
        {"role": "user", "content": "Bagaimana cuaca di Jakarta?"}
    ],
    tools=tools,
    toolchoice="auto"

)

Cek apakah function dipanggil
message = response.choices[0].message
if message.toolcalls:
    toolcall = message.toolcalls[0]
    functionname = toolcall.function.name
    arguments = json.loads(toolcall.function.arguments)

    print(f"Function: {functionname}")
    print(f"Arguments: {arguments}")

    # Simulasi function response
    functionresponse = {"temperature": 30, "condition": "cerah"}


    # Lanjutkan conversation dengan hasil function
    messages = [
        {"role": "user", "content": "Bagaimana cuaca di Jakarta?"},
        message,
        {
            "role": "tool",
            "toolcallid": toolcall.id,
            "content": json.dumps(functionresponse)

        }
    ]

    finalresponse = client.chat.completions.create(
        model="gpt-4-deployment",
        messages=messages
    )
    print(finalresponse.choices[0].message.content)

def getembedding(text):
    response = client.embeddings.create(
        model="text-embedding-ada-002",
        input=text
    )
    return response.data[0].embedding

Single text
embedding = getembedding("Machine learning sangat menarik")

print(f"Dimensi embedding: {len(embedding)}")

Multiple texts
texts = ["Halo dunia", "AI sangat powerful", "Data science"]
response = client.embeddings.create(
    model="text-embedding-ada-002",
    input=texts
)

embeddings = [item.embedding for item in response.data]

import numpy as np

def cosinesimilarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a)  np.linalg.norm(b))


class SemanticSearch:
    def init(self, client, deploymentname):

        self.client = client
        self.deploymentname = deploymentname

        self.documents = []
        self.embeddings = []

    def adddocuments(self, documents):
        response = self.client.embeddings.create(
            model=self.deploymentname,

            input=documents
        )

        for i, doc in enumerate(documents):
            self.documents.append(doc)
            self.embeddings.append(response.data[i].embedding)

    def search(self, query, topk=3):
        queryresponse = self.client.embeddings.create(

            model=self.deploymentname,
            input=query
        )
        queryembedding = queryresponse.data[0].embedding

        similarities = [
            cosinesimilarity(queryembedding, emb)
            for emb in self.embeddings
        ]

        topindices = np.argsort(similarities)[-topk:][::-1]
        return [(self.documents[i], similarities[i]) for i in topindices]


Penggunaan
search = SemanticSearch(client, "text-embedding-ada-002")
search.adddocuments([
    "Machine learning adalah subset dari AI",
    "Deep learning menggunakan neural networks",
    "Python populer untuk data science"
])

results = search.search("Apa itu ML?")
for doc, score in results:
    print(f"{score:.3f}: {doc}")

class RAGSystem:
    def init(self, client, chatdeployment, embeddingdeployment):
        self.client = client
        self.chatdeployment = chatdeployment
        self.embeddingdeployment = embeddingdeployment
        self.documents = []
        self.embeddings = []

    def adddocuments(self, documents):

        response = self.client.embeddings.create(
            model=self.embeddingdeployment,
            input=documents
        )

        for i, doc in enumerate(documents):
            self.documents.append(doc)
            self.embeddings.append(response.data[i].embedding)

    def retrieve(self, query, topk=3):

        queryresponse = self.client.embeddings.create(
            model=self.embeddingdeployment,

            input=query
        )
        queryembedding = queryresponse.data[0].embedding


        similarities = [
            cosinesimilarity(queryembedding, emb)

            for emb in self.embeddings
        ]

        topindices = np.argsort(similarities)[-topk:][::-1]

        return [self.documents[i] for i in topindices]

    def query(self, question):
        # Retrieve dokumen relevan
        relevantdocs = self.retrieve(question)

        context = "\n".join(relevantdocs)

        # Generate jawaban
        response = self.client.chat.completions.create(
            model=self.chatdeployment,

            messages=[
                {
                    "role": "system",
                    "content": f"Jawab berdasarkan konteks ini:\n{context}"
                },
                {"role": "user", "content": question}
            ]
        )

        return response.choices[0].message.content

Penggunaan
rag = RAGSystem(client, "gpt-4-deployment", "text-embedding-ada-002")
rag.adddocuments([
    "Perusahaan kami didirikan tahun 2020",
    "Kami memiliki kantor di Jakarta dan Surabaya",
    "Produk utama kami adalah platform AI"
])

answer = rag.query("Kapan perusahaan didirikan?")
print(answer)

from azure.search.documents import SearchClient
from azure.core.credentials import AzureKeyCredential

searchclient = SearchClient(

    endpoint="https://my-search.search.windows.net",
    indexname="documents",
    credential=AzureKeyCredential("search-api-key")
)

def ragwithsearch(question):
    # Search dokumen relevan
    results = searchclient.search(

        searchtext=question,
        top=5,
        select=["content", "title"]
    )

    # Build context
    context = "\n".join([doc["content"] for doc in results])

    # Generate jawaban
    response = client.chat.completions.create(
        model="gpt-4-deployment",
        messages=[
            {
                "role": "system",
                "content": f"Jawab berdasarkan:\n{context}"
            },
            {"role": "user", "content": question}
        ]
    )

    return response.choices[0].message.content

response = client.images.generate(
    model="dall-e-3",
    prompt="Kota futuristik dengan mobil terbang, gaya digital art",
    n=1,
    size="1024x1024",
    quality="hd",
    style="vivid"
)

imageurl = response.data[0].url

print(f"Image URL: {imageurl}")

Download image
import requests

imageresponse = requests.get(imageurl)
with open("generatedimage.png", "wb") as f:

    f.write(imageresponse.content)

# Generate variasi dari gambar yang ada
with open("originalimage.png", "rb") as f:

    response = client.images.createvariation(
        model="dall-e-2",
        image=f,
        n=1,
        size="1024x1024"
    )

variationurl = response.data[0].url

import base64

def encodeimage(imagepath):

    with open(imagepath, "rb") as f:
        return base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gpt-4-vision-deployment",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Apa yang ada di gambar ini?"},
                {
                    "type": "imageurl",

                    "imageurl": {
                        "url": f"data:image/png;base64,{encodeimage('image.png')}"

                    }
                }
            ]
        }
    ],
    maxtokens=500
)

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

response = client.chat.completions.create(
    model="gpt-4-vision-deployment",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Bandingkan kedua gambar ini:"},
                {
                    "type": "imageurl",

                    "imageurl": {"url": f"data:image/png;base64,{encodeimage('image1.png')}"}

                },
                {
                    "type": "imageurl",
                    "imageurl": {"url": f"data:image/png;base64,{encodeimage('image2.png')}"}
                }
            ]
        }
    ]
)

from openai import APIError, RateLimitError
import time

def callwithretry(func, maxretries=3):

    for attempt in range(maxretries):
        try:
            return func()
        except RateLimitError:
            waittime = 2  attempt

            print(f"Rate limited, menunggu {waittime}s...")
            time.sleep(waittime)

        except APIError as e:
            print(f"API error: {e}")
            raise
    raise Exception("Max retries exceeded")

Penggunaan
result = callwithretry(

    lambda: client.chat.completions.create(
        model="gpt-4-deployment",
        messages=[{"role": "user", "content": "Halo"}]
    )
)

import tiktoken

def counttokens(text, model="gpt-4"):
    encoding = tiktoken.encodingformodel(model)
    return len(encoding.encode(text))

def truncatetotokens(text, maxtokens, model="gpt-4"):

    encoding = tiktoken.encodingformodel(model)

    tokens = encoding.encode(text)
    if len(tokens) > maxtokens:
        tokens = tokens[:maxtokens]

    return encoding.decode(tokens)

Cek jumlah token
text = "Teks panjang Anda di sini..."
print(f"Tokens: {counttokens(text)}")

Key takeaways:

• Gunakan model yang sesuai untuk tugas
• Implementasikan error handling yang proper
• Kelola tokens secara efektif
• Gunakan RAG untuk domain knowledge
• Monitor penggunaan dan biaya