cv2.resize(array, (W, H))

def copyMakeBorder(src, top, bottom, left, right, borderType, dst=None, value=None): # real signature unknown; restored from __doc__

image = cv2.imread("img.jpg")

region = image[y1:y2, x1:x2]

w, h = x2 - x1, y2 - y1 # h, w = image.shape
m = max(w, h)
ratio = 224.0 / m
new_w, new_h = int(ratio * w), int(ratio *h)
assert new_w > 0 and new_h > 0
resized = cv2.resize(region, (new_w, new_h))

W, H = 256, 256
top = (H - new_h) // 2
bottom = (H - new_h) // 2
if top + bottom + h < H:
    bottom += 1

left = (W - new_w) // 2
right = (W - new_w) // 2
if left + right + w < W:
    right += 1

pad_image = cv2.copyMakeBorder(resized, top, bottom, left, right, cv2.BORDER_CONSTANT, value = self.white)

def pltShow(img):
    dst = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    plt.imshow(dst)

def testErosion():
    img = cv2.imread('test.png', 0)
    kernel = np.ones((5, 5), np.uint8)
    erosion = cv2.erode(img, kernel, iterations=1)
    plt.subplot(121),pltShow(img),plt.title("Origin")
    plt.subplot(122),pltShow(erosion),plt.title("Erosion")
    plt.show()

img_3 = cv2.imread(img_path, mode)
erosion = cv2.dilate(img_3, kernel, iterations=1)

def testOpen():
    img = cv2.imread("test2.png", 0)
    kernel = np.ones((5,5), np.uint8)
    erosion = cv2.erode(img, kernel, iterations=1)
    dilateAfterErosion = cv2.dilate(erosion, kernel, iterations=1)
    opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel)
    plt.subplot(131), pltShow(img), plt.title("Origin")
    plt.subplot(132), pltShow(dilateAfterErosion), plt.title("DilateAfterErosion")
    plt.subplot(133), pltShow(opening), plt.title("Opening")
    plt.show()

def testClose():
    img = cv2.imread("test3.png", 0)
    kernel = np.ones((5,5), np.uint8)
    dilate = cv2.dilate(img, kernel, iterations=1)
    erosionAfterDilate = cv2.erode(dilate, kernel, iterations=1)
    closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
    plt.subplot(131), pltShow(img), plt.title("Origin")
    plt.subplot(132), pltShow(erosionAfterDilate), plt.title("ErosionAfterDilate")
    plt.subplot(133), pltShow(closing), plt.title("Closing")
    plt.show()

def testGradient():
    img = cv2.imread('test.png', 0)
    kernel = np.ones((2, 2), np.uint8)
    gradient = cv2.morphologyEx(img, cv2.MORPH_GRADIENT, kernel)
    plt.subplot(121), pltShow(img), plt.title("Origin")
    plt.subplot(122), pltShow(gradient), plt.title("Gradient")
    plt.show()

import cv2
import numpy as np
cv2.namedWindow("img", cv2.WINDOW_NORMAL)
cv2.resizeWindow("img", 640, 480)
img = cv2.imread("i.png")
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
new_img = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel, iterations=1)
cv2.imshow("img", np.hstack((img, new_img)))
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np
cv2.namedWindow("img", cv2.WINDOW_NORMAL)
cv2.resizeWindow("img", 640, 480)
img = cv2.imread("is.png")
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
# 黑帽操作
new_img = cv2.morphologyEx(img, cv2.MORPH_BLACKHAT, kernel, iterations=1)
cv2.imshow("img", np.hstack((img, new_img)))
cv2.waitKey(0)
cv2.destroyAllWindows()

# 用绿色(0, 255, 0)来画出最小的矩形框架
x, y, w, h = cv2.boundingRect(cnt)
cv2.rectangle(img, (x, y), (x+w, y+h), (0, 255, 0), 2)

# 用红色表示有旋转角度的矩形框架
rect = cv2.minAreaRect(cnt)
box = cv2.cv.BoxPoints(rect)
box = np.int0(box)
cv2.drawContours(img, [box], 0, (0, 0, 255), 2)
cv2.imwrite('contours.png', img)

# 1、表示打开笔记本的内置摄像头，
cap = cv2.VideoCapture(0) 

# 2 视频文件路径
cap = cv2.VideoCapture(“../test.avi”)


# 3
ret,frame = cap.read()

# 4
cap.release()

