論文從理論的角度出發，對目標檢測的域自適應問題進行了深入的研究，基於H-divergence的對抗訓練提出了DA Faster R-CNN，從圖片級和實例級兩種角度進行域對齊，並且加入一致性正則化來學習域不變的RPN。從實驗來看，論文的方法十分有效，這是一個很符合實際需求的研究，能解決現實中場景多樣，訓練數據標註有限的情況。
 
來源：曉飛的算法工程筆記 公眾號

論文: Domain Adaptive Faster R-CNN for Object Detection in the Wild

• 論文地址：https://arxiv.org/pdf/1803.03243.pdf
• 論文代碼：https://github.com/yuhuayc/da-faster-rcnn

Introduction

  目前，目標檢測算法在公開數據上有很好的表現，但在現實世界環境中通常會有許多特殊的挑戰，比如視角、物體外觀、背景、光照以及圖片質量的不同，使得測試數據和訓練數據存在較大的跨偏移問題。

  以自動駕駛為例，不同的公開數據集里的圖片存在較大的差異，域偏移問題會導致明顯的檢測器性能下降。儘管收集更多的訓練圖片能解決域偏移的影響，但顯然這不是最好的方案。
  為了解決上面的問題，論文提出Domain Adaptive Faster R-CNN，最小化圖片級別域偏移(圖片尺寸、圖片風格、光照等)以及實例級域偏移(目標外表、目標尺寸等)，每個模塊學習一個域分類器並且通過對抗訓練學習域不變的特徵，並且加入分類器的一致性正則化來保證RPN學習到域不變的proposal。
  論文的主要貢獻如下：

• 從概率角度對跨域目標檢測中的域偏移問題進行理論分析。
• 設計了兩個域自適應模塊來消除圖片級別和實例級別的域差異。
• 提出一致性正則化來學習域不變RPN。
• 將提出的模塊集成到Faster R-CNN中，進行端到端的訓練。

Distribution Alignment with H-divergence

  論文設計了H-divergence度量兩個不同分佈的樣本集，定義$x$為特徵向量，$x_{\mathcal{S}}$為源域樣本$x_{\mathcal{T}}$為目標域樣本，$h:x\to {0,1}$為域分類器，預測源域樣本$x_{\mathcal{S}}$為0，預測目標域樣本$x_{\mathcal{T}}$為1。假設$\mathcal{H}$為一組域分類器，則H-divergence的定義為：

  $err_{\mathcal{S}}$和$err_{\mathcal{T}}$為$h(x)$在源域和目標域樣本的預測誤差，上述的公式意味着域距離$d_{\mathcal{H}}(\mathcal{S},\mathcal{T})$與域分類器的錯誤率成反比，若最好的域分類器的錯誤率越高，則源域和目標域的距離越近。
  在神經網絡中，定義網絡$f$產生特徵向量$x$，為了進行域對齊，需要網絡$f$產生能夠減小域距離$d_{\mathcal{H}}(\mathcal{S},\mathcal{T})$的特徵向量，即最小化公式：

  上述的公式可以通過對抗訓練進行優化，論文採用gradient reverse
layer(GRL)進行實現，訓練主幹特徵最大化域分類誤差並且訓練域分類器最小域分類誤差進行對抗訓練，最終得出魯棒的特徵。

Domain Adaptation for Object Detection

A Probabilistic Perspective

  目標檢測問題可表示為後驗概率$P(C, B|I)$，$I$為圖片，$B$為目標的bbox，$C\in {1,\cdots,K}$為目標類別。定義目標檢測的樣本的聯合分佈為$P(C,B,I)$，其中源域和目標域的分佈是不一樣的$P_{\mathcal{S}}(C,B,I) \neq P_{\mathcal{T}}(C,B,I)$

• Image-Level Adaptation

  根據貝恭弘=叶 恭弘斯公式，目標檢測的聯合分佈可定義為

  定義目標檢測為covariate shift假設，設定域間的條件概率$P(C, B|I)$是一樣的，域分佈偏移主要來自於$P(I)$分佈的不同。在Faster R-CNN中，$P(I)$即從圖片提取的特徵，所以要解決域偏移問題，就要控制$P_{\mathcal{S}}(I)=P_{\mathcal{T}}(I)$，保證不同域的圖片提取的特徵一致。

• Instance-Level Adaptation

  另一方面，目標檢測的聯合分佈也可以定義為

  基於covariate shift假設，設定域間的條件概率$P(C|B,I)$是一樣的，域分佈偏移主要來自於$P(B,I)$分佈的不同，而$P(B,I)$即圖像中bbox區域特徵，所以為了解決域偏移問題，需要控制$P_{\mathcal{S}}(B,I)=P_{\mathcal{T}}(B,I)$，保證不同域的圖片提取的相同目標的bbox特徵不變。
  需要注意的是，目標域是沒有標註信息的，只能通過$P(B,I)=P(B|I)P(I)$獲取，$P(B|I)$為bbox預測器，這樣就需要RPN具備域不變性，為此，論文再添加了Joint Adaptation。

