Quy trình Kubeflow – Tóm tắt vấn đề trên GitHub

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 hướng đến việc triển khai quy trình công việc Học máy (ML) trên Kubernetes đơn giản, di động và có thể mở rộng. Mục tiêu là đưa ra một cách thức đơn giản để triển khai các hệ thống nguồn mở tốt nhất dành cho công nghệ học máy cho nhiều cơ sở hạ tầng.

Một quy trình công nghệ học máy có thể bao gồm nhiều bước và có sự phụ thuộc lẫn nhau, từ chuẩn bị và phân tích dữ liệu, huấn luyện, đánh giá, triển khai và nhiều bước khác. Thật khó để soạn và theo dõi các quy trình này một cách đặc biệt (ví dụ: trong một tập hợp các sổ tay hoặc tập lệnh) và những việc như kiểm tra và tái lặp lại ngày càng trở nên khó khăn.Quy trình kiểm tra Kubeflow (KFP) giúp triển khai các vấn đề học tập và kiểm tra nhiều lần bằng cách Quy trình của Cloud AI giúp bạn dễ dàng thiết lập quy trình 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ẽ xây dựng một ứng dụng web giúp tóm tắt các vấn đề trên GitHub bằng cách sử dụng Quy trình Kubeflow để huấn luyện và phân phát mô hình. Dựa trên một ví dụ trong kho lưu trữ Ví dụ về Kubeflow. Sau khi hoàn thành, cơ sở hạ tầng của bạn sẽ có:

  • Một cụm Google Kubernetes Engine (GKE) đã cài đặt Quy trình Kubeflow (thông qua Quy trình của Cloud AI).
  • 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 thông tin dự đoán từ mô hình đã huấn luyện
  • Một giao diện người dùng diễn giải 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ẽ xây dựng sẽ huấn luyện mô hình Tensor2Tensor trên dữ liệu vấn đề trên GitHub, học cách dự đoán tên vấn đề từ các vấn đề. Sau đó, nền tảng này sẽ xuất mô hình đã huấn luyện và triển khai mô hình đã xuất bằng cách sử dụng tính năng Phân phát thông qua Tenor. Bước cuối cùng trong quy trình sẽ khởi chạy một ứng dụng web, ứng dụng này tương tác với thực thể TF-Serve để nhận thông tin dự đoán về mô hình.

  • Cách cài đặt Quy trình Kubeflow trên cụm GKE
  • Cách xây dựng và chạy quy trình công việc học máy bằng Quy trình Kubeflow
  • Cách xác định và chạy quy trình trên Sổ tay nền tảng AI

Bạn cần có

2. Thiết lập

Cloud Shell

Truy cập vào Bảng điều khiển GCP trong trình duyệt và đăng nhập bằng thông tin đăng nhập của dự án:

Nhấp vào "Chọn dự án" nếu cần để bạn tiếp tục làm việc với dự án của lớp học lập trình.

4f23e1fe87a47cb2.pngs

Sau đó, hãy nhấp vào nút "Kích hoạt Cloud Shell" biểu tượng ở trên cùng bên phải của bảng điều khiển để khởi động Cloud Shell.

ecf212797974dd31.png

Khi khởi động Cloud Shell, bạn sẽ được thông báo tên của dự án được thiết lập để sử dụng. Kiểm tra để đảm bảo chế độ cài đặt này đã chính xác.

Để tìm mã dự án, hãy truy cập vào Bảng điều khiển trên Trang chủ của Bảng điều khiển GCP. Nếu màn hình trống, hãy nhấp vào "Yes" (Có) khi được nhắc tạo trang tổng quan.

115cdf745978ad.pngS

Sau đó, trong cửa sổ dòng lệnh Cloud Shell, hãy chạy các lệnh này nếu cần để định cấu hình gcloud nhằm sử dụng đúng dự án:

export PROJECT_ID=<your_project_id>
gcloud config set project ${PROJECT_ID}

Tạo bộ chứa 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 hệ thống để có thể thuận tiện cho việc xác định tên bộ chứa có chứa mã dự án của bạn. Tạo bộ chứa bằng lệnh gsutil mb (tạo nhóm):

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 bộ chứa thông qua Bảng điều khiển 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ó sẵn công khai. Để tránh bị giới hạn số lượng yêu cầu, đặc biệt là tại các sự kiện có 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 không có quyền. Thông báo này chỉ đơn giản là uỷ quyền cho bạn với tư cách một cá nhân chứ không phải là người dùng ẩn danh.

  1. Truy cập vào https://github.com/settings/tokens và tạo mã thông báo mới không có phạm vi.
  2. Lưu ở nơi an toàn. Nếu bị mất mật khẩu, bạn sẽ phải xoá rồi tạo một mã mới.

