满守园

Caffe：blob.hpp

Reshape函数解释见代码

ReshapeLike函数解释见代码

create()函数解释见代码

NCHW可以在caffe中直接获取，如下

int num() const { return LegacyShape(0); }

int channels() const { return LegacyShape(1); }

int height() const { return LegacyShape(2); }

int width() const { return LegacyShape(3); }

CopyDataFrom函数解释见代码

data_at函数解释见代码

mutable_cpu_data函数解释见代码

offset函数解释见代码

#ifndef CAFFE_BLOB_HPP_
#define CAFFE_BLOB_HPP_

#include 
#include 
#include 
#include 
#include 
#include 

#include "caffe/common.hpp"
#include "caffe/syncedmem.hpp"
#include "caffe/tensor.hpp"
#include "caffe/type.hpp"
#include "caffe/util/benchmark.hpp"
#include "caffe/util/math_functions.hpp"

const int kMaxBlobAxes = 32;

namespace caffe {

template
class TBlob;

/**
 * @brief A wrapper around SyncedMemory holders serving as the basic
 *        computational unit through which Layer%s, Net%s, and Solver%s
 *        interact.
 *
 *        This is template-less implementation made for mixed precision.
 *        Instances can be converted to any other supported Type.
 *
 * TODO(dox): more thorough description.
 */
class Blob {
 public:
  void Swap(Blob& other) noexcept {
    std::swap(data_tensor_, other.data_tensor_);
    std::swap(diff_tensor_, other.diff_tensor_);
    std::swap(connectivity_, other.connectivity_);	
    std::swap(shape_data_, other.shape_data_);
    std::swap(shape_, other.shape_);
    std::swap(count_, other.count_);
  }

 protected:
  Blob(Type data_type, Type diff_type)
      : data_tensor_(make_shared(data_type)),
        diff_tensor_(make_shared(diff_type)),
        count_(0) {}
  explicit Blob(Type dtype)
      : Blob(dtype, dtype) {}

 public:
  virtual ~Blob() {}

  /// @brief Deprecated; use Reshape(const vector& shape).
  void Reshape(const int num, const int channels, const int height, const int width);
  void Reshape(const int num);

  /**
   * @brief Change the dimensions of the blob, allocating new memory if
   *        necessary.
   *
   * This function can be called both to create an initial allocation
   * of memory, and to adjust the dimensions of a top blob during Layer::Reshape
   * or Layer::Forward. When changing the size of blob, memory will only be
   * reallocated if sufficient memory does not already exist, and excess memory
   * will never be freed.
   *
   * Note that reshaping an input blob and immediately calling Net::Backward is
   * an error; either Net::Forward or Net::Reshape need to be called to
   * propagate the new input shape to higher layers.
   */
  void Reshape(const vector& shape);
  void Reshape(const BlobShape& shape);

  void ReshapeLike(const Blob* other) {
// TODO   if (this->shape() != other->shape()) {
      Reshape(other->shape());
//    }
  }

  void ReshapeLike(const Blob& other) {
    ReshapeLike(&other);
  }

  Type data_type() const {
    return data_tensor_->type();
  }

  Type diff_type() const {
    return diff_tensor_->type();
  }

  bool diff_equals(const Blob& other) const {
    return diff_tensor_ == other.diff_tensor_;
  }

  void allocate_data(bool on_gpu = true) {
    data_tensor_->current_memory(on_gpu);
  }

  void allocate_diff(bool on_gpu = true) {
    diff_tensor_->current_memory(on_gpu);
  }

  /**
   * @brief Creates an instance of a Blob with given Dtype.
   */
  template
  static shared_ptr create() {
    return shared_ptr(new Blob(tp(), tp()));
  }

  /**
   * @brief Creates an instance of a Blob with given Type.
   */
  static shared_ptr create(Type data_type, Type diff_type) {
    return shared_ptr(new Blob(data_type, diff_type));
  }

  /// @brief Creates an instance of a Blob with given type Dtype and given shape.
  template
  static shared_ptr create(const vector& shape) {
    shared_ptr ptr = create();
    ptr->Reshape(shape);
    return ptr;
  }

  template
  static shared_ptr create(int N) {
    shared_ptr ptr = create();
    vector shape;
    shape.push_back(N);
    ptr->Reshape(shape);
    return ptr;
  }


  /// @brief Deprecated; use create(const vector& shape).
  template
  static shared_ptr create(int num, int channels, int height, int width) {
    shared_ptr ptr = create();
    ptr->Reshape(num, channels, height, width);
    return ptr;
  }

  /**
   * @brief Copy from a source Blob.
   *
   * @param source the Blob to copy from
   * @param copy_diff if false, copy the data; if true, copy the diff
   * @param reshape if false, require this Blob to be pre-shaped to the shape
   *        of other (and die otherwise); if true, Reshape this Blob to other's
   *        shape if necessary
   */
  void CopyFrom(const Blob& source, bool copy_diff = false, bool reshape = false,
      Packing pk_from = NCHW, Packing pk_to = NCHW, int group = 0);

  void CopyDataFrom(const Blob& source, bool reshape = false,
      Packing pk_from = NCHW, Packing pk_to = NCHW, int group = 0) {
    CopyFrom(source, false, reshape, pk_from, pk_to, group);
  }