• Joint Adaptation

  考慮到$P(B,I)=P(B|I)P(I)$，而分佈$P(B|I)$是域不變且非零的，因此有

  若域間的圖片級特徵的分佈是一樣的，實例級特徵的分佈也應該是一樣的。但實際中很難達到完美的$P(B|I)$，首先$P(I)$分佈很難完美地對齊，導致$P(B|I)$的輸入有偏，其次bbox是從源域學習而來的，會存在一定地偏差。
  為此，論文使用一致性正則化來消除$P(B|I)$的偏置，使用域分類器$h(x)$來進行源域和目標域的判斷。定義域標籤為$D$，圖像級分類器可看為預測$P(D|I)$，實例級的分類器可看為預測$P(D|B,I)$。根據貝恭弘=叶 恭弘斯理論，得到

  其中，$P(B|I)$是域不變的bbox預測器，而$P(B|D,I)$為域相關的bbox預測器。由於目標域沒有標註的bbox，所以實際僅學習到域相關的bbox預測器$P(B|D,I)$。但可以通過強制兩種分類器的一致性$P(D|B,I)=P(D|I)$，使得$P(B|D,I)$逼近$P(B|I)$。

Domain Adaptation Components

  DA Faster R-CNN的架構如圖2所示，包含兩個域自適應模塊以及一致性正則化模塊，自適應模塊加入GRL(gradient reverse layer)進行對抗訓練，每個模塊包含一個域分類器，最終的損失函數為

• Image-Level Adaptation

  為了消除圖片級域分佈不匹配，使用patch-based域分類器對特徵圖的每個特徵點進行分類，每個特徵點實際對應原圖的一片區域$I_i$，這樣特徵點域分類器就等同於預測了每個圖像中每個patch的域標籤，這樣的好處在於：

• 圖片級表達的對齊通常能有助於消除整圖帶來的偏移。
• 由於目標檢測算法的batch size通常很小，path-based能夠提高域分類器的訓練樣本數。

  定義$D_i$為第$i$個訓練圖片的域標籤，$\phi_{u,v}(I_i)$為特徵圖上的一個激活值，$p^{(u,v)}_i$為域分類器的一個輸出，則圖片級自適應損失為

  為了對齊域分佈，需要同時優化域分類器最小化域分類損失以及優化主幹網絡的參數最大化域分類損失進行對抗訓練，論文採用GRL進行實現，使用梯度下降來訓練域分類器，回傳梯度給主幹時將梯度置為反符號。

• Instance-Level Adaptation

  實例級特徵對齊有助於減少實例的局部差異，比如外表，大小，視角等。跟圖片級特徵對齊類似，定義$p_{i,j}$為第$i$個圖片的第$j$個proposal，實例級的自適應損失為

  同樣的，在域分類器前添加GRL模塊進行對抗訓練。

• Consistency Regularization

  如前面的分析，強制域分類器的一致性有助於學習魯棒的跨域bbox預測器，加入一致性正則化。由於圖片級域分類器是對特徵值進行分類的，取平均輸出作為圖片級概率，一致性正則化為

  其中$|I|$為特徵圖的點數，$||\cdot||$為$\mathcal{l}_2$距離。

Experiments

Learning from Synthetic Data

  SIM 10k是從GTAV中截取畫面進行標註的數據集，Cityscapes為真實圖片，這裏對比從生成圖片到真實圖片的域轉移。

Driving in Adverse Weather

  Foggy Cityscapes通過生成霧來模擬真實場景，這裏對比天氣帶來的域轉移。

Cross Camera Adaptation

  這裏對比兩個不同的訓練數據集的域對齊。

Error Analysis on Top Ranked Detections

  每個模塊都能提升一定的準確率，而圖片級對齊的背景錯誤率較高，這可能由於圖片級對齊對RPN的提升更直接。

Image-level v.s. Instance-level Alignment

Consistency Regularization

CONCLUSION

  論文從理論的角度出發，對目標檢測的域自適應問題進行了深入的研究，基於H-divergence的對抗訓練提出了DA Faster R-CNN，從圖片級和實例級兩種角度進行域對齊，並且加入一致性正則化來學習域不變的RPN。從實驗來看，論文的方法十分有效，這是一個很符合實際需求的研究，能解決現實中場景多樣，訓練數據標註有限的情況。

 
 
 

如果本文對你有幫助，麻煩點個贊或在看唄～
更多內容請關注 微信公眾號【曉飛的算法工程筆記】

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?

介紹

