'프로그램 사용/yolo_tensorflow_golo'에 해당되는 글 79건

  1. 2021.07.01 tensorflow cross compile
  2. 2021.06.30 tensorflow lite on rpi4 64bit
  3. 2021.06.30 tensorflow delegate
  4. 2021.06.25 tflite typed_tensor(), tensor()
  5. 2021.06.14 tflite yolov4
  6. 2021.06.10 tensorflow lite yolov4
  7. 2021.05.26 tensorflow lite interpreter->AllocateTensors()
  8. 2021.05.21 tflite common.h
  9. 2021.05.10 imx6q neon tensorlow lite
  10. 2021.05.01 tflite type

아따 빡세다 -_-

 

컴파일 하는데 libz.so.1이 없다고 하는데

아마도.. 64bit ubuntu라 32bit 용 libz가 없다고 배쨰는 듯

/home/minimonk/work/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/../libexec/gcc/arm-linux-gnueabihf/4.8.3/cc1plus: error while loading shared libraries: libz.so.1: cannot open shared object file: No such file or directory

$sudo apt-get install lib32z1

[링크 : https://damedame.tistory.com/entry/libzso1-파일을-찾을수-없을때]

 

std::is_trivially_copyable은 c++11 표준이라 gcc 5.x 이상부터 지원하기 때문이라고

In file included from /home/minimonk/work/tensorflow/tensorflow/lite/tools/make/downloads/ruy/ruy/frontend.h:30:0,
                 from /home/minimonk/work/tensorflow/tensorflow/lite/tools/make/downloads/ruy/ruy/ruy.h:23,
                 from ./tensorflow/lite/kernels/cpu_backend_gemm_ruy.h:21,
                 from ./tensorflow/lite/kernels/cpu_backend_gemm.h:25,
                 from ./tensorflow/lite/kernels/internal/optimized/optimized_ops.h:45,
                 from tensorflow/lite/kernels/audio_spectrogram.cc:24:
/home/minimonk/work/tensorflow/tensorflow/lite/tools/make/downloads/ruy/ruy/create_trmul_params.h: In function ‘void ruy::detail::FinalizeMulParams(const ruy::MulParams<AccumScalar, DstScalar>&, ruy::ChannelDimension, ruy::Ctx*, ruy::TrMulParams*)’:
/home/minimonk/work/tensorflow/tensorflow/lite/tools/make/downloads/ruy/ruy/create_trmul_params.h:388:17: error: ‘is_trivially_copyable’ is not a member of ‘std’
   static_assert(std::is_trivially_copyable<MulParamsType>::value, "");
                 ^
/home/minimonk/work/tensorflow/tensorflow/lite/tools/make/downloads/ruy/ruy/create_trmul_params.h:388:57: error: expected primary-expression before ‘>’ token
   static_assert(std::is_trivially_copyable<MulParamsType>::value, "");
                                                         ^
/home/minimonk/work/tensorflow/tensorflow/lite/tools/make/downloads/ruy/ruy/create_trmul_params.h:388:58: error: ‘::value’ has not been declared
   static_assert(std::is_trivially_copyable<MulParamsType>::value, "");
                                                          ^

[링크 : https://stackoverflow.com/questions/25123458/is-trivially-copyable-is-not-a-member-of-std]

 

예라이... -_-

$ arm-linux-gnueabihf-g++ --version
arm-linux-gnueabihf-g++ (crosstool-NG linaro-1.13.1-4.8-2014.01 - Linaro GCC 2013.11) 4.8.3 20140106 (prerelease)
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 

$ sudo apt-get install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf

[링크 : https://blog.thinkbee.kr/linux/crosscompile-arm/]

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tensorflow cross compile  (0) 2021.07.01
tensorflow lite on rpi4 64bit  (0) 2021.06.30
tensorflow delegate  (0) 2021.06.30
tflite typed_tensor(), tensor()  (0) 2021.06.25
tflite yolov4  (0) 2021.06.14
tensorflow lite yolov4  (0) 2021.06.10
Posted by 구차니

댓글을 달아 주세요

build_rpi_lib.sh를 통해 빌드 하려는데 에러 뿜뿜 -_-

그래서 makefile을 고쳐야 하나 멘붕이 와서 다시 찾아 보는데

/bin/bash: arm-linux-gnueabihf-g++: command not found

 

./tensorflow/lite/tools/make/build_aarch64_lib.sh

[링크 : https://www.tensorflow.org/lite/guide/build_arm64?hl=ko]

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tensorflow cross compile  (0) 2021.07.01
tensorflow lite on rpi4 64bit  (0) 2021.06.30
tensorflow delegate  (0) 2021.06.30
tflite typed_tensor(), tensor()  (0) 2021.06.25
tflite yolov4  (0) 2021.06.14
tensorflow lite yolov4  (0) 2021.06.10
Posted by 구차니

댓글을 달아 주세요

전에 찾아볼때 대리자 이런게 있길래 그냥 넘겼는데

그래프 실행의 "일부" 또는 "전체"를 다른 실행자에게 넘기는 방법

오.. 그러면 전체 연산중에 일부만을 넘길수 있다면.. delegate를 이용해 분산 처리도 가능할지도?

 

TensorFlow Lite 대리자는 그래프 실행의 일부 또는 전체를 다른 executor에 위임하는 방법입니다.

 

NPU도 지원이 가능하다는데

  • 최신 Android 기기용 NNAPI 대리자 - NNAPI 대리자를 사용하여 GPU, DSP 및/또는 NPU를 사용할 수 있는 Android 기기에서 모델을 가속화할 수 있습니다. Android 8.1(API 27+) 이상에서 사용할 수 있습니다. NNAPI 대리자 개요, 단계별 지침 및 모범 사례는 TensorFlow Lite NNAPI 대리자를 참조하세요.

[링크 : https://www.tensorflow.org/lite/performance/delegates?hl=ko]

 

cpp 로는 안되나.. android 8.1 이상 기기에서 쓸 수 있다고만 나오네

Android Neural Networks API(NNAPI)는 Android 8.1(API 레벨 27) 이상을 실행하는 모든 Android 기기에서 사용할 수 있습니다. 다음과 같은 하드웨어 가속기를 지원하는 Android 기기의 TensorFlow Lite 모델을 속도를 향상합니다.
  • 그래픽 처리 장치(GPU)
  • 디지털 신호 프로세서(DSP)
  • 신경 처리 장치(NPU)

[링크 : https://www.tensorflow.org/lite/performance/nnapi?hl=ko]

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tensorflow cross compile  (0) 2021.07.01
tensorflow lite on rpi4 64bit  (0) 2021.06.30
tensorflow delegate  (0) 2021.06.30
tflite typed_tensor(), tensor()  (0) 2021.06.25
tflite yolov4  (0) 2021.06.14
tensorflow lite yolov4  (0) 2021.06.10
Posted by 구차니

댓글을 달아 주세요

정상적으로 작동하지 않아서 코드를 보는데, typed_tensor()라는 부분을 발견.

 

typed_tensor (int tensor_index)
T *
Perform a checked cast to the appropriate tensor type (mutable pointer version).

[링크 : https://www.tensorflow.org/lite/api_docs/cc/class/tflite/interpreter#classtflite_1_1_interpreter_1a314...]

 

tensor (int tensor_index)
TfLiteTensor *
Get a mutable tensor data structure.

[링크 : https://www.tensorflow.org/lite/api_docs/cc/class/tflite/interpreter#classtflite_1_1_interpreter_1ac1d...]

[링크 : https://www.tensorflow.org/lite/api_docs/cc/class/tflite/interpreter]

 

+

[링크 : https://github.com/tensorflow/tensorflow/.../tensorflow/lite/examples/label_image/label_image.cc]

[링크 : https://github.com/tensorflow/tensorflow/.../tensorflow/lite/examples/label_image/bitmap_helpers_impl.h]

 

+

2021.06.28

이거랑 상관없었음

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tensorflow lite on rpi4 64bit  (0) 2021.06.30
tensorflow delegate  (0) 2021.06.30
tflite typed_tensor(), tensor()  (0) 2021.06.25
tflite yolov4  (0) 2021.06.14
tensorflow lite yolov4  (0) 2021.06.10
tensorflow lite interpreter->AllocateTensors()  (0) 2021.05.26
Posted by 구차니

댓글을 달아 주세요

어우 언제 또 분석하냐 ㅠㅠ

 

[링크 : https://github.com/hunglc007/tensorflow-yolov4-tflite/blob/master/core/yolov4.py]

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tensorflow delegate  (0) 2021.06.30
tflite typed_tensor(), tensor()  (0) 2021.06.25
tflite yolov4  (0) 2021.06.14
tensorflow lite yolov4  (0) 2021.06.10
tensorflow lite interpreter->AllocateTensors()  (0) 2021.05.26
tflite common.h  (0) 2021.05.21
Posted by 구차니

댓글을 달아 주세요

output 텐서의 차원에 대한 정보는 세개 변수에 저장된다.

TfLiteType type;
TfLiteIntArray* dims;
size_t bytes;

 

type은 개별 엘리먼트의 출력 포맷(float라던가 uint8 이라던가)의 변수 크기를 저장하고

dims.size 에는 몇 차원 텐서인지

dims.data[] 에는 차원별 갯수를 저장한다.

dims.size = 4

dims.data[] = [1 7 7 18] 식으로 저장되며

float32형이기에

1*7*7*18*sizeof(float) = 3528 byte로

해당 내용은 bytes에 저장된다.

 

TfLitePtrUnion data;

그리고 그 용량의 데이터는 data에 저장되어 접근을 하면 되는데..

차원을 어떻게 접근해야 하려나.. -_-

 

대충 label_image.cc 예제에서 이런 식으로 출력하면 okay

    printf("dims size[%d]\n",output_dims->size);
    for(int idx = 0; idx < output_dims->size; idx++)
    {
            printf("%d\t",output_dims->data[idx]);
    }

    printf("tensor pos bytes [%d]\n",interpreter->tensor(interpreter->outputs()[0])->bytes);
    printf("tensor per bytes [%d]\n",interpreter->tensor(interpreter->outputs()[1])->bytes);

 

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tflite typed_tensor(), tensor()  (0) 2021.06.25
tflite yolov4  (0) 2021.06.14
tensorflow lite yolov4  (0) 2021.06.10
tensorflow lite interpreter->AllocateTensors()  (0) 2021.05.26
tflite common.h  (0) 2021.05.21
imx6q neon tensorlow lite  (0) 2021.05.10
Posted by 구차니

댓글을 달아 주세요

segmentation fault가 떠서 어디서 죽나 찾는데 꽤나 고생했네 -_-

(빌드가 느리면 역시 스트레스..)

 

그런데 도무지 allocateTensors() 라는 함수가 어떤 역활을 하는지 모르겠네..

한번 할당하고 또 할당하면 오류나는 느낌..

 

  // Allocate memory for the model's input `Tensor`s.
  try interpreter.allocateTensors()

[링크 : https://www.tensorflow.org/lite/guide/inference]

[링크 : https://www.tensorflow.org/lite/api_docs/cc/class/tflite/interpreter#allocatetensors]

 

여기 소스를 많이 참고했는데.. tensorflow의 label_image쪽이랑은 또 많이 달라서

어느 가이드를 따라가야 하나 고민..

[링크 : https://github.com/Qengineering/TensorFlow_Lite_SSD_RPi_64-bits/blob/master/MobileNetV1.cpp]

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tflite yolov4  (0) 2021.06.14
tensorflow lite yolov4  (0) 2021.06.10
tensorflow lite interpreter->AllocateTensors()  (0) 2021.05.26
tflite common.h  (0) 2021.05.21
imx6q neon tensorlow lite  (0) 2021.05.10
tflite type  (0) 2021.05.01
Posted by 구차니

댓글을 달아 주세요

label_image 예제를 보면 get_top_n 에서

(prediction[i] + 128) / 256.0 나 prediction[i] / 255.0 

같은 quantization 범위에 맞춘 무언가가 보이는데 

TfLiteQuantizationParams.scale 와 TfLiteQuantizationParams.zero_point을 이용하면 자동화 가능할 느낌.

template <class T>
void get_top_n(T* prediction, int prediction_size, size_t num_results,
               float threshold, std::vector<std::pair<float, int>>* top_results,
               TfLiteType input_type) {
  // Will contain top N results in ascending order.
  std::priority_queue<std::pair<float, int>, std::vector<std::pair<float, int>>,
                      std::greater<std::pair<float, int>>>
      top_result_pq;

  const long count = prediction_size;  // NOLINT(runtime/int)
  float value = 0.0;

  for (int i = 0; i < count; ++i) {
    switch (input_type) {
      case kTfLiteFloat32:
        value = prediction[i];
        break;
      case kTfLiteInt8:
        value = (prediction[i] + 128) / 256.0;
        break;
      case kTfLiteUInt8:
        value = prediction[i] / 255.0;
        break;
      default:
        break;
    }
    // Only add it if it beats the threshold and has a chance at being in
    // the top N.
    if (value < threshold) {
      continue;
    }

    top_result_pq.push(std::pair<float, int>(value, i));

    // If at capacity, kick the smallest value out.
    if (top_result_pq.size() > num_results) {
      top_result_pq.pop();
    }
  }

  // Copy to output vector and reverse into descending order.
  while (!top_result_pq.empty()) {
    top_results->push_back(top_result_pq.top());
    top_result_pq.pop();
  }
  std::reverse(top_results->begin(), top_results->end());
}

 

netron 에서 보면 quantization 범위가 나오는데, 어딘가 저장하고는 있는 듯 해서 검색 중

// SupportedQuantizationTypes.
typedef enum TfLiteQuantizationType {
  // No quantization.
  kTfLiteNoQuantization = 0,
  // Affine quantization (with support for per-channel quantization).
  // Corresponds to TfLiteAffineQuantization.
  kTfLiteAffineQuantization = 1,
} TfLiteQuantizationType;

// Structure specifying the quantization used by the tensor, if-any.
typedef struct TfLiteQuantization {
  // The type of quantization held by params.
  TfLiteQuantizationType type;
  // Holds a reference to one of the quantization param structures specified
  // below.
  void* params;
} TfLiteQuantization;

// Legacy. Will be deprecated in favor of TfLiteAffineQuantization.
// If per-layer quantization is specified this field will still be populated in
// addition to TfLiteAffineQuantization.
// Parameters for asymmetric quantization. Quantized values can be converted
// back to float using:
//     real_value = scale * (quantized_value - zero_point)
typedef struct TfLiteQuantizationParams {
  float scale;
  int32_t zero_point;
} TfLiteQuantizationParams;

// Parameters for asymmetric quantization across a dimension (i.e per output
// channel quantization).
// quantized_dimension specifies which dimension the scales and zero_points
// correspond to.
// For a particular value in quantized_dimension, quantized values can be
// converted back to float using:
//     real_value = scale * (quantized_value - zero_point)
typedef struct TfLiteAffineQuantization {
  TfLiteFloatArray* scale;
  TfLiteIntArray* zero_point;
  int32_t quantized_dimension;
} TfLiteAffineQuantization;

typedef struct TfLiteTensor {
  TfLiteType type;
  TfLitePtrUnion data;
  TfLiteIntArray* dims;
  TfLiteQuantizationParams params;
  TfLiteAllocationType allocation_type;
  size_t bytes;
  const void* allocation;
  const char* name;
  struct TfLiteDelegate* delegate;
  TfLiteBufferHandle buffer_handle;
  bool data_is_stale;
  bool is_variable;
  TfLiteQuantization quantization;
  TfLiteSparsity* sparsity;
  const TfLiteIntArray* dims_signature;
} TfLiteTensor;

 

+

2021.05.26

typedef struct TfLiteIntArray {
  int size;
// gcc 6.1+ have a bug where flexible members aren't properly handled
// https://github.com/google/re2/commit/b94b7cd42e9f02673cd748c1ac1d16db4052514c
#if (!defined(__clang__) && defined(__GNUC__) && __GNUC__ == 6 && \
     __GNUC_MINOR__ >= 1) ||                                      \
    defined(HEXAGON) || (__clang_major__ == 7 && __clang_minor__ == 1)
  int data[0];
#else
  int data[];
#endif
} TfLiteIntArray;

// Fixed size list of floats. Used for per-channel quantization.
typedef struct TfLiteFloatArray {
  int size;
// gcc 6.1+ have a bug where flexible members aren't properly handled
// https://github.com/google/re2/commit/b94b7cd42e9f02673cd748c1ac1d16db4052514c
// This also applies to the toolchain used for Qualcomm Hexagon DSPs.
#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ == 6 && \
    __GNUC_MINOR__ >= 1
  float data[0];
#else
  float data[];
#endif
} TfLiteFloatArray;

 

class Interpreter {
  /// Invoke the interpreter (run the whole graph in dependency order).
  ///
  /// NOTE: It is possible that the interpreter is not in a ready state
  /// to evaluate (i.e. if a ResizeTensor() has been performed without an
  /// AllocateTensors().
  /// Returns status of success or failure.
  TfLiteStatus Invoke();

  /// WARNING: Experimental interface, subject to change
  Subgraph& primary_subgraph() {
    return *subgraphs_.front();  /// Safe as subgraphs_ always has 1 entry.
  }
  
  /// Read only access to list of inputs.
  const std::vector<int>& inputs() const { return primary_subgraph().inputs(); }
  
  /// Read only access to list of outputs.
  const std::vector<int>& outputs() const {
    return primary_subgraph().outputs();
  }
  
  // Subgraphs
  std::vector<std::unique_ptr<Subgraph>> subgraphs_;
};

[링크 : https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/interpreter.h]

 

class Subgraph {
  // Array of indices representing the tensors that are inputs to the
  // interpreter.
  std::vector<int> inputs_;

  // Array of indices representing the tensors that are outputs to the
  // interpreter.
  std::vector<int> outputs_;
  
  // Read only access to list of inputs.
  std::vector<int>& inputs() { return inputs_; }

  // Read only access to list of inputs.
  const std::vector<int>& inputs() const { return inputs_; }

  // Read only access to list of outputs.
  std::vector<int>& outputs() { return outputs_; }

  // Read only access to list of outputs.
  const std::vector<int>& outputs() const { return outputs_; }
};

[링크 : https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/core/subgraph.h]

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tensorflow lite yolov4  (0) 2021.06.10
tensorflow lite interpreter->AllocateTensors()  (0) 2021.05.26
tflite common.h  (0) 2021.05.21
imx6q neon tensorlow lite  (0) 2021.05.10
tflite type  (0) 2021.05.01
tflite example  (0) 2021.04.19
Posted by 구차니

댓글을 달아 주세요

이번 빌드 옵션들을 뒤져보다 보니 빼먹고 안 넣은게 있었네

(라고 쓰고 실은 귀찮았던...)

 

-mvectorize-with-neon-quad -ffast-math

[링크 : http://stackoverflow.com/questions/14962447/gcc-options-for-a-freescale-imx6q-arm-processor]

 

 

In addition GCC offers the -ffast-math flag which is a shortcut for several options, presenting the least conforming but fastest math mode. It enables -fno-trapping-math, -funsafe-math-optimizations, -ffinite-math-only, -fno-errno-math, -fno-signaling-nans, -fno-rounding-math, -fcx-limited-range and -fno-signed-zeros. Each of these flags violates IEEE in a different way. 

[링크 : http://gcc.gnu.org/wiki/FloatingPointMath]

 

 

Cortex-A9 -mcpu=cortex-a9 -mfpu=vfpv3-fp16 -mfpu=vfpv3-d16-fp16 -mfpu=neon-fp16

[링크 : http://www.programmersought.com/article/5320739655/]

 

-DENABLE_VFPV3=ON ARM VFPv3 floating 

[링크 : http://www.google.com/amp/s/learnopencv.com/build-and-install-opencv-4-for-raspberry-pi/amp/]

 

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tensorflow lite interpreter->AllocateTensors()  (0) 2021.05.26
tflite common.h  (0) 2021.05.21
imx6q neon tensorlow lite  (0) 2021.05.10
tflite type  (0) 2021.05.01
tflite example  (0) 2021.04.19
tflite convert  (0) 2021.04.16
Posted by 구차니

댓글을 달아 주세요

 

변수 추적해보니 그게 그거인가?

  int output = interpreter->outputs()[0];
  TfLiteIntArray* output_dims = interpreter->tensor(output)->dims;
  // assume output dims to be something like (1, 1, ... ,size)
  auto output_size = output_dims->data[output_dims->size - 1];

 

    const float* detection_locations = interpreter->tensor(interpreter->outputs()[0])->data.f;
    const float* detection_classes=interpreter->tensor(interpreter->outputs()[1])->data.f;
    const float* detection_scores = interpreter->tensor(interpreter->outputs()[2])->data.f;
    const int    num_detections = *interpreter->tensor(interpreter->outputs()[3])->data.f;

    //there are ALWAYS 10 detections no matter how many objects are detectable
    //cout << "number of detections: " << num_detections << "\n";

    const float confidence_threshold = 0.5;
    for(int i = 0; i < num_detections; i++){
        if(detection_scores[i] > confidence_threshold){
            int  det_index = (int)detection_classes[i]+1;
            float y1=detection_locations[4*i  ]*cam_height;
            float x1=detection_locations[4*i+1]*cam_width;
            float y2=detection_locations[4*i+2]*cam_height;
            float x2=detection_locations[4*i+3]*cam_width;

            Rect rec((int)x1, (int)y1, (int)(x2 - x1), (int)(y2 - y1));
            rectangle(src,rec, Scalar(0, 0, 255), 1, 8, 0);
            putText(src, format("%s", Labels[det_index].c_str()), Point(x1, y1-5) ,FONT_HERSHEY_SIMPLEX,0.5, Scalar(0, 0, 255), 1, 8, 0);
        }
    }

 

 

typedef struct {
  int size;
#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ == 6 && \
    __GNUC_MINOR__ >= 1
  int data[0];
#else
  int data[];
#endif
} TfLiteIntArray;

typedef union {
  int* i32;
  int64_t* i64;
  float* f;
  char* raw;
  const char* raw_const;
  uint8_t* uint8;
  bool* b;
  int16_t* i16;
  TfLiteComplex64* c64;
  int8_t* int8;
} TfLitePtrUnion;

typedef struct {
  TfLiteType type;
  TfLitePtrUnion data;
  TfLiteIntArray* dims;
  TfLiteQuantizationParams params;
  TfLiteAllocationType allocation_type;
  size_t bytes;
  const void* allocation;
  const char* name;
  TfLiteDelegate* delegate;
  TfLiteBufferHandle buffer_handle;
  bool data_is_stale;
  bool is_variable;
  TfLiteQuantization quantization;
} TfLiteTensor;

[링크 : https://android.googlesource.com/platform/external/tensorflow/.../tensorflow/lite/c/c_api_internal.h]

 

현재 소스에서는 common.h 로 옮겨진듯

[링크 : https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/c/common.h]

'프로그램 사용 > yolo_tensorflow_golo' 카테고리의 다른 글

tflite common.h  (0) 2021.05.21
imx6q neon tensorlow lite  (0) 2021.05.10
tflite type  (0) 2021.05.01
tflite example  (0) 2021.04.19
tflite convert  (0) 2021.04.16
LSTM - Long short-term memory  (0) 2021.04.16
Posted by 구차니

댓글을 달아 주세요