1. Giới thiệu
| Kubeflow là một bộ công cụ học máy dành cho Kubernetes. Dự án này nhằm mục đích giúp việc triển khai quy trình học máy (ML) trên Kubernetes trở nên đơn giản, dễ di chuyển và có khả năng mở rộng. Mục tiêu là cung cấp một cách đơn giản để triển khai các hệ thống nguồn mở tốt nhất cho học máy cho nhiều cơ sở hạ tầng. |
| Quy trình học máy có thể bao gồm nhiều bước có sự phụ thuộc lẫn nhau, từ việc chuẩn bị và phân tích dữ liệu, đến huấn luyện, đánh giá, triển khai và nhiều bước khác. Khó có thể soạn và theo dõi các quy trình này theo cách đặc biệt (ví dụ: trong một bộ sổ tay hoặc tập lệnh) và những việc như kiểm tra và khả năng tái tạo ngày càng trở nên khó khăn.Kubeflow Pipelines (KFP) giúp giải quyết những vấn đề này bằng cách cung cấp một cách để triển khai các quy trình học máy mạnh mẽ, có thể lặp lại cùng với tính năng giám sát, kiểm tra, theo dõi phiên bản và khả năng tái tạo. Cloud AI Pipelines giúp bạn dễ dàng thiết lập một bản cài đặt KFP. |
Sản phẩm bạn sẽ tạo ra
Trong lớp học lập trình này, bạn sẽ tạo một ứng dụng web tóm tắt các vấn đề trên GitHub bằng cách sử dụng Kubeflow Pipelines để huấn luyện và phân phát một mô hình. Ví dụ này dựa trên một ví dụ trong kho lưu trữ Kubeflow Examples. Sau khi hoàn tất, cơ sở hạ tầng của bạn sẽ bao gồm:
- Một cụm Google Kubernetes Engine (GKE) đã cài đặt Kubeflow Pipelines (thông qua Cloud AI Pipelines).
- Một quy trình huấn luyện mô hình Tensor2Tensor trên GPU
- Một vùng chứa phân phát cung cấp các dự đoán từ mô hình đã huấn luyện
- Giao diện người dùng diễn giải các dự đoán để cung cấp thông tin tóm tắt cho các vấn đề trên GitHub
- Một sổ tay tạo quy trình từ đầu bằng SDK Kubeflow Pipelines (KFP)
Kiến thức bạn sẽ học được
Quy trình mà bạn sẽ tạo ra sẽ huấn luyện một mô hình Tensor2Tensor trên dữ liệu vấn đề của GitHub, học cách dự đoán tiêu đề vấn đề từ nội dung vấn đề. Sau đó, nó sẽ xuất mô hình đã huấn luyện và triển khai mô hình đã xuất bằng Tensorflow Serving. Bước cuối cùng trong quy trình này sẽ chạy một ứng dụng web, ứng dụng này tương tác với phiên bản TF-Serving để nhận được các dự đoán về mô hình.
- Cách cài đặt Kubeflow Pipelines trên một cụm GKE
- Cách tạo và chạy quy trình làm việc về học máy bằng Kubeflow Pipelines
- Cách xác định và chạy quy trình từ Sổ tay Nền tảng Trí tuệ nhân tạo
Bạn cần có
- Bạn nên có kiến thức cơ bản về Kubernetes nhưng không bắt buộc
- Một dự án GCP đang hoạt động mà bạn có quyền sở hữu
- (Không bắt buộc) Tài khoản GitHub
- Quyền truy cập vào Google Cloud Shell, có trong Bảng điều khiển Google Cloud Platform (GCP)
2. Thiết lập
Cloud Shell
Truy cập vào GCP Console trong trình duyệt rồi đăng nhập bằng thông tin đăng nhập dự án của bạn:
Nhấp vào "Chọn một dự án" nếu cần để bạn có thể làm việc với dự án lớp học lập trình của mình.
Sau đó, hãy nhấp vào biểu tượng "Kích hoạt Cloud Shell" ở trên cùng bên phải của bảng điều khiển để khởi động Cloud Shell.
Khi bạn khởi động Cloud Shell, hệ thống sẽ cho bạn biết tên của dự án mà Cloud Shell được thiết lập để sử dụng. Kiểm tra để đảm bảo chế độ cài đặt này là chính xác.
Để tìm mã dự án, hãy truy cập vào bảng điều khiển Trang chủ của GCP. Nếu màn hình trống, hãy nhấp vào "Có" khi được nhắc để tạo trang tổng quan.
Sau đó, trong thiết bị đầu cuối Cloud Shell, hãy chạy các lệnh này nếu cần để định cấu hình gcloud sử dụng đúng dự án:
export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}
Tạo một vùng lưu trữ
Tạo một bộ chứa Cloud Storage để lưu trữ các tệp quy trình. Bạn cần sử dụng một mã nhận dạng duy nhất trên toàn cầu, vì vậy, bạn nên xác định một tên bộ chứa bao gồm mã dự án của mình. Tạo vùng chứa bằng lệnh gsutil mb (make bucket):
export PROJECT_ID=<your_project_id>
export BUCKET_NAME=kubeflow-${PROJECT_ID}
gsutil mb gs://${BUCKET_NAME}
Ngoài ra, bạn có thể tạo một vùng chứa thông qua Bảng điều khiển của GCP.
Không bắt buộc**: Tạo mã thông báo GitHub**
Lớp học lập trình này gọi API GitHub để truy xuất dữ liệu công khai. Để ngăn chặn việc giới hạn tốc độ, đặc biệt là tại các sự kiện mà một số lượng lớn yêu cầu ẩn danh được gửi đến API GitHub, hãy thiết lập mã truy cập mà không có quyền. Đây chỉ là bước xác thực bạn với tư cách là một cá nhân chứ không phải người dùng ẩn danh.
- Truy cập vào https://github.com/settings/tokens rồi tạo một mã thông báo mới mà không có phạm vi.
- Lưu ở nơi an toàn. Nếu mất mã này, bạn sẽ cần xoá và tạo một mã mới.
Nếu bỏ qua bước này, phòng thí nghiệm vẫn sẽ hoạt động – bạn chỉ bị hạn chế hơn một chút về các lựa chọn tạo dữ liệu đầu vào để kiểm thử mô hình.
Không bắt buộc: Ghim trang tổng quan hữu ích
Trong bảng điều khiển GCP, hãy ghim trang tổng quan Kubernetes Engine và Storage để dễ dàng truy cập hơn.
Tạo một bản cài đặt AI Platform Pipelines (Hosted Kubeflow Pipelines)
Làm theo hướng dẫn trong các phần "Trước khi bắt đầu" và "Thiết lập phiên bản" tại đây để thiết lập một phiên bản GKE đã cài đặt KFP. Nhớ đánh dấu vào ô Cho phép truy cập vào các Cloud API sau như được chỉ ra trong tài liệu. (Nếu không, quy trình ví dụ sẽ không chạy thành công). Để không gian tên cài đặt là default.
Bạn cần chọn một vùng hỗ trợ Nvidia k80. Bạn có thể sử dụng us-central1-a hoặc us-central1-c làm giá trị mặc định.
Ghi lại tên cụm và vùng GKE được liệt kê cho bản cài đặt của bạn trong trang tổng quan AI Pipelines sau khi quá trình cài đặt hoàn tất, đồng thời đặt các biến môi trường thành các giá trị này để thuận tiện.
export ZONE=<your zone> export CLUSTER_NAME=<your cluster name>
Thiết lập kubectl để sử dụng thông tin đăng nhập của cụm GKE mới
Sau khi tạo cụm GKE, hãy định cấu hình kubectl để sử dụng thông tin đăng nhập của cụm mới bằng cách chạy lệnh sau trong Cloud Shell:
gcloud container clusters get-credentials ${CLUSTER_NAME} \
--project ${PROJECT_ID} \
--zone ${ZONE}
Hoặc nhấp vào tên của cụm trong trang tổng quan AI Pipelines để truy cập vào trang GKE của cụm đó, rồi nhấp vào "Kết nối" ở đầu trang. Trong cửa sổ bật lên, hãy dán lệnh vào Cloud Shell.
Thao tác này sẽ định cấu hình ngữ cảnh kubectl để bạn có thể tương tác với cụm. Để xác minh cấu hình, hãy chạy lệnh sau:
kubectl get nodes -o wide
Bạn sẽ thấy các nút được liệt kê với trạng thái "Ready" và các thông tin khác về tuổi, phiên bản, địa chỉ IP ngoài, hình ảnh hệ điều hành, phiên bản kernel và thời gian chạy vùng chứa của nút.
Định cấu hình cụm để cài đặt trình điều khiển Nvidia trên các nhóm nút có hỗ trợ GPU
Tiếp theo, chúng ta sẽ áp dụng một daemonset cho cụm. Thao tác này sẽ cài đặt trình điều khiển Nvidia trên mọi nút cụm có GPU:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml
Sau đó, hãy chạy lệnh sau để cấp cho các thành phần KFP quyền tạo tài nguyên Kubernetes mới:
kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner
Tạo một bộ nút GPU
Sau đó, chúng ta sẽ thiết lập một bộ nút GPU có kích thước là 1:
gcloud container node-pools create gpu-pool \
--cluster=${CLUSTER_NAME} \
--zone ${ZONE} \
--num-nodes=1 \
--machine-type n1-highmem-8 \
--scopes cloud-platform --verbosity error \
--accelerator=type=nvidia-tesla-k80,count=1
3. Chạy quy trình từ trang tổng quan Quy trình
Mở trang tổng quan về quy trình
Trong Cloud Console, hãy truy cập vào bảng điều khiển Pipelines nếu bạn chưa truy cập. Sau đó, hãy nhấp vào "MỞ BẢNG ĐIỀU KHIỂN PIPELINES" cho bản cài đặt của bạn, rồi nhấp vào Pipelines trong thanh trình đơn bên trái. Nếu bạn gặp lỗi tải, hãy làm mới thẻ. Bạn sẽ thấy một trang mới như sau:
Nội dung mô tả quy trình
Quy trình mà bạn sẽ chạy có một số bước (xem Phụ lục của lớp học lập trình này để biết thông tin chi tiết):
- Một điểm kiểm tra mô hình hiện có sẽ được sao chép vào nhóm của bạn.
- Mô hình Tensor2Tensor được huấn luyện bằng dữ liệu đã xử lý trước.
- Quá trình huấn luyện bắt đầu từ điểm kiểm tra mô hình hiện có được sao chép ở bước đầu tiên, sau đó huấn luyện thêm vài trăm bước nữa. (Sẽ mất quá nhiều thời gian để huấn luyện đầy đủ trong lớp học lập trình).
- Khi quá trình huấn luyện kết thúc, bước trong quy trình sẽ xuất mô hình ở dạng phù hợp để phân phát bằng TensorFlow Serving.
- Một phiên bản phân phát TensorFlow được triển khai bằng mô hình đó.
- Một ứng dụng web được ra mắt để tương tác với mô hình được phân phát nhằm truy xuất các dự đoán.
Tải xuống và biên dịch quy trình
Trong phần này, chúng ta sẽ xem cách biên dịch một định nghĩa quy trình. Việc đầu tiên chúng ta cần làm là cài đặt KFP SDK. Chạy lệnh sau trong Cloud Shell:
pip3 install -U kfp
Để tải tệp định nghĩa quy trình xuống, hãy thực thi lệnh này trong Cloud Shell:
curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py
Sau đó, hãy biên dịch tệp định nghĩa quy trình bằng cách chạy tệp đó như sau:
python3 gh_summ_hosted_kfp.py
Bạn sẽ thấy tệp gh_summ_hosted_kfp.py.tar.gz xuất hiện trong kết quả.
Tải quy trình đã biên dịch lên
Trong giao diện người dùng web của Kubeflow Pipelines, hãy nhấp vào Upload pipeline (Tải quy trình lên) rồi chọn Import by URL (Nhập theo URL). Sao chép rồi dán URL sau đây. URL này trỏ đến chính quy trình mà bạn vừa biên dịch. (Bạn cần thực hiện thêm một vài bước để tải tệp lên từ Cloud Shell, vì vậy chúng ta sẽ dùng một cách nhanh hơn).
Đặt tên cho quy trình (ví dụ: gh_summ).
Chạy quy trình
Nhấp vào quy trình đã tải lên trong danh sách. Thao tác này cho phép bạn xem biểu đồ tĩnh của quy trình. Sau đó, hãy nhấp vào Tạo thử nghiệm để tạo một Thử nghiệm mới bằng quy trình đó. Thử nghiệm là một cách để nhóm các lượt chạy có liên quan về mặt ngữ nghĩa với nhau.
Đặt tên cho Thử nghiệm (ví dụ: cùng tên với quy trình gh_summ), sau đó nhấp vào Tiếp theo để tạo.
Thao tác này sẽ mở ra một trang để bạn nhập các tham số cho một Lần chạy và bắt đầu chạy.
Bạn có thể muốn thực thi các lệnh sau trong Cloud Shell để giúp điền các tham số.
gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"
Tên của Lượt chạy sẽ được điền sẵn, nhưng bạn có thể đặt một tên khác nếu muốn.
Sau đó, hãy điền vào 3 trường tham số:
project- (không bắt buộc)
github-token working-dir
Đối với working-dir, hãy nhập một số đường dẫn trong vùng chứa GCS mà bạn đã tạo. Thêm tiền tố "gs://". Đối với trường github-token, hãy nhập mã thông báo mà bạn đã tạo (không bắt buộc) trước đó hoặc giữ nguyên chuỗi giữ chỗ nếu bạn không tạo mã thông báo.
Sau khi điền thông tin vào các trường, hãy nhấp vào Start (Bắt đầu), sau đó nhấp vào lần chạy được liệt kê để xem thông tin chi tiết. Trong khi một bước của quy trình đang chạy, bạn có thể nhấp vào bước đó để biết thêm thông tin, bao gồm cả việc xem nhật ký pod của bước đó. (Bạn cũng có thể xem nhật ký cho một bước trong quy trình thông qua đường liên kết đến nhật ký Cloud Logging (Stackdriver) của bước đó, ngay cả khi nút cụm đã bị xoá).
Xem định nghĩa về quy trình
Trong khi quy trình đang chạy, bạn có thể muốn xem xét kỹ hơn cách quy trình được thiết lập và những việc quy trình đang làm. Bạn có thể xem thêm thông tin chi tiết trong phần Phụ lục của lớp học lập trình này.
Xem thông tin huấn luyện mô hình trong TensorBoard
Sau khi hoàn tất bước huấn luyện, hãy chọn thẻ Trực quan hoá của bước đó rồi nhấp vào nút Bắt đầu TensorBoard màu xanh dương. Sau khi TensorBoard sẵn sàng, hãy nhấp vào Mở TensorBoard.
Khám phá trang tổng quan về Artifacts and Executions (Hiện vật và lượt thực thi)
Kubeflow Pipelines tự động ghi nhật ký siêu dữ liệu về các bước trong quy trình khi quy trình thực thi. Cả thông tin về Artifact (Hiện vật) và Execution (Thực thi) đều được ghi lại. Nhấp vào những mục này trong thanh điều hướng bên trái của trang tổng quan để khám phá thêm.
Đối với Artifacts (Hiện vật), bạn có thể xem cả bảng tổng quan và bảng điều khiển Lineage Explorer (Trình khám phá dòng dõi).
Đưa ứng dụng web do quy trình tạo ra và đưa ra một số dự đoán
Bước cuối cùng trong quy trình này sẽ triển khai một ứng dụng web, cung cấp giao diện người dùng để truy vấn mô hình đã huấn luyện (được phân phát thông qua TF Serving) nhằm đưa ra dự đoán.
Sau khi quy trình hoàn tất, hãy kết nối với ứng dụng web bằng cách chuyển tiếp cổng đến dịch vụ của ứng dụng (chúng ta đang chuyển tiếp cổng vì trong lớp học lập trình này, dịch vụ ứng dụng web chưa được thiết lập để có một điểm cuối bên ngoài).
Tìm tên dịch vụ bằng cách chạy lệnh sau trong Cloud Shell:
kubectl get services
Tìm một tên dịch vụ như sau: ghsumm-*-webappsvc trong danh sách.
Sau đó, trong Cloud Shell, hãy chuyển tiếp cổng đến dịch vụ đó như sau, thay đổi lệnh sau để sử dụng tên webappsvc của bạn:
kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80
Sau khi chuyển tiếp cổng đang chạy, hãy nhấp vào biểu tượng "xem trước" ở phía trên ngăn Cloud Shell, rồi nhấp vào "Xem trước trên cổng 8080" trong trình đơn thả xuống.
Bạn sẽ thấy một trang như thế này xuất hiện trong thẻ mới:
Nhấp vào nút Populate Random Issue (Điền vấn đề ngẫu nhiên) để truy xuất một khối văn bản. Nhấp vào Tạo tiêu đề để gọi mô hình đã huấn luyện và hiển thị một dự đoán.
Nếu các tham số của quy trình bao gồm một mã thông báo GitHub hợp lệ, bạn có thể thử nhập một URL GitHub vào trường thứ hai, sau đó nhấp vào "Tạo tiêu đề". Nếu bạn không thiết lập mã thông báo GitHub hợp lệ, hãy chỉ sử dụng trường "Populate Random Issue" (Điền vấn đề ngẫu nhiên).
4. Chạy quy trình từ một sổ tay Nền tảng Trí tuệ nhân tạo
Bạn cũng có thể xác định và chạy Kubeflow Pipelines một cách tương tác từ sổ tay Jupyter bằng cách sử dụng KFP SDK. AI Platform Notebooks (Sổ tay Nền tảng Trí tuệ nhân tạo) mà chúng ta sẽ dùng cho lớp học lập trình này giúp việc này trở nên rất đơn giản.
Tạo một phiên bản sổ tay
Chúng ta sẽ tạo một phiên bản sổ tay từ Cloud Shell bằng API của phiên bản đó. (Ngoài ra, bạn có thể tạo một sổ tay thông qua Cloud Console. Hãy xem tài liệu để biết thêm thông tin).
Đặt các biến môi trường sau trong Cloud Shell:
export INSTANCE_NAME="kfp-ghsumm" export VM_IMAGE_PROJECT="deeplearning-platform-release" export VM_IMAGE_FAMILY="tf2-2-3-cpu" export MACHINE_TYPE="n1-standard-4" export LOCATION="us-central1-c"
Sau đó, trong Cloud Shell, hãy chạy lệnh để tạo phiên bản sổ tay:
gcloud beta notebooks instances create $INSTANCE_NAME \ --vm-image-project=$VM_IMAGE_PROJECT \ --vm-image-family=$VM_IMAGE_FAMILY \ --machine-type=$MACHINE_TYPE --location=$LOCATION
Khi chạy lệnh này lần đầu tiên, bạn có thể được yêu cầu bật API notebooks cho dự án của mình. Trả lời "y" nếu bạn đồng ý.
Sau vài phút, máy chủ sổ tay của bạn sẽ hoạt động. Bạn có thể thấy các phiên bản Notebook được liệt kê trong Cloud Console.
Tải sổ tay lớp học lập trình lên
Sau khi tạo phiên bản sổ tay, hãy nhấp vào đường liên kết này để tải sổ tay Jupyter của lớp học lập trình lên. Chọn phiên bản sổ tay bạn muốn sử dụng. Sổ tay sẽ tự động mở.
Chạy sổ tay
Làm theo hướng dẫn trong sổ tay cho phần còn lại của phòng thí nghiệm. Xin lưu ý rằng trong phần "Thiết lập" của sổ tay, bạn sẽ cần điền các giá trị của riêng mình trước khi chạy phần còn lại của sổ tay.
(Nếu đang sử dụng dự án của riêng mình, đừng quên quay lại và thực hiện phần "Dọn dẹp" của lớp học lập trình này).
5. Dọn dẹp
Bạn không cần làm việc này nếu đang sử dụng tài khoản codelab tạm thời, nhưng bạn có thể muốn xoá bản cài đặt Pipelines và Notebook nếu đang sử dụng dự án của riêng mình.
Gỡ bỏ cụm GKE của Pipelines
Bạn có thể xoá cụm Pipelines khỏi Cloud Console. (Bạn có thể chỉ xoá bản cài đặt Pipelines nếu muốn sử dụng lại cụm GKE).
Xoá phiên bản AI Notebook
Nếu đã chạy phần "Sổ tay" của lớp học lập trình, bạn có thể XOÁ hoặc DỪNG phiên bản sổ tay trong Cloud Console.
Không bắt buộc: Xoá mã thông báo GitHub
Truy cập vào https://github.com/settings/tokens rồi xoá mã thông báo đã tạo.
6. Phụ lục
Xem xét mã
Xác định quy trình
Đường dẫn được dùng trong lớp học lập trình này được xác định tại đây.
Hãy xem cách xác định quy trình này, cũng như cách xác định các thành phần (bước) của quy trình. Chúng tôi sẽ đề cập đến một số điểm nổi bật, nhưng hãy xem tài liệu để biết thêm thông tin chi tiết.
Các bước trong Kubeflow Pipeline đều dựa trên vùng chứa. Khi tạo một quy trình, bạn có thể sử dụng các thành phần dựng sẵn, với các hình ảnh vùng chứa đã được dựng hoặc dựng các thành phần của riêng bạn. Đối với lớp học lập trình này, chúng ta sẽ tạo một lớp học lập trình của riêng mình.
Bốn bước trong quy trình được xác định từ các thành phần có thể sử dụng lại, được truy cập thông qua các tệp định nghĩa thành phần. Trong đoạn mã đầu tiên này, chúng ta đang truy cập vào các tệp định nghĩa thành phần này thông qua URL của chúng và sử dụng các định nghĩa này để tạo "ops" mà chúng ta sẽ dùng để tạo một bước trong quy trình.
import kfp.dsl as dsl
import kfp.gcp as gcp
import kfp.components as comp
...
copydata_op = comp.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/datacopy_component.yaml'
)
train_op = comp.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/examples/master/github_issue_summarization/pipelines/components/t2t/train_component.yaml'
)
Dưới đây là một trong những định nghĩa thành phần (đối với hoạt động huấn luyện) ở định dạng yaml. Bạn có thể thấy rằng các đối số đầu vào, đầu ra, hình ảnh vùng chứa và điểm truy cập vùng chứa của nó được xác định.
name: Train T2T model
description: |
A Kubeflow Pipeline component to train a Tensor2Tensor
model
metadata:
labels:
add-pod-env: 'true'
inputs:
- name: train_steps
description: '...'
type: Integer
default: 2019300
- name: data_dir
description: '...'
type: GCSPath
- name: model_dir
description: '...'
type: GCSPath
- name: action
description: '...'
type: String
- name: deploy_webapp
description: '...'
type: String
outputs:
- name: launch_server
description: '...'
type: String
- name: train_output_path
description: '...'
type: GCSPath
- name: MLPipeline UI metadata
type: UI metadata
implementation:
container:
image: gcr.io/google-samples/ml-pipeline-t2ttrain:v3ap
args: [
--data-dir, {inputValue: data_dir},
--action, {inputValue: action},
--model-dir, {inputValue: model_dir},
--train-steps, {inputValue: train_steps},
--deploy-webapp, {inputValue: deploy_webapp},
--train-output-path, {outputPath: train_output_path}
]
env:
KFP_POD_NAME: "{{pod.name}}"
fileOutputs:
launch_server: /tmp/output
MLPipeline UI metadata: /mlpipeline-ui-metadata.json
Bạn cũng có thể xác định một bước trong quy trình thông qua hàm khởi tạo dsl.ContainerOp, như chúng ta sẽ thấy bên dưới.
Dưới đây là phần lớn định nghĩa về quy trình. Chúng ta sẽ xác định các thông tin đầu vào của quy trình (và giá trị mặc định của chúng). Sau đó, chúng ta xác định các bước trong quy trình. Đối với hầu hết các bước, chúng ta sẽ sử dụng "ops" được xác định ở trên, nhưng chúng ta cũng sẽ xác định một bước "serve" nội tuyến thông qua ContainerOp, chỉ định trực tiếp hình ảnh vùng chứa và các đối số điểm truy cập.
Bạn có thể thấy rằng các bước train, log_model và serve đang truy cập vào đầu ra từ các bước trước đó dưới dạng đầu vào. Bạn có thể đọc thêm về cách chỉ định vấn đề này tại đây.
@dsl.pipeline(
name='Github issue summarization',
description='Demonstrate Tensor2Tensor-based training and TF-Serving'
)
def gh_summ( #pylint: disable=unused-argument
train_steps: 'Integer' = 2019300,
project: str = 'YOUR_PROJECT_HERE',
github_token: str = 'YOUR_GITHUB_TOKEN_HERE',
working_dir: 'GCSPath' = 'gs://YOUR_GCS_DIR_HERE',
checkpoint_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/model_output_tbase.bak2019000/',
deploy_webapp: str = 'true',
data_dir: 'GCSPath' = 'gs://aju-dev-demos-codelabs/kubecon/t2t_data_gh_all/'
):
copydata = copydata_op(
data_dir=data_dir,
checkpoint_dir=checkpoint_dir,
model_dir='%s/%s/model_output' % (working_dir, dsl.RUN_ID_PLACEHOLDER),
action=COPY_ACTION,
)
train = train_op(
data_dir=data_dir,
model_dir=copydata.outputs['copy_output_path'],
action=TRAIN_ACTION, train_steps=train_steps,
deploy_webapp=deploy_webapp
)
serve = dsl.ContainerOp(
name='serve',
image='gcr.io/google-samples/ml-pipeline-kubeflow-tfserve:v6',
arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
"--model_path", train.outputs['train_output_path']
]
)
train.set_gpu_limit(1)
Xin lưu ý rằng chúng tôi yêu cầu bước "train" (huấn luyện) chạy trên một nút trong cụm có ít nhất 1 GPU.
train.set_gpu_limit(1)
Bước cuối cùng trong quy trình (cũng được xác định nội tuyến) là có điều kiện. Thao tác này sẽ chạy sau khi bước "serve" hoàn tất, chỉ khi đầu ra của bước huấn luyện launch_server là chuỗi "true". Thao tác này sẽ khởi chạy "ứng dụng web dự đoán" mà chúng ta đã dùng để yêu cầu bản tóm tắt vấn đề từ mô hình T2T đã được huấn luyện.
with dsl.Condition(train.outputs['launch_server'] == 'true'):
webapp = dsl.ContainerOp(
name='webapp',
image='gcr.io/google-samples/ml-pipeline-webapp-launcher:v1',
arguments=["--model_name", 'ghsumm-%s' % (dsl.RUN_ID_PLACEHOLDER,),
"--github_token", github_token]
)
webapp.after(serve)
Định nghĩa hình ảnh vùng chứa thành phần
Tài liệu về Kubeflow Pipeline mô tả một số phương pháp hay nhất để tạo các thành phần của riêng bạn. Trong quy trình này, bạn sẽ cần xác định và tạo một hình ảnh vùng chứa. Bạn có thể xem các bước thành phần cho quy trình của lớp học lập trình này tại đây. Các định nghĩa Dockerfile nằm trong thư mục con containers, ví dụ: tại đây.
Sử dụng các VM có thể bị dừng ngang với GPU để huấn luyện
Máy ảo có thể bị dừng là các phiên bản máy ảo Compute Engine có thời gian hoạt động tối đa là 24 giờ và không đảm bảo tính sẵn sàng. Giá của máy ảo có thể bị giành quyền thấp hơn giá của máy ảo Compute Engine tiêu chuẩn.
Với Google Kubernetes Engine (GKE), bạn có thể dễ dàng thiết lập một cụm hoặc bộ nút sử dụng các VM có thể bị dừng. Bạn có thể thiết lập một bộ nút như vậy bằng GPU được đính kèm với các phiên bản có thể bị ưu tiên. Các nút này hoạt động giống như các nút thông thường có hỗ trợ GPU, nhưng GPU chỉ tồn tại trong suốt thời gian hoạt động của phiên bản.
Bạn có thể thiết lập một bộ nút có thể bị ưu tiên, có hỗ trợ GPU cho cụm bằng cách chạy một lệnh tương tự như lệnh sau, chỉnh sửa lệnh sau bằng tên và vùng của cụm, đồng thời điều chỉnh loại và số lượng trình tăng tốc theo yêu cầu của bạn. Bạn có thể tuỳ ý xác định bộ nút để tự động mở rộng quy mô dựa trên khối lượng công việc hiện tại.
gcloud container node-pools create preemptible-gpu-pool \
--cluster=<your-cluster-name> \
--zone <your-cluster-zone> \
--enable-autoscaling --max-nodes=4 --min-nodes=0 \
--machine-type n1-highmem-8 \
--preemptible \
--node-taints=preemptible=true:NoSchedule \
--scopes cloud-platform --verbosity error \
--accelerator=type=nvidia-tesla-k80,count=4
Bạn cũng có thể thiết lập một bộ nút thông qua Cloud Console.
Xác định một Kubeflow Pipeline sử dụng các nút GKE có thể bị ưu tiên
Nếu đang chạy Kubeflow trên GKE, giờ đây, bạn có thể dễ dàng xác định và chạy Kubeflow Pipelines, trong đó một hoặc nhiều bước (thành phần) của quy trình chạy trên các nút có thể bị ưu tiên, giúp giảm chi phí chạy một công việc. Để sử dụng các máy ảo có thể bị ưu tiên để đưa ra kết quả chính xác, các bước mà bạn xác định là có thể bị ưu tiên phải là đẳng phương (tức là nếu bạn chạy một bước nhiều lần, thì bước đó sẽ có cùng kết quả) hoặc phải kiểm tra công việc để bước đó có thể tiếp tục từ nơi bị gián đoạn.
Khi xác định một Kubeflow Pipeline, bạn có thể cho biết rằng một bước nhất định sẽ chạy trên một nút có thể bị ưu tiên bằng cách sửa đổi thao tác như sau:
your_pipelines_op.apply(gcp.use_preemptible_nodepool())
Hãy xem tài liệu này để biết thông tin chi tiết.
Có lẽ bạn cũng muốn thử lại bước này một số lần nếu nút bị ưu tiên. Bạn có thể thực hiện việc này như sau: ở đây, chúng ta sẽ chỉ định 5 lần thử lại.
your_pipelines_op.set_gpu_limit(1).apply(gcp.use_preemptible_nodepool()).set_retry(5)
Hãy thử chỉnh sửa quy trình Kubeflow mà chúng ta đã dùng trong lớp học lập trình này để chạy bước huấn luyện trên một VM có thể bị ưu tiên.
Thay đổi dòng sau trong quy cách quy trình để sử dụng thêm một nhóm nút có thể bị ưu tiên (hãy đảm bảo bạn đã tạo một nhóm nút như đã nêu ở trên) và thử lại 5 lần:
train.set_gpu_limit(1)
Sau đó, hãy biên dịch lại quy trình, tải phiên bản mới lên (đặt tên mới cho phiên bản đó), rồi chạy phiên bản mới của quy trình.