先說一下什麼是循環依賴，Spring在初始化A的時候需要注入B，而初始化B的時候需要注入A，在Spring啟動后這2個Bean都要被初始化完成

Spring的循環依賴有兩種場景

1. 構造器的循環依賴
2. 屬性的循環依賴

構造器的循環依賴，可以在構造函數中使用@Lazy註解延遲加載。在注入依賴時，先注入代理對象，當首次使用時再創建對象完成注入

屬性的循環依賴主要是通過3個map來解決的

構造器的循環依賴

@Component
public class ConstructorA {

	private ConstructorB constructorB;

	@Autowired
	public ConstructorA(ConstructorB constructorB) {
		this.constructorB = constructorB;
	}
}

@Component
public class ConstructorB {

	private ConstructorA constructorA;

	@Autowired
	public ConstructorB(ConstructorA constructorA) {
		this.constructorA = constructorA;
	}
}

@Configuration
@ComponentScan("com.javashitang.dependency.constructor")
public class ConstructorConfig {
}

public class ConstructorMain {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context =
				new AnnotationConfigApplicationContext(ConstructorConfig.class);
		System.out.println(context.getBean(ConstructorA.class));
		System.out.println(context.getBean(ConstructorB.class));
	}
}

運行ConstructorMain的main方法的時候會在第一行就報異常，說明Spring沒辦法初始化所有的Bean，即上面這種形式的循環依賴Spring無法解決。

我們可以在ConstructorA或者ConstructorB構造函數的參數上加上@Lazy註解就可以解決

@Autowired
public ConstructorB(@Lazy ConstructorA constructorA) {
	this.constructorA = constructorA;
}

因為我們主要關注屬性的循環依賴，構造器的循環依賴就不做過多分析了

屬性的循環依賴

先演示一下什麼是屬性的循環依賴

@Component
public class FieldA {

	@Autowired
	private FieldB fieldB;
}

@Component
public class FieldB {

	@Autowired
	private FieldA fieldA;
}

@Configuration
@ComponentScan("com.javashitang.dependency.field")
public class FieldConfig {
}

public class FieldMain {

	public static void main(String[] args) {
		AnnotationConfigApplicationContext context =
				new AnnotationConfigApplicationContext(FieldConfig.class);
		// com.javashitang.dependency.field.FieldA@3aa9e816
		System.out.println(context.getBean(FieldA.class));
		// com.javashitang.dependency.field.FieldB@17d99928
		System.out.println(context.getBean(FieldB.class));
	}
}

Spring容器正常啟動，能獲取到FieldA和FieldB這2個Bean

屬性的循環依賴在面試中還是經常被問到的。總體來說也不複雜，但是涉及到Spring Bean的初始化過程，所以感覺比較複雜，我寫個demo演示一下整個過程

Spring的Bean的初始化過程其實比較複雜，為了方便理解Demo，我就把Spring Bean的初始化過程分為2部分

1. bean的實例化過程，即調用構造函數將對象創建出來
2. bean的初始化過程，即填充bean的各種屬性

bean初始化過程完畢，則bean就能被正常創建出來了

下面開始寫Demo，ObjectFactory接口用來生產Bean，和Spring中定義的接口一樣

public interface ObjectFactory<T> {
	T getObject();
}

public class DependencyDemo {

	// 初始化完畢的Bean
	private final Map<String, Object> singletonObjects =
			new ConcurrentHashMap<>(256);

	// 正在初始化的Bean對應的工廠，此時對象已經被實例化
	private final Map<String, ObjectFactory<?>> singletonFactories =
			new HashMap<>(16);

	// 存放正在初始化的Bean，對象還沒有被實例化之前就放進來了
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	public  <T> T getBean(Class<T> beanClass) throws Exception {
		// 類名為Bean的名字
		String beanName = beanClass.getSimpleName();
		// 已經初始化好了，或者正在初始化
		Object initObj = getSingleton(beanName, true);
		if (initObj != null) {
			return (T) initObj;
		}
		// bean正在被初始化
		singletonsCurrentlyInCreation.add(beanName);
		// 實例化bean
		Object object = beanClass.getDeclaredConstructor().newInstance();
		singletonFactories.put(beanName, () -> {
			return object;
		});
		// 開始初始化bean，即填充屬性
		Field[] fields = object.getClass().getDeclaredFields();
		for (Field field : fields) {
			field.setAccessible(true);
			// 獲取需要注入字段的class
			Class<?> fieldClass = field.getType();
			field.set(object, getBean(fieldClass));
		}
		// 初始化完畢
		singletonObjects.put(beanName, object);
		singletonsCurrentlyInCreation.remove(beanName);
		return (T) object;
	}

