Ringkasan kode dengan Granite

Ringkasan kode adalah proses menghasilkan deskripsi dalam bahasa alami dari cuplikan kode. Tugas umum dalam meringkas kode termasuk menelusuri basis kode baru, mempelajari bahasa pemrograman baru, atau menghasilkan komentar kode dan penjelasan fungsi. Membuat ringkasan dari sebuah cuplikan kode mirip dengan membuat ringkasan teks dari dokumen bahasa alami . Ini berbeda karena model bahasa besar (LLM) yang menghasilkan ringkasan perlu memahami bahasa pemrograman yang dibacanya sambil mengidentifikasi logika yang mendasari apa yang ingin dicapai.

Ringkasan kode merupakan bagian penting dari pengembangan perangkat lunak, membantu pemeliharaan perangkat lunak dengan melakukan peringkasan kode sumber secara otomatis, membuat ringkasan bahasa alami untuk dokumentasi, atau mengurai basis kode skala besar. Model LLM yang lebih baru yang menggunakan pendekatan berbasis transformator dapat bertindak sebagai model ringkasan kode atau menjalankan pembuatan kode juga. Fungsi-fungsi ini dimungkinkan karena model telah dilatih pada kumpulan data besar yang dibangun dari sumber seperti repositori Github yang menyertakan kode dan komentar bersama dengan dokumentasi untuk kode itu.

Sebelum LLM dipopulerkan, pendekatan untuk ringkasan kode memerlukan parsing semantik kode dan menghasilkan pohon sintaks abstrak (AST) dari setiap pengidentifikasi dari kode yang kemudian dapat digunakan untuk menghasilkan dokumentasi.^1,2 Dengan munculnya pembelajaran mendalam dan jaringan neural, pendekatan yang berakar pada ilmu komputer ditinggalkan demi pendekatan yang lebih banyak meminjam metodologi dari penerjemahan mesin neural ^3,4.

Untuk model transformator, jendela konteks yang lebih besar menghasilkan hasil yang lebih baik. Banyak model Kode Granite terbaru yang canggih seperti Granite-8B-Code-Instruct-128K, memiliki jendela konteks 128k. Jendela konteks yang lebih besar memungkinkan model untuk menyimpan lebih banyak teks dalam memori kerja. Ini membantu memantau momen dan detail penting dalam obrolan yang berlarut-larut, atau dokumen atau basis kode yang panjang. Memori kerja ini memungkinkan chatbot berbasis LLM untuk menghasilkan respons yang masuk akal dalam waktu cepat dan dalam konteks yang lebih panjang, membantu mereka mengungguli model dengan jendela konteks yang lebih kecil baik dengan evaluasi manusia dan metrik evaluasi.⁵

Jendela konteks yang lebih besar memungkinkan model menyimpan lebih banyak teks dalam memori kerja mereka, membantu melacak momen dan detail penting dalam obrolan yang berlarut-larut atau dokumen atau basis kode yang panjang.

Ketika ChatGPT pertama kali diperkenalkan jendela konteksnya adalah 4.000 token. Jika percakapan Anda melampaui batas antarmuka obrolan 3.000 kata, chatbot kemungkinan akan berhalusinasi dan membelok di luar topik. Saat ini, standarnya adalah 32.000 token, dengan industri beralih ke 128.000 token. Itu kira-kira panjangnya buku 250 halaman. IBM sekarang memiliki dua model Granite dengan jendela 128.000 token dan lebih banyak lagi sedang dalam perjalanan.

Pada langkah ini, kami akan memandu Anda melalui pembuatan akun IBM untuk mengakses Jupyter Notebook.

1. Masuk ke watsonx.ai menggunakan akun IBM® Cloud Anda.

2. Klik + untuk membuat proyek baru.

a. Pilih Buat proyek kosong.

b. Masukkan nama proyek di bidang Nama.

c. Buat Cloud Object Storage untuk menyimpan aset proyek Anda jika belum dibuat.

d. Pilih Buat.

3. Buat Jupyter Notebook.

a. Pilih tab Aset di lingkungan proyek Anda.

b. Klik Aset baru.

c. Pilih opsi Bekerja dengan model di panel kiri.

d. Klik Bekerja dengan data dan model menggunakan notebook Python dan R.

e. Masukkan nama untuk notebook Anda di bidang Nama. Pilih waktu proses 23.1 pada Python (4 vCPU 16 GB RAM) untuk menentukan konfigurasi.

f. Pilih Buat.

4. Menyiapkan instance Waktu Proses watsonx.ai dan kunci API

a. Buat instance layanan Runtime watsonx.ai (pilih wilayah yang sesuai dan pilih paket Lite, yang merupakan instance gratis).

b. Buat API Key.

c. Kaitkan instance layanan waktu proses watsonx.ai ke proyek yang Anda buat di watsonx.ai.

Pertama, kita akan menginstal pustaka Hugging Face Hub sumber terbuka untuk mengunduh model:

Sekarang kita dapat mengunduh Granite-8B-Code-Instruct-128K:

Sekarang kita bisa mulai menggunakan Granite Code Instruct.

