i_see_the_world
i_see_the_world

1+X计算机视觉考证一些知识点

如有错误，还望大佬指正，我也才刚学，难免有疏漏，勿怪勿怪…(〃´･ω･)

文章目录

  • Python
    • 1、Python基础语法
        • 1.1 Python标识符
        • 1.2 行和缩进
        • 1.3 变量的输入和输出
        • 1.4 关键字
        • 1.5 运算符
    • 2，分支循环
        • 2.1 if循环
        • 2.2 循环语句
    • 3、列表和元组
        • 3.1 List列表
  • OpenCV
    • 1，图像
      • A.图像入门
      • B.图像的基本操作
        • 1,访问像素值并修改它们
        • 2,访问图像属性
        • 3,分割和合并图像
        • 4,为图像设置边框
        • 5,图像上的算术运算
        • 6,OpenCV中的绘图功能
      • C.图像处理 cv2.cvtColor
      • D.图像几何变换
      • E.图像阈值 cv.threshold
      • F.图像平滑
        • 1，滤波
        • 2，噪声
      • G.形态学转化
        • 1，腐蚀操作`cv2.erode(img,kernel)`
        • 2，膨胀操作`cv.dilate(img,kernel) `
        • 3，开运算和闭运算
        • 4，顶帽和黑帽
      • H.图像金字塔
        • 1，高斯金字塔
        • 2，拉普拉斯金字塔
      • I.轮廓
      • J.Canny边缘检测和图像梯度
      • K.特征检测
        • 1，SIFT
        • 2，Brute-Force匹配器
      • L.直方图
    • 2，视频
  • 机器学习
    • 常见算法
      • 深度学习
    • 卷积神经网络
    • BP神经网络
    • 神经网络常见激活函数
  • paddlepaddle
    • 难以分类
  • 实操题
    • 图像题
    • 视频题
    • 框架题

Python

1、Python基础语法

1.1 Python标识符

在 Python 里，标识符由字母、数字、下划线组成。

在 Python 中，所有标识符可以包括英文、数字以及下划线(_)，但不能以数字开头。

Python 中的标识符是区分大小写的。

以下划线开头的标识符是有特殊意义的。以单下划线开头_foo的代表不能直接访问的类属性，需通过类提供的接口进行访问，不能用from xxx import *而导入。

以双下划线开头的 __foo 代表类的私有成员，以双下划线开头和结尾的 __foo__代表 Python 里特殊方法专用的标识，如 __init__()代表类的构造函数。

stu = 1

1.2 行和缩进

学习 Python 与其他语言最大的区别就是，Python 的代码块不使用大括号 {} 来控制类，函数以及其他逻辑判断。python 最具特色的就是用缩进来写模块。

缩进的空白数量是可变的，但是所有代码块语句必须包含相同的缩进空白数量，这个必须严格执行。

 # 没有严格缩进，在执行时会报错
if True:
    print ("True")
else:
    print ("False")

变量

在 Python 中，每个变量 在使用前都必须赋值，变量 赋值以后 该变量 才会被创建
等号（=）用来给变量赋值
= 左边是一个变量名
= 右边是存储在变量中的值

  • 变量的类型
  • str —— 字符串
    bool —— 布尔（真假）
    int —— 整数
    float —— 浮点数（小数）
  • Python 可以根据=等号右侧的值，自动推导出变量中存储数据的类型
  • 定义变量的时候不需要指定类型

1.3 变量的输入和输出

在 Python 中，如果要获取用户在键盘上的输入信息，需要使用到input函数
用户输入的 任何内容 Python 都认为是一个 字符串

字符串变量 = input("提示信息：")

演练

# 1. 输入苹果单价
price_str = input("请输入苹果价格：")
# 2. 要求苹果重量
weight_str = input("请输入苹果重量：")
# 3. 计算金额
# 1> 将苹果单价转换成小数
price = float(price_str)
# 2> 将苹果重量转换成小数
weight = float(weight_str)
# 3> 计算付款金额
money = price * weight
print(money)

1.4 关键字

关键字 就是在 Python 内部已经使用的标识符
关键字 具有特殊的功能和含义
不允许定义和关键字相同的名字的标示符

import关键字 可以导入一个 “工具包”。在 Python 中不同的工具包，提供有不同的工具

1.5 运算符

算数运算符 描述 补充
+ 加 10 + 20 = 30
- 减 10 - 20 = -10
* 乘 10 * 20 = 200
/ 除 10 / 20 = 0.5
// 取整除 返回除法的整数部分（商） 9 // 2 输出结果 4
% 取余数 返回除法的余数 9 % 2 = 1
** 幂 又称次方、乘方，2 ** 3 = 8
比较运算符 > < == != >= <=
逻辑运算符 and or not
赋值运算符 = += -= *= /= //= **=

运算符的优先级

运算符 描述
** 幂 (最高优先级)
* / % // 乘、除、取余数、取整除
+ - 加法、减法
<= < > >= 比较运算符
== != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
not or and 逻辑运算符

2，分支循环

2.1 if循环

Python 程序语言指定任何非 0 和非空（None）值为 True，0 或者 None为 False。

# -*-coding:utf-8-*-
results=59
if results>=60:
    print ('及格')
else :
    print ('不及格')

# -*-coding:utf-8-*-

results = 89

if results > 90:
    print('优秀')
elif results > 80:
    print('良好')
elif results > 60:
    print ('及格')
else :
    print ('不及格')

2.2 循环语句

Python 提供了 for 循环和 while 循环，当然还有一些控制循环的语句：

  • break：在语句块执行过程中终止循环，并且跳出整个循环
  • continue：在语句块执行过程中终止当前循环，跳出该次循环，执行下一次循环
  • pass：pass 是空语句，是为了保持程序结构的完整性
count = 1
sum = 0
while count <= 100:
    sum = sum + count
    count = count + 1
print(sum)

for letter in 'wsc':
    print(letter)
# 输出
w
s
c

range()函数

Python函数range()让你能够轻松地生成一系列的数字。

range(0,5)  # 生成0,1,2,3,4

打印九九乘法表

for i in range(1, 10):
        for j in range(1, i+1):
            print('{}x{}={}\t'.format(i, j, i*j), end='')
        print()

#输出结果
1x1=1   
2x1=2   2x2=4   
3x1=3   3x2=6   3x3=9   
4x1=4   4x2=8   4x3=12  4x4=16  
5x1=5   5x2=10  5x3=15  5x4=20  5x5=25  
6x1=6   6x2=12  6x3=18  6x4=24  6x5=30  6x6=36  
7x1=7   7x2=14  7x3=21  7x4=28  7x5=35  7x6=42  7x7=49  
8x1=8   8x2=16  8x3=24  8x4=32  8x5=40  8x6=48  8x7=56  8x8=64  
9x1=9   9x2=18  9x3=27  9x4=36  9x5=45  9x6=54  9x7=63  9x8=72  9x9=81

随机数

在 Python 中，要使用随机数，首先需要导入 随机数 的 模块 —— “工具包”

import random

导入模块后，可以直接在 模块名称 后面敲一个 . ，会提示该模块中包含的所有函数
random.randint(a, b)，返回 [a, b] 之间的整数，包含 a 和 b

random.randint(12, 20)  # 生成的随机数n: 12 <= n <= 20   
random.randint(20, 20)  # 结果永远是 20   
random.randint(20, 10)  # 该语句是错误的，下限必须小于上限

3、列表和元组

3.1 List列表

List 列表—一组有序、可变的数据集合；我们可以通过 List 列表的索引编号（位置编码）来访问列表中的元素；
集合中的任何一个元素，称为集合的元素或者成员；
同一个列表集合中可以同时存储数字、字符、字符串，甚至包含另一个 List；
创建 List 列表的方法有两种：

# 创建的时候直接复制
list01 = [100,90,80,70]

# 创建空 list 然后插入
list01 = []
list01.append(100)
list01.append(90)

访问list中的元素

list01 = [10,20,30,40,50,60,70,80,90,100]
print(list01[0])    # 结果：10 解释：访问列表集合的第一个元素
print(list01[-1])   # 结果：100 解释：访问集合的最后一个元素
print(list01[4:])   # 结果：[50,60,70,80,90,100]
print(list01[:4])   # 结果：[10,20,30,40] 解释：如果只有右边的数字，右边的编号取不到
print(list01[:-5])  # 结果：[10,20,30,40,50]
print(list01[-5:])  # 结果：[60,70,80,90,100]
print(list01[1:5])  # 结果：[20,30,40,50]
print(list01[-4:-1])    # 结果：[70,80,90]
print(list01[1::2])  #结果：[20, 40, 60, 80, 100] 解释：[开始索引:结束索引:每次变化索引]
print(list01[-1:-4:-1]) # 结果：[100,90,80]

基本操作

# 把list01的值赋给list02
list01 = [1,2,3]
list02 = list01  

# 使用copy把list01的值拷贝给list03
list03 = list01.copy()  

# 让两个list集合合并
list01 = [1,2,3]
list02 = [4,5,6]
print(list01+list02)  

# 返回list集合元素的个数
list01 = ['a','b','c']
print(len(list01))  

# 使用成员运算符
list01 = ['a','b','c']
print("a是否在list01中",'a' in list01)  # in、not in都可以使用

# 元素的添加
list02.append("AAA")
list02.insert(1,"CCC")
# 使用 extend 添加，可以添加一个集合
list02.extend(["DDD","EEE","FFF"])

# 元素的删除
list01.remove('f')
list01.pop(1)   # 删除第二个元素
del list01[1:5] # 切片删除第二个到第五个
list01.clear()  # 清空list中所有的元素

基本运算

list01 = [45,90,123,987,-10,78,96]
print("List01的最大值：",max(list01))
print("List01的最小值：",min(list01))
print("list所有元素和:%d"%sum(list01))
# 使用 sort()进行排序，默认是升序
list01.sort()
# 先升序，再反转。使用 reverse()方法进行逆序操作
list01 = [12,33,44,55,6,22]
list01.sort()
list01.reverse()
# 添加参数
list01 = [12,33,44,55,6,22]
list01.sort(reverse=True)
print(list01)

OpenCV

OpenCV中文文档

1，图像

A.图像入门

cv2.imread("img/time.jpg",cv2.IMREAD_COLOR)

  • 第一空：图像路径
  • 第二空：指定图像的读取方式
    • IMREAD_COLOR 加载彩色图像
    • IMREAD_GRAYSCALE 灰度图像
    • IMREAD_UNCHANGED 加载图像，包括alpha通道
    • 注意 除了这三个标志，你可以分别简单地传递整数1、0或-1。

cv2.imshow("图像的名字",img) #显示图片

cv2.imwrite("文件名",img) #保存图片

cv.waitKey()是一个键盘绑定函数。其参数是以毫秒为单位的时间。该函数等待任何键盘事件指定的毫秒。如果您在这段时间内按下任何键，程序将继续运行。如果0被传递，它将无限期地等待一次敲击键。它也可以设置为检测特定的按键，例如，如果按下键 a 等，我们将在下面讨论。

  • 如果使用的是64位计算机，则必须k = cv.waitKey(0)按如下所示修改行：k = cv.waitKey(0) & 0xFF

