การประมวลผลแบบกระจาย (Distributed Computing) ใน Deep Learning

การประมวลผลแบบกระจาย (Distributed Computing) ใน Deep Learning เป็นการใช้คอมพิวเตอร์หลายเครื่องในการประมวลผลโมเดล Neural Network เพื่อเพิ่มประสิทธิภาพการเรียนรู้และการทำนายผลของโมเดล โดยที่แต่ละเครื่องจะเรียนรู้แยกกันและส่งผลลัพธ์กลับมายังเครื่องหลัก เพื่อทำการรวมผลลัพธ์เพื่อสรุปผลลัพธ์ที่ถูกต้อง

การประมวลผลแบบกระจายใน Deep Learning มีหลายวิธีการทำ เช่นการใช้ Framework ที่มีการจัดการ Distributed Computing อยู่แล้ว เช่น TensorFlow, PyTorch หรือ Apache Spark และ Hadoop ที่มีความสามารถในการจัดการข้อมูลแบบ Distributed Computing

การประมวลผลแบบกระจายมีข้อดีอย่างมาก อาทิเช่น

• ลดเวลาในการเรียนรู้และประมวลผลโมเดล Neural Network
• สามารถปรับขนาดของระบบได้อย่างยืดหยุ่น
• ช่วยลดต้นทุนในการซื้อฮาร์ดแวร์ใหม่ๆ
• สามารถจัดการข้อมูลขนาดใหญ่ได้ง่ายขึ้น

การประมวลผลแบบกระจายใน Deep Learning ยังเป็นกระบวนการที่ยังคงพัฒนาต่อเนื่อง โดยมีการวิจัยและพัฒนาระบบที่มีประสิทธิภาพสูงขึ้นเรื่อยๆ ซึ่งจะช่วยเพิ่มประสิทธิภาพการทำงานและความแม่นยำของโมเดล Neural Network ในการประมวลผลข้อมูลในอนาคตอย่างมีประสิทธิภาพ

การประมวลผลแบบกระจาย (Distributed Computing) ใน Deep Learning เป็นการแบ่งงานการคำนวณของโมเดล Deep Learning ออกเป็นหลายๆ ชิ้นเพื่อที่จะประมวลผลพร้อมกันในหลายๆ เครื่อง โดยใช้แต่ละเครื่องเป็น worker ซึ่งเป็นรูปแบบหนึ่งของ Parallel Computing ที่ช่วยลดเวลาในการคำนวณและเพิ่มประสิทธิภาพในการฝึกโมเดล Deep Learning ได้มากขึ้น

ตัวอย่าง การประมวลผลแบบกระจายใน Deep Learning ด้วย TensorFlow 2.0 สามารถเขียนได้ดังนี้

import tensorflow as tf
from tensorflow import keras
import numpy as np

# กำหนด IP address และ port ของแต่ละ worker
worker_hosts = ['10.0.0.1:2222', '10.0.0.2:2222']

# กำหนด IP address และ port ของเครื่องหลัก (master)
task_index = 0
job_name = 'worker'
master_host = '10.0.0.3:2222'

# กำหนด TensorFlow Cluster
cluster_spec = tf.train.ClusterSpec({'worker': worker_hosts, 'master': [master_host]})

# กำหนดตัวแปรรับค่าจาก Command Line
tf.app.flags.DEFINE_integer('task_index', 0, 'Index of task within the job.')
FLAGS = tf.app.flags.FLAGS
tf.logging.set_verbosity(tf.logging.INFO)

# กำหนดตัวแปร Input
input_shape = (28, 28, 1)
num_classes = 10

# โหลดข้อมูล
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = np.expand_dims(x_train, -1)
x_test = np.expand_dims(x_test, -1)
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

# กำหนด Model
inputs = keras.Input(shape=input_shape)
x = keras.layers.Conv2D(32, kernel_size=(3, 3), activation='relu')(inputs)
x = keras.layers.MaxPooling2D(pool_size=(2, 2))(x)
x = keras.layers.Conv2D(64, kernel_size=(3, 3), activation='relu')(x)
x = keras.layers.MaxPooling2D(pool_size=(2, 2))(x)
x = keras.layers.Flatten()(x)
x = keras.layers.Dropout(0.5)(x)

outputs = keras.layers.Dense(num_classes, activation='softmax')(x)
model = keras.Model(inputs=inputs, outputs=outputs)

# กำหนด Hyperparameters
batch_size = 128
epochs = 5

# กำหนดตัวแปร optimizer และ loss function
optimizer = keras.optimizers.Adam()
loss_fn = keras.losses.CategoricalCrossentropy()

# กำหนด Distributed Training Strategy
strategy = tf.distribute.experimental.MultiWorkerMirroredStrategy()

