首页 > 其他分享 >学习笔记

学习笔记

时间：2024-02-01 11:57:10浏览次数：20  
标签：__ plt cv2 笔记 学习 print np import

机器学习基础环境安装与使用

库的安装

miniconda3安装教程
https://blog.csdn.net/HowieXue/article/details/118442904

requirements.txt文件 
matplotlib==2.2.2
numpy==1.14.2
pandas==0.20.3
tables==3.4.2
jupyter==1.0.0
各版本Anaconda的下载、安装和卸载（适用于Windows/Linux系统） 
下载教程
https://blog.csdn.net/QAQIknow/article/details/107681368
anaconda各版本
https://mirrors.tuna.tsinghua.edu.cn/anaconda/archive/
python包安装失败 
安装网址
https://www.lfd.uci.edu/~gohlke/pythonlibs/
pip install wheel
pip install --target=包路径 包名
示例
pip install --target=D:\ProgramData\Anaconda3\Lib\site-packages numpy

使用pip 命令安装

pip install -r requirements.txt

matplotlib使用

绘制图像

import matplotlib.pyplot as plt
#1.创建画布
plt.figure(figsize=(20,8),dpi=100)#figsize指定图像长度，dpi指定图像清晰度
#2.绘制图像
x=[1,2,3]
y=[4,5,6]
plt.plot(x,y)
#3.显示图像
plt.show()

image

图像保存

import matplotlib.pyplot as plt
#1.创建画布
plt.figure(figsize=(20,8),dpi=100)#figsize指定图像长度，dpi指定图像清晰度
#2.绘制图像
x=[1,2,3]
y=[4,5,6]
plt.plot(x,y)
#4.保存图片到指定路径
plt.savefig('./测试.png')
#3.显示图像
plt.show()

x,y轴字体设置

simhei字体下载

import matplotlib.pyplot as plt
#1.创建画布
plt.figure(figsize=(20,8),dpi=100)#figsize指定图像长度，dpi指定图像清晰度
#2.绘制图像
x=[1,2,3]
y=[4,5,6]
plt.plot(x,y)
#2.1 添加x,y刻度
y_ticks=range(3)
plt.yticks(y_ticks)
x_ticks_labal=["11点{}分".format(i) for i in range(3)]
# plt.rc("font",family="SimHei") ###增加了这一行
plt.style.use("seaborn")
plt.rcParams['font.sans-serif']='SimHei'
plt.xticks(x,x_ticks_labal)#必须最开始传递的是数字再进行替换
#3.显示图像
plt.show()

image

添加网格显示

import matplotlib.pyplot as plt
#1.创建画布
plt.figure(figsize=(20,8),dpi=100)#figsize指定图像长度，dpi指定图像清晰度
#2.绘制图像
x=[1,2,3]
y=[4,5,6]
plt.plot(x,y)
#2.1 添加x,y刻度
y_ticks=range(3)
plt.yticks(y_ticks)
x_ticks_labal=["11点{}分".format(i) for i in range(3)]
# plt.rc("font",family="SimHei") ###增加了这一行
plt.style.use("seaborn")
plt.rcParams['font.sans-serif']='SimHei'
plt.xticks(x,x_ticks_labal)#必须最开始传递的是数字再进行替换
#添加网格
plt.grid(True,linestyle="--",alpha=1)#线形，透明度
#3.显示图像
plt.show()

image

添加描述

import matplotlib.pyplot as plt
#1.创建画布
plt.figure(figsize=(20,8),dpi=100)#figsize指定图像长度，dpi指定图像清晰度
#2.绘制图像
x=[1,2,3]
y=[4,5,6]
plt.plot(x,y)
#2.1 添加x,y刻度
y_ticks=range(3)
plt.yticks(y_ticks)
x_ticks_labal=["11点{}分".format(i) for i in range(3)]
# plt.rc("font",family="SimHei") ###增加了这一行
plt.style.use("seaborn")
plt.rcParams['font.sans-serif']='SimHei'
plt.xticks(x,x_ticks_labal)#必须最开始传递的是数字再进行替换
#添加网格
plt.grid(True,linestyle="--",alpha=1)#线形，透明度
#添加描述
plt.xlabel("时间")
plt.ylabel("温度")
plt.title("一小时温度变化图",fontsize=30)
#3.显示图像
plt.show()

image

显示图例

import matplotlib.pyplot as plt
#1.创建画布
plt.figure(figsize=(20,8),dpi=100)#figsize指定图像长度，dpi指定图像清晰度
#2.绘制图像
x=[1,2,3]
y1=[4,5,6]
y2=[5,8,6]

plt.plot(x,y1,label="上海")
plt.plot(x,y2,label="北京")
#2.1 添加x,y刻度
y_ticks=range(3)
plt.yticks(y_ticks)
x_ticks_labal=["11点{}分".format(i) for i in range(3)]
# plt.rc("font",family="SimHei") ###增加了这一行
plt.style.use("seaborn")
plt.rcParams['font.sans-serif']='SimHei'
plt.xticks(x,x_ticks_labal)#必须最开始传递的是数字再进行替换
#添加网格
plt.grid(True,linestyle="--",alpha=1)#线形，透明度
#添加描述
plt.xlabel("时间")
plt.ylabel("温度")
plt.title("一小时温度变化图")
#显示图例
plt.legend(loc="best")
#3.显示图像
plt.show()

image

多个坐标系显示图像

import matplotlib.pyplot as plt
# plt.rc("font",family="SimHei") ###增加了这一行
plt.style.use("seaborn")
plt.rcParams['font.sans-serif']='SimHei'
#1.创建画布
fig,axes=plt.subplots(nrows=1,ncols=2,figsize=(20,8),dpi=100)
#2.绘制图像
x=[1,2,3]
y1=[4,5,6]
y2=[5,8,6]

