Tutorial Metaflow untuk Pemula: Membangun dan Menskalakan Alur Kerja Data

Menyiapkan Metaflow

Metaflow menyarankan pengguna menginstal Python 3, bukan Python 2.7, untuk proyek baru. Dokumentasi menyatakan bahwa “Python 3 memiliki lebih sedikit bug dan dukungannya lebih baik dibandingkan Python 2.7 yang sudah tidak digunakan lagi.”

Langkah berikutnya adalah membuat lingkungan virtual untuk mengelola dependensi proyek Anda. Jalankan perintah berikut untuk melakukannya: 

python -m venv venv
source venv/bin/activate

Ini akan membuat dan mengaktifkan lingkungan virtual. Setelah aktif, Anda siap menginstal Metaflow. 

Metaflow tersedia sebagai paket Python untuk MacOS dan Linux. Versi terbaru dapat diinstal dari repositori Metaflow di Github atau PyPi dengan menjalankan perintah berikut: 

pip install metaflow

Sayangnya, saat penulisan ini, Metaflow belum menawarkan dukungan native untuk pengguna Windows. Namun, pengguna Windows 10 dapat menggunakan WSL (Windows Subsystem for Linux) untuk menginstal Metaflow, yang memungkinkan mereka menjalankan lingkungan Linux di dalam sistem operasi Windows. Sim ak dokumentasi untuk panduan langkah demi langkah menginstal Metaflow di Windows 10. 

Integrasi AWS (Opsional)

Metaflow menawarkan integrasi mulus dengan AWS, yang memungkinkan pengguna menskalakan workflow mereka menggunakan infrastruktur cloud. Untuk mengintegrasikan AWS, Anda perlu menyiapkan kredensial AWS Anda.

Catatan: Langkah-langkah ini mengasumsikan Anda sudah memiliki akun AWS dan AWS CLI terpasang. Untuk detail lebih lanjut, ikuti petunjuk di dokumentasi AWS. 

1. Pertama, pasang AWS CLI dengan menjalankan:

pip install awscli

2. Konfigurasikan AWS dengan menjalankan

aws configure

Dari sini, Anda akan diminta memasukkan AWS Access Key ID dan Secret Access Key—ini adalah kredensial yang digunakan AWS CLI untuk mengautentikasi permintaan Anda ke AWS. Perlu dicatat bahwa Anda juga mungkin diminta memasukkan region dan format output. 

Setelah Anda memasukkan detail ini, voila! Metaflow akan otomatis menggunakan kredensial AWS Anda untuk menjalankan workflow. 

Membangun Workflow Pertama Anda dengan Metaflow

Sekarang Metaflow sudah siap, saatnya membangun workflow pertama Anda. Pada bagian ini, saya akan memandu Anda melalui dasar-dasar membuat flow, menjalankannya, dan memahami cara tugas serta langkah diatur dalam Metaflow. 

Di akhir bagian ini, Anda akan memiliki workflow yang memproses data dan melakukan operasi sederhana. Mari mulai!

Gambaran umum sebuah flow di Metaflow

Metaflow menggunakan paradigma dataflow, yang mewakili program sebagai graf berarah dari operasi. Pendekatan ini ideal untuk membangun pipeline pemrosesan data, terutama dalam machine learning.

Dalam Metaflow, graf operasi disebut flow. Sebuah flow terdiri dari serangkaian tugas yang dipecah menjadi langkah-langkah. Perlu dicatat bahwa setiap langkah dapat dianggap sebagai operasi yang direpresentasikan sebagai node, dengan transisi antar langkah bertindak sebagai edge dari graf.

Transisi linear dasar Metaflow | Sumber: Dokumentasi Metaflow

Ada beberapa aturan struktural untuk flow di Metaflow. Misalnya, setiap flow harus menyertakan langkah start dan langkah end. Saat sebuah flow dieksekusi, yang disebut run, ia dimulai dengan langkah start dan dianggap berhasil jika mencapai langkah end tanpa error. 

Apa yang terjadi di antara langkah start dan end sepenuhnya terserah Anda—sebagaimana akan Anda lihat pada segmen berikutnya. 

Menulis flow pertama Anda

Berikut flow sederhana untuk memulai. Catatan: Kode dapat dijalankan di DataLab.

from metaflow import FlowSpec, step