haarcascade_eye.xml
haarcascade_eye_tree_eyeglasses.xml
haarcascade_frontalcatface.xml
haarcascade_frontalcatface_extended.xml
haarcascade_frontalface_alt.xml
haarcascade_frontalface_alt2.xml
haarcascade_frontalface_alt_tree.xml
haarcascade_frontalface_default.xml
haarcascade_fullbody.xml
haarcascade_lefteye_2splits.xml
haarcascade_licence_plate_rus_16stages.xml
haarcascade_lowerbody.xml
haarcascade_profileface.xml
haarcascade_righteye_2splits.xml
haarcascade_russian_plate_number.xml
haarcascade_smile.xml
haarcascade_upperbody.xml

detector = dlib.cnn_face_detection_model_v1(face_detector_model_path)  # dlib.cnn_face_detection_model_v1
# detector = dlib.get_frontal_face_detector()

predictor = dlib.shape_predictor('shape_predictor_68_face_landmarks.dat')


detections = detector(img, 1)

# step 3. get shape of one face for example
detection = detections[0]  # dlib.mmod_rectangle
# the mmod_rectangle contains two parts : confidence and rect

shape = predictor(img, detection.rect)  # dlib.full_object_detection

# step 4. get all the face landmark points
landmark_points = shape.parts() # dlib.points

#1 list->tensor
data = [[1,2],[3,4]]
x_data = torch.tensor(data, dtype=torch.float)
### torch.FloatTensor, torch.DoubleTensor
float_tensor = torch.FloatTensor([4,5,6])

#2 np.array -> tensor
np_array = np.array(data)
x_np_data = torch.from_numpy(data)

#3 tensor -> tensor
x_ones = torch.ones_like(x_data)
x_rand = torch.rand_like(x_data, dtype=torch.float)

#4 new empty tensor
shape = (2,3)
x_ones = torch.ones(shape)
x_zeros = torch.zeros(shape)
x_rand = torch.rand(shape)

#5  tensor to numpy
tensor.numpy()

# index + slice
tensor = torch.rand(4,4)
a = tensor[:, 1]

# get mask
Tensor[Mask]

x = torch.rand((3,4))
y = x @ x.T
y = x.matmul(x.T)

torch.nn.init.xavier_uniform_(conv.weight)
torch.nn.init.xavier_uniform_(conv.bias, 0)


# REF: https://blog.csdn.net/qq_42995479/article/details/120598487

# kaiming均匀分布
# torch.nn.init.kaiming_uniform_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu')
# 服从 U(-a, a), a = sqrt(6 / (1 + b ^2) * fan_in), 其中b为激活函数的负半轴的斜率， relu是0
# model 可以是fan_in或者fan_out。fan_in 表示使正向传播时，方差一致； fan_out使反向传播时， 方差一致
# nonlinearity 可选为relu和leaky_relu， 默认是leaky_relu

# kaiming正态分布,  N～ (0,std)，其中std = sqrt(2/(1+b^2)*fan_in)
# torch.nn.init.kaiming_normal_(tensor, a=0, mode='fan_in', nonlinearity='leaky_relu')

for m in net.modules():
     if isinstance(m, torch.nn.Conv2d):
          nn.kaiming_normal_(m.weight, mode = 'fan_in')
          nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')

>>> x = torch.zeros(2, 1, 2, 1, 2)
>>> x.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x)
>>> y.size()
torch.Size([2, 2, 2])
>>> y = torch.squeeze(x, 0)
>>> y.size()
torch.Size([2, 1, 2, 1, 2])
>>> y = torch.squeeze(x, 1)
>>> y.size()
torch.Size([2, 2, 1, 2])
>>> y = torch.squeeze(x, (1, 2, 3))
torch.Size([2, 2, 2])

>>> x = torch.tensor([1, 2, 3, 4])
>>> torch.unsqueeze(x, 0)
tensor([[ 1,  2,  3,  4]])
>>> torch.unsqueeze(x, 1)
tensor([[ 1],
        [ 2],
        [ 3],
        [ 4]])

torch.save({
            'model_state_dict': {k: _models[k].state_dict() for k in _models},
            'optimizer_state_dict': {k: optimizers[k].state_dict() for k in optimizers},
            "stats": stats,
            'flags': vars(flags),
            'frames': frames,
            'position_frames': position_frames
        }, checkpointpath)

torch.save(learner_model.get_model(position).state_dict(), model_weights_dir)

torch.save(model.state_dict(), PATH)

model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH))
model.eval()