axes[0].plot(x,y1,label="上海")
axes[1].plot(x,y2,label="北京")
# #2.1 添加x,y刻度
y_ticks=range(3)
axes[0].set_yticks(y1)
axes[0].set_xticks(x)
x_ticks_labal=["11点{}分".format(i) for i in range(3)]

axes[0].set_xticklabels(x_ticks_labal)#必须最开始传递的是数字再进行替换
# #添加网格
axes[0].grid(True,linestyle="--",color='r',alpha=1)#线形，透明度
# #添加描述
axes[0].set_xlabel("时间")
axes[0].set_ylabel("温度")
axes[0].set_title("一小时温度变化图")
#显示图例
axes[0].legend(loc=0)
#3.显示图像
plt.show()

image

拆线图的应用场景

plot绘制数学图像

import numpy as np
import matplotlib.pyplot as plt
#生成数据
x=np.linspace(-10,10,1000)
y=np.sin(x)
#生成画布
plt.figure(figsize=(20,8),dpi=100)
#绘制
plt.plot(x,y)
#显示
plt.show()

image

其它图

散点图

import matplotlib.pyplot as plt
import random
#1.散点图
# 数据准备
x=[random.randint(1,22) for _ in range(10)]
y=[random.randint(2,30) for _ in range(10)]
#1.创建画布
plt.figure(figsize=(20,8),dpi=100)
#2.图像绘制（散点图）
plt.scatter(x,y)
#3.图像展示
plt.show()

image

柱状图

import matplotlib.pyplot as plt
import matplotlib as mpl
import random
#2.柱状图
#数据准备
str_list_name=['开心','中国','like','美','猫','狗','兔']
#横坐标
x=range(len(str_list_name))
y=[10,20,62,5,36,23,10]
#创建画布
plt.figure(figsize=(20,8),dpi=100)
#绘制
plt.bar(x,y,color=['b','r','g','y','c','m','k'],width=0.5)
#显示中文字体
# mpl.rc("font", family='Microsoft YaHei')
plt.rcParams['font.sans-serif'] = 'SimHei'#SimSun :宋体；KaiTI：楷体；Microsoft YaHei：微软雅黑LiSu：隶书；FangSong：仿宋；Apple LiGothic Medium：苹果丽中黑；
plt.rcParams['axes.unicode_minus']=False#解决坐标轴负数的负号显示问题
#x轴替换
plt.xticks(x,str_list_name,fontsize=15)
#添加网格
plt.grid()
#添加标题
plt.title('柱状图展示')
#显示图像
plt.show()

image

更多

直方图：plt.hist()
饼图：plt.pie()
参考链接

Numpy学习

创建

import numpy as np

score=np.array([[i for i in range(3)] for _ in range(3)])

ndarray的属性

print(score.shape)#数组维度的元组
print(score.ndim)#数组的维度
print(score.size)#数组元素的数量
print(score.itemsize)#一个数组维度的长度(字节)
print(score.dtype)#数组元素的类型

image

基本使用

生成数组

import numpy as np
#生成为1的数组
ones=np.ones([4, 8])
print(ones)
#生成为0的数组
print(np.zeros_like(ones))

image

从现有数组生成

import numpy as np
a=np.array([[1,2,3],[2,3,4]])
a1=np.array(a)#深拷贝
# print(a1)
a2=np.asarray(a)#浅拷贝
# print(a2)
a[0,0]=100
print(a)
print(a1)
print(a2)

image

生成固定范围的数组

import numpy as np
linspace=np.linspace(0,100,10)#生成等间隔的数组
print(linspace)
arange=np.arange(10,50,3)#每隔多少生成数据
print(arange)
logspace=np.logspace(0,2,3)#生成10^x
print(logspace)

image

生成随机数组

import numpy as np
random_rand=np.random.rand(2,3)
print(random_rand)
random_uniform=np.random.uniform(low=1,high=10,size=(2,3))#生成均匀分布的随机数
print(random_uniform)
random_randint=np.random.randint(1,10,size=(2,3))
print(random_randint)

image

生成正态分布

import matplotlib.pyplot as plt
random_normal=np.random.normal(1,75,100000000)
plt.figure(figsize=(20,8),dpi=100)
plt.hist(random_normal,bins=1000)
plt.show()

image

数组索引，切片

import numpy as np
import matplotlib.pyplot as plt
random_normal=np.random.normal(0,1,(3,10))
print(random_normal)
stock_change=random_normal[0:2,0:3]#按照先行后列
print(stock_change)

image
image

形状修改

import numpy as np
import matplotlib.pyplot as plt
random_normal=np.random.normal(0,1,(4,5))
reshape=random_normal.reshape([5,4])#数组的形状被修改为：5，4，
# print(reshape)
reshape1=random_normal.reshape([-1,10])# -1：表示通过待计算
# print(reshape1)

# random_normal.resize([5,4])#对原来的数据进行修改
new_random_normal=random_normal.T
print(new_random_normal)

类型修改

import numpy as np
import matplotlib.pyplot as plt
random_normal=np.random.normal(0,1,(4,5))
astype=random_normal.astype(np.int32)
print(astype)
tostring=astype.tostring()
print(tostring)

image

数据去重

import numpy as np
import matplotlib.pyplot as plt
temp=np.array([[1,2,3,4],[3,4,5,6]])
unique=np.unique(temp)
print(unique)

image

ndarray运算

逻辑运算

import numpy as np
import matplotlib.pyplot as plt
random_normal=np.random.normal(0,1,(8,10))
print(random_normal)
stacke_change=random_normal[0:5,0:5]
print(stacke_change)
print(stacke_change>1)
stacke_change[stacke_change>1]=2
print(stacke_change)

通用判断函数

import numpy as np
import matplotlib.pyplot as plt
random_normal=np.random.normal(0,1,(8,10))
stacke_change=random_normal[0:5,0:5]
stacke_change[stacke_change>1]=2
print(stacke_change)
print(np.all(stacke_change>0))#所有大于0返回True
print(np.any(stacke_change>0))#有一个大于0返回True

image

三元运算符