  void CopyDiffFrom(const Blob& source, bool reshape = false,
      Packing pk_from = NCHW, Packing pk_to = NCHW, int group = 0) {
    CopyFrom(source, true, reshape, pk_from, pk_to, group);
  }

  bool is_data_empty() const {
    return data_tensor_->is_empty();
  }

  bool is_diff_empty() const {
    return diff_tensor_->is_empty();
  }

  std::string shape_string() const {
    std::ostringstream stream;
    for (size_t i = 0; i < shape_.size(); ++i) {
      stream << shape_[i] << " ";
    }
    stream << "(" << count_ << ")";
    return stream.str();
  }

  const vector& shape() const { return shape_; }

  /**
   * @brief Returns the dimension of the index-th axis (or the negative index-th
   *        axis from the end, if index is negative).
   *
   * @param index the axis index, which may be negative as it will be
   *        "canonicalized" using CanonicalAxisIndex.
   *        Dies on out of range index.
   */
  int shape(int index) const {
    return shape_[CanonicalAxisIndex(index)];
  }

  int num_axes() const {
    return shape_.size();
  }

  int count() const {
    return count_;
  }

  size_t sizeof_data() const {
    return data_tensor_->size_of();
  }

  size_t sizeof_diff() const {
    return diff_tensor_->size_of();
  }

  /**
   * @brief Compute the volume of a slice; i.e., the product of dimensions
   *        among a range of axes.
   *
   * @param start_axis The first axis to include in the slice.
   *
   * @param end_axis The first axis to exclude from the slice.
   */
  int count(int start_axis, int end_axis) const {
    CHECK_LE(start_axis, end_axis);
    CHECK_GE(start_axis, 0);
    CHECK_GE(end_axis, 0);
    CHECK_LE(start_axis, num_axes());
    CHECK_LE(end_axis, num_axes());
    int count = 1;
    for (int i = start_axis; i < end_axis; ++i) {
      count *= shape(i);
    }
    return count;
  }

  /**
   * @brief Compute the volume of a slice spanning from a particular first
   *        axis to the final axis.
   *
   * @param start_axis The first axis to include in the slice.
   */
  int count(int start_axis) const {
    return count(start_axis, num_axes());
  }

  /**
   * @brief Returns the 'canonical' version of a (usually) user-specified axis,
   *        allowing for negative indexing (e.g., -1 for the last axis).
   *
   * @param axis_index the axis index.
   *        If 0 <= index < num_axes(), return index.
   *        If -num_axes <= index <= -1, return (num_axes() - (-index)),
   *        e.g., the last axis index (num_axes() - 1) if index == -1,
   *        the second to last if index == -2, etc.
   *        Dies on out of range index.
   */
  int CanonicalAxisIndex(int axis_index) const {
    CHECK_GE(axis_index, -num_axes()) << "axis " << axis_index << " out of range for " << num_axes()
                                      << "-D Blob with shape " << shape_string();
    CHECK_LT(axis_index, num_axes()) << "axis " << axis_index << " out of range for " << num_axes()
                                     << "-D Blob with shape " << shape_string();
    if (axis_index < 0) {
      return axis_index + num_axes();
    }
    return axis_index;
  }

  /// @brief Deprecated legacy shape accessor num: use shape(0) instead.
  int num() const { return LegacyShape(0); }

  /// @brief Deprecated legacy shape accessor channels: use shape(1) instead.
  int channels() const { return LegacyShape(1); }

  /// @brief Deprecated legacy shape accessor height: use shape(2) instead.
  int height() const { return LegacyShape(2); }

  /// @brief Deprecated legacy shape accessor width: use shape(3) instead.
  int width() const { return LegacyShape(3); }

  int LegacyShape(int index) const {
    CHECK_LE(num_axes(), 4) << "Cannot use legacy accessors on Blobs with > 4 axes.";
    CHECK_LT(index, 4);
    CHECK_GE(index, -4);
    if (index >= num_axes() || index < -num_axes()) {
      // Axis is out of range, but still in [0, 3] (or [-4, -1] for reverse
      // indexing) -- this special case simulates the one-padding used to fill
      // extraneous axes of legacy blobs.
      return 1;
    }
    return shape(index);
  }

  size_t offset(size_t n, size_t c = 0, size_t h = 0, size_t w = 0) const {
    CHECK_GE(n, 0);
    CHECK_LE(n, num());
    CHECK_GE(channels(), 0);
    CHECK_LE(c, channels());
    CHECK_GE(height(), 0);
    CHECK_LE(h, height());
    CHECK_GE(width(), 0);
    CHECK_LE(w, width());
    return ((n * channels() + c) * height() + h) * width() + w;
  }

  int offset(const vector& indices) const {
    CHECK_LE(indices.size(), num_axes());
    int offset = 0;
    for (int i = 0; i < num_axes(); ++i) {
      offset *= shape(i);
      if ((int)indices.size() > i) {
        CHECK_GE(indices[i], 0);
        CHECK_LT(indices[i], shape(i));
        offset += indices[i];
      }
    }
    return offset;
  }

  template
  void set_cpu_data(Dtype* data) {
    CHECK_NOTNULL(data);
    convert_data(tp());
    CHECK(is_type(data_type()));
    data_tensor_->mutable_synced_mem()->set_cpu_data(data);
  }