	/**
	 * allowEarlyReference參數的含義是Spring是否允許循環依賴，默認為true
	 * 所以當allowEarlyReference設置為false的時候，當項目存在循環依賴，會啟動失敗
	 */
	public Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null 
				&& isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory =
							this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
					}
				}
			}
		}
		return singletonObject;
	}

	/**
	 * 判斷bean是否正在被初始化
	 */
	public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}

}

測試一波

public static void main(String[] args) throws Exception {
	DependencyDemo dependencyDemo = new DependencyDemo();
	// 假裝掃描出來的對象
	Class[] classes = {A.class, B.class};
	// 假裝項目初始化所有bean
	for (Class aClass : classes) {
		dependencyDemo.getBean(aClass);
	}
	// true
	System.out.println(
			dependencyDemo.getBean(B.class).getA() == dependencyDemo.getBean(A.class));
	// true
	System.out.println(
			dependencyDemo.getBean(A.class).getB() == dependencyDemo.getBean(B.class));
}

是不是很簡單？我們只用了2個map就搞定了Spring的循環依賴

2個Map就能搞定循環依賴，那為什麼Spring要用3個Map呢？

原因其實也很簡單，當我們從singletonFactories中根據BeanName獲取相應的ObjectFactory，然後調用getObject()這個方法返回對應的Bean。在我們的例子中
ObjectFactory的實現很簡單哈，就是將實例化好的對象直接返回，但是在Spring中就沒有這麼簡單了，執行過程比較複雜，為了避免每次拿到ObjectFactory然後調用getObject()，我們直接把ObjectFactory創建的對象緩存起來不就行了，這樣就能提高效率了

比如A依賴B和C，B和C又依賴A，如果不做緩存那麼初始化B和C都會調用A對應的ObjectFactory的getObject()方法。如果做緩存只需要B或者C調用一次即可。

知道了思路，我們把上面的代碼改一波，加個緩存。

public class DependencyDemo {

	// 初始化完畢的Bean
	private final Map<String, Object> singletonObjects =
			new ConcurrentHashMap<>(256);

	// 正在初始化的Bean對應的工廠，此時對象已經被實例化
	private final Map<String, ObjectFactory<?>> singletonFactories =
			new HashMap<>(16);

	// 緩存Bean對應的工廠生產好的Bean
	private final Map<String, Object> earlySingletonObjects =
			new HashMap<>(16);

	// 存放正在初始化的Bean，對象還沒有被實例化之前就放進來了
	private final Set<String> singletonsCurrentlyInCreation =
			Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	public  <T> T getBean(Class<T> beanClass) throws Exception {
		// 類名為Bean的名字
		String beanName = beanClass.getSimpleName();
		// 已經初始化好了，或者正在初始化
		Object initObj = getSingleton(beanName, true);
		if (initObj != null) {
			return (T) initObj;
		}
		// bean正在被初始化
		singletonsCurrentlyInCreation.add(beanName);
		// 實例化bean
		Object object = beanClass.getDeclaredConstructor().newInstance();
		singletonFactories.put(beanName, () -> {
			return object;
		});
		// 開始初始化bean，即填充屬性
		Field[] fields = object.getClass().getDeclaredFields();
		for (Field field : fields) {
			field.setAccessible(true);
			// 獲取需要注入字段的class
			Class<?> fieldClass = field.getType();
			field.set(object, getBean(fieldClass));
		}
		singletonObjects.put(beanName, object);
		singletonsCurrentlyInCreation.remove(beanName);
		earlySingletonObjects.remove(beanName);
		return (T) object;
	}

	/**
	 * allowEarlyReference參數的含義是Spring是否允許循環依賴，默認為true
	 */
	public Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null
				&& isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory =
							this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}
}

我們寫的getSingleton的實現和org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton(java.lang.String, boolean)的實現一模一樣，這個方法幾乎所有分析Spring循環依賴的文章都會提到，這次你明白工作原理是什麼了把

總結一波

1. 拿bean的時候先從singletonObjects（一級緩存）中獲取
2. 如果獲取不到，並且對象正在創建中，就從earlySingletonObjects（二級緩存）中獲取
3. 如果還是獲取不到就從singletonFactories（三級緩存）中獲取，然後將獲取到的對象放到earlySingletonObjects（二級緩存）中，並且將bean對應的singletonFactories（三級緩存）清除
4. bean初始化完畢，放到singletonObjects（一級緩存）中，將bean對應的earlySingletonObjects（二級緩存）清除

歡迎關注

參考博客

[1]https://mp.weixin.qq.com/s/gBr3UfC1HRcw4U-ZMmtRaQ
[2]https://mp.weixin.qq.com/s/5mwkgJB7GyLdKDgzijyvXw
比較詳細
[1]https://zhuanlan.zhihu.com/p/84267654
[2]https://juejin.im/post/5c98a7b4f265da60ee12e9b2

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※教你寫出一流的銷售文案?