import numpy as np
import matplotlib.pyplot as plt
random_normal=np.random.normal(0,1,(8,10))
stacke_change=random_normal[0:2,0:2]
stacke_change[stacke_change>1]=2
print(stacke_change)
where=np.where(stacke_change>0,1,0)
print(where)
logical_and=np.where(np.logical_and(stacke_change>0,stacke_change<1),1,0)
print(logical_and)
logical_or=np.where(np.logical_or(stacke_change>0,stacke_change<1),2,3)
print(logical_or)

image

综合运算

import numpy as np
import matplotlib.pyplot as plt
random_normal=np.random.normal(0,1,(8,10))
stacke_change=random_normal[0:2,0:2]
max=stacke_change.max(axis=1)#求最大值,axis 1按行， axis 0按列求值
argmax=stacke_change.argmax()#最大值的下标
print(stacke_change)
print(max)
print(argmax)

image

矩阵

1.矩阵和向量
矩阵：理解---》二维数组
向量：理解---》一维数组
2.加法和标量乘法
加法：对应位置相加
乘法：标量和每个位置的元素相乘
3.矩阵向量（矩阵）乘法
（M行，N列）X （N行，L列）=（M行，L列）

数组间的运算

数组与数的运算

import numpy as np
import matplotlib.pyplot as plt
arr=np.array([1,2,3,4])
print(arr)
new_arr=arr+1
print(new_arr)

image

数组与数组的运算

需要满足广播机制
	维度相同
		shape对应位置为1

矩阵运算

矩阵乘法api

import numpy as np
import matplotlib.pyplot as plt
random_randint_a=np.random.randint(0,10,(3,2))
print(random_randint_a)
random_randint_b=np.random.randint(0,10,(2,2))
print(random_randint_b)
matmul=np.matmul(random_randint_a,random_randint_b)#乘数字报错
dot=np.dot(random_randint_a,10)#乘数字
print(matmul)

image

pandas学习

DataFrame的使用

import pandas as pd
import numpy as np
stock_change=np.random.normal(0,1,(10,5))
stock_code=['股票{}'.format(i+1)for i in range(stock_change.shape[0])]
date=pd.date_range(start='20230211',periods=stock_change.shape[1],freq="B")#freq:递进单位，默认1天，“B”默认略过周未
dataframe=pd.DataFrame(stock_change,index=stock_code,columns=date)
print(dataframe)

image

DataFrame的属性

import pandas as pd
import numpy as np
stock_change=np.random.normal(0,1,(3,4))
stock_code=['股票{}'.format(i+1)for i in range(stock_change.shape[0])]
date=pd.date_range(start='20230211',periods=stock_change.shape[1],freq="B")
dataframe=pd.DataFrame(stock_change,index=stock_code,columns=date)
print(dataframe)
print('-'*20)
print(dataframe.shape)#查看几行几列
print('-'*20)
print(dataframe.index)#查看行标题
print('-'*20)
print(dataframe.columns)#查看列标题
print('-'*20)
print(dataframe.values)#查看值
print('-'*20)
print(dataframe.T)#行，列互换
print('-'*20)
print(dataframe.head(2))#查看前几行
print('-'*20)
print(dataframe.tail(1))#查看后几行

image

索引的设置

import pandas as pd
import numpy as np
stock_change=np.random.normal(0,1,(2,4))
stock_code=['股票{}'.format(i+1)for i in range(stock_change.shape[0])]
date=pd.date_range(start='20230211',periods=stock_change.shape[1],freq="B")
dataframe=pd.DataFrame(stock_change,index=stock_code,columns=date)
reset_index=dataframe.reset_index(drop=True)#drop:默认为False，不删除原来索引，如果为True删除原来的索引值
print(reset_index)

image

import pandas as pd
import numpy as np
dataframe=pd.DataFrame({
    'month':[1,2,3],
    'year':[2,3,4],
    'sale':[8,9,0]
})
new_dataframe=dataframe.set_index(keys=['year'])#以某字段设置索引
print(new_dataframe)

image

数据离散化

pd.qcut()---把数据大致分为数量相等的几类
pd.cut()---指定分组间隔
one-hot编码
把数据转换成为0，1统计类型
pd.get_dummies()

合并

pd.concat()
pd.merge()
left --左表
right --右表
on --指定键
how --按照什么方式进行拼接

交叉表与透视表

探索两列数据之间的关系
pd.crosstab()
返回具体数量
对象.pivot_table()
返回占比情况

分组和聚合

对象.groupby()
参数：as_index --是否进行索引
可以对数据进行对此分组，需要里面传递一个列表进行完成

pandas画图

对象.plot()
kind --
line --折线图
bar
barh --条形图旋转
hist
pie
scatter

文件读取与存储

1.csv
	读取--pd.read_csv
		参数：
			usecols --需要哪列
	存储 --对象.to_csv
		参数：
			columns --保存哪列
2.hdf
	读取 --pd.read_hdf()
	写入 --对象.to_hdf()
		注意：保存文件是 ....。h5
3.json
	读取 --pd.read_json()
	写入--对象.to_json()
		参数：
			orient --
			按照什么方式进行读取或者写入
			lines --是否按照行读取和写入

缺失值

判断数据是否为NAN：
np.any(pd.isnull(movie))#里面如果有一个缺失值，就返回True
np.all(pd.notnull(movie))#里面如果有一个缺失值，就返回False
处理方式：
存在缺失值nan,并且是np.nan:
删除存在的缺失值的dropna(axis='rows')
注：不会修改原数据，需要接受返回值
替换缺失值:fillna(value,inplace=True)
value：替换成的值
inplace:True:会修改原数据,False：不替换修改原数据，生成新的对象不是缺失值nan，有默认标记的
对象.replace()
to_replace --替换前的值
value --替换后的值

K-近邻算法简介

Scikit-learn工具

安装

pip install scikit-learn==0.19.1

k近邻算法api初步使用

