Platform For AI:Panduan cepat Model Gallery

Untuk menjalankan kode berikut, Anda perlu membuat Kunci API Alibaba Cloud Model Studio. Kode ini menggunakan qwen-plus-latest untuk menghasilkan data bisnis dan qwen3-235b-a22b untuk pelabelan.

# -*- coding: utf-8 -*-
import os
import asyncio
import random
import json
import sys
from typing import List
import platform
from openai import AsyncOpenAI

# Buat instance klien asinkron.
# CATATAN: Skrip ini menggunakan endpoint API kompatibel DashScope.
# Jika Anda menggunakan layanan kompatibel OpenAI lain, ubah base_url-nya.
client = AsyncOpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
)

# Daftar Negara Bagian dan Wilayah AS.
us_states = [
    "Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado", "Connecticut", "Delaware",
    "Florida", "Georgia", "Hawaii", "Idaho", "Illinois", "Indiana", "Iowa", "Kansas", "Kentucky",
    "Louisiana", "Maine", "Maryland", "Massachusetts", "Michigan", "Minnesota", "Mississippi",
    "Missouri", "Montana", "Nebraska", "Nevada", "New Hampshire", "New Jersey", "New Mexico",
    "New York", "North Carolina", "North Dakota", "Ohio", "Oklahoma", "Oregon", "Pennsylvania",
    "Rhode Island", "South Carolina", "South Dakota", "Tennessee", "Texas", "Utah", "Vermont",
    "Virginia", "Washington", "West Virginia", "Wisconsin", "Wyoming", "District of Columbia",
    "Puerto Rico", "Guam", "American Samoa", "Kepulauan Virgin AS", "Kepulauan Mariana Utara"
]

# Template penerima.
recipient_templates = [
    "Kepada: {name}", "Penerima: {name}", "Kirim ke {name}", "Untuk: {name}",
    "ATTN: {name}", "{name}", "Nama: {name}", "Kontak: {name}", "Penerima: {name}"
]

# Template nomor telepon.
phone_templates = [
    "Tel: {phone}", "Tel. {phone}", "Ponsel: {phone}", "Telepon: {phone}",
    "Nomor kontak: {phone}", "Nomor telepon {phone}", "TEL: {phone}", "PONSEL: {phone}",
    "Kontak: {phone}", "P: {phone}", "{phone}", "Hubungi: {phone}",
]


# Hasilkan nomor telepon bergaya AS yang masuk akal.
def generate_us_phone():
    """Menghasilkan nomor telepon AS acak 10 digit dalam format (XXX) XXX-XXXX."""
    area_code = random.randint(201, 999)  # Hindari kode area 0xx, 1xx.
    exchange = random.randint(200, 999)
    line = random.randint(1000, 9999)
    return f"({area_code}) {exchange}-{line}"


# Gunakan LLM untuk menghasilkan informasi penerima dan alamat.
async def generate_recipient_and_address_by_llm(state: str):
    """Menggunakan LLM untuk menghasilkan nama penerima dan detail alamat untuk negara bagian tertentu."""
    prompt = f"""Harap hasilkan informasi penerima untuk lokasi di {state}, AS, termasuk:
1. Nama lengkap bahasa Inggris yang realistis. Upayakan keragaman.
2. Nama kota nyata dalam negara bagian tersebut.
3. Alamat jalan spesifik, seperti nomor dan nama jalan, serta nomor apartemen. Harus realistis.
4. Kode ZIP 5 digit yang sesuai untuk kota atau area tersebut.

Harap kembalikan hanya objek JSON dalam format berikut:
{{"name": "Nama Penerima", "city": "Nama Kota", "street_address": "Alamat Jalan Spesifik", "zip_code": "Kode ZIP"}}

Jangan sertakan teks lain, hanya JSON. Pastikan nama beragam, bukan hanya John Doe.
"""

    try:
        response = await client.chat.completions.create(
            messages=[{"role": "user", "content": prompt}],
            model="qwen-plus-latest",
            temperature=1.5,  # Tingkatkan suhu untuk nama dan alamat yang lebih beragam.
        )

        result = response.choices[0].message.content.strip()
        # Bersihkan penanda blok kode markdown yang mungkin ada.
        if result.startswith('```'):
            result = result.split('\n', 1)[1]
        if result.endswith('```'):
            result = result.rsplit('\n', 1)[0]

        # Coba uraikan JSON.
        info = json.loads(result)
        print(info)
        return info
    except Exception as e:
        print(f"Gagal menghasilkan penerima dan alamat: {e}, menggunakan cadangan.")
        # Mekanisme cadangan.
        backup_names = ["Michael Johnson", "Emily Williams", "David Brown", "Jessica Jones", "Christopher Davis",
                        "Sarah Miller"]
        return {
            "name": random.choice(backup_names),
            "city": "Anytown",
            "street_address": f"{random.randint(100, 9999)} Main St",
            "zip_code": f"{random.randint(10000, 99999)}"
        }


