（Caffe）基本类Blob，Layer，Net（一）

最新推荐文章于 2023-07-19 09:17:37 发布
最新推荐文章于 2023-07-19 09:17:37 发布
阅读量1.7w 收藏 36
点赞数 13
分类专栏： Caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mounty_fsc/article/details/51085654
版权

本文地址：http://blog.csdn.net/mounty_fsc/article/details/51085654

Caffe中，Blob，Layer，Net，Solver是最为核心的类，以下介绍这几个类，Solver将在下一节介绍。

1 Blob

1.1 简介

Blob是：

  1. 对待处理数据带一层封装，用于在Caffe中通信传递。
  2. 也为CPU和GPU间提供同步能力
  3. 数学上，是一个N维的C风格的存储数组
    总的来说，Caffe使用Blob来交流数据，其是Caffe中标准的数组与统一的内存接口，它是多功能的，在不同的应用场景具有不同的含义，如可以是：batches of images, model parameters, and derivatives for optimization等。

1.2 源代码

/** 
 * @brief A wrapper around SyncedMemory holders serving as the basic 
 *        computational unit through which Layer%s, Net%s, and Solver%s 
 *        interact. 
 * 
 * TODO(dox): more thorough description. 
 */  
template <typename Dtype>  
class Blob {  
 public:  
  Blob()  
       : data_(), diff_(), count_(0), capacity_(0) {}  

  /// @brief Deprecated; use <code>Blob(const vector<int>& shape)</code>.  
  explicit Blob(const int num, const int channels, const int height,  
      const int width);  
  explicit Blob(const vector<int>& shape);  

  .....  

 protected:  
  shared_ptr<SyncedMemory> data_;  
  shared_ptr<SyncedMemory> diff_;  
  shared_ptr<SyncedMemory> shape_data_;  
  vector<int> shape_;  
  int count_;  
  int capacity_;  

  DISABLE_COPY_AND_ASSIGN(Blob);  
};  // class Blob

注：此处只保留了构造函数与成员变量。

说明：

  1. Blob在实现上是对SyncedMemory（见1.5部分）进行了一层封装。
  2. shape_为blob维度，见1.3部分
  3. data_为原始数据
  4. diff_为梯度信息
  5. count_为该blob的总容量（即数据的size），函数count(x,y)（或count(x)）返回某个切片[x,y]（[x,end]）内容量，本质上就是shape[x]shape[x+1]….*shape[y]的值

1.3 Blob的shape

由源代码中可以注意到Blob有个成员变量：vector shape_
其作用：

  1. 对于图像数据，shape可以定义为4维的数组(Num, Channels, Height, Width)或(n, k, h, w)，所以Blob数据维度为n*k*h*w，Blob是row-major保存的，因此在(n, k, h, w)位置的值物理位置为((n * K + k) * H + h) * W + w。其中Number是数据的batch size，对于256张图片为一个training batch的ImageNet来说n = 256;Channel是特征维度，如RGB图像k = 3
  2. 对于全连接网络，使用2D blobs (shape (N, D))，然后调用InnerProductLayer
  3. 对于参数，维度根据该层的类型和配置来确定。对于有3个输入96个输出的卷积层，Filter核 11 x 11，则blob为96 x 3 x 11 x 11. 对于全连接层，1000个输出，1024个输入，则blob为1000 x 1024.

1.4 Blob的行优先的存储方式

以Blob中二维矩阵为例（如全连接网络shape (N, D)），如图所示。同样的存储方式可以推广到多维。

这里写图片描述

1.5 SyncedMemory

由1.2知，Blob本质是对SyncedMemory的再封装。其核心代码如下：

/** 
 * @brief Manages memory allocation and synchronization between the host (CPU) 
 *        and device (GPU). 
 * 
 * TODO(dox): more thorough description. 
 */  
class SyncedMemory {  
 public:  
...  
 const void* cpu_data();  
  const void* gpu_data();  
  void* mutable_cpu_data();  
  void* mutable_gpu_data();  
...  
 private:  
...  
  void* cpu_ptr_;  
  void* gpu_ptr_;  
...  
};  // class SyncedMemory

