Các phương pháp hay nhất để đào tạo tăng tốc TensorFlow 1.x trên Amazon SageMaker

Ngày nay, rất nhiều khách hàng đang sử dụng TensorFlow để đào tạo mô hình học sâu về tỷ lệ nhấp của họ trong các đề xuất quảng cáo và cá nhân hóa trong thương mại điện tử. Khi hành vi của khách hàng thay đổi, họ có thể tích lũy một lượng lớn dữ liệu mới mỗi ngày. Lặp lại mô hình là một trong những công việc hàng ngày của nhà khoa học dữ liệu, nhưng họ phải đối mặt với vấn đề mất quá nhiều thời gian để đào tạo trên các tập dữ liệu lớn.

Amazon SageMaker là một nền tảng học máy (ML) được quản lý hoàn toàn có thể giúp các nhà khoa học dữ liệu tập trung vào các mô hình thay vì cơ sở hạ tầng, với hỗ trợ gốc cho các thuật toán và khuôn khổ của riêng bạn như TensorFlow và PyTorch. SageMaker cung cấp các tùy chọn đào tạo phân tán linh hoạt điều chỉnh theo quy trình công việc cụ thể của bạn. Bởi vì nhiều nhà khoa học dữ liệu có thể thiếu kinh nghiệm trong quá trình đào tạo tăng tốc, trong bài đăng này, chúng tôi chỉ cho bạn các yếu tố quan trọng để đào tạo mô hình học sâu nhanh và các phương pháp đào tạo tăng tốc tốt nhất cho TensorFlow 1.x trên SageMaker. Chúng tôi cũng có một mã mẫu của DeepFM đào tạo phân phối trên SageMaker về Repo GitHub.

Có nhiều yếu tố bạn nên xem xét để tối đa hóa việc sử dụng CPU / GPU khi chạy tập lệnh TensorFlow của mình trên SageMaker, chẳng hạn như cơ sở hạ tầng, loại bộ tăng tốc, phương pháp đào tạo phân tán, phương pháp tải dữ liệu, đào tạo chính xác hỗn hợp, v.v.

Chúng tôi thảo luận về các phương pháp hay nhất trong các lĩnh vực sau:

• Tăng tốc đào tạo trên một phiên bản duy nhất
• Tăng tốc đào tạo trên nhiều trường hợp
• Đường ống dẫn dữ liệu
• Đào tạo chính xác hỗn hợp tự động

Tăng tốc đào tạo trên một phiên bản duy nhất

Khi chạy tập lệnh TensorFlow của bạn trên một phiên bản, bạn có thể chọn một chuỗi được tối ưu hóa cho máy tính, chẳng hạn như Đám mây điện toán đàn hồi Amazon (Amazon EC2) Dòng C5 hoặc dòng máy tính tăng tốc với nhiều GPU trong một phiên bản như p3.8xlarge, p3.16xlarge, p3dn.24xlarge và p4d.24xlarge.

Trong phần này, chúng tôi thảo luận về các chiến lược cho nhiều CPU trên một phiên bản duy nhất và đào tạo phân tán với nhiều GPU trên một phiên bản duy nhất.

Nhiều CPU trên một phiên bản duy nhất

Trong phần này, chúng tôi thảo luận về việc thiết lập thủ công tính song song của các nhà khai thác trên các thiết bị CPU, phương pháp tháp, TensorFlow MirroredStrategy và Horovod.

Đặt thủ công song song của các nhà khai thác trên các thiết bị CPU

TensorFlow tự động chọn số lượng luồng thích hợp để song song tính toán hoạt động trong quá trình huấn luyện. Tuy nhiên, bạn có thể đặt intra_op nhóm chủ đề và inter_op cài đặt song song do TensorFlow cung cấp và sử dụng các biến môi trường của MKL-DNN để đặt ràng buộc cho chuỗi hệ điều hành. Xem đoạn mã sau:

# Set parallelism of intra_op and inter_op
num_cpus = int(os.environ['SM_NUM_CPUS'])
config = tf.ConfigProto(allow_soft_placement=True, device_count={'CPU': num_cpus}, intra_op_parallelism_threads=num_cpus, inter_op_parallelism_threads=num_cpus)
run_config = tf.estimator.RunConfig().replace(session_config = config)