from sklearn.neighbors import KNeighborsClassifier
#获取数据
x=[[1],[2],[0],[0]]
y=[1,1,0,0]
#机器学习
#1.实例化一个训练模型
estimator=KNeighborsClassifier(n_neighbors=2)#n_neighbors选定参考几个邻居
#2.调用fit方法进行训练
estimator.fit(x,y)
#预测其他值
ret=estimator.predict([[100]])
print(ret)

pytorch学习

pytorch的安装

https://pytorch.org/get_started/locally
带GPU安装步骤
conda install pytorch torchvision cudatoolkit=9.0 -c pytorch
不带GPU安装步骤
conda install pytorch-cpu torchvision-cpu -c pytorch

pytorch中创建张量

import torch
import numpy as np
#使用python中的列表或者序列创建tensor
t1=torch.Tensor([1,2,3])
print(t1)
#使用numpy中的数组创建tensor
array=np.arange(12).reshape(3,4)
t2=torch.Tensor(array)
print(t2)
#使用torch的api创建tensor
print(torch.empty(3,4))#创建3行4列的空的tensor
print(torch.ones([3,4]))#创建3行4列的全为1的tensor
print(torch.zeros([3,4]))#创建3行4列的全为0的tensor
print(torch.rand([3,4]))#创建3行4列的随机值的tensor，随机值的区间是[0,1)
print(torch.randint(low=0,high=10,size=[3,4]))#创建3行4列的随机整数的tensor,随机值的区间是[low,high)
print(torch.randn([3,4]))#创建3行4列的随机数的tensor，随机数的tensor,随机值的分布式均值为0，方差为1

image

张量的方法和属性

import torch
import numpy as np
t1=torch.Tensor([[[1]]])
t2=torch.Tensor([[[1,2]]])
print(t1.item())#获取tensor中的数据（当tensor中只有一个元素可用）
print(t2.numpy())#转为numpy数组
print(t2.size())#获取形状
print(t2.view(2))#类似numpy中的reshape，是一种浅拷贝，仅仅是形状发生改变
print(t2.dim())#获取阶数
print(t2.max())#获取最大值
print(t2.t()) #t2.transpose()转置二维///transpose(1,2) permute(0,2,1)

image

pytorchAPL的使用

import torch
import torch.nn as nn
from torch.optim import SGD
import matplotlib.pyplot as plt
#0.准备数据
x=torch.rand([500,1])
y_true=3 * x +0.8
#1.定义模型
class MyLinear(nn.Module):
    def __init__(self):
        #继承父类的init
        super(MyLinear,self).__init__()
        self.linear=nn.Linear(1,1)
    def forward(self,x):
        out=self.linear(x)
        return out
#2.实例化模型，优化器类实例化，loss实例化
my_linear=MyLinear()
optimizer=SGD(my_linear.parameters(),0.001)
loss_fn=nn.MSELoss()
#3.循环，进行梯度下降，参数的更新
for i in range(2000):
    #得到预测值
    y_predict=my_linear(x)
    loss=loss_fn(y_predict,y_true)
    #梯度置为0
    optimizer.zero_grad()
    #反向传播
    loss.backward()
    #参数的跟新
    optimizer.step()
    if i%50==0:
        params=list(my_linear.parameters())
        print(loss.item(),params[0].item(),params[1].item())
#4.模型评估
my_linear.eval()#设置模型为评估模式，即预测模式
#my_linear.train(mode=True)#表示设置模型为训练模式
predict=my_linear(x)
predict=predict.data.numpy()
plt.scatter(x.data.numpy(),y_true.data.numpy(),c='r')
plt.plot(x.data.numpy(),predict)
plt.show()

image

在GPU上运行

import torch
import torch.nn as nn
from torch.optim import SGD
import matplotlib.pyplot as plt
#定义一个device对象
deivce=torch.device('cuda' if torch.cuda.is_available() else 'cpu')
#0.准备数据
x=torch.rand([500,1]).to(deivce)
y_true=3 * x +0.8
y_true=y_true.to(deivce)
#1.定义模型
class MyLinear(nn.Module):
    def __init__(self):
        #继承父类的init
        super(MyLinear,self).__init__()
        self.linear=nn.Linear(1,1)
    def forward(self,x):
        out=self.linear(x)
        return out
#2.实例化模型，优化器类实例化，loss实例化
my_linear=MyLinear().to(deivce)
optimizer=SGD(my_linear.parameters(),0.001)
loss_fn=nn.MSELoss()
#3.循环，进行梯度下降，参数的更新
for i in range(2000):
    #得到预测值
    y_predict=my_linear(x)
    print(y_predict)
    loss=loss_fn(y_predict,y_true)
    #梯度置为0
    optimizer.zero_grad()
    #反向传播
    loss.backward()
    #参数的跟新
    optimizer.step()
    if i%50==0:
        params=list(my_linear.parameters())
        print(loss.item(),params[0].item(),params[1].item())

opencv学习

中文教程

安装

pip install opencv-contrib-python 最新版安装失败
pip install opencv-python==4.3.0.38

初步使用

import cv2
import numpy as np
if __name__ == '__main__':
    flower=cv2.imread('./1.webp')
    # print(flower.shape)
    # print(type(flower))
    # print(flower)
    cv2.imshow('flower',flower)#弹出窗口
    cv2.waitKey()#行待键盘输入，任意输入就可以关闭
    cv2.destroyAllWindows()#销毁内存

尺寸和颜色

import cv2
import numpy as np
if __name__ == '__main__':
    flower=cv2.imread('./1.webp')
    flower=cv2.resize(flower,(305,305))#图片尺寸的改变
    gray=cv2.cvtColor(flower,code=cv2.COLOR_BGR2GRAY)#黑白图片
    cv2.imshow('flower',gray)#弹出窗口
    cv2.waitKey(0)#0无限等待，1000毫秒=1秒这后，自动消失
    cv2.destroyAllWindows()#销毁内存

image

hsv颜色