Nếu bạn bỏ qua bước này, phòng thí nghiệm vẫn sẽ hoạt động – bạn sẽ chỉ bị giới hạn nhiều hơn một chút trong các lựa chọn tạo dữ liệu đầu vào nhằm kiểm thử mô hình của mình.

Không bắt buộc: Ghim trang tổng quan hữu ích

Trong bảng điều khiển của GCP, hãy ghim trang tổng quan Kubernetes EngineBộ nhớ để truy cập dễ dàng hơn.

2a50622902d75f6a.pngS

Tạo quy trình cho nền tảng AI (Quy trình Kubeflow được lưu trữ)

Làm theo hướng dẫn trong phần "Trước khi bắt đầu" và "Thiết lập phiên bản của bạn" ở đây để thiết lập một phiên bản GKE đã cài đặt KFP. Hãy nhớ đánh dấu vào hộp Cho phép truy cập vào các API đám mây sau đây theo hướng dẫn trong tài liệu. (Nếu không, quy trình mẫu sẽ không chạy thành công). Để nguyên không gian tên cài đặt là default.

Bạn cần chọn một vùng hỗ trợ Nvidia k80s. Bạn có thể sử dụng us-central1-a hoặc us-central1-c làm mặc định.

Hãy ghi lại tên cụmvùng của GKE được liệt kê cho phần cài đặt của bạn trong trang tổng quan về Quy trình AI sau khi cài đặt xong. Bạn cũng có thể đặt các biến môi trường thành các giá trị này để thuận tiện.

6f0729a4fdee88ac.pngS

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 của bạn

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}

Ngoài ra, bạn có thể nhấp vào tên của cụm trên trang tổng quan về Quy trình AI để truy cập vào trang GKE của cụm đó, sau đó nhấp vào "Kết nối" ở đầu trang. Từ 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 của mình. Để 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ó trạng thái là "Ready" và các thông tin khác về tuổi của nút, phiên bản, địa chỉ IP ngoài, hình ảnh hệ điều hành, phiên bản hạt nhân và thời gian chạy vùng chứa.

Đị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 hỗ trợ GPU

Tiếp theo, chúng ta sẽ áp dụng một daemonset cho cụm này. 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ó hỗ trợ GPU:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml

Sau đó, chạy lệnh sau để cấp cho các thành phần KFP quyền tạo các tài nguyên mới của Kubernetes:

kubectl create clusterrolebinding sa-admin --clusterrole=cluster-admin --serviceaccount=kubeflow:pipeline-runner

Tạo nhóm nút GPU

Sau đó, chúng ta sẽ thiết lập một nhóm 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 trên trang tổng quan Pipelines

Mở trang tổng quan Quy trình

Trong bảng điều khiển Cloud, hãy truy cập vào bảng điều khiển Đường dẫn nếu bạn chưa ở đó. Sau đó, nhấp vào "MỞ TRANG TỔNG QUAN VỀ ĐOẠN VIDEO" cho cài đặt của bạn rồi nhấp vào Dòng 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:

7bb5a9cf0773c3bc.png.

Nội dung mô tả đường dẫn

Quy trình 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):

  1. Một điểm kiểm tra mô hình hiện có sẽ được sao chép vào bộ chứa của bạn.
  2. Mô hình Tensor2Tensor được huấn luyện bằng cách sử dụ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 trong bước đầu tiên, sau đó huấn luyện thêm vài trăm bước. (Sẽ mất quá nhiều thời gian để huấn luyện đầy đủ kỹ năng này trong lớp học lập trình này).
  • Khi quá trình huấn luyện kết thúc, bước quy trình sẽ xuất mô hình ở dạng phù hợp để phân phát bằng cách phân phát TensorFlow.
  1. Một thực thể phân phát TensorFlow được triển khai bằng mô hình đó.
  2. Bạn có thể khởi chạy một ứng dụng web để tương tác với mô hình được phân phát nhằm truy xuất cụm từ gợi ý.

Tải xuống và biên dịch quy trình

Trong phần này, chúng ta sẽ tìm hiểu cách biên dịch định nghĩa quy trình. Điều đầu tiên chúng ta cần làm là cài đặt SDK KFP. 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 sau trên Cloud Shell:

curl -O https://raw.githubusercontent.com/amygdala/kubeflow-examples/ghsumm/github_issue_summarization/pipelines/example_pipelines/gh_summ_hosted_kfp.py

Sau đó, biên dịch tệp định nghĩa quy trình bằng cách chạy như sau:

python3 gh_summ_hosted_kfp.py

Bạn sẽ thấy kết quả là tệp gh_summ_hosted_kfp.py.tar.gz.

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 Tải quy trình lên rồi chọn Nhập theo URL. Sao chép, rồi dán vào URL sau đây trỏ đến cùng một quy trình mà bạn vừa biên dịch. (Để tải tệp lên từ Cloud Shell cần thêm một vài bước, chúng ta sẽ tạo lối tắt).

https://storage.googleapis.com/aju-dev-demos-codelabs/KF/compiled_pipelines/gh_summ_hosted_kfp.py.tar.gz

Đặt tên cho quy trình (ví dụ: gh_summ).

867fdbe248d13bab.png.

Chạy quy trình

Nhấp vào quy trình đã tải lên trong danh sách — điều này cho phép bạn xem biểu đồ tĩnh của quy trình — sau đó nhấp vào Tạo thử nghiệm để tạo một Thử nghiệm mới bằng cách sử dụng quy trình. Thử nghiệm là một cách để nhóm các lần chạy có liên quan về mặt ngữ nghĩa.

d4b5b1a043d32d4a.png

Đặt tên cho Thử nghiệm (ví dụ: tên giống với quy trình, gh_summ), sau đó nhấp vào Tiếp theo để tạo.

d9f7d2177efad53.png

Thao tác này sẽ mở ra một trang để bạn có thể nhập các tham số cho Chạy và bắt đầu chạy.

Bạn nên thực thi các lệnh sau trong Cloud Shell để điền các tham số.

gcloud config get-value project
echo "gs://${BUCKET_NAME}/codelab"

Tên Run (Chạy) sẽ được điền tự động nhưng bạn có thể đặt tên khác nếu muốn.

Sau đó, điền vào 3 trường thông số:

  • project
  • (không bắt buộc) github-token
  • working-dir

Đối với thư mục hoạt động, hãy nhập một số đường dẫn trong bộ chứa GCS mà bạn đã tạo. Bao gồm "gs://" tiền tố. Đối với trường github-token, hãy nhập mã thông báo mà bạn đã tạo trước đó (không bắt buộc) hoặc giữ nguyên chuỗi phần giữ chỗ nếu bạn không tạo mã thông báo.

8676afba6fd32ac1.pngS

Sau khi điền vào các trường, hãy nhấp vào Bắt đầu, sau đó nhấp vào lần chạy có trong danh sách để xem chi tiết. Trong khi một bước cụ thể trong quy trình đang chạy, bạn có thể nhấp vào bước đó để xem thêm thông tin về bước đó, bao gồm cả việc xem nhật ký nhóm của quy trình đó. (Bạn cũng có thể xem nhật ký của một bước trong quy trình thông qua đường liên kết đến nhật ký Cloud Logging (Stackdriver), ngay cả khi nút cụm đã bị gỡ bỏ).

db2dc819ac0f5c1.png

Xem định nghĩa quy trình

Trong khi quy trình đang chạy, bạn nên xem xét kỹ hơn cách kết hợp và hoạt động của quy trình. 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 bước huấn luyện hoàn tất, hãy chọn thẻ Visualization (Hình ảnh trực quan) rồi nhấp vào nút Start TensorBoard màu xanh dương, sau đó khi đã sẵn sàng, hãy nhấp vào Open Tensorboard.

6cb511540a64b9e5.png.

d55eb03c4d04f64d.png

Khám phá trang tổng quan Cấu phần phần mềm và các lượt thực thi

Kubeflow Pipelines tự động ghi lại siêu dữ liệu về các bước quy trình khi một quy trình thực thi. Cả thông tin về ArtifactArtifact đều được ghi lại. Hãy nhấp vào các 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.

3002c4055cc8960b.pngS

Đối với Cấu phần phần mềm, bạn có thể xem cả bảng điều khiển tổng quan và bảng điều khiển Trình khám phá dòng tin.

7885776e899d1183.pngS

40c4f7e5b6545dec.png.

Hiển thị ứng dụng web được tạo theo quy trình và đưa ra một số dự đoán

Bước cuối cùng trong quy trình là 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 quá trình Phân phát TF – để đư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 sẽ chuyển tiếp vì đối với lớp học lập trình này, dịch vụ ứng dụng web không được thiết lập để có đ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