# Use Intel MKL-DNN Setting to accelerate training speed
os.environ["KMP_AFFINITY"]= "verbose,disabled"
os.environ['OMP_NUM_THREADS'] = str(num_cpus)
os.environ['KMP_SETTINGS'] = '1'

Biến môi trường KMP_AFFINITY của MKL-DNN được đặt thành granularity=fine,compact,1,0 theo mặc định. Sau khi đặt cả intra và inter của TensorFlow thành số vCPU tối đa của phiên bản hiện tại, giới hạn trên của việc sử dụng CPU gần như bằng với số lõi vật lý của phiên bản huấn luyện.

Nếu bạn đặt os.environ["KMP_AFFINITY"]= "verbose,disabled", luồng hệ điều hành không bị ràng buộc với siêu luồng phần cứng và việc sử dụng CPU có thể vượt quá số lõi vật lý.

Về các cài đặt của tính song song trong TensorFlow, song song giữa các TensorFlow và số luồng MKL-DNN, sự kết hợp khác nhau của ba tham số này dẫn đến tốc độ huấn luyện khác nhau. Do đó, bạn cần thử nghiệm từng trường hợp để tìm ra sự kết hợp tốt nhất. Một tình huống phổ biến là đặt ba tham số (intra_op_parallelism_threads và inter_op_parallelism_threads cho TensorFlow, os.environ['OMP_NUM_THREADS'] cho MKL-DNN) đến một nửa số vCPU (lõi vật lý) hoặc tổng số vCPU.

Phương pháp tháp

Để sao chép một mô hình qua GPU, mỗi GPU sẽ nhận được phiên bản chuyển tiếp của riêng nó. Ví dụ của chuyển tiếp được gọi là tháp. Phương pháp tháp hầu như luôn được sử dụng cho các thiết bị GPU. Để so sánh tốc độ đào tạo với các phương pháp khác, ở đây chúng tôi cũng sử dụng phương pháp tháp cho thiết bị CPU của mình.

Nếu bạn không đặt thiết bị CPU theo cách thủ công, TensorFlow không sử dụng phương pháp tháp để tính trung bình các gradient, vì vậy bạn không cần phải chia tỷ lệ kích thước lô trong những trường hợp như vậy.

1. Đặt thiết bị CPU theo cách thủ công:

device_list = []
if manual_CPU_device_set:
		cpu_prefix=’/cpu:’
		for I in range(1, num_cpus):
			devices_list.append(cpu_prefix + str(i))

2. Sử dụng replicate_model_fn quấn model_fn:

DeepFM = tf.estimator.Estimator(model_fn=tf.contrib.estimator.replicate_model_fn(model_fn, devices=device_list), model_dir=FLAGS.model_dir, params=model_params, config=config)

3. Sử dụng TowerOptimizer quấn optimizer:

optimizer = tf.contrib.estimator.TowerOptimizer(optimizer)

4. Bọc của bạn model_fn:

with tf.variable_scope(‘deepfm_model’, reuse=tf.AUTO_REUSE)

5. Điều chỉnh kích thước lô thành (NUM_CPU - 1).

Hãy xem xét sự khác biệt của việc sử dụng CPU khi bật chế độ tháp. Hình sau cho thấy việc sử dụng CPU của phiên bản ml.c5.18xlarge với cấu hình sau:

Không có dữ liệu Tower + LibSVM + chế độ ống + MKL-DNN vô hiệu hóa ràng buộc + Cài đặt song song TensorFlow intra / inter op thành số vCPU của phiên bản tối đa

Hình sau cho thấy việc sử dụng CPU của phiên bản ml.c5.18xlarge với cấu hình sau:

Tháp với thiết bị CPU đã đặt + Dữ liệu LibSVM + chế độ ống + Liên kết vô hiệu hóa MKL-DNN + Cài đặt song song TensorFlow intra / inter op thành số vCPU tối đa của phiên bản

Việc sử dụng CPU cao hơn khi sử dụng phương pháp tháp và nó vượt quá số lõi vật lý.

TensorFlow MirroredChiến lược

TensorFlow MirroredStrategy có nghĩa là đào tạo đồng bộ trên nhiều bản sao trên một máy. Chiến lược này thường được sử dụng để đào tạo trên một máy có nhiều GPU. Để so sánh tốc độ đào tạo với một phương pháp khác, chúng tôi sử dụng MirroredStrategy cho thiết bị CPU của mình.

