数据增强代码实践，补一点多进程，多线程的知识点

目前最先进的神经网络模型，其本质上也是在利用一系列线性和非线性的函数去拟合目标输出。既然是拟合，当然越多的样本就能获得越准确的结果，这也是为什么现在训练神经网络所使用的数据规模越来越大。
在实际使用中，我们往往可能只有几千甚至几百份数据。面对神经网络数以 M 计的参数，很容易陷入过拟合的陷阱。因为神经网络的收敛需要一个较长的训练过程，而这个过程中网络遇到的反反复复都是训练集的那几张图片，硬背都背下来了，自然很难学到什么能够泛化的特征。一个自然的想法是，能不能用一张图片去生成一系列图片，从而成百上千倍地扩充我们的数据集？而这，也正是数据增强的目的之一。
神经网络是没有常识的，因此它永远只会用最“方便”的方式区分两个类别。假设我们要训练一个区分苹果和橘子的神经网络，但手上的数据只有红苹果和青橘子，那无论我们拍摄多少张照片，神经网络也只会简单地认为红色的就是苹果，青色的就是橘子。这在实际使用中经常出现，拍摄的灯光、拍摄的角度等等，任何一个不起眼的区分点，都会被神经网络当做分类的依据。
数据增强的目标并不是无脑地堆数据，而是尽可能地去覆盖原始数据无法覆盖不到，但现实生活中会出现的情况。使用数据增强技术可以增加数据集中图像的多样性，从而提高模型的性能和泛化能力。在Pytorch框架中，常用的数据增强的函数主要集成在了transforms文件中，由于transforms的输入规定为PIL文件格式，所以我们需要使用PIL.Image模块。

导包：

from PIL import Image
from pathlib import Path
import matplotlib.pyplot as plt
import torch
import numpy as np
plt.rcParams["savefig.bbox"]="tight"
org_img=Image.open(Path("nest.jpg"))
torch.manual_seed(0)
print(np.array(org_img).shape) 
# (2286, 2603, 3)

resize,缩放

import torchvision.transforms as T
resize_img=[T.Resize(size=newsize)(org_img) for newsize in [1000,2000]]

ax1=plt.subplot(131)
ax1.set_title("original")
ax1.imshow(org_img)

ax2=plt.subplot(132)
ax2.set_title("1000*1000")
ax2.imshow(resize_img[0])

ax3=plt.subplot(133)
ax3.set_title(2000*2000)
ax3.imshow(resize_img[1])

plt.show()

灰度化

gray_img = T.Grayscale()(org_img)
ax1 = plt.subplot(121)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(122)
ax2.set_title('gray')
ax2.imshow(gray_img,cmap='gray')
plt.show()

标准化

norm_img=T.Normalize(mean=(0.5,0.5,0.5),std=(0.5,0.5,0.5))(T.ToTensor()(org_img))
norm_img=[T.ToPILImage()(norm_img)]

ax1 = plt.subplot(121)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(122)
ax2.set_title('normalize')
ax2.imshow(norm_img[0])

plt.show()

旋转

plt.rcParams['font.sans-serif'] = ['SimHei']
rotate_img=[T.RandomRotation(degrees=180)(org_img)]
# print(rotate_img)

ax1=plt.subplot(121)
ax1.set_title("original")
ax1.imshow(org_img)

ax2=plt.subplot(122)
ax2.set_title("$180$")
ax2.imshow(rotate_img[0])

plt.show()

中心裁剪

center_crop=[T.CenterCrop(size=newsize)(org_img) for newsize in (300,600)]

ax1 = plt.subplot(131)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(132)
ax2.set_title('300*300')
ax2.imshow(np.array(center_crop[0]))

ax3 = plt.subplot(133)
ax3.set_title('600*600')
ax3.imshow(np.array(center_crop[1]))

plt.show()

随机裁剪

rand_corp=[T.RandomCrop(size=newsize)(org_img) for newsize in [500,1000]]

ax1 = plt.subplot(131)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(132)
ax2.set_title('500*500')
ax2.imshow(np.array(rand_corp[0]))

ax3 = plt.subplot(133)
ax3.set_title('1000*1000')
ax3.imshow(np.array(rand_corp[1]))

plt.show()