  template
  void set_cpu_diff(Dtype* diff) {
    CHECK_NOTNULL(diff);
    convert_diff(tp());
    CHECK(is_type(diff_type()));
    diff_tensor_->mutable_synced_mem()->set_cpu_data(diff);
  }

  template
  const Dtype* cpu_data() const {
    convert_data(tp());
    return static_cast(data_tensor_->synced_mem()->cpu_data());
  }

  template
  const Dtype* cpu_diff() const {
    convert_diff(tp());
    return static_cast(diff_tensor_->synced_mem()->cpu_data());
  }

  template
  Dtype* mutable_cpu_data_c(bool copy_from_gpu) {
    convert_data(tp());
    return static_cast(data_tensor_->mutable_synced_mem()->mutable_cpu_data(copy_from_gpu));
  }

  template
  Dtype* mutable_cpu_data() {  // Keeping PyCaffe intact
    return mutable_cpu_data_c(true);
  }

  template
  Dtype* mutable_cpu_diff_c(bool copy_from_gpu) {
    convert_diff(tp());
    return static_cast(diff_tensor_->mutable_synced_mem()->mutable_cpu_data(copy_from_gpu));
  }

  template
  Dtype* mutable_cpu_diff() {
    return mutable_cpu_diff_c(true);
  }

  // Element-wise accessor. Might be slow due to syncing from GPU to CPU.
  // Currently it's used in tests only. We better keep it this way.
  float data_at(const int n, const int c, const int h, const int w) const {
    return at(offset(n, c, h, w), data_type(), data_tensor_->synced_mem()->cpu_data());
  }
  float diff_at(const int n, const int c, const int h, const int w) const {
    return at(offset(n, c, h, w), diff_type(), diff_tensor_->synced_mem()->cpu_data());
  }
  float data_at(const vector& index) const {
    return at(offset(index), data_type(), data_tensor_->synced_mem()->cpu_data());
  }
  float diff_at(const vector& index) const {
    return at(offset(index), diff_type(), diff_tensor_->synced_mem()->cpu_data());
  }
  float data_at(int index) const {
    return at(index, data_type(), data_tensor_->synced_mem()->cpu_data());
  }
  float diff_at(int index) const {
    return at(index, diff_type(), diff_tensor_->synced_mem()->cpu_data());
  }

  void Update();

  /// @brief Compute the maximum of absolute values (L_\infinity norm) of the data.
  float amax_data(int group = 0) const {
    return data_tensor_->amax(group);
  }

  /// @brief Compute the maximum of absolute values (L_\infinity norm) of the diff.
  float amax_diff(int group = 0) const {
    return diff_tensor_->amax(group);
  }

  /// @brief Compute the sum of absolute values (L1 norm) of the data.
  float asum_data(int group = 0) const {
    return data_tensor_->asum(group);
  }

  /// @brief Compute the sum of absolute values (L1 norm) of the diff.
  float asum_diff(int group = 0) const {
    return diff_tensor_->asum(group);
  }

  /// @brief Compute the sum of squares (L2 norm squared) of the data.
  float sumsq_data(int group = 0) const {
    return data_tensor_->sumsq(group);
  }

  /// @brief Compute the sum of squares (L2 norm squared) of the diff.
  float sumsq_diff(int group = 0) const {
    return diff_tensor_->sumsq(group);
  }

  /// @brief Scale the blob data by a constant factor.
  void scale_data(float scale, void* handle = nullptr) {
    data_tensor_->scale(scale, handle);
  }

  /// @brief Scale the blob diff by a constant factor.
  void scale_diff(float scale, void* handle = nullptr) {
    diff_tensor_->scale(scale, handle);
  }

  /// @brief Set all the blob's data elements to a value.
  void set_data(float value) {
    data_tensor_->set(value);
  }

  /// @brief Set all the blob's diff elements to a value.
  void set_diff(float value) {
    diff_tensor_->set(value);
  }

  /**
   * @brief Set the data_ shared_ptr to point to the SyncedMemory holding the
   *        data_ of Blob other -- useful in Layer%s which simply perform a copy
   *        in their Forward pass.
   *
   * This deallocates the SyncedMemory holding this Blob's data_, as
   * shared_ptr calls its destructor when reset with the "=" operator.
   */
  void ShareData(const Blob& other);

  /**
   * @brief Set the diff_ shared_ptr to point to the SyncedMemory holding the
   *        diff_ of Blob other -- useful in Layer%s which simply perform a copy
   *        in their Forward pass.
   *
   * This deallocates the SyncedMemory holding this Blob's diff_, as
   * shared_ptr calls its destructor when reset with the "=" operator.
   */
  void ShareDiff(const Blob& other);

  void ToProto(BlobProto* proto, bool store_in_old_format, bool write_diff = false, bool write_data = true) const;
  void ToProtoBVLC(BlobProto* proto, bool write_diff = false, bool write_data = true) const;

  void FromProto(const BlobProto& proto, bool reshape = true, bool ignore_shape_mismatch = false);
  bool ShapeEquals(const BlobProto& other);
  std::string to_string(int indent = 0) const;  // debug helper

  // These ones are to be used with care: they don't convert.
  void* current_mutable_data_memory(bool is_gpu, bool flush = true) {
    return data_tensor_->current_mutable_memory(is_gpu, flush);
  }