cv.destroyAllWindows()只会破坏我们创建的所有窗口。如果要销毁任何特定的窗口，请使用函数

cv.destroyWindow()在其中传递确切的窗口名称作为参数。

import cv2 # opencv的读取格式为BGR
import matplotlib.pyplot as plt
import numpy as np

img = cv2.imread("img/time.jpg",cv2.IMREAD_COLOR) # 读取彩色图像
img2 = cv2.imread("img/time.jpg",cv2.IMREAD_GRAYSCALE) # 读取灰度图像
# print(img)

cv2.imshow("image",img) # 图像显示
cv2.imshow("image2",img2) # 图像显示
cv2.waitKey(0) # 等待时间，毫秒级，0表示任意键终止
cv2.destroyAllWindows() 

cv2.imwrite("img/time-change.jpg",img) # 保存图片

import numpy as np
import cv2
img = cv2.imread('img/time.jpg',0)
cv2.imshow('image',img)
k = cv2.waitKey(0)
if k == 27:         # 等待ESC退出
    cv2.destroyAllWindows()
elif k == ord('s'): # 等待关键字，保存和退出
    cv2.imwrite('img/time-c.jpg',img)
    cv2.destroyAllWindows()

使用Matplotlib

Matplotlib是Python的绘图库，可为你提供多种绘图方法。

import matplotlib.pyplot as plt

OpenCV加载的彩色图像处于BGR模式。但是Matplotlib以RGB模式显示。因此，如果使用OpenCV读取彩色图像，则Matplotlib中将无法正确显示彩色图像。

B.图像的基本操作

1,访问像素值并修改它们

对于单个像素访问，Numpy数组方法array.item()和array.itemset())被认为更好，但是它们始终返回标量。如果要访问所有B，G，R值，则需要分别调用所有的array.item()。

import cv2 as cv # opencv的读取格式为BGR
import matplotlib.pyplot as plt
import numpy as np

# 读取图像
img = cv.imread("img/time.jpg")
print(img.item(10,10,2))  # 输出111
img.itemset((10,10,2),33) # 修改像素
print(img.item(10,10,2))  # 输出33
cv.imshow("change",img)
cv.waitKey(0)

2,访问图像属性

图像属性包括行数，列数和通道数，图像数据类型，像素数等。

图像的形状可通过img.shape访问。它返回行，列和通道数的元组（如果图像是彩色的）

像素总数可通过访问img.size

图像数据类型通过img.dtype获得

import cv2 as cv # opencv的读取格式为BGR
import matplotlib.pyplot as plt
import numpy as np
# 读取图像
img = cv.imread("img/time.jpg")
# 图像的形状
print("shape---->",img.shape)  # 输出(400,400,3)
# 图像大小
print("size----->",img.size)   # 输出480000
# 数据类型
print("dtype---->",img.dtype ) # 输出uint8
cv.imshow("change",img)
cv.waitKey(0)

注意

  • img.dtype在调试时非常重要，因为OpenCV-Python代码中的大量错误是由无效的数据类型引起的。
  • 如果图像是灰度的，则返回的元组仅包含行数和列数，因此这是检查加载的图像是灰度还是彩色的好方法。

3,分割和合并图像

b,g,r = cv.split(img)
img = cv.merge((b,g,r))

注意：cv.split()是一项耗时的操作（就时间而言）。因此，仅在必要时才这样做。否则请进行Numpy索引。

4,为图像设置边框

如果要在图像周围创建边框（如相框），则可以使用cv.copyMakeBorder()。但是它在卷积运算，零填充等方面有更多应用。此函数采用以下参数：

  • src - 输入图像
  • top，bottom，left，right 边界宽度（以相应方向上的像素数为单位）
  • borderType - 定义要添加哪种边框的标志。它可以是以下类型：
    • cv.BORDER_CONSTANT - 添加恒定的彩色边框。该值应作为下一个参数给出。
    • cv.BORDER_REFLECT - 边框将是边框元素的镜像，如下所示： fedcba | abcdefgh | hgfedcb
    • cv.BORDER_REFLECT_101或 cv.BORDER_DEFAULT与上述相同，但略有变化，例如： gfedcb | abcdefgh | gfedcba
    • cv.BORDER_REPLICATE最后一个元素被复制，像这样： aaaaaa | abcdefgh | hhhhhhh
    • cv.BORDER_WRAP难以解释，它看起来像这样： cdefgh | abcdefgh | abcdefg
  • value -边框的颜色，如果边框类型为cv.BORDER_CONSTANT
import cv2 as cv
import matplotlib.pyplot as plt

BLUE = [255,0,0]
img1 = cv.imread('img/time.jpg')
replicate = cv.copyMakeBorder(img1,20,10,10,10,cv.BORDER_REPLICATE)
reflect = cv.copyMakeBorder(img1,10,10,10,10,cv.BORDER_REFLECT)
reflect101 = cv.copyMakeBorder(img1,10,10,10,10,cv.BORDER_REFLECT_101)
wrap = cv.copyMakeBorder(img1,10,10,10,10,cv.BORDER_WRAP)
constant= cv.copyMakeBorder(img1,10,10,10,10,cv.BORDER_CONSTANT,value=BLUE)

plt.subplot(231),plt.imshow(img1,'gray'),plt.title('ORIGINAL')
plt.subplot(232),plt.imshow(replicate,'gray'),plt.title('REPLICATE')
plt.subplot(233),plt.imshow(reflect,'gray'),plt.title('REFLECT')
plt.subplot(234),plt.imshow(reflect101,'gray'),plt.title('REFLECT_101')
plt.subplot(235),plt.imshow(wrap,'gray'),plt.title('WRAP')
plt.subplot(236),plt.imshow(constant,'gray'),plt.title('CONSTANT')
plt.show()

1+X计算机视觉考证一些知识点_第1张图片

5,图像上的算术运算

可以通过OpenCV函数cv.add()或仅通过numpy操作res = img1 + img2添加两个图像。两个图像应具有相同的深度和类型，或者第二个图像可以只是一个标量值。

注意：OpenCV加法和Numpy加法之间有区别。OpenCV加法是饱和运算，而Numpy加法是模运算。

图像融合

这也是图像加法，但是对图像赋予不同的权重，以使其具有融合或透明的感觉。根据以下等式添加图像：

G ( x ) = ( 1 − α ) f 0 ( x ) + α f 1 ( x ) G(x)=(1−α)f_0(x)+αf_1(x) G(x)=(1−α)f0​(x)+αf1​(x)

cv.addWeighted()在图像上应用以下公式。

d s t = α ⋅ i m g 1 + β ⋅ i m g 2 + γ dst=α⋅img1+β⋅img2+γ dst=α⋅img1+β⋅img2+γ

import cv2 as cv # opencv的读取格式为BGR
import matplotlib.pyplot as plt
import numpy as np

img1 = cv.imread('img/time.jpg')
img2 = cv.imread('img/opencv.png')
dst = cv.addWeighted(img1,0.7,img2,0.3,0)
cv.imshow('dst',dst)
cv.waitKey(0)
cv.destroyAllWindows()

两张图片：数组具有相同的大小和相同数量的通道

掩膜（mask）

？有点像PS里的蒙版

数字图像处理中,掩模为二维矩阵数组,有时也用多值图像。数字图像处理中,图像掩模主要用于：

  • 提取感兴趣区：用预先制作的感兴趣区掩模与待处理图像相乘,得到感兴趣区图像,感兴趣区内图像值保持不变,而区外图像值都为0。
  • 屏蔽作用：用掩模对图像上某些区域作屏蔽,使其不参加处理或不参加处理参数的计算,或仅对屏蔽区作处理或统计
  • 结构特征提取,用相似性变量或图像匹配方法检测和提取图像中与掩模相似的结构特征。
  • 特殊形状图像的制作。

例如：mask中的 1 就是感兴趣的区域，感兴趣区内图像值保持不变，而区外图像值都为0。

1+X计算机视觉考证一些知识点_第2张图片

cv.bitwise_and是对二进制数据进行“与”操作，即对图像（灰度图像或彩色图像均可）每个像素值进行二进制“与”操作

  • 1&1=1，1&0=0，0&1=0，0&0=0​

cv.bitwise_or是对二进制数据进行“或”操作，即对图像（灰度图像或彩色图像均可）每个像素值进行二进制“或”操作

  • 1 ∣ 1 = 1 ， 1 ∣ 0 = 1 ， 0 ∣ 1 = 1 ， 0 ∣ 0 = 0 1|1=1，1|0=1，0|1=1，0|0=0 1∣1=1，1∣0=1，0∣1=1，0∣0=0

cv.bitwise_xor是对二进制数据进行“异或”操作，即对图像（灰度图像或彩色图像均可）每个像素值进行二进制“异或”操作

  • 1 1 = 0 , 1 0 = 1 , 0 1 = 1 , 0 0 = 0 1^1=0,1^0=1,0^1=1,0^0=0 11=0,10=1,01=1,00=0

cv.bitwise_not是对二进制数据进行“非”操作，即对图像（灰度图像或彩色图像均可）每个像素值进行二进制“非”操作

  • !1=0，!0=1

mask和原图必须有相同的shape和dtype

6,OpenCV中的绘图功能

cv.line() cv.circle() cv.rectangle() cv.ellipse() cv.putText()

  • 参数
    • img：您要绘制形状的图像
    • color：形状的颜色。对于BGR，将其作为元组传递，例如：(255,0,0)对于蓝色。对于灰度，只需传递标量值即可。
    • 厚度：线或圆等的粗细。如果对闭合图形（如圆）传递-1 ，它将填充形状。默认厚度= 1
    • lineType：线的类型，是否为8连接线，抗锯齿线等。默认情况下，为8连接线。cv2.LINE_AA给出了抗锯齿的线条，看起来非常适合曲线。

C.图像处理 cv2.cvtColor

cv2.cvtColor(input_image, flag)

OpenCV中有超过150种颜色空间转换方法。但是我们将研究只有两个最广泛使用的,BGR↔灰色和BGR↔HSV。

对于颜色转换，我们使用cv函数。cvtColor(input_image, flag)，其中flag决定转换的类型。

对于BGR→灰度转换，我们使用标志cv.COLOR_BGR2GRAY。

对于BGR→HSV，我们使用标志cv.COLOR_BGR2HSV

注意：HSV的色相范围为[0,179]，饱和度范围为[0,255]，值范围为[0,255]。因此，如果你要将OpenCV值和它们比较，你需要将这些范围标准化

练习：提取图像中的蓝色部分

import cv2 as cv
import numpy as np
# 读取图片
img = cv.imread("img/opencv.png")
# 转换颜色空间 BGR 到 HSV
hsv = cv.cvtColor(img, cv.COLOR_BGR2HSV)
# 定义HSV中蓝色的范围
lower_blue = np.array([110,50,50])
upper_blue = np.array([130,255,255])
# 设置HSV的阈值使得只取蓝色
mask = cv.inRange(hsv, lower_blue, upper_blue)
# 将掩膜和图像逐像素相加
res = cv.bitwise_and(img,img, mask= mask)
cv.imshow('img',img)
cv.imshow('mask',mask)
cv.imshow('res',res)
cv.waitKey(0)
cv.destroyAllWindows()