Khi sử dụng TensorFlow MirroredStrategy, nếu bạn không đặt thiết bị CPU, TensorFlow chỉ sử dụng một CPU làm nhân viên duy nhất, điều này gây lãng phí tài nguyên. Chúng tôi khuyên bạn nên cài đặt thiết bị CPU theo cách thủ công, vì nó sẽ làm giảm hoạt động trên /CPU:0, Do đó /CPU:0 thiết bị không được sử dụng như một bản sao ở đây. Xem đoạn mã sau:

device_list = []
if manual_CPU_device_set:
		cpu_prefix=’/cpu:’
		for I in range(1, num_cpus):
			devices_list.append(cpu_prefix + str(i))
mirrored_strategy = tf.distribute.MirroredStrategy(devices=devices_list)
	else:
mirrored_strategy = tf.distribute.MirroredStrategy()

# Set strategy to config:
config = tf.estimator.RunConfig(train_distribute=mirrored_strategy,
eval_distribute=mirrored_strategy,
session_config = config)

Bạn cần chia tỷ lệ kích thước hàng loạt khi sử dụng MirroredStrategy; ví dụ: chia tỷ lệ kích thước lô thành bội số của số lượng thiết bị GPU.

Đối với chiến lược phụ khi bạn đặt thiết bị CPU, nếu bạn không đặt cross_device_ops tham số trong tf.distribute.MirroredStrategy(), TensorFlow sử dụng ReductionToOneDevice chiến lược phụ theo mặc định. Tuy nhiên, nếu bạn đặt HierarchicalCopyAllReduce là chiến lược phụ, TensorFlow chỉ thực hiện công việc giảm bớt /CPU:0. Khi bạn sử dụng API tập dữ liệu TensorFlow và phân phối chiến lược cùng nhau, đối tượng tập dữ liệu sẽ được trả về thay vì các tính năng và nhãn trong hàm input_fn.

Thông thường, TensorFlow MirroredStrategy chậm hơn so với phương pháp tháp khi đào tạo CPU, vì vậy chúng tôi khuyên bạn không nên sử dụng MirroredStrategy trên một máy chủ đơn nhiều CPU.

Horovod

Horovod là một khung đào tạo học sâu phân tán cho TensorFlow, Keras, PyTorch và Apache MXNet. Mục tiêu của Horovod là làm cho việc học sâu phân tán trở nên nhanh chóng và dễ sử dụng.

Có một tham số là distribution trong API ước tính SDK SageMaker Python, mà bạn có thể sử dụng để nêu rõ khóa đào tạo phân tán Horovod. SageMaker cung cấp cơ sở hạ tầng và chạy tập lệnh của bạn với MPI. Xem đoạn mã sau:

hvd_processes_per_host = 4
distribution = {'mpi': { 
'enabled': True, 
'processes_per_host': hvd_processes_per_host,
'custom_mpi_options': '-verbose --NCCL_DEBUG=INFO -x OMPI_MCA_btl_vader_single_copy_mechanism=none' 
} 
}

Khi chọn một phiên bản GPU, chẳng hạn như ml.p3.8xlarge, bạn cần ghim từng GPU cho mọi nhân viên:

config = tf.ConfigProto()
config.gpu_options.visible_device_list = str(hvd.local_rank())

Để tăng tốc độ hội tụ mô hình, hãy chia tỷ lệ học tập theo số lượng công nhân theo tài liệu chính thức của Horovod. Tuy nhiên, trong các dự án thực tế, bạn nên mở rộng tỷ lệ học tập ở một mức độ nào đó, chứ không phải theo số lượng công nhân, điều này dẫn đến hiệu suất mô hình không tốt. Ví dụ: nếu tỷ lệ học tập ban đầu là 0.001, chúng tôi chia tỷ lệ học tập thành 0.0015, ngay cả khi số lượng công nhân là bốn người trở lên.