  void* current_mutable_diff_memory(bool is_gpu, bool flush = true) {
    return diff_tensor_->current_mutable_memory(is_gpu, flush);
  }

  const void* current_data_memory(bool is_gpu) const {
    return data_tensor_->current_memory(is_gpu);
  }

  const void* current_diff_memory(bool is_gpu) const {
    return diff_tensor_->current_memory(is_gpu);
  }

  bool is_data_on_gpu() const {
    return data_tensor_->is_gpu_head();
  }

  bool is_diff_on_gpu() const {
    return diff_tensor_->is_gpu_head();
  }

  size_t gpu_memory_data_use(bool own_only = false) const;
  size_t gpu_memory_diff_use(bool own_only = false) const;

  void set_gpu_data(void* data) {
    CHECK_NOTNULL(data);
    data_tensor_->mutable_synced_mem()->set_gpu_data(data);
  }

  void set_gpu_diff(void* diff) {
    CHECK_NOTNULL(diff);
    diff_tensor_->mutable_synced_mem()->set_gpu_data(diff);
  }

  template
  const Dtype* gpu_data() const {
    convert_data(tp());
    return static_cast(data_tensor_->synced_mem()->gpu_data());
  }

  template
  const Dtype* gpu_diff() const {
    convert_diff(tp());
    return static_cast(diff_tensor_->synced_mem()->gpu_data());
  }

  template
  Dtype* mutable_gpu_data_c(bool copy_from_cpu) {
    convert_data(tp());
    return static_cast(data_tensor_->mutable_synced_mem()->mutable_gpu_data(copy_from_cpu));
  }

  template
  Dtype* mutable_gpu_data() {  // Keeping PyCaffe intact
    return mutable_gpu_data_c(true);
  }

  template
  Dtype* mutable_gpu_diff_c(bool copy_from_cpu) {
    convert_diff(tp());
    return static_cast(diff_tensor_->mutable_synced_mem()->mutable_gpu_data(copy_from_cpu));
  }

  template
  Dtype* mutable_gpu_diff() {
    return mutable_gpu_diff_c(true);
  }

  const int* gpu_shape() const;

  // Element-wise mutator. Might be slow due to syncing from GPU to CPU.
  template
  void set_value_at(bool set_data, int idx, Dtype val) {
    void* ptr = set_data ? current_mutable_data_memory(false, false) :
                current_mutable_diff_memory(false, false);
    CHECK_NOTNULL(ptr);
    const Type dtype = set_data ? data_type() : diff_type();
    if (is_type(dtype)) {
      static_cast(ptr)[idx] = static_cast(val);
    } else if (is_type(dtype)) {
      static_cast(ptr)[idx] = static_cast(val);
    } else if (is_type(dtype)) {
      static_cast(ptr)[idx] = static_cast(val);
    } else {
      LOG(FATAL) << "Unknown data or diff: " << Type_Name(dtype);
    }
  }
  
  void cpu_eltwise_multi(int count, Type dtype, const void* X, void* Y);
  void gpu_eltwise_multi(int count, Type dtype, const void* X, void* Y);
  float cpu_max(int count, Type dtype, const void* X, const int start_index) const;
  float gpu_max(int count, Type dtype, const void* X, const int start_index) const;
  float max(const int start_index, const int count) const;
  
  float cpu_min(int count, Type dtype, const void* X, const int start_index) const;
  float gpu_min(int count, Type dtype, const void* X, const int start_index) const;
  float min(const int start_index, const int count) const;
    
  int cpu_count_zero(int count, Type dtype, const void* X, float threshold, const int start_index) const;
  int gpu_count_zero(int count, Type dtype, const void* X, float threshold, const int start_index) const;
  int count_zero(float threshold, const int start_index, const int count) const;
  int count_zero_connectivity(float threshold, const int start_index, const int count) const;
  void cpu_if_nonzero(int count, Type dtype, const void* X, void* Y) const;
  void gpu_if_nonzero(int count, Type dtype, const void* X, void* Y) const;
  void cpu_set(int count, Type dtype, void* X, float val);
  void gpu_set(int count, Type dtype, void* X, float val);
  
  void cpu_zerout(int count, Type dtype, const void* X, void* Y, float threshold, const int start_index);
  void gpu_zerout(int count, Type dtype, const void* X, void* Y, float threshold, const int start_index);
  void zerout(float threshold, const int start_index, const int count);

  //For sparse operation
  inline const shared_ptr& connectivity() const {
    return connectivity_;
  }
  void InitializeConnectivity(float val = 1.0);
  void ComputeSparseDiff();
  void ComputeSparseData();
  void StoreSparseModeConnectivity(const SparseMode mode);
  
  DISABLE_COPY_MOVE_AND_ASSIGN(Blob);

 protected:
  mutable shared_ptr data_tensor_;
  mutable shared_ptr diff_tensor_;
  shared_ptr shape_data_;
  vector shape_;
  int count_;

  //For sparse operation  
  mutable shared_ptr connectivity_;

  bool is_current_data_valid() const {
    return data_tensor_->is_current_valid();
  }

  bool is_current_diff_valid() const {
    return diff_tensor_->is_current_valid();
  }

  void convert_data(Type new_data_type) const {
    data_tensor_->convert(new_data_type);
  }