D.图像几何变换

翻转

cv2.flip(filename, flipcode)

  • filename：需要操作的图像
  • flipcode：翻转方式
    • 1：水平翻转
    • 0：垂直翻转
    • -1：水平垂直翻转

变换

OpenCV提供了两个转换函数cv.warpAffine和cv.warpPerspective，您可以使用它们进行各种转换。

cv.warpAffine采用2x3转换矩阵，而cv.warpPerspective采用3x3转换矩阵作为输入

缩放

缩放只是调整图像的大小。为此，OpenCV带有一个函数cv.resize()。图像的大小可以手动指定，也可以指定缩放比例。也可使用不同的插值方法。首选的插值方法是cv.INTER_AREA（慢）和cv.INTER_LINEAR用于缩放。默认情况下，出于所有调整大小的目的，使用的插值方法为cv.INTER_LINEAR。

平移

平移是物体位置的移动。如果您知道在(x,y)方向上的位移，则将其设为 ( t x , t y ) (t_x,t_y) (tx​,ty​)，你可以创建转换矩阵M，如下所示：

M = [ 1 0 t x 0 1 t y ] M=\begin{bmatrix}1 & 0 & t_x \\ 0 & 1 & t_y\\ \end{bmatrix} M=[10​01​tx​ty​​]

您可以将其放入np.float32类型的Numpy数组中，并将其传递给cv.warpAffine函数。

1+X计算机视觉考证一些知识点_第3张图片

import numpy as np
import cv2 as cv
img = cv.imread('img/time.jpg',0)
rows,cols = img.shape
M = np.float32([[1,0,100],[0,1,50]])
dst = cv.warpAffine(img,M,(cols,rows))
cv.imshow('img',dst)
cv.waitKey(0)
cv.destroyAllWindows()

警告：cv.warpAffine函数的第三个参数是输出图像的大小，其形式应为(width，height)。记住width =列数，height =行数。

E.图像阈值 cv.threshold

对于每个像素，应用相同的阈值（thresh）。如果像素值小于阈值，则将其设置为0，否则将其设置为最大值。

函数cv.threshold(src,thresh,maxval,type)用于应用阈值。

  • src：输入图，只能输入单通道的图像，通常来说是灰度图像。
  • thresh：阈值，用于对像素值进行分类。
  • maxval：当像素值超过了阈值（或者小于阈值，根据type来决定），所赋予的值
  • type：所有简单的阈值类型为
    • cv.THRESH_BINARY ——超过阈值部分取maxval(最大值)，否则取零
    • cv.THRESH_BINARY_INV ——超过阈值部分取零，否则取maxval(最大值)
    • cv.THRESH_TRUNC ——大于阈值部分设为阈值，否则设为0
    • cv.THRESH_TOZERO ——大于阈值部分不改变，否则设为0
    • cv.THRESH_TOZERO_INV ——大于阈值部分设为0，否则不变
ret,thresh = cv2.threshold(img,127,255,cv.THRESH_BINARY) # 将图像二值化

F.图像平滑

讲解滤波的视频

1，滤波

均值滤波 #简单的平均卷积操作

cv2.blur(img,(3,3)) 一般是奇数(3,3), (5,5)，(7,7)

方框滤波（和均值滤波一样，可以选择归一化，容易越界）

cv2.boxFilter(img,-1,(3,3),normalize=True)

高斯滤波

cv2.GaussianBlur(img,(5,5),1)

高斯滤波是一种线性平滑滤波，适用于消除高斯噪声，广泛应用于图像处理的减噪过程。通俗的讲，高斯滤波就是对整幅图像进行加权平均的过程，每一个像素点的值，都由其本身和邻域内的其他像素值经过加权平均后得到

中值滤波

cv2.medianBlur(img,5) 可以用来去除椒盐噪声(也称为脉冲噪声)

中值滤波 是一种非线性平滑技术。中值滤波是在“最小绝对误差”准则下的最优滤波。中值滤波对脉冲噪声有良好的滤除作用，特别是在滤除噪声的同时，能够保护信号的边缘，使之不被模糊。这些优良特性是线性滤波方法所不具有的。

中值滤波不是一种边缘增强算子。中值滤波是一种图象去噪（或图象平滑）算子。

2，噪声

椒盐噪声(也称为脉冲噪声)

1+X计算机视觉考证一些知识点_第4张图片

就是图像上出现了一个一个的点

高斯噪声

高斯噪声是指它的概率密度函数服从高斯分布（即正态分布）的一类噪声

1+X计算机视觉考证一些知识点_第5张图片

G.形态学转化

通常是二进制的图像，就只有黑白

1，腐蚀操作cv2.erode(img,kernel)

kernel = np.ones((3,3),np.uint8)
erosion = cv2.erode(img,kernel,iterations = 1)
  • iterations：腐蚀次数

结果是，根据内核的大小，边界附近的所有像素都会被丢弃。因此，前景物体的厚度或大小减小，或只是图像中的白色区域减小。它有助于去除小的白色噪声，分离两个连接的对象等。

2，膨胀操作cv.dilate(img,kernel)

就是加粗效果

kernel = np.ones((3,3),np.uint8)
dilation = cv.dilate(img,kernel,iterations = 1)

图像膨胀操作过程

  • 读取灰度图像
  • 二值化处理图像
  • 声明结构函数
  • 应用膨胀函数

3，开运算和闭运算

  • 开运算：腐蚀然后膨胀它对于消除噪音很有用。它可以消除细小的物体、在纤细点处分离物体、平滑较大物体的边界时不明显的改变其面积。
  • 闭运算：先膨胀然后再侵蚀，在关闭前景对象内部的小孔或对象上的小黑点时很有用。它具有填充物体内细小的空洞、连接邻近物体、在不明显改变物体面积的情况下平滑其边界的作用。
    1+X计算机视觉考证一些知识点_第6张图片
    消除连续区域内的小噪声点可以通过连续多次使用开闭运算（对）
kernel = np.ones((3,3),np.uint8)
opening = cv.morphologyEx(img, cv.MORPH_OPEN, kernel) 
closing = cv.morphologyEx(img, cv.MORPH_CLOSE, kernel)

4，顶帽和黑帽

  • 顶帽运算：输入图像和图像开运算之差
  • 黑帽运算：输入图像和图像闭运算之差
kernel = np.ones((3,3),np.uint8)
tophat = cv.morphologyEx(img, cv.MORPH_TOPHAT, kernel) 
blackhat = cv.morphologyEx(img, cv.MORPH_BLACKHAT, kernel)

H.图像金字塔

1，高斯金字塔

高斯金字塔：向下采样（从金字塔底端到顶端）——缩小

cv2.pyrDown(img)：将所有偶数行和列去除。

高斯金字塔：向上采样（从金字塔顶端到底端）——放大

cv2.pyrUp(img)

  • 将图像在每个方向扩大为原来的两倍，新增的行和列以O填充
  • 使用先前同样的内核(乘以4)与放大后的图像卷积，获得近似值

2，拉普拉斯金字塔

拉普拉斯金字塔的层由高斯金字塔的层与高斯金字塔的高层的扩展版本之间的差形成。

  • 获取在采样过程中所丢失的信息，这些丢失的信息构成拉普拉斯金字塔
  • 拉普拉斯金字塔可以认为是残差金字塔，用来存储下采样后图片与原始图片的差异。
  • 拉普拉斯金字塔后的重建图像与原始图像可能存在差异

I.轮廓

边缘是零散的点，轮廓是整体

  • 为了获得更高的准确性，请使用二进制图像。因此，在找到轮廓之前，请应用阈值或canny边缘检测。
  • 从OpenCV 3.2开始，findContours()不再修改源图像。
  • 在OpenCV中，找到轮廓就像从黑色背景中找到白色物体。因此请记住，要找到的对象应该是白色，背景应该是黑色。

cv2.findContours(img,mode,method) —— 检索轮廓

  • img：图片路径
  • mode：轮廓检索模式：
    • cv2.RETR_EXTERNAL:表示只检测外轮廓
    • cv2.RETR_LIST:检测的轮廓不建立等级关系
    • cv2.RETR_CCOMP:建立两个等级的轮廓，上面的一层为外边界，里面的一层为内孔的边界信息。如国内筒内还有一个连通物体，这个物体的边界也在顶层
    • cv2.RETR_TREE：建立一个等级树结构的轮廓。最常用的模式，检索所有的轮廓，并重构嵌套轮廓的层次
  • method：轮廓的近似方法：
    • cv2.CHAIN_APPROX_NONE：存储所有的轮廓点，相邻两个点的像素位置差不超过1，以Freeman链码的方式输出轮廓，所有其他方法输出多边形
    • cv2. cv2.CHAIN_APPROX_SIMPLE：简化保存，比如矩形轮廓就只保存四个顶点的轮廓点。压缩水平的，垂直的和斜的部分，也就是，函数只保留他们的重点部分。
    • cv2.CHAIN_APPROX_TC89_L1:使用teh-Chinl chain近似算法
    • cv2.CHAIN_APPROX_TC89_KCOS：使用teh-Chinl chain近似算法
binary, contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)

binary：图片结果

contours：保存的事轮廓信息

cv.drawContours(img, contours, -1, (0,255,0), 3) ——绘制所有轮廓
绘制轮廓 drawContours(image, contours, contourIdx, color, thickness)

例如：mask = cv.drawContours(mask,contours,-1,(255,255,255),-1)

  • image：图像
  • contours：轮廓
  • contourIdx：需要绘制的轮廓的指数 (-1 表示 “all”)
  • color：绘制的颜色
  • thickness：轮廓线的宽度。-1就是填充轮廓

cv2.arcLength() 函数用于计算封闭轮廓的周长或曲线的长度

cv2.contourArea()计算轮廓面积

cv.minEnclosingCircle()查找最小包围圈

cv2.minAreaRect()生成最小斜矩形（图中的红线）

cv2.boundingRect()生成最小外接矩形（图中的绿线）
1+X计算机视觉考证一些知识点_第7张图片

J.Canny边缘检测和图像梯度

边缘检测

图像边缘是指图像局部特性的不连续性。

图像中存在边缘时，一定有较大的梯度值。

cv.Canny()

Canny算法是一种被广泛应用于边缘检测的标准算法，其目标是找到一个最优的边缘检测解或找寻一幅图像中灰度强度变换最强的位置。最优边缘检测主要通过低错误率，高定位性和最小响应三个标准进行评价。Canny算子的实现步骤如下：

  • step1: 用高斯滤波器平滑图象；
  • step2: 计算图像中每个像素点的梯度强度和方向（用一阶偏导的有限差分来计算梯度的幅值和方向）；
  • step3: 对梯度幅值进行非极大值抑制（Non-Maximum Suppression），以消除边缘检测带来的杂散响应；
  • step4: 用双阈值算法(Double-Threshold)检测来确定真实和潜在的边缘，通过抑制孤立的弱边缘最终完成边缘检测；

Canny边缘检测算法是具有严格定义的
Canny算法具有满足边缘检测的三个标准和实现过程简单的优势
Canny算法寻找一幅图像中灰度强度变化最强的位置

