精华内容
下载资源
问答
  • 今天小编就为大家分享一篇Python谱减法语音降噪实例,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 我们下面借助opencv的python封装包cv2,对其进行一些降噪处理,使得图片更新清晰和无干扰。 二值化处理在图片处理中,二值化是一个很常见的操作,我们首先将图片转为灰度,然后再根据特定的阈值将图片进行黑白的二值...

    o55g08d9dv.jpg广告关闭

    腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元!

    我们下面借助opencv的python封装包cv2,对其进行一些降噪处理,使得图片更新清晰和无干扰。 二值化处理在图片处理中,二值化是一个很常见的操作,我们首先将图片转为灰度,然后再根据特定的阈值将图片进行黑白的二值化处理。 import cv2import matplotlib.pyplot as pltimg =cv2.imread(201910302114.png)img2 = cv2...

    简介图片验证码识别的可以分为几个步骤,一般用 pillow 库或 opencv 来实现,这几个过程是:1. 灰度处理&二值化2. 降噪3.字符分割4. 标准化5. 识别所谓降噪就是把不需要的信息通通去除,比如背景,干扰线,干扰像素等等,只留下需要识别的字符,让图片变成2进制点阵,方便代入模型训练。 8邻域降噪8邻域降噪 的前提是...

    另外降噪可以多次执行,比如我对上面的降噪后结果再进行依次降噪,可以得到下面的效果:再进行识别得到了结果:p7 = image.open(7.png)tesserocr.image_to_text(p7)8069 ,nn另外,从图片来看,实际数据颜色明显和噪点干扰线不同,根据这一点可以直接把噪点全部去除,这里就不展开说了。 第一篇文章,先记录如何将图片...

    s3vlyovq30.jpeg

    所有源码点击阅读原文。 原网址:https:www.cnblogs.comqqandfqrp7866650.html大致介绍 在python爬虫爬取某些网站的验证码的时候可能会遇到验证码识别的...降噪 降噪是验证码处理中比较重要的一个步骤,我这里使用了点降噪和线降噪? 线降噪的思路就是检测这个点相邻的四个点(图中标出的绿色点),判断这四个点...

    准备工作这里我们使用opencv做图像处理,所以需要安装下面两个库pip3 install opencv-pythonpip3 installnumpy识别原理我们采取一种有监督式学习的方法来识别验证码,包含以下几个步骤图片处理 - 对图片进行降噪、二值化处理切割图片 -将图片切割成单个字符并保存人工标注 - 对切割的字符图片进行人工标注...

    hd9f7prcba.png

    大致介绍 在python爬虫爬取某些网站的验证码的时候可能会遇到验证码识别的问题,现在的验证码大多分为四类:1、计算验证码2、滑块验证码 3、识图验证码 4...img) return img降噪 降噪是验证码处理中比较重要的一个步骤,我这里使用了点降噪和线降噪? 线降噪的思路就是检测这个点相邻的四个点(图中标出的绿色点)...

    简介本书是计算机视觉编程的权威实践指南,通过python语言讲解了基础理论与算法,并通过大量示例细致分析了对象识别、基于内容的图像搜索、光学字符识别、光流法、跟踪、3d重建、立体成像、增强现实、姿态估计、全景创建、图像分割、降噪、图像分组等技术。 另外,书中附带的练习还能让读者巩固并学会应用编程知识...

    3n79ott2w8.png

    tesserocr是python的一个ocr识别库,但其实是对tesseract做的一层python api封装,所以它的核心是tesseract。 因此,在安装tesserocr之前,我们需要先安装...图片降噪所谓降噪就是把不需要的信息通通去除,比如背景,干扰线,干扰像素等等,只剩下需要识别的文字,让图片变成2进制点阵最好。 对于彩色背景的验证码...

    opencv 使用 cc++ 开发,同时也提供了 python、java、matlab 等其他语言的接口。 如果你不了解 cc++,请阅读《c语言教程》和《c++教程》。 opencv 是跨平台的,可以在 windows、linux、mac os、android、ios 等操作系统上运行。 应用领域非常广泛,包括图像拼接、图像降噪、产品质检、人机交互、人脸识别、动作识别...

    335wwyaddq.png

    www.pythonware.comproductspil(csdn下载)下载后是一个exe,直接双击安装,它会自动安装到c:python27libsite-packages中去,(2)pytesser:下载地址:http:code.google.comppytesser,(csdn下载)下载解压后直接放c:python27libsite-packages(根据你安装的python路径而不同),同时,新建一个pytheeer.pth,内容...

    1、 opencv的结构和python一样,当前的opencv也有两个大版本,opencv2和opencv3。 相比opencv2,opencv3提供了更强的功能和更多方便的特性。 不过考虑到和深度学习框架的兼容性,以及上手安装的难度,这部分先以2为主进行介绍。 根据功能和需求的不同,opencv中的函数接口大体可以分为如下部分:core:核心模块...

    98b0l1dun3.jpeg

    另外降噪可以多次执行,比如我对上面的降噪后结果再进行依次降噪,可以得到下面的效果:再进行识别得到了结果:另外,从图片来看,实际数据颜色明显和噪点干扰线不同,根据这一点可以直接把噪点全部去除,这里就不展开说了。 第一篇文章,先记录如何将图片进行灰度处理、二值化、降噪,并结合tesserocr来识别简单的...

    如下:2 识别思路首先对图片做二值化来降噪处理,去掉图片中的噪点,干扰线等。 然后将图片中的单个字符切分出来。 最后识别每个字符。 图片的处理,我采用 python 标准图像处理库 pil。 图片分割,我暂时采用谷歌开源库 tesseract-ocr。 字符识别则使用 pytesseract 库。 3 安装pillow我使用的 python 版本是 3.6, ...

    微软在 github 上开源了一个 python 静态类型检查工具:pyright ,引起了社区内的多方关注。 微软在开源项目上的参与力度是越来越大了,不说收购 github 这种大的战略野心,只说它家开源的 vs code 编辑器,在猿界已经割粉无数,连我们 python 圈的红人 kenneth reitz(多个开源项目的作者,包括 requests、requests...

    ag49mco9a2.jpg

    adorable-animal-basket-1543793.jpg 近日,微软在 github 上开源了一个 python 静态类型检查工具:pyright ,引起了社区内的多方关注。 微软在开源项目上的参与力度是越来越大了,不说收购 github 这种大的战略野心,只说它家开源的 vs code 编辑器,在猿界已经割粉无数,连我们 python 圈的红人 kenneth reitz...

    6efc5wbxkv.jpeg

    近日,微软在 github 上开源了一个 python 静态类型检查工具:pyright ,引起了社区内的多方关注。 微软在开源项目上的参与力度是越来越大了,不说收购 github 这种大的战略野心,只说它家开源的 vs code 编辑器,在猿界已割粉无数,连我 python 圈的红人 kennethreitz(多个开源项目的作者,包括 requests、requests...

    qvjz4w2lda.png

    http:pythonware.comproductspil注:官网提供的安装包是32位的,64位系统请前往这里 http:www.lfd.uci.edu~gohlkepythonlibs#pillow 下载替代包pillow。 三、一般思路验证码识别的一般思路为:1、图片降噪2、图片切割3、图像文本输出3.1图片降噪所谓降噪就是把不需要的信息通通去除,比如背景,干扰线,干扰像素等等...

    原文链接:http:tecdat.cn? p=13173----介绍在本教程中,我们将学习如何使用python语言执行图像处理。 我们不会局限于单个库或框架; 但是,我们将最常使用的是open cv库。 我们将先讨论一些图像处理,然后再继续介绍可以方便使用图像处理的不同应用程序场景。 什么是图像处理? 重要的是要了解图像处理的确切含义...

    ostp2dzdii.jpeg

    作者|dataman编译|arno来源|analyticsvidhya这篇文章的目的是介绍关于利用自动编码器实现图像降噪的内容。 在神经网络世界中,对图像数据进行建模需要特殊的方法。 其中最著名的是卷积神经网络(cnn或convnet)或称为卷积自编码器。 并非所有的读者都了解图像数据,那么我先简要介绍图像数据(如果你对这方面已经很清楚...

    n6idyqi228.jpeg

    作者|dataman编译|arno来源|analyticsvidhya这篇文章的目的是介绍关于利用自动编码器实现图像降噪的内容。 在神经网络世界中,对图像数据进行建模需要特殊的方法。 其中最著名的是卷积神经网络(cnn或convnet)或称为卷积自编码器。 并非所有的读者都了解图像数据,那么我先简要介绍图像数据(如果你对这方面已经很清楚...

    展开全文
  • 谱减法语音降噪Python实现

    万次阅读 多人点赞 2017-03-03 16:18:18
    谱减法语音降噪Python实现 本文是参考 [投稿]谱减法语音降噪原理 Matlab版本的代码,采用Python实现的。具体的降噪原理请参阅上文。 下面是谱减法语音降噪Python实现 文件speech_enhanced.py #!/usr/...

    谱减法语音降噪的Python实现

    本文是参考 [投稿]谱减法语音降噪原理 Matlab版本的代码,采用Python实现的。具体的降噪原理请参阅上文。

    20190427 修改了部分逻辑错误,感谢 Jarvissshcjdnxjsjj

    先来张图看看效果:
    在这里插入图片描述
    下面是谱减法语音降噪的Python实现

    文件speech_enhanced.py

    #!/usr/bin/env python
    import numpy as np
    import wave
    import nextpow2
    import math
    
    # 打开WAV文档
    f = wave.open("input_file.wav")
    # 读取格式信息
    # (nchannels, sampwidth, framerate, nframes, comptype, compname)
    params = f.getparams()
    nchannels, sampwidth, framerate, nframes = params[:4]
    fs = framerate
    # 读取波形数据
    str_data = f.readframes(nframes)
    f.close()
    # 将波形数据转换为数组
    x = np.fromstring(str_data, dtype=np.short)
    # 计算参数
    len_ = 20 * fs // 1000 # 样本中帧的大小
    PERC = 50 # 窗口重叠占帧的百分比
    len1 = len_ * PERC // 100  # 重叠窗口
    len2 = len_ - len1   # 非重叠窗口
    # 设置默认参数
    Thres = 3
    Expnt = 2.0
    beta = 0.002
    G = 0.9
    # 初始化汉明窗
    win = np.hamming(len_)
    # normalization gain for overlap+add with 50% overlap
    winGain = len2 / sum(win)
    
    # Noise magnitude calculations - assuming that the first 5 frames is noise/silence
    nFFT = 2 * 2 ** (nextpow2.nextpow2(len_))
    noise_mean = np.zeros(nFFT)
    
    j = 0
    for k in range(1, 6):
        noise_mean = noise_mean + abs(np.fft.fft(win * x[j:j + len_], nFFT))
        j = j + len_
    noise_mu = noise_mean / 5
    
    # --- allocate memory and initialize various variables
    k = 1
    img = 1j
    x_old = np.zeros(len1)
    Nframes = len(x) // len2 - 1
    xfinal = np.zeros(Nframes * len2)
    
    # =========================    Start Processing   ===============================
    for n in range(0, Nframes):
        # Windowing
        insign = win * x[k-1:k + len_ - 1]
        # compute fourier transform of a frame
        spec = np.fft.fft(insign, nFFT)
        # compute the magnitude
        sig = abs(spec)
    
        # save the noisy phase information
        theta = np.angle(spec)
        SNRseg = 10 * np.log10(np.linalg.norm(sig, 2) ** 2 / np.linalg.norm(noise_mu, 2) ** 2)
    
    
        def berouti(SNR):
            if -5.0 <= SNR <= 20.0:
                a = 4 - SNR * 3 / 20
            else:
                if SNR < -5.0:
                    a = 5
                if SNR > 20:
                    a = 1
            return a
    
    
        def berouti1(SNR):
            if -5.0 <= SNR <= 20.0:
                a = 3 - SNR * 2 / 20
            else:
                if SNR < -5.0:
                    a = 4
                if SNR > 20:
                    a = 1
            return a
    
        if Expnt == 1.0:  # 幅度谱
            alpha = berouti1(SNRseg)
        else:  # 功率谱
            alpha = berouti(SNRseg)
        #############
        sub_speech = sig ** Expnt - alpha * noise_mu ** Expnt;
        # 当纯净信号小于噪声信号的功率时
        diffw = sub_speech - beta * noise_mu ** Expnt
        # beta negative components
    
        def find_index(x_list):
            index_list = []
            for i in range(len(x_list)):
                if x_list[i] < 0:
                    index_list.append(i)
            return index_list
    
        z = find_index(diffw)
        if len(z) > 0:
            # 用估计出来的噪声信号表示下限值
            sub_speech[z] = beta * noise_mu[z] ** Expnt
            # --- implement a simple VAD detector --------------
        if SNRseg < Thres:  # Update noise spectrum
            noise_temp = G * noise_mu ** Expnt + (1 - G) * sig ** Expnt  # 平滑处理噪声功率谱
            noise_mu = noise_temp ** (1 / Expnt)  # 新的噪声幅度谱
        # flipud函数实现矩阵的上下翻转,是以矩阵的“水平中线”为对称轴
        # 交换上下对称元素
        sub_speech[nFFT // 2 + 1:nFFT] = np.flipud(sub_speech[1:nFFT // 2])
        x_phase = (sub_speech ** (1 / Expnt)) * (np.array([math.cos(x) for x in theta]) + img * (np.array([math.sin(x) for x in theta])))
        # take the IFFT
    
        xi = np.fft.ifft(x_phase).real
        # --- Overlap and add ---------------
        xfinal[k-1:k + len2 - 1] = x_old + xi[0:len1]
        x_old = xi[0 + len1:len_]
        k = k + len2
    # 保存文件
    wf = wave.open('en_outfile.wav', 'wb')
    # 设置参数
    wf.setparams(params)
    # 设置波形文件 .tostring()将array转换为data
    wave_data = (winGain * xfinal).astype(np.short)
    wf.writeframes(wave_data.tostring())
    wf.close()
    
    
    
    
    

    以上代码均可以去我的Github上找到。

    以上代码中用到了nextpow2,其中n = nextpow2(x) 表示最接近x的2的n次幂,这里就不在贴出,有需要的朋友直接去Github查看。

    展开全文
  • 我做的仿真实验是用matlab直接调用wden()函数来实现语音降噪处理,那么如何把wden()函数用python的语言编写出来实现它呢?我知道python有一个pywt库,但是不知道怎么用,请各位大佬指导一下啊!!要完整能运行的代码...
  • 声学语音处理的python源码 ,包括各种语音滤波处理,gammotan滤波,特征提取等
  • python对对验验证证码码降降噪噪的的实实现现示示例例代代码码 这篇文章主要介绍了python对验证码降噪的实现示例代码文中通过示例代码介绍的非常详细对大家的学习或 者工作具有一定的参考学习 值需要的朋友们下面...
  • 下面是谱减法语音降噪Python实现文件speech_enhanced.py#!/usr/bin/env pythonimport numpy as npimport waveimport nextpow2import math# 打开WAV文档f = wave.open("filename.wav")# 读取格式信息# (nchannels, ...

    下面是谱减法语音降噪的Python实现

    文件speech_enhanced.py

    #!/usr/bin/env python

    import numpy as np

    import wave

    import nextpow2

    import math

    # 打开WAV文档

    f = wave.open("filename.wav")

    # 读取格式信息

    # (nchannels, sampwidth, framerate, nframes, comptype, compname)

    params = f.getparams()

    nchannels, sampwidth, framerate, nframes = params[:4]

    fs = framerate

    # 读取波形数据

    str_data = f.readframes(nframes)

    f.close()

    # 将波形数据转换为数组

    x = np.fromstring(str_data, dtype=np.short)

    # 计算参数

    len_ = 20 * fs // 1000

    PERC = 50

    len1 = len_ * PERC // 100

    len2 = len_ - len1

    # 设置默认参数

    Thres = 3

    Expnt = 2.0

    beta = 0.002

    G = 0.9

    # 初始化汉明窗

    win = np.hamming(len_)

    # normalization gain for overlap+add with 50% overlap

    winGain = len2 / sum(win)

    # Noise magnitude calculations - assuming that the first 5 frames is noise/silence

    nFFT = 2 * 2 ** (nextpow2.nextpow2(len_))

    noise_mean = np.zeros(nFFT)

    j = 0

    for k in range(1, 6):

    noise_mean = noise_mean + abs(np.fft.fft(win * x[j:j + len_], nFFT))

    j = j + len_

    noise_mu = noise_mean / 5

    # --- allocate memory and initialize various variables

    k = 1

    img = 1j

    x_old = np.zeros(len1)

    Nframes = len(x) // len2 - 1

    xfinal = np.zeros(Nframes * len2)

    # ========================= Start Processing ===============================

    for n in range(0, Nframes):

    # Windowing

    insign = win * x[k-1:k + len_ - 1]

    # compute fourier transform of a frame

    spec = np.fft.fft(insign, nFFT)

    # compute the magnitude

    sig = abs(spec)

    # save the noisy phase information

    theta = np.angle(spec)

    SNRseg = 10 * np.log10(np.linalg.norm(sig, 2) ** 2 / np.linalg.norm(noise_mu, 2) ** 2)

    def berouti(SNR):

    if -5.0 <= SNR <= 20.0:

    a = 4 - SNR * 3 / 20

    else:

    if SNR < -5.0:

    a = 5

    if SNR > 20:

    a = 1

    return a

    def berouti1(SNR):

    if -5.0 <= SNR <= 20.0:

    a = 3 - SNR * 2 / 20

    else:

    if SNR < -5.0:

    a = 4

    if SNR > 20:

    a = 1

    return a

    if Expnt == 1.0: # 幅度谱

    alpha = berouti1(SNRseg)

    else: # 功率谱

    alpha = berouti(SNRseg)

    #############

    sub_speech = sig ** Expnt - alpha * noise_mu ** Expnt;

    # 当纯净信号小于噪声信号的功率时

    diffw = sub_speech - beta * noise_mu ** Expnt

    # beta negative components

    def find_index(x_list):

    index_list = []

    for i in range(len(x_list)):

    if x_list[i] < 0:

    index_list.append(i)

    return index_list

    z = find_index(diffw)

    if len(z) > 0:

    # 用估计出来的噪声信号表示下限值

    sub_speech[z] = beta * noise_mu[z] ** Expnt

    # --- implement a simple VAD detector --------------

    if SNRseg < Thres: # Update noise spectrum

    noise_temp = G * noise_mu ** Expnt + (1 - G) * sig ** Expnt # 平滑处理噪声功率谱

    noise_mu = noise_temp ** (1 / Expnt) # 新的噪声幅度谱

    # flipud函数实现矩阵的上下翻转,是以矩阵的“水平中线”为对称轴

    # 交换上下对称元素

    sub_speech[nFFT // 2 + 1:nFFT] = np.flipud(sub_speech[1:nFFT // 2])

    x_phase = (sub_speech ** (1 / Expnt)) * (np.array([math.cos(x) for x in theta]) + img * (np.array([math.sin(x) for x in theta])))

    # take the IFFT

    xi = np.fft.ifft(x_phase).real

    # --- Overlap and add ---------------

    xfinal[k-1:k + len2 - 1] = x_old + xi[0:len1]

    x_old = xi[0 + len1:len_]

    k = k + len2

    # 保存文件

    wf = wave.open('outfile.wav', 'wb')

    # 设置参数

    wf.setparams(params)

    # 设置波形文件 .tostring()将array转换为data

    wave_data = (winGain * xfinal).astype(np.short)

    wf.writeframes(wave_data.tostring())

    wf.close()

    以上代码中用到了nextpow2,其中n = nextpow2(x) 表示最接近x的2的n次幂,这里就不在贴出,有需要的朋友直接去Github查看。

    展开全文
  • 使用python对音频信号进行降噪

    千次阅读 热门讨论 2020-03-25 21:01:07
    此算法基于(但不是完全重现)Audacity概述的一种降噪效果的算法(链接到C ++代码) 该算法需要两个输入: 包含音频片段原型噪声的噪声音频片段 包含要删除的信号和噪声的信号音频片段 算法步骤 在噪声音频片段上...

    源码链接:https://download.csdn.net/download/bibinGee/12327301

     

    此算法基于(但不是完全重现)Audacity概述的一种降噪效果的算法(链接到C ++代码)
    该算法需要两个输入:

    1. 包含音频片段原型噪声的噪声音频片段
    2. 包含要删除的信号和噪声的信号音频片段

    算法步骤

    1. 在噪声音频片段上计算FFT
    2. 统计信息是通过噪声的FFT计算得出的(频率)
    3. 基于噪声的统计信息(和算法的期望灵敏度)计算阈值
    4. 通过信号计算FFT
    5. 通过将信号FFT与阈值进行比较来确定掩码
    6. 使用滤镜在频率和时间上对蒙版进行平滑处理
    7. 掩码被叠加到信号的FFT中,并被反转

     

    wav_loc = "assets/audio/fish.wav"
    rate, data = wavfile.read(wav_loc)
    data = data / 32768
    def fftnoise(f):
        f = np.array(f, dtype="complex")
        Np = (len(f) - 1) // 2
        phases = np.random.rand(Np) * 2 * np.pi
        phases = np.cos(phases) + 1j * np.sin(phases)
        f[1 : Np + 1] *= phases
        f[-1 : -1 - Np : -1] = np.conj(f[1 : Np + 1])
        return np.fft.ifft(f).real
    
    
    def band_limited_noise(min_freq, max_freq, samples=1024, samplerate=1):
        freqs = np.abs(np.fft.fftfreq(samples, 1 / samplerate))
        f = np.zeros(samples)
        f[np.logical_and(freqs >= min_freq, freqs <= max_freq)] = 1
    IPython.display.Audio(data=data, rate=rate)
    fig, ax = plt.subplots(figsize=(20,4))
    ax.plot(data)

     

    加入噪声

    noise_len = 2 # seconds
    noise = band_limited_noise(min_freq=4000, max_freq = 12000, samples=len(data), samplerate=rate)*10
    noise_clip = noise[:rate*noise_len]
    audio_clip_band_limited = data+noise
    fig, ax = plt.subplots(figsize=(20,4))
    ax.plot(audio_clip_band_limited)
    IPython.display.Audio(data=audio_clip_band_limited, rate=rate)

    加入噪声后的波形: 

     

    去噪

    import time
    from datetime import timedelta as td
    
    
    def _stft(y, n_fft, hop_length, win_length):
        return librosa.stft(y=y, n_fft=n_fft, hop_length=hop_length, win_length=win_length)
    
    
    def _istft(y, hop_length, win_length):
        return librosa.istft(y, hop_length, win_length)
    
    
    def _amp_to_db(x):
        return librosa.core.amplitude_to_db(x, ref=1.0, amin=1e-20, top_db=80.0)
    
    
    def _db_to_amp(x,):
        return librosa.core.db_to_amplitude(x, ref=1.0)
    
    
    def plot_spectrogram(signal, title):
        fig, ax = plt.subplots(figsize=(20, 4))
        cax = ax.matshow(
            signal,
            origin="lower",
            aspect="auto",
            cmap=plt.cm.seismic,
            vmin=-1 * np.max(np.abs(signal)),
            vmax=np.max(np.abs(signal)),
        )
        fig.colorbar(cax)
        ax.set_title(title)
        plt.tight_layout()
        plt.show()
    
    
    def plot_statistics_and_filter(
        mean_freq_noise, std_freq_noise, noise_thresh, smoothing_filter
    ):
        fig, ax = plt.subplots(ncols=2, figsize=(20, 4))
        plt_mean, = ax[0].plot(mean_freq_noise, label="Mean power of noise")
        plt_std, = ax[0].plot(std_freq_noise, label="Std. power of noise")
        plt_std, = ax[0].plot(noise_thresh, label="Noise threshold (by frequency)")
        ax[0].set_title("Threshold for mask")
        ax[0].legend()
        cax = ax[1].matshow(smoothing_filter, origin="lower")
        fig.colorbar(cax)
        ax[1].set_title("Filter for smoothing Mask")
        plt.show()
    
    
    def removeNoise(
        audio_clip,
        noise_clip,
        n_grad_freq=2,
        n_grad_time=4,
        n_fft=2048,
        win_length=2048,
        hop_length=512,
        n_std_thresh=1.5,
        prop_decrease=1.0,
        verbose=False,
        visual=False,
    ):
        """Remove noise from audio based upon a clip containing only noise
    
        Args:
            audio_clip (array): The first parameter.
            noise_clip (array): The second parameter.
            n_grad_freq (int): how many frequency channels to smooth over with the mask.
            n_grad_time (int): how many time channels to smooth over with the mask.
            n_fft (int): number audio of frames between STFT columns.
            win_length (int): Each frame of audio is windowed by `window()`. The window will be of length `win_length` and then padded with zeros to match `n_fft`..
            hop_length (int):number audio of frames between STFT columns.
            n_std_thresh (int): how many standard deviations louder than the mean dB of the noise (at each frequency level) to be considered signal
            prop_decrease (float): To what extent should you decrease noise (1 = all, 0 = none)
            visual (bool): Whether to plot the steps of the algorithm
    
        Returns:
            array: The recovered signal with noise subtracted
    
        """
        if verbose:
            start = time.time()
        # STFT over noise
        noise_stft = _stft(noise_clip, n_fft, hop_length, win_length)
        noise_stft_db = _amp_to_db(np.abs(noise_stft))  # convert to dB
        # Calculate statistics over noise
        mean_freq_noise = np.mean(noise_stft_db, axis=1)
        std_freq_noise = np.std(noise_stft_db, axis=1)
        noise_thresh = mean_freq_noise + std_freq_noise * n_std_thresh
        if verbose:
            print("STFT on noise:", td(seconds=time.time() - start))
            start = time.time()
        # STFT over signal
        if verbose:
            start = time.time()
        sig_stft = _stft(audio_clip, n_fft, hop_length, win_length)
        sig_stft_db = _amp_to_db(np.abs(sig_stft))
        if verbose:
            print("STFT on signal:", td(seconds=time.time() - start))
            start = time.time()
        # Calculate value to mask dB to
        mask_gain_dB = np.min(_amp_to_db(np.abs(sig_stft)))
        print(noise_thresh, mask_gain_dB)
        # Create a smoothing filter for the mask in time and frequency
        smoothing_filter = np.outer(
            np.concatenate(
                [
                    np.linspace(0, 1, n_grad_freq + 1, endpoint=False),
                    np.linspace(1, 0, n_grad_freq + 2),
                ]
            )[1:-1],
            np.concatenate(
                [
                    np.linspace(0, 1, n_grad_time + 1, endpoint=False),
                    np.linspace(1, 0, n_grad_time + 2),
                ]
            )[1:-1],
        )
        smoothing_filter = smoothing_filter / np.sum(smoothing_filter)
        # calculate the threshold for each frequency/time bin
        db_thresh = np.repeat(
            np.reshape(noise_thresh, [1, len(mean_freq_noise)]),
            np.shape(sig_stft_db)[1],
            axis=0,
        ).T
        # mask if the signal is above the threshold
        sig_mask = sig_stft_db < db_thresh
        if verbose:
            print("Masking:", td(seconds=time.time() - start))
            start = time.time()
        # convolve the mask with a smoothing filter
        sig_mask = scipy.signal.fftconvolve(sig_mask, smoothing_filter, mode="same")
        sig_mask = sig_mask * prop_decrease
        if verbose:
            print("Mask convolution:", td(seconds=time.time() - start))
            start = time.time()
        # mask the signal
        sig_stft_db_masked = (
            sig_stft_db * (1 - sig_mask)
            + np.ones(np.shape(mask_gain_dB)) * mask_gain_dB * sig_mask
        )  # mask real
        sig_imag_masked = np.imag(sig_stft) * (1 - sig_mask)
        sig_stft_amp = (_db_to_amp(sig_stft_db_masked) * np.sign(sig_stft)) + (
            1j * sig_imag_masked
        )
        if verbose:
            print("Mask application:", td(seconds=time.time() - start))
            start = time.time()
        # recover the signal
        recovered_signal = _istft(sig_stft_amp, hop_length, win_length)
        recovered_spec = _amp_to_db(
            np.abs(_stft(recovered_signal, n_fft, hop_length, win_length))
        )
        if verbose:
            print("Signal recovery:", td(seconds=time.time() - start))
        if visual:
            plot_spectrogram(noise_stft_db, title="Noise")
        if visual:
            plot_statistics_and_filter(
                mean_freq_noise, std_freq_noise, noise_thresh, smoothing_filter
            )
        if visual:
            plot_spectrogram(sig_stft_db, title="Signal")
        if visual:
            plot_spectrogram(sig_mask, title="Mask applied")
        if visual:
            plot_spectrogram(sig_stft_db_masked, title="Masked signal")
        if visual:
            plot_spectrogram(recovered_spec, title="Recovered spectrogram")
        return recovered_signal
    output = removeNoise(audio_clip=audio_clip_band_limited,noise_clip=noise_clip,verbose=True,visual=True)

     

     

     

     

     

     

    fig, ax = plt.subplots(nrows=1,ncols=1, figsize=(20,4))
    plt.plot(output, color='black')
    ax.set_xlim((0, len(output)))
    plt.show()
    # play back a sample of the song
    IPython.display.Audio(data=output, rate=44100)

    去噪后的波形:

     

    让我们尝试一个更具挑战性的示例

    wav_loc = "assets/audio/fish.wav"
    src_rate, src_data = wavfile.read(wav_loc)
    # src_data = np.concatenate((src_data, np.zeros(src_rate*3)))
    src_data = src_data / 32768
    wav_loc = "assets/audio/cafe.wav"
    noise_rate, noise_data = wavfile.read(wav_loc)
    # get some noise to add to the signal
    noise_to_add = noise_data[len(src_data) : len(src_data) * 2]
    # get a different part of the noise clip for calculating statistics
    noise_clip = noise_data[: len(src_data)]
    noise_clip = noise_clip / max(noise_to_add)
    noise_to_add = noise_to_add / max(noise_to_add)
    # apply noise
    snr = 1  # signal to noise ratio
    audio_clip_cafe = src_data + noise_to_add / snr
    noise_clip = noise_clip / snr
    fig, ax = plt.subplots(figsize=(20, 4))
    ax.plot(noise_clip)
    IPython.display.Audio(data=noise_clip, rate=src_rate)

    强干扰噪声波形

    
    fig, ax = plt.subplots(figsize=(20,4))
    ax.plot(audio_clip_cafe)
    IPython.display.Audio(data=audio_clip_cafe, rate=src_rate)

    信号加上强干扰噪声后

     

    执行去噪

    output = removeNoise(
        audio_clip=audio_clip_cafe,
        noise_clip=noise_clip,
        n_std_thresh=2,
        prop_decrease=0.95,
        visual=True,
    )
    
    fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(20, 4))
    plt.plot(output, color="black")
    ax.set_xlim((0, len(output)))
    plt.show()
    # play back a sample of the song
    IPython.display.Audio(data=output, rate=44100)

    去噪后的信号

     

    展开全文
  • Speech Enhancement Generative Adversarial Network in PyTorch
  • 原标题:Python | 简单的扩音,音频去噪,静音剪切之前一段时间一直在搞数字语音识别,在训练算法上耗费了很多时间,但结果不尽人意。后来才发现自己一直忽视了音频预处理的一步,于是转而囫囵吞枣般学习一些简单的...
  • 本文讲解如何从视频中提取音频。并应用两种方法对音频数据进行绘图展示。最后探讨傅里叶变换在音频数据中的降噪应用。
  • 采用kalman滤波算法,对含噪声的语音信号进行降噪,能够取得较好的效果。
  • 浮云降噪是一款智能化的音频增益软件,可实现音频降噪和调高音量等功能。程序采用最先进的人工智能算法,可以极大消除音频中的风声、水声、电流声等多种噪声,与此同时,还可以调高音量,最终导出高品质的音频文件。...
  • 这个matlab的程序如何与工程中其他文件进行对接?我其他文件函数用的是python写。没有这方面的经验,各位大拿详细指导一下。如果不用matlab写的话会更加麻烦
  • 这是一个开源项目,希望使用Python友好且实时的降噪技术处理音频输入。 所有处理均在内部进行,但可以由服务器处理。 检查 。 怎么跑 有多种运行方式:本地版本(作为个人用户),云版本(作为企业摘要系统)和...
  • 最近在看speech enhancement 内容,看完谱减法部分后,在网上找相应的代码来看,然后将MATLAB代码转成Python代码,顺便学习一下Python的使用。 谱减法的基础实现: 论文《Enhancement of speechcorrupted by ...
  • Python语音基础操作--5.1自适应滤波

    千次阅读 2020-05-30 14:02:17
    语音降噪主要研究如何利用信号处理技术消除信号中的强噪声干扰,从而提高输出信噪比以提取出有用信号的技术。消除信号中噪声污染的通常方法是让受污染的信号通过二个能抑制噪声而让信号相对不变的滤波器,此滤波器从...
  • 深度学习音频去噪

    2020-11-29 21:18:43
    - Clone this repository - pip install -r requirements.txt - python main.py OPTIONS * Modes of the program (Possible OPTIONS): --mode: default='prediction', type=str, choices=['data_creation', '...
  • 语音降噪-维纳滤波

    2021-06-05 22:59:37
    语音降噪-维纳滤波维纳滤波原理时频域维纳滤波器频域维纳滤波器迭代维纳滤波器 维纳滤波原理 输入信号通过一个线性时不变系统之后产生一个输出信号,使得输出信号尽量逼近期望信号,使其估计误差最小化,能够最小化这...
  • 要使一个函数运行在一个包含大约100个wav文件的整个文件夹上,但无法获得输出无法理解似乎是什么问题。在def noise_reduction(dirName):types = ('*.wav', '*.aif', '*.aiff', '*.mp3', '*.au', '*.ogg')wav_file_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 766
精华内容 306
关键字:

python语音降噪

python 订阅