最近对主动学习有需求，特地看了一些博客，明天准备看看相关的文章

个人理解：
目前AI领域的学习方式分为有监督，无监督，半监督，主动学习，这里列一下他们之间的不同

其实中间还有个弱监督，但是提的较少或者这个和半监督很相似归为一类了。

什么是主动学习：
主动学习目的是根据策略主动筛选出最有价值的未标注样本，给专家进行标注，在保证模型性能不下降的情况下尽量减少标注成本。这一需求在语音识别，医学图像处理方面有着极大的需求。

为什么要运用主动学习：
1.大量的深度学习模型需要数据作为输入，但是很多一部分是要标记数据做输入进行监督学习，虽然有些算法是无监督学习，但是效果并不是很理想。这就需要大量的标注，标注是非常消耗时间和money的，所以尽可能的少标数据同时效果不下降就很重要了，主动学习就很好的满足了这一点。
2.一般送入的数据足够多，网络参数训练的越充分，但是巨大的数据消耗训练时间，GPU资源，很多数据还在训练之前做增强。但是有相当一部分数据增强是无效冗余的，不仅每提高模型质量，反而增加了训练时间。

主动学习框架

小记python中的深拷贝与浅拷贝

浅拷贝：简单理解就是赋值操作，拷贝了引用
你变我也变，我俩指向了同一片内存空间。

In [7]: a = [1, 2, 3, 4]                                                        
In [8]: b = a                                                                   
In [9]: b                                                                       
Out[9]: [1, 2, 3, 4]
In [10]: a                                                                      
Out[10]: [1, 2, 3, 4]
In [11]: a.append(0)                                                            
In [12]: a                                                                      
Out[12]: [1, 2, 3, 4, 0]
In [13]: b                                                                      
Out[13]: [1, 2, 3, 4, 0]
In [14]: id(a)                                                                  
Out[14]: 139897924776968
In [15]: id(b)                                                                  
Out[15]: 139897924776968

深拷贝
深拷贝是重新开辟一个内存空间，同时将你里面的内容也复制过来，并且深拷贝是递归复制。

In [17]: import copy                                                            
In [18]: a = [1, 2, 3]                                                          
In [19]: b = copy.deepcopy(a)                                                   
In [20]: a                                                                      
Out[20]: [1, 2, 3]
In [21]: b                                                                      
Out[21]: [1, 2, 3]
In [22]: a.append(0)                                                            
In [23]: a                                                                      
Out[23]: [1, 2, 3, 0]
In [24]: b                                                                      
Out[24]: [1, 2, 3]
In [25]: id(a)                                                                  
Out[25]: 139897926146696
In [26]: id(b)                                                                  
Out[26]: 139897935482312

深拷贝递归复制

In [33]: a = [1, 2]                                                             
In [34]: b = [11, 22]                                                           
In [35]: c = [a, b]                                                             
In [36]: import copy                                                            
In [37]: d = copy.deepcopy(c)                                                   
In [38]: c                                                                      
Out[38]: [[1, 2], [11, 22]]
In [39]: c                                                                      
Out[39]: [[1, 2], [11, 22]]
In [40]: a.append(0)                                                            
In [41]: d                                                                      
Out[41]: [[1, 2], [11, 22]]
In [42]: c                                                                      
Out[42]: [[1, 2, 0], [11, 22]]

copy.copy()
当复制的对象是可变类型时，　copy.copy()相当于深拷贝，当其为不可变类型时是浅拷贝

c = [a, b]                                                             
In [50]: d = copy.copy(c)                                                       
In [51]: c                                                                      
Out[51]: [[1, 2], [11, 22]]
In [52]: d                                                                      
Out[52]: [[1, 2], [11, 22]]
In [53]: id(c)                                                                  
Out[53]: 139897924794248
In [54]: id(d)                                                                  
Out[54]: 139897904219080
e = (a, b)                                                             
In [58]: f = copy.copy(e)                                                       
In [59]: id(e)                                                                  
Out[59]: 139897895878600
In [60]: id(f)                                                                  
Out[60]: 139897895878600