利用 opencv实现图像自适应二值化 --python

阈值化：给定一个数组和一个与之，然后根据数组中的每个元素的值，是高于还是低于阈值而进行一些操作。如果像素值大于阈值，则分配给它一个值(如白色的)，否则它被分配给另一个值(如黑色)。

创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：网站建设、网站制作、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的民勤网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

此为固定阈值的事例。具体效果如下：

函数中四个参数分别是原图像、阈值、最大值、阈值类型

阈值类型一般分为五种：

cv2.THRESH_BINARY——大于阈值的部分像素值变为最大值，其他变为0

cv2.THRESH_BINARY_INV——大于阈值的部分变为0，其他部分变为最大值

cv2.THRESH_TRUNC——大于阈值的部分变为阈值，其余部分不变

cv2.THRESH_TOZERO——大于阈值的部分不变，其余部分变为0

cv2.THRESH_TOZERO_INV——大于阈值的部分变为0，其余部分不变

自适应阈值是根据图像上的每一个小区域计算与其对应的阈值，因此在同一幅图像上采用的是不同的阈值，从而能使我们在亮度 不同的情况下得到更好的结果。

th2为算术平均法的自适应二值化

th3为高斯加权均值法自适应二值化

结果如下：

用python编写一个字符串压缩程序(要求为自适应模型替代法)

你好，下面是LZ777自适应压缩算法的一个简单实现，你可以看看

import math

from bitarray import bitarray

class LZ77Compressor:

"""

A simplified implementation of the LZ77 Compression Algorithm

"""

MAX_WINDOW_SIZE = 400

def __init__(self, window_size=20):

self.window_size = min(window_size, self.MAX_WINDOW_SIZE)

self.lookahead_buffer_size = 15 # length of match is at most 4 bits

def compress(self, input_file_path, output_file_path=None, verbose=False):

"""

Given the path of an input file, its content is compressed by applying a simple

LZ77 compression algorithm.

The compressed format is:

0 bit followed by 8 bits (1 byte character) when there are no previous matches

within window

1 bit followed by 12 bits pointer (distance to the start of the match from the

current position) and 4 bits (length of the match)

If a path to the output file is provided, the compressed data is written into

a binary file. Otherwise, it is returned as a bitarray

if verbose is enabled, the compression description is printed to standard output

"""

data = None

i = 0

output_buffer = bitarray(endian='big')

# read the input file

try:

with open(input_file_path, 'rb') as input_file:

data = input_file.read()

except IOError:

print 'Could not open input file ...'

raise

while i len(data):

#print i

match = self.findLongestMatch(data, i)

if match:

# Add 1 bit flag, followed by 12 bit for distance, and 4 bit for the length

# of the match

(bestMatchDistance, bestMatchLength) = match

output_buffer.append(True)

output_buffer.frombytes(chr(bestMatchDistance 4))

output_buffer.frombytes(chr(((bestMatchDistance 0xf) 4) | bestMatchLength))

if verbose:

print "1, %i, %i" % (bestMatchDistance, bestMatchLength),

i += bestMatchLength

else:

# No useful match was found. Add 0 bit flag, followed by 8 bit for the character

output_buffer.append(False)

output_buffer.frombytes(data[i])

if verbose:

print "0, %s" % data[i],

i += 1

# fill the buffer with zeros if the number of bits is not a multiple of 8

output_buffer.fill()

# write the compressed data into a binary file if a path is provided

if output_file_path:

try:

with open(output_file_path, 'wb') as output_file:

output_file.write(output_buffer.tobytes())

print "File was compressed successfully and saved to output path ..."

return None

except IOError:

print 'Could not write to output file path. Please check if the path is correct ...'

raise

# an output file path was not provided, return the compressed data

return output_buffer

def decompress(self, input_file_path, output_file_path=None):

"""

Given a string of the compressed file path, the data is decompressed back to its

original form, and written into the output file path if provided. If no output

file path is provided, the decompressed data is returned as a string

"""