torch.save(model, PATH)

# Model class must be defined somewhere
model = torch.load(PATH)
model.eval()

model_scripted = torch.jit.script(model) # Export to TorchScript
model_scripted.save('model_scripted.pt') # Save

model = torch.jit.load('model_scripted.pt')
model.eval()

torch.save({
            'epoch': epoch,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'loss': loss,
            ...
            }, PATH)

model = TheModelClass(*args, **kwargs)
optimizer = TheOptimizerClass(*args, **kwargs)

checkpoint = torch.load(PATH)
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
loss = checkpoint['loss']

model.eval()
# - or -
model.train()

torch.save(model.state_dict(), PATH)

device = torch.device("cuda")
model = TheModelClass(*args, **kwargs)
model.load_state_dict(torch.load(PATH))
model.to(device)
# Make sure to call input = input.to(device) on any input tensors that you feed to the model

import torch

def print_model_param_names(model):
    for name, param in model.named_parameters():
        print(name)

def print_model_param_values(model):
    for name, param in model.named_parameters():
        print(name, param.data)

# 创建一个模型实例
model = torch.nn.Sequential(
          torch.nn.Linear(10, 5),
          torch.nn.ReLU(),
          torch.nn.Linear(5, 1)
        )

# 打印模型的所有参数名
print_model_param_names(model)

# 打印模型的所有参数值
print_model_param_values(model)

# 打印模型的所有参数名和参数值，并取出参数值
params = {}
for name, param in model.named_parameters():
    print('Parameter name:', name)
    print('Parameter value:', param)
    params[name] = param.clone().detach().numpy()

# 断开图的链接
model = None

df = pd.read_csv('file_path')

df = pd.DataFrame(columns=['index', 'v2'])
df['index'] = np.arange(10)
df['v2'] = np.random.randn(10)
# 修改某行的v2列值
df.loc[df.index==1, 'c'] = '9'

import numpy as np
import pandas as pd

df=pd.DataFrame({'A':[1,2,3],'B':[4,5,6],'C':[7,8,9]})

1.使用DataFrame中的values方法
df.values

2.使用DataFrame中的as_matrix()方法
df.as_matrix()

3.使用Numpy中的array方法
np.array(df)

df['name'] # 会返回本列的 Series
df.name
df.Q1
# df.1Q 即使列名叫 1Q 也无法使用
# df.my name 有空格也无法调用，可以处理加上下划线

# 使用 .loc 按照标签索引访问
for index in df.index:
    print(f"Index: {index}")
    print(f"Row data: {df.loc[index]}")
    print()

# 使用 .iloc 按照位置索引访问
for i in range(len(df)):
    print(f"Row {i} data: {df.iloc[i]}")
    print()

# 代表索引，如果是字符需要加引号
df.loc[0] # 选择索引为 0 的行
df.loc[8]

df.loc[[0,5,10]] # 指定索引 0，5，10 的行
df.loc[['Eli', 'Ben']] # 如果行索引是 name，提取所有列
df.loc[['Eli', 'Ben'],["name", "grade"]] # 如果行索引是 name, 提取指定列
df.loc[:,["name", "grade"]]
# 真假选择，长度要和索引一样
df.loc[[False, True]*50] # 为真的列显示，隔一个显示一个

df.loc[0:5] # 索引切片, 代表0-5行，包括5
df.loc['2010':'2014'] # 如果索引是时间可以用字符查询
df.loc[:] # 所有
# 本方法支持 Series

# 索引单调性
(
    df.index.is_monotonic_increasing,
    df.index.is_monotonic_decreasing
)
# (True, False)

# 姓名开头从 Ad 到 Bo 的
df.set_index('name').sort_index().loc['Ad':'Bo']
# 姓名开头从开始到 Bo 的
df.set_index('name').sort_index().loc[:'Bo']
# 团队名称从 C 到 D 的
df.set_index('team').sort_index().loc['C': 'D']
# 姓名开头从 Te 到 X 的
df.sort_values('name').set_index('name').loc['Te': 'X']

dft.loc[:, ['Q1', 'Q2']] # 所有行，Q1 和 Q2两列
dft.loc[:, ['Q1', 'Q2']] # 所有行，Q1 和 Q2两列
dft.loc[:10, 'Q1':] # 0-10 行，Q1后边的所有列