Mari kita berikan model kita panggilan fungsi yang cukup kompleks dari perpustakaan Gluonts, diambil dari repositori GitHub mereka. Ini adalah blok kode panjang untuk ditempelkan dalam prompt sehingga kami akan menyimpannya dalam variabel:

ll_func_2 = """

    def call(
        self, data: torch.Tensor, weights: torch.Tensor
    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:

    assert (
        data.shape == weights.shape
    ), "data and observed_indicator must have same shape"

    with torch.no_grad():

        observed_data = torch.where(weights == 1, data, torch.nan)
        med = torch.nanmedian(observed_data, dim=self.dim, keepdim=True).values
        q1 = torch.nanquantile(observed_data, 0,25, dim=self.dim, keepdim=True)
        q3 = torch.nanquantile(observed_data, 0,75, dim=self.dim, keepdim=True)
        iqr = q3 - q1

        # if observed data is all zeros, nanmedian returns nan
        loc = torch.where(torch.isnan(med), torch.zeros_like(med), med)
        scale = torch.where(torch.isnan(iqr), torch.ones_like(iqr), iqr)
        scale = torch.maximum(scale, torch.full_like(iqr, self.minimum_scale))
        scaled_data = (data - loc) / scale

        if not self.keepdim:
            loc = torch.squeeze(loc, dim=self.dim)
            scale = torch.squeeze(scale, dim=self.dim)

        # assert no nans in scaled data, loc or scale
        assert not torch.any(torch.isnan(scaled_data))
        assert not torch.any(torch.isnan(loc))
        assert not torch.any(torch.isnan(scale))
        assert not torch.any(scale == 0)

        return scaled_data, loc, scaledef call(
            self, data: torch.Tensor, weights: torch.Tensor
        ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:

        assert (
            data.shape == weights.shape
        ), "data and observed_indicator must have same shape"

Sekarang kita dapat meminta Granite Code untuk ringkasan dengan membuat token obrolan kita dan kemudian memanggil model.generate()

chat = [
{ "role": "user", "content": "Explain what this function does" + ll_func_2 },
]
chat = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)

# have the encoder turn text into output tokens
inputs = tokenizer(chat, return_tensors="pt").input_ids
start_index = inputs.shape[-1]

# generate output tokens
output = model.generate(inputs, max_new_tokens=1500)

# have the decoder turn output tokens into text
output = tokenizer.batch_decode(output[start_index:])

# loop over the batch to print, in this example the batch size is 1
print(output[0])

Mari kita periksa ringkasan yang dihasilkan:

Jawaban:
Fungsi ini melakukan normalisasi data menggunakan metode rentang interkuartil (IQR). Dibutuhkan dua argumen: data dan bobot. Argumen data adalah tensor bentuk (batch_size, sequence_length, hidden_size), di mana batch_size adalah jumlah sampel dalam batch, sequence_length adalah panjang urutan input, dan hidden_size adalah dimensi dari keadaan tersembunyi. Argumen bobot adalah tensor berbentuk (batch_size, sequence_length), di mana setiap elemen bernilai 0 atau 1, menunjukkan apakah elemen yang sesuai dalam tensor data diamati atau hilang.

Fungsi pertama-tama memeriksa apakah tensor data dan bobot memiliki bentuk yang sama. Kemudian, ia menghitung median dan IQR dari titik data yang diamati (yang dengan bobot 1) menggunakan fungsi torch.nanmedian dan torch.nanquantile. Fungsi torch.nanmedian menghitung median sepanjang dimensi yang ditentukan (`self.dim`), sedangkan fungsi torch.nanquantile menghitung persentil ke-25 dan ke-75.

Selanjutnya, fungsi menghitung parameter lokasi (`loc`) dan skala (`skala`) dari distribusi yang dinormalisasi. Lokasi diatur ke median titik data yang diamati, dan skala diatur ke IQR dari titik data yang diamati. Jika titik data yang diamati semuanya nol, fungsi menetapkan lokasi ke nol. Fungsi ini juga memastikan bahwa skala setidaknya merupakan nilai minimum (`self.minimum_scale`) untuk menghindari pembagian dengan nol.

Akhirnya, fungsi menghitung data yang dinormalisasi (`scaled_data`) dengan mengurangi lokasi dan membaginya dengan skala. Jika argumen keepdim disetel ke False, fungsi menghapus dimensi yang ditentukan dari lokasi dan skala tensor. Fungsi ini juga melakukan pernyataan untuk memastikan bahwa data, lokasi, dan tensor skala yang dinormalisasi tidak mengandung nilai NaN atau nol dalam skala.

Fungsi mengembalikan tupel yang berisi data, lokasi, dan tensor skala yang dinormalisasi.

Deskripsi ini sangat rinci dan secara akurat menggambarkan fungsi yang kami berikan dan algoritma yang mendasarinya.

Menghasilkan dokumentasi adalah aplikasi ringkasan kode yang kuat karena tidak hanya menjelaskan kode kepada pengguna masa depan yang membaca kode tetapi juga dapat membantu menghasilkan dokumentasi menggunakan alat seperti pydoc.

Kita sekarang dapat meminta Granite Code untuk menghasilkan docstrings untuk suatu fungsi. Karena jendela konteks yang lebih besar kita dapat meneruskan seluruh fungsi bersama dengan permintaan untuk menghasilkan docstring. 

Silakan tulis docstring Python yang diformat dengan benar untuk fungsi berikut:

Kode Granite mengembalikan dokumentasi yang sangat baik dalam format Python:

Mengekstrak objek JSON dari string HTML yang diberikan menggunakan tombol yang ditentukan dan karakter berhenti.
Args:

    html (str): String HTML input untuk mengekstrak objek JSON dari.

    key (str): Kunci yang digunakan untuk menemukan awal objek JSON dalam string HTML.

    num_chars (int, opsional): Jumlah karakter setelah kunci untuk disertakan dalam objek JSON yang diekstraksi. Defaultnya 2.

 stop (str, opsional): Karakter yang menandai akhir objek JSON dalam string HTML. Default ke '"'.

Pengembalian:

    str: Objek JSON yang diekstraksi sebagai string.

Sekarang jika mau, kita dapat menggunakan kembali prompt sebelumnya yang masih ada di jendela konteks besar:

chat = "Rewrite the previous function to be a class method and include the docstrings."

# have the encoder turn text into output tokens
inputs = tokenizer(chat, return_tensors="pt").input_ids
start_index = inputs.shape[-1]

# generate output tokens
output = model.generate(inputs, max_new_tokens=1500)

# have the decoder turn output tokens into text
output = tokenizer.batch_decode(output[start_index:])

# loop over the batch to print, in this example the batch size is 1
print(output[0])

Ini menghasilkan

class HtmlJsonExtractor:

    def init(self, html):

    """
    Initializes the HtmlJsonExtractor object with the given HTML string.

    Args:

        html (str): The input HTML string to extract JSON objects from.
    """

        self.html = html

    @classmethod

    def extract(cls, html, key, num_chars=2, stop='"'):

    """
    Extracts a JSON object from the given HTML string using the specified key and stop character.

    Args:

        html (str): The input HTML string to extract the JSON object from.

        key (str): The key used to locate the start of the JSON object in the HTML string.

        num_chars (int, opsional): Jumlah karakter setelah kunci untuk disertakan dalam objek JSON yang diekstraksi. Defaultnya 2.

 stop (str, opsional): Karakter yang menandai akhir objek JSON dalam string HTML. Default ke '"'.

    Mengembalikan:

 str: Objek JSON yang diekstrak sebagai string.
    """

        pos_begin = html.find(key) + len(key) + num_chars
        pos_end = html.find(stop, pos_begin)
        return html[pos_begin:pos_end]

Model sekarang telah membuat kelas dengan nama yang sesuai, menjadikan kode sebelumnya sebagai metode kelas itu, dan memasukkan docstrings kami.

Sekarang mari kita prompt model untuk membantu kita mengoptimalkan cuplikan kode:

chat = """Please optimize the following code:

def fib(n):
    if (n < 2):
        return 1
    else:
        return fib(n-1) + fib(n-2)"""

Kode Granite mengembalikan:

Fungsi Python fib(n) menghitung bilangan Fibonacci ke-n menggunakan rekursi. Namun, implementasi ini memiliki kompleksitas waktu O (2^n), yang tidak efisien untuk input besar. Kita bisa

mengoptimalkannya menggunakan pemrograman dinamis atau memoisasi untuk mengurangi kompleksitas waktu menjadi O(n). Berikut versi fungsi yang dioptimalkan:

```python

def fib_optimized(n, memo={}):
    if n < 2:
        return 1
    elif n not in memo:
        memo[n] = fib_optimized(n-1, memo) + fib_optimized(n-2, memo)
    return memo[n]
```

Versi yang dioptimalkan ini menggunakan memo kamus untuk menyimpan angka Fibonacci yang dihitung sebelumnya. Saat menghitung angka Fibonacci ke-n, pertama-tama memeriksa apakah sudah dihitung dan disimpan dalam memo. Jika demikian, ia mengembalikan nilai yang disimpan alih-alih menghitung ulang, yang menghemat waktu dan meningkatkan kinerja.

Di sini model telah menjelaskan tidak hanya apa yang salah dengan fungsi dalam hal efisiensi dan memberikan kompleksitas Big-O pada implementasi, tetapi juga memberikan implementasi yang lebih baik. Memberikan ulasan dan penjelasan adalah cara untuk memanfaatkan ringkasan dan sebagai bagian dari pembuatan kode yang lebih umum untuk membantu pengembang meningkatkan.

Dalam tutorial ini Anda belajar tentang ringkasan kode dan menggunakan model Kode Granite dengan jendela konteks yang diperluas dari 128k token untuk menghasilkan penjelasan kode Python. Kami juga menggunakan prompt untuk menghasilkan dokumentasi baru, menambahkan kelas di sekitar sepotong kode dan menggunakan jendela konteks yang diperluas untuk menambahkan dokumentasi itu ke jendela kode baru. Akhirnya, kami meminta Granite Code menganalisis dan meringkas cuplikan kode dan menjelaskan bagaimana itu dapat ditingkatkan.