# กำหนดการ Compile Model
with strategy.scope():
    model.compile(optimizer=optimizer, loss=loss_fn, metrics=['accuracy'])

# กำหนด Callbacks
callbacks = [tf.keras.callbacks.TensorBoard(log_dir='./logs')]

# สร้าง input pipeline สำหรับการทำ distributed training
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)).shuffle(10000).batch(batch_size)
train_dataset = strategy.experimental_distribute_dataset(train_dataset)

# ทำ Distributed Training
with strategy.scope():

# สร้าง instance ของ tf.keras.callbacks.TensorBoard สำหรับ logging
callbacks = [tf.keras.callbacks.TensorBoard(log_dir='./logs')]

# ทำการ train โดยใช้ fit method
history = model.fit(train_dataset, epochs=epochs, callbacks=callbacks)

# คำนวณค่า accuracy ของโมเดลบนข้อมูล test
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(batch_size)
test_dataset = strategy.experimental_distribute_dataset(test_dataset)

with strategy.scope():
results = model.evaluate(test_dataset)

print("test loss, test acc:", results)

จากตัวอย่าง โค้ดนี้สามารถทำงานได้เมื่อต้องติดตั้ง TensorFlow 2.x และ Python 3.x ซึ่งเป็นการประมวลผลแบบกระจาย (Distributed Computing) ในการทำ Deep Learning โดยใช้ TensorFlow 2.0 และ MultiWorkerMirroredStrategy ในการแบ่งการทำงานของโมเดล (Model) ไปยังหลายๆ เครื่องพร้อมกันเพื่อเพิ่มความเร็วในการ train และคำนวณผลลัพธ์

การใช้ TensorFlow 2.x ในการทำ Distributed Training โดยใช้ MultiWorkerMirroredStrategy สำหรับการทำ parallelization ของโมเดลบนหลายๆ worker โดยมี worker ทั้งหมด 2 เครื่อง และมีเครื่องหลัก (master) 1 เครื่อง

การสร้าง Model ของ Neural Network และการเตรียมข้อมูลสำหรับการ train และ test โดยใช้ชุดข้อมูล MNIST ที่เป็นตัวเลขแต่ละตัวมีขนาด 28×28 พิกเซล และมีจำนวน class อยู่ 10 ตัว

การทำงานของโค้ดนี้จะมีการโหลดข้อมูล MNIST และสร้างโมเดล CNN สำหรับการจำแนกตัวเลข จากนั้นกำหนด Hyperparameters ต่างๆ เช่น batch size, epochs, optimizer และ loss function

แต่เนื่องจากการทำ Distributed Training ทำงานบนหลาย worker จึงต้องใช้ Distributed Training Strategy เพื่อจัดการการ parallelization ในการ train โมเดล ในที่นี้ใช้ MultiWorkerMirroredStrategy ซึ่งจะทำ parallelization โดยใช้แบบ mirrored strategy โดยแต่ละ worker จะมีโมเดลเทียบเท่ากันและแชร์ค่า gradients กันเพื่อทำ parallel training ในการใช้ MultiWorkerMirroredStrategy ในการแบ่งการทำงานของโมเดล (Model) ไปยังหลายๆ เครื่องพร้อมกัน ทำให้การทำงานมีความเร็วสูงขึ้น และสามารถทำงานได้ทุกๆ เครื่องพร้อมกันโดยไม่ต้องใช้เวลานานในการ train ได้แบ่ง dataset ออกเป็น batch_size และ epochs ต่างๆ เพื่อให้สามารถ train โมเดลได้อย่างเหมาะสม รวมไปถึงการกำหนด hyperparameters เช่น optimizer และ loss function ในการ compile โมเดล

ส่วนของโค้ดที่เกี่ยวข้องกับ Distributed Training จะอยู่ในบล็อก with strategy.scope(): ซึ่งจะใช้สร้าง instance ของโมเดลและ compile โมเดลด้วย optimizer และ loss function และทำ Distributed Training โดยใช้ fit method และใช้ evaluate method เพื่อคำนวณค่า accuracy ของโมเดลบนข้อมูล test

ส่วนของ callbacks จะใช้ TensorBoard สำหรับการ logging ผลการ train และ test ของโมเดล

สุดท้ายคือการ train และ test โมเดล โดยการใช้ fit method และ evaluate method จากตัวแปร model ที่ได้รับการ compile แล้ว ทำให้สามารถวัดความแม่นยำของโมเดลได้อย่างถูกต้องและสามารถนำไปใช้งานได้อย่างเหมาะสม ผลลัพธ์ที่แสดงจากโปรแกรมจะเป็น test loss และ test accuracy ของโมเดลบนข้อมูล test