class MyFirstFlow(FlowSpec):
    @step
    def start(self):
        print("Starting the flow!")
        self.data = [1, 2, 3, 4, 5]  # Example dataset
        self.next(self.process_data)
    @step
    def process_data(self):
        self.processed_data = [x * 2 for x in self.data]  # Simple data processing
        print("Processed data:", self.processed_data)
        self.next(self.end)
    @step
    def end(self):
        print("Flow is complete!")

if __name__ == '__main__': 
    MyFirstFlow()

Dalam flow ini:

• Langkah start() menginisialisasi workflow dan mendefinisikan dataset.
• Langkah process_data() memproses data dengan mengalikan dua setiap elemen.
• Langkah end() menyelesaikan flow.

Setiap langkah menggunakan dekorator @step, dan Anda menentukan urutan flow menggunakan self.next() untuk menghubungkan langkah-langkahnya.

Menjalankan flow Anda

Setelah menulis flow, simpan sebagai my_first_flow.py. Jalankan dari command line dengan menggunakan:

py -m my_first_flow.py run

Fitur baru ditambahkan pada Metaflow 2.12 yang memungkinkan pengguna mengembangkan dan menjalankan flow di notebook. 

Untuk mengeksekusi flow dalam satu sel tertentu, Anda hanya perlu menambahkan one-liner NBRunner pada baris terakhir di sel yang sama. Contohnya:

from metaflow import FlowSpec, step, NBRunner

class MyFirstFlow(FlowSpec):
    @step
    def start(self):
        print("Starting the flow!")
        self.data = [1, 2, 3, 4, 5]  # Example dataset
        self.next(self.process_data)
    @step
    def process_data(self):
        self.processed_data = [x * 2 for x in self.data]  # Simple data processing
        print("Processed data:", self.processed_data)
        self.next(self.end)
    @step
    def end(self):
        print("Flow is complete!")

run = NBRunner(MyFirstFlow).nbrun()

Jika Anda mendapatkan error berikut:

“Metaflow could not determine your user name based on environment variables ($USERNAME etc.)”

Tambahkan hal berikut ke kode Anda sebelum eksekusi Metaflow:

import os
if os.environ.get("USERNAME") is None:
    os.environ["USERNAME"] = "googlecolab"

Pada kedua kasus, Metaflow akan mengeksekusi flow selangkah demi selangkah. Secara khusus, ia akan menampilkan output setiap langkah di terminal sebagai berikut: 

Output dari kode di atas | Sumber: Gambar oleh penulis

Konsep Inti dalam Metaflow

Memahami konsep inti Metaflow sangat penting untuk membangun alur kerja data yang efisien dan dapat diskalakan. Pada bagian ini, saya akan membahas tiga konsep fundamental: 

• Langkah-langkah dan branching
• Data artifact
• Versioning 

Elemen-elemen ini membentuk tulang punggung struktur dan eksekusi workflow Metaflow, memungkinkan Anda mengelola proses kompleks dengan mudah.

Langkah-langkah dan branching

Kita sempat menyinggung langkah sebelumnya, namun demi kejelasan, mari kita tinjau lagi. Hal terpenting tentang workflow Metaflow adalah bahwa workflow dibangun berdasarkan langkah-langkah. 

Langkah mewakili setiap tugas individual dalam sebuah workflow. Dengan kata lain, setiap langkah akan melakukan operasi tertentu (misalnya, pemuatan data, pemrosesan, pemodelan, dan sebagainya). 

Contoh yang kita buat di atas pada “Menulis flow pertama Anda” adalah transformasi linear. Selain langkah berurutan, Metaflow juga memungkinkan pengguna melakukan branch pada workflow. Workflow bercabang memungkinkan Anda menjalankan beberapa tugas secara paralel dengan membuat jalur eksekusi terpisah. 

Contoh branching | Sumber: Dokumentasi Metaflow

Manfaat utama branching adalah performa. Branching berarti Metaflow dapat mengeksekusi berbagai langkah pada banyak core CPU atau instance di cloud. 

Berikut tampilan sebuah branch dalam kode: 

from metaflow import FlowSpec, step, NBRunner

class BranchFlow(FlowSpec):
    @step
    def start(self):
        print("Starting the flow!")
        self.data = [1, 2, 3, 4, 5]  # Example dataset
        self.next(self.split)
    @step
    def split(self):
        self.next(self.branch1, self.branch2)
  
    @step
    def branch1(self):
        # Code for branch 1
        print("This is branch 1")
        self.next(self.join)
    
    @step
    def branch2(self):
        # Code for branch 2
        print("This is branch 2")
        self.next(self.join)
  
    @step
    def join(self, inputs):
        # Merging branches back
        print("Branches joined.")
        self.next(self.end)
  
    @step
    def end(self):
        print("Flow is complete!")

