现在如果给机器人一个相声台本，他就能跟我们说相声了，只不过是文字交流。那么能不能让机器人加上耳朵，能够听，加上嘴巴能够说呢？前者是语音识别，后者是语音合成。当然在这之前要给机器人准备好相应的器官—嘴巴（扬声器）和耳朵（麦克风）。
    首先语音识别，也就是从一段声音里面识别出文字信息。这里我们先准备好一段语音hello.wav，该音频文件为中文。
    然后安装语音识别库SpeechRecognition，但该库对中文不太友好，这里我们选用大厂的语音识别功能，像百度、阿里、讯飞等。首先我们需要注册百度（或其他厂）的语音开发者账号，拿到属于自己的三元组。然后pip install baidu-aip,接下来代码如下：

    1. from aip import AipSpeech
    3. APP_ID = '16835749'
    4. API_KEY = 'UnZlBOVhwYu8m5eNqwOPHt99'
    5. SECRET_KEY = '6jhCitggsR0Ew91fdC47oMa1qtibTrsK'
    7. client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    9. # 读取文件
    10. def get_file_content(filePath):
    11.      with open(filePath, 'rb') as fp:
    12.         return fp.read()
    14. # 识别本地文件
    15. test1 = client.asr(get_file_content('hello.wav'), 'pcm', 16000, {'dev_pid': 1536, })
    17. print(test1)

    现在已经能够识别到本地音频文件了，那么要实现实时语音识别，就是调用麦克风功能录下声音存成文件，然后及时再调用该文件这样的过程。使用python调用麦克风进行录音的程序如下：
    首先也需要一个库文件的支持pip install pyaudio：

    1. import pyaudio
    2. import wave
    3. input_filename = "input.wav"               # 麦克风采集的语音输入
    4. input_filepath = "../src/"              # 输入文件的path
    5. in_path = input_filepath + input_filename
    7. def get_audio(filepath):
    8.     CHUNK = 256
    9.     FORMAT = pyaudio.paInt16
    10.     CHANNELS = 1                # 声道数
    11.     RATE = 11025                # 采样率
    12.     RECORD_SECONDS = 5
    13.     WAVE_OUTPUT_FILENAME = filepath
    14.     p = pyaudio.PyAudio()
    16.     stream = p.open(format=FORMAT,
    17.                     channels=CHANNELS,
    18.                     rate=RATE,
    19.                     input=True,
    20.                     frames_per_buffer=CHUNK)
    22.     print("*"*10, "开始录音：请在5秒内输入语音")
    23.     frames = []
    24.     for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
    25.         data = stream.read(CHUNK)
    26.         frames.append(data)
    27.     print("*"*10, "录音结束\n")
    29.     stream.stop_stream()
    30.     stream.close()
    31.     p.terminate()
    33.     wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
    34.     wf.setnchannels(CHANNELS)
    35.     wf.setsampwidth(p.get_sample_size(FORMAT))
    36.     wf.setframerate(RATE)
    37.     wf.writeframes(b''.join(frames))
    38.     wf.close()
    39. get_audio(in_path)

    然后把上面两个程序合并：

    1. from aip import AipSpeech
    2. import pyaudio
    3. import wave
    4. input_filename = "input.wav"               # 麦克风采集的语音输入
    5. input_filepath = "../src/"              # 输入文件的path
    6. in_path = input_filepath + input_filename
    8. def get_audio(filepath):
    9.     CHUNK = 256
    10.     FORMAT = pyaudio.paInt16
    11.     CHANNELS = 1                # 声道数
    12.     RATE = 11025                # 采样率
    13.     RECORD_SECONDS = 5
    14.     WAVE_OUTPUT_FILENAME = filepath
    15.     p = pyaudio.PyAudio()
    17.     stream = p.open(format=FORMAT,
    18.                     channels=CHANNELS,
    19.                     rate=RATE,
    20.                     input=True,
    21.                     frames_per_buffer=CHUNK)
    23.     print("*"*10, "开始录音：请在5秒内输入语音")
    24.     frames = []
    25.     for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
    26.         data = stream.read(CHUNK)
    27.         frames.append(data)
    28.     print("*"*10, "录音结束\n")
    30.     stream.stop_stream()
    31.     stream.close()
    32.     p.terminate()
    34.     wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
    35.     wf.setnchannels(CHANNELS)
    36.     wf.setsampwidth(p.get_sample_size(FORMAT))
    37.     wf.setframerate(RATE)
    38.     wf.writeframes(b''.join(frames))
    39.     wf.close()
    40. get_audio(in_path)
    42. #申请百度语音识别
    43. APP_ID = '16835749'
    44. API_KEY = 'UnZlBOVhwYu8m5eNqwOPHt99'
    45. SECRET_KEY = '6jhCitggsR0Ew91fdC47oMa1qtibTrsK'
    47. client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    49. # 读取文件
    50. def get_file_content(filePath):
    51.      with open(filePath, 'rb') as fp:
    52.         return fp.read()
    54. # 识别本地文件
    55. # path='/Users/alice/Documents/Blog/AI/语音识别/speechrecognition/audiofiles'
    56. test1 = client.asr(get_file_content(in_path), 'pcm', 16000, {'dev_pid': 1536, })
    58. print(test1)

    这样就能实时把我们的讲话识别转换成文字了，在从识别出来的文字中提取有效信息，交给后台进行匹配对应的回答内容输出出来。
    那么输出出来的文字如何也变成声音说出来呢，接下来就是语音合成了，语音合成也需要相应的库文件，这里我们使用pyttsx3语音合成模块pip install pyttsx3

    1. import pyttsx3
    2. engine = pyttsx3.init()
    3. engine.say("风飘荡，雨濛茸，翠条柔弱花头重")
    4. engine.runAndWait()

    当然我们也可以使用百度的语音合成功能：

    1. from aip import AipSpeech
    3. """ 你的 APPID AK SK """
    4. APP_ID = '16835749'
    5. API_KEY = 'UnZlBOVhwYu8m5eNqwOPHt99'
    6. SECRET_KEY = '6jhCitggsR0Ew91fdC47oMa1qtibTrsK'
    8. client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    9. result = client.synthesis(text = '你好百度', options={'vol':5})
    11. if not isinstance(result,dict):
    12.     with open('audio.mp3','wb') as f:
    13.         f.write(result)
    14. else:print(result)

    该文字已经转成音频，要实时播放出来的话，再加上python调用音频文件播放的功能。
    但是这里百度语音合成的是mp3格式的，所以python播放mp3的话需要另外一个音频库pip install playsound:

    1. from playsound import playsound
    2. playsound("audio.mp3")

    跟百度语音合成的程序合并：

    1. from aip import AipSpeech
    2. from playsound import playsound
    4. """ 你的 APPID AK SK """
    5. APP_ID = '16835749'
    6. API_KEY = 'UnZlBOVhwYu8m5eNqwOPHt99'
    7. SECRET_KEY = '6jhCitggsR0Ew91fdC47oMa1qtibTrsK'
    9. client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    10. result = client.synthesis(text = '你好百度', options={'vol':5})
    12. if not isinstance(result,dict):
    13.     with open('audio.mp3','wb') as f:
    14.         f.write(result)
    15. else:print(result)
    16. playsound("audio.mp3")

    还记得pyaudio那个处理音频的文件库吗，当然也可以用它，但是pyaudio播放的是wav格式的音频文件，要实现音频播放的话，得在播放之前把mp3格式的文件处理成wav格式，而音频格式的转换需要另外使用pydub和ffmpeg实现mp3转wav。有兴趣的可以试一下。
    至此，我们已经实现语音转文字的语音识别功能和文字转语音的语音合成功能。那么我们把之前准备的语料库放进来试下，在放之前呢再补充一点百度语音的一个有点，也就是可以更换朗读者，上面程序第10行里面是百度语音的属性选项，在其选项里添加一个朗读者角色，第10行的程序更改如下：

    1. #per    String    发音人选择, 0为女声，1为男声，3为情感合成-度逍遥，4为情感合成-度丫丫，默认为普通女    否
    2. result = client.synthesis(text = '你好百度', options={'vol':5,'per':4})

    那么完整程序如下：

    1. from aip import AipSpeech
    2. from playsound import playsound
    4. """ 你的 APPID AK SK """
    5. APP_ID = '16835749'
    6. API_KEY = 'UnZlBOVhwYu8m5eNqwOPHt99'
    7. SECRET_KEY = '6jhCitggsR0Ew91fdC47oMa1qtibTrsK'
    9. client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    10. #下面option中：vol值0-15，per可选0，1，3，4
    11. result = client.synthesis(text = '你好百度', options={'vol':5,'per':4})
    14. if not isinstance(result,dict):
    15.     with open('audio.mp3','wb') as f:
    16.         f.write(result)
    17. else:print(result)
    18. playsound("audio.mp3")

    好了，现在把之前的语料库的内容放进来，还记得当时纯文字交流的程序吗：

    1. with open("语料库.txt","r",encoding="utf-8") as lib:
    2.     lists = lib.readlines()
    3. print(lists)
    4. print(len(lists))
    5. while True:
    6.     ask = input("请开始对话：")
    7.     a = 0
    8.     b = 0
    9.     while a==0:
    10.         for i in range(0,len(lists),2):
    11.             if lists[i].find(ask)!=-1:
    12.                 print(lists[i+1])
    13.                 b =1
    14.                 break
    15.         a = 1
    16.         if b==0:
    17.             print("你问的问题太深奥，我还没学会呢，换个问题吧")
    18.             ask = input("请开始对话：")
    19.             a = 0

    首先是语音识别，把我们的讲话识别成文字，并封装成一个子函数，注意这里识别出来的内容是以另一种叫做json的文件格式存储的。
    image.png
    也就是上面语音识别的程序的输出结果test1是一串数据，而我们想要的只有result里面的“你叫什么名字”，所以这里还需要另外python读取json文件

    1. #*****************以下是语音合成的程序**********************
    2. from aip import AipSpeech
    3. import pyaudio
    4. import wave
    5. input_filename = "input.wav"               # 麦克风采集的语音输入
    6. input_filepath = "../src/"              # 输入文件的path
    7. in_path = input_filepath + input_filename
    9. def get_audio(filepath):
    10.     CHUNK = 256
    11.     FORMAT = pyaudio.paInt16
    12.     CHANNELS = 1                # 声道数
    13.     RATE = 11025                # 采样率
    14.     RECORD_SECONDS = 5
    15.     WAVE_OUTPUT_FILENAME = filepath
    16.     p = pyaudio.PyAudio()
    18.     stream = p.open(format=FORMAT,
    19.                     channels=CHANNELS,
    20.                     rate=RATE,
    21.                     input=True,
    22.                     frames_per_buffer=CHUNK)
    24.     print("*"*10, "开始录音：请在5秒内输入语音")
    25.     frames = []
    26.     for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
    27.         data = stream.read(CHUNK)
    28.         frames.append(data)
    29.     print("*"*10, "录音结束\n")
    31.     stream.stop_stream()
    32.     stream.close()
    33.     p.terminate()
    35.     wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
    36.     wf.setnchannels(CHANNELS)
    37.     wf.setsampwidth(p.get_sample_size(FORMAT))
    38.     wf.setframerate(RATE)
    39.     wf.writeframes(b''.join(frames))
    40.     wf.close()
    41. get_audio(in_path)
    43. #申请百度语音识别
    44. APP_ID = '16835749'
    45. API_KEY = 'UnZlBOVhwYu8m5eNqwOPHt99'
    46. SECRET_KEY = '6jhCitggsR0Ew91fdC47oMa1qtibTrsK'
    48. client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    50. # 读取文件
    51. def get_file_content(filePath):
    52.      with open(filePath, 'rb') as fp:
    53.         return fp.read()
    55. # 识别本地文件
    56. # path='/Users/alice/Documents/Blog/AI/语音识别/speechrecognition/audiofiles'
    57. test1 = client.asr(get_file_content(in_path), 'pcm', 16000, {'dev_pid': 1536, })
    59. print(test1)
    60. #***********************语音合成到此结束*****************
    61. import json
    62. print(test1["result"])

    image.png
    现在输出的是数组，只需要再从数组里面取出文字就行了。即如下程序：

    1. a=["abc","123"]
    2. print(a[0])

    语音识别的程序的最后一行改成：

    1. print(test1["result"][0])

    现在就已经能够拿到我们需要的内容了，那么就可以继续封装：

    1. import json
    2. from aip import AipSpeech
    3. import pyaudio
    4. import wave
    5. input_filename = "input.wav"               # 麦克风采集的语音输入
    6. input_filepath = "../src/"              # 输入文件的path
    7. in_path = input_filepath + input_filename
    9. def get_audio(filepath):
    10.     CHUNK = 256
    11.     FORMAT = pyaudio.paInt16
    12.     CHANNELS = 1                # 声道数
    13.     RATE = 11025                # 采样率
    14.     RECORD_SECONDS = 5
    15.     WAVE_OUTPUT_FILENAME = filepath
    16.     p = pyaudio.PyAudio()
    18.     stream = p.open(format=FORMAT,
    19.                     channels=CHANNELS,
    20.                     rate=RATE,
    21.                     input=True,
    22.                     frames_per_buffer=CHUNK)
    24.     print("*"*10, "开始录音：请在5秒内输入语音")
    25.     frames = []
    26.     for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
    27.         data = stream.read(CHUNK)
    28.         frames.append(data)
    29.     print("*"*10, "录音结束\n")
    31.     stream.stop_stream()
    32.     stream.close()
    33.     p.terminate()
    35.     wf = wave.open(WAVE_OUTPUT_FILENAME, 'wb')
    36.     wf.setnchannels(CHANNELS)
    37.     wf.setsampwidth(p.get_sample_size(FORMAT))
    38.     wf.setframerate(RATE)
    39.     wf.writeframes(b''.join(frames))
    40.     wf.close()
    41. get_audio(in_path)
    43. #申请百度语音识别
    44. APP_ID = '16835749'
    45. API_KEY = 'UnZlBOVhwYu8m5eNqwOPHt99'
    46. SECRET_KEY = '6jhCitggsR0Ew91fdC47oMa1qtibTrsK'
    48. client = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
    50. # 读取文件
    51. def get_file_content(filePath):
    52.      with open(filePath, 'rb') as fp:
    53.         return fp.read()
    55. def result_word():
    56.     # 识别本地文件
    57.     # path='/Users/alice/Documents/Blog/AI/语音识别/speechrecognition/audiofiles'
    58.     test1 = client.asr(get_file_content(in_path), 'pcm', 16000, {'dev_pid': 1536, })
    59.     # print(test1["result"][0])
    60.     return test1["result"][0]
    61. print(result_word)
    62. with open("语料库.txt","r",encoding="utf-8") as lib:
    63.     lists = lib.readlines()
    64. print(lists)
    65. print(len(lists))
    66. while True:
    67.     print("请开始对话：")
    68.     ask = result_word()
    69.     a = 0
    70.     b = 0
    71.     while a==0:
    72.         for i in range(0,len(lists),2):
    73.             if lists[i].find(ask)!=-1:
    74.                 print(lists[i+1])
    75.                 b =1
    76.                 break
    77.         a = 1
    78.         if b==0:
    79.             print("你问的问题太深奥，我还没学会呢，换个问题吧")
    80.             print("请开始对话：")
    81.             ask = result_word()
    82.             a = 0

    但是测试发现只能识别一次，这是因为我们调用录音识别程序的那个命令get_audio(in_path)为放在重复执行里面，但是放进合适的位置之后发现还会出现别的问题，比如提示消息太多还太乱，还有就是如果我们在程序运行过程中没有讲话，而录一个空的文件，也会中断程序的运行，所以现在开始debug的过程。