《Weighted Maximum Mean Discrepancy for Unsupervised Domain Adaptation》源码剖析

最新推荐文章于 2020-11-19 20:08:47 发布
最新推荐文章于 2020-11-19 20:08:47 发布
阅读量679 收藏 2
点赞数
分类专栏： 代码剖析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/big_yellow_man/article/details/93772127
版权

介绍

这是对论文《Weighted Maximum Mean Discrepancy for Unsupervised Domain Adaptation》作者在github给出的代码示例进行的分析，代码基于Caffe框架扩展，fork于mmd-caffe，主要对MMDLoss(WMMDLoss)进行定义和实现，理论分析，源码地址。

数据集

该方法为迁移学习中domain adaptation类，作者将domain 、target dataset 文件名集中于一个txt文件中，训练数据集和测试数据集文件申明分别位于\data\amazon_to_caltech\traina2c.txt和\data\amazon_to_caltech\testa2c.txt，该文件可以由images/code/data_constructor.py脚本生成，示例采用amazon -> caltech作为数据集。

网络结构

在\model\train_val.prototxt中定义了基于AlexNet的网络结构，可视化如下：
在这里插入图片描述
在这里插入图片描述
在几次卷积等操作后，在第二个fc层使用mmd（实则wmmd方法，作者未改名，the backward function in mmd_layer.cu is adjusted to replace the conventional mmd with weighted mmd specified）和一次dropout，再进行一次mmd（wmmd），除该网络结构模型外，根据作者文章阐述，WMMD方法加在GoggleNet最后一个inception和全连接层，LeNet最后一个卷积层。

wmmd方法使用和实现

可以看到，关键的部分在fc7和fc8_office，具体结构定义如下：

layer {
  name: "fc7"
  type: "InnerProduct"
  bottom: "fc6"
  top: "fc7"
  param {
    lr_mult: 0.1
    decay_mult: 1.0
  }
  param {
    lr_mult: 0.2
    decay_mult: 0.0
  }
  inner_product_param {
    num_output: 4096
    weight_filler {
      type: "gaussian"
      std: 0.005
    }
    bias_filler {
      type: "constant"
      value: 1.0
    }
  }
}
layer {
  name: "mmd_fc7"
  type: "MMDLoss"
  bottom: "fc7"
  bottom: "label"
  bottom: "weight"
  top: "fc7"
  mmd_param {
    num_of_kernel: 10
    mmd_lambda: 0.3
    iter_of_epoch: 32
    method_param {
      top_num: 5
      i_lambda: 0.0
    }
    method: "none"
    kernel_mul: 2.0
    fix_gamma: false
    mmd_lr: 10.0
    quad_weight: 0.0
    mmd_lock: 1
    num_class: 10
    entropy_thresh: 10
  }
}
layer {
  name: "relu7"
  type: "ReLU"
  bottom: "fc7"
  top: "fc7"
}
layer {
  name: "drop7"
  type: "Dropout"
  bottom: "fc7"
  top: "fc7"
  dropout_param {
    dropout_ratio: 0.5
  }
}
layer {
  name: "fc8_office"
  type: "InnerProduct"
  bottom: "fc7"
  top: "fc8_office"
  param {
    lr_mult: 0.1
    decay_mult: 1.0
  }
  param {
    lr_mult: 0.2
    decay_mult: 0.0
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "gaussian"
      std: 0.01
    }
    bias_filler {
      type: "constant"
      value: 0.0
    }
  }
}
layer {
  name: "mmd_fc8"
  type: "MMDLoss"
  bottom: "fc8_office"
  bottom: "label"
  bottom: "weight"
  top: "fc8_office"
  mmd_param {
    num_of_kernel: 10
    mmd_lambda: 0.1
    iter_of_epoch: 32
    method_param {
      top_num: 5
      i_lambda: 0.0
    }
    method: "none"
    kernel_mul: 2.0
    fix_gamma: false
    mmd_lr: 5.0
    quad_weight: 0.0
    mmd_lock: 1
    num_class: 10
    entropy_thresh: 10
  }
}

显然MMDLoss是自定义层，在neuron_layer.hpp 看到MMDLossLayer的定义：