# Hasilkan satu catatan data mentah.
async def generate_record():
    """Menghasilkan satu string gabungan berantakan informasi alamat AS."""
    # Pilih negara bagian secara acak.
    state = random.choice(us_states)

    # Gunakan LLM untuk menghasilkan info penerima dan alamat.
    info = await generate_recipient_and_address_by_llm(state)

    # Format nama penerima.
    recipient = random.choice(recipient_templates).format(name=info['name'])

    # Hasilkan nomor telepon.
    phone = generate_us_phone()
    phone_info = random.choice(phone_templates).format(phone=phone)

    # Susun baris alamat lengkap.
    full_address = f"{info['street_address']}, {info['city']}, {state} {info['zip_code']}"

    # Gabungkan semua komponen.
    components = [recipient, phone_info, full_address]

    # Acak urutan komponen.
    random.shuffle(components)

    # Pilih pemisah acak.
    separators = [' ', ', ', '; ', ' | ', '\t', ' - ', ' // ', '', '  ']
    separator = random.choice(separators)

    # Gabungkan komponen.
    combined_data = separator.join(components)
    return combined_data.strip()


# Hasilkan batch data.
async def generate_batch_data(count: int) -> List[str]:
    """Menghasilkan jumlah catatan data tertentu."""
    print(f"Mulai menghasilkan {count} catatan...")

    # Gunakan semaphore untuk mengontrol konkurensi, misalnya hingga 20 permintaan konkuren.
    semaphore = asyncio.Semaphore(20)

    async def generate_single_record(index):
        async with semaphore:
            try:
                record = await generate_record()
                print(f"Catatan #{index + 1} dihasilkan: {record}")
                return record
            except Exception as e:
                print(f"Gagal menghasilkan catatan #{index + 1}: {e}")
                return None

    # Hasilkan data secara konkuren.
    tasks = [generate_single_record(i) for i in range(count)]

    data = await asyncio.gather(*tasks)

    successful_data = [record for record in data if record is not None]

    return successful_data


# Simpan data ke file.
def save_data(data: List[str], filename: str = "us_recipient_data.json"):
    """Menyimpan data yang dihasilkan ke file JSON."""
    with open(filename, 'w', encoding='utf-8') as f:
        json.dump(data, f, ensure_ascii=False, indent=2)
    print(f"Data telah disimpan ke {filename}")


# Fase 1: Produksi Data.
async def produce_data_phase():
    """Menangani generasi data penerima mentah."""
    print("=== Fase 1: Memulai Generasi Data Penerima Mentah ===")

    # Hasilkan 2.000 catatan.
    batch_size = 2000
    data = await generate_batch_data(batch_size)

    # Simpan data.
    save_data(data, "us_recipient_data.json")

    print(f"\nTotal catatan yang dihasilkan: {len(data)}")
    print("\nData Contoh:")
    for i, record in enumerate(data[:3]):  # Tampilkan 3 pertama sebagai contoh.
        print(f"{i + 1}. Data Mentah: {record}\n")

    print("=== Fase 1 Selesai ===\n")
    return True


# Tentukan prompt sistem untuk model ekstraksi.
def get_system_prompt_for_extraction():
    """Mengembalikan prompt sistem untuk tugas ekstraksi informasi."""
    return """Anda adalah asisten ekstraksi informasi profesional yang berspesialisasi dalam mengurai alamat pengiriman AS dari teks tidak terstruktur.

## Deskripsi Tugas
Berdasarkan teks masukan yang diberikan, ekstrak dan hasilkan objek JSON yang berisi enam bidang berikut:
- name: Nama lengkap penerima.
- street_address: Alamat jalan lengkap, termasuk nomor, nama jalan, dan nomor apartemen atau suite apa pun.
- city: Nama kota.
- state: Nama lengkap negara bagian (misalnya, "California", bukan "CA").
- zip_code: Kode ZIP 5 atau 9 digit.
- phone: Nomor telepon kontak lengkap.

## Aturan Ekstraksi
1.  **Penanganan Alamat**:
    -   Identifikasi secara akurat komponen: jalan, kota, negara bagian, dan kode ZIP.
    -   Bidang `state` harus berupa nama resmi lengkap (misalnya, "New York", bukan "NY").
    -   `street_address` harus berisi semua detail sebelum kota, seperti "123 Apple Lane, Apt 4B".
2.  **Identifikasi Nama**:
    -   Ekstrak nama penerima lengkap.
3.  **Penanganan Nomor Telepon**:
    -   Ekstrak nomor telepon lengkap, mempertahankan format aslinya.
4.  **Kode ZIP**:
    -   Ekstrak kode 5 digit atau 9 digit (ZIP+4).

## Format Output
Patuhi secara ketat format JSON berikut. Jangan tambahkan teks penjelasan atau markdown.
{
  "name": "Nama Lengkap Penerima",
  "street_address": "Alamat Jalan Lengkap",
  "city": "Nama Kota",
  "state": "Nama Negara Bagian Lengkap",
  "zip_code": "Kode ZIP",
  "phone": "Nomor Telepon Kontak"
}
"""