Nói chung, chỉ có chính (xếp hạng Horovod 0) lưu điểm kiểm tra và mô hình cũng như hoạt động đánh giá. Bạn không cần phải chia tỷ lệ kích thước lô khi sử dụng Horovod. SageMaker cung cấp Chế độ ống để truyền dữ liệu từ Dịch vụ lưu trữ đơn giản của Amazon (Amazon S3) vào các phiên bản đào tạo. Khi bạn bật chế độ Pipe, hãy lưu ý rằng các công nhân khác nhau trên cùng một máy chủ cần sử dụng các kênh khác nhau để tránh lỗi. Điều này là do quy trình công nhân đầu tiên đọc dữ liệu FIFO / kênh và các quy trình công nhân khác trên cùng một phiên bản sẽ bị treo vì chúng không thể đọc dữ liệu từ cùng một FIFO / kênh, vì vậy Horovod không hoạt động bình thường. Để tránh vấn đề này, hãy đặt các kênh theo số lượng công nhân cho mỗi trường hợp. Ít nhất hãy đảm bảo rằng những người lao động khác nhau trên cùng một máy chủ sử dụng các kênh khác nhau; cùng một kênh có thể được sử dụng bởi người lao động trên một máy chủ lưu trữ khác nhau.

Khi sử dụng Horovod, bạn có thể gặp phải lỗi sau:

“One or more tensors were submitted to be reduced, gathered or broadcasted by subset of ranks and are waiting for remainder of ranks for more than 60 seconds. This may indicate that different ranks are trying to submit different tensors or that only subset of ranks is submitting tensors, which will cause deadlock.”

Nguyên nhân có thể cho vấn đề này là một cấp bậc nhất định (chẳng hạn như cấp bậc 0) làm việc chậm hơn hoặc làm nhiều công việc hơn các cấp bậc khác, và điều này khiến các cấp bậc khác phải chờ đợi lâu. Mặc dù hạng 0 đôi khi phải làm nhiều việc hơn các hạng khác, nhưng cần lưu ý rằng hạng 0 không nên làm nhiều việc trong một thời gian dài. Ví dụ: đối với đánh giá mô hình trên bộ xác nhận và lưu các điểm kiểm tra trong quá trình đào tạo, nếu không thể tránh khỏi việc các hoạt động này sẽ mất nhiều thời gian, có thể gây ra lỗi, một giải pháp là để tất cả công nhân làm công việc giống như xếp hạng 0 (các điểm kiểm tra lưu, đánh giá, v.v.).

Phân bổ dữ liệu là một trong những điều quan trọng nhất cần xem xét khi sử dụng đào tạo phân tán. Bạn có thể sử dụng TensorFlow dataset.shard() trong kịch bản của bạn. SageMaker cũng cung cấp tính năng phân đoạn tập dữ liệu trong kênh đầu vào bằng cách thiết lập distribution=S3shardbykey trong kênh tập dữ liệu. Xem đoạn mã sau:

dataset = PipeModeDataset(channel, record_format='TFRecord')

number_host = len(FLAGS.hosts)

if FLAGS.enable_data_multi_path : # If there are multi channels mapping with different S3 path
    if FLAGS.enable_s3_shard == False :
        if number_host > 1:
            index = hvd.rank() // FLAGS.worker_per_host
            dataset = dataset.shard(number_host, index)
else :
    if FLAGS.enable_s3_shard :
        dataset = dataset.shard(FLAGS.worker_per_host, hvd.local_rank())
    else :
        dataset = dataset.shard(hvd.size(), hvd.rank())

Hình sau cho thấy kết quả khi sử dụng Horovod (ml.c5.18xlarge, Horovod + LibSVM + cài đặt intra op và inter op mặc định), bạn có thể so sánh với phương pháp tháp.

Đào tạo phân tán với nhiều GPU trên một phiên bản duy nhất

Việc bắt đầu đào tạo phân tán với nhiều GPU trên một phiên bản là điều bình thường vì các nhà khoa học dữ liệu chỉ cần quản lý một phiên bản và tận dụng lợi thế của liên kết tốc độ cao giữa các GPU. Các công việc đào tạo của SageMaker hỗ trợ nhiều loại phiên bản có nhiều GPU trên một phiên bản, chẳng hạn như ml.p3.8xlarge, ml.p3.16xlarge, ml.p3dn.24xlarge và ml.p4d.24xlarge. Phương thức này giống như nhiều CPU trong một phiên bản đơn lẻ, nhưng với một vài thay đổi trong tập lệnh.

