{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "FhGuhbZ6M5tl" }, "source": [ "##### Copyright 2022 The TensorFlow Authors." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "cellView": "form", "execution": { "iopub.execute_input": "2022-12-14T21:44:40.260864Z", "iopub.status.busy": "2022-12-14T21:44:40.260648Z", "iopub.status.idle": "2022-12-14T21:44:40.264300Z", "shell.execute_reply": "2022-12-14T21:44:40.263790Z" }, "id": "AwOEIRJC6Une" }, "outputs": [], "source": [ "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n", "# you may not use this file except in compliance with the License.\n", "# You may obtain a copy of the License at\n", "#\n", "# https://www.apache.org/licenses/LICENSE-2.0\n", "#\n", "# Unless required by applicable law or agreed to in writing, software\n", "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", "# See the License for the specific language governing permissions and\n", "# limitations under the License." ] }, { "cell_type": "markdown", "metadata": { "id": "EIdT9iu_Z4Rb" }, "source": [ "# Core API 및 DTensor를 사용하는 분산 훈련" ] }, { "cell_type": "markdown", "metadata": { "id": "bBIlTPscrIT9" }, "source": [ "\n", " \n", " \n", " \n", " \n", "
TensorFlow.org에서 보기\n", " Google Colab에서 실행하기\n", "GitHub에서 소스 보기노트북 다운로드하기
" ] }, { "cell_type": "markdown", "metadata": { "id": "SjAxxRpBzVYg" }, "source": [ "## 소개\n", "\n", "이 노트북은 [TensorFlow Core 하위 수준 API](https://www.tensorflow.org/guide/core) 및 [DTensor](https://www.tensorflow.org/guide/dtensor_overview)를 사용하는 데이터 병렬 분산 훈련 예제를 보여줍니다. TensorFlow Core 및 기본 사용 사례에 대해 자세히 알아보려면 [Core API 개요](https://www.tensorflow.org/guide/core)를 확인하세요. DTensor에 대한 자세한 내용은 [DTensor 개요](https://www.tensorflow.org/guide/dtensor_overview) 가이드와 [DTensor를 사용하는 분산 훈련](https://www.tensorflow.org/tutorials/distribute/dtensor_ml_tutorial) 가이드를 참고하세요.\n", "\n", "이 예제에서는 [멀티 레이어 퍼셉트론](https://www.tensorflow.org/guide/core/mlp_core) 가이드와 동일한 모델 및 최적화 도구를 사용합니다. Core API를 사용하는 엔드 투 엔드 머신러닝 워크플로를 작성하는 데 익숙해지려면 먼저 이 튜토리얼을 참고하세요.\n", "\n", "참고: DTensor는 아직 실험적인 TensorFlow API입니다. 즉, 테스트에서 해당 기능을 사용할 수 있습니다. 사실 테스트 환경에서만 사용할 수 있습니다." ] }, { "cell_type": "markdown", "metadata": { "id": "d_OFkG0dyWCp" }, "source": [ "## DTensor를 사용하는 데이터 병렬 훈련 개요\n", "\n", "분산 기능을 지원하는 MLP를 빌드하기 전에 잠시 시간을 내어 데이터 병렬 훈련용 DTensor의 기본 사항을 살펴보도록 합니다.\n", "\n", "DTensor를 사용하여 장치 전반에서 분산 훈련을 실행하고 효율성과 안정성, 그리고 확장성을 개선할 수 있습니다. DTensor는 SPMD(Single program, multiple data) 확장이라는 절차와 샤딩 지시문에 따라 프로그램과 텐서를 배포합니다. `DTensor` 인식 레이어의 변수는 `dtensor.DVariable`로 생성되고, `DTensor` 인식 레이어 객체의 생성자는 일반적인 레이어 매개변수에 `Layout` 입력을 추가적으로 더합니다.\n", "\n", "데이터 병렬 훈련의 주요 개념은 다음과 같습니다.\n", "\n", "- 모델 변수는 각각 N개의 장치에 복제됩니다.\n", "- 전역 배치는 복제본당 N개의 배치로 분할됩니다.\n", "- 각 복제본의 배치는 복제본 장치에서 훈련됩니다.\n", "- 모든 복제본에서 데이터 가중치 부여가 일괄적으로 수행되기 전에 그래디언트가 감소합니다.\n", "- 데이터 병렬 훈련은 장치 수와 거의 비례하는 선형 속도를 제공합니다." ] }, { "cell_type": "markdown", "metadata": { "id": "nchsZfwEVtVs" }, "source": [ "## 설치하기\n", "\n", "DTensor는 TensorFlow 2.9.0 릴리스에 포함된 항목입니다." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:40.268159Z", "iopub.status.busy": "2022-12-14T21:44:40.267721Z", "iopub.status.idle": "2022-12-14T21:44:40.270487Z", "shell.execute_reply": "2022-12-14T21:44:40.269952Z" }, "id": "latuqlI_Yvoo" }, "outputs": [], "source": [ "#!pip install --quiet --upgrade --pre tensorflow" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:40.273409Z", "iopub.status.busy": "2022-12-14T21:44:40.272993Z", "iopub.status.idle": "2022-12-14T21:44:40.688670Z", "shell.execute_reply": "2022-12-14T21:44:40.687951Z" }, "id": "1rRo8oNqZ-Rj" }, "outputs": [], "source": [ "import matplotlib\n", "from matplotlib import pyplot as plt\n", "# Preset Matplotlib figure sizes.\n", "matplotlib.rcParams['figure.figsize'] = [9, 6]" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:40.692942Z", "iopub.status.busy": "2022-12-14T21:44:40.692288Z", "iopub.status.idle": "2022-12-14T21:44:42.877645Z", "shell.execute_reply": "2022-12-14T21:44:42.876992Z" }, "id": "9xQKvCJ85kCQ" }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2022-12-14 21:44:41.543863: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer.so.7'; dlerror: libnvinfer.so.7: cannot open shared object file: No such file or directory\n", "2022-12-14 21:44:41.543964: W tensorflow/compiler/xla/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libnvinfer_plugin.so.7'; dlerror: libnvinfer_plugin.so.7: cannot open shared object file: No such file or directory\n", "2022-12-14 21:44:41.543973: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Cannot dlopen some TensorRT libraries. If you would like to use Nvidia GPU with TensorRT, please make sure the missing libraries mentioned above are installed properly.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "2.11.0\n" ] } ], "source": [ "import tensorflow as tf\n", "import tensorflow_datasets as tfds\n", "from tensorflow.experimental import dtensor\n", "print(tf.__version__)\n", "# Set random seed for reproducible results \n", "tf.random.set_seed(22)" ] }, { "cell_type": "markdown", "metadata": { "id": "vDH9-sy4sfPf" }, "source": [ "이 실험을 위해 8개의 가상 CPU를 구성합니다. DTensor는 GPU 또는 TPU 장치와 함께 사용할 수도 있습니다. 이 노트북에서는 가상 장치를 사용하기 때문에 분산 훈련으로 인한 속도 향상은 눈에 띄지 않습니다. " ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:42.881452Z", "iopub.status.busy": "2022-12-14T21:44:42.881038Z", "iopub.status.idle": "2022-12-14T21:44:45.869777Z", "shell.execute_reply": "2022-12-14T21:44:45.869138Z" }, "id": "H2iM-6J4s2D6" }, "outputs": [ { "data": { "text/plain": [ "['/device:CPU:0',\n", " '/device:CPU:1',\n", " '/device:CPU:2',\n", " '/device:CPU:3',\n", " '/device:CPU:4',\n", " '/device:CPU:5',\n", " '/device:CPU:6',\n", " '/device:CPU:7']" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def configure_virtual_cpus(ncpu):\n", " phy_devices = tf.config.list_physical_devices('CPU')\n", " tf.config.set_logical_device_configuration(phy_devices[0], [\n", " tf.config.LogicalDeviceConfiguration(),\n", " ] * ncpu)\n", "\n", "configure_virtual_cpus(8)\n", "\n", "DEVICES = [f'CPU:{i}' for i in range(8)]\n", "devices = tf.config.list_logical_devices('CPU')\n", "device_names = [d.name for d in devices]\n", "device_names" ] }, { "cell_type": "markdown", "metadata": { "id": "F_72b0LCNbjx" }, "source": [ "## MNIST 데이터세트\n", "\n", "[TensorFlow 데이터세트](https://www.tensorflow.org/datasets/catalog/mnist)의 데이터세트를 사용할 수 있습니다. 데이터는 훈련 세트와 테스트 세트로 나눕니다. 시간을 절약하기 위해 훈련과 테스트에 5000개의 예제만 사용합니다." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:45.873540Z", "iopub.status.busy": "2022-12-14T21:44:45.872808Z", "iopub.status.idle": "2022-12-14T21:44:46.878892Z", "shell.execute_reply": "2022-12-14T21:44:46.878205Z" }, "id": "8h4fV_JCfPIX" }, "outputs": [], "source": [ "train_data, test_data = tfds.load(\"mnist\", split=['train[:5000]', 'test[:5000]'], batch_size=128, as_supervised=True)" ] }, { "cell_type": "markdown", "metadata": { "id": "twkJ35YB6tSi" }, "source": [ "### 데이터 전처리하기\n", "\n", "데이터를 2차원으로 변형하고 단위 간격 [0,1]에 맞도록 크기를 다시 조정하여 데이터를 전처리합니다." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:46.882824Z", "iopub.status.busy": "2022-12-14T21:44:46.882545Z", "iopub.status.idle": "2022-12-14T21:44:46.928140Z", "shell.execute_reply": "2022-12-14T21:44:46.927530Z" }, "id": "6Cmjhg0xCqbz" }, "outputs": [], "source": [ "def preprocess(x, y):\n", " # Reshaping the data\n", " x = tf.reshape(x, shape=[-1, 784])\n", " # Rescaling the data\n", " x = x/255\n", " return x, y\n", "\n", "train_data, test_data = train_data.map(preprocess), test_data.map(preprocess)" ] }, { "cell_type": "markdown", "metadata": { "id": "6o3CrycBXA2s" }, "source": [ "## MLP 빌드하기\n", "\n", "DTensor 인식 레이어로 MLP 모델을 빌드합니다." ] }, { "cell_type": "markdown", "metadata": { "id": "OHW6Yvg2yS6H" }, "source": [ "### 밀집 레이어\n", "\n", "DTensor를 지원하는 밀집 레이어 모듈을 생성하는 것으로 시작합니다. `dtensor.call_with_layout` 함수는 DTensor 입력을 받고 DTensor 출력을 생성하는 함수를 호출하는 데 사용할 수 있습니다. 이것은 TensorFlow 지원 함수로 DTensor 변수 `dtensor.DVariable`을 초기화하는 데 유용합니다." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:46.931642Z", "iopub.status.busy": "2022-12-14T21:44:46.931413Z", "iopub.status.idle": "2022-12-14T21:44:46.937237Z", "shell.execute_reply": "2022-12-14T21:44:46.936600Z" }, "id": "IM0yJos25FG5" }, "outputs": [], "source": [ "class DenseLayer(tf.Module):\n", "\n", " def __init__(self, in_dim, out_dim, weight_layout, activation=tf.identity):\n", " super().__init__()\n", " # Initialize dimensions and the activation function\n", " self.in_dim, self.out_dim = in_dim, out_dim\n", " self.activation = activation\n", "\n", " # Initialize the DTensor weights using the Xavier scheme\n", " uniform_initializer = tf.function(tf.random.stateless_uniform)\n", " xavier_lim = tf.sqrt(6.)/tf.sqrt(tf.cast(self.in_dim + self.out_dim, tf.float32))\n", " self.w = dtensor.DVariable(\n", " dtensor.call_with_layout(\n", " uniform_initializer, weight_layout,\n", " shape=(self.in_dim, self.out_dim), seed=(22, 23),\n", " minval=-xavier_lim, maxval=xavier_lim))\n", " \n", " # Initialize the bias with the zeros\n", " bias_layout = weight_layout.delete([0])\n", " self.b = dtensor.DVariable(\n", " dtensor.call_with_layout(tf.zeros, bias_layout, shape=[out_dim]))\n", "\n", " def __call__(self, x):\n", " # Compute the forward pass\n", " z = tf.add(tf.matmul(x, self.w), self.b)\n", " return self.activation(z)" ] }, { "cell_type": "markdown", "metadata": { "id": "X-7MzpjgyHg6" }, "source": [ "### MLP 순차 모델\n", "\n", "이제 밀집 레이어를 순차적으로 실행하는 MLP 모듈을 생성합니다." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:46.940708Z", "iopub.status.busy": "2022-12-14T21:44:46.940228Z", "iopub.status.idle": "2022-12-14T21:44:46.943983Z", "shell.execute_reply": "2022-12-14T21:44:46.943413Z" }, "id": "6XisRWiCyHAb" }, "outputs": [], "source": [ "class MLP(tf.Module):\n", "\n", " def __init__(self, layers):\n", " self.layers = layers\n", " \n", " def __call__(self, x, preds=False): \n", " # Execute the model's layers sequentially\n", " for layer in self.layers:\n", " x = layer(x)\n", " return x" ] }, { "cell_type": "markdown", "metadata": { "id": "r5HZJ0kv-V3v" }, "source": [ "DTensor로 \"데이터 병렬\" 훈련을 수행하는 작업은 `tf.distribute.MirroredStrategy`와 동일합니다. 이를 위해 각 장치는 데이터 배치의 샤드에서 동일한 모델을 실행합니다. 따라서 다음이 필요합니다.\n", "\n", "- 단일 `\"batch\"` 차원의 `dtensor.Mesh`\n", "- 메시 전체에 가중치를 복제하는 모든 가중치용 `dtensor.Layout`(각 축에 `dtensor.UNSHARDED` 사용)\n", "- 메시에서 배치 차원을 분할하는 데이터용 `dtensor.Layout`\n", "\n", "단일 배치 차원으로 구성된 DTensor 메시를 생성합니다. 여기서 각 장치는 전역 배치에서 샤드를 수신하는 복제본이 됩니다. 이 메시를 사용하여 다음 아키텍처로 MLP 모드를 인스턴스화합니다.\n", "\n", "순방향 전달: ReLU(784 x 700) x ReLU(700 x 500) x Softmax(500 x 10)\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:46.947258Z", "iopub.status.busy": "2022-12-14T21:44:46.946790Z", "iopub.status.idle": "2022-12-14T21:44:47.180241Z", "shell.execute_reply": "2022-12-14T21:44:47.179472Z" }, "id": "VmlACuki3oPi" }, "outputs": [], "source": [ "mesh = dtensor.create_mesh([(\"batch\", 8)], devices=DEVICES)\n", "weight_layout = dtensor.Layout([dtensor.UNSHARDED, dtensor.UNSHARDED], mesh)\n", "\n", "input_size = 784\n", "hidden_layer_1_size = 700\n", "hidden_layer_2_size = 500\n", "hidden_layer_2_size = 10\n", "\n", "mlp_model = MLP([\n", " DenseLayer(in_dim=input_size, out_dim=hidden_layer_1_size, \n", " weight_layout=weight_layout,\n", " activation=tf.nn.relu),\n", " DenseLayer(in_dim=hidden_layer_1_size , out_dim=hidden_layer_2_size,\n", " weight_layout=weight_layout,\n", " activation=tf.nn.relu),\n", " DenseLayer(in_dim=hidden_layer_2_size, out_dim=hidden_layer_2_size, \n", " weight_layout=weight_layout)])" ] }, { "cell_type": "markdown", "metadata": { "id": "tyBATDoRmDkg" }, "source": [ "### 훈련 메트릭\n", "\n", "훈련에 교차 엔트로피 손실 함수와 정확성 메트릭을 사용합니다." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:47.184641Z", "iopub.status.busy": "2022-12-14T21:44:47.184016Z", "iopub.status.idle": "2022-12-14T21:44:47.188702Z", "shell.execute_reply": "2022-12-14T21:44:47.187924Z" }, "id": "rskOYA7FVCwg" }, "outputs": [], "source": [ "def cross_entropy_loss(y_pred, y):\n", " # Compute cross entropy loss with a sparse operation\n", " sparse_ce = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=y_pred)\n", " return tf.reduce_mean(sparse_ce)\n", "\n", "def accuracy(y_pred, y):\n", " # Compute accuracy after extracting class predictions\n", " class_preds = tf.argmax(y_pred, axis=1)\n", " is_equal = tf.equal(y, class_preds)\n", " return tf.reduce_mean(tf.cast(is_equal, tf.float32))" ] }, { "cell_type": "markdown", "metadata": { "id": "JSiNRhTOnKZr" }, "source": [ "### 옵티마이저\n", "\n", "옵티마이저를 사용하면 표준 경사 하강법에 비해 훨씬 더 빠른 수렴 결과를 얻을 수 있습니다. Adam 옵티마이저가 아래에 구현되어 있으며DTensor와 호환되도록 구성되어 있습니다. Keras 옵티마이저를 DTensor와 함께 사용하려면 실험적 `tf.keras.dtensor.experimental.optimizers` 모듈을 참고합니다." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:47.191996Z", "iopub.status.busy": "2022-12-14T21:44:47.191547Z", "iopub.status.idle": "2022-12-14T21:44:47.198393Z", "shell.execute_reply": "2022-12-14T21:44:47.197819Z" }, "id": "-9kIAI_lfXDS" }, "outputs": [], "source": [ "class Adam(tf.Module):\n", "\n", " def __init__(self, model_vars, learning_rate=1e-3, beta_1=0.9, beta_2=0.999, ep=1e-7):\n", " # Initialize optimizer parameters and variable slots\n", " self.model_vars = model_vars\n", " self.beta_1 = beta_1\n", " self.beta_2 = beta_2\n", " self.learning_rate = learning_rate\n", " self.ep = ep\n", " self.t = 1.\n", " self.v_dvar, self.s_dvar = [], []\n", " # Initialize optimizer variable slots\n", " for var in model_vars:\n", " v = dtensor.DVariable(dtensor.call_with_layout(tf.zeros, var.layout, shape=var.shape))\n", " s = dtensor.DVariable(dtensor.call_with_layout(tf.zeros, var.layout, shape=var.shape))\n", " self.v_dvar.append(v)\n", " self.s_dvar.append(s)\n", "\n", " def apply_gradients(self, grads):\n", " # Update the model variables given their gradients\n", " for i, (d_var, var) in enumerate(zip(grads, self.model_vars)):\n", " self.v_dvar[i].assign(self.beta_1*self.v_dvar[i] + (1-self.beta_1)*d_var)\n", " self.s_dvar[i].assign(self.beta_2*self.s_dvar[i] + (1-self.beta_2)*tf.square(d_var))\n", " v_dvar_bc = self.v_dvar[i]/(1-(self.beta_1**self.t))\n", " s_dvar_bc = self.s_dvar[i]/(1-(self.beta_2**self.t))\n", " var.assign_sub(self.learning_rate*(v_dvar_bc/(tf.sqrt(s_dvar_bc) + self.ep)))\n", " self.t += 1.\n", " return " ] }, { "cell_type": "markdown", "metadata": { "id": "w54b7GtLfn1j" }, "source": [ "### 데이터 패킹\n", "\n", "장치에 데이터를 전송하는 헬퍼 함수를 작성하는 것으로 시작합니다. 이 함수는 `dtensor.pack`을 사용하여 복제본을 지원하는 장치로 복제본을 대상으로 하는 전역 배치의 샤드를 보내야(전송만 해야 함) 합니다. 편리한 진행을 위해 단일 클라이언트 애플리케이션을 가정합니다.\n", "\n", "다음으로 이 헬퍼 함수를 사용하여 훈련 데이터 배치를 배치축(첫 번째)을 따라 샤딩한 DTensor로 패킹하는 함수를 작성합니다. 이렇게 하면 DTensor가 훈련 데이터를 '배치' 메시 차원에 고르게 분배합니다. DTensor에서 배치 크기는 항상 전역 배치 크기를 나타냅니다. 따라서 배치 크기는 배치 메시 차원의 크기로 균등하게 나눌 수 있도록 선택해야 합니다. `tf.data` 통합을 단순화하기 위한 추가 DTensor API가 계획되어 있으므로 계속 지켜봐 주시기 바랍니다." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:47.201647Z", "iopub.status.busy": "2022-12-14T21:44:47.201214Z", "iopub.status.idle": "2022-12-14T21:44:47.206798Z", "shell.execute_reply": "2022-12-14T21:44:47.206211Z" }, "id": "3Rx82djZ6ITm" }, "outputs": [], "source": [ "def repack_local_tensor(x, layout):\n", " # Repacks a local Tensor-like to a DTensor with layout\n", " # This function assumes a single-client application\n", " x = tf.convert_to_tensor(x)\n", " sharded_dims = []\n", "\n", " # For every sharded dimension, use tf.split to split the along the dimension.\n", " # The result is a nested list of split-tensors in queue[0].\n", " queue = [x]\n", " for axis, dim in enumerate(layout.sharding_specs):\n", " if dim == dtensor.UNSHARDED:\n", " continue\n", " num_splits = layout.shape[axis]\n", " queue = tf.nest.map_structure(lambda x: tf.split(x, num_splits, axis=axis), queue)\n", " sharded_dims.append(dim)\n", "\n", " # Now we can build the list of component tensors by looking up the location in\n", " # the nested list of split-tensors created in queue[0].\n", " components = []\n", " for locations in layout.mesh.local_device_locations():\n", " t = queue[0]\n", " for dim in sharded_dims:\n", " split_index = locations[dim] # Only valid on single-client mesh.\n", " t = t[split_index]\n", " components.append(t)\n", "\n", " return dtensor.pack(components, layout)\n", "\n", "def repack_batch(x, y, mesh):\n", " # Pack training data batches into DTensors along the batch axis\n", " x = repack_local_tensor(x, layout=dtensor.Layout(['batch', dtensor.UNSHARDED], mesh))\n", " y = repack_local_tensor(y, layout=dtensor.Layout(['batch'], mesh))\n", " return x, y" ] }, { "cell_type": "markdown", "metadata": { "id": "osEK3rqpYfKd" }, "source": [ "### 훈련하기\n", "\n", "데이터 배치를 제공할 경우 단일 훈련 단계를 실행하는 추적 가능한 함수를 작성합니다. 이 함수는 특별한 DTensor 주석을 요구하지 않습니다. 또한 테스트 단계를 실행하고 적절한 성능 메트릭을 반환하는 함수를 작성하도록 합니다." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:47.210204Z", "iopub.status.busy": "2022-12-14T21:44:47.209747Z", "iopub.status.idle": "2022-12-14T21:44:47.214438Z", "shell.execute_reply": "2022-12-14T21:44:47.213897Z" }, "id": "ZICEsDGuSbDD" }, "outputs": [], "source": [ "@tf.function\n", "def train_step(model, x_batch, y_batch, loss, metric, optimizer):\n", " # Execute a single training step\n", " with tf.GradientTape() as tape:\n", " y_pred = model(x_batch)\n", " batch_loss = loss(y_pred, y_batch)\n", " # Compute gradients and update the model's parameters\n", " grads = tape.gradient(batch_loss, model.trainable_variables)\n", " optimizer.apply_gradients(grads)\n", " # Return batch loss and accuracy\n", " batch_acc = metric(y_pred, y_batch)\n", " return batch_loss, batch_acc\n", "\n", "@tf.function\n", "def test_step(model, x_batch, y_batch, loss, metric):\n", " # Execute a single testing step\n", " y_pred = model(x_batch)\n", " batch_loss = loss(y_pred, y_batch)\n", " batch_acc = metric(y_pred, y_batch)\n", " return batch_loss, batch_acc" ] }, { "cell_type": "markdown", "metadata": { "id": "RjIDVTwwX-Mr" }, "source": [ "이제 배치 크기가 128인 3 epoch의 MLP 모델을 훈련합니다." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:47.217553Z", "iopub.status.busy": "2022-12-14T21:44:47.217026Z", "iopub.status.idle": "2022-12-14T21:44:51.063559Z", "shell.execute_reply": "2022-12-14T21:44:51.062595Z" }, "id": "oC85kuZgmh3q" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 0\n", "Training loss: 1.850, Training accuracy: 0.343\n", "Testing loss: 1.375, Testing accuracy: 0.504\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 1\n", "Training loss: 1.028, Training accuracy: 0.674\n", "Testing loss: 0.744, Testing accuracy: 0.782\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Epoch: 2\n", "Training loss: 0.578, Training accuracy: 0.839\n", "Testing loss: 0.486, Testing accuracy: 0.869\n" ] } ], "source": [ "# Initialize the training loop parameters and structures\n", "epochs = 3\n", "batch_size = 128\n", "train_losses, test_losses = [], []\n", "train_accs, test_accs = [], []\n", "optimizer = Adam(mlp_model.trainable_variables)\n", "\n", "# Format training loop\n", "for epoch in range(epochs):\n", " batch_losses_train, batch_accs_train = [], []\n", " batch_losses_test, batch_accs_test = [], []\n", "\n", " # Iterate through training data\n", " for x_batch, y_batch in train_data:\n", " x_batch, y_batch = repack_batch(x_batch, y_batch, mesh)\n", " batch_loss, batch_acc = train_step(mlp_model, x_batch, y_batch, cross_entropy_loss, accuracy, optimizer)\n", " # Keep track of batch-level training performance\n", " batch_losses_train.append(batch_loss)\n", " batch_accs_train.append(batch_acc)\n", "\n", " # Iterate through testing data\n", " for x_batch, y_batch in test_data:\n", " x_batch, y_batch = repack_batch(x_batch, y_batch, mesh)\n", " batch_loss, batch_acc = test_step(mlp_model, x_batch, y_batch, cross_entropy_loss, accuracy)\n", " # Keep track of batch-level testing\n", " batch_losses_test.append(batch_loss)\n", " batch_accs_test.append(batch_acc)\n", "\n", "# Keep track of epoch-level model performance\n", " train_loss, train_acc = tf.reduce_mean(batch_losses_train), tf.reduce_mean(batch_accs_train)\n", " test_loss, test_acc = tf.reduce_mean(batch_losses_test), tf.reduce_mean(batch_accs_test)\n", " train_losses.append(train_loss)\n", " train_accs.append(train_acc)\n", " test_losses.append(test_loss)\n", " test_accs.append(test_acc)\n", " print(f\"Epoch: {epoch}\")\n", " print(f\"Training loss: {train_loss.numpy():.3f}, Training accuracy: {train_acc.numpy():.3f}\")\n", " print(f\"Testing loss: {test_loss.numpy():.3f}, Testing accuracy: {test_acc.numpy():.3f}\")" ] }, { "cell_type": "markdown", "metadata": { "id": "j_RVmt43G12R" }, "source": [ "### 성능 평가\n", "\n", "먼저 훈련하는 동안 모델의 손실과 정확성을 시각화하는 플로팅 함수를 작성합니다. " ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:51.067506Z", "iopub.status.busy": "2022-12-14T21:44:51.066909Z", "iopub.status.idle": "2022-12-14T21:44:51.071739Z", "shell.execute_reply": "2022-12-14T21:44:51.070948Z" }, "id": "VXTCYVtNDjAM" }, "outputs": [], "source": [ "def plot_metrics(train_metric, test_metric, metric_type):\n", " # Visualize metrics vs training Epochs\n", " plt.figure()\n", " plt.plot(range(len(train_metric)), train_metric, label = f\"Training {metric_type}\")\n", " plt.plot(range(len(test_metric)), test_metric, label = f\"Testing {metric_type}\")\n", " plt.xlabel(\"Epochs\")\n", " plt.ylabel(metric_type)\n", " plt.legend()\n", " plt.title(f\"{metric_type} vs Training Epochs\");" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:51.074991Z", "iopub.status.busy": "2022-12-14T21:44:51.074503Z", "iopub.status.idle": "2022-12-14T21:44:51.281828Z", "shell.execute_reply": "2022-12-14T21:44:51.281011Z" }, "id": "407qok7q2JIO" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_metrics(train_losses, test_losses, \"Cross entropy loss\")" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2022-12-14T21:44:51.285328Z", "iopub.status.busy": "2022-12-14T21:44:51.284831Z", "iopub.status.idle": "2022-12-14T21:44:51.465450Z", "shell.execute_reply": "2022-12-14T21:44:51.464633Z" }, "id": "8H_TgxV92NfX" }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plot_metrics(train_accs, test_accs, \"Accuracy\")" ] }, { "cell_type": "markdown", "metadata": { "id": "DHO_u-3w4YRF" }, "source": [ "## 모델 저장하기\n", "\n", "`tf.saved_model`과 DTensor의 통합은 아직 개발을 진행하고 있습니다. TensorFlow 2.9.0부터 tf.saved_model은 완전히 복제된 변수가 있는 DTensor 모델만 허용합니다. 해결 방법으로 체크포인트를 다시 로드하여 DTensor 모델을 완전히 복제된 모델로 전환할 수 있습니다. 그러나 모델을 저장한 후에는 모든 DTensor 주석이 손실되며 저장된 서명은 일반 Tensor로만 사용할 수 있습니다. 안정화되면 통합을 보여주기 위해 이 튜토리얼이 업데이트됩니다.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "VFLfEH4ManbW" }, "source": [ "## 결론\n", "\n", "이 노트북에서는 DTensor 및 TensorFlow Core API를 사용하는 분산 훈련의 개요를 제공했습니다. 다음은 도움이 될 수 있는 몇 가지 추가 정보입니다.\n", "\n", "- 분산 훈련을 지원하고 고도로 구성 가능한 머신러닝 워크플로를 구축하는 데 [TensorFlow Core API](https://www.tensorflow.org/guide/core)를 사용할 수 있습니다.\n", "- [DTensor 개념](https://www.tensorflow.org/guide/dtensor_overview) 가이드 및 [DTensor를 사용하는 분산 훈련](https://www.tensorflow.org/tutorials/distribute/dtensor_ml_tutorial) 가이드에는 DTensor 및 통합에 대한 최신 정보가 포함되어 있습니다.\n", "\n", "TensorFlow Core API를 사용하는 더 많은 예제는 [가이드](https://www.tensorflow.org/guide/core)를 확인하세요. 데이터 로드 및 준비에 대해 자세히 알아보려면 [이미지 데이터 로드](https://www.tensorflow.org/tutorials/load_data/images) 또는 [CSV 데이터 로드](https://www.tensorflow.org/tutorials/load_data/csv) 튜토리얼을 참고하세요." ] } ], "metadata": { "colab": { "collapsed_sections": [ "FhGuhbZ6M5tl" ], "name": "distribution.ipynb", "toc_visible": true }, "kernelspec": { "display_name": "Python 3", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.16" } }, "nbformat": 4, "nbformat_minor": 0 }