图像梯度：图像就是函数

图像梯度是指图像某像素在x和y两个方向上的变化率（与相邻像素比较），是一个二维向量，由2个分量组成，X轴的变化、Y轴的变化 。

其中 X轴的变化是指当前像素右侧（X加1）的像素值减去当前像素左侧（X减1）的像素值。
同理，Y轴的变化是当前像素下方（Y加1）的像素值减去当前像素上方（Y减1）的像素值。

K.特征检测

拐点被认为是图像中的良好特征，物体的良好特性包括尺度不变性与旋转不变性

  • 尺度不变性：人类在识别一个物体时，不管这个物体或远或近，都能对它进行正确的辨认，这就是所谓的尺度不变性
  • 旋转不变性：当这个物体发生旋转时，我们照样可以正确地辨认它，这就是所谓的旋转不变性。

1，SIFT

尺度不变特征转换(Scale-invariant feature transform或SIFT)是一种电脑视觉的算法用来侦测与描述影像中的局部性特征，它在空间尺度中寻找极值点，并提取出其位置、尺度、旋转不变量，

SIFT算法的特点有：

  1. SIFT特征是图像的局部特征，其对旋转、尺度缩放、亮度变化保持不变性，对视角变化、仿射变换、噪声也保持一定程度的稳定性；
  2. 独特性（Distinctiveness）好，信息量丰富，适用于在海量特征数据库中进行快速、准确的匹配；
  3. 多量性，即使少数的几个物体也可以产生大量的SIFT特征向量；
  4. 高速性，经优化的SIFT匹配算法甚至可以达到实时的要求；
  5. 可扩展性，可以很方便的与其他形式的特征向量进行联合。

SIFT算法可以解决的问题：目标的自身状态、场景所处的环境和成像器材的成像特性等因素影响图像配准/目标识别跟踪的性能。而SIFT算法在一定程度上可解决：

  • 目标的旋转、缩放、平移（RST）
  • 图像仿射/投影变换（视点viewpoint）
  • 光照影响（illumination）
  • 目标遮挡（occlusion）
  • 杂物场景（clutter）
  • 噪声

检测特征点: sift.detect(image,keypoints) 或 keypoint = sift.detect(image, None)

SIFT的特征提取函数为detectAndCompute
特征提取可以获得所有的特征点

2，Brute-Force匹配器

Brute-Force匹配器也就是蛮力匹配器，顾名思义，它的工作原理是：在第一幅图像上选取一个关键点，然后依次与第二幅图像的每个关键点进行（描述符）距离测试，最后返回距离最近的关键点。

创建一个BFMatcher对象cv.BFMatcher(normType,corssCheck)

  • 第一个是normType，它用来指定要使用的距离测试类型。
    默认值为cv.NORM_L2,这个类型很适合SIFT和SURF等（cv.NORM_L1也可以）。对于使用二进制描述符的ORB,BRIEF,BRISK算法等，要使用cv.NORM_HAMMING，这样就会返回两个测试对象间的汉明距离。如果ORB算法的参数设置为MTA_K==3或4，normType就应该设置为cv.NORM_HAMMING2。
  • 第二个参数是布尔变量corssCheck，默认值为False。如果设置为True，匹配条件就会更加严格，只有到A中的第i个特征点与B中的第j个特征点距离最近，并且B中的第j个特征点到A中的第i个特征点也是最近（A中没有其他的点到j的距离最近）时才会返回最佳匹配（i, j）。也就是这两个特征点要互相匹配才行。这样就能提供统一的结果，这可以用来代替D.Lowe在SIFT文章中提出的比值测试方法。

BFMatcher对象有两个方法

  • bf.match()：会返回最佳匹配。
  • bf.knnMatch()：每个关键点返回k个匹配（降序排列之后取前K个），其中K是由用户设定的。

L.直方图

通过查看图像的直方图，您可以直观地了解该图像的对比度，亮度，强度分布等

灰度直方图能反映一幅图像各灰度级像元占图像的面积比。

cv.calcHist([images]，channels，mask，histSize，ranges)

  • images：它是uint8或float32类型的源图像。它应该放在方括号中，即“ [img]”。
  • channels：也以方括号给出。它是我们计算直方图的通道的索引。例如，如果输入为灰度图像，则其值为[0]。对于彩色图像，您可以传递[0]，[1]或[2]分别计算蓝色，绿色或红色通道的直方图。
  • mask：图像掩码。为了找到完整图像的直方图，将其指定为“无”。但是，如果要查找图像特定区域的直方图，则必须为此创建一个掩码图像并将其作为掩码。
  • histSize：这表示我们的BIN计数。需要放在方括号中。对于全尺寸，我们通过[256]。
  • ranges：这是我们的RANGE。通常为[0,256]。

2，视频

cv2.VideoCapture("视频路径") #读取图像

import cv2
import matplotlib.pyplot as plt
import numpy as np

vc = cv2.VideoCapture("img/test.mp4")
while vc.isOpened():
    ret ,frame = vc.read() # 如果正确读取帧，ret为True
    if frame is None:
        break
    if ret == True:
        gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY) # 将BGR格式变成灰度图像
        print("gray----------->",gray)
        cv2.imshow("result",gray)
        if cv2.waitKey(30) & 0xFF == 27:
            break
vc.release()
cv2.destroyAllWindows()

cv2.VideoWriter_fourcc('','','','')

  • cv2.VideoWriter_fourcc('I','4','2','0')—未压缩的YUV颜色编码，4:2:0色度子采样。兼容性好，但文件较大。文件扩展名**.avi**
  • cv2.VideoWriter_fourcc('P','I','M','1')—MPEG-1编码类型，文件扩展名**.avi**。随机访问，灵活的帧率、可变的图像尺寸、定义了I-帧、P-帧和B-帧 、运动补偿可跨越多个帧 、半像素精度的运动向量 、量化矩阵、GOF结构 、slice结构 、技术细节、输入视频格式。
  • cv2.VideoWriter_fourcc('X','V','I','D')—MPEG-4编码类型，视频大小为平均值，MPEG4所需要的空间是MPEG1或M-JPEG的1/10，它对运动物体可以保证有良好的清晰度，间/时间/画质具有可调性。文件扩展名**.avi**。
  • cv2.VideoWriter_fourcc('T','H','E','O')—OGGVorbis，音频压缩格式，有损压缩，类似于MP3等的音乐格式。，兼容性差，件扩展名**.ogv**。
  • cv2.VideoWriter_fourcc('F','L','V','1')—FLV是FLASH VIDEO的简称，FLV流媒体格式是一种新的视频格式。由于它形成的文件极小、加载速度极快，使得网络观看视频文件成为可能，它的出现有效地解决了视频文件导入Flash后，使导出的SWF文件体积庞大，不能在网络上很好的使用等缺点。文件扩展名为**.flv**。

cv2.VideoCapture("img/test.mp4").get(propId)方法访问该视频的某些功能

  • 例如：cv2.VideoCapture("img/test.mp4").get(cv.CAP_PROP_FRAME_WIDTH)：检查框架的宽度
    cv2.VideoCapture("img/test.mp4").get(cv.CAP_PROP_FRAME_HEIGHT)检查框架高度

其中一些值可以使用cv2.VideoCapture("img/test.mp4").set(propId，value)进行修改。value是你想要的新值。

读取视频帧率：frame_count = capture.get(cv2.CAP_PROP_FRAME_COUNT)

机器学习

基于学习方式的分类

  • 监督学习:K-近邻算法、决策树、朴素贝叶斯、逻辑回归、卷积神经网络
  • 非监督学习:聚类、EM算法、受限波尔兹曼机等

1+X计算机视觉考证一些知识点_第8张图片
1+X计算机视觉考证一些知识点_第9张图片

历史数据、训练、模型、预测等属于机器学习过程范畴
监督学习又叫做回归问题（应该是回归问题是监督学习问题的一种）

常见算法

  • 决策树算法
  • 朴素贝叶斯算法
  • 支持向量机算法
  • 随机森林算法
  • 人工神经网络算法
  • Boosting与Bagging算法
  • 关联规则算法
  • EM（期望最大化）算法
  • 深度学习

深度学习

深度学习（DL，Deep Learning）是机器学习（ML，Machine Learning）领域中一个新的研究方向，它被引入机器学习使其更接近于最初的目标——人工智能（AI，Artificial Intelligence）。

深度学习是学习样本数据的内在规律和表示层次，这些学习过程中获得的信息对诸如文字，图像和声音等数据的解释有很大的帮助。它的最终目标是让机器能够像人一样具有分析学习能力，能够识别文字、图像和声音等数据。 深度学习是一个复杂的机器学习算法，在语音和图像识别方面取得的效果，远远超过先前相关技术。

深度学习在搜索技术、数据挖掘、机器学习、机器翻译、自然语言处理、多媒体学习、语音、推荐和个性化技术，以及其他相关领域都取得了很多成果。
使用深度学习框架完成建模任务有两个显著优势：

  • 节省大量编写底层代码的精力：屏蔽底层实现，用户只需关注模型的逻辑结构，降低了深度学习入门门槛。
  • 省去了部署和适配环境的烦恼：飞桨框架具备灵活的移植性，可将代码部署到CPU/GPU/移动端上，选择具有分布式性能的深度学习工具会使模型训练更高效，预测端也针对大量的硬件进行了适配和优化工作。

常见的深度学习优化器

  • 随机梯度下降(SGD, stochastic gradient descent)：最常用的方法
  • 动量（momentum）
  • Nesterov 动量
  • AdaGrad（自适应梯度算法）
  • RMSProp
  • Adam（自适应矩估计）

深度学习防止过拟合的几种方法

  • L1,L2正则化，L1又被成为 Lasso
  • early stopping
  • bagging 和其他集成方法
  • 辅助分类节点(auxiliary classifiers)
  • Dropout
  • Batch Normalization

深度学习模型

  • AlexNet
  • VGG Net
  • LENet
  • GoogleNet
  • ResNet
  • ResNeXt
  • R-CNN
  • YOLO
  • SqueezeNet
  • SegNet
  • GAN

常见的损失函数

  • 图像分类：交叉熵
  • 目标检测：Focal loss，L1/L2损失函数，IOU Loss，GIOU ，DIOU，CIOU
  • 图像识别：Triplet Loss，Center Loss，Sphereface，Cosface，Arcface
  • 均方误差损失函数(MSE)

迁移学习

迁移学习是一种机器学习方法，就是把为任务 A 开发的模型作为初始点，重新使用在为任务 B 开发模型的过程中。

深度学习中，在计算机视觉任务和自然语言处理任务中，将预训练的模型作为新模型的起点是一种常用的方法，通常这些预训练的模型在开发神经网络的时候，已经消耗了巨大的时间资源和计算资源，迁移学习可以将已习得的强大技能迁移到相关的的问题上。

卷积神经网络

什么是卷积核的通道数？CNN的卷积输出通道数又是如何确定的？

CNN的卷积核通道数 = 卷积输入层的通道数
CNN的卷积输出层通道数(深度)= 卷积核的个数

卷积操作后，特征图大小计算