  void convert_diff(Type new_diff_type) const {
    diff_tensor_->convert(new_diff_type);
  }

  static float at(int offset, Type dtype, const void* data);
  static void cpu_axpy(int count, Type dtype, float alpha, const void* X, void* Y);
  static void gpu_axpy(int count, Type dtype, float alpha, const void* X, void* Y);

  static void check_integrity(bool do_data, Type current_type, Type new_type) {
    CHECK_EQ(current_type, new_type)
      << "Attempt to change TBlob native " << (do_data ? "data" : "diff")
      << " type from " << Type_Name(current_type) << " to " << Type_Name(new_type);
  }
};  // class Blob


/**
 * @brief A wrapper around SyncedMemory holders serving as the basic
 *        computational unit through which Layer%s, Net%s, and Solver%s
 *        interact.
 *
 *        This is template implementation made for simpler instantiation.
 *        Instances can be converted to any other supported Type.
 *
 * TODO(dox): more thorough description.
 */
template
class TBlob : public Blob {
 public:
  TBlob()
      : Blob(tp()) {}

  /// @brief Deprecated; use TBlob(const vector& shape).
  TBlob(const int num, const int channels, const int height, const int width)
      : Blob(tp()) {
    Reshape(num, channels, height, width);
  }

  explicit TBlob(const vector& shape)
      : Blob(tp()) {
    Reshape(shape);
  }

  // Shadowing parent's implementations and calling them with Dtype by default.
  // We might get rid of shadowing but overall changes would be too dramatic
  // in this case. These are the shortcuts allowing to keep current
  // code intact (pretty much).
  template
  const T* cpu_data() const {
    check_integrity(true, data_type(), tp());
    return Blob::cpu_data();
  }

  template
  const T* cpu_diff() const {
    check_integrity(false, diff_type(), tp());
    return Blob::cpu_diff();
  }

  template
  T* mutable_cpu_data(bool copy_from_gpu = true) {
    check_integrity(true, data_type(), tp());
    return Blob::mutable_cpu_data_c(copy_from_gpu);
  }

  template
  T* mutable_cpu_diff(bool copy_from_gpu = true) {
    check_integrity(false, diff_type(), tp());
    return Blob::mutable_cpu_diff_c(copy_from_gpu);
  }

  template
  const T* gpu_data() const {
    check_integrity(true, data_type(), tp());
    return Blob::gpu_data();
  }

  template
  const T* gpu_diff() const {
    check_integrity(false, diff_type(), tp());
    return Blob::gpu_diff();
  }

  template
  T* mutable_gpu_data(bool copy_from_cpu = true) {
    check_integrity(true, data_type(), tp());
    return Blob::mutable_gpu_data_c(copy_from_cpu);
  }

  template
  T* mutable_gpu_diff(bool copy_from_cpu = true) {
    check_integrity(false, diff_type(), tp());
    return Blob::mutable_gpu_diff_c(copy_from_cpu);
  }

  DISABLE_COPY_MOVE_AND_ASSIGN(TBlob);
};  // class TBlob

}  // namespace caffe

#endif  // CAFFE_BLOB_HPP_