# 注：索引是字符需要加引号
df.at[4, 'Q1'] # 65
df.at['lily', 'Q1'] # 65 假定索引是 name
df.at[0, 'name'] # 'Liver'
df.loc[0].at['name'] # 'Liver'
# 指定列的值对应其他列的值
df.set_index('name').at['Eorge', 'team'] # 'C'
df.set_index('name').team.at['Eorge'] # 'C'
# 指定列的对应索引的值
df.team.at[3] # 'C'

df.iat[4, 2] # 65
df.loc[0].iat[1] # 'E'

df.get('name', 0) # 是 name 列
df.get('nameXXX', 0) # 0, 返回默认值
s.get(3, 0) # 93, Series 传索引返回具体值
df.name.get(99, 0) # 'Ben'

data[data.列名.str.contains()]
data[data.列名.str.contains('^某某')]
data[data.列名.str.contains('某某')]
data[data.列名.str.contains('某某$')]


data['列名']=data['列名'].apply(str)#把非字符串格式改为字符串格式

#// 多条件查询
data[data.source.str.contains('某某|某某1')]
# 对条件查询结果进行删除
data[-data.source.str.contains('某某|某某1')]

#数据框去重
DataFrame.drop_duplicates(subset=None,keep='first',inplace=False)
#    按某列去重
data.drop_duplicates(subset='列名',keep='first',inplace=False)
#    按多列去重
data.drop_duplicates(subset=['列名','列名1'],keep='first',inplace=False)

s.where(s > 90) # 不符合条件的为 NaN
s.where(s > 90, 0) # 不符合条件的为 0
# np.where, 大于80是真否则是假
np.where(s>80, True, False)
np.where(df.num>=60, '合格', '不合格')

s.mask(s > 90) # 符合条件的为 NaN
s.mask(s > 90, 0) # 符合条件的为 0

# 例：能被整除的显示，不能的显示相反数
m = df.loc[:,'Q1':'Q4'] % 3 == 0
df.loc[:,'Q1':'Q4'].where(m, -df.loc[:,'Q1':'Q4'])

# 行列相同数量，返回一个 array
df.lookup([1,3,4], ['Q1','Q2','Q3']) # array([36, 96, 61])
df.lookup([1], ['Q1']) # array([36])

df.query('Q1 > Q2 > 90') # 直接写类型 sql where 语句
df.query('Q1 + Q2 > 180')
df.query('Q1 == Q2')
df.query('(Q1<50) & (Q2>40) and (Q3>90)')
df.query('Q1 > Q2 > Q3 > Q4')
df.query('team != "C"')
df.query('team in ["A","B"]')
df.query('team not in ("E","A","B")')
df.query('name.str.contains("am")') # 包含 am 字符
# 对于名称中带有空格的列，可以使用反引号引起来
df.query('B == `team name`')

# 支持传入变量，如：大于平均分40分的
a = df.Q1.mean()
df.query('Q1 > @a+40')
df.query('Q1 > `Q2`+@a')

# df.eval() 用法与 df.query 类似
df[df.eval("Q1 > 90 > Q3 > 10")]
df[df.eval("Q1 > `Q2`+@a")]

df.filter(items=['Q1', 'Q2']) # 选择两列
df.filter(regex='Q', axis=1) # 列名包含Q的
df.filter(regex='e$', axis=1) # 以 e 结尾的
df.filter(regex='1$', axis=0) # 正则, 索引名包含1的
df.filter(like='2', axis=0) # 索引中有2的
# 索引中2开头列名有Q的
df.filter(regex='^2', axis=0).filter(like='Q', axis=1)

df.select_dtypes(include=['float64']) # 选择 float64 型数据
df.select_dtypes(include='bool')
df.select_dtypes(include=['number']) # 只取数字型
df.select_dtypes(exclude=['int']) # 排除 int 类型
df.select_dtypes(exclude=['datetime64'])

# Q1 Q2 成绩全为 80 分的
df[(df.loc[:,['Q1','Q2']] > 80).all(1)]
# Q1 Q2 成绩至少有一个 80 分的
df[(df.loc[:,['Q1','Q2']] > 80).any(1)]

# Series数据修改，返回当前列的series
review_points_mean = reviews.points.mean()
reviews.points.map(lambda p: p - review_points_mean)

# DataFrame 引用修改，返回完整的DF数据
def remean_points(row):
    row.points = row.points - review_points_mean
    return row

reviews.apply(remean_points, axis='columns')

import pandas as pd
x2 = pd.read_csv("submit.csv")
# 修改id==80000的行，'isDefault'的值
x2.loc[x2.id==800000,'isDefault'] = 1
x2