若图像为正方形：设输入图像尺寸为WxW，卷积核尺寸为FxF，步幅为S，Padding使用P,经过该卷积层后输出的图像尺寸为NxN：

N = W − F + 2 P S + 1 N=\frac{W-F+2P}{S}+1 N=SW−F+2P​+1

  • 例题：输入大小为5X5,卷积核的大小为3X3 ,步长为2，最后的得到特征图大小是2X2。

卷积的计算

首先，有几个概念要搞定

输入图片的尺寸：一般用 n × n n×n n×n 表示输入的image大小。

卷积核的大小：一般用 f × f f×f f×f 表示卷积核的大小。

填充（Padding）：一般用 p p p 来表示填充大小。设置填充的目的：希望每个输入方块都能作为卷积窗口的中心

步幅(Stride)：一般用 s s s 来表示步长大小。设置步幅的目的：希望减小输入参数的数目，减少计算量

输出图片的尺寸：一般用 o o o 来表示。计算公式如下： o = n + 2 p − f s + 1 o = \frac{n+2p-f}{s}+1 o=sn+2p−f​+1

1+X计算机视觉考证一些知识点_第10张图片

由题意得： o = 3 , n = 5 , p = 2 o=3,n=5,p=2 o=3,n=5,p=2，代入公式 o = n + 2 p − f s + 1 o = \frac{n+2p-f}{s}+1 o=sn+2p−f​+1
可得 2 s = 9 − f 2s=9-f 2s=9−f，代入一下选项，可得答案为A

具体原理是什么呢？输出的图片是怎么来的呢

假设有一个3×3卷积核 h，和一个待处理的7×7矩阵 x，假设步长为2，就是蓝色区域移动的格数变成了两个。

1+X计算机视觉考证一些知识点_第11张图片

下图中写的应该是步幅（Stride）= 2，这个傻逼作者图片做错了ヾ(｡｀Д´｡)ﾉ彡


这里就可以看出步幅的作用了，成倍的缩小了尺寸。从原图的7×7变成了3×3，但是不能说步幅为2，就缩小2倍，不是很严谨。

上图这种情况指的是padding = 0的情况，没有进行填充。这就导致有些方块不是卷积窗口的中心。

如果padding=2，就是在原图的基础上，向外扩充矩阵，并填充0。如图所示：
1+X计算机视觉考证一些知识点_第12张图片

再按照原来的方式进行计算。

池化

1+X计算机视觉考证一些知识点_第13张图片

1+X计算机视觉考证一些知识点_第14张图片

随机池化（Stochastic Pooling）可以看作在一个池化窗口内对特征图数值进行归一化， 按照特征图归一化后的概率值大小随机采样选择，即元素值大的被选中的概率也大。

池化计算

设输入图像尺寸为WxH，其中W:图像宽，H:图像高，D:图像深度（通道数），卷积核的尺寸为FxF，S:步长

池化后输出图像大小：

W = W − F S + 1 W=\frac{W-F}{S}+1 W=SW−F​+1

H = H − F S + 1 H=\frac{H-F}{S}+1 H=SH−F​+1

池化后输出图像深度为D

BP神经网络

BP神经网络算法又称为误差方向传播算法(Error Back Propagation Training)，简称BP，是监督式学习算法的一种

BP神经网络算法的出现就是为了解决线性不可分的情况的，为解决非线性问题

BP神经网络：通常一个多层神经网络由L层神经元组成，第1层称为输入层，最后一层（第L层）被称为输出层，其它各层均被称为隐含层（第2层~第L-1层）

1+X计算机视觉考证一些知识点_第15张图片

工作信号正向传播

工作信号正向传播：输入信号从 输入层 经 隐含层，神经元传向输出层，在输出端产生输出信号，这是工作信号的正向传播。在信号的向前传递过程中网络的权值是固定不变的，每一层神经元的状态只影响下一层神经元的状态。

BP神经网络可以用于解决回归问题也可以用于解决分类问题。

如果，在输出层不能得到期望的输出，则转入误差信号反向传播。

误差信号反向传播

网络的实际输出与期望输出之间差值即为误差信号，由输出端开始逐层向前传播这是误差信号的反向传播。

在误差信号反向传播的过程中，网络的权值由误差反馈进行调节。通过权值的不断修正，使网络的实际输出更接近期望输出。

归一化 : 归一化是将数据缩小到0- 1之间

min-max标准化

x ＇ = x − m i n A m a x A − m i n A x^＇= \frac{x-minA}{maxA-minA} x＇=maxA−minAx−minA​

VGG

VggNet一共有六种不同的网络结构，但是每种结构都有含有５组卷积，每组卷积都使用３ｘ３的卷积核，每组卷积后进行一个２ｘ２最大池化，接下来是三个全连接层。VGGNet探索了卷积神经网络的深度与其性能之间的关系，成功地构筑了16~19层深的卷积神经网络，证明了增加网络的深度能够在一定程度上影响网络最终的性能，使错误率大幅下降，同时拓展性又很强，迁移到其它图片数据上的泛化性也非常好。
VGG16模型其中不包含输出层

神经网络常见激活函数

Sigmoid函数又名 Logistic 函数，值域为 (0, 1) ，可以将任意一个实数映射到一个介于 (0, 1) 区间之内的值，常用于隐层神经元输出，其函数表达式为： f ( x ) = 1 1 + e − x f(x) = \frac{1}{1+e^{-x}} f(x)=1+e−x1​

  • 优点：Sigmoid 函数求导简便，在在特征相差比较复杂或是相差不是特别大时效果比较
  • 缺点：激活函数计算量大，在反向传播时容易出现梯度消失问题；当x很大或者很小时，函数变化的很慢，会拖慢梯度下降算法

Tanh 函数叫做 反正切 函数，值域为 (-1, 1) ，可以将任意一个实数映射到一个介于 (-1, 1) 区间之内的值，其函数表达式为： f ( x ) = e x − e − x e x + e − x f(x)=\frac{e^{x}-e^{-x}}{e^{x}+e^{-x}} f(x)=ex+e−xex−e−x​

  • 优点：Tanh 函数几乎总比 Sigmoid 函数表现的好，因为函数输出介于 -1 和 1 之间，激活函数的平均值更接近 0，使用 Tanh 函数有类似数据中心化的效果，使得数据的平均值更接近 0，使得下一层的学习更加方便
  • 缺点：在输出层时，我们更希望输出值 y是一个介于 0 和 1 之间的数而不是 -1 和 1 之间； 在二元分类的时候， Tanh 函数作为输出层的表现也不如 Sigmoid 函数； 当 z 很大或者很小时，函数变化的很慢，会拖慢梯度下降算法

Relu函数：解析式： R e l u = m a x ( 0 , x ) Relu=max(0,x) Relu=max(0,x)，ReLU目前仍是最常用的activation function，在搭建人工神经网络的时候推荐优先尝试

softmax函数： S i = e i ∑ e j S_i = \frac{e^i}{\sum e^j} Si​=∑ejei​：映射区间[0，1]，主要用于:离散化概率分布，值域为(0,1)

paddlepaddle

1，导入paddle

import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear

树莓派，英语: Raspberry Pi,是可以运行Linux系统的电脑，为英国树莓派基金会所开发，其主要特点为机身小巧和价格低廉，一经推出便受到各种计 算机爱好者、开发者的喜爱。其处理器(CPU) 使用的是(ARM)架构。

在PaddlePaddlel练完成的模型，想要在在树莓派上的推测，需要转换成Paddlelite格式， 转换需要使用工具为opt

Raspbian是树莓派官方推出的操作系统

Paddle-Lite 框架是 PaddleMobile 新一代架构，重点支持移动端推理预测，特点高性能、多硬件、轻量级，支持PaddleFluid /TensorFlow/Caffe/ONNX模型的推理部署，目前已经支持 ARM CPU, Mali GPU, Adreno GPU, Huawei NPU 等多种硬件，正在逐步增加 X86 CPU, Nvidia GPU 等多款硬件，相关硬件性能业内领先。

create_paddle_predictor函数用来根据CxxConfig或MobileConfig构建预测器。

paddle.nn.Linear实现神经网络的全连接层

2016年，百度开源了PaddIcPaddle,已经发展成为国际主流认可的深度学习平台，下列关于paddlepaddle
说法正确的是(ABCD)。
A、主要包括图像识别、语音识别、情感分析等
B、可以实现CPU/GPU单机和分布式模式
C、支持海量数据、数台机器并行运算
D、该平台易用、高效、灵活和可伸缩等特点

难以分类

计算机显示器的颜色模型为RGB

常见的颜色空间：RGB颜色空间，HSV颜色空间（色调（H），饱和度（S），明度（V）），HSL颜色空间

数字图像中有 ( ABCD ) 基本特征。
A、颜色特征
B、纹理特征
C、形状特征
D、空间关系特征

从图像工程的角度上，属于机器视觉过程的阶段有 ( ABC )。
A、括数字化成像
B、图像处理
C、图像分析
D、图像分割

Flask是一个使用Python编写的轻量级Web应用框架。关于Flask Web开发，使用Flask之前，需要安装，使用pip命令安装:pip install flask

使用Flask开发Web应用的主要步骤包括(ABCD)。
A、创建Flask对象
B、为每个请求创建一个处理的函数
C、在函数上使用注解的形式标识该函数处理哪个请求
D、在函数入口中使用Flask对象的run方法来启动该应用

边缘计算和云计算的区别：

边缘计算的特点：分布式和低延时，效率更高，安全性高，缓解流量压力，依赖数据端处理芯片的性能，设备故障影响小

计算机视觉

计算机视觉是一门研究如何使机器看的科学
计算机视觉从20世纪80年代就开始蓬勃发展
数据量，运算力和算法模型是影响计算机视觉行业发展的三大要素

百度

百度OCR的接口可以通过http的方式调用，也可以通过OCR Python SDK来调用。通过Python SDK调用时，下面(说法有误。

百度银行卡识别接口可以识别出卡片的信息。支持对主流银行卡的卡号、有效期、发卡行、卡片类型。

百度OCR接口调用：
去百度智能云管理中心新建项目，查看生成的AppID、API Key、Secret Key。正确的加载方式：pip install baidu-aip

细化是将一个曲线型物体细化为一条单像素宽的线，以图形化显示出其拓扑性质。(错)

消除连续区域内的小噪声点可以通过连续多次使用开闭运算（对）

图像分割技术是由图像处理向图像分析阶段过渡过程中必须的。

实操题

图像题

Q1T1

# 在桌面/quiz/Q1/data目录下有图片chip.png，利用openCV中的函数查找轮廓。
# 通过遍历每个轮廓的最小包围圆，如果圆的半径大于20 则在chip.png图片上画对应的白色圆圈，
# 并将画圆之后的图片保存为chip2.png，代码文件命名为Q1.py，最终将图片和代码保存在桌面/user/Q1目录下。

import cv2 as cv
img = cv.imread("../quiz/Q1/data/chip.png") # 读取图片
# 轮廓得用二进制图像
img_gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY) # 先转换成灰度图像
ret, img2 = cv.threshold(img_gray,155,255,cv.THRESH_BINARY) # 图像二值化
contours, hierarchy = cv.findContours(img2,cv.RETR_TREE,cv.CHAIN_APPROX_NONE)
for ct in contours:
    (x,y), radius = cv.minEnclosingCircle(ct)
    if(radius > 20.0):
        cv.circle(img,(int(x),int(y)),int(radius),(255,255,255),1)
        cv.imwrite("Q1/chip2.png",img)