深度学习框架人工智能操作系统训练&前向推理 PyTorch Tensorflow MindSpore caffe 张量加速引擎TBE 深度学习编译器多面体 polyhedral AI集群框架 EwenWanW 深度学习人工智能 pytorch 深度学习编译器
深度学习框架人工智能操作系统训练&前向推理深度学习框架发展到今天，目前在架构上大体已经基本上成熟并且逐渐趋同。无论是国外的Tensorflow、PyTorch，亦或是国内最近开源的MegEngine、MindSpore，目前基本上都是支持EagerMode和GraphMode两种模式。AI嵌入式框架OneFlow&清华计图Jittor&华为深度学习框架MindSpore&旷视深度学习框架MegEn
Caffeine 与 Guava Cache 雨季里的向日葵 java
一、概要1.1背景在项目开发中，为提升系统性能，减少IO开销，本地缓存是必不可少的。最常见的本地缓存是Guava和Caffeine，Caffeine是基于GoogleGuavaCache设计经验改进的结果，相较于Guava在性能和命中率上更具有效率。1.2应用场景愿意消耗一些内存空间来提升速度预料到某些键会被多次查询缓存中存放的数据总量不会超出内存容量二、GuavaCache2.1GuavaCac
OSError: [WinError 126] 找不到指定的模块---caffe2_detectron_ops_gpu.dll 努力的小柚 python运行问题 python pytorch
代码复现记录：问题：OSError:[WinError126]找不到指定的模块。Errorloading"C:\Anaconda\Anaconda3\envs\TIN\lib\site-packages\torch\lib\caffe2_detectron_ops_gpu.dll"oroneofitsdependencies.在搜索很多关于无法查找到caffe2_detectron_ops_gpu
caffe/PyTorch/TensorFlow 在Jupyter Notebook GPU中运用俊俏的萌妹纸 caffe 人工智能深度学习
在JupyterNotebook中使用Caffe框架并利用GPU加速，可以实现多种效果和目的，主要集中在深度学习领域。以下是一些主要的应用场景：快速训练模型：GPU加速可以显著提高模型训练的速度。对于大型数据集和复杂的神经网络结构，使用GPU可以大大减少训练时间。实时数据增强：在训练过程中，可以实时地对输入数据进行变换和增强，以提高模型的泛化能力。GPU加速使得这些操作更加高效。大规模数据处理：深
Linux下Caffe、Docker、Tensorflow、PyTorch环境搭建(CentOS 7) SnailTyan
文章作者：Tyan博客：noahsnail.com|CSDN|注：模型的训练、测试、部署都可以通过Docker环境完成，环境问题会更少。1.CUDA8.0安装CUDA8.0Configenvvariables#CUDAPATHexportPATH="/usr/local/cuda-8.0/bin:$PATH"#CUDALDLIBRARY_PATHexportLD_LIBRARY_PATH="/us
JVM级缓存本地缓存Caffeine 旺仔爱Java JVM专题 jvm JVM缓存本地缓存 Caffeine Guava Cache
JVM级缓存本地缓存Caffeine和GuavaCache前言一、创建缓存的代码逻辑二、Caffeine的优化方面淘汰算法W-TinyLFU三、Caffeine的业务使用总结前言最新的Java面试题，技术栈涉及Java基础、集合、多线程、Mysql、分布式、Spring全家桶、MyBatis、Dubbo、缓存、消息队列、Linux…等等，会持续更新。一、创建缓存的代码逻辑Caffeine：publ
面试redis篇-04缓存雪崩卡搜偶缓存面试 redis
原理缓存雪崩：是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。解决方案：给不同的Key的TTL添加随机值利用Redis集群提高服务的可用性（哨兵模式、集群模式）给缓存业务添加降级限流策略（ngxin或springcloudgateway）给业务添加多级缓存（Guava或Caffeine）问答面试官：什么是缓存雪崩?怎么解决?回答：缓存雪崩意思是设
深度学习主流开源框架：Caffe、TensorFlow、Pytorch、Theano、Keras、MXNet、Chainer seasonsyy 深度学习小知识深度学习开源框架 pytorch
2.6深度学习主流开源框架表2.1深度学习主流框架参数对比框架关键词总结框架关键词基本数据结构（都是高维数组）Caffe“在工业中应用较为广泛”，“编译安装麻烦一点”BlobTensorFlow“安装简单pip”TensorPytorch“定位：快速实验研究”，“简单”，“灵活”TensorTheano×“用于处理大规模神经网络的训练”，“不支持移动设备”，“不能应用于工业环境”，“编译复杂模型时
MMsegmentation-随机初始化 SatVision炼金士 mmalb-炼金术 python
系列文章目录文章目录系列文章目录前言一、初始化单个模块二、初始化多个模块总结前言mmlab下游分支调用权重随机初始化使用参考mmengine的说明文档mmengine支持模型初始化方法包括：BaseInit,Caffe2XavierInit,ConstantInit,KaimingInit,NormalInit,PretrainedInit,TruncNormalInit,UniformInit,
解决：源码安装caffe时遇到libcudnn.so: file not recognized问题 Gracie丹妮
参考教程(19条消息)ubuntu16.04下Detectron+caffe2(Pytorch)安装配置过程_张家坎的博客-CSDN博客_caffe2_detectron_ops_gpu.dllhttps://blog.csdn.net/u014236392/article/details/81117287安装caffe2执行sudomakeinstall之后遇到如下问题:/home/Xdn/cu
进场行礼问候退场东方芭蕾Lily
1.当听到响铃声，按编号排队依次进入考场。tips：面带微笑，优雅自信且有礼貌的边看着考试官边跑到准备问好的位置。步伐轻盈像一阵风样，到位置站好一位脚，保持挺拔向上体态。小仙女就是你们。2.行礼问候Examier:(考试官)GillianMccafferyGoodmorning/afternoongirlsGoodmorning/afrernoonmadamorMs.MccafferyQuesti
YOLOv5独家改进：上采样算子 | 超轻量高效动态上采样DySample，效果秒杀CAFFE，助力小目标检测 AI小怪兽 YOLOv5原创自研 YOLO caffe 目标检测深度学习人工智能
本文独家改进：一种超轻量高效动态上采样DySample，具有更少的参数、FLOPs，效果秒杀CAFFE和YOLOv5网络中的nn.Upsample在多个数据集下验证能够涨点，尤其在小目标检测领域涨点显著。收录YOLOv5原创自研https://blog.csdn.net/m0_63774211/category_12511931.html全网独家首发创新（原创），适合paper！！！2024年计算
caffez转ncnn，及环境配置宁静深远软件安装
一、安装ncnn1、安装protobuf(a)、gitclonehttps://github.com/google/protobuf(b)、自动生成configure配置文件，运行：./autogen.sh(c)、配置环境：./configure(d)、编译源代码:make(e)、安装：sudomakeinstall(f)、刷新动态库:sudoldconfig2、安装ncnn(a)、mkdirco
最新姿态估计研究进展 a微风掠过
最新姿态估计研究进展自上而下：就是先检测包含人的框，即humanproposal，然后对框子中的人进行姿态估计。一般RCNN（区域CNN就是这个思路）自下而上：先检测keypoint，然后根据热力图、点与点之间连接的概率，根据图论知识，基于PAF（部分亲和字段）将关键点连接起来，将关键点分组到人。1、CMU：openpose研究多人的姿态估计运行环境：caffe自下而上，关键点被分组到人的实例时间
智慧云智能教育考试平台展示 barry200890 springboot vue 考试 java vue.js 小程序
智慧云智能教育平台项目简介技术架构1.1后端技术栈:*基于SpringBoot+MybatisPlus+Shiro+mysql5.7+redis+websocket构建.*使用jdk1.8的新特性如:caffeine缓存,lambda表达式.1.2前端技术:*Vue*Vuex*Vxe-Table(文档地址：https://gitee.com/xuliangzhan_admin/vxe-table)
what is SSD|Single Shot MultiBox Detector Woooooooooooooo
文章摘选自多篇文章，仅用于学习，在此表示感谢，若有侵权请联系，感谢论文下载地址：https://arxiv.org/abs/1512.02325论文代码：https://github.com/weiliu89/caffe/tree/ssd省去了区域建议网络，直接使用不同尺度featuremap中的cell得到priodbox（和anchor类似），利用卷积可以直接得到box的回归和score而不需
caffe中的参考模型雨住多一横
RCNNmode_reference_rcnn_ilsvrc13l.pngcaffenet用于Flickrstyle数据集model_finetune_flickr_style.pngAlexNetmodel_alexnet.pnggooglenetmodel_googlenet.pngcaffenetmodel_reference_caffenet.png
RT-DETR算法优化改进：上采样算子 | 超轻量高效动态上采样DySample，效果秒杀CAFFE，助力小目标检测 AI小怪兽 RT-DETR魔术师算法 caffe 目标检测 YOLO 深度学习人工智能
本文独家改进：一种超轻量高效动态上采样DySample，具有更少的参数、FLOPs，效果秒杀CAFFE和YOLOv8网络中的nn.Upsample在多个数据集下验证能够涨点，尤其在小目标检测领域涨点显著。RT-DETR魔术师专栏介绍：https://blog.csdn.net/m0_63774211/category_12497375.html✨✨✨魔改创新RT-DETR引入前沿顶会创新（CVPR
「性能提升」扩展 Spring Cache 支持多级缓存冷冷zz
为什么多级缓存缓存的引入是现在大部分系统所必须考虑的redis作为常用中间件，虽然我们一般业务系统（毕竟业务量有限）不会遇到如下图在随着data-size的增大和数据结构的复杂的造成性能下降，但网络IO消耗会成为整个调用链路中不可忽视的部分。尤其在微服务架构中，一次调用往往会涉及多次调用例如pigoauth2.0的client认证Caffeine来自未来的本地内存缓存,性能比如常见的内存缓存实现性
Spring Cache duration～ spring-boot spring java 后端
目录标题SpringCache1介绍2常用注解3入门SpringCache1介绍SpringCache是一个框架，实现了基于注解的缓存功能，只需要简单地加一个注解，就能实现缓存功能。SpringCache提供了一层抽象，底层可以切换不同的缓存实现，例如：EHCacheCaffeineRedis(常用)起步依赖：org.springframework.bootspring-boot-starter-
Caffeine与Spring cache的各种注解操作 500了 spring java 后端
前言Caffeine是一个基于Java8的进程内缓存框架，它使用乐观锁技术来提高并发吞吐量，并被誉为最快的缓存之一。Caffeine是内存型缓存，即缓存与调用者属于同一个应用，具体地说是属于同一个JVM。它的设计目标是提供高性能、高命中率以及低内存占用的本地缓存解决方案，被描述为GuavaCache的加强版和“新一代缓存”。关于Caffeine的使用，其提供了多种灵活的配置选项：自动加载数据：可以
缓存组件Caffeine的使用月月大王 Java #工具类缓存
caffeine是一个高性能的缓存组件，在需要缓存数据，但数据量不算太大，不想引入redis的时候，caffeine就是一个不错的选择。可以把caffeine理解为一个简单的redis。1、导入依赖com.github.ben-manes.caffeinecaffeine2.9.3导入是要注意版本，最开始我用的版本是3.1.1，不过启动是的时候会报错，这是因为我用的是jdk1.8，需要降低一下版本
Makefile.config walkMAN_aholic
##Refertohttp://caffe.berkeleyvision.org/installation.html#Contributionssimplifyingandimprovingourbuildsystemarewelcome!#cuDNNaccelerationswitch(uncommenttobuildwithcuDNN).USE_CUDNN:=1#CPU-onlyswitch(
缓存Caffeine之W-TinyLFU淘汰策略 georgesnoopy guava 缓存 java 淘汰策略 Caffeine
我们常见的缓存是基于内存的缓存，但是单机的内存是有限的，不能让缓存数据撑爆内存，所有需要缓存淘汰机制。https://mp.csdn.net/editor/html/115872837中大概说明了LRU的缓存淘汰机制，以及基于LRU的著名实现guavacache。除了LRU淘汰策略外，其是常见的还有FIFO以及LFU，只是说目前用的最多的是LRU。LRULRU记录了缓存中数据项的访问时间，在缓存数
Caffeine史上最快的内存缓存奇遇少年缓存 java
引言在现代的Web应用程序中，缓存是提升性能，减少数据库负载，加快响应速度的关键技术之一。SpringBoot作为一个简化Spring应用开发的框架，提供了与多种缓存技术集成的支持。Caffeine是一个高性能，灵活的缓存库，它可以作为本地缓存在Java应用中广泛使用。本文将详细介绍如何在SpringBoot项目中集成Caffeine缓存，并通过一个实例来展示它的使用。什么是Caffeine缓存？
如何解决caffe和video-caffe不能使用cudnn8编译的问题 Arnold-FY-Chen video-caffe 深度学习 Caffe video-caffe caffe 深度学习 cudnn8 cudnn
因为caffe之类的代码很久不更新了，只支持到了使用cudnn7.x，在使用了cudnn8的环境下编译caffe或video-caffe时，会在src/caffe/layers/cudnn_conv_layer.cpp等文件里出错：error:identifier"CUDNN_CONVOLUTION_FWD_SPECIFY_WORKSPACE_LIMIT"isundefinederror:iden
Redis 6.0 客户端缓存极简博客 java redis
不难发现，我们经常将Redis作为系统的缓存服务，但你有没有发现。在我们每次操作Redis时，都需要发送网络请求。这样就避免不了网络的开销。但如何解决这个问题呢？我们引入了本地缓存来解决此问题。查询逻辑从先前的直接查询转变为：先通过查询本地缓存，不存在再去远程查找然后设置到本地缓存-适用于分布式客户端缓存。有没有感觉像我们使用过的本地缓存Guava、Caffeine等一样？有啥特别的？这里Redi
[图像算法]-(yolov5.train)-GPU架构中的半精度fp16与单精度fp32计算蒸饺与白茶
GPU架构中的半精度与单精度计算由于项目原因，我们需要对darknet中卷积层进行优化，然而对于像caffe或者darknet这类深度学习框架来说，都已经将卷积运算转换成了矩阵乘法，从而可以方便调用cublas库函数和cudnn里tiling过的矩阵乘。 CUDA在推出7.5的时候提出了可以计算16位浮点数据的新特性。定义了两种新的数据类型half和half2.之前有师弟已经DEMO过半精度
caffe搭建深度神经网络 A异乡人_7a44
利用Caffe进行深度神经网络训练第一步需要搞懂几个重要文件：solver.prototxttrain_val.prototxttrain.shsolver.prototxtsolver这个文件主要存放模型训练所用到的一些超参数：net:=指定待训练模型结构文件，即train_val.prototxttest_interval:=测试间隔，即每隔多少次迭代进行一次测试test_initializa
deep-visualization-toolbox可视化安装 2014wzy caffe框架
运行环境：Linux+caffe步骤：Step0:Compilemasterbranchofcaffe本代码运行的前提是，配置过caffe。因为配置caffe的过程中会出现一些依赖库，正是本代码所需要的。http://blog.csdn.NET/u011204487/article/details/51596471是配置caffe的过程。注意Makefile.config中的CPU_ONLY:=1
HQL之投影查询归来朝歌 HQL Hibernate 查询语句投影查询
在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
Spring整合redis bylijinnan redis
pom.xml <dependencies>  <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2 在项目中出现了org.hiber
android动画效果不懂事的小屁孩 android动画
前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
js delete 删除机理以及它的内存泄露问题的解决方案换个号韩国红果果 JavaScript
delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露（其实还未删除）举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
Oracle将零干预分析加入网络即服务计划蓝儿唯美 oracle
由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
spring学习——springmvc（二） a-john springMVC
Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
POJ-2828-Buy Tickets aijuans ACM_POJ
POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
Java Ant build.xml详解 asia007 build.xml
1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台 --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
android按钮监听器的四种技术百合不是茶 android xml配置监听器实现接口
android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方; 1,activity中使用内部类实现接口 ,创建内部类实例使用add方法与java类似创建监听器的实例 myLis lis = new myLis(); 使用add方法给按钮添加监听器
软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。如今很多的公司
TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForge How do Attachement Anchor Wiki Syntax
the CollabNet user information center http://help.collab.net/ How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
【Redis四】Redis数据类型 bit1129 redis
概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
SSH2整合-附源码白糖_ eclipse spring tomcat Hibernate Google
今天用eclipse终于整合出了struts2+hibernate+spring框架。我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。补充1：项目中部分jar包不是最新版的，可能导
[转]开源项目代码的学习方法 braveCS 学习方法
转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html 1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
编程之美-子数组的最大和（二维） bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
读书笔记-3 chengxuyuancsdn jquery笔记 resultMap配置 ibatis一对多配置
1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
[物理与天文]物理学新进展 comsci
如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境怎么办呢?
Oracle 11g新特性:Automatic Diagnostic Repository daizj oracle ADR
Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。这两份log文
简单排序:选择排序 dieslrae 选择排序
public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
线程同步工具类 shuizhaosi888 同步工具类
同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
bleeding edge是什么意思 haojinghua DI
不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。 In computer science, bleeding edge is a term that
c中实现utf8和gbk的互转 jimmee c iconv utf8&gbk编码
#include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
在代码中获取Android theme中的attr属性值 OliveExcel android theme
Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西. 在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
基于Zookeeper的分布式共享锁 roadrunners zookeeper 分布式共享锁
首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。官
两个容易被忽略的MySQL知识 tomcat_oracle mysql
1、varchar(5)可以存储多少个汉字，多少个字母数字？　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
zoj 3827 Information Entropy(水题) 阿尔萨斯 format
题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&

Caffe：blob.hpp

你可能感兴趣的:(Caffe)