# random.randn(x1, x2, x3, ...)
# 返回一个满足正态分布的数组
# 参数：x1:第一维大小
#      x2:第二维大小
#      …

x=np.random.randn(3,5)    # shape (3,5)
print(x) 


#random.randn(x1, x2, x3, ...)
# 返回一个值在[0,1)之间的数组
# 参数：x1:第一维大小
#      x2:第二维大小
#      …

x=np.random.rand(2,4)
print(x)


#numpy.random.randint(low,high=None,size=None,dtype=‘l’)
#返回一个数组
#参数：low:数组最小值
#   high:数组最大值
#   size:数组维度大小
#   dtype:数据类型，默认为int
#   high为空时，默认生成随机数为[0,low)

x=np.random.randint(1,11,(3,4))
y=np.random.randint(10)
print("x:",x)
print("y:",y)
#输出：
x: [[9 2 4 6]
    [1 3 7 7]
    [8 5 5 5]]
y: 3

# np.random.choice(a,size=None,replace=True,p=None)
# 返回一个数组
# 参数：a:一维数组类似数据或整数，整数时对应一维数组为np.arange(a)
#   size:数组维度大小
#   replace:抽样后是否将该数放回数组，若True则放回，False则不放回，所有数不相同
#   p:数组中的数出现的概率
# 举例：
x=np.random.choice(5, 3, replace=False, p=[0.1, 0, 0.3, 0.6, 0])
#输出：[0 2 3]


# 随机数[0,1]之间
np.random.random()


# seed( ) 用于指定随机数生成时所用算法开始的整数值，如果使用相同的seed( )值，则每次生成的随即数都相同，如果不设置这个值，则系统根据时间来自己选择这个值，此时每次生成的随机数因时间差异而不同。
np.random.seed()


# 是 NumPy 库中的一个函数，用于从正态分布（也称为高斯分布）中随机抽取样本。
np.random.normal 

import numpy as np

a=np.eye(3)
print(a)

a=np.eye(4,k=1)
print(a)

a=np.eye(4,k=-1)
print(a)

a=np.eye(4,k=-3)
print(a)

import numpy as np

labels=np.array([[1],[2],[0],[1]])
print("labels的大小：",labels.shape,"\n")

#因为我们的类别是从0-2，所以这里是3个类
a=np.eye(3)[1]
print("如果对应的类别号是1，那么转成one-hot的形式",a,"\n")

a=np.eye(3)[2]
print("如果对应的类别号是2，那么转成one-hot的形式",a,"\n")

a=np.eye(3)[1,0]
print("1转成one-hot的数组的第一个数字是：",a,"\n")

#这里和上面的结果的区别，注意!!!
a=np.eye(3)[[1,2,0,1]]
print("如果对应的类别号是1,2,0,1，那么转成one-hot的形式\n",a)

res=np.eye(3)[labels.reshape(-1)]
print("labels转成one-hot形式的结果：\n",res,"\n")
print("labels转化成one-hot后的大小：",res.shape)

labels的大小： (4, 1) 

如果对应的类别号是1，那么转成one-hot的形式 [0. 1. 0.] 

如果对应的类别号是2，那么转成one-hot的形式 [0. 0. 1.] 

1转成one-hot的数组的第一个数字是： 0.0 

如果对应的类别号是1,2,0,1，那么转成one-hot的形式
 [[0. 1. 0.]
 [0. 0. 1.]
 [1. 0. 0.]
 [0. 1. 0.]]
labels转成one-hot形式的结果：
 [[0. 1. 0.]
 [0. 0. 1.]
 [1. 0. 0.]
 [0. 1. 0.]] 

labels转化成one-hot后的大小： (4, 3)

import numpy as np

a=np.identity(3)
print(a)


[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

import numpy as np
a = np.zeros((32,32))
print(a.shape)
a1 = np.expand_dims(a,0)
print(a1.shape)
>>> (32,32) (1,32,32)

import numpy as np
a = np.zeros((32,32))
print(a.shape)
a1 = a[None,:,:]
print(a1.shape)
>>> (32,32) (1,32,32)

import numpy as np
a = np.zeros((1,32,32))
print(a.shape)
a1 = a.squeeze()
print(a1.shape)

>>> (1,32,32) (32,32)

import numpy as np
a = np.zeros((3,32,32))
print(a.shape)
a1 = a[0,:,:]
print(a1.shape)