ml workspace
0.13.2
Lingkungan pengembangan berbasis web all-in-one untuk pembelajaran mesin
Memulai • Fitur & Tangkapan Lelak • Dukungan • Laporkan bug • FAQ • Masalah yang Diketahui • Kontribusi
ML Workspace adalah IDE berbasis web all-in-one yang berspesialisasi untuk pembelajaran mesin dan ilmu data. Sederhana untuk digunakan dan membuat Anda mulai dalam beberapa menit untuk solusi ML yang dibangun secara produktif di mesin Anda sendiri. Ruang kerja ini adalah alat utama bagi pengembang yang dimuat sebelumnya dengan berbagai perpustakaan ilmu data populer (misalnya, TensorFlow, Pytorch, Kera, SkLearn) dan alat dev (misalnya, Jupyter, VS Code, Tensorboard) dikonfigurasi dengan sempurna, dioptimalkan, dan terintegrasi.
Ruang kerja mengharuskan Docker untuk diinstal pada mesin Anda (Panduan Instalasi).
Menyebarkan instance ruang kerja tunggal sesederhana:
docker run -p 8080:8080 mltooling/ml-workspace:0.13.2Voila, itu mudah! Sekarang, Docker akan menarik gambar ruang kerja terbaru ke mesin Anda. Ini mungkin memakan waktu beberapa menit, tergantung pada kecepatan internet Anda. Setelah ruang kerja dimulai, Anda dapat mengaksesnya melalui http: // localhost: 8080.
Jika memulai dengan mesin lain atau dengan port yang berbeda, pastikan untuk menggunakan IP/DNS mesin dan/atau port yang terbuka.
Untuk menggunakan satu contoh untuk penggunaan produktif, kami sarankan untuk menerapkan setidaknya opsi berikut:
docker run -d
-p 8080:8080
--name " ml-workspace "
-v " ${PWD} :/workspace "
--env AUTHENTICATE_VIA_JUPYTER= " mytoken "
--shm-size 512m
--restart always
mltooling/ml-workspace:0.13.2 Perintah ini menjalankan wadah di latar belakang ( -d ), memasang direktori kerja Anda saat ini ke folder /workspace ( -v ), mengamankan ruang kerja melalui token yang disediakan ( --env AUTHENTICATE_VIA_JUPYTER ), menyediakan 512MB dari memori yang dibagikan ( --restart always --shm-size ) untuk mencegah crash yang tidak diharapkan (lihat bagian masalah yang diketahui). Anda dapat menemukan opsi tambahan untuk Docker yang dijalankan di sini dan opsi konfigurasi ruang kerja di bagian di bawah ini.
Ruang kerja menyediakan berbagai opsi konfigurasi yang dapat digunakan dengan mengatur variabel lingkungan (melalui opsi Docker Run: --env ).
| Variabel | Keterangan | Bawaan |
|---|---|---|
| Workspace_base_url | URL dasar di mana Jupyter dan semua alat lainnya akan dicapai dari. | / |
| Workspace_ssl_enabled | Aktifkan atau nonaktifkan SSL. Saat diatur ke True, baik sertifikat (cert.crt) harus dipasang ke /resources/ssl atau, jika tidak, wadah menghasilkan sertifikat yang ditandatangani sendiri. | PALSU |
| Workspace_auth_user | Nama Pengguna Auth Dasar. Untuk mengaktifkan Auth Dasar, pengguna dan kata sandi harus diatur. Kami merekomendasikan untuk menggunakan AUTHENTICATE_VIA_JUPYTER untuk mengamankan ruang kerja. | |
| Workspace_auth_password | Kata Sandi Pengguna Auth Dasar. Untuk mengaktifkan Auth Dasar, pengguna dan kata sandi harus diatur. Kami merekomendasikan untuk menggunakan AUTHENTICATE_VIA_JUPYTER untuk mengamankan ruang kerja. | |
| Workspace_port | Mengkonfigurasi port container-internal utama dari proxy ruang kerja. Untuk sebagian besar skenario, konfigurasi ini tidak boleh diubah, dan konfigurasi port melalui Docker harus digunakan alih -alih ruang kerja harus dapat diakses dari port yang berbeda. | 8080 |
| Config_backup_enabled | Cadangkan dan kembalikan konfigurasi pengguna secara otomatis ke folder yang bertahan /workspace , seperti .ssh, .jupyter, atau .gitconfig dari direktori home pengguna. | BENAR |
| Shared_links_enabled | Aktifkan atau nonaktifkan kemampuan untuk berbagi sumber daya melalui tautan eksternal. Ini digunakan untuk mengaktifkan berbagi file, akses ke port workspace-internal, dan pengaturan SSH berbasis perintah yang mudah. Semua tautan bersama dilindungi melalui token. Namun, ada risiko tertentu karena token tidak dapat dengan mudah dibatalkan setelah berbagi dan tidak kedaluwarsa. | BENAR |
| Termasuk_tutorials | Jika true , pilihan notebook tutorial dan pengantar ditambahkan ke folder /workspace di startup kontainer, tetapi hanya jika foldernya kosong. | BENAR |
| Max_num_threads | Jumlah utas yang digunakan untuk perhitungan saat menggunakan berbagai perpustakaan umum (MKL, OpenBlas, OMP, Numba, ...). Anda juga dapat menggunakan auto untuk membiarkan ruang kerja secara dinamis menentukan jumlah utas berdasarkan sumber daya CPU yang tersedia. Konfigurasi ini dapat ditimpa oleh pengguna dari dalam ruang kerja. Secara umum, ada baiknya mengaturnya pada atau di bawah jumlah CPU yang tersedia untuk ruang kerja. | mobil |
| Konfigurasi Jupyter: | ||
| Shutdown_inactive_kernels | Secara otomatis mematikan kernel tidak aktif setelah batas waktu tertentu (untuk membersihkan sumber daya memori atau GPU). Nilai dapat berupa batas waktu dalam hitungan detik atau diatur ke true dengan nilai default 48H. | PALSU |
| Authenticate_via_jupyter | Jika true , semua permintaan HTTP akan diautentikasi terhadap server Jupyter, yang berarti bahwa metode otentikasi yang dikonfigurasi dengan Jupyter akan digunakan untuk semua alat lainnya juga. Ini dapat dinonaktifkan dengan false . Nilai lain apa pun akan mengaktifkan otentikasi ini dan diterapkan sebagai token melalui notebookapp. Konfigurasi Jupyter. | PALSU |
| Notebook_args | Tambah dan timpa opsi konfigurasi Jupyter melalui arg Command Line. Lihat ikhtisar ini untuk semua opsi. | |
Untuk bertahan data, Anda perlu memasang volume ke /workspace (via Docker Run Opsi: -v ).
Direktori kerja default dalam wadah adalah /workspace , yang juga merupakan direktori root dari instance Jupyter. Direktori /workspace dimaksudkan untuk digunakan untuk semua artefak karya penting. Data dalam direktori lain dari server (misalnya, /root ) mungkin tersesat saat restart wadah.
Kami sangat menyarankan untuk mengaktifkan otentikasi melalui salah satu dari dua opsi berikut. Untuk kedua opsi, pengguna akan diminta untuk mengotentikasi untuk mengakses salah satu alat yang telah dipasang sebelumnya.
Otentikasi hanya berfungsi untuk semua alat yang diakses melalui port ruang kerja utama (default:
8080). Ini berfungsi untuk semua alat yang diinstal sebelumnya dan fitur port akses. Jika Anda mengekspos port wadah lain, pastikan untuk mengamankannya dengan otentikasi juga!
Aktifkan otentikasi berbasis token berdasarkan implementasi otentikasi Jupyter melalui variabel AUTHENTICATE_VIA_JUPYTER :
docker run -p 8080:8080 --env AUTHENTICATE_VIA_JUPYTER= " mytoken " mltooling/ml-workspace:0.13.2 Anda juga dapat menggunakan <generated> untuk membiarkan Jupyter menghasilkan token acak yang dicetak pada log kontainer. Nilai true tidak akan mengatur token apa pun tetapi mengaktifkan bahwa setiap permintaan ke alat apa pun di ruang kerja akan diperiksa dengan instance Jupyter jika pengguna diautentikasi. Ini digunakan untuk alat -alat seperti JupyterHub, yang mengonfigurasi cara otentikasinya sendiri.
Aktifkan otentikasi dasar melalui variabel WORKSPACE_AUTH_USER dan WORKSPACE_AUTH_PASSWORD :
docker run -p 8080:8080 --env WORKSPACE_AUTH_USER= " user " --env WORKSPACE_AUTH_PASSWORD= " pwd " mltooling/ml-workspace:0.13.2 Otentikasi dasar dikonfigurasi melalui proxy nginx dan mungkin lebih banyak kinerja dibandingkan dengan opsi lain karena dengan AUTHENTICATE_VIA_JUPYTER setiap permintaan ke alat apa pun di ruang kerja akan memeriksa melalui instance Jupyter jika pengguna (berdasarkan cookie permintaan) diautentikasi.
Kami sarankan mengaktifkan SSL sehingga ruang kerja dapat diakses melalui HTTPS (komunikasi terenkripsi). Enkripsi SSL dapat diaktifkan melalui variabel WORKSPACE_SSL_ENABLED .
Saat diatur ke true , file cert.crt dan cert.key harus dipasang ke /resources/ssl atau, jika file sertifikat tidak ada, wadah menghasilkan sertifikat yang ditandatangani sendiri. Misalnya, jika /path/with/certificate/files pada sistem lokal berisi sertifikat yang valid untuk domain host (file cert.crt dan cert.key ), itu dapat digunakan dari ruang kerja seperti yang ditunjukkan di bawah ini:
docker run
-p 8080:8080
--env WORKSPACE_SSL_ENABLED= " true "
-v /path/with/certificate/files:/resources/ssl:ro
mltooling/ml-workspace:0.13.2 Jika Anda ingin menjadi tuan rumah ruang kerja di domain publik, kami sarankan untuk menggunakan Enkripsi Let's Encrypt untuk mendapatkan sertifikat tepercaya untuk domain Anda. Untuk menggunakan sertifikat yang dihasilkan (misalnya, melalui alat certbot) untuk ruang kerja, privkey.pem sesuai dengan file cert.key dan fullchain.pem ke file cert.crt .
Saat Anda mengaktifkan dukungan SSL, Anda harus mengakses ruang kerja di atas
https://, tidak lebih darihttp://.
Secara default, wadah ruang kerja tidak memiliki kendala sumber daya dan dapat menggunakan sebanyak mungkin sumber daya yang diberikan seperti yang diizinkan oleh penjadwal kernel host. Docker menyediakan cara untuk mengontrol berapa banyak memori, atau CPU yang dapat digunakan wadah, dengan mengatur bendera konfigurasi runtime dari perintah run docker.
Ruang kerja membutuhkan minimal 2 CPU dan 500MB untuk berjalan stabil dan dapat digunakan.
Misalnya, perintah berikut membatasi ruang kerja untuk hanya menggunakan maksimum 8 CPU, 16 GB memori, dan 1 GB memori bersama (lihat masalah yang diketahui):
docker run -p 8080:8080 --cpus=8 --memory=16g --shm-size=1G mltooling/ml-workspace:0.13.2Untuk lebih banyak opsi dan dokumentasi tentang kendala sumber daya, silakan merujuk ke Panduan Docker Resmi.
Jika diperlukan proxy, Anda dapat melewati konfigurasi proxy melalui variabel lingkungan HTTP_PROXY , HTTPS_PROXY , dan NO_PROXY .
Selain gambar ruang kerja utama ( mltooling/ml-workspace ), kami memberikan rasa gambar lain yang memperluas fitur atau meminimalkan ukuran gambar untuk mendukung berbagai kasus penggunaan.
Rasa minimal ( mltooling/ml-workspace-minimal ) adalah gambar terkecil kami yang berisi sebagian besar alat dan fitur yang dijelaskan di bagian fitur tanpa sebagian besar perpustakaan Python yang sudah diinstal sebelumnya pada gambar utama kami. Perpustakaan Python atau alat yang dikecualikan dapat diinstal secara manual selama runtime oleh pengguna.
docker run -p 8080:8080 mltooling/ml-workspace-minimal:0.13.2 Rasa R ( mltooling/ml-workspace-r ) didasarkan pada gambar ruang kerja default kami dan memperluasnya dengan interpreter R, kernel R-jupyter, server RStudio (akses melalui Open Tool -> RStudio ), dan berbagai paket populer dari ekosistem R.
docker run -p 8080:8080 mltooling/ml-workspace-r:0.12.1 Rasa Spark ( mltooling/ml-workspace-spark ) didasarkan pada gambar ruang kerja R-FLavour kami dan memperpanjangnya dengan spark runtime, spark-jupyter kernel, zeppelin notebook (akses melalui Open Tool -> Zeppelin ), pyspark, hadoop, java kernel, dan beberapa perpustakaan tambahan & java.
docker run -p 8080:8080 mltooling/ml-workspace-spark:0.12.1Saat ini, rasa GPU hanya mendukung CUDA 11.2. Dukungan untuk versi CUDA lainnya dapat ditambahkan di masa depan.
Rasa GPU ( mltooling/ml-workspace-gpu ) didasarkan pada gambar ruang kerja default kami dan memperluasnya dengan CUDA 10.1 dan versi GPU yang siap dari berbagai perpustakaan pembelajaran mesin (misalnya, Tensorflow, Pytorch, CNTK, JAX). Gambar GPU ini memiliki persyaratan tambahan berikut untuk sistem:
>=460.32.03 (instruksi).docker run -p 8080:8080 --gpus all mltooling/ml-workspace-gpu:0.13.2docker run -p 8080:8080 --runtime nvidia --env NVIDIA_VISIBLE_DEVICES= " all " mltooling/ml-workspace-gpu:0.13.2Rasa GPU juga dilengkapi dengan beberapa opsi konfigurasi tambahan, seperti yang dijelaskan di bawah ini:
| Variabel | Keterangan | Bawaan |
|---|---|---|
| Nvidia_visible_devices | Kontrol GPU mana yang dapat diakses di dalam ruang kerja. Secara default, semua GPU dari host dapat diakses di dalam ruang kerja. Anda dapat menggunakan all , none , atau menentukan daftar ID perangkat yang dipisahkan koma (misalnya, 0,1 ). Anda dapat mengetahui daftar ID perangkat yang tersedia dengan menjalankan nvidia-smi pada mesin host. | semua |
| Cuda_visible_devices | Kontrol aplikasi GPU CUDA mana yang berjalan di dalam ruang kerja akan melihat. Secara default, semua GPU yang memiliki ruang kerja memiliki akses akan terlihat. Untuk membatasi aplikasi, berikan daftar ID perangkat internal yang dipisahkan secara koma (misalnya, 0,2 ) berdasarkan perangkat yang tersedia dalam ruang kerja (jalankan nvidia-smi ). Dibandingkan dengan NVIDIA_VISIBLE_DEVICES , pengguna ruang kerja masih dapat mengakses GPU lain dengan menimpa konfigurasi ini dari dalam ruang kerja. | |
| Tf_force_gpu_allow_growth | Secara default, sebagian besar memori GPU akan dialokasikan oleh eksekusi pertama dari grafik TensorFlow. Meskipun perilaku ini dapat diinginkan untuk pipa produksi, ia kurang diinginkan untuk penggunaan interaktif. Gunakan true untuk mengaktifkan alokasi memori GPU dinamis atau false untuk menginstruksikan TensorFlow untuk mengalokasikan semua memori saat dieksekusi. | BENAR |
Ruang kerja dirancang sebagai lingkungan pengembangan pengguna tunggal. Untuk pengaturan multi-pengguna, kami sarankan untuk digunakan? Hub ML. ML Hub didasarkan pada JupyterHub dengan tugas untuk menelurkan, mengelola, dan membuat ruang kerja proxy untuk banyak pengguna.
ML Hub memudahkan untuk mengatur lingkungan multi-pengguna pada server tunggal (melalui Docker) atau cluster (melalui Kubernetes) dan mendukung berbagai skenario penggunaan & penyedia otentikasi. Anda dapat mencoba ML Hub melalui:
docker run -p 8080:8080 -v /var/run/docker.sock:/var/run/docker.sock mltooling/ml-hub:latestUntuk informasi lebih lanjut dan dokumentasi tentang ML Hub, silakan lihat situs GitHub.
Proyek ini dikelola oleh Benjamin Räthlein, Lukas Masuch, dan Jan Kalkan. Harap dipahami bahwa kami tidak akan dapat memberikan dukungan individu melalui email. Kami juga percaya bahwa bantuan jauh lebih berharga jika dibagikan secara publik sehingga lebih banyak orang dapat memperoleh manfaat darinya.
| Jenis | Saluran |
|---|---|
| Laporan Bug | |
| ? Permintaan fitur | |
| ? Pertanyaan penggunaan | |
| ? Pengumuman | |
| ❓ Permintaan lain |
Jupyter • Desktop GUI • VS Code • Jupyterlab • Integrasi Git • Berbagi File • Port Akses • Tensorboard • Ekstensibilitas • Pemantauan Perangkat Keras • Akses SSH • Pengembangan Jarak Jauh • Eksekusi Pekerjaan
Ruang kerja dilengkapi dengan pilihan alat pengembangan sumber terbuka terbaik di kelasnya untuk membantu dengan alur kerja pembelajaran mesin. Banyak dari alat ini dapat dimulai dari menu Open Tool dari Jupyter (aplikasi utama ruang kerja):
Di dalam ruang kerja Anda, Anda memiliki hak istimewa root & sudo penuh untuk menginstal perpustakaan atau alat yang Anda butuhkan melalui terminal (misalnya,
pip,apt-get,conda, ataunpm). Anda dapat menemukan lebih banyak cara untuk memperluas ruang kerja di bagian ekstensibilitas
Jupyter Notebook adalah lingkungan interaktif berbasis web untuk menulis dan menjalankan kode. Blok bangunan utama Jupyter adalah browser file, editor notebook, dan kernel. File-browser menyediakan manajer file interaktif untuk semua notebook, file, dan folder di direktori /workspace .
Buku catatan baru dapat dibuat dengan mengklik tombol drop-down New di bagian atas daftar dan memilih kernel bahasa yang diinginkan.
Anda dapat menelurkan instance terminal interaktif juga dengan memilih
New -> Terminaldi browser file.
Editor Notebook memungkinkan pengguna untuk menulis dokumen yang menyertakan kode langsung, teks Markdown, perintah shell, persamaan lateks, widget interaktif, plot, dan gambar. Dokumen notebook ini memberikan catatan komputasi yang lengkap dan mandiri yang dapat dikonversi ke berbagai format dan dibagikan kepada orang lain.
Ruang kerja ini memiliki berbagai ekstensi Jupyter pihak ketiga yang diaktifkan. Anda dapat mengonfigurasi ekstensi ini di tab NBEXTENSIONS: Tab
nbextensionsdi browser file
Notebook memungkinkan kode dijalankan dalam berbagai bahasa pemrograman yang berbeda. Untuk setiap dokumen notebook yang dibuka pengguna, aplikasi web memulai kernel yang menjalankan kode untuk buku catatan itu dan mengembalikan output. Ruang kerja ini memiliki kernel Python 3 yang sudah diinstal sebelumnya. Kernel tambahan dapat diinstal untuk mendapatkan akses ke bahasa lain (misalnya, R, Scala, GO) atau sumber daya komputasi tambahan (misalnya, GPU, CPU, memori).
Python 2 direceh dan kami tidak merekomendasikan untuk menggunakannya. Namun, Anda masih dapat memasang kernel Python 2.7 melalui perintah ini:
/bin/bash /resources/tools/python-27.sh
Ruang kerja ini menyediakan akses VNC berbasis HTTP ke ruang kerja melalui NovNC. Dengan demikian, Anda dapat mengakses dan bekerja di dalam ruang kerja dengan GUI desktop yang berfitur lengkap. Untuk mengakses desktop GUI ini, buka Open Tool , pilih VNC , dan klik tombol Connect . Dalam hal ini Anda diminta kata sandi, gunakan vncpassword .
Setelah Anda terhubung, Anda akan melihat GUI desktop yang memungkinkan Anda menginstal dan menggunakan browser web penuh atau alat lain yang tersedia untuk Ubuntu. Di dalam folder Tools di desktop, Anda akan menemukan kumpulan skrip instalasi yang membuatnya langsung untuk menginstal beberapa alat pengembangan yang paling umum digunakan, seperti Atom, Pycharm, R-Runtime, R-Studio, atau Postman (cukup klik dua kali pada skrip).
Clipboard: Jika Anda ingin berbagi clipboard antara mesin Anda dan ruang kerja, Anda dapat menggunakan fungsionalitas copy-paste seperti yang dijelaskan di bawah ini:
Tugas jangka panjang: Gunakan desktop GUI untuk eksekusi Jupyter yang sudah berjalan lama. Dengan menjalankan notebook dari browser GUI desktop ruang kerja Anda, semua output akan disinkronkan ke notebook bahkan jika Anda telah memutus browser Anda dari notebook.
Visual Studio Code ( Open Tool -> VS Code ) adalah editor kode open-source ringan namun kuat dengan dukungan bawaan untuk berbagai bahasa dan ekosistem ekstensi yang kaya. Ini menggabungkan kesederhanaan editor kode sumber dengan perkakas pengembang yang kuat, seperti penyelesaian dan debugging kode Intellisense. Ruang kerja mengintegrasikan kode VS sebagai aplikasi berbasis web yang dapat diakses melalui browser yang berbasis pada proyek server kode yang luar biasa. Ini memungkinkan Anda untuk menyesuaikan setiap fitur sesuai keinginan Anda dan menginstal sejumlah ekstensi pihak ketiga.
Ruang kerja juga menyediakan integrasi kode VS ke dalam Jupyter yang memungkinkan Anda untuk membuka instance VS Code untuk folder yang dipilih, seperti yang ditunjukkan di bawah ini:
Jupyterlab ( Open Tool -> JupyterLab ) adalah antarmuka pengguna generasi berikutnya untuk Project Jupyter. Ini menawarkan semua blok bangunan yang akrab dari notebook Jupyter klasik (notebook, terminal, editor teks, browser file, output kaya, dll.) Dalam antarmuka pengguna yang fleksibel dan kuat. Contoh Jupyterlab ini dilengkapi dengan beberapa ekstensi yang bermanfaat seperti Jupyterlab-Toc, Jupyterlab-Git, dan Juptyterlab-Tensorboard.
Kontrol Versi adalah aspek penting dari kolaborasi produktif. Untuk membuat proses ini semulus mungkin, kami telah mengintegrasikan ekstensi Jupyter yang dibuat khusus khusus pada mendorong buku catatan tunggal, klien git berbasis web (Ungit), alat untuk membuka dan mengedit dokumen teks biasa (misalnya, .py , .md ) sebagai notebook (JupyText), seperti halnya notebook merging (nbde) sebagai notebook (JupyText), seperti halnya notebook merging (nbd) sebagai notebook. Selain itu, Jupyterlab dan VS Code juga menyediakan klien GIT yang berbasis di GUI.
Untuk kloning repositori melalui https , kami sarankan untuk menavigasi ke folder root yang diinginkan dan mengklik tombol git seperti yang ditunjukkan di bawah ini:
Ini mungkin meminta beberapa pengaturan yang diperlukan dan, selanjutnya, Open Ungit, klien Git berbasis web dengan UI yang bersih dan intuitif yang membuatnya nyaman untuk menyinkronkan artefak kode Anda. Di dalam Ungit, Anda dapat mengkloning repositori apa pun. Jika diperlukan otentikasi, Anda akan diminta kredensial Anda.
Untuk melakukan dan mendorong satu buku catatan ke repositori Git jarak jauh, kami sarankan untuk menggunakan plugin git yang terintegrasi ke dalam Jupyter, seperti yang ditunjukkan di bawah ini:
Untuk operasi GIT yang lebih maju, kami sarankan untuk menggunakan Ungit. Dengan Ungit, Anda dapat melakukan sebagian besar tindakan git umum seperti dorong, tarik, menggabungkan, cabang, tag, checkout, dan banyak lagi.
Jupyter Notebook sangat bagus, tetapi sering kali adalah file besar, dengan format file JSON yang sangat spesifik. Untuk mengaktifkan selfing dan penggabungan yang mulus melalui git ruang kerja ini telah dipasang sebelumnya dengan NBDIME. NBDIME memahami struktur dokumen notebook dan, oleh karena itu, secara otomatis membuat keputusan yang cerdas saat menyebarkan dan menggabungkan buku catatan. Dalam hal Anda memiliki konflik menggabungkan, NBDime akan memastikan bahwa notebook masih dapat dibaca oleh Jupyter, seperti yang ditunjukkan di bawah ini:
Selain itu, ruang kerja dipasang sebelumnya dengan Jupytext, plugin Jupyter yang membaca dan menulis notebook sebagai file teks biasa. Ini memungkinkan Anda untuk membuka, mengedit, dan menjalankan skrip atau file markdown (misalnya .py , .md ) sebagai notebook dalam Jupyter. Di tangkapan layar berikut, kami telah membuka file markdown melalui Jupyter:
Dalam kombinasi dengan GIT, JupyText memungkinkan sejarah diff yang jelas dan penggabungan konflik versi yang mudah. Dengan kedua alat itu, berkolaborasi di Jupyter Notebooks dengan Git menjadi langsung.
Workspace memiliki fitur untuk berbagi file atau folder apa pun dengan siapa pun melalui tautan yang dilindungi token. Untuk berbagi data melalui tautan, pilih file atau folder apa pun dari Jupyter Directory Tree dan klik tombol Bagikan seperti yang ditunjukkan pada tangkapan layar berikut:
Ini akan menghasilkan tautan unik yang dilindungi melalui token yang memberi siapa pun dengan akses tautan untuk melihat dan mengunduh data yang dipilih melalui UI FileBrowser:
Untuk menonaktifkan atau mengelola (misalnya, berikan izin edit) tautan yang dibagikan, buka FileBrowser melalui Open Tool -> Filebrowser dan pilih Settings->User Management .
Dimungkinkan untuk mengakses port internal ruang kerja mana pun dengan memilih Open Tool -> Access Port . Dengan fitur ini, Anda dapat mengakses API REST atau aplikasi web yang berjalan di dalam ruang kerja secara langsung dengan browser Anda. Fitur ini memungkinkan pengembang untuk membangun, menjalankan, menguji, dan men -debug API REST atau aplikasi web langsung dari ruang kerja.
Jika Anda ingin menggunakan klien HTTP atau berbagi akses ke port yang diberikan, Anda dapat memilih opsi Get shareable link . Ini menghasilkan tautan yang dijamin token yang dapat digunakan oleh siapa pun yang dapat digunakan untuk mengakses port yang ditentukan.
Aplikasi HTTP perlu diselesaikan dari jalur URL relatif atau mengkonfigurasi jalur dasar (
/tools/PORT/). Alat yang dapat diakses dengan cara ini diamankan oleh sistem otentikasi ruang kerja! Jika Anda memutuskan untuk mempublikasikan port wadah lain sendiri daripada menggunakan fitur ini untuk membuat alat dapat diakses, pastikan untuk mengamankannya melalui mekanisme otentikasi!
1234 dengan menjalankan perintah ini di terminal dalam ruang kerja: python -m http.server 1234Open Tool -> Access Port , Input Port 1234 , dan pilih Get shareable link .Access , dan Anda akan melihat konten yang disediakan oleh http.server Python. SSH menyediakan serangkaian fitur yang kuat yang memungkinkan Anda menjadi lebih produktif dengan tugas pengembangan Anda. Anda dapat dengan mudah mengatur koneksi SSH yang aman dan tanpa kata sandi ke ruang kerja dengan memilih Open Tool -> SSH . Ini akan menghasilkan perintah pengaturan yang aman yang dapat dijalankan pada mesin Linux atau Mac mana pun untuk mengonfigurasi koneksi SSH tanpa kata sandi & aman ke ruang kerja. Atau, Anda juga dapat mengunduh skrip pengaturan dan menjalankannya (alih -alih menggunakan perintah).
Skrip pengaturan hanya berjalan di Mac dan Linux. Windows saat ini tidak didukung.
Cukup jalankan perintah pengaturan atau skrip pada mesin dari tempat Anda ingin mengatur koneksi ke ruang kerja dan memasukkan nama untuk koneksi (misalnya, my-workspace ). Anda mungkin juga diminta beberapa input tambahan selama proses, misalnya untuk menginstal kernel jarak jauh jika remote_ikernel diinstal. Setelah koneksi SSH tanpa kata sandi berhasil diatur dan diuji, Anda dapat terhubung dengan aman ke ruang kerja dengan hanya mengeksekusi ssh my-workspace .
Selain kemampuan untuk menjalankan perintah pada mesin jarak jauh, SSH juga menyediakan berbagai fitur lain yang dapat meningkatkan alur kerja pengembangan Anda seperti yang dijelaskan dalam bagian berikut.
Koneksi SSH dapat digunakan untuk port aplikasi tunneling dari mesin jarak jauh ke mesin lokal, atau sebaliknya. Misalnya, Anda dapat mengekspos port internal ruang kerja 5901 (server VNC) ke mesin lokal di port 5000 dengan mengeksekusi:
ssh -nNT -L 5000:localhost:5901 my-workspaceUntuk mengekspos port aplikasi dari mesin lokal Anda ke ruang kerja, gunakan opsi
-R(bukan-L).
Setelah terowongan dibuat, Anda dapat menggunakan penampil VNC favorit Anda di mesin lokal Anda dan terhubung ke vnc://localhost:5000 (Kata Sandi Default: vncpassword ). Untuk membuat koneksi terowongan lebih tahan dan dapat diandalkan, kami sarankan untuk menggunakan Autossh untuk secara otomatis restart terowongan SSH dalam kasus bahwa koneksi mati:
autossh -M 0 -f -nNT -L 5000:localhost:5901 my-workspacePort Tunneling cukup berguna ketika Anda telah memulai alat berbasis server di dalam ruang kerja yang Anda sukai untuk dapat diakses untuk mesin lain. Dalam pengaturan defaultnya, ruang kerja memiliki berbagai alat yang sudah berjalan di port yang berbeda, seperti:
8080 : Port ruang kerja utama dengan akses ke semua alat terintegrasi.8090 : Server Jupyter.8054 : VS Code Server.5901 : Server VNC.22 : SSH Server.Anda dapat menemukan informasi port tentang semua alat dalam konfigurasi pengawas.
Untuk informasi lebih lanjut tentang port tunneling/forwarding, kami merekomendasikan panduan ini.
SCP memungkinkan file dan direktori disalin dengan aman ke, dari, atau di antara mesin yang berbeda melalui koneksi SSH. Misalnya, untuk menyalin file lokal ( ./local-file.txt ) ke folder /workspace di dalam ruang kerja, jalankan:
scp ./local-file.txt my-workspace:/workspace Untuk menyalin Direktori /workspace dari my-workspace ke Direktori Kerja Mesin Lokal, Jalankan:
scp -r my-workspace:/workspace .Untuk informasi lebih lanjut tentang SCP, kami merekomendasikan panduan ini.
RSYNC adalah utilitas untuk mentransfer dan menyinkronkan file secara efisien antara mesin yang berbeda (misalnya, melalui koneksi SSH) dengan membandingkan waktu modifikasi dan ukuran file. Perintah RSYNC akan menentukan file mana yang perlu diperbarui setiap kali dijalankan, mana yang jauh lebih efisien dan nyaman daripada menggunakan sesuatu seperti SCP atau SFTP. Misalnya, untuk menyinkronkan semua konten folder lokal ( ./local-project-folder/ ) ke dalam /workspace/remote-project-folder/ folder di dalam ruang kerja, jalankan:
rsync -rlptzvP --delete --exclude= " .git " " ./local-project-folder/ " " my-workspace:/workspace/remote-project-folder/ "Jika Anda memiliki beberapa perubahan di dalam folder di ruang kerja, Anda dapat menyinkronkan perubahan itu kembali ke folder lokal dengan mengubah argumen sumber dan tujuan:
rsync -rlptzvP --delete --exclude= " .git " " my-workspace:/workspace/remote-project-folder/ " " ./local-project-folder/ "Anda dapat menjalankan kembali perintah -perintah ini setiap kali Anda ingin menyinkronkan salinan terbaru file Anda. RSYNC akan memastikan bahwa hanya pembaruan yang akan ditransfer.
Anda dapat menemukan informasi lebih lanjut tentang RSYNC di halaman pria ini.
Selain menyalin dan menyinkronkan data, koneksi SSH juga dapat digunakan untuk memasang direktori dari mesin jarak jauh ke sistem file lokal melalui SSHFS. Misalnya, untuk memasang direktori /workspace my-workspace ke jalur lokal (misalnya /local/folder/path ), jalankan:
sshfs -o reconnect my-workspace:/workspace /local/folder/pathSetelah direktori jarak jauh dipasang, Anda dapat berinteraksi dengan sistem file jarak jauh dengan cara yang sama seperti dengan direktori dan file lokal mana pun.
Untuk informasi lebih lanjut tentang SSHFS, kami merekomendasikan panduan ini.
Ruang kerja dapat diintegrasikan dan digunakan sebagai runtime jarak jauh (juga dikenal sebagai kernel/mesin/penerjemah jarak jauh) untuk berbagai alat pengembangan dan IDE yang populer, seperti Jupyter, VS Code, Pycharm, Colab, atau hidrogen atom. Dengan demikian, Anda dapat menghubungkan alat pengembangan favorit Anda yang berjalan di mesin lokal ke mesin jarak jauh untuk eksekusi kode. Ini memungkinkan pengalaman pengembangan berkualitas lokal dengan sumber daya komputasi yang diselenggarakan dari jarak jauh.
Integrasi ini biasanya memerlukan koneksi SSH tanpa kata sandi dari mesin lokal ke ruang kerja. Untuk mengatur koneksi SSH, silakan ikuti langkah -langkah yang dijelaskan di bagian akses SSH.
Ruang kerja dapat ditambahkan ke instance Jupyter sebagai kernel jarak jauh dengan menggunakan alat Remote_ikernel. Jika Anda telah menginstal Remote_ikernel ( pip install remote_ikernel ) di mesin lokal Anda, skrip pengaturan SSH dari ruang kerja secara otomatis akan menawarkan Anda opsi untuk mengatur koneksi kernel jarak jauh.
Saat menjalankan kernel pada mesin jarak jauh, notebook itu sendiri akan disimpan ke sistem file lokal, tetapi kernel hanya akan memiliki akses ke sistem file dari mesin jarak jauh yang menjalankan kernel. Jika Anda perlu menyinkronkan data, Anda dapat menggunakan RSYNC, SCP, atau SSHF seperti yang dijelaskan di bagian akses SSH.
Jika Anda ingin mengatur secara manual dan mengelola kernel jarak jauh, gunakan alat baris perintah Remote_ikernel, seperti yang ditunjukkan di bawah ini:
# Change my-workspace with the name of a workspace SSH connection
remote_ikernel manage --add
--interface=ssh
--kernel_cmd= " ipython kernel -f {connection_file} "
--name= " ml-server (Python) "
--host= " my-workspace " Anda dapat menggunakan fungsionalitas baris perintah Remote_ikernel untuk mendaftar ( remote_ikernel manage --show ) atau hapus ( remote_ikernel manage --delete <REMOTE_KERNEL_NAME> ) Koneksi kernel jarak jauh.
Visual Studio Code Remote - SSH Extension memungkinkan Anda untuk membuka folder jarak jauh pada mesin jarak jauh dengan akses SSH dan bekerja dengannya seperti yang Anda lakukan jika foldernya ada di mesin Anda sendiri. Setelah terhubung ke mesin jarak jauh, Anda dapat berinteraksi dengan file dan folder di mana saja pada sistem file jarak jauh dan memanfaatkan sepenuhnya set fitur VS Code (Intellisense, debugging, dan dukungan ekstensi). The menemukan dan berfungsi di luar kotak dengan koneksi SSH tanpa kata sandi seperti yang dikonfigurasi oleh skrip pengaturan SSH Workspace. Untuk mengaktifkan aplikasi VS Code lokal Anda untuk terhubung ke ruang kerja:
Anda dapat menemukan fitur dan informasi tambahan tentang ekstensi SSH jarak jauh di panduan ini.
Tensorboard menyediakan serangkaian alat visualisasi untuk membuatnya lebih mudah dipahami, men -debug, dan mengoptimalkan proses eksperimen Anda. Ini termasuk fitur logging untuk skalar, histogram, struktur model, embeddings, dan visualisasi teks & gambar. Ruang kerja dilengkapi dengan ekstensi jupyter_tensorboard yang mengintegrasikan Tensorboard ke dalam antarmuka Jupyter dengan fungsionalitas untuk memulai, mengelola, dan menghentikan instance. Anda dapat membuka instance baru untuk direktori log yang valid, seperti yang ditunjukkan di bawah ini:
Jika Anda telah membuka instance Tensorboard di direktori log yang valid, Anda akan melihat visualisasi data yang dicatat:
Tensorboard dapat digunakan dalam kombinasi dengan banyak kerangka ML lainnya selain TensorFlow. Dengan menggunakan perpustakaan Tensorboardx, Anda pada dasarnya dapat masuk dari pustaka berbasis Python mana pun. Juga, Pytorch memiliki integrasi tensorboard langsung seperti yang dijelaskan di sini.
Jika Anda lebih suka melihat papan tensor langsung di dalam buku catatan Anda, Anda dapat menggunakan sihir Jupyter berikut:
%load_ext tensorboard
%tensorboard --logdir /workspace/path/to/logs
Ruang kerja menyediakan dua alat berbasis web yang telah dipasang sebelumnya untuk membantu pengembang selama pelatihan model dan tugas eksperimen lainnya untuk mendapatkan wawasan tentang segala sesuatu yang terjadi pada sistem dan mencari tahu kemacetan kinerja.
NetData ( Open Tool -> Netdata ) adalah dasbor perangkat keras dan pemantauan kinerja real -time yang memvisualisasikan proses dan layanan pada sistem Linux Anda. Ini memantau metrik tentang CPU, GPU, memori, disk, jaringan, proses, dan banyak lagi.
Glance ( Open Tool -> Glances ) adalah dasbor pemantauan perangkat keras berbasis web juga dan dapat digunakan sebagai alternatif untuk NetData.
NetData dan Glance akan menunjukkan kepada Anda statistik perangkat keras untuk seluruh mesin di mana wadah ruang kerja sedang berjalan.
Pekerjaan didefinisikan sebagai tugas komputasi apa pun yang berjalan untuk waktu tertentu selesai, seperti pelatihan model atau pipa data.
Gambar ruang kerja juga dapat digunakan untuk menjalankan kode python sewenang-wenang tanpa memulai salah satu alat yang telah diinstal sebelumnya. This provides a seamless way to productize your ML projects since the code that has been developed interactively within the workspace will have the same environment and configuration when run as a job via the same workspace image.
To run Python code as a job, you need to provide a path or URL to a code directory (or script) via EXECUTE_CODE . The code can be either already mounted into the workspace container or downloaded from a version control system (eg, git or svn) as described in the following sections. The selected code path needs to be python executable. In case the selected code is a directory (eg, whenever you download the code from a VCS) you need to put a __main__.py file at the root of this directory. The __main__.py needs to contain the code that starts your job.
You can execute code directly from Git, Mercurial, Subversion, or Bazaar by using the pip-vcs format as described in this guide. For example, to execute code from a subdirectory of a git repository, just run:
docker run --env EXECUTE_CODE= " git+https://github.com/ml-tooling/ml-workspace.git#subdirectory=resources/tests/ml-job " mltooling/ml-workspace:0.13.2For additional information on how to specify branches, commits, or tags please refer to this guide.
In the following example, we mount and execute the current working directory (expected to contain our code) into the /workspace/ml-job/ directory of the workspace:
docker run -v " ${PWD} :/workspace/ml-job/ " --env EXECUTE_CODE= " /workspace/ml-job/ " mltooling/ml-workspace:0.13.2In the case that the pre-installed workspace libraries are not compatible with your code, you can install or change dependencies by just adding one or multiple of the following files to your code directory:
requirements.txt : pip requirements format for pip-installable dependencies.environment.yml : conda environment file to create a separate Python environment.setup.sh : A shell script executed via /bin/bash . The execution order is 1. environment.yml -> 2. setup.sh -> 3. requirements.txt
You can test your job code within the workspace (started normally with interactive tools) by executing the following python script:
python /resources/scripts/execute_code.py /path/to/your/jobIt is also possible to embed your code directly into a custom job image, as shown below:
FROM mltooling/ml-workspace:0.13.2
# Add job code to image
COPY ml-job /workspace/ml-job
ENV EXECUTE_CODE=/workspace/ml-job
# Install requirements only
RUN python /resources/scripts/execute_code.py --requirements-only
# Execute only the code at container startup
CMD [ "python" , "/resources/docker-entrypoint.py" , "--code-only" ]The workspace is pre-installed with many popular interpreters, data science libraries, and ubuntu packages:
conda , pip , apt-get , npm , yarn , sdk , poetry , gdebi ...The full list of installed tools can be found within the Dockerfile.
For every minor version release, we run vulnerability, virus, and security checks within the workspace using safety, clamav, trivy, and snyk via docker scan to make sure that the workspace environment is as secure as possible. We are committed to fix and prevent all high- or critical-severity vulnerabilities. You can find some up-to-date reports here.
The workspace provides a high degree of extensibility. Within the workspace, you have full root & sudo privileges to install any library or tool you need via terminal (eg, pip , apt-get , conda , or npm ). You can open a terminal by one of the following ways:
New -> TerminalApplications -> Terminal EmulatorFile -> New -> TerminalTerminal -> New Terminal Additionally, pre-installed tools such as Jupyter, JupyterLab, and Visual Studio Code each provide their own rich ecosystem of extensions. The workspace also contains a collection of installer scripts for many commonly used development tools or libraries (eg, PyCharm , Zeppelin , RStudio , Starspace ). You can find and execute all tool installers via Open Tool -> Install Tool . Those scripts can be also executed from the Desktop VNC (double-click on the script within the Tools folder on the Desktop VNC).
For example, to install the Apache Zeppelin notebook server, simply execute:
/resources/tools/zeppelin.sh --port=1234 After installation, refresh the Jupyter website and the Zeppelin tool will be available under Open Tool -> Zeppelin . Other tools might only be available within the Desktop VNC (eg, atom or pycharm ) or do not provide any UI (eg, starspace , docker-client ).
As an alternative to extending the workspace at runtime, you can also customize the workspace Docker image to create your own flavor as explained in the FAQ section.
The workspace can be extended in many ways at runtime, as explained here. However, if you like to customize the workspace image with your own software or configuration, you can do that via a Dockerfile as shown below:
# Extend from any of the workspace versions/flavors
FROM mltooling/ml-workspace:0.13.2
# Run you customizations, e.g.
RUN
# Install r-runtime, r-kernel, and r-studio web server from provided install scripts
/bin/bash $RESOURCES_PATH/tools/r-runtime.sh --install &&
/bin/bash $RESOURCES_PATH/tools/r-studio-server.sh --install &&
# Cleanup Layer - removes unneccessary cache files
clean-layer.shFinally, use docker build to build your customized Docker image.
For a more comprehensive Dockerfile example, take a look at the Dockerfile of the R-flavor.
To update a running workspace instance to a more recent version, the running Docker container needs to be replaced with a new container based on the updated workspace image.
All data within the workspace that is not persisted to a mounted volume will be lost during this update process. As mentioned in the persist data section, a volume is expected to be mounted into the /workspace folder. All tools within the workspace are configured to make use of the /workspace folder as the root directory for all source code and data artifacts. During an update, data within other directories will be removed, including installed/updated libraries or certain machine configurations. We have integrated a backup and restore feature ( CONFIG_BACKUP_ENABLED ) for various selected configuration files/folders, such as the user's Jupyter/VS-Code configuration, ~/.gitconfig , and ~/.ssh .
If the workspace is deployed via Docker (Kubernetes will have a different update process), you need to remove the existing container (via docker rm ) and start a new one (via docker run ) with the newer workspace image. Make sure to use the same configuration, volume, name, and port. For example, a workspace (image version 0.8.7 ) was started with this command:
docker run -d
-p 8080:8080
--name "ml-workspace"
-v "/path/on/host:/workspace"
--env AUTHENTICATE_VIA_JUPYTER="mytoken"
--restart always
mltooling/ml-workspace:0.8.7
and needs to be updated to version 0.9.1 , you need to:
docker stop "ml-workspace" && docker rm "ml-workspace"docker run -d -p 8080:8080 --name "ml-workspace" -v "/path/on/host:/workspace" --env AUTHENTICATE_VIA_JUPYTER="mytoken" --restart always mltooling/ml-workspace:0.9.1 If you want to directly connect to the workspace via a VNC client (not using the noVNC webapp), you might be interested in changing certain VNC server configurations. To configure the VNC server, you can provide/overwrite the following environment variables at container start (via docker run option: --env ):
| Variabel | Keterangan | Bawaan |
|---|---|---|
| VNC_PW | Password of VNC connection. This password only needs to be secure if the VNC server is directly exposed. If it is used via noVNC, it is already protected based on the configured authentication mechanism. | vncpassword |
| VNC_RESOLUTION | Default desktop resolution of VNC connection. When using noVNC, the resolution will be dynamically adapted to the window size. | 1600x900 |
| VNC_COL_DEPTH | Default color depth of VNC connection. | 24 |
Unfortunately, we currently do not support using a non-root user within the workspace. We plan to provide this capability and already started with some refactoring to allow this configuration. However, this still requires a lot more work, refactoring, and testing from our side.
Using root-user (or users with sudo permission) within containers is generally not recommended since, in case of system/kernel vulnerabilities, a user might be able to break out of the container and be able to access the host system. Since it is not very common to have such problematic kernel vulnerabilities, the risk of a severe attack is quite minimal. As explained in the official Docker documentation, containers (even with root users) are generally quite secure in preventing a breakout to the host. And compared to many other container use-cases, we actually want to provide the flexibility to the user to have control and system-level installation permissions within the workspace container.
The workspace comes preinstalled with various common tools to create isolated Python environments (virtual environments). The following sections provide a quick-intro on how to use these tools within the workspace. You can find information on when to use which tool here. Please refer to the documentation of the given tool for additional usage information.
venv (recommended):
To create a virtual environment via venv, execute the following commands:
# Create environment in the working directory
python -m venv my-venv
# Activate environment in shell
source ./my-venv/bin/activate
# Optional: Create Jupyter kernel for this environment
pip install ipykernel
python -m ipykernel install --user --name=my-venv --display-name= " my-venv ( $( python --version ) ) "
# Optional: Close enviornment session
deactivatepipenv (recommended):
To create a virtual environment via pipenv, execute the following commands:
# Create environment in the working directory
pipenv install
# Activate environment session in shell
pipenv shell
# Optional: Create Jupyter kernel for this environment
pipenv install ipykernel
python -m ipykernel install --user --name=my-pipenv --display-name= " my-pipenv ( $( python --version ) ) "
# Optional: Close environment session
exitvirtualenv :
To create a virtual environment via virtualenv, execute the following commands:
# Create environment in the working directory
virtualenv my-virtualenv
# Activate environment session in shell
source ./my-virtualenv/bin/activate
# Optional: Create Jupyter kernel for this environment
pip install ipykernel
python -m ipykernel install --user --name=my-virtualenv --display-name= " my-virtualenv ( $( python --version ) ) "
# Optional: Close environment session
deactivateconda :
To create a virtual environment via conda, execute the following commands:
# Create environment (globally)
conda create -n my-conda-env
# Activate environment session in shell
conda activate my-conda-env
# Optional: Create Jupyter kernel for this environment
python -m ipykernel install --user --name=my-conda-env --display-name= " my-conda-env ( $( python --version ) ) "
# Optional: Close environment session
conda deactivateTip: Shell Commands in Jupyter Notebooks:
If you install and use a virtual environment via a dedicated Jupyter Kernel and use shell commands within Jupyter (eg !pip install matplotlib ), the wrong python/pip version will be used. To use the python/pip version of the selected kernel, do the following instead:
import sys
!{ sys . executable } - m pip install matplotlibThe workspace provides three easy options to install different Python versions alongside the main Python instance: pyenv, pipenv (recommended), conda.
pipenv (recommended):
To install a different python version (eg 3.7.8 ) within the workspace via pipenv, execute the following commands:
# Install python vers
pipenv install --python=3.7.8
# Activate environment session in shell
pipenv shell
# Check python installation
python --version
# Optional: Create Jupyter kernel for this environment
pipenv install ipykernel
python -m ipykernel install --user --name=my-pipenv --display-name= " my-pipenv ( $( python --version ) ) "
# Optional: Close environment session
exitpyenv :
To install a different python version (eg 3.7.8 ) within the workspace via pyenv, execute the following commands:
# Install python version
pyenv install 3.7.8
# Make globally accessible
pyenv global 3.7.8
# Activate python version in shell
pyenv shell 3.7.8
# Check python installation
python3.7 --version
# Optional: Create Jupyter kernel for this python version
python3.7 -m pip install ipykernel
python3.7 -m ipykernel install --user --name=my-pyenv-3.7.8 --display-name= " my-pyenv (Python 3.7.8) "conda :
To install a different python version (eg 3.7.8 ) within the workspace via conda, execute the following commands:
# Create environment with python version
conda create -n my-conda-3.7 python=3.7.8
# Activate environment session in shell
conda activate my-conda-3.7
# Check python installation
python --version
# Optional: Create Jupyter kernel for this python version
pip install ipykernel
python -m ipykernel install --user --name=my-conda-3.7 --display-name= " my-conda ( $( python --version ) ) "
# Optional: Close environment session
conda deactivateTip: Shell Commands in Jupyter Notebooks:
If you install and use another Python version via a dedicated Jupyter Kernel and use shell commands within Jupyter (eg !pip install matplotlib ), the wrong python/pip version will be used. To use the python/pip version of the selected kernel, do the following instead:
import sys
!{ sys . executable } - m pip install matplotlib Certain desktop tools (eg, recent versions of Firefox) or libraries (eg, Pytorch - see Issues: 1, 2) might crash if the shared memory size ( /dev/shm ) is too small. The default shared memory size of Docker is 64MB, which might not be enough for a few tools. You can provide a higher shared memory size via the shm-size docker run option:
docker run --shm-size=2G mltooling/ml-workspace:0.13.2 In general, the performance of running code within Docker is nearly identical compared to running it directly on the machine. However, in case you have limited the container's CPU quota (as explained in this section), the container can still see the full count of CPU cores available on the machine and there is no technical way to prevent this. Many libraries and tools will use the full CPU count (eg, via os.cpu_count() ) to set the number of threads used for multiprocessing/-threading. This might cause the program to start more threads/processes than it can efficiently handle with the available CPU quota, which can tremendously slow down the overall performance. Therefore, it is important to set the available CPU count or the maximum number of threads explicitly to the configured CPU quota. The workspace provides capabilities to detect the number of available CPUs automatically, which are used to configure a variety of common libraries via environment variables such as OMP_NUM_THREADS or MKL_NUM_THREADS . It is also possible to explicitly set the number of available CPUs at container startup via the MAX_NUM_THREADS environment variable (see configuration section). The same environment variable can also be used to get the number of available CPUs at runtime.
Even though the automatic configuration capabilities of the workspace will fix a variety of inefficiencies, we still recommend configuring the number of available CPUs with all libraries explicitly. Misalnya:
import os
MAX_NUM_THREADS = int ( os . getenv ( "MAX_NUM_THREADS" ))
# Set in pytorch
import torch
torch . set_num_threads ( MAX_NUM_THREADS )
# Set in tensorflow
import tensorflow as tf
config = tf . ConfigProto (
device_count = { "CPU" : MAX_NUM_THREADS },
inter_op_parallelism_threads = MAX_NUM_THREADS ,
intra_op_parallelism_threads = MAX_NUM_THREADS ,
)
tf_session = tf . Session ( config = config )
# Set session for keras
import keras . backend as K
K . set_session ( tf_session )
# Set in sklearn estimator
from sklearn . linear_model import LogisticRegression
LogisticRegression ( n_jobs = MAX_NUM_THREADS ). fit ( X , y )
# Set for multiprocessing pool
from multiprocessing import Pool
with Pool ( MAX_NUM_THREADS ) as pool :
results = pool . map ( lst )If you encounter the following error within the container logs when starting the workspace, it will most likely not be possible to run the workspace on your hardware:
exited: nginx (terminated by SIGILL (core dumped); not expected)
The OpenResty/Nginx binary package used within the workspace requires to run on a CPU with SSE4.2 support (see this issue). Unfortunately, some older CPUs do not have support for SSE4.2 and, therefore, will not be able to run the workspace container. On Linux, you can check if your CPU supports SSE4.2 when looking into the cat /proc/cpuinfo flags section. If you encounter this problem, feel free to notify us by commenting on the following issue: #30.
Requirements : Docker and Act are required to be installed on your machine to execute the build process.
To simplify the process of building this project from scratch, we provide build-scripts - based on universal-build - that run all necessary steps (build, test, and release) within a containerized environment. To build and test your changes, execute the following command in the project root folder:
act -b -j buildUnder the hood it uses the build.py files in this repo based on the universal-build library. So, if you want to build it locally, you can also execute this command in the project root folder to build the docker container:
python build.py --makeFor additional script options:
python build.py --helpRefer to our contribution guides for more detailed information on our build scripts and development process.
Licensed Apache 2.0 . Created and maintained with ❤️ by developers from Berlin.