template <typename Dtype>
class NeuronLayer : public Layer<Dtype> {
 public:
  explicit NeuronLayer(const LayerParameter& param)
     : Layer<Dtype>(param) {}
  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
 
  virtual inline int ExactNumBottomBlobs() const { return 1; }
  virtual inline int ExactNumTopBlobs() const { return 1; }
};

template <typename Dtype>
class MMDLossLayer : public NeuronLayer<Dtype> {
 public:
  explicit MMDLossLayer(const LayerParameter& param)
      : NeuronLayer<Dtype>(param){}
  virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);

  virtual inline const char* type() const { return "MMDLoss"; }
  virtual inline int ExactNumBottomBlobs() const { return -1; }
  virtual inline int ExactNumTopBlobs() const { return -1; }

 protected:
  virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);
  virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
  virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
  Dtype* beta_;
  //Dtype* weig_;
  Dtype* sum_of_weig_;
  Blob<Dtype> mmd_data_;
  Dtype mmd_lambda_;
  int input_num_;
  int data_dim_;
  int size_of_source_;
  int size_of_target_;
  Dtype gamma_;
  int num_of_kernel_;
  int* source_index_;
  int* target_index_;
  int iter_of_epoch_;
  int now_iter_;
  int now_iter_test_;
  bool fix_gamma_;
  Dtype** Q_;
  Dtype* sum_of_epoch_;
  Dtype* variance_;
  Dtype I_lambda_;
  int all_sample_num_;
  int top_k_;
  Dtype* sum_of_pure_mmd_;
  int method_number_;
  Dtype kernel_mul_;
  int class_num;
  float mmd_lr_;
  float quad_weight_;
  int mmd_lock_;
  int num_class_;
  int test_inter_;
  int total_iter_test_;
  int total_target_num;
  //for evalutation
  Dtype *count_soft;
  Dtype *avg_entropy;
  int *count_hard;
  int *count_tmp;
  int *source_num_batch;
  int *target_num_batch;
  int *source_num_resamp;
  int *target_num_resamp;
  float cross_entropy;
  float entropy_stand;
  float entropy_thresh_;
};

其次mmd_layer.cpp中有该类方法的实现，和mmd_layer.cu中cuda方法实现，//TODO。
在mmd_layer.cpp中LayerSetUp方法为WMMDLoss层的数据处理和几个method(max,none,L2,max_ratio)的处理。

#include <algorithm>
#include <cfloat>
#include <vector>

#include "caffe/layer.hpp"
#include "caffe/util/math_functions.hpp"
#include "caffe/neuron_layers.hpp"