Phương pháp tháp

Phương pháp tháp ở đây gần giống như trong đào tạo đa CPU. Bạn cần chia tỷ lệ kích thước lô theo số lượng GPU được sử dụng.

TensorFlow MirroredChiến lược

Chiến lược phụ mặc định của MirroredStrategy is NcclAllReduce. Bạn cần chia tỷ lệ kích thước lô theo số lượng GPU được sử dụng. Xem đoạn mã sau:

mirrored_strategy = tf.distribute.MirroredStrategy()
config = tf.estimator.RunConfig(train_distribute=mirrored_strategy,
				eval_distribute=mirrored_strategy)

Tăng tốc đào tạo trên nhiều trường hợp

Mở rộng quy mô luôn là một lựa chọn để cải thiện tốc độ đào tạo. Ngày càng có nhiều nhà khoa học dữ liệu chọn điều này làm tùy chọn mặc định liên quan đến đào tạo phân tán. Trong phần này, chúng tôi thảo luận về các chiến lược đào tạo phân tán với nhiều máy chủ.

Nhiều CPU với nhiều phiên bản

Có bốn phương pháp chính để sử dụng nhiều CPU với nhiều trường hợp khi bật đào tạo phân tán:

• • Máy chủ tham số mà không cần thiết lập thủ công song song của các nhà khai thác trên các thiết bị CPU
  • Máy chủ tham số với cài đặt thủ công song song của các nhà khai thác trên các thiết bị CPU
  • Máy chủ tham số có tháp (thiết lập thiết bị CPU theo cách thủ công và đặt allow_soft_placement=True in tf.ConfigProto)
  • Horovod

Khi sử dụng một máy chủ tham số trong tf.estimator API, đường dẫn của trạm kiểm soát phải là đường dẫn có thể chia sẻ được, chẳng hạn như Amazon S3 hoặc đường dẫn cục bộ của Dịch vụ tệp đàn hồi của Amazon (Amazon EFS) ánh xạ tới vùng chứa. Đối với một máy chủ tham số trong tf.keras, đường dẫn điểm kiểm tra có thể được đặt thành đường dẫn cục bộ. Đối với Horovod, đường dẫn điểm kiểm tra có thể được đặt thành đường dẫn cục bộ của phiên bản huấn luyện.

Khi sử dụng một máy chủ tham số và tf.estimator API với đường dẫn điểm kiểm tra đến Amazon S3, nếu mô hình khá lớn, bạn có thể gặp lỗi chính bị kẹt khi lưu điểm kiểm tra vào S3. Bạn có thể sử dụng vùng chứa tích hợp sẵn của SageMaker TensorFlow 1.15 hoặc TensorFlow 1.15.2 hoặc sử dụng Amazon EFS làm đường dẫn điểm kiểm tra của lượt chia sẻ.

Khi sử dụng máy chủ tham số cho nhiều máy chủ, tải thông số trên mỗi quá trình máy chủ tham số có thể không cân bằng (đặc biệt khi có các biến bảng nhúng tương đối lớn), điều này có thể gây ra lỗi. Bạn có thể kiểm tra kích thước tệp của từng điểm kiểm tra của phân đoạn trong Amazon S3 để xác định xem các thông số trên máy chủ thông số có cân bằng hay không, vì mỗi máy chủ thông số tương ứng với một phân đoạn của tệp điểm kiểm tra. Để tránh những vấn đề như vậy, bạn có thể sử dụng chức năng phân vùng để cố gắng làm cho các tham số của từng máy chủ tham số được phân phối đồng đều:

with tf.variable_scope('deepfm_model', reuse=tf.AUTO_REUSE, partitioner = tf.fixed_size_partitioner(num_shards=len(FLAGS.hosts))):

GPU đơn với nhiều phiên bản

Các công việc đào tạo của SageMaker hỗ trợ các phiên bản chỉ có một GPU, như dòng ml.p3.xlarge, ml.g4dn và ml.g5. Có hai phương pháp chính được sử dụng trong trường hợp này: máy chủ tham số và Horovod.