加入高斯噪声

blur_img=[T.GaussianBlur(kernel_size=(3,3),sigma=x)(org_img) for x in (30,60)]

ax1 = plt.subplot(131)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(132)
ax2.set_title('sigma=30')
ax2.imshow(np.array(blur_img[0]))

ax3 = plt.subplot(133)
ax3.set_title('sigma=60')
ax3.imshow(np.array(blur_img[1]))

plt.show()

调色，饱和等

colorjitter=[T.ColorJitter(brightness=(0.2,0.8),contrast=(0.5,0.5),saturation=(0.5,0.5),hue=0.5)(org_img)]
# 亮度（brightness）、对比度（contrast）、饱和度（saturation）和色调（hue)
# brightness_factor从[max(0, 1 - brightness), 1 + brightness]中随机采样产生。应当是非负数。
# contrast_factor从[max(0, 1 - contrast), 1 + contrast]中随机采样产生。应当是非负数。
# saturation_factor从[max(0, 1 - saturation), 1 + saturation]中随机采样产生。应当是非负数。
# hue_factor从[-hue, hue]中随机采样产生，其值应当满足0<= hue <= 0.5或-0.5 <= min <= max <= 0.5
ax1 = plt.subplot(121)
ax1.set_title('original')
ax1.imshow(org_img)
ax2 = plt.subplot(122)
ax2.set_title('colorjitter')
ax2.imshow(np.array(colorjitter[0]))
plt.show()

水平翻转

horizon=[T.RandomHorizontalFlip(p=1)(org_img)]
# p表示概率
ax1 = plt.subplot(121)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(122)
ax2.set_title('horizon')
ax2.imshow(np.array(horizon[0]))

plt.show()

垂直翻转

vertical=[T.RandomVerticalFlip(p=1)(org_img)]

ax1 = plt.subplot(121)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(122)
ax2.set_title('VerticalFlip')
ax2.imshow(np.array(vertical[0]))

plt.show()

加入自定义噪声

def add_noise(imputs,noise_fac=0.5):
    noise=imputs + torch.randn_like(imputs)*noise_fac
    noise=torch.clip(noise,0.0,1.0)
    # clip这个函数将将数组中的元素限制在a_min, a_max之间，大于a_max的就使得它等于 a_max，小于a_min,的就使得它等于a_min。
    return noise

noise_img=[add_noise(T.ToTensor()(org_img),fac) for fac in (0.4,0.8)]
noise_img=[T.ToPILImage()(n_img) for n_img in noise_img]

ax1 = plt.subplot(131)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(132)
ax2.set_title('noise_factor=0.4')
ax2.imshow(np.array(noise_img[0]))

ax3 = plt.subplot(133)
ax3.set_title('noise_factor=0.8')
ax3.imshow(np.array(noise_img[1]))

plt.show()

加入掩码块

def add_box(img,num_box,size=100):
    h,w=size,size
    img=np.asarray(img).copy()
    img_size=img.shape[1]
    boxes=[]
    for k in range(num_box):
        y,x=np.random.randint(0,img_size-w,(2,))
        img[y:y+h,x:x+w]=0
        boxes.append((x,y,h,w))
    img=Image.fromarray(img.astype('uint8'),'RGB')
    return img

block_img=[add_box(org_img,num_box=15)]

ax1 = plt.subplot(121)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(122)
ax2.set_title('add black boxes')
ax2.imshow(np.array(block_img[0]))

plt.show()

中心掩码块

def add_center(o_img,size=150):
    h,w=size,size
    img=np.asarray(o_img).copy()
    img_size=img.shape[1]
    img[int(img_size/2-h):int(img_size/2+h),int(img_size/2-w):int(img_size/2+w)]=0
    img=Image.fromarray(img.astype('uint8'),'RGB')
    return img

center_img=[add_center(org_img,size=200)]

ax1 = plt.subplot(121)
ax1.set_title('original')
ax1.imshow(org_img)

ax2 = plt.subplot(122)
ax2.set_title('add_center')
ax2.imshow(np.array(center_img[0]))

plt.show()

多进程与多线程