import cv2
import numpy as np
if __name__ == '__main__':
    flower=cv2.imread('./1.webp')
    hsv=cv2.cvtColor(flower,code=cv2.COLOR_BGR2HSV)
    #定义在HSV颜色空间中蓝色的范围
    lower_blue=np.array([110,50,50])#浅蓝色
    upper_blue=np.array([130,255,255])#深蓝色
    #根据蓝色的范围，标记图片中哪些位置是蓝色
    mask=cv2.inRange(hsv,lower_blue,upper_blue)
    print(mask)
    cv2.imshow('hsv的使用',hsv)#弹出窗口
    cv2.waitKey(0)#0无限等待，1000毫秒=1秒这后，自动消失
    cv2.destroyAllWindows()#销毁内存

image

图片马赛克

import cv2
import numpy as np
if __name__ == '__main__':
    flower=cv2.imread('./1.webp')
    #模糊
    flower2=cv2.resize(flower,(35,23))
    flower3=cv2.resize(flower2,(500,500))
    cv2.imshow('马赛克的使用',flower3)#弹出窗口
    cv2.waitKey(5000)#0无限等待，1000毫秒=1秒这后，自动消失
    cv2.destroyAllWindows()#销毁内存
    #方式一
    # flower2=cv2.resize(flower,(35,23))
    # flower3=np.repeat(flower2,10,axis=0)#repeat重复
    # flower4=np.repeat(flower3,10,axis=1)
    # cv2.imshow('马赛克的使用',flower4)#弹出窗口
    # cv2.waitKey(5000)#0无限等待，1000毫秒=1秒这后，自动消失
    # cv2.destroyAllWindows()#销毁内存

    #方式二
    # flower2=flower[::10,::10]#第10个中取出一个像素
    # cv2.namedWindow('马赛克的使用',flags=cv2.WINDOW_NORMAL)
    # cv2.resizeWindow('马赛克的使用',500,500)
    # cv2.imshow('马赛克的使用',flower2)
    # cv2.waitKey(0)

image
image

人脸马赛克

import cv2
import numpy as np
if __name__ == '__main__':
    belle=cv2.imread('./2.webp')
    #人脸左上角坐标（160，145）右下角坐标（310，300）(宽度，高度）
    face=belle[145:300,160:310]
    face=face[::10,::10]
    face=np.repeat(face,10,axis=0)
    face=np.repeat(face,10,axis=1)
    belle[145:300,160:310]=face[:155,:150]#填充，尺寸一致
    cv2.imshow('美女',belle)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

人脸检测

资料下载

import cv2
import numpy as np
if __name__ == '__main__':
    belle=cv2.imread('./2.webp')
    #人脸特征详细说明
    face_detector=cv2.CascadeClassifier('./haarcascade_frontalface_alt.xml')
    faces=face_detector.detectMultiScale(belle)#坐标x,y,w,h
    print(faces)
    for x,y,w,h in faces:
        cv2.rectangle(belle,pt1=(x,y),pt2=(x+w,y+h),color=[0,0,255],thickness=2)#矩形
    cv2.imshow('人脸检测',belle)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

多张人脸检测