# Gunakan LLM untuk memprediksi data terstruktur dari teks mentah.
async def predict_structured_data(raw_data: str):
    """Menggunakan LLM untuk memprediksi data terstruktur dari string mentah."""
    system_prompt = get_system_prompt_for_extraction()

    try:
        response = await client.chat.completions.create(
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": raw_data}
            ],
            model="qwen3-235b-a22b",  # Model kuat direkomendasikan untuk tugas ini.
            temperature=0.0,  # Suhu lebih rendah untuk akurasi ekstraksi yang lebih tinggi.
            response_format={"type": "json_object"},
            extra_body={"enable_thinking": False}
        )

        result = response.choices[0].message.content.strip()

        # Bersihkan penanda blok kode markdown yang mungkin ada.
        if result.startswith('```'):
            lines = result.split('\n')
            for i, line in enumerate(lines):
                if line.strip().startswith('{'):
                    result = '\n'.join(lines[i:])
                    break
        if result.endswith('```'):
            result = result.rsplit('\n```', 1)[0]

        structured_data = json.loads(result)
        return structured_data

    except Exception as e:
        print(f"Gagal memprediksi data terstruktur: {e}, Data mentah: {raw_data}")
        # Kembalikan struktur kosong jika gagal.
        return {
            "name": "",
            "street_address": "",
            "city": "",
            "state": "",
            "zip_code": "",
            "phone": ""
        }


# Fase 2: Konversi Data.
async def convert_data_phase():
    """Membaca data mentah, memprediksi format terstruktur, dan menyimpan sebagai data SFT."""
    print("=== Fase 2: Memulai Konversi Data ke Format SFT ===")

    try:
        print("Membaca file us_recipient_data.json...")
        with open('us_recipient_data.json', 'r', encoding='utf-8') as f:
            raw_data_list = json.load(f)

        print(f"Berhasil membaca {len(raw_data_list)} catatan.")
        print("Mulai memprediksi data terstruktur menggunakan model ekstraksi...")

        # Pesan sistem yang sederhana dan jelas dapat meningkatkan kecepatan pelatihan dan inferensi.
        system_prompt = "Anda adalah asisten ahli untuk mengekstraksi JSON terstruktur dari informasi pengiriman AS. Kunci JSON-nya adalah name, street_address, city, state, zip_code, dan phone."
        output_file = 'us_recipient_sft_data.json'

        # Gunakan semaphore untuk mengontrol konkurensi.
        semaphore = asyncio.Semaphore(10)

        async def process_single_item(index, raw_data):
            async with (semaphore):
                structured_data = await predict_structured_data(raw_data)
                print(f"Memproses catatan #{index + 1}: {raw_data}")

                conversation = {
                        "instruction": system_prompt + '  ' + raw_data,
                        "output": json.dumps(structured_data, ensure_ascii=False)
                }

                return conversation

        print(f"Memulai konversi ke {output_file}...")

        tasks = [process_single_item(i, raw_data) for i, raw_data in enumerate(raw_data_list)]
        conversations = await asyncio.gather(*tasks)

        with open(output_file, 'w', encoding='utf-8') as outfile:
            json.dump(conversations, outfile, ensure_ascii=False, indent=4)

        print(f"Konversi selesai! Diproses {len(raw_data_list)} catatan.")
        print(f"File output: {output_file}")
        print("=== Fase 2 Selesai ===")

    except FileNotFoundError:
        print("Kesalahan: us_recipient_data.json tidak ditemukan.")
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Kesalahan decoding JSON: {e}")
        sys.exit(1)
    except Exception as e:
        print(f"Terjadi kesalahan selama konversi: {e}")
        sys.exit(1)


# Fungsi utama.
async def main():
    print("Memulai pipeline pemrosesan data...")
    print("Program ini akan menjalankan dua fase secara berurutan:")
    print("1. Menghasilkan data penerima AS mentah.")
    print("2. Memprediksi data terstruktur dan mengonversinya ke format SFT.")
    print("-" * 50)

    # Fase 1: Hasilkan data.
    success = await produce_data_phase()

    if success:
        # Fase 2: Konversi data.
        await convert_data_phase()

        print("\n" + "=" * 50)
        print("Semua proses selesai dengan sukses!")
        print("File yang dihasilkan:")
        print("- us_recipient_data.json: Daftar data mentah tidak terstruktur.")
        print("- us_recipient_sft_data.json: Data pelatihan berformat SFT.")
        print("=" * 50)
    else:
        print("Fase generasi data gagal. Menghentikan.")


if __name__ == '__main__':
    # Atur kebijakan loop peristiwa untuk Windows jika diperlukan.
    if platform.system() == 'Windows':
        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())

    # Jalankan korutin utama.
    asyncio.run(main(), debug=False)