Phương pháp đào tạo phân tán máy chủ tham số tích hợp sẵn của SageMaker là bắt đầu một quy trình máy chủ tham số và quy trình công nhân cho mỗi trường hợp huấn luyện (mỗi máy chủ tham số chỉ chịu trách nhiệm cho một phần của các tham số mô hình), do đó, mặc định là đa máy đơn- Đào tạo GPU. Đào tạo phân tán máy chủ tham số tích hợp SageMaker là một phương pháp cập nhật gradient không đồng bộ. Để giảm tác động của các cập nhật không đồng bộ đối với sự hội tụ đào tạo, bạn nên giảm tỷ lệ học tập. Nếu bạn muốn sử dụng tất cả các GPU trên phiên bản, bạn cần sử dụng kết hợp máy chủ tham số và phương pháp tháp.

Đối với Horovod, chỉ cần đặt processes_per_host=1 trong tham số phân phối của SageMaker Python Estimator API.

Nhiều GPU với nhiều phiên bản

Đối với các máy chủ tham số và phương pháp tháp, các thay đổi mã về cơ bản giống như phương pháp tháp cho một phiên bản duy nhất với nhiều GPU và không cần phải thiết lập các thiết bị GPU theo cách thủ công.

Đối với Horovod, hãy đặt process_per_host trong tham số phân phối thành số GPU của mỗi phiên bản huấn luyện. Nếu bạn sử dụng chế độ Pipe, số lượng công nhân trên mỗi phiên bản cần phải khớp với số kênh.

Đường ống dẫn dữ liệu

Ngoài cơ sở hạ tầng mà chúng ta đã thảo luận, có một điều quan trọng khác cần xem xét: đường ống dẫn dữ liệu. Đường ống dữ liệu đề cập đến cách bạn tải dữ liệu và chuyển đổi dữ liệu trước khi nó cấp vào mạng thần kinh. CPU được sử dụng để chuẩn bị dữ liệu, trong khi GPU được sử dụng để tính toán dữ liệu từ CPU. Bởi vì GPU là một tài nguyên đắt tiền, nhiều thời gian nhàn rỗi của GPU sẽ không hiệu quả; một đường dẫn dữ liệu tốt trong công việc đào tạo của bạn có thể cải thiện việc sử dụng GPU và CPU.

Khi bạn đang cố gắng tối ưu hóa quy trình nhập dữ liệu TensorFlow của mình, hãy xem xét thứ tự API được sử dụng trong Bộ dữ liệu TensorFlow, kích thước dữ liệu đào tạo (nhiều tệp nhỏ hoặc một số tệp lớn), kích thước hàng loạt, v.v.

Chúng ta hãy xem xét sự tương tác giữa GPU và CPU trong quá trình đào tạo. Các số liệu sau đây so sánh các tương tác có và không có đường dẫn.

Một đường dẫn tốt hơn có thể giảm thời gian nhàn rỗi của GPU. Hãy xem xét các mẹo sau:

• Sử dụng logic chức năng đơn giản trong việc trích xuất các tính năng và nhãn
• Tìm nạp trước các mẫu vào bộ nhớ
• Giảm I / O đĩa không cần thiết và I / O mạng
• Lưu trữ các tính năng và nhãn đã xử lý trong bộ nhớ
• Giảm số lần sao chép giữa CPU và GPU
• Yêu cầu các công nhân khác nhau giải quyết các phần khác nhau của tập dữ liệu đào tạo
• Giảm thời gian gọi API tập dữ liệu TensorFlow

TensorFlow cung cấp một API chuyển đổi liên quan đến các định dạng tập dữ liệu và thứ tự của API chuyển đổi trong TensorFlow ảnh hưởng rất nhiều đến tốc độ đào tạo. Thứ tự tốt nhất để gọi API tập dữ liệu TensorFlow cần được kiểm tra. Sau đây là một số nguyên tắc cơ bản:

• Sử dụng bản đồ vectơ. Điều này có nghĩa là trước tiên hãy gọi API lô tập dữ liệu TensorFlow, sau đó gọi API bản đồ tập dữ liệu. Chức năng phân tích cú pháp tùy chỉnh được cung cấp trong chức năng bản đồ, chẳng hạn như decode_tfrecord trong mã mẫu, phân tích cú pháp một loạt dữ liệu nhỏ. Ngược lại, bản đồ đầu tiên và sau đó hàng loạt là một bản đồ vô hướng và chức năng phân tích cú pháp tùy chỉnh xử lý chỉ một mẫu.
• Sử dụng API bộ nhớ cache tập dữ liệu TensorFlow để lưu các tính năng và nhãn vào bộ nhớ cache. Đặt API bộ nhớ cache tập dữ liệu TensorFlow trước API lặp lại tập dữ liệu TensorFlow, nếu không việc sử dụng RAM sẽ tăng tuyến tính theo từng thời kỳ. Nếu tập dữ liệu lớn bằng RAM, không sử dụng API bộ nhớ cache tập dữ liệu TensorFlow. Nếu bạn cần sử dụng API bộ nhớ cache tập dữ liệu TensorFlow và API xáo trộn, hãy cân nhắc sử dụng theo thứ tự sau: tạo đối tượng tập dữ liệu TensorFlow -> API bộ nhớ cache -> API xáo trộn -> API lô -> API bản đồ -> API lặp lại -> API tìm nạp trước.
• Sử dụng tfrecord định dạng tập dữ liệu hơn định dạng LibSVM.
• Chế độ tệp hoặc chế độ ống tùy thuộc vào định dạng tập dữ liệu và số lượng tệp của bạn. Các tfrecorddataset API có thể đặt num_parallel_reads để đọc nhiều tệp song song và thiết lập buffer_size để tối ưu hóa việc đọc dữ liệu, trong khi pipemodedataset API không có cài đặt như vậy. Chế độ ống thích hợp hơn cho các trường hợp một tệp lớn và tổng số tệp nhỏ. Chúng tôi khuyên bạn nên sử dụng công việc xử lý SageMaker để thực hiện công việc tiền xử lý, chẳng hạn như nối nhiều tệp vào một tệp lớn hơn theo nhãn, sử dụng phương pháp lấy mẫu để làm cho tập dữ liệu cân bằng hơn và xáo trộn tập dữ liệu cân bằng.

Xem mẫu mã sau:

def decode_tfrecord(batch_examples):
        # The feature definition here should BE consistent with LibSVM TO TFRecord process.
        features = tf.parse_example(batch_examples,
                                           features={
                                               "label": tf.FixedLenFeature([], tf.float32),
                                               "ids": tf.FixedLenFeature(dtype=tf.int64, shape=[FLAGS.field_size]),
                                               "values": tf.FixedLenFeature(dtype=tf.float32, shape=[FLAGS.field_size]) 
                                           })
        
        batch_label = features["label"]
        batch_ids = features["ids"]
        batch_values = features["values"]
        
        return {"feat_ids": batch_ids, "feat_vals": batch_values}, batch_label


    def decode_libsvm(line):
        columns = tf.string_split([line], ' ')
        labels = tf.string_to_number(columns.values[0], out_type=tf.float32)
        splits = tf.string_split(columns.values[1:], ':')
        id_vals = tf.reshape(splits.values,splits.dense_shape)
        feat_ids, feat_vals = tf.split(id_vals,num_or_size_splits=2,axis=1)
        feat_ids = tf.string_to_number(feat_ids, out_type=tf.int32)
        feat_vals = tf.string_to_number(feat_vals, out_type=tf.float32)
        return {"feat_ids": feat_ids, "feat_vals": feat_vals}, labels

if FLAGS.pipe_mode == 0:
        dataset = tf.data.TFRecordDataset(filenames)
    else :
        # Enter Pipe mode
        dataset = PipeModeDataset(channel, record_format='TFRecord')
        
    if FLAGS.enable_s3_shard == False:
        host_rank = FLAGS.hosts.index(FLAGS.current_host)
        number_host = len(FLAGS.hosts)
        dataset = dataset.shard(number_host, host_rank)
    
    dataset = dataset.batch(batch_size, drop_remainder=True) # Batch size to use
    dataset = dataset.map(decode_tfrecord,
                          num_parallel_calls=tf.data.experimental.AUTOTUNE) 

    if num_epochs > 1:
        dataset = dataset.repeat(num_epochs)
    dataset = dataset.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)

Để đào tạo về các phiên bản CPU, thiết lập tính song song của intra op, inter op, và biến môi trường của MKL-DNN là một điểm khởi đầu tốt.

Đào tạo chính xác hỗn hợp tự động