Blob同时保存了data_和diff_,其类型为SyncedMemory的指针。
对于data_(diff_相同),其实际值要么存储在CPU(cpu_ptr_)要么存储在GPU(gpu_ptr_),有两种方式访问CPU数据(GPU相同)：

  1. 常量方式,void* cpu_data()，其不改变cpu_ptr_指向存储区域的值。

  2. 可变方式，void* mutable_cpu_data()，其可改变cpu_ptr_指向存储区值。
    以mutable_cpu_data()为例

    void* SyncedMemory::mutable_cpu_data() {
  to_cpu();
  head_ = HEAD_AT_CPU;
  return cpu_ptr_;
}

inline void SyncedMemory::to_cpu() {
  switch (head_) {
  case UNINITIALIZED:
    CaffeMallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_);
    caffe_memset(size_, 0, cpu_ptr_);
    head_ = HEAD_AT_CPU;
    own_cpu_data_ = true;
    break;
  case HEAD_AT_GPU:

#ifndef CPU_ONLY

    if (cpu_ptr_ == NULL) {
      CaffeMallocHost(&cpu_ptr_, size_, &cpu_malloc_use_cuda_);
      own_cpu_data_ = true;
    }
    caffe_gpu_memcpy(size_, gpu_ptr_, cpu_ptr_);
    head_ = SYNCED;

#else

    NO_GPU;

#endif

    break;
  case HEAD_AT_CPU:
  case SYNCED:
    break;
  }
}

说明：

  1. 经验上来说，如果不需要改变其值，则使用常量调用的方式，并且，不要在你对象中保存其指针。为何要这样设计呢，因为这样涉及能够隐藏CPU到GPU的同步细节，以及减少数据传递从而提高效率，当你调用它们的时候，SyncedMem会决定何时去复制数据，通常情况是仅当gnu或cpu修改后有复制操作，引用1官方文档中有一个例子说明何时进行复制操作。
  2. 调用mutable_cpu_data()可以让head转移到cpu上
  3. 第一次调用mutable_cpu_data()是UNINITIALIZED将执行9到14行，将为cpu_ptr_分配host内存
  4. 若head从gpu转移到cpu，将把数据从gpu复制到cpu中

2 Layer

2.1 简介

Layer是Caffe的基础以及基本计算单元。Caffe十分强调网络的层次性，可以说，一个网络的大部分功能都是以Layer的形式去展开的，如convolute,pooling,loss等等。
在创建一个Caffe模型的时候，也是以Layer为基础进行的，需按照src/caffe/proto/caffe.proto中定义的网络及参数格式定义网络 prototxt文件（需了解google protocol buffer）

2.2 Layer与Blob的关系

如图，名为conv1的Layer 的输入是名为data的bottom blob，其输出是名为conv1的top blob。

其protobuff定义如下，一个layer有一个到多个的top和bottom，其对应于blob

layer {  
      name: "conv1"  
      type: "Convolution"  
      bottom: "data"  
      top: "conv1"  
     ....  
    }