# cv.imshow("chip2",img)
# cv.waitKey(0)
# cv.destroyAllWindows()

Q1T2

#在桌面/quiz/Q1/data目录下有一幅图片contours.jpg，使用轮廓绘制功能，提取前景图（图1）和前景对象的二值化（图2）
#然后逐个显示一幅图像内的边缘信息，图3、4，类似下图：由左图1生成2，3、4。
#分别保存为drawContours.jpg、mask.jpg、contours1.jpg、contours2.jpg，
#代码文件命名为Q1.py，最终将图片和代码保存在桌面/user/Q1目录下。

import cv2 as cv
import numpy as np
img = cv.imread("quiz/Q1/data/contours.jpg") # 读取图片
gray = cv.cvtColor(img,cv.COLOR_BGR2GRAY) # 转换成灰度图
ret,img2 = cv.threshold(gray,128,255,cv.THRESH_BINARY) # 转换成二值图
contours,hierarchy = cv.findContours(img2,cv.RETR_TREE,cv.CHAIN_APPROX_NONE) # 查找所有轮廓
mask = np.zeros(img.shape,img.dtype) # 绘制掩膜mask
mask = cv.drawContours(mask,contours,-1,(255,255,255),-1) # 填充轮廓
cv.imwrite("user/Q1/mask.jpg",mask) # 保存图像
dc = cv.bitwise_and(img,mask) # ‘与’操作
cv.imwrite("user/Q1/drawContours.jpg",dc)

# 边缘信息：根据drawContours.jpg绘制轮廓
dc_gray = cv.cvtColor(dc,cv.COLOR_BGR2GRAY) #将drawContours.jpg转换为灰度图
ret,img2 = cv.threshold(dc_gray,128,255,cv.THRESH_BINARY) # 转换成二值图
contours,hierarchy = cv.findContours(img2,cv.RETR_TREE,cv.CHAIN_APPROX_SIMPLE) # 查找重要轮廓
n = len(contours)
for i in range(n):
    temp = np.zeros(img.shape,img.dtype) # 临时画板
    cv.imwrite("user/Q1/contours"+str(i+1)+".jpg",cv.drawContours(temp,contours,i,(255,255,255),2))
    i+=1

Q1T3

# 在桌面/quiz/Q1/data目录下给定的两张图片，使用Python编程操作，利用OpenCV库判断图片的匹配情况。
# 具体流程：首先读取两张图片，初始化SIFT特征提取器，利用特征提取器分别对两个图像提取特征，
# 将两张图片的特征点分别绘制到各自图片上打印出来，
# 创建使用NORM_L2距离测量方式和crossCheck匹配条件的Brute-Force匹配器，
# 对两幅图像的关键点描述进行匹配并输出匹配的数量，最后计算有效的匹配数量，
# 规则为找到匹配的距离的最大值maxdist，然后最大距离作为参考只保留距离小于0.4*maxdist的哪些匹配点。
# 最终将代码保存在桌面/user/Q1目录下。

import cv2 as cv
dog1 = cv.imread("quiz/Q1/data/dog_1.jpg")
dog2 = cv.imread("quiz/Q1/data/dog_2.jpg")

# 初始化SIFT特征提取器
sift = cv.xfeatures2d.SIFT_create()
# 查找和绘制关键点
kp1, des1 = sift.detectAndCompute(dog1, None)
kp2, des2 = sift.detectAndCompute(dog2, None)

# 绘制关键点
kp_img1 = cv.drawKeypoints(dog1, kp1, dog1)
kp_img2 = cv.drawKeypoints(dog2, kp2, dog2)

# 创建一个BFMatcher匹配器
bf = cv.BFMatcher(cv.NORM_L2, crossCheck=True)
# 进行匹配
matches = bf.match(des1, des2)
print(len(matches))

# 对匹配进行排序
matches = sorted(matches, key=lambda x: x.distance)
maxdist = matches[-1].distance
print(maxdist)

# 保留距离小于0.4*maxdist的匹配点
goodMatches = []
for m in matches:
    if m.distance < 0.4 * maxdist:
        goodMatches.append(m)
    else:
        continue
print(len(goodMatches))

cv.imshow("kp_img1",kp_img1)
cv.imshow("kp_img2",kp_img2)
cv.waitKey(0)
cv.destroyAllWindows()

视频题

Q2T1

# 在桌面/quiz/Q2/data目录下有一段视频in.mp4，请使用python编写代码，读取视频的帧率、宽度、高度值。
# 调用opencv的函数，将该视频另存为flv格式,且视频的帧率、宽、高与in.mp4保持一致，
# 新视频名字为out.flv，代码文件命名为Q2.py，最终将视频和代码保存在桌面/user/Q2目录下

import cv2 as cv
video = cv.VideoCapture("quiz/Q2/data/in.mp4")
width = video.get(cv.CAP_PROP_FRAME_WIDTH)
height = video.get(cv.CAP_PROP_FRAME_HEIGHT)
fps = video.get(cv.CAP_PROP_FPS)
# print("width------>",width)
# print("height----->",height)
# print("fps-------->",fps)
fourcc = cv.VideoWriter_fourcc("F","L","V","1")
vid_flv = cv.VideoWriter("user/Q2/out.flv",fourcc,fps,(int(width),int(height)))
while True:
    ret,frame = video.read()
    if not ret:
        break
    vid_flv.write(frame)
video.release()

Q2T2

# 在桌面/quiz/Q2/data目录下有一段视频in.mp4，
# 请使用python编写代码，捕获该视频的第一帧，保存为cap1.jpg图片。
# 然后读取该图片，将图片垂直翻转，保存为cap2.jpg图片，代码文件命名为Q2.py，
# 最终将图片和代码保存在桌面/user/Q2目录下。
import cv2 as cv
video = cv.VideoCapture("quiz/Q2/data/in.mp4")
retval, cap1 = video.read()
cv.imwrite("user/Q2/cap1.jpg",cap1)
# 释放 VideoCapture
video.release()
cap2 = cv.flip(cap1,0)
cv.imwrite("user/Q2/cap2.jpg",cap2)
# cv.imshow("img",cap1)
# cv.waitKey(0)
# cv.destroyAllWindows()

Q3T2

# 在桌面/quiz/Q2/data目录下有许多照片，请使用python编写代码，将图片转换为视频。
# 设置视频的帧率为5fps，视频的大小为(300.200)， 
# 设置视频保存为avi格式，视频名字为out.avi，代码文件命名为Q2.py，
# 最终将视频和代码保存在桌面/user/Q2目录下。

import cv2 as cv
fourcc = cv.VideoWriter_fourcc('I','4','2','0')
out = cv.VideoWriter("user/Q2/out.avi",fourcc,5,(300,200))
for i in range(1,10):
    temp = cv.imread("quiz/Q2/data/"+str(i)+".jpeg")
    out.write(temp)
out.release()

框架题

Q3T1

#在桌面/quiz/Q3/目录下有代码文件Q3.py，给定CIFAR10数据集（图像大小为32X32），
# 请编写一个卷积神经网络模型完成图像分类模型，最终将代码文件Q3.py保存在桌面/user/Q3目录下。
# 任务一：搭建一个模型，由一层卷积层，一层最大池化层，一层全连接层组成。
# 卷积层包含10个大小为3 X 3的卷积核，步长为1，卷积后特征图尺寸不变；
# 池化层大小为2 X 2，步长为2；
# 全连接层输出图像属于飞机、汽车、鸟类、猫、鹿、狗、青蛙、马、船和卡车共计 10 个类别的概率。
# 部分代码已给出。附：PaddlePaddle常用函数表。

#任务二：进行模型训练。选择Adam的优化方法，学习率为0.001，
# 利用数据集训练模型。要求训练5轮，每一轮中每隔100个batch输出训练损失；
# 每一轮结束后输出模型在验证集上的准确率与损失。训练模型，请补充下列代码：

#1 请补充所需要的依赖包代码
# ___________1____________
import numpy as np
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D,Pool2D,Linear
# ___________1____________
trainset = paddle.dataset.cifar.train10()
testset = paddle.dataset.cifar.test10()
# 包装数据读取器，每次读取的数据数量设置为batch_size=8
train_loader = paddle.batch(trainset, batch_size=8)
valid_loader = paddle.batch(testset, batch_size=8)

# 定义cifar数据识别网络结构
class model_cifar(fluid.dygraph.Layer):
    def __init__(self,  name_scope, num_classes=10):
        super(model_cifar, self).__init__(name_scope)
        #2 请补充代码完成网络基本层的定义
        # _____________2____________
        self.conv = Conv2D(num_channels=3, num_filters=10, stride= 1, padding=1, filter_size=3, act='relu')
        self.pool = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
        self.fc = Linear(input_dim=2560, output_dim=num_classes, act='softmax')
        Conv2D(num_channels=3,num_filters=10,stride=1)
        # _____________2____________

    def forward(self, input):
        #3 请补充代码完成网络结构
        # ___________3_____________
        input = self.conv(input)
        input = self.pool(input)
        input = fluid.layers.flatten(input)
        output = self.fc(input)
        # _____________3____________
        return output


def train(model):
    model.train()
    epochs_num = 5
    # _____1_____    #定义优化器
    opt = fluid.optimizer.AdamOptimizer(learning_rate=0.001, parameter_list=model.parameters())
    train_loss = []
    train_acc = []
    # _____1_____
    for pass_num in range(epochs_num):       
        for batch_id,data in enumerate(train_loader()): #将数据转换成fluid要求的格式
            images=np.array([x[0].reshape(3,32,32) for x in data],np.float32) 
            labels = np.array([x[1] for x in data], dtype='int64').reshape(-1, 1)
            # 调整输入数据形状和类型、构建标签，将numpy.ndarray转化成Tensor
            # _________ 2___________
            image = fluid.dygraph.to_variable(images)
            label = fluid.dygraph.to_variable(labels)
            # _________ 2___________
            #进行训练预测
            predict=model(image) 
            
            #获取损失值并计算平均损失值
            # __________3___________
            loss = fluid.layers.cross_entropy(predict, label)
            avg_loss = fluid.layers.mean(loss)
            # __________3___________
                
            #计算精度                  
            # __________4___________
            acc = fluid.layers.accuracy(predict, label)
            train_loss.append(avg_loss.numpy())
            train_acc.append(acc.numpy())
            # __________4___________

            #每100个batch训练完后，显示一次损失值和精度值
            # if ___________5_______
            if batch_id != 0 and batch_id % 100 == 0:
             print("epoch:{},batch_id:{},train_loss:{},train_acc:{}".format(pass_num,batch_id,avg_loss,acc))
            #反向传播，计算评价损失
            # ___________6__________
            avg_loss.backward()
            #最小化损失
            # ___________7__________
            opt.minimize(avg_loss)
            #清除梯度值
            # ___________8__________
            model.clear_gradients()
            
        # 模型验证    
        model.eval()
        accuracies = []
        losses = []
        for batch_id, data in enumerate(valid_loader()):
            # 调整输入数据形状和类型
            image = np.array([x[0] for x in data],dtype='float32').reshape(-1, 3, 32, 32)
            labels = np.array([x[1] for x in data], dtype='int64').reshape(-1, 1)
            
            # 将numpy.ndarray转化成Tensor   ——补充
            img = fluid.dygraph.to_variable(image)
            label = fluid.dygraph.to_variable(labels)

            # 计算模型输出
            logits = model(img)
            pred = fluid.layers.softmax(logits)
            
            # 计算验证集损失值
            # _________9______________
            # 计算验证集精度值
            # _________10______________
            loss = fluid.layers.softmax_with_cross_entropy(logits, label)
            acc = fluid.layers.accuracy(pred, label)
            accuracies.append(acc.numpy())
            losses.append(loss.numpy())
            # _________10______________
        