data = bitarray(endian='big')

output_buffer = []

# read the input file

try:

with open(input_file_path, 'rb') as input_file:

data.fromfile(input_file)

except IOError:

print 'Could not open input file ...'

raise

while len(data) = 9:

flag = data.pop(0)

if not flag:

byte = data[0:8].tobytes()

output_buffer.append(byte)

del data[0:8]

else:

byte1 = ord(data[0:8].tobytes())

byte2 = ord(data[8:16].tobytes())

del data[0:16]

distance = (byte1 4) | (byte2 4)

length = (byte2 0xf)

for i in range(length):

output_buffer.append(output_buffer[-distance])

out_data = ''.join(output_buffer)

if output_file_path:

try:

with open(output_file_path, 'wb') as output_file:

output_file.write(out_data)

print 'File was decompressed successfully and saved to output path ...'

return None

except IOError:

print 'Could not write to output file path. Please check if the path is correct ...'

raise

return out_data

def findLongestMatch(self, data, current_position):

"""

Finds the longest match to a substring starting at the current_position

in the lookahead buffer from the history window

"""

end_of_buffer = min(current_position + self.lookahead_buffer_size, len(data) + 1)

best_match_distance = -1

best_match_length = -1

# Optimization: Only consider substrings of length 2 and greater, and just

# output any substring of length 1 (8 bits uncompressed is better than 13 bits

# for the flag, distance, and length)

for j in range(current_position + 2, end_of_buffer):

start_index = max(0, current_position - self.window_size)

substring = data[current_position:j]

for i in range(start_index, current_position):

repetitions = len(substring) / (current_position - i)

last = len(substring) % (current_position - i)

matched_string = data[i:current_position] * repetitions + data[i:i+last]

if matched_string == substring and len(substring) best_match_length:

best_match_distance = current_position - i

best_match_length = len(substring)

if best_match_distance 0 and best_match_length 0:

return (best_match_distance, best_match_length)

return None

Python 列表？

是不是这个list让你感觉有些困扰呢，你看一下我下面的表示方式：

你的list和我的abc都是表示一个列表名。

del abc[1]：调用系统方法del，删除列表abc中索引为1的项；

abc.pop()：调用列表（这里为abc）本身的方法pop()，删除abc列表的最后一项。

abc[1]中用方括号是列表的索引操作，为列表自身的规则；pop()中也可以传入参数用于表示索引位置，但此处为向方法内传入位置参数。

方法来源不一样，使用规则有差别。

2019-03-02

集成学习： 构建并结合多个学习器来完成学习任务。

同质： 集成中只包含同种类型的个体学习器（基学习器）；

异质： 集成中的个体学习器（组件学习器）由不同学习算法生成。

个体学习器的“准确性”和“多样性”很重要，且相互冲突。

分类： 个体学习器间存在强依赖关系，必须串行生成的序列化方法，eg，Boosting；个体学习器间不存在强依赖关系，可同时生成的并行化方法，eg，Bagging和随机森林。

工作机制： 先从初始训练集训练出一个基学习器1，根据基学习器误差率表现更新训练样本权重，使弱学习器1学习误差率高的训练样本权重变高，让这些点在弱学习器2中得到更多的重视，然后基于调整权重后的训练集训练学习器2,...重复进行，直至弱学习器数目达到指定的值T，最终将这T个基学习器进行加权结合。

Boosting族算法最著名的代表是AdaBoost，是“Adaptive Boosting（自适应增强）”的缩写。它的自适应在于：前一个基本分类器分错的样本会得到加强，加权后的全体样本再次被用来训练下一个基本分类器。同时，在每一轮中加入一个新的弱分类器，直到达到某个预定的足够小的错误率或达到预先指定的最大迭代次数。

算法过程

优点：作为分类器时精度很高；在AdaBoost框架下，可使用各种回归分类模型来构建学习器；不易发生过拟合（会加入正则化项）。