并发：在一段时间内交替去执行多个任务。例子:对于单核cpu处理多任务,操作系统轮流让各个任务交替执行。
并行：在一段时间内真正的同时一起执行多个任务。例子:对于多核cpu处理多任务，操作系统会给cpu的每个内核安排一个执行的任务，多个内核是真正的一起同时执行多个任务。这里需要注意多核cpu是并行的执行多任务，始终有多个任务一起执行。
进程是操作系统分配资源的最小单元, 线程是操作系统调度的最小单元。(一个是供分配，一个是供调度)
一个应用程序至少包括1个进程，而1个进程包括1个或多个线程，线程的尺度更小。
每个进程在执行过程中拥有独立的内存单元，而一个进程的多个线程在执行过程中共享内存。
一座工厂（类似CPU），假设电力有限，只能供一个车间，即只能运行一个任务，里面有许多的车间（类似进程），执行单个的任务，这时，就是每次只能单个车间运行，若是另一个车间想工作，则当前车间得休息。
而多核CPU，就像多个工厂，它可以同时让多个车间（类似多个进程）一起工作，当然，是工作在不同工厂里，也就是运行在不同CPU核上。
而每个车间里有很多的工人，这就类似是线程，一个车间可以有多个工人，也就是一个进程可有多个线程。
这就是基本的CPU、多核、进程、线程之间的关系。这里好像一切都很和谐，跟锁没什么关系。为社么会出现锁呢？接下来就得谈谈内存占用的问题。
- 在一个进程下，它拥有的资源是有限的（有多少呢，举个例子），而在这个进程下，多个线程是共享这些资源的，就像是一个车间地方大小是一定的，每个工人工作占用的地方不一致，那怎么办呢，那就得加把锁了，当某个工作地方被占满了就得挂上锁，告诉其他工人，这里已经容不下人了。得等人出来，也就是某个线程结束释放内存时，才能又进去人，开始新的线程。
- 这里大佬们发明了一个简单防止冲突的方法，叫做互斥锁（Mutual exclusion，缩写 Mutex）。也就是说，一个线程在使用共享内存时，会把门锁住，防止其他人进来占用。后来的人得等着，等这把锁被解开，也就是空间被释放，才能再进去用这个空间。
- 还有些房间，可以同时容纳n个人。也就是说，如果人数大于n，多出来的人只能在外面等着。这好比某些内存区域，只能供给固定数目的线程使用。这时的解决方法，就是在门口挂n把钥匙。进去的人就取一把钥匙，出来时再把钥匙挂回原处。后到的人发现钥匙架空了，就知道必须在门口排队等着了。这种做法叫做"信号量"（Semaphore），用来保证多个线程不会互相冲突。
多进程CPU会自动分配资源，同时可以跑在不同的内核上。而Python多线程则在CPU上实际上是间断的工作，就是一个线程跑，则其他线程处于休息状态，下一个线程开始，则其他线程又进入休息状态。
多线程: threading，利用CPU和IO可以同时执行的原理，让CPU不会干巴巴等待IO完成
- 多线程Thread ( threading) 优点:相比进程，更轻量级.占用资源少。缺点:相比讲程，多线程只能并发执行，不能利用多CPU ( GIL)·相比协程:启动数目有限制,占用内存资源，有线程切换开销。适用于:Io密集型计算、同时运行的任务数目要求不多
多进程:multiprocessing，利用多核CPU的能力，真正的并行执行任务
- 多进程Process ( multiprocessing)·优点:可以利用多核CPU并行运算。缺点:占用资源最多、可启动数自比线程少,适用于:CPU密集型计算
异步IO: asyncio，在单线程利用CPU和IO同时执行的原理，实现函数异步执行
- 多协程Coroutine ( asyncio ) 优点:内存开销最少、启动协程数量最多。缺点:支持的库有限制(aiohttp vs requests)、代码实现复杂。适用于:IO密集型计算、需要超多任务运行、但有现成库支持的场景
一个进程里可有多个线程，一个线程里可有多个协程。
使用Lock对资源加锁，防止冲突访问
使用Queue实现不同线程/进程之间的数据通信，实现生产者-消费者模式
使用线程池Pool/进程池Pool，简化线程/进程的任务提交、等待结束、获取结果
使用subprocess启动外部程序的进程，并进行输入输出交互
CPU密集型也叫计算密集型，是指 I/O 在很短的时间就可以完成，CPU需要大量的计算和处理，特点是CPU占用率相当高
- 例如:压缩解压缩、加密解密、正则表达式搜索
I/O 密集型指的是系统运作大部分的状况是CPU在等I/O(硬盘/内存)的读/写操作，CPU占用率仍然较低。
- 例如:文件处理程序、网络爬虫程序、读写数据库程序
全局解释器锁（英语:Global Interpreter Lock，缩写GIL)，是计算机程序设计语言解释器用于同步线程的一种机制，它使得任何时刻仅有一个线程在执行。即便在多核心处理器上，使用GIL的解释器也只允许同一时间执行一个线程。GIL简化了共享资源的管理.
- 因为Python的线程虽然是真正的线程，但解释器执行代码时，有一个GIL锁：Global Interpreter Lock，任何Python线程执行前，必须先获得GIL锁，然后，每执行100条字节码，解释器就自动释放GIL锁，让别的线程有机会执行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁，所以，多线程在Python中只能交替执行，即使100个线程跑在100核CPU上，也只能用到1个核。
多线程threading机制依然是有用的，用于IO密集型计算。因为在I/O (read,write,send,recv,etc.)期间，线程会释放GIL,实现CPU和IO的并行因此多线程用于IO密集型计算依然可以大幅提升速度。但是多线程用于CPU密集型计算时，只会更加拖慢速度。
使用multiprocessing的多进程机制实现并行计算、利用多核CPU优势。为了应对GIL的问题，Python提供了multiprocessing
新建线程系统需要分配资源、终止线程系统需要回收资源如果可以重用线程，则可以减去新建/终止的开销。一个线程的运行时间可以分为3部分：线程的启动时间、线程体的运行时间和线程的销毁时间。在多线程处理的情景中，如果线程不能被重用，就意味着每次创建都需要经过启动、销毁和运行3个过程。这必然会增加系统相应的时间，降低了效率。
使用线程池的好处1、提升性能:因为减去了大量新建、终止线程的开销,重用了线程资源;2、适用场景:适合处理突发性大量请求或需要大量线程完成任务、但实际任务处理时间较短；3、防御功能:能有效避免系统因为创建线程过多，而导致系统负荷过大相应变慢等问题；4、代码优势:使用线程池的语法比自己新建线程执行线程更加简洁
使用线程池：由于线程预先被创建并放入线程池中，同时处理完当前任务之后并不销毁而是被安排处理下一个任务，因此能够避免多次创建线程，从而节省线程创建和销毁的开销，能带来更好的性能和系统稳定性。线程池基本原理：我们把任务放进队列中去，然后开N个线程，每个线程都去队列中取一个任务，执行完了之后告诉系统说我执行完了，然后接着去队列中取下一个任务，直至队列中所有任务取空，退出线程。