if __name__ == '__main__':
    # 创建模型
    with fluid.dygraph.guard():
        # 进入训练模型
        # _________11______________
        model = model_cifar("cifar",num_classes=10)
        # _________11______________
        #启动训练过程
        train(model)

Q3T2

# coding: utf-8

# 给定波士顿房价数据集即uci_housing数据集，请自行补充一个逻辑回归模型完成房价预测模型。附：PaddlePaddle常用函数表。
# 波士顿房价数据说明：此数据源于美国某经济学杂志上，分析研究波士顿房价( Boston HousePrice)的数据集。
# 数据集中的每一行数据都是对波士顿周边或城镇房价的情况描述，下面对数据集变量说明下，方便理解数据集变量代表的意义。
# CRIM: 城镇人均犯罪率
# ZN: 住宅用地所占比例
# INDUS: 城镇中非住宅用地所占比例
# CHAS: 虚拟变量,用于回归分析
# NOX: 环保指数
# RM: 每栋住宅的房间数
# AGE: 1940 年以前建成的自住单位的比例
# DIS: 距离 5 个波士顿的就业中心的加权距离
# RAD: 距离高速公路的便利指数
# TAX: 每一万美元的不动产税率
# PTRATIO: 城镇中的教师学生比例
# B: 城镇中的黑人比例
# LSTAT: 地区中有多少房东属于低收入人群
# MEDV: 自住房屋房价中位数（也就是均价）
# 波士顿房价给出了13个特征维度变量预测房价MEDV。

# 步骤一：准备数据
import paddle.fluid as fluid
import paddle
import os
import matplotlib.pyplot as plt

BUF_SIZE = 500
BATCH_SIZE = 20

# 开启静态图
paddle.enable_static()

# 用于训练的数据提供器，每次从缓存中随机读取批次大小的数据
train_reader = paddle.batch(paddle.reader.shuffle(paddle.dataset.uci_housing.train(), buf_size=BUF_SIZE), batch_size=BATCH_SIZE)
# 用于测试的数据提供器，每次从缓存中随机读取批次大小的数据
test_reader = paddle.batch(paddle.reader.shuffle(paddle.dataset.uci_housing.test(), buf_size=BUF_SIZE), batch_size=BATCH_SIZE)

# 步骤二：定义网络
# （1）网络结构
# 得分点
# 1、正确定义输入变量（3分）
# 2、正确定义标签变量（3分）
# 3、正确定义全连接层（3分）
# 定义张量变量x，表示13维的特征值
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
# 定义张量y,表示目标值
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
# 定义一个简单的线性网络,连接输入和输出的全连接层
# input:输入tensor;
# size:该层输出单元的数目为1
# act:激活函数默认
y_predict = fluid.layers.fc(input=x, size=1, act=None)

# (2)定义损失函数
# 得分点
# 1、正确求一个batch的损失值（4分）
# 2、正确对损失值求平均值（2分）
cost = fluid.layers.square_error_cost(input=y_predict, label=y)  # 求一个batch的损失值
avg_cost = fluid.layers.mean(cost)  # 对损失值求平均值

# (3)定义优化函数，采用SGD优化器，学习率为0.001
# 得分点
# 1、正确调用SGD优化器（2分）
# 2、正确求解最小损失（2分）
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001)
opts = optimizer.minimize(avg_cost)

# 步骤三：模型训练
# （1）创建Executor
use_cuda = False  # use_cuda为False,表示运算场所为CPU;use_cuda为True,表示运算场所为GPU
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
# 创建一个Executor实例exe
exe = fluid.Executor(place)
# Executor的run()方法执行startup_program(),进行参数初始化
exe.run(fluid.default_startup_program())

# （2）定义输入数据维度
# 得分点
# 1、正确定义输入数据维度（4分）
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])  # feed_list:向模型输入的变量表或变量表名

# （3）定义绘制训练过程的损失值变化趋势的方法draw_train_process，x轴为iter，y轴为cost，
# 曲线颜色为红色，图例和图标题为training cost，字体合适。
# # 得分点
# 1、正确定义图层（4分）
# 2、正确定义坐标轴（8分）
# 3、正确定义图例和标题（4分）
iter = 0
iters = []
train_costs = []


def draw_train_process(iters, train_costs):
    title = "training cost"
    plt.title(title, fontsize=24)
    plt.xlabel("iter", fontsize=14)
    plt.ylabel("cost", fontsize=14)
    plt.plot(iters, train_costs, color='red', label='training cost')
    plt.grid()  # 图像带网格，可忽略
    plt.show()


# （4）训练并保存模型，每一轮中每隔30个batch输出训练损失，每一轮结束后输出模型在验证集上的损失，并绘制出损失值变化趋势.
# 得分点
# 1、正确遍历train_reader迭代器（6分）
# 2、正确每隔30个batch输出训练损失（2分）
# 3、正确保存模型（3分）
EPOCH_NUM = 50
model_save_dir = "fit_line.inference.model"

for pass_id in range(EPOCH_NUM):  # 训练EPOCH_NUM轮
    # 开始训练并输出最后一个batch的损失值
    train_cost = 0
    for batch_id, data in enumerate(train_reader()):  # 遍历train_reader迭代器
        train_cost = exe.run(program=fluid.default_main_program(),  # 运行主程序
                             feed=feeder.feed(data),  # 喂入一个batch的训练数据，根据feed_list和data提供的信息，将输入数据转成一种特殊的数据结构
                             fetch_list=[avg_cost])
        if batch_id % 30 == 0:
            print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0][0]))  # 打印最后一个batch的损失值
        iter = iter + BATCH_SIZE
        iters.append(iter)
        train_costs.append(train_cost[0][0])

    # 开始测试并输出最后一个batch的损失值
    test_cost = 0
    for batch_id, data in enumerate(test_reader()):  # 遍历test_reader迭代器
        test_cost = exe.run(program=fluid.default_main_program().clone(for_test=True),  # 运行测试
                            feed=feeder.feed(data),  # 喂入一个batch的测试数据
                            fetch_list=[avg_cost])  # fetch均方误差
    print('Test:%d, Cost:%0.5f' % (pass_id, test_cost[0][0]))  # 打印最后一个batch的损失值

    # 保存模型
    # 如果保存路径不存在就创建
if not os.path.exists(model_save_dir):
    os.makedirs(model_save_dir)
print('save models to %s' % model_save_dir)
# 保存训练参数到指定路径中，构建一个专门用预测的program
fluid.io.save_inference_model(model_save_dir,  # 保存推理model的路径
                              ['x'],  # 推理（inference）需要 feed 的数据
                              [y_predict],  # 保存推理（inference）结果的 Variables
                              exe)  # exe 保存 inference model
draw_train_process(iters, train_costs)

Q3T3

# coding: utf-8

# 给定手写数字识别PaddlePaddle模型参数文件：mnist.pdparams及卷积神经网络的结构定义，
# 请基于PaddlePaddle使用Python编写推理程序对给定手写数字图片进行识别，
# 模型参数文件和待识别图片在桌面/quiz/Q3/data目录下，最终将代码保存在桌面/user/Q3目录下。
# 卷积神经网络的结构定义：
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
import numpy as np
import cv2