namespace caffe {

template <typename Dtype>
void MMDLossLayer<Dtype>::LayerSetUp(
    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  NeuronLayer<Dtype>::LayerSetUp(bottom, top);
  input_num_ = bottom[0]->count(0, 1);
  data_dim_ = bottom[0]->count(1);
  num_of_kernel_ = this->layer_param_.mmd_param().num_of_kernel();
  mmd_lambda_ = this->layer_param_.mmd_param().mmd_lambda();
  iter_of_epoch_ = this->layer_param_.mmd_param().iter_of_epoch();
  fix_gamma_ = this->layer_param_.mmd_param().fix_gamma();
  beta_ = new Dtype[num_of_kernel_];
  mmd_lr_ = this->layer_param_.mmd_param().mmd_lr();
  quad_weight_ = this->layer_param_.mmd_param().quad_weight();
  mmd_lock_ = this->layer_param_.mmd_param().mmd_lock();//specify when the weights of each layer need update
  num_class_ = this->layer_param_.mmd_param().num_class();
  test_inter_ = this->layer_param_.mmd_param().test_inter();
  total_iter_test_ = this->layer_param_.mmd_param().total_iter_test();
  //weig_ = new Dtype[10];
  sum_of_weig_ = new Dtype[num_class_];

  caffe_set(num_class_,Dtype(0),sum_of_weig_);
  //caffe_set(10,Dtype(1.0),weig_);
  caffe_set(num_of_kernel_, Dtype(1.0) / num_of_kernel_, beta_);
  now_iter_ = 0;
  now_iter_test_ = 0;

  sum_of_epoch_ = new Dtype[num_of_kernel_];
  caffe_set(num_of_kernel_, Dtype(0), sum_of_epoch_);
  gamma_ = Dtype(-1);
  Q_ = new Dtype* [num_of_kernel_];
  for(int i = 0; i < num_of_kernel_; i++){
      Q_[i] = new Dtype[num_of_kernel_];
      caffe_set(num_of_kernel_, Dtype(0), Q_[i]);
  }
  variance_ = new Dtype[num_of_kernel_];
  caffe_set(num_of_kernel_, Dtype(0), variance_);
  sum_of_pure_mmd_ = new Dtype[num_of_kernel_];
  caffe_set(num_of_kernel_, Dtype(0), sum_of_pure_mmd_);
  all_sample_num_ = 0;
  total_target_num = 0;
  kernel_mul_ = this->layer_param_.mmd_param().kernel_mul();
  if(this->layer_param_.mmd_param().method() == "max"){
        method_number_ = 1;
        top_k_ = this->layer_param_.mmd_param().method_param().top_num();
  }
  else if(this->layer_param_.mmd_param().method() == "none"){
        method_number_ = 0;
  }
  else if(this->layer_param_.mmd_param().method() == "L2"){
        method_number_ = 4;
        top_k_ = this->layer_param_.mmd_param().method_param().top_num();
        I_lambda_ = this->layer_param_.mmd_param().method_param().i_lambda();
  }
  else if(this->layer_param_.mmd_param().method() == "max_ratio"){
        top_k_ = this->layer_param_.mmd_param().method_param().top_num();
        method_number_ = 3;
  }
  LOG(INFO) << this->layer_param_.mmd_param().method() << " num: " << method_number_;
  source_index_ = new int[input_num_];
  target_index_ = new int[input_num_];

  mmd_data_.Reshape(1, 1, 1, data_dim_);

  class_num = bottom[2]->count(0);

  count_soft = new Dtype[class_num];
  avg_entropy = new Dtype[class_num];
  count_tmp = new int [class_num];
  caffe_set(class_num,Dtype(0.0),count_soft);
  caffe_set(class_num,Dtype(0.0),avg_entropy);
  count_hard = new int[class_num];
  caffe_set(class_num,0,count_hard);
  caffe_set (class_num,0,count_tmp);
  source_num_batch = new int[class_num];
  target_num_batch = new int[class_num];
  source_num_resamp = new int[class_num];
  target_num_resamp= new int[class_num];
  caffe_set(class_num,0,source_num_batch);
  caffe_set(class_num,0,target_num_batch);
  caffe_set(class_num,0,source_num_resamp);
  caffe_set(class_num,0,target_num_resamp);
  cross_entropy = 0.0;
  entropy_stand = 1.0;//for all class
  entropy_thresh_ = this->layer_param_.mmd_param().entropy_thresh();//for every sample

}

template <typename Dtype>
void MMDLossLayer<Dtype>::Reshape(
    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  NeuronLayer<Dtype>::Reshape(bottom, top);
}

template <typename Dtype>
void MMDLossLayer<Dtype>::Forward_cpu(
  const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
}

template <typename Dtype>
void MMDLossLayer<Dtype>::Backward_cpu(
  const vector<Blob<Dtype>*>& top, const vector<bool>& propagate_down,
  const vector<Blob<Dtype>*>& bottom) {
}

#ifdef CPU_ONLY
STUB_GPU(MMDLossLayer);
#endif

INSTANTIATE_CLASS(MMDLossLayer);
REGISTER_LAYER_CLASS(MMDLoss);

}

作者其它修改的地方

  • mmd layer: the backward function in mmd_layer.cu is adjusted to replace the conventional mmd with weighted mmd specified in the paper
  • softmax loss layer: Instead of ignoring the empirical loss on target domain, we modified the function so that logistic loss is added based on pseudo label.
  • data layer: we add an parameter to the data label so that the number of classes is conveyed to mmd layer.

datalayer