Hãy tìm tên dịch vụ như sau: ghsumm-*-webappsvc trong danh sách.

Sau đó, trong Cloud Shell, hãy chuyển tiếp đến dịch vụ đó như sau, thay đổi lệnh sau để sử dụng tên của ứng dụng web của bạn:

kubectl port-forward svc/ghsumm-xxxxx-webappsvc 8080:80

Khi tính năng chuyển tiếp cổng đang chạy, hãy nhấp vào "bản xem trước" biểu tượng phía trên ngăn Cloud Shell và trong trình đơn thả xuống, hãy nhấp vào "Xem trước trên cổng 8080".

65572bb3b12627cc.pngS

Bạn sẽ thấy một trang như thế này xuất hiện trong một thẻ mới:

902ad2d555281508.pngS

Nhấp vào nút Điền vấn đề ngẫu nhiên để truy xuất một khối văn bản. Nhấp vào Generate TItle (Tạo tiêu đề) để gọi mô hình đã huấn luyện và hiển thị thông tin dự đoán.

b7c39ce51ee603bd.png

Nếu các tham số quy trình của bạn có 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 "Điền vấn đề ngẫu nhiên" .

4. Chạy quy trình trên Sổ tay nền tảng AI

Bạn cũng có thể xác định và chạy Quy trình Kubeflow theo cách tương tác trên sổ tay Jupyter bằng SDK KFP. Sổ tay AI Platform mà chúng tôi sẽ sử dụng trong lớp học lập trình này sẽ làm cho việc này trở nên rất đơn giản.

Tạo một thực thể sổ tay

Chúng ta sẽ tạo một thực thể sổ tay từ Cloud Shell bằng API của sổ tay đó. (Ngoài ra, bạn có thể tạo sổ tay qua Cloud Console. Hãy xem tài liệu để biết thêm thông tin).

Thiết lập 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 đó, trên Cloud Shell, hãy chạy lệnh để tạo thực thể 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

Trong lần đầu chạy lệnh này, 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 có.

Sau vài phút, máy chủ sổ tay của bạn sẽ được thiết lập và chạy. Bạn có thể xem các thực thể của mình trong Notebook được liệt kê trong Cloud Console.

206adf3905413dfa.png

Tải sổ tay của lớp học lập trình lên

Sau khi tạo thực thể 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 thực thể sổ tay mà bạn muốn sử dụng. Sổ tay sẽ tự động mở.

Thực thi sổ tay

Làm theo các hướng dẫn trong sổ tay cho các phần còn lại của phòng thí nghiệm. Lưu ý rằng trong phần "Thiết lập" một phần của sổ tay, bạn sẽ cần phải đ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 bạn đang sử dụng dự án của riêng mình, hãy nhớ quay lại và thực hiện phần "Dọn dẹp" trong phòng thí nghiệm này).

5. Dọn dẹp

Bạn không cần làm như vậy nếu đang sử dụng tài khoản lớp học lập trình tạm thời, nhưng bạn nên gỡ bỏ phần cài đặt Quy trình và Sổ tay nếu đang sử dụng dự án của riêng mình.

Gỡ bỏ cụm Pipelines GKE

Bạn có thể xoá cụm Quy trình trong Cloud Console. (Bạn có thể chỉ xoá chế độ cài đặt Pipelines nếu muốn sử dụng lại cụm GKE).

Xoá thực thể AI Notebook

Nếu bạn đã chạy "Sổ tay" của lớp học lập trình này, bạn có thể XOÁ hoặc DỪNG thực thể sổ tay từ 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 mã

Xác định quy trình

Quy trình dùng trong lớp học lập trình này được định nghĩa tại đây.

Hãy xem xét cách định nghĩa, cũng như cách các thành phần (các bước) được định nghĩa. 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 này để biết thêm chi tiết.

Các bước của Quy trình Kubeflow dựa trên vùng chứa. Khi đang xây dựng một quy trình, bạn có thể sử dụng các thành phần tạo sẵn với hình ảnh vùng chứa đã tạo sẵn hoặc tạo các thành phần của riêng mình. Đối với lớp học lập trình này, chúng ta đã tự xây dựng

Bốn bước trong quy trình được xác định từ các thành phần có thể tái sử dụng, được truy cập thông qua tệp định nghĩa thành phần của các thành phần đó. Trong đoạn mã đầu tiên này, chúng ta 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 "hoạt động" mà chúng tôi sẽ sử dụng để tạo bước 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 các định nghĩa thành phần cho 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 nhập vùng chứa đã đượ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 của quy trình thông qua hàm khởi tạo dsl.ContainerOp, như chúng ta sẽ thấy dưới đây.