2.3 源代码

 /** 
     * Layer%s must implement a Forward function, in which they take their input 
     * (bottom) Blob%s (if any) and compute their output Blob%s (if any). 
     * They may also implement a Backward function, in which they compute the error 
     * gradients with respect to their input Blob%s, given the error gradients with 
     * their output Blob%s. 
     */  
    template <typename Dtype>  
    class Layer {  
     public:  
      /** 
       * You should not implement your own constructor. Any set up code should go 
       * to SetUp(), where the dimensions of the bottom blobs are provided to the 
       * layer. 
       */  
      explicit Layer(const LayerParameter& param)  
        : layer_param_(param), is_shared_(false) {  
    ...  
        }  
      virtual ~Layer() {}  

      /** 
       * @brief Implements common layer setup functionality. 
       * @param bottom the preshaped input blobs 
       * @param top 
       *     the allocated but unshaped output blobs, to be shaped by Reshape 
       */  
      void SetUp(const vector<Blob<Dtype>*>& bottom,  
          const vector<Blob<Dtype>*>& top) {  
    ...  
      }  

      ...  

      /** 
       * @brief Given the bottom blobs, compute the top blobs and the loss. 
       * \return The total loss from the layer. 
       * 
       * The Forward wrapper calls the relevant device wrapper function 
       * (Forward_cpu or Forward_gpu) to compute the top blob values given the 
       * bottom blobs.  If the layer has any non-zero loss_weights, the wrapper 
       * then computes and returns the loss.
       * 
       * Your layer should implement Forward_cpu and (optionally) Forward_gpu. 
       */  
      inline Dtype Forward(const vector<Blob<Dtype>*>& bottom,  
          const vector<Blob<Dtype>*>& top);  

      /** 
       * @brief Given the top blob error gradients, compute the bottom blob error 
       *        gradients. 
       * 
       * @param top 
       *     the output blobs, whose diff fields store the gradient of the error 
       *     with respect to themselves 
       * @param propagate_down 
       *     a vector with equal length to bottom, with each index indicating 
       *     whether to propagate the error gradients down to the bottom blob at 
       *     the corresponding index 
       * @param bottom 
       *     the input blobs, whose diff fields will store the gradient of the error 
       *     with respect to themselves after Backward is run 
       * 
       * The Backward wrapper calls the relevant device wrapper function 
       * (Backward_cpu or Backward_gpu) to compute the bottom blob diffs given the 
       * top blob diffs. 
       * 
       * Your layer should implement Backward_cpu and (optionally) Backward_gpu. 
       */  
      inline void Backward(const vector<Blob<Dtype>*>& top,  
          const vector<bool>& propagate_down,  
          const vector<Blob<Dtype>*>& bottom);  

     ...  

     protected:  
      /** The protobuf that stores the layer parameters */  
      LayerParameter layer_param_;  
      /** The phase: TRAIN or TEST */  
      Phase phase_;  
      /** The vector that stores the learnable parameters as a set of blobs. */  
      vector<shared_ptr<Blob<Dtype> > > blobs_;  
      /** Vector indicating whether to compute the diff of each param blob. */  
      vector<bool> param_propagate_down_;  

      /** The vector that indicates whether each top blob has a non-zero weight in 
       *  the objective function. */  
      vector<Dtype> loss_;  

      virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
          const vector<Blob<Dtype>*>& top) = 0;  

      virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
          const vector<Blob<Dtype>*>& top) {  
        // LOG(WARNING) << "Using CPU code as backup.";  
        return Forward_cpu(bottom, top);  
      }  

      virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
          const vector<bool>& propagate_down,  
          const vector<Blob<Dtype>*>& bottom) = 0;  

      virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
          const vector<bool>& propagate_down,  
          const vector<Blob<Dtype>*>& bottom) {  
        // LOG(WARNING) << "Using CPU code as backup.";  
        Backward_cpu(top, propagate_down, bottom);  
      }  

    ...  

     };  // class Layer

说明：每一层定义了三种操作

  1. Setup：Layer的初始化
  2. Forward：前向传导计算，根据bottom计算top，调用了Forward_cpu（必须实现）和Forward_gpu（可选，若未实现，则调用cpu的）
  3. Backward：反向传导计算，根据top计算bottom的梯度，其他同上

2.4 派生类分类

在Layer的派生类中，主要可以分为Vision Layers

  • Vision Layers
    Vison 层主要用于处理视觉图像相关的层，以图像作为输入，产生其他的图像。其主要特点是具有空间结构。
    包含Convolution(conv_layer.hpp)、Pooling(pooling_layer.hpp)、Local Response Normalization(LRN)(lrn_layer.hpp)、im2col等，注：老版本的Caffe有头文件include/caffe/vision_layers.hpp，新版本中用include/caffe/layer/conv_layer.hpp等取代
  • Loss Layers
    这些层产生loss，如Softmax(SoftmaxWithLoss)、Sum-of-Squares / Euclidean(EuclideanLoss)、Hinge / Margin(HingeLoss)、Sigmoid Cross-Entropy(SigmoidCrossEntropyLoss)、Infogain(InfogainLoss)、Accuracy and Top-k等
  • Activation / Neuron Layers
    元素级别的运算，运算均为同址计算（in-place computation，返回值覆盖原值而占用新的内存）。如：ReLU / Rectified-Linear and Leaky-ReLU(ReLU)、Sigmoid(Sigmoid)、TanH / Hyperbolic Tangent(TanH)、Absolute Value(AbsVal)、Power(Power)、BNLL(BNLL)等
  • Data Layers
    网络的最底层，主要实现数据格式的转换，如：Database(Data)、In-Memory(MemoryData)、HDF5 Input(HDF5Data)、HDF5 Output(HDF5Output)、Images(ImageData)、Windows(WindowData)、Dummy(DummyData)等
  • Common Layers
    Caffe提供了单个层与多个层的连接。如：Inner Product(InnerProduct)、Splitting(Split)、Flattening(Flatten)、Reshape(Reshape)、Concatenation(Concat)、Slicing(Slice)、Elementwise(Eltwise)、Argmax(ArgMax)、Softmax(Softmax)、Mean-Variance Normalization(MVN)等