run = NBRunner(BranchFlow).nbrun()

Data artifact

Data artifact adalah variabel yang memungkinkan Anda menyimpan dan meneruskan data antar langkah dalam sebuah workflow. Artifact ini mempertahankan output dari satu langkah ke langkah berikutnya—begitulah data tersedia untuk langkah-langkah selanjutnya. 

Pada dasarnya, ketika Anda menetapkan data ke self dalam sebuah langkah pada kelas Metaflow, Anda menyimpannya sebagai artifact, yang kemudian dapat diakses oleh langkah lain mana pun dalam flow (lihat komentar pada kode).

class ArtifactFlow(FlowSpec):
    @step
    def start(self):
        # Step 1: Initializing data
        print("Starting the flow!")
        self.data = [1, 2, 3, 4, 5]  # Example dataset saved as an artifact
        self.next(self.process_data)
    @step
    def process_data(self):
        # Step 2: Processing the data from the 'start' step
        self.processed_data = [x * 2 for x in self.data]  # Processing artifact data
        print("Processed data:", self.processed_data)
        self.next(self.save_results)
    @step
    def save_results(self):
        # Step 3: Saving the processed data artifact
        self.results = sum(self.processed_data)  # Saving final result as an artifact
        print("Sum of processed data:", self.results)
        self.next(self.end)
    @step
    def end(self):
        # Final step
        print("Flow is complete!")
        print(f"Final result: {self.results}")  # Accessing artifact in final step

Mengapa artifact menjadi konsep inti Metaflow? Karena artifact memiliki sejumlah kegunaan:

• Mengotomatisasi manajemen aliran data, menghilangkan kebutuhan untuk memuat dan menyimpan data secara manual.
• Memungkinkan persistensi (lebih lanjut setelah ini), yang berarti artifact memungkinkan pengguna melakukan analisis kemudian hari dengan Client API, memvisualisasikan dengan Cards, dan digunakan ulang antar flow.
• Konsistensi di lingkungan lokal dan cloud. Ini menghilangkan kebutuhan transfer data eksplisit.
• Memungkinkan pengguna memeriksa data sebelum kegagalan terjadi dan melanjutkan eksekusi setelah memperbaiki bug.

Versioning dan persistensi

Metaflow secara otomatis menangani versioning untuk workflow Anda. Ini berarti setiap kali sebuah flow dieksekusi, ia akan dilacak sebagai run yang unik. Dengan kata lain, setiap run memiliki versinya sendiri, sehingga Anda dapat dengan mudah meninjau dan mereproduksi run sebelumnya. 

Metaflow melakukan ini dengan memberikan pengenal unik untuk setiap run dan mempertahankan data serta artifact dari eksekusi tersebut. Persistensi ini memastikan tidak ada data yang hilang antar run. Workflow sebelumnya dapat dengan mudah dikunjungi kembali dan diperiksa, dan langkah tertentu dapat dijalankan ulang jika diperlukan. Hasilnya, debug dan pengembangan iteratif menjadi jauh lebih efisien, dan pemeliharaan reprodusibilitas menjadi lebih sederhana. 

Contoh Praktis: Melatih Model Machine Learning

Pada bagian ini, saya akan memandu Anda menggunakan Metaflow untuk melatih model machine learning. Anda akan mempelajari cara:

• Mendefinisikan workflow yang memuat data
• Melatih model machine learning 
• Melacak hasil

Pada akhirnya, Anda akan lebih memahami cara menggunakan Metaflow untuk menyusun dan menjalankan workflow machine learning secara efisien. Mari mulai!

Sebagai awal, kita akan membuat flow dasar yang memuat dataset, melakukan pelatihan, dan menghasilkan output model. 

Catatan: Kode dapat dijalankan di DataLab.

from metaflow import FlowSpec, step, Parameter, NBRunner