# 定义模型结构
class MNIST(fluid.dygraph.Layer):
    def __init__(self):
        super(MNIST, self).__init__()

        # 定义一个卷积层，使用relu激活函数
        self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
        # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
        self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
        # 定义一个卷积层，使用relu激活函数
        self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
        # 定义一个池化层，池化核为2，步长为2，使用最大池化方式
        self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
        # 定义一个全连接层，输出节点数为10
        self.fc = Linear(input_dim=980, output_dim=10, act='softmax')

    # 定义网络的前向计算过程
    def forward(self, inputs):
        x = self.conv1(inputs)
        x = self.pool1(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = fluid.layers.reshape(x, [x.shape[0], 980])
        x = self.fc(x)
        return x


# 任务一：
# 编写一个图像预处理函数load_image，对指定路径图片进行数据预处理，
# 其中图像处理请使用OpenCV。处理流程为：首先读取数据目录下的待识别图片，
# 然后缩放大小为28X28，将其转换为灰度图，再转换为numpy数组，调整形状为（1, 1, 28, 28），
# 数据类型设置为float32，再对其进行归一化处理，最后返回处理后的数据。

# 得分点
# 1. 正确定义函数（2分）
# 2. 使用OpenCV进行图像处理（3分）
# 3. 正确加载图像（2分）
# 4. 正确缩放图像（3分）
# 5. 正确转换为灰度图（3分）
# 6. 正确转换为numpy数组（3分）
# 7. 正确调整数组形状（3分）
# 8. 正确设置数据类型（3分）
# 9. 正确进行归一化处理（3分）

def load_image(img_path):
    img = cv2.imread(img_path)
    img = cv2.resize(img, (28, 28))
    img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
    img = np.array(img).reshape(1, 1, 28, 28).astype(np.float32)
    img = 1.0 - img / 255.
    return img


# 任务二：
# 编写推理代码，识别数据目录下的图片内容。首先打开PaddlePaddle动态图的模式，
# 实例化化MNIST模型得到模型对象，使用模型对象加载模型参数文件（mnist.pdparams，位于数据目录），
# 设置模型对象为评估模式，即仅用于预测，对数据目录下的待识别图片调用load_image函数得到预处理后数据，
# 将数据置入模型得到预测结果返回，对返回结果处理获取置信度最高的值的索引值，即预测值。

# 得分点
# 1. 正确打开PaddlePaddle动态图的模式（3分）
# 2. 正确实例化化MNIST模型（2分）
# 3. 正确加载模型参数文件（5分）
# 4. 正确设置设置模型对象为评估模式（5分）
# 5. 正确使用模型得到预测结果（5分）
# 6. 正确获取置信度最高预测值（5分）

with fluid.dygraph.guard():
    model = MNIST()
    model_dict, _ = fluid.load_dygraph("../../quiz/Q3/data/mnist")
    model.load_dict(model_dict)

    model.eval()
    tensor_img = load_image('../../quiz/Q3/data/0.jpg')
    results = model(fluid.dygraph.to_variable(tensor_img))
    lab = np.argsort(results.numpy())
    print("预测结果: ", lab[0][-1])

你可能感兴趣的:(Python+计算机视觉,python,人工智能,pycharm,opencv)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商 nseejrukjhad langchaineasyui前端python
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
    随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • 数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首 张三叨
    你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Python编译器 鹿鹿~ Python编译器Pythonpython开发语言后端
    嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • jsonp 常用util方法 hw1287789687 jsonpjsonp常用方法jsonp callback
    jsonp 常用java方法 (1)以jsonp的形式返回:函数名(json字符串) /*** * 用于jsonp调用 * @param map : 用于构造json数据 * @param callback : 回调的javascript方法名 * @param filters : <code>SimpleBeanPropertyFilter theFilt
  • 多线程场景 alafqq 多线程
    0 能不能简单描述一下你在java web开发中需要用到多线程编程的场景？0 对多线程有些了解，但是不太清楚具体的应用场景，能简单说一下你遇到的多线程编程的场景吗？ Java多线程 2012年11月23日 15:41 Young9007 Young9007 4 0 0 4 Comment添加评论关注(2) 3个答案 按时间排序 按投票排序 0 0 最典型的如： 1、
  • Maven学习——修改Maven的本地仓库路径 Kai_Ge maven
          安装Maven后我们会在用户目录下发现.m2 文件夹。默认情况下，该文件夹下放置了Maven本地仓库.m2/repository。所有的Maven构件(artifact)都被存储到该仓库中，以方便重用。但是windows用户的操作系统都安装在C盘，把Maven仓库放到C盘是很危险的，为此我们需要修改Maven的本地仓库路径。    
  • placeholder的浏览器兼容 120153216 placeholder
    【前言】 自从html5引入placeholder后，问题就来了， 不支持html5的浏览器也先有这样的效果， 各种兼容，之前考虑，今天测试人员逮住不放， 想了个解决办法，看样子还行，记录一下。   【原理】 不使用placeholder，而是模拟placeholder的效果， 大概就是用focus和focusout效果。   【代码】 <scrip
  • debian_用iso文件创建本地apt源 2002wmj Debian
    1.将N个debian-506-amd64-DVD-N.iso存放于本地或其他媒介内，本例是放在本机/iso/目录下 2.创建N个挂载点目录 如下： debian:~#mkdir –r /media/dvd1 debian:~#mkdir –r /media/dvd2 debian:~#mkdir –r /media/dvd3 …. debian:~#mkdir –r /media
  • SQLSERVER耗时最长的SQL 357029540 SQL Server
    对于DBA来说，经常要知道存储过程的某些信息： 1.   执行了多少次 2.   执行的执行计划如何 3.   执行的平均读写如何 4.   执行平均需要多少时间 列名          &
  • com/genuitec/eclipse/j2eedt/core/J2EEProjectUtil 7454103 eclipse
    今天eclipse突然报了com/genuitec/eclipse/j2eedt/core/J2EEProjectUtil 错误，并且工程文件打不开了，在网上找了一下资料，然后按照方法操作了一遍，好了，解决方法如下： 错误提示信息： An error has occurred.See error log for more details. Reason: com/genuitec/
  • 用正则删除文本中的html标签 adminjun javahtml正则表达式去掉html标签
    使用文本编辑器录入文章存入数据中的文本是HTML标签格式，由于业务需要对HTML标签进行去除只保留纯净的文本内容，于是乎Java实现自动过滤。 如下： public static String Html2Text(String inputString) { String htmlStr = inputString; // 含html标签的字符串 String textSt
  • 嵌入式系统设计中常用总线和接口 aijuans linux 基础
                   嵌入式系统设计中常用总线和接口         任何一个微处理器都要与一定数量的部件和外围设备连接，但如果将各部件和每一种外围设备都分别用一组线路与CPU直接连接，那么连线
  • Java函数调用方式——按值传递 ayaoxinchao java按值传递对象基础数据类型
    Java使用按值传递的函数调用方式，这往往使我感到迷惑。因为在基础数据类型和对象的传递上，我就会纠结于到底是按值传递，还是按引用传递。其实经过学习，Java在任何地方，都一直发挥着按值传递的本色。   首先，让我们看一看基础数据类型是如何按值传递的。   public static void main(String[] args) { int a = 2;
  • ios音量线性下降 bewithme ios音量
    直接上代码吧   //second 几秒内下降为0 - (void)reduceVolume:(int)second { KGVoicePlayer *player = [KGVoicePlayer defaultPlayer]; if (!_flag) { _tempVolume = player.volume;
  • 与其怨它不如爱它 bijian1013 选择理想职业规划
            抱怨工作是年轻人的常态，但爱工作才是积极的心态，与其怨它不如爱它。         一般来说，在公司干了一两年后，不少年轻人容易产生怨言，除了具体的埋怨公司“扭门”，埋怨上司无能以外，也有许多人是因为根本不爱自已的那份工作，工作完全成了谋生的手段，跟自已的性格、专业、爱好都相差甚远。  
  • 一边时间不够用一边浪费时间 bingyingao 工作时间浪费
    一方面感觉时间严重不够用，另一方面又在不停的浪费时间。 每一个周末，晚上熬夜看电影到凌晨一点，早上起不来一直睡到10点钟，10点钟起床，吃饭后玩手机到下午一点。 精神还是很差，下午像一直野鬼在城市里晃荡。 为何不尝试晚上10点钟就睡，早上7点就起，时间完全是一样的，把看电影的时间换到早上，精神好，气色好，一天好状态。 控制让自己周末早睡早起，你就成功了一半。 有多少个工作
  • 【Scala八】Scala核心二：隐式转换 bit1129 scala
    Implicits work like this: if you call a method on a Scala object, and the Scala compiler does not see a definition for that method in the class definition for that object, the compiler will try to con
  • sudoku slover in Haskell (2) bookjovi haskellsudoku
    继续精简haskell版的sudoku程序，稍微改了一下，这次用了8行，同时性能也提高了很多，对每个空格的所有解不是通过尝试算出来的，而是直接得出。   board = [0,3,4,1,7,0,5,0,0, 0,6,0,0,0,8,3,0,1, 7,0,0,3,0,0,0,0,6, 5,0,0,6,4,0,8,0,7,
  • Java-Collections Framework学习与总结-HashSet和LinkedHashSet BrokenDreams linkedhashset
            本篇总结一下两个常用的集合类HashSet和LinkedHashSet。         它们都实现了相同接口java.util.Set。Set表示一种元素无序且不可重复的集合；之前总结过的java.util.List表示一种元素可重复且有序
  • 读《研磨设计模式》-代码笔记-备忘录模式-Memento bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; /* * 备忘录模式的功能是，在不破坏封装性的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态，为以后的状态恢复作“备忘”
  • 《RAW格式照片处理专业技法》笔记 cherishLC PS
    注意，这不是教程！仅记录楼主之前不太了解的 一、色彩（空间）管理 作者建议采用ProRGB（色域最广），但camera raw中设为ProRGB，而PS中则在ProRGB的基础上，将gamma值设为了1.8（更符合人眼） 注意：bridge、camera raw怎么设置显示、输出的颜色都是正确的（会读取文件内的颜色配置文件），但用PS输出jpg文件时，必须先用Edit->conv
  • 使用 Git 下载 Spring 源码 编译 for Eclipse crabdave eclipse
    使用 Git 下载 Spring 源码 编译 for Eclipse   1、安装gradle，下载 http://www.gradle.org/downloads 配置环境变量GRADLE_HOME，配置PATH  %GRADLE_HOME%/bin，cmd，gradle -v   2、spring4 用jdk8 下载 https://jdk8.java.
  • mysql连接拒绝问题 daizj mysql登录权限
    mysql中在其它机器连接mysql服务器时报错问题汇总 一、[running][email protected]:~$mysql -uroot -h 192.168.9.108 -p   //带-p参数，在下一步进行密码输入 Enter password:    //无字符串输入 ERROR 1045 (28000): Access
  • Google Chrome 为何打压 H.264 dsjt applehtml5chromeGoogle
    Google 今天在 Chromium 官方博客宣布由于 H.264 编解码器并非开放标准，Chrome 将在几个月后正式停止对 H.264 视频解码的支持，全面采用开放的 WebM 和 Theora 格式。 Google 在博客上表示，自从 WebM 视频编解码器推出以后，在性能、厂商支持以及独立性方面已经取得了很大的进步，为了与 Chromium 现有支持的編解码器保持一致，Chrome
  • yii 获取控制器名 和方法名 dcj3sjt126com yiiframework
    1. 获取控制器名 在控制器中获取控制器名:  $name = $this->getId(); 在视图中获取控制器名:    $name = Yii::app()->controller->id;    2. 获取动作名  在控制器beforeAction()回调函数中获取动作名:  $name =
  • Android知识总结（二） come_for_dream android
    明天要考试了，速速总结如下   1、Activity的启动模式        standard：每次调用Activity的时候都创建一个（可以有多个相同的实例，也允许多个相同Activity叠加。）        singleTop：可以有多个实例，但是不允许多个相同Activity叠加。即，如果Ac
  • 高洛峰收徒第二期：寻找未来的“技术大牛” ——折腾一年，奖励20万元 gcq511120594 工作项目管理
    高洛峰，兄弟连IT教育合伙人、猿代码创始人、PHP培训第一人、《细说PHP》作者、软件开发工程师、《IT峰播》主创人、PHP讲师的鼻祖！ 首期现在的进程刚刚过半，徒弟们真的很棒，人品都没的说，团结互助，学习刻苦，工作认真积极，灵活上进。我几乎会把他们全部留下来，现在已有一多半安排了实际的工作，并取得了很好的成绩。等他们出徒之日，凭他们的能力一定能够拿到高薪，而且我还承诺过一个徒弟，当他拿到大学毕
  • linux expect heipark expect
    1. 创建、编辑文件go.sh   #!/usr/bin/expect spawn sudo su admin expect "*password*" { send "13456\r\n" } interact    2. 设置权限   chmod u+x go.sh  3.
  • Spring4.1新特性——静态资源处理增强 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • idea ubuntuxia 乱码 liyonghui160com
      1.首先需要在windows字体目录下或者其它地方找到simsun.ttf 这个 字体文件。 2.在ubuntu 下可以执行下面操作安装该字体： sudo mkdir /usr/share/fonts/truetype/simsun sudo cp simsun.ttf /usr/share/fonts/truetype/simsun fc-cache -f -v
  • 改良程序的11技巧 pda158 技巧
    有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。   让我们看一些基本的编程技巧：   尽量保持方法简短 永远永远不要把同一个变量用于多个不同的
  • 300个涵盖IT各方面的免费资源（下）——工作与学习篇 shoothao 创业免费资源学习课程远程工作
    工作与生产效率:   A. 背景声音 Noisli:背景噪音与颜色生成器。 Noizio:环境声均衡器。 Defonic:世界上任何的声响都可混合成美丽的旋律。 Designers.mx:设计者为设计者所准备的播放列表。 Coffitivity:这里的声音就像咖啡馆里放的一样。 B. 避免注意力分散 Self Co
  • 深入浅出RPC uule rpc
    深入浅出RPC-浅出篇 深入浅出RPC-深入篇   RPC Remote Procedure Call Protocol 远程过程调用协议   它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他