translate comments to Eng

Author: junseokShim

tensorflow/lite/micro/kernels/one_hot.cc

@@ -30,21 +30,22 @@ constexpr int kOnValueTensor = 2;
 constexpr int kOffValueTensor = 3;
 constexpr int kOutputTensor = 0;
 
-namespace {  // 로컬 유틸 함수들
+namespace {  // Local Util functions
 inline int NumElements(const TfLiteEvalTensor* t) {
   int count = 1;
-  // TfLiteEvalTensor의 dims는 TfLiteIntArray* 타입입니다.
   for (int i = 0; i < t->dims->size; ++i) {
     count *= t->dims->data[i];
   }
   return count;
 }
 }  // namespace
 
-// TfLiteNode에서 입력 (indices, depth, on_value, off_value) 및 출력 텐서
-// (output) 를 가져옴 params->axis 를 읽어 실제로 Depth 차원이 들어갈 위치
-// (Axis) 계산 Prepare과 Eval 함수 내에서 잠시 생성되었다가 사라짐 → Stack
-// memory 사용 효율적
+// Retrieves the input tensors (indices, depth, on_value, off_value) and the
+// output tensor (output) from the TfLiteNode.
+// Reads params->axis to compute the actual position (axis) where the depth
+// dimension will be inserted.
+// These values are created temporarily within the Prepare and Eval functions
+// and are destroyed afterward → efficient use of stack memory.
 struct OneHotContext {
   OneHotContext(TfLiteContext* context, TfLiteNode* node) {
     indices = tflite::micro::GetEvalInput(context, node, kIndicesTensor);
@@ -62,7 +63,7 @@ struct OneHotContext {
   }
 
   const TfLiteEvalTensor* indices;
-  const TfLiteEvalTensor* depth;  // 새로 생기는 One-hot 차원 크기
+  const TfLiteEvalTensor* depth;
   const TfLiteEvalTensor* on_value;
   const TfLiteEvalTensor* off_value;
   TfLiteEvalTensor* output;
@@ -72,8 +73,7 @@ struct OneHotContext {
   TfLiteType dtype;
 };
 
-// 실제 연산 수행 함수
-//
+// Operation function
 template <typename T, typename TI>
 void OneHotComputeImpl(const OneHotContext& op_context) {
   int prefix_dim_size = 1;
@@ -121,20 +121,17 @@ TfLiteStatus ResizeOutputTensor(TfLiteContext* context,
                                 const OneHotContext& op_context) {
   TF_LITE_ENSURE(context, *op_context.depth->data.i32 >= 0);
 
-  // depth 데이터 읽기
+  // read depth data
   const int depth_val =
       *tflite::micro::GetTensorData<int32_t>(op_context.depth);
   TF_LITE_ENSURE(context, depth_val >= 0);
 
-  // Output Tensor 검증
+  // Output Tensor evaluation
   TF_LITE_ENSURE(context, op_context.output != nullptr);
 
   TF_LITE_ENSURE(context, op_context.output->dims != nullptr);
 
-  // todo
-  // TFLM에서는 Output Tensor의 dims가 이미 할당되어 있다고 가정합니다.
-  // 하지만 모델이 생성될 때 계산된 dims와 현재 depth값으로 계산한 dims가
-  // 일치하는지 확인은 필요합니다.
+  // TFLM assumes that the output tensor’s dims are already allocated
   const int expected_dims_size = op_context.output_dims;
   TF_LITE_ENSURE_EQ(context, op_context.output->dims->size, expected_dims_size);
 
@@ -148,8 +145,8 @@ TfLiteStatus ResizeOutputTensor(TfLiteContext* context,
       expected_dim_i = op_context.indices->dims->data[i - 1];
     }
 
-    // TFLM 컴파일러(Offline Memory Planner)가 할당해둔 크기와 실제 계산 크기가
-    // 다르면 에러
+    // If the size pre-allocated by the TFLM compiler (Offline Memory Planner)
+    // does not match the actual computed size, an error is raised.
     TF_LITE_ENSURE_EQ(context, op_context.output->dims->data[i],
                       expected_dim_i);
   }
@@ -191,8 +188,8 @@ TfLiteStatus Prepare(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_TYPES_EQ(context, op_context.off_value->type,
                           op_context.dtype);
 
-  // depth 텐서가 상수가 아니더라도, 테스트에서는 output shape를
-  // 미리 지정해 두었으므로 여기서는 그냥 검증만 수행
+  // Even if the depth tensor is not a constant, the test predefines the output
+  // shape, so here we only perform validation.
   return ResizeOutputTensor(context, op_context);
 }
 
@@ -227,7 +224,7 @@ TfLiteStatus Eval(TfLiteContext* context, TfLiteNode* node) {
 
 }  // namespace one_hot
 
-// 헤더에 선언된 Register_ONE_HOT 구현
+// Implementation of Register_ONE_HOT declared in the header
 const TFLMRegistration* Register_ONE_HOT() {
   static TFLMRegistration r = {};
 

tensorflow/lite/micro/kernels/one_hot.h

@@ -8,7 +8,7 @@ namespace tflite {
 namespace ops {
 namespace micro {
 
-// ONE_HOT 커널 등록 함수 (all_ops_resolver 등에서 사용)
+// ONE_HOT Kernel regist function (use at all_ops_resolver)
 const TFLMRegistration* Register_ONE_HOT();
 
 }  // namespace micro

tensorflow/lite/micro/one_hot_test.cc

@@ -17,14 +17,14 @@ namespace tflite {
 namespace testing {
 namespace {
 
-// OneHot 연산 테스트를 위한 헬퍼 함수
+// Helper function for OneHot operation test
 template <typename T>
 void TestOneHot(const int* indices_dims, const int32_t* indices_data,
                 const int* depth_dims, const int32_t* depth_data,
                 const int* on_dims, const T* on_data, const int* off_dims,
                 const T* off_data, const int* output_dims,
                 const T* expected_output_data, T* output_data, int axis = -1) {
-  // 1. 텐서 설정
+  // 1. Tensor Setting
   TfLiteIntArray* in_dims = IntArrayFromInts(indices_dims);
   TfLiteIntArray* d_dims = IntArrayFromInts(depth_dims);
   TfLiteIntArray* on_val_dims = IntArrayFromInts(on_dims);
@@ -33,26 +33,25 @@ void TestOneHot(const int* indices_dims, const int32_t* indices_data,
 
   const int output_dims_count = ElementCount(*out_dims);
 
-  // 2. 입력 텐서 생성
+  // 2. Create Input Tensor
   constexpr int inputs_size = 4;
   constexpr int outputs_size = 1;
   constexpr int tensors_size = inputs_size + outputs_size;
   TfLiteTensor tensors[tensors_size] = {
       CreateTensor(indices_data, in_dims), CreateTensor(depth_data, d_dims),
       CreateTensor(on_data, on_val_dims),  CreateTensor(off_data, off_val_dims),
-      CreateTensor(output_data, out_dims),  // 출력 텐서 (데이터는 비워둠)
+      CreateTensor(output_data, out_dims),  // Output Tensor
   };
 
-  // 3. 파라미터 설정
+  // 3. Parameter setting
   TfLiteOneHotParams builtin_data = {axis};
 
-  // 4. KernelRunner 실행
+  // 4. KernelRunner execution
   int inputs_array_data[] = {4, 0, 1, 2, 3};  // indices, depth, on, off
   TfLiteIntArray* inputs_array = IntArrayFromInts(inputs_array_data);
   int outputs_array_data[] = {1, 4};  // output tensor index
   TfLiteIntArray* outputs_array = IntArrayFromInts(outputs_array_data);
 
-  // 등록 함수 이름은 구현하신 이름으로 변경 (예:
   // tflite::ops::micro::Register_ONE_HOT)
   const TFLMRegistration registration = *tflite::ops::micro::Register_ONE_HOT();
   micro::KernelRunner runner(registration, tensors, tensors_size, inputs_array,
@@ -62,7 +61,7 @@ void TestOneHot(const int* indices_dims, const int32_t* indices_data,
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.InitAndPrepare());
   TF_LITE_MICRO_EXPECT_EQ(kTfLiteOk, runner.Invoke());
 
-  // 5. 결과 검증
+  // 5. Result evaluation
   for (int i = 0; i < output_dims_count; ++i) {
     TF_LITE_MICRO_EXPECT_EQ(expected_output_data[i], output_data[i]);
   }
@@ -93,7 +92,7 @@ TF_LITE_MICRO_TEST(OneHot_BasicInt32) {
   const int output_dims[] = {2, 3, 3};
   const int32_t expected_output[] = {1, 0, 0, 0, 1, 0, 0, 0, 1};
 
-  int32_t output_data[9];  // 결과 받을 버퍼
+  int32_t output_data[9];
 
   tflite::testing::TestOneHot(indices_dims, indices_data, depth_dims,
                               depth_data, on_dims, on_data, off_dims, off_data,