缺点：对异常样本点敏感，异常样本在迭代中可能会获得较高的权重，影响最终的强学习器的预测准确性。

两者均是0/1误差的平滑近似：

梯度提升算法首先给定一个目标损失函数，它的定义域是所有可行的基函数集合，提升算法通过迭代的选择一个负梯度方向上的基函数来逐渐逼近局部最小值。

GB每一次建立模型 是在之前建立模型 损失函数的梯度下降方向。一般认为损失函数越小，性能越好，因此最好是使损失函数沿着梯度方向下降，模型得以不断改进提升性能。

GBDT是GB和DT的结合，是以决策树为基学习器的gb算法，此处的决策树是回归树。GBDT中的决策树深度一般不超过5，叶子结点数不超过10。GBDT核心在于： 每一棵树学得是之前所有树结论和的残差 ，这个残差就是一个加预测值后能得真实值的累加量。比如A的真实年龄是18岁，但第一棵树的预测年龄是12岁，差了6岁，即残差为6岁。那么在第二棵树里我们把A的年龄设为6岁去学习，如果第二棵树真的能把A分到6岁的叶子节点，那累加两棵树的结论就是A的真实年龄；如果第二棵树的结论是5岁，则A仍然存在1岁的残差，第三棵树里A的年龄就变成1岁，继续学习。

xgboost是在GBDT基本思路上改善而来，主要改变有

1） 在损失函数中加入防止过拟合的惩罚函数

T是叶子的个数，w是预测函数的参数，也就是决策树算法下叶子节点的权重值。可以控制γ和λ这两个超参数来调整正则化的惩罚力度。其实这里的惩罚函数也就定义了模型复杂度，比如γ越大，λ越大，复杂度越小越不易过拟合。

2） 用二阶泰勒展式将损失函数展开，同时用到了一阶和二阶导数

第t次的loss：

对上式做二阶泰勒展开：g为一阶导数，h为二阶导数

3)CART回归树中寻找最佳分割点的衡量标准是最小化均方差，xgboost 寻找分割点的标准是最大化 ，lamda，gama与正则化项相关

xgboost算法的步骤和GB基本相同，都是首先初始化为一个常数，gb是根据一阶导数ri，xgboost是根据一阶导数gi和二阶导数hi，迭代生成基学习器，相加更新学习器。

为得到泛化性能强的集成，集成中的个体学习器应尽可能相互独立，考虑使用相互有交叠的采样子集。

并行式集成学习的最著名代表，基于自助采样法，算法流程如下：

优点：训练一个Bagging集成与直接使用基学习算法训练一个学习器的复杂度同阶；与标准AdaBoost只适用于二分类任务不同，Bagging能不经修改的用于多分类、回归任务；初始训练集63.2%用于训练，36.8%用作验证集对泛化性能做“包外估计”。

但从偏差-方差分解角度看，Bagging主要关注降低方差。

随机森林是Bagging的一个扩展变体，在以决策树为基学习器构建Bagging集成的基础上，在决策树训练过程中引入了 随机属性选择 。即对基决策树的每个结点，先从该结点的属性集合中随机选择一个包含k（kd，d为所有属性个数）个属性的子集，然后从中选一个最优属性用于划分。若k=d，则为传统决策树；k=1，则随机选择一个属性划分。一般推荐 。

RF起始性能相对较差，但随着学习器数目的增加，会收敛到更低的泛化误差。另外RF的训练效率常优于Bagging，因为Bagging使用“确定型”决策树，选择划分属性时要对结点所有属性进行考察，而RF使用“随机型”决策树，只需考虑一个属性子集。

学习器结合可能会从三个方面带来好处：

1）统计方面：当多个假设达到同等性能时，可减小因误选单学习器导致泛化性能不佳的风险；

2）计算方面：降低陷入糟糕局部极小点的风险；

3）表示方面：扩大相应假设空间，学习更好的近似。

对数值型输出 ，最常见的结合策略是平均法。

简单平均：                    