作者修改了image_data_layer.cpp，以提供一个新的top输出-weight，所以在datalayer有三个top输出，所以在声明ImageDataLayer的地方，ExactNumTopBlobs返回值从2修改为3，以下是主要修改的地方：

template <typename Dtype>
class ImageDataLayer : public BasePrefetchingDataLayer<Dtype> {
 public:
  explicit ImageDataLayer(const LayerParameter& param)
      : BasePrefetchingDataLayer<Dtype>(param) {}
  virtual ~ImageDataLayer();
  virtual void DataLayerSetUp(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);

  virtual inline const char* type() const { return "ImageData"; }
  virtual inline int ExactNumBottomBlobs() const { return 0; }
  virtual inline int ExactNumTopBlobs() const { return 3; }

 protected:
  shared_ptr<Caffe::RNG> prefetch_rng_;
  virtual void ShuffleImages();
  virtual void InternalThreadEntry();

  vector<std::pair<std::string, int*> > lines_;
  int lines_id_;
};

  // image
  const int crop_size = this->layer_param_.transform_param().crop_size();
  const int batch_size = this->layer_param_.image_data_param().batch_size();
  if (crop_size > 0) {
    top[0]->Reshape(batch_size, channels, crop_size, crop_size);
    this->prefetch_data_.Reshape(batch_size, channels, crop_size, crop_size);
    this->transformed_data_.Reshape(1, channels, crop_size, crop_size);
  } else {
    top[0]->Reshape(batch_size, channels, height, width);
    this->prefetch_data_.Reshape(batch_size, channels, height, width);
    this->transformed_data_.Reshape(1, channels, height, width);
  }
  LOG(INFO) << "output data size: " << top[0]->num() << ","
      << top[0]->channels() << "," << top[0]->height() << ","
      << top[0]->width();
  // label
  vector<int> label_shape;
  label_shape.push_back(batch_size);
  label_shape.push_back(label_dim);
  top[1]->Reshape(label_shape);
  this->prefetch_label_.Reshape(label_shape);
  //weight_
  vector<int> weight_shape;
  weight_shape.push_back(class_num);
  top[2]->Reshape(weight_shape);
  this->prefetch_weight_.Reshape(weight_shape);

  Dtype* top_weight_= top[2]->mutable_cpu_data();
  Dtype* prefetch_weight = this->prefetch_weight_.mutable_cpu_data();
  caffe_set(class_num,Dtype(1.0/class_num),top_weight_);
  caffe_copy(class_num,top[2]->cpu_data(),prefetch_weight);