class TrainModelFlow(FlowSpec):
    @step
    def start(self):
        # Load and split the dataset
        print("Loading data...")
        self.data = [1, 2, 3, 4, 5]  # Replace with actual data loading logic
        self.labels = [0, 1, 0, 1, 0]  # Replace with labels
        self.next(self.train_model)
	   
    @step
    def train_model(self):
        # Training a simple model (e.g., linear regression)
        print("Training the model...")
        self.model = sum(self.data) / len(self.data)  # Replace with actual model training
        print(f"Model output: {self.model}")
        self.next(self.end)
	   
    @step
    def end(self):
        # Final step
        print("Training complete. Model ready for deployment!")f

Dalam kode ini, kita mendefinisikan tiga langkah:

1. start(): Memuat dan membagi dataset. Dalam skenario nyata, Anda akan memuat data dari sumber sebenarnya (misalnya, file atau basis data).
2. train_model(): Mensimulasikan pelatihan model. Di sini, perhitungan rata-rata sederhana dilakukan alih-alih algoritme machine learning sebenarnya, tetapi Anda dapat menggantinya dengan kode pelatihan apa pun yang Anda perlukan.
3. end(): Menandai akhir flow dan menunjukkan bahwa model siap untuk deployment.

Setelah Anda mendefinisikan flow, Anda dapat menjalankannya menggunakan perintah berikut:

run = NBRunner(TrainModelFlow)
run.nbrun()

Perlu dicatat bahwa kode ini hanya berfungsi di notebook (seluruh kode harus berada dalam satu sel).

Jika Anda ingin menjalankan kode ini sebagai skrip, hapus perintah NBRunner dan tambahkan hal berikut di akhir skrip Anda, lalu simpan (misalnya, “metaflow_ml_model.py”): 

if __name__ == "__main__": 
    TrainModelFlow()

Kemudian, untuk menjalankan skrip, buka command line dan jalankan perintah berikut:

py -m metaflow_ml_model.py 

Metaflow secara otomatis melacak setiap run dan memungkinkan Anda memvisualisasikan hasil melalui Metaflow UI. 

Praktik Terbaik Menggunakan Metaflow

Jadi, bagaimana cara memaksimalkan fitur Metaflow? Berikut beberapa praktik terbaik yang dapat membantu Anda mencapainya sekaligus mengoptimalkan workflow Anda: 

Mulai dengan flow kecil

Jika Anda baru mengenal Metaflow, mulailah dengan workflow sederhana untuk membiasakan diri dengan API-nya. Memulai dari yang kecil akan membantu Anda memahami cara kerja kerangka kerja ini dan membangun kepercayaan diri sebelum beralih ke proyek yang lebih kompleks. Pendekatan ini mengurangi kurva belajar dan memastikan fondasi Anda kuat.

Manfaatkan UI Metaflow untuk debugging

Metaflow menyertakan sebuah antar muka pengguna yang kuat dan sangat membantu untuk debugging dan melacak workflow Anda. Gunakan UI untuk memantau run, memeriksa output tiap langkah, dan mengidentifikasi masalah yang mungkin muncul. Memvisualisasikan data dan log memudahkan Anda menemukan dan memperbaiki masalah selama eksekusi flow.

Manfaatkan AWS untuk skalabilitas

Saat pertama kali memasang Metaflow, ia beroperasi dalam mode lokal. Dalam mode ini, artifact dan metadata disimpan di direktori lokal, dan komputasi dijalankan menggunakan proses lokal. Pengaturan ini bekerja baik untuk penggunaan personal, namun jika proyek Anda melibatkan kolaborasi atau dataset besar, sebaiknya konfigurasikan Metaflow untuk memanfaatkan AWS guna skalabilitas yang lebih baik. Kabar baiknya, Metaflow menyediakan integrasi yang sangat baik dengan AWS.

Kesimpulan

Dalam tutorial ini, kita membahas cara memulai dengan Metaflow, mulai dari instalasi hingga membangun workflow data science pertama Anda. Kita mengulas konsep inti, seperti mendefinisikan langkah, menggunakan data artifact untuk meneruskan data antar langkah, dan versioning untuk melacak serta mereproduksi run. Kita juga meninjau contoh praktis pelatihan model machine learning, yang menunjukkan cara mendefinisikan, menjalankan, dan memantau workflow Anda. Terakhir, kita membahas beberapa praktik terbaik untuk membantu Anda memaksimalkan Metaflow. 

Untuk melanjutkan pembelajaran MLOps, lihat sumber daya berikut: 

• Konsep MLOps
• Dasar-dasar MLOps
• MLOps Otomatis Penuh