Dưới đây là phần lớn về định nghĩa quy trình. Chúng ta sẽ xác định đầu vào quy trình (và các giá trị mặc định của chúng). Sau đó, chúng ta sẽ xác định các bước quy trình. Đa số chúng tôi sử dụng "hoạt động" được xác định ở trên, nhưng chúng ta cũng đang xác định "phân phát" bước cùng dòng thông qua ContainerOp, trực tiếp chỉ định hình ảnh vùng chứa và đối số điểm nhập.

Bạn có thể thấy rằng các bước train, log_modelserve đang truy cập vào kết quả của các bước trước đó làm dữ liệu đầu vào. Bạn có thể đọc thêm về cách chỉ định điều 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)

Lưu ý rằng chúng tôi yêu cầu "tàu" bước để chạy trên một nút trong cụm có sẵn í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 cùng dòng) là bước có điều kiện. Bộ lọc này sẽ chạy sau "serve" chỉ kết thúc khi bước huấn luyện launch_server đầu ra là chuỗi "true". Công cụ này khởi chạy "ứng dụng web dự đoán" mà chúng tôi dùng để yêu cầu thông tin tóm tắt về vấn đề từ mô hình T2T đã qua 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ề Quy trình Kubeflow mô tả một số phương pháp hay nhất để xây dựng các thành phần của riêng bạn. Trong quá trình này, bạn sẽ cần xác định và tạo 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 của Dockerfile nằm trong các thư mục con containers, ví dụ: tại đây.

Dùng máy ảo có thể giành trước cùng với GPU để huấn luyện

Máy ảo tạm thời là các phiên bản của Máy ảo Compute Engine hoạt động tối đa 24 giờ và không đảm bảo khả năng sử dụng. Giá của máy ảo có thể được ưu tiê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 nhóm nút sử dụng các máy ảo có thể giành quyền truy cập. Bạn có thể thiết lập một nhóm nút như vậy với GPU được đính kèm với các thực thể có thể giành quyền trước. Các lớp này hoạt động giống như các nút có GPU thông thường, nhưng GPU chỉ tồn tại trong thời gian hoạt động của thực thể.

Bạn có thể thiết lập một nhóm nút có thể giành quyền, được bật GPU cho cụm của mình bằng cách chạy một lệnh tương tự như sau, chỉnh sửa lệnh sau đây với tên và vùng của cụm, cũng như điều chỉnh loại trình tăng tốc và số lượng theo yêu cầu của bạn. Bạn có thể tuỳ ý xác định nhóm nút để tự động điều chỉnh tỷ lệ 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 nhóm nút thông qua Cloud Console.

Xác định một Quy trình Kubeflow sử dụng các nút GKE có thể giành trước

Nếu đang chạy Kubeflow trên GKE, thì giờ đây, bạn có thể dễ dàng xác định và chạy Quy trình Kubeflow, trong đó một hoặc nhiều bước quy trình (thành phần) chạy trên các nút có quyền sử dụng trước, giúp giảm chi phí thực hiện công việc. Để việc sử dụng máy ảo có thể giành quyền trước nhằm đưa ra kết quả chính xác, các bước mà bạn xác định là có thể bị bỏ qua phải không thay đổi (nghĩa là nếu bạn chạy một bước nhiều lần thì sẽ có cùng một kết quả) hoặc phải hoạt động ở điểm kiểm tra để bước đó có thể tiếp tục từ nơi đã dừng lại nếu bị gián đoạn.

Khi xác định Quy trình Kubeflow, bạn có thể cho biết rằng một bước cụ thể sẽ chạy trên một nút có thể giành trước bằng cách sửa đổi hoạt động như sau:

your_pipelines_op.apply(gcp.use_preemptible_nodepool())

Hãy xem tài liệu để biết thông tin chi tiết.

Có lẽ bạn cũng nên thử lại bước này một vài lần nếu nút đó bị giành quyền. Bạn có thể thực hiện như sau. Ở đây, chúng tôi 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 tôi đã sử 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 máy ảo có thể truy cập trước.

Thay đổi dòng sau trong thông số kỹ thuật của quy trình để sử dụng thêm một nhóm nút có thể giành trước (hãy đảm bảo bạn đã tạo một nhóm nút như chỉ ra ở trên) ở trên và để thử lại 5 lần:

  train.set_gpu_limit(1)

Sau đó, 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 quy trình) rồi chạy phiên bản mới của quy trình.