注，括号内为Layer Type,没有括号暂缺信息，详细咱见引用2

3 Net

3.1 简介

一个Net由多个Layer组成。一个典型的网络从data layer（从磁盘中载入数据）出发到loss layer结束。如图是一个简单的逻辑回归分类器。

如下定义：

name: "LogReg"
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  data_param {
    source: "input_leveldb"
    batch_size: 64
  }
}
layer {
  name: "ip"
  type: "InnerProduct"
  bottom: "data"
  top: "ip"
  inner_product_param {
    num_output: 2
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "ip"
  bottom: "label"
  top: "loss"
}

3.2 源代码

/**
 * @brief Connects Layer%s together into a directed acyclic graph (DAG)
 *        specified by a NetParameter.
 *
 * TODO(dox): more thorough description.
 */
template <typename Dtype>
class Net {
 public:
...
  /// @brief Initialize a network with a NetParameter.
  void Init(const NetParameter& param);
...

  const vector<Blob<Dtype>*>& Forward(const vector<Blob<Dtype>* > & bottom,
      Dtype* loss = NULL);
...
  /**
   * The network backward should take no input and output, since it solely
   * computes the gradient w.r.t the parameters, and the data has already been
   * provided during the forward pass.
   */
  void Backward();
  ...
  Dtype ForwardBackward(const vector<Blob<Dtype>* > & bottom) {
    Dtype loss;
    Forward(bottom, &loss);
    Backward();
    return loss;
  }
...

 protected:
  ...
  /// @brief The network name
  string name_;
  /// @brief The phase: TRAIN or TEST
  Phase phase_;
  /// @brief Individual layers in the net
  vector<shared_ptr<Layer<Dtype> > > layers_;
  /// @brief the blobs storing intermediate results between the layer.
  vector<shared_ptr<Blob<Dtype> > > blobs_;
  vector<vector<Blob<Dtype>*> > bottom_vecs_;
  vector<vector<Blob<Dtype>*> > top_vecs_;
  ...
  /// The root net that actually holds the shared layers in data parallelism
  const Net* const root_net_;
};
}  // namespace caffe

说明：

  1. Init中，通过创建blob和layer搭建了整个网络框架，以及调用各层的SetUp函数。
  2. blobs_存放这每一层产生的blobls的中间结果，bottom_vecs_存放每一层的bottom blobs，top_vecs_存放每一层的top blobs

参考文献：
[1].http://caffe.berkeleyvision.org/tutorial/net_layer_blob.html
[2].http://caffe.berkeleyvision.org/tutorial/layers.html
[3].https://yufeigan.github.io
[4].https://www.zhihu.com/question/27982282