(特殊的加权平均法，宜在个体学习器性能相近时使用)

加权平均法：                

其中 是个体学习器 的权重，一般从训练数据中学习而得，通常要求 ，宜在个体学习器相差较大时使用。

对分类任务，学习器从类别标记集合中预测出一个标记，最常见的结合策略是投票法。

绝大多数投票法：

相对多数投票法：

                         

预测为得票最多的标记，若同时有多个标记获得最高票，则从中随机选取一个。

加权投票法：

                     

与加权平均法类似， 是 的权重，通常 。

个体学习器的输出类型：

类标记： 硬投票。 ，若 将样本x预测为类别 则取值为1，否则为0。

类概率： 软投票。 ，相当于对后验概率 的一个估计。

不同类型的 值不能混用；对一些能在预测出类别标记的同时产生分类置信度的学习器，其分类置信度可转化为类概率使用；分类置信度应规范化后使用；基于类概率进行结合优于直接基于类标记进行结合；若基学习器类型不同，不能直接比较类概率值，应先将其转化为类标记输出（eg类概率输出最大的设为1，其他为0）再投票。

当训练数据很多时，常使用通过另一个学习器来进行结合的“学习法”，代表算法Stacking

第一阶段获得各个模型对样本x1的预测标签值；第二阶段将各个模型的预测标签值作为一个新的特征（x1的真实标签值还是标签值），再用某个算法进行训练，获得一个融合模型，用这个融合模型进行测试集的预测。

周志华《机器学习》

python图片宽度不变高度自适应

题主是否想询问“python图片如何设置宽度不变高度自适应”？

1、首先打开python软件。

2、其次点击右上角的图片设置。

3、最后点击大小设置，修改为宽度不变高度自适应即可。

3种python3的canny边缘检测之静态，可调节和自适应

先看高级版的python3的canny的自适应边缘检测：

内容：

1 canny的边缘检测的介绍。

2 三种方法的canny的边缘检测，由浅入深地介绍：固定值的静态，可自调节的，自适应的。

说明：

1 环境：python3.8、opencv4.5.3和matplotlib3.4.3。

2 图片：来自品阅网正版免费图库。

3 实现自适应阈值的canny边缘检测的参考代码和文章：

上述的代码，本机均有报错，故对代码进行修改，注释和运行。

初级canny：

1 介绍：opencv中给出了canny边缘检测的接口，直接调用：

即可得到边缘检测的结果ret，其中，t1，t2是需要人为设置的阈值。

2 python的opencv的一行代码即可实现边缘检测。

3 Canny函数及使用：

4 Canny边缘检测流程：

去噪 -- 梯度 -- 非极大值抑制 -- 滞后阈值

5 代码：

6 操作和过程：

7 原图：

8 疑问：

ret = cv2.canny(img,t1,t2)，其中，t1，t2是需要人为设置的阈值，一般人怎么知道具体数值是多少，才是最佳的呀？所以，这是它的缺点。

中级canny：

1 中级canny，就是可调节的阈值，找到最佳的canny边缘检测效果。

2 采用cv2.createTrackbar来调节阈值。

3 代码：

4 操作和效果：

5 原图：

高级canny：

1 自适应canny的算法：

ret = cv2.canny(img,t1,t2)

即算法在运行过程中能够自适应地找到较佳的分割阈值t1，t2。

2 文件结构：

3 main.py代码：

4 dog.py代码：

5 bilateralfilt.py代码：

6 原图：

7 效果图：本文第一个gif图，此处省略。

小结：

1 本文由浅入深，总结的很好，适合收藏。

2 对于理解python的opencv的canny的边缘检测，很有帮助。

3 本文高级版canny自适应的算法参考2篇文章，虽然我进行代码的删除，注释，修改，优化等操作，故我不标注原创，对原作者表达敬意。

4 自己总结和整理，分享出来，希望对大家有帮助。

当前文章：关于python自适应函数的信息
本文URL：http://kswjz.com/article/hjpeee.html