Điều cuối cùng chúng ta thảo luận là đào tạo độ chính xác hỗn hợp tự động, có thể tăng tốc độ và dẫn đến hiệu suất của mô hình. Theo bài viết này, GPU Nvidia V100 (phiên bản P3) và A100 (phiên bản P4dn) hỗ trợ lõi Tensor. Bạn có thể bật đào tạo độ chính xác hỗn hợp trong TensorFlow khi sử dụng các loại phiên bản đó. Bắt đầu từ phiên bản 1.14, TensorFlow đã hỗ trợ đào tạo độ chính xác hỗn hợp tự động. Bạn có thể sử dụng câu lệnh sau để bao bọc trình tối ưu hóa ban đầu của mình:

tf.train.experimental.enable_mixed_precision_graph_rewrite(optimizer)

Nếu mô hình nhỏ và việc sử dụng GPU thấp, thì việc đào tạo độ chính xác hỗn hợp tự động sẽ không có lợi thế. Nếu mô hình lớn, đào tạo chính xác hỗn hợp tự động có thể đẩy nhanh tốc độ đào tạo.

Kết luận

Khi bạn bắt đầu đào tạo mô hình học sâu của mình trong SageMaker, hãy xem xét các mẹo sau để đạt được tốc độ đào tạo nhanh hơn:

• Trước tiên, hãy thử phương pháp đa CPU, đơn phiên bản hoặc một GPU, phương pháp đơn phiên bản. Nếu hiệu suất sử dụng CPU / GPU rất cao (ví dụ hơn 90%), hãy chuyển sang bước tiếp theo.
• Thử nhiều CPU hơn trong một máy chủ hoặc nhiều GPU hơn trong một máy chủ duy nhất. Nếu mức sử dụng gần đạt mức sử dụng tối đa của CPU hoặc GPU, hãy chuyển sang bước tiếp theo.
• Thử nhiều CPU hoặc nhiều GPU với nhiều máy chủ.
• Bạn cần sửa đổi mã khi sử dụng máy chủ tham số hoặc Horovod. Việc sửa đổi mã không giống với API dựa trên phiên TensorFlow, tf.estimator API và tf.keras API. Máy chủ tham số hoặc Horovod có thể hiển thị các tốc độ đào tạo khác nhau trong các trường hợp và nhiệm vụ đào tạo khác nhau, vì vậy hãy thử cả hai phương pháp nếu bạn có thời gian và ngân sách để xác định phương pháp tốt nhất.

Hãy ghi nhớ những lời khuyên sau:

• Kiểm tra việc sử dụng trước khi mở rộng quy mô, tối ưu hóa đường ống dữ liệu của bạn và làm cho CPU và GPU chồng chéo lên nhau trong dòng thời gian.
• Đầu tiên hãy mở rộng quy mô, sau đó mở rộng quy mô.
• Nếu bạn không thể tăng hiệu suất sử dụng GPU của mình sau tất cả các phương pháp, hãy thử CPU. Có nhiều trường hợp (đặc biệt là đối với mô hình xếp hạng tỷ lệ nhấp) trong đó tổng thời gian đào tạo phiên bản CPU ngắn hơn và tiết kiệm chi phí hơn so với đào tạo phiên bản GPU.

Chúng tôi cũng có một mẫu mã trong Repo GitHub, nơi chúng tôi hiển thị hai mẫu đào tạo được phân phối DeepFM trên SageMaker. Một là máy chủ tham số TensorFlow trên các phiên bản CPU, cái còn lại là Horovod trên các phiên bản GPU.

Về các tác giả

Dư Huệ Lương là một kiến ​​trúc sư giải pháp học máy của Sr. Anh ấy tập trung vào việc thúc đẩy và ứng dụng máy học, đồng thời tham gia sâu vào nhiều dự án máy học của khách hàng. Anh ấy có kinh nghiệm phong phú trong đào tạo phân tán học sâu, hệ thống đề xuất và quảng cáo tính toán.

Thạch Soái Vương là một kiến ​​trúc sư giải pháp học máy của Sr. Anh ấy làm việc với các khách hàng của AWS để giúp họ áp dụng học máy trên quy mô lớn. Anh ấy thích xem phim và đi du lịch khắp thế giới.