import cv2
import numpy as np
if __name__ == '__main__':
    belles=cv2.imread('./3.jpeg')
    # gray=cv2.cvtColor(belles,code=cv2.COLOR_BGR2GRAY)#减少数据
    #人脸特征详细说明
    face_detector=cv2.CascadeClassifier('./haarcascade_frontalface_alt.xml')
    faces=face_detector.detectMultiScale(belles,
                                         scaleFactor=1.1,#缩放
                                         minNeighbors=1,#

                                         )#坐标x,y,w,h
    print(faces)
    for x,y,w,h in faces:
        # cv2.rectangle(belles,pt1=(x,y),pt2=(x+w,y+h),color=[0,0,255],thickness=2)#矩形
        cv2.circle(belles,center=(x+w//2,y+h//2),
                   radius=w//2,
                   color=[0,255,0],
                   thickness=2)#圆
    cv2.imshow('人脸检测',belles)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

人脸贴纸画

import cv2
import numpy as np

if __name__ == '__main__':
    belle = cv2.imread('./2.webp')
    gray = cv2.cvtColor(belle, code=cv2.COLOR_BGR2GRAY)
    face_detector = cv2.CascadeClassifier('./haarcascade_frontalface_alt.xml')
    faces = face_detector.detectMultiScale(gray)
    star = cv2.imread('./4.webp')
    for x, y, w, h in faces:
        # cv2.rectangle(belle,pt1=(x,y),pt2=(x+w,y+h),color=[0,0,255],thickness=2)
        # belle[y:y+h//4,x+(3*w)//8-10:x+(3*w)//8-10+w//4]=cv2.resize(star,(w//4,h//4))
        star_s = cv2.resize(star, (w // 4, h // 4))
        w1 = w // 4
        h1 = h // 4
        for i in range(h1):
            for j in range(w1):
                if not (star_s[i, j] > 180).all():  # 显示红色
                    belle[i + y, j + x + 3 * w // 8 - 10] = star_s[i, j]
    cv2.imshow('face painting', belle)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

轮廓绘制

import cv2
import numpy as np

if __name__ == '__main__':
    belle=cv2.imread('images.jpg')
    hsv=cv2.cvtColor(belle,code=cv2.COLOR_BGR2HSV)
    #跟据颜色的值进行查找
    lower_red=(156,50,50)#浅红色
    upper_red=(180,255,255)#深红色
    mask=cv2.inRange(hsv,lower_red,upper_red)
    #手工绘制
    # h,w,c=belle.shape
    # mask=np.zeros((h,w),dtype=np.uint8)
    # x_data=np.array([124,169,208,285,307,260,175])+50
    # y_data=np.array([205,124,135,173,216,311,309])+10
    # pts=np.c_[x_data,y_data]#横纵坐标合并，点（x,y)
    # cv2.fillPoly(mask,[pts],(255),8,0)
    # res=cv2.bitwise_and(belle,belle,mask=mask)
    cv2.imshow('belle',mask)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

轮廓边界

import cv2
import numpy as np

if __name__ == '__main__':
    belle=cv2.imread('2.webp')
    gray=cv2.cvtColor(belle,cv2.COLOR_BGR2GRAY)
    gray2=cv2.GaussianBlur(gray,(5,5),1)
    canny=cv2.Canny(gray2,75,200)
    cv2.imshow('belle',canny)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

人脸轮廓替换

import cv2
import numpy as np

if __name__ == '__main__':
    belle=cv2.imread('2.webp')
    dog=cv2.imread('5.jpg')
    face_detector=cv2.CascadeClassifier('./haarcascade_frontalface_alt.xml')
    belle_gray=cv2.cvtColor(belle,code=cv2.COLOR_BGR2GRAY)
    dog_gray=cv2.cvtColor(dog,code=cv2.COLOR_BGR2GRAY)
    #狗二进制图片，黑白
    threshold,binary=cv2.threshold(dog_gray,50,255,cv2.THRESH_OTSU)
    print(threshold)
    contours,hierarchy=cv2.findContours(binary,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    areas=[]
    for contour in contours:
        areas.append(cv2.contourArea(contour))
    areas=np.asarray(areas)
    index=areas.argsort()#从小到大，进行排序
    mask=np.zeros_like(dog_gray,dtype=np.uint8)
    mask=cv2.drawContours(mask,contours,index[-2],(255,255,255),thickness=-1)
    faces=face_detector.detectMultiScale(belle)
    for x,y,w,h in faces:
        mask2=cv2.resize(mask,(w,h))
        dog_gray2=cv2.resize(dog_gray,(w,h))
        for i in range(h):
            for j in range(w):
                if not (mask2[i,j]==255).all():
                    belle[i+y,j+x]=dog_gray2[i,j]
    cv2.imshow('belle',belle)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

直方图均匀化处理

pip install scikit-image 图片处理库

import cv2
import numpy as np
import matplotlib.pyplot as plt
from skimage import data
if __name__ == '__main__':
    moon=data.moon()
    # plt.hist(moon.ravel(),bins=256)
    # plt.show()
    # moon2=cv2.equalizeHist(moon)#直方图均衡化
    # plt.hist(moon2.reshape(-1),bins=256)
    # plt.show()
    hist=cv2.calcHist([moon],[0],None,[256],[0,256])
    print(hist)
    print(hist.shape)
    plt.plot(hist)
    plt.show()
    cv2.imshow('moon',moon)
    # cv2.imshow('moon',moon2)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image
image
image
image
image

视频中人脸识别

import cv2
if __name__ == '__main__':
    video=cv2.VideoCapture('./1.mp4')
    face_detector=cv2.CascadeClassifier('./haarcascade_frontalface_alt.xml')
    while True:
        retval,image=video.read()#retval 布尔值表明是否获得图片
        image=cv2.resize(image,(640,360))
        if retval==False:#取了最后一张，再读取，就没有了
            print('视频读取完毕')
            break
        gray=cv2.cvtColor(image,code=cv2.COLOR_BGR2GRAY)
        faces=face_detector.detectMultiScale(gray)
        for x,y,w,h in faces:
            cv2.rectangle(image,pt1=(x,y),pt2=(x+w,y+h),color=[0,0,255],thickness=2)
        cv2.imshow('ttnk',image)
        key=cv2.waitKey(1)
        if key==ord('q'):
            print('用户键盘输入了q，程序退出')
            break
    print(image.shape)
    cv2.destroyAllWindows()
    video.release()#释放内存

image

视频人脸马赛克和属性

import cv2
import numpy as np
if __name__ == '__main__':
    video=cv2.VideoCapture('./1.mp4')
    fps=video.get(propId=cv2.CAP_PROP_FPS)#视频帧率
    width=video.get(propId=cv2.CAP_PROP_FRAME_WIDTH)#视频宽度
    height=video.get(propId=cv2.CAP_PROP_FRAME_HEIGHT)#视频高度
    count=video.get(propId=cv2.CAP_PROP_FRAME_COUNT)#视频帧率
    print(fps,width,height,count)
    face_detector=cv2.CascadeClassifier('./haarcascade_frontalface_alt.xml')
    while True:
        retval,image=video.read()#retval 布尔值表明是否获得图片
        image=cv2.resize(image,(640,360))
        if retval==False:#取了最后一张，再读取，就没有了
            print('视频读取完毕')
            break
        gray=cv2.cvtColor(image,code=cv2.COLOR_BGR2GRAY)
        faces=face_detector.detectMultiScale(gray)
        for x,y,w,h in faces:
            # cv2.rectangle(image,pt1=(x,y),pt2=(x+w,y+h),color=[0,0,255],thickness=2)
            face=image[y:y+h,x:x+w]
            face=face[::10,::10]
            face=np.repeat(np.repeat(face,10,axis=0),10,axis=1)
            image[y:y+h,x:x+w]=face[:h,:w]
        cv2.imshow('ttnk',image)
        key=cv2.waitKey(1)
        if key==ord('q'):
            print('用户键盘输入了q，程序退出')
            break

    cv2.destroyAllWindows()
    video.release()#释放内存

image

视频保存

import cv2
import numpy as np
if __name__ == '__main__':
    video=cv2.VideoCapture('./2.mp4')
    face_detector=cv2.CascadeClassifier('./haarcascade_frontalface_alt.xml')
    writer=cv2.VideoWriter(filename='./a.mp4',
                    fourcc=cv2.VideoWriter.fourcc(*'MP4V'),#视频编码
                    fps=24,#帧率
                    frameSize=(640,360)#图片尺寸
                    )
    while True:
        retval,image=video.read()#retval 布尔值表明是否获得图片
        # image=cv2.resize(image,(640,360))
        if retval==False:#取了最后一张，再读取，就没有了
            print('视频读取完毕')
            break
        gray=cv2.cvtColor(image,code=cv2.COLOR_BGR2GRAY)#黑白，二维
        gray2=np.repeat(gray.reshape(360,640,1),3,axis=1)#蓝绿红
        writer.write(gray2)
        faces=face_detector.detectMultiScale(gray)
        for x,y,w,h in faces:
            # cv2.rectangle(image,pt1=(x,y),pt2=(x+w,y+h),color=[0,0,255],thickness=2)
            face=image[y:y+h,x:x+w]
            face=face[::10,::10]
            face=np.repeat(np.repeat(face,10,axis=0),10,axis=1)
            image[y:y+h,x:x+w]=face[:h,:w]
        cv2.imshow('ttnk',image)
        key=cv2.waitKey(1)
        if key==ord('q'):
            print('用户键盘输入了q，程序退出')
            break

    cv2.destroyAllWindows()
    video.release()#释放内存
    writer.release()

pydub音频的使用

教程

初步使用

import pydub
if __name__ == '__main__':
    mp3=pydub.AudioSegment.from_mp3('./1.mp3')
    print(mp3)
    m=mp3[:21*1000]
    m.export('./2.mp3')

音视频合成

import subprocess
if __name__ == '__main__':
    #将视频和音频进行合并
    cmd='ffmpeg -i 2.mp4 -i 2.mp3 out.mp4'
    c=subprocess.call(cmd,shell=True)
    print('0成功，反之不成功',c)

摄像头人脸识

import numpy as np
import cv2
if __name__ == '__main__':
    cap=cv2.VideoCapture(0)#打开本机的摄像头
    while True:
        flag,frame=cap.read()#flag是否读取了图片
        if not flag:
            break
        gray=cv2.cvtColor(frame,code=cv2.COLOR_BGR2GRAY)
        cv2.imshow('face',frame)
        key=cv2.waitKey(1000//24)
        if key==ord('q'):
            break
        cv2.destroyAllWindows()
        cap.release()

腐蚀和膨胀

import numpy as np
import cv2
if __name__ == '__main__':
    img=cv2.imread('./images2.jpg',flags=cv2.IMREAD_GRAYSCALE)
    img=(img-255)*255
    kernel=np.ones(shape=[5,5],dtype=np.uint8)
    #腐蚀，由多变少
    img2=cv2.erode(img,kernel=kernel,iterations=1)
    cv2.imshow('erode',img)
    cv2.imshow('erode2',img2)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

import numpy as np
import cv2
if __name__ == '__main__':
    img=cv2.imread('./images2.jpg',flags=cv2.IMREAD_GRAYSCALE)
    img=(img-255)*255
    kernel=np.ones(shape=[5,5],dtype=np.uint8)
    #腐蚀，由多变少,越是边界上，越容易被腐蚀，去除噪声，图像变小，变细
    img2=cv2.erode(img,kernel=kernel,iterations=1)
    #膨胀，图像变粗，变大
    img3=cv2.dilate(img2,kernel,iterations=1)
    cv2.imshow('raw',img)#原图
    cv2.imshow('erode',img2)#腐蚀
    cv2.imshow('dilate',img3)#膨胀，还原（噪声去掉还原）
    cv2.waitKey(0)
    cv2.destroyAllWindows()

image

形态操作

import numpy as np
import cv2
if __name__ == '__main__':
    img=cv2.imread('./images2.jpg',flags=cv2.IMREAD_GRAYSCALE)
    img=(img-255)*255
    #开运算
    result=cv2.morphologyEx(img,op=cv2.MORPH_OPEN,kernel=np.ones(shape=[5,5],
                                                                 dtype=np.uint8,
                                                                 ),iterations=1)
    #闭运算
    result2=cv2.morphologyEx(img,op=cv2.MORPH_CLOSE,kernel=np.ones(shape=[10,10],dtype=np.uint8),
                             iterations=1)
    #形态学梯度
    result3 = cv2.morphologyEx(img, op=cv2.MORPH_GRADIENT, kernel=np.ones(shape=[5, 5],
                                                                     dtype=np.uint8,
                                                                     ), iterations=1)
    cv2.imshow('raw',img)#原图
    cv2.imshow('morphologyEx',result)
    cv2.imshow('morphologyEx2',result2)
    cv2.imshow('morphologyEx3',result3)
    cv2.waitKey(0)
    cv2.destroyAllWindows()

车牌号识别

资料下载

import numpy as np
import cv2
if __name__ == '__main__':
   car=cv2.imread('./car.png')
   gray=cv2.cvtColor(car,code=cv2.COLOR_BGR2GRAY)
   car_detector=cv2.CascadeClassifier('./haarcascade_russian_plate_number.xml')
   # plates=car_detector.detectMultiScale(gray)
   plates = car_detector.detectMultiScale(gray,
                                          scaleFactor=1.05,  # 缩放
                                          minNeighbors=1,  #

                                          )  # 坐标x,y,w,h
   for x,y,w,h in plates:
       cv2.rectangle(car,pt1=(x,y),pt2=(x+w,y+h),color=[0,0,255],thickness=2)
   cv2.imshow('plates',car)
   cv2.waitKey(0)
   cv2.destroyAllWindows()

image

车牌号定位

import numpy as np
import cv2
def lpr(filename):
    img=cv2.imread(filename)
    gray_img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)#灰度化处理
    GaussianBlur_img=cv2.GaussianBlur(gray_img,(3,3),0)#高斯平滑
    Sobel_img=cv2.Sobel(GaussianBlur_img,-1,1,0,ksize=3)#提取边界
    ret,binary_img=cv2.threshold(Sobel_img,127,255,cv2.THRESH_BINARY)#二值化操作
    #形态学运算
    kernel=np.ones((5,15),np.uint8)
    #先闭运算将车牌数字部分连接，再开运算将不是块状的或是较小的部分去掉
    close_img=cv2.morphologyEx(binary_img,cv2.MORPH_CLOSE,kernel)
    open_img=cv2.morphologyEx(close_img,cv2.MORPH_OPEN,kernel)
    #由于部分图像得到的轮廓边缘不整齐，因此再进行一次膨胀操作
    element=cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
    dilation_img=cv2.dilate(open_img,element,iterations=3)
    #获取轮廓
    contours,hierarchy=cv2.findContours(dilation_img,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
    rectangles=[]
    for c in contours:
        x=[]
        y=[]
        for point in c:
            y.append(point[0][0])
            x.append(point[0][1])
        r=[min(y),min(x),max(y),max(x)]
        rectangles.append(r)
    #用颜色识别出车牌区域
    dist_r=[]
    max_mean=0
    for r in rectangles:
        block=img[r[1]:r[3],r[0]:r[2]]
        hsv=cv2.cvtColor(block,cv2.COLOR_BGR2HSV)
        low=np.array([100,43,46])
        up=np.array([124,255,255])
        result=cv2.inRange(hsv,low,up)
        #用计算均值的方式
        mean=np.mean(result)
        if mean > max_mean:
            max_mean=mean
            dist_r=r
    #画出识别结果
    cv2.rectangle(img,(dist_r[0]+3,dist_r[1]),(dist_r[2]-3,dist_r[3]),(0,255,0),2)
    cv2.imshow('lpr',img)
    cv2.waitKey(0)
    cv2.destroyAllWindows()
if __name__ == '__main__':
    path='./car2.jpg'
    lpr(path)

image

HSV颜色查询

image

标签：__,plt,cv2,笔记,学习,print,np,import
From： https://www.cnblogs.com/ytmjcmn/p/17980075

相关文章

  • DC-9渗透学习
    开靶机，net模式，启动arp-scan-l命令扫描存活主机nmap-sS-sV-A-n192.168.100.22┌──(root㉿kali)-[~]└─#nmap-sS-sV-A-n192.168.100.22StartingNmap7.94(https://nmap.org)at2024-01-3121:21ESTNmapscanreportfor192.168.100.22Hostisup(0.0......
  • 浮木云学习日志（6）---代码导出
    随着对浮木云的了解愈加深入，不知不觉已经形成5篇随笔记录了，新进来的小伙伴想跟我一样了解浮木云的话，可直接进入官网浮木云-产品设计开发智能助手进行了解使用，如果不太清楚使用的话，可直接查看我之前的5篇小记，帮助你快速入门。之前刚介绍浮木云的时候，发现这个小众平台具有导出源代......
  • GPU学习笔记
    GPU相比CPU更适合连续的同质的运算。原因：  GPU有更多算术运算单元（ALU）  支持多线程处理分支  wrap独占寄存器  ...单指令多数据（SIMD）：每次取一条指令，应用到多个不同数据计算的计算上。单指令多线程（SIMT）：会把程序分支分布到不同线程上，线程组执行每执行指令会更新掩码告......
  • tcp 远程服务器,C#编程学习之使用TcpClient / BeginConnect测试远程服务器tcp端口连接
    原文链接：hhttps://blog.csdn.net/weixin_36286567/article/details/119265325有时候经常需要对一些服务器的端口进行tcp连接测试，通常使用“telnetIP地址端口号”的方式即可，不能说这种方式不可取，只是使用起来比较麻烦，本着简单好用的目的，不如我们自己动手写一个测试tcp端口连接的......
  • 字符串算法学习笔记
    \(\text{Pt.}1\)基础一、进制哈希二、Manacher三、Trie\(\text{Pt.}2\)自动机自动机是什么？它是一个对“信息序列”进行判定的数学模型。“信息序列”可以很随意，比如一个二进制数，比如一个字符串。而“判定”也可以很随意，比如判定一个二进制数是不是奇数，判定当前字符串是......
  • m基于Q-Learning强化学习的异构网络小区范围扩展(CRE)技术matlab仿真
    1.算法仿真效果matlab2022a仿真结果如下： 2.算法涉及理论知识概要        基于Q-Learning强化学习的异构网络小区范围扩展（CellRangeExtension,CRE）技术是一种旨在优化异构无线网络性能的方法。异构网络是由不同类型的基站（如宏基站、微基站、皮基站等）组成的网络，这......
  • 程序是怎样跑起来的第二章读书笔记
    根据本章内容知道了8位=1字节，了解了用二进制数表示计算机信息的原因。只要掌握了使用二进制数来表示信息的方法及其运算机制也就自然能够了解程序的运行机制，理解了为什么计算机处理的信息要用二进制数来表示的，近一步知道用二进制数表示计算机信息的原因。计算机内部是由IC”这种......
  • 蒻苟的第一篇学习笔记（快速排序）
    快速排序是一个非常经典也非常常用的排序算法。在平均状况下，排序n个项目需要Ο(nlogn)次比较，在最坏状况下则需要Ο(n2)次比较，但这种状况其实并不常见。快速排序是分而治之思想在排序算法上的典型应用。算法步骤：1.从数列中挑出一个元素，称为"基准"。2。设置两个"哨兵"，利用......
  • 《程序是怎样跑起来的》阅读笔记 - 第一、二章
    简介：《程序是怎样跑起来的》是一本介绍计算机程序工作原理的畅销书籍。本文将对该书的前两章进行阅读笔记，主要涵盖了计算机基础知识和程序执行过程的基本原理。第一章：计算机基础知识本章主要讲解了计算机的基本组成部分以及它们之间的关系。作者通过引入一个简单的模型，描述了计......
  • 欧拉函数学习笔记
    前言本人能力有限，有错误欢迎指出。定义\(\varphi(n)\)表示的是小于等于\(n\)和\(n\)互质的数的个数。公式设\(n=\prod\limits_{i=1}^{s}p_i^{k_i}\)，有\[\begin{aligned}\varphi(n)&=\prod_{i=1}^s\varphi(p_i^{k_i})\\&=\prod_{i=1}^sp_i^{k_i}-p_i^{k_i-1}\\&=\prod......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99