# 创建队列实例， 用于存储任务
queue = Queue()
# 定义需要线程池执行的任务
def do_job():
    while True:
        i = queue.get()
        time.sleep(1)
        print 'index %s, curent: %s' % (i, threading.current_thread())
        queue.task_done()
if __name__ == '__main__':
    # 创建包括3个线程的线程池
    for i in range(3):
        t = Thread(target=do_job)
        t.daemon=True # 设置线程daemon  主线程退出，daemon线程也会推出，即时正在运行
        t.start()
    # 模拟创建线程池3秒后塞进10个任务到队列
    time.sleep(3)
    for i in range(10):
        queue.put(i)
    queue.join()

多线程和多进程在python中的支持
信号量（英语:Semaphore)又称为信号量、旗语，是一个同步对象，用于保持在0至指定最大值之间的一个计数值。当线程完成一次对该semaphore对象的等待( wait)时，该计数值减一;·当线程完成一次对semaphore对象的释放（release)时，计数值加一。当计数值为0，则线程等待该semaphore对象不再能成功直至该semaphore对象变成signaled状态. semaphore对象的计数值大于0，为signaled状态;计数值等于0，为nonsignaled状态.
设置主进程守护：子进程对象.daemon=true。多线程是Python程序中实现多任务的一种方式；线程是程序执行的最小单位；同属一个进程的多个线程共享进程所拥有的全部资源．