沤江一流
关注
  • 13
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Caffe学习(五)——Blob,Layer,Net介绍
cui841923894的博客
08-20 2240
简介 深度网络（Net）是由许多互相连接的层（layers）组合成的组合模型，Caffe定义的网络模型就是这样逐层(layers)连接。 Net包含了整个自顶向下的网络，网络由各个Layer组合而成； Layer指处理数据的单层运算算子（比如卷积运算、pooling运算等）； Blob是网络运行时数据存储、传递和操作的接口； 以examples/mnist/lenet_train_tes...
关于caffe中的blob结构及卷积计算汇总
神秘少年的博客
11-02 5347
传送门：根据博主这篇文章汇总：http://www.cnblogs.com/zjutzz/p/5960289.html 关于caffe中的blob结构及卷积计算 blob是caffe中的基本数据结构，简单理解就是一个“4维数组”。但是，这个4维数组有什么意义？ TensorFlow这款google出的框架，带出了tensor（张量）的概念。虽然是数学概念，个人还是倾向于简单理解为“多维数组”
caffe训练分类数据集的教程
12-03
caffe训练数据集的教程：非常详细，不会的可以提问哦～～～～
caffe blob类用法详解
dengheCSDN的博客
09-18 1万+
此部分内容参考了三人的博客,写的东西有相同之处和不同之处,互相补充吧.       1. 转载链接:http://blog.csdn.net/chenriwei2/article/details/46367023       主要功能： Blob 是Caffe作为数据传输的媒介，无论是网络权重参数，还是输入数据，都是转化为Blob数据结构来存储，网络，求解器等都是直接与此结构打交道的。
PyTorch转Caffe模型
xiaohe9275的博客
12-22 2085
PyTorch转Caffe模型 这里使用的工具来自：PytorchToCaffe，主体代码如下： PytorchToCaffe-master |——Caffe | |——caffe.proto | |——caffe_pb2.py | |
Blob数据类型&数据库事务，数据库连接池
一天不看代码浑身难受
11-19 1262
文章目录一、 操作BLOB类型字段1.1 MySQL BLOB类型1.2 向数据表中插入大数据类型1.3 修改数据表中的Blob类型字段1.4 从数据表中读取大数据类型二、 批量插入2.1 批量执行SQL语句2.2 高效的批量插入2.2.1 实现层次一：使用Statement2.2.2 实现层次二：使用PreparedStatement2.2.3 实现层次三2.2.4 实现层次四三、 数据库事务3.1 数据库事务介绍3.2 JDBC事务处理3.3 事务的ACID属性3.3.1 数据库的并发问题3.3.2 .
Caffe Blob
juluwangriyue的博客
03-22 244
Caffe Blob Caffe使用Blob结构来存储、交换和处理网络中正向和反向迭代的数据和导数信息。Blob是Caffe的标注数组结构，提供了Caffe的统一内存接口。 Blob是Caffe中处理和传递实际数据的数据封装包，并且在CPU与GPU之间具有同步处理能力。Blob还可以根据CPU主机到GPU设备的同步需要，屏蔽CPU/GPU混合运算在计算上的开销。主机和设备上的内存按需求分配，以提高内存的使用效率。 一般对批量图像数据，Blob的维度为图像数量N×通道数K×图像高度H×图像宽度W。Blo
blob类型是干什么的？底层原理是什么？
长风破浪会有时的博客
07-19 1356
类型是数据库中的一种特殊数据类型，用于存储二进制数据。它提供了一种在数据库中存储和操作二进制数据的机制。具体的实现方式和底层原理取决于所使用的数据库系统，但通常会以二进制文件或二进制数据块的形式存储在数据库表中，并通过数据库查询语言或驱动程序来进行操作。类型的字段会以一种特定的方式存储在数据库中。数据库系统会根据字段的定义将二进制数据保存为二进制文件或二进制数据块，并将其与其他数据一起存储在数据库的相应表中。数据时，可以通过数据库查询语言（如 SQL）或相应的数据库驱动程序来检索和操作这些二进制数据。
Blob（二进制大对象）
热门推荐
哥头的博客
03-08 1万+
Blob（二进制大对象）Oracle LOB：LOB，即Large Objects（大对象），是用来存储大量的二进制和文本数据的一种数据类型（一个LOB字段可存储多达4GB的数据）。LOB分为两种类型：内部LOB和外部LOB。        -内部LOB将数据以字节流的形式存储在数据库的内部。因而，内部LOB的许多操作都可以参与事务，也可以像处理普通数据一样对其进行备份和恢复操作。        ...
GoogleNet-Caffe模型实现图像分类.txt
08-23
包含bvlc_googlenet.caffemodel、bvlc_googlenet.prototxt、synset_words.txt文件 和GoogleNet-Caffe模型实现图像分类源码、图片素材。 具体实现效果见CSDN博客“DNN系列2_GoogleNet-Caffe模型实现图像分类”
EfficientNet-Caffe.zip
10-22
神经网络架构搜索出的网络EfficientNet，根据官方开源pytorch代码，转为caffe的网络协议文件，可以顺利训练，这里提供了EfficientNet B0的3种版本，第一种是完整 版，也就是使用了swish激活以及SE模块的，第二种是将...
caffe 实现的性别年龄表情预测分类
03-17
caffe 实现的性别年龄表情预测分类
bvlc_googlenet.caffemodel bvlc_googlenet.prototxt synset_words
04-26
opencv.dnn做图像分类需要的googlenet caffe模型模型文件bvlc_googlenet.caffemodel bvlc_googlenet.prototxt及ImageNet标签文件synset_words.txt等
blob是什么类型？
webot123456的博客
04-13 1万+
BLOB (binary large object)----二进制大对象，是一个可以存储二进制文件的容器。 　　在计算机中，BLOB常常是数据库中用来存储二进制文件的字段类型。 　 　　BLOB是一个大文件，典型的BLOB是一张图片或一个声音文件，由于它们的尺寸，必须使用特殊的方式来处理（例如：上传、下载或者存放到一个数据库）。 根据Eric Raymond的说法，处理BLOB的主要思想就是让文件处理器（如数据库管理器）不去理会文件是什么，而是关心如何去处理它。 　 　　但也有专家强调，这种处理大数据对象的
Caffe学习2：Blob
Run_it_faraway的博客
07-27 1257
caffe源码中会出现不少explicit、inline关键字； C++中的explicit关键字的作用是禁止单参数构造函数的隐式转换，只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的；还有inline的作用，iniline主要是将代码进行复制，扩充，会使代码总量上升，好处就是可以节省调用的开销，能提高执行效率。 1.Blob Caffe 使用 blob
一文带你熟悉Pytorch-＞Caffe-＞om模型转换流程
华为云官方博客
02-22 3225
摘要：本文旨在分享Pytorch->Caffe->om模型转换流程。 标准网络 Baseline：PytorchToCaffe 主要功能代码在： PytorchToCaffe +-- Caffe | +-- caffe.proto | +-- layer_param.py +-- example | +-- resnet_pytorch_2_caffe.py +-- pytorch_to_caffe.py 直接使用可以参考resnet_pytorch_2_caffe.py
批量插入及数据库事务（三）
weixin_42628809的博客
08-23 2779
五.批量插入 5.1 批量执行SQL语句 当需要成批插入或者更新记录时，可以采用Java的批量更新机制，这一机制允许多条语句一次性提交给数据库批量处理。通常情况下比单独提交处理更有效率 JDBC的批量处理语句包括下面三个方法： ①addBatch(String)：添加需要批量处理的SQL语句或是参数； ②executeBatch()：执行批量处理语句； ③clearBatch():清空缓存的数据 通常我们会遇到两种批量执行SQL语句的情况： ①多条SQL语句的批量处理； ②一个SQL语句的批量传参； 5.2
【04】caffe网络layer top和bottom可以一样的相关解释
yeler082的博客
06-19 2741
Caffe model里为啥有的layer top和bottom还能一样的？例如我们有时候会在网络结构中会看到下面这样的定义，其中的输入bottom和输出的层名称都是"conv1_1"，实际上产生这样的同名通常是我们利用python接口定义网络时使用了in_place=True参数设置造成的，caffe利用in-place计算可以节省内（显）存，同时还可以省去反复申请和释放内存的时间。 lay...
caffe代码阅读5：Layer的实现细节-2016.3.17
一亩半分地
03-17 1万+
解析Caffe中的Layer类的相关具体的实现。
squeezenet caffemodel下载
最新发布
10-23
SqueezeNet是一种高效的神经网络模型，它具有非常小的模型大小和低计算成本，适合在计算资源有限的设备上部署。如果您想要下载SqueezeNet的caffemodel文件，您可以按照以下步骤进行操作。 1. 打开您的浏览器，并搜索"SqueezeNet caffemodel"。 2. 在搜索结果中，找到可信赖的源，例如Caffe官方网站或GitHub等。 3. 点击打开该源网站，并寻找与SqueezeNet相关的caffemodel文件下载链接。 4. 一旦找到合适的链接，请点击下载按钮或链接。 5. 浏览器将开始下载caffemodel文件，下载速度取决于您的互联网连接速度和文件大小。 6. 一旦下载完成，您可以在您的计算机上找到下载的caffemodel文件。 7. 为了在使用它之前方便管理和使用，您可以将caffemodel文件放在一个您容易访问的位置。 总的来说，在下载SqueezeNet的caffemodel文件时，您需要打开浏览器，搜索并找到可信赖的源，然后下载该文件并妥善保存。下载完成后，您将可以在您的计算机上使用该文件进行相关的机器学习或深度学习任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值