WHQ_
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最优传输论文（三十）：Mind the Class Weight Bias: Weighted Maximum Mean Discrepancy for Unsupervised Domai论文原理
lyy的博客
09-03 339
文章目录前言摘要1. Introduction2. Preliminaries and Related Work2.1. MMD and Its Application in Domain Adaptation2.2. Metrics for Domain Discrepancy3. Weighted Maximum Mean Discrepancy4. Weighted Domain Adaptation Network5. Experiments5.1. Comparison with State-of
domain adaptation 之 Maximun Mean discrepancy （一）
钉马掌的小铁匠的博客
08-06 457
一、小数据集的过拟合问题 我们现在了解到的是深度学习适合于大规模数据的应用，而在小规模的数据上易出现过拟合。深度学习的特点是它擅于记忆，它能非常出色地基础训练数据的数据特征，从而在训练的数据上表现优异。在针对特定任务时，大规模的数据往往能涵盖特征空间的绝大部分，此时的训练集的特征空间往往与验证集的特征空间高度重合，深度学习模型在记住训练集特征的同时也就记住了验证集特征，以至于在训练集表现优秀的模型在验证集数据上也能表现很好。但是小规模的数据集通常只占据特定任务特征空间的一部分，此时划分的训练集和验证集的特征
《Weighted Maximum Mean Discrepancy for Unsupervised Domain Adaptation》论文阅读
big_yellow_man的博客
06-27 1988
摘要 在区域自适应（domain adaptation）中，最大平均差(maximum mean discrepancy，MMD)作为源域和目标域分布的一种差异度量方法被广泛采用，然而，现有的基于MMD的域自适应方法通常忽略了类先验分布的变化，比如跨域的类权重偏差（class weight bias across domains），对于领域适应来说是普遍存在的，作者认为这可能是由于样本选择标准和应...
[cvpr2017]Mind the Class Weight Bias: Weighted Maximum Mean Discrepancy for Unsupervised DA
MataFela的博客
08-21 3244
introduce 作者认为使用MMD（maximum mean discrepancy）来衡量source domain和target domain之间的差异不够准确，这是因为没有考虑class prior distributions（类的先验分布？），为了解决这个问题，作者提出了一个叫做weighted MMD（WMMD）的模型。（Despite the great success achie
domain-adaptation
05-01
极域适应 此仓库是关于domian适应的令人敬畏的事物的集合，包括论文，代码等。您可以随意编辑。 内容 概述 深度视觉域适应：一项调查 视觉应用程序的域适应：全面调查 理论 域适应表示的分析[NIPS2006] 从不同领域学习的理论[ML2010] 域适应的学习界限[NIPS2007] 对抗DA M-ADDA：采用深度度量学习的无监督域自适应[arXiv 2018年7月6日] [Pytorch（官方）] 领域适应的增强循环对抗学习[arXiv 2018年7月1日] 用于无监督域自适应的分解式对抗网络[arXiv 4 Jun 2018] DiDA：用于域适应的解缠结合成[arXiv 21 May 2018] 对抗性残差变换网络的无监督域自适应[arXiv 25 Apr 2018] 具有类预测不确定性对齐的简单域适配[arXiv 2018年4月12日] 因果生成域适应网
DNA Self-Assembly for Maximum Weighted Independent Set Problem
02-21
DNA Self-Assembly for Maximum Weighted Independent Set Problem
AWMF for Salt and Pepper噪声去除：论文代码“A New Adaptive Weighted Mean Filter for Removing Salt-and-Pepper Noise”-matlab开发
05-29
用于去除椒盐噪声的 AWMF 滤波器的源代码。 结果很有希望。 参考论文：P. Zhang 和 F. Li，A New Adaptive Weighted Mean Filter for Removing 椒盐噪声，SPL 2014。
domain adaptation.rar
10-11
DANN（Domain Adversarial Neural Network）、RTN（Relevant Transfer Network）、DARN（Deep Adaptation Network）、MDAN（Multi-Task Domain Adaptation Network）、MWGAN（Margin Weighted Generative ...
Inverse Variance Weighted Mean:Inverse Variance Weighted Mean-matlab开发
05-29
反方差加权均值通常用于统计分析中，尤其是要考虑汇总或编译的数据集中不确定性的变化。 y = ivwmean(x,var) 返回由方差“var”的倒数加权的“x”元素的逆方差加权平均值 笔记“x”的每个元素都需要相应的方差，因此...
Weighted Graph Based Description for Finger-vein Recognition
02-11
Weighted Graph Based Description for Finger-vein Recognition
Mean Maximum Discrepancy计算代码 pytorch代码
04-09
Mean Maximum Discrepancy计算代码，分为线性核和高斯核两种，以pytorch书写的
MMD_mean_mmd_discrepancy_weekarq_最大均值差异
09-11
利用matlab来实现Maximum Mean Discrepancy（最大均值差异）的计算。
UnsupervisedMT：基于短语和神经的无监督机器翻译
02-25
无监督机器翻译 该存储库包含以下示例中提供的无监督PBSMT和NMT模型的原始实现： （EMNLP 2018）。 注意：对于NMT方法，我们建议您看一下和相关的GitHub存储库 ，其中包含更好的模型和更有效的无监督机器翻译实现。 NMT实现支持： 三种机器翻译架构（seq2seq，biLSTM +注意，Transformer） 能够跨模型/语言共享任意数量的参数 去噪自动编码器培训 并行数据训练 反向并行数据训练 动态多线程生成反向并行数据 以及原始论文中未使用的其他功能（留作以后的工作）： 培训期间任意语言 语言模型预训练/共享参数共同训练 对抗训练 PBSMT实现支持： 无监督短语表生成脚本 摩西自动化培训 依存关系 Python 3 （当前在版本0.5上进行测试） （干净并标记化文本/训练PBSMT模型） （生成并应用BPE代码） （生成嵌入） （生成跨
Maximum Mean Discrepancy理解
tunhuzhuang1836的博客
09-21 2万+
MMD
MMD ：maximum mean discrepancy
热门推荐
easylifer的专栏
05-27 4万+
MMD最先提出的时候用于双样本的检测（two-sample test）问题，用于判断两个分布p和q是否相同。它的基本假设是：如果对于所有以分布生成的样本空间为输入的函数f，如果两个分布生成的足够多的样本在f上的对应的像的均值都相等，那么那么可以认为这两个分布是同一个分布。现在一般用于度量两个分布之间的相似性。在[1]中从任意空间到RKHS上介绍了MMD的计算，这里根据这个顺序来介绍。
基于matlab的fisher线性判别及感知器判别_Deep Domain Adaptation论文集(一)：基于label迁移知识...
weixin_39741101的博客
11-19 193
本系列简单梳理一下《Deep Visual Domain Adaptation: A Survey》这篇综述文章的内容，囊括了现在用深度网络做领域自适应DA(Domain Adaptation)的各个方面的一些文章。原文链接：Deep Visual Domain Adaptation: A SurveyClass Criterion类别准则：使用标签信息作为指导在不同领域之间迁移知识Distill...
【机器学习】最大均值差异MMD详解
zkq_1986的博客
01-08 1万+
引言 最大均值差异(maximum mean discrepancy, MMD)提出时候是用来测试两个样本，是否来自两个不同分布p和q，如果均值差异达到最大，就说明采样的样本来自完全不同的分布。 原理 MMD的基本原理如下所述：假设有一个满足P分布的数据集Xs=[xs1,...,xsn]和一个满足Q分布的数据集Xt=[xt1,...,xtm] 并且存在一个再生希尔伯特空间H(RKHS) 存在...
[论文阅读笔记@2019.6] Maximum Classifier Discrepancy for Unsupervised Domain Adaptation
quyan的博客
12-23 4139
文章目录[论文阅读笔记@2019.6] Maximum Classifier Discrepancy for Unsupervised Domain Adaptation1. IntroductionPrevious Methods:However:Proposed Method:2. Related Work3. Method3.1 Overall Idea要让生成器的特征更远离分类边界（靠近源...
[cvpr2017]Deep Hashing Network for Unsupervised Domain Adaptation
MataFela的博客
08-31 1904
introduction 作者的框架（Domain Adaptive Hashing (DAH) ）通过学习source domain和target domain的信息哈希码来进行分类（数据量很庞大，所以考虑到了哈希，可以利用哈希的快速查询和低内存使用）。 作者在一个新的数据集——Office-Home——上进行试验，这个数据集有来自4个域的图像信息（15500图像65个类），作者希望正式自己的算法
multi-channel weighted nuclear norm minimization for real color image denois
最新发布
11-07
多通道加权核范数最小化是一种用于真实彩色图像去噪的方法。在图像去噪过程中，由于颜色信息的存在，图像可以被视为多通道数据。传统的图像去噪方法通常将图像视为灰度图像进行处理，忽略了颜色信息的重要性。而多通道加权核范数最小化通过考虑颜色通道间的相关性，在去噪过程中更准确地保留了图像的颜色信息。 该方法的核心思想是使用核范数作为正则化项来追求平滑的图像结果，并通过加权项来平衡各个颜色通道的重要性。核范数是矩阵的一种范数，在这里用于约束图像的平滑性，从而实现去噪处理。通过对多通道图像的颜色通道进行适当的加权，可以保证各个通道的平滑性能够得到更好的平衡。 该方法相比于传统的灰度图像去噪方法，在保持图像细节的同时更好地保持了图像的颜色特性。此外，由于采用了核范数最小化的方法，能够有效地去除图像中的噪声，并减轻图像模糊等问题。 综上所述，多通道加权核范数最小化是一种适用于真实彩色图像去噪的方法。通过考虑多通道颜色信息和加权核范数约束，该方法能够更准确地去除图像噪声，保留图像的细节和颜色特性。这种方法在实际的图像处理中具有潜在的应用价值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值