python 全栈开发，Day133(玩具与玩具之间的对话,基于jieba gensim pypinyin实现的自然语言处理,打包apk)...

绝地灬酷狼 2022-02-02 08:09 140阅读 0赞

# [python 全栈开发，Day133(玩具与玩具之间的对话,基于jieba gensim pypinyin实现的自然语言处理,打包apk)][python _Day133_jieba gensim pypinyin_apk] #

**先下载github代码，下面的操作，都是基于这个版本来的！**

[https://github.com/987334176/Intelligent\_toy/archive/v1.6.zip][https_github.com_987334176_Intelligent_toy_archive_v1.6.zip]

**注意：由于涉及到版权问题，此附件没有图片和音乐。请参考链接，手动采集一下！**

请参考链接：

[https://www.cnblogs.com/xiao987334176/p/9647993.html\#autoid-3-4-0][https_www.cnblogs.com_xiao987334176_p_9647993.html_autoid-3-4-0]

# 一、玩具与玩具之间的对话 #

## app消息提醒 ##

之前实现了App发送语音消息给web端玩具，web端有消息提醒。现在app端，也需要消息提醒！

那么在后端，需要判断。这个消息是人还是玩具发送的消息。加一个user\_type

### 玩具表增加user\_type ###

修改玩具表toys。这里的小鱼，表示用户！

![1341090-20180926172801381-85440313.png][]

增加user\_type

![1341090-20180926172844805-1399396994.png][]

toys表的其他记录，也需要一并修改

**务必保证 friend\_list里面的每一条记录。都有user\_type字段！**

**务必保证，每一个玩具都有2个好友。一个是主人，一个是除自己之外的玩具。**

### 用户表增加user\_type ###

修改用户表

![1341090-20180926171427989-1216525640.png][]

修改第一个好友，增加user\_type字段，toy表示玩具

![1341090-20180926172201387-1176993454.png][]

修改另外一条记录

![1341090-20180926172328405-424360074.png][]

完整数据如下：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

{
        "_id" : ObjectId("5b9bb768e1253281608e96eb"),
        "username" : "xiao",
        "password" : "202cb962ac59075b964b07152d234b70",
        "age" : "20",
        "nickname" : "xiao",
        "gender" : "1",
        "phone" : "1234567",
        "avatar" : "boy.jpg",
        "bind_toy" : [
            "5ba0f1f2e12532418089bf88",
            "5ba21c84e1253229c4acbd12"
        ],
        "friend_list" : [
            {
                "friend_id" : "5ba0f1f2e12532418089bf88",
                "friend_name" : "小可爱",
                "friend_remark" : "小甜甜",
                "friend_avatar" : "girl.jpg",
                "friend_chat" : "5ba0f1f2e12532418089bf87",
                "user_type" : "toy"
            },
            {
                "friend_id" : "5ba21c84e1253229c4acbd12",
                "friend_name" : "嘻嘻",
                "friend_remark" : "小豆芽",
                "friend_avatar" : "girl.jpg",
                "friend_chat" : "5ba21c84e1253229c4acbd11",
                "user_type" : "toy"
            }
        ]
    }

**务必保证 friend\_list里面的每一条记录。都有user\_type字段！**

### 后台逻辑修改 ###

进入flask项目，修改 serv--> friend.py，增加user\_type

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from flask import Blueprint, request, jsonify
    from setting import MONGO_DB
    from setting import RET
    from bson import ObjectId
    
    fri = Blueprint("fri", __name__)
    
    
    @fri.route("/friend_list", methods=["POST"])
    def friend_list():  # 好友列表
        user_id = request.form.get("user_id")
        # 查询用户id信息
        res = MONGO_DB.users.find_one({
           "_id": ObjectId(user_id)})
        friend_list = res.get("friend_list")  # 获取好友列表
    
        RET["code"] = 0
        RET["msg"] = ""
        RET["data"] = friend_list
    
        return jsonify(RET)
    
    @fri.route("/add_req", methods=["POST"])
    def add_req():  # 添加好友请求
        user_id = request.form.get("user_id")  # 有可能是 toy_id or user_id
        friend_id = request.form.get("friend_id")  # 100%是toy_id
        req_type = request.form.get("req_type")
        req_msg = request.form.get("req_msg")  # 描述
        remark = request.form.get("remark")  # 备注
    
        if req_type == "toy":
            user_info = MONGO_DB.toys.find_one({
           "_id": ObjectId(user_id)})
        else:
            user_info = MONGO_DB.users.find_one({
           "_id": ObjectId(user_id)})
    
        req_str = {
            "req_user": str(user_info.get("_id")),
            "req_type": req_type,
            "req_toy": friend_id,
            "req_msg": req_msg,
            "avatar": user_info.get("avatar"),
            "user_remark": remark,
            # 昵称，玩具是没有的
            "user_nick": user_info.get("nickname") if user_info.get("nickname") else user_info.get("baby_name"),
            # 状态，1通过，2拒绝,0中间状态(可切换到1和2)。
            "status": 0
        }
    
        MONGO_DB.req.insert_one(req_str)
    
        RET["code"] = 0
        RET["msg"] = "请求发送成功"
        RET["data"] = {}
    
        return jsonify(RET)
    
    @fri.route("/req_list", methods=["POST"])
    def req_list():  # 添加请求列表
        user_id = request.form.get("user_id")
        user_info = MONGO_DB.users.find_one({
           "_id": ObjectId(user_id)})
        bind_toy = user_info.get("bind_toy")
    
        reqs = list(MONGO_DB.req.find({
           "req_toy": {
           "$in": bind_toy}, "status": 0}))
    
        for index, req in enumerate(reqs):
            reqs[index]["_id"] = str(req.get("_id"))
    
        RET["code"] = 0
        RET["msg"] = ""
        RET["data"] = reqs
    
        return jsonify(RET)
    
    
    @fri.route("/get_req", methods=["POST"])
    def get_req():  # 获取一个好友请求
        req_id = request.form.get("req_id")
    
        req_info = MONGO_DB.req.find_one({
           "_id": ObjectId(req_id)})
    
        req_info["_id"] = str(req_info.get("_id"))
    
        RET["code"] = 0
        RET["msg"] = ""
        RET["data"] = req_info
    
        return jsonify(RET)
    
    
    @fri.route("/acc_req", methods=["POST"])
    def acc_req():  # 允许一个好友请求
        req_id = request.form.get("req_id")
        remark = request.form.get("remark")
    
        req_info = MONGO_DB.req.find_one({
           "_id": ObjectId(req_id)})
    
        # 1. 为 user 或 toy 添加 toy
        if req_info.get("req_type") == "toy":
            user_info = MONGO_DB.toys.find_one({
           "_id": ObjectId(req_info.get("req_user"))})
            user_type = "toy"
        else:
            user_info = MONGO_DB.users.find_one({
           "_id": ObjectId(req_info.get("req_user"))})
            user_type = "user"
    
        toy = MONGO_DB.toys.find_one({
           "_id": ObjectId(req_info.get("req_toy"))})
    
        chat_window = MONGO_DB.chat.insert_one({
           "user_list": [str(toy.get("_id")), str(user_info.get("_id"))]})
    
        friend_info = {
            "friend_id": str(toy.get("_id")),
            "friend_name": toy.get("baby_name"),
            "friend_remark": req_info.get("user_remark"),
            "friend_avatar": toy.get("avatar"),
            "friend_chat": str(chat_window.inserted_id),
            "user_type": "toy"
        }
    
        if req_info.get("req_type") == "toy":
            MONGO_DB.toys.update_one({
            "_id": ObjectId(req_info.get("req_user"))},
                                     {
            "$push": {
           "friend_list": friend_info}})
        else:
            MONGO_DB.users.update_one({
            "_id": ObjectId(req_info.get("req_user"))},
                                      {
            "$push": {
           "friend_list": friend_info}})
    
        # 2. 为 toy 添加 user 或 toy
        user_name = user_info.get("nickname") if user_info.get("nickname") else user_info.get("baby_name")
        friend_info2 = {
            "friend_id": str(user_info.get("_id")),
            "friend_name": user_name,
            # 同意方的备注
            "friend_remark": remark if remark else user_name,
            "friend_avatar": user_info.get("avatar"),
            "friend_chat": str(chat_window.inserted_id),
            "user_type":user_type  # 用户类型
        }
    
        MONGO_DB.toys.update_one({
            "_id": ObjectId(req_info.get("req_toy"))},
                                 {
            "$push": {
           "friend_list": friend_info2}})
    
    
        RET["code"] = 0
        RET["msg"] = f"添加好友{remark}成功"
        RET["data"] = {}
    
        MONGO_DB.req.update_one({
            "_id": ObjectId(req_id)}, {
           "$set": {
           "status": 1}})
    
        return jsonify(RET)
    
    
    @fri.route("/ref_req", methods=["POST"])
    def ref_req():  # 拒绝一个好友请求
        req_id = request.form.get("req_id")
    
        MONGO_DB.req.update_one({
            "_id": ObjectId(req_id)}, {
           "$set": {
           "status": 2}})
    
        RET["code"] = 0
        RET["msg"] = "已拒绝好友请求"
        RET["data"] = {}
    
        return jsonify(RET)

修改 serv--> devices.py，增加user\_type

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from flask import Blueprint, request, jsonify
    from setting import MONGO_DB
    from setting import RET
    from bson import ObjectId
    
    devs = Blueprint("devs", __name__)
    
    
    @devs.route("/yanzheng_qr", methods=["POST"])
    def yanzheng_qr():  # 验证二维码
        device_id = request.form.get("device_id")  # 获取设备id
        print(device_id)
        if MONGO_DB.devices.find_one({
           "device_id": device_id}):  # 从数据库中查询设备id
            # 查询该玩具是不是已被用户绑定
            toy_info = MONGO_DB.toys.find_one({
           "device_id": device_id})
            # 未绑定开启绑定逻辑
            if not toy_info:
                RET["code"] = 0
                RET["msg"] = "感谢购买本公司产品"
                RET["data"] = {}
    
            # 如果被绑定加好友逻辑开启
            if toy_info:
                RET["code"] = 1
                RET["msg"] = "添加好友"
                RET["data"] = {
           "toy_id": str(toy_info.get("_id"))}
    
        else:
            RET["code"] = 2
            RET["msg"] = "二货，这不是本公司设备，快去买正版!"
            RET["data"] = {}
    
        return jsonify(RET)
    
    
    @devs.route("/bind_toy", methods=["POST"])
    def bind_toy():  # 绑定玩具
        chat_window = MONGO_DB.chat.insert_one({})  # 插入一个空数据
        chat_id = chat_window.inserted_id  # 获取聊天id
    
        user_id = request.form.get("user_id")  # 用户id
        res = MONGO_DB.users.find_one({
           "_id": ObjectId(user_id)})  # 查询用户id是否存在
    
        device_id = request.form.get("device_id")  # 设备id
        toy_name = request.form.get("toy_name")  # 玩具的昵称
        baby_name = request.form.get("baby_name")  # 小主人的名字
        remark = request.form.get("remark")  # 玩具主人对您的称呼
        gender = request.form.get("gender")  # 性别
    
        toy_info = {
            "device_id": device_id,
            "toy_name": toy_name,
            "baby_name": baby_name,
            "gender": gender,
            "avatar": "boy.jpg" if gender == 1 else "girl.jpg",
            # 绑定用户
            "bind_user": str(res.get("_id")),
            # 第一个好友
            "friend_list": [{
                "friend_id": str(res.get("_id")),  # 好友id
                "friend_name": res.get("nickname"),  # 好友昵称
                "friend_remark": remark,  # 好友称呼
                "friend_avatar": res.get("avatar"),  # 好友头像
                "friend_chat": str(chat_id),  # 好友聊天id
                "user_type":"user"  # 用户类型
            }]
        }
    
        toy_res = MONGO_DB.toys.insert_one(toy_info)  # 插入玩具表数据
    
        if res.get("friend_list"):  # 判断用户好友列表是否为空
            # 追加好友
            res["bind_toy"].append(str(toy_res.inserted_id))
            res["friend_list"].append({
                "friend_id": str(toy_res.inserted_id),
                "friend_name": toy_name,
                "friend_remark": baby_name,
                "friend_avatar": toy_info.get("avatar"),
                "friend_chat": str(chat_id),
                "user_type": "toy"  # 用户类型
            })
        else:
            # 更新好友
            res["bind_toy"] = [str(toy_res.inserted_id)]
            res["friend_list"] = [{
                "friend_id": str(toy_res.inserted_id),
                "friend_name": toy_name,
                "friend_remark": baby_name,
                "friend_avatar": toy_info.get("avatar"),
                "friend_chat": str(chat_id),
                "user_type": "toy"  # 用户类型
            }]
    
        MONGO_DB.users.update_one({
            "_id": ObjectId(user_id)}, {
           "$set": res})  # 更新用户记录
    
        # 更新聊天表
        # user_list有2个值。第一个是玩具id，第2个是用户id
        # 这样，用户和玩具就能通讯了
        MONGO_DB.chat.update_one({
           "_id": chat_id},
                                 {
            "$set":
                                      {
            "user_list":
                                           [str(toy_res.inserted_id),
                                            str(res.get("_id"))]}})
    
        RET["code"] = 0
        RET["msg"] = "绑定成功"
        RET["data"] = {}
    
        return jsonify(RET)

修改 utils-->baidu\_ai.py，增加user\_type

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from aip import AipSpeech
    import os
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # 项目根目录
    
    import sys
    sys.path.append(BASE_DIR)  # 加入到系统环境变量中
    
    import setting  # 导入setting
    from uuid import uuid4
    # from setting import MONGO_DB
    # import setting
    import os
    from bson import ObjectId
    
    client = AipSpeech(setting.APP_ID,setting.API_KEY,setting.SECRET_KEY)
    
    def text2audio(text):
        res = client.synthesis(text, "zh", 1, setting.SPEECH)
        file_name = f"{uuid4()}.mp3"
        file_path = os.path.join(setting.CHAT_FILE, file_name)
        with open(file_path, "wb") as f:
            f.write(res)
    
        return file_name
    
    
    def get_file_content(filePath):
        os.system(f"ffmpeg -y -i {filePath}  -acodec pcm_s16le -f s16le -ac 1 -ar 16000 {filePath}.pcm")
        with open(f"{filePath}.pcm", 'rb') as fp:
            return fp.read()
    
    
    def audio2text(file_name):
        # 识别本地文件
        liu = get_file_content(file_name)
    
        res = client.asr(liu, 'pcm', 16000, {
            'dev_pid': 1536,
        })
    
        if res.get("result"):
            return res.get("result")[0]
        else:
            return res
    
    # text2audio("你好")
    
    def my_nlp(q,toy_id):
        # 1. 假设玩具说：q = 我要给爸爸发消息
        print(q,"百度q")
        if "发消息" in q:
            toy = setting.MONGO_DB.toys.find_one({
           "_id":ObjectId(toy_id)})
            # print(toy.get("friend_list"))
            for i in toy.get("friend_list"):
                # print(i.get("friend_remark"),i.get("friend_name"),'iiiiiiiii')
                if i.get("friend_remark") in q or i.get("friend_name") in q :
                    res = text2audio(f"可以按消息键，给{i.get('friend_remark')}发消息了")
                    send_str = {
                        "code": 0,
                        "from_user": i.get("friend_id"),
                        "msg_type": "chat",
                        "data": res,
                        "user_type":i.get("user_type")
                    }
                    return send_str
    
        if "我要听" in q or "我想听" in q or "唱一首" in q:
            sources = setting.MONGO_DB.sources.find({})
            for i in sources:
                if i.get("title") in q:
                    send_str = {
                        "code": 0,
                        "from_user": toy_id,
                        "msg_type": "music",
                        "data": i.get("audio")
                    }
                    return send_str
    
    
    
        res = text2audio("对不起，我没明白你的意思")
        send_str = {
            "code": 0,
            "from_user": toy_id,
            "msg_type": "chat",
            "data": res
        }
        return send_str

修改 im\_serv.py，增加user\_type

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from flask import Flask, request
    from geventwebsocket.websocket import WebSocket
    from geventwebsocket.handler import WebSocketHandler
    from gevent.pywsgi import WSGIServer
    import json, os
    from uuid import uuid4
    from setting import AUDIO_FILE,CHAT_FILE
    from serv import content
    from utils import baidu_ai
    from utils import chat_redis
    import setting
    from bson import ObjectId
    import time
    
    app = Flask(__name__)
    
    user_socket_dict = {}  # 空字典,用来存放用户名和发送消息
    
    
    @app.route("/toy/<tid>")
    def toy(tid):  # 玩具连接
        # 获取请求的WebSocket对象
        user_socket = request.environ.get("wsgi.websocket")  # type:WebSocket
        if user_socket:
            # 设置键值对
            user_socket_dict[tid] = user_socket
            print(user_socket_dict)
            # {'123456': <geventwebsocket.websocket.WebSocket object at 0x00000176ABD92E18>}
    
        file_name = ""
        to_user = ""
        # 循环,接收消息
        while True:
            msg = user_socket.receive()
            if type(msg) == bytearray:
                file_name = f"{uuid4()}.wav"
                file_path = os.path.join(CHAT_FILE, file_name)
                with open(file_path, "wb") as f:
                    f.write(msg)
            else:
                msg_dict = json.loads(msg)
                to_user = msg_dict.get("to_user")
                msg_type = msg_dict.get("msg_type")
                user_type = msg_dict.get("user_type")
    
            if to_user and file_name:
                other_user_socket = user_socket_dict.get(to_user)
                if msg_type == "ai":
                    q = baidu_ai.audio2text(file_path)
                    print(q)
                    ret = baidu_ai.my_nlp(q, tid)
                    other_user_socket.send(json.dumps(ret))
                else:
                    if user_type == "toy":
                        res = setting.MONGO_DB.toys.find_one({
           "_id": ObjectId(to_user)})
                        fri = [i.get("friend_remark") for i in res.get("friend_list") if i.get("friend_id") == tid][0]
                        msg_file_name = baidu_ai.text2audio(f"你有来自{fri}的消息")
                        send_str = {
                            "code": 0,
                            "from_user": tid,
                            "msg_type": "chat",
                            "user_type": "toy",
                            "data": msg_file_name
                        }
                    else:
                        send_str = {
                            "code": 0,
                            "from_user": tid,
                            "msg_type": "chat",
                            "data": file_name,
                        }
    
                    if other_user_socket:  # 当websocket连接存在时
                        chat_redis.save_msg(tid, to_user)  # 保存消息到redis
                        # 发送数据
                        other_user_socket.send(json.dumps(send_str))
                    else:
                        # 离线消息
                        chat_redis.save_msg(tid, to_user)
    
                    # 保存聊天记录到MongoDB
                    _add_chat(tid, to_user, send_str.get("data"))
    
                to_user = ""
                file_name = ""
    
    
    @app.route("/app/<uid>")
    def user_app(uid):  # 手机app连接
        user_socket = request.environ.get("wsgi.websocket")  # type:WebSocket
        if user_socket:
            user_socket_dict[uid] = user_socket
            # { uid : websocket}
            print(user_socket_dict)
    
        file_name = ""
        to_user = ""
    
        while True:  # 手机听歌 把歌曲发送给 玩具 1.将文件直接发送给玩具 2.将当前听的歌曲名称或ID发送到玩具
            msg = user_socket.receive()
            if type(msg) == bytearray:  # 判断类型为bytearray
                file_name = f"{uuid4()}.amr"  # 文件后缀为amr，安卓和ios通用
                file_path = os.path.join(CHAT_FILE, file_name)  # 存放在chat目录
                print(msg)
                with open(file_path, "wb") as f:
                    f.write(msg)  # 写入文件
    
                # 将amr转换为mp3,因为html中的audio不支持amr
                os.system(f"ffmpeg -i {file_path} {file_path}.mp3")
    
            else:
                msg_dict = json.loads(msg)
                to_user = msg_dict.get("to_user")  # 获取目标用户
    
                if msg_dict.get("msg_type") == "music":
                    other_user_socket = user_socket_dict.get(to_user)
    
                    send_str = {
                        "code": 0,
                        "from_user": uid,
                        "msg_type": "music",
                        "data": msg_dict.get("data")
                    }
                    other_user_socket.send(json.dumps(send_str))
    
                # res = content._content_one(content_id)
            if file_name and to_user:  # 如果文件名和发送用户同上存在时
                # 查询玩具信息
                res = setting.MONGO_DB.toys.find_one({
           "_id": ObjectId(to_user)})
                # 获取friend_remark
                fri = [i.get("friend_remark") for i in res.get("friend_list") if i.get("friend_id") == uid][0]
                msg_file_name = baidu_ai.text2audio(f"你有来自{fri}的消息")
    
                # 获取websocket对象
                other_user_socket = user_socket_dict.get(to_user)
                # 构造数据
                send_str = {
                    "code": 0,
                    "from_user": uid,
                    "msg_type": "chat", # 聊天类型
                    # 后缀必须是mp3的
                    "data": msg_file_name
                }
                if other_user_socket:
                    chat_redis.save_msg(uid, to_user)
                    # 发送数据给前端页面
                    other_user_socket.send(json.dumps(send_str))
                else:
                    # 保存redis
                    chat_redis.save_msg(uid, to_user)
    
                # 添加聊天记录到数据库
                _add_chat(uid, to_user, f"{file_name}.mp3")
                # 最后一定要清空这2个变量，否则造成混乱
                file_name = ""
                to_user = ""
    
    def _add_chat(sender, to_user, msg):  # 添加聊天记录到数据库
        chat_window = setting.MONGO_DB.chat.find_one({
           "user_list": {
           "$all": [sender, to_user]}})
        if not chat_window.get("chat_list"):
            chat_window["chat_list"] = [{
                "sender": sender,
                "msg": msg,
                "updated_at": time.time(),
            }]
            res = setting.MONGO_DB.chat.update_one({
           "_id": ObjectId(chat_window.get("_id"))}, {
           "$set": chat_window})
        else:
            chat = {
                "sender": sender,
                "msg": msg,
                "updated_at": time.time(),
            }
            res = setting.MONGO_DB.chat.update_one({
           "_id": ObjectId(chat_window.get("_id"))}, {
           "$push": {
           "chat_list": chat}})
    
        return res
    
    if __name__ == '__main__':
        # 创建一个WebSocket服务器
        http_serv = WSGIServer(("0.0.0.0", 9528), app, handler_class=WebSocketHandler)
        # 开始监听HTTP请求
        http_serv.serve_forever()
    
    
    '''
    {
        "code": 0,
        "from_user": uid,  # APP用户id
        "data": music_name  # 歌曲名
    }
    '''

修改 templates-->index.html，增加user\_type

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    
    </head>
    <body>
    <audio src="" autoplay="autoplay" controls id="player"></audio>
    <br>
    <input type="text" id="device_id"/>
    <button οnclick="start_toy()">玩具开机键</button>
    <br>
    <button οnclick="start_reco()">开始废话</button>
    <br>
    <button οnclick="stop_reco()">发送语音</button>
    <br>
    <button οnclick="start_reco()">录制消息</button>
    <span id="to_user"></span>
    <span id="user_type"></span>
    <br>
    <button οnclick="send_reco()">发送语音消息</button>
    <br>
    <button οnclick="recv_msg()">收取消息</button>
    </body>
    <script src="/static/recorder.js"></script>
    <script src="/static/jquery.min.js"></script>
    <script type="application/javascript">
        var serv = "http://127.0.0.1:9527";
        var ws_serv = "ws://127.0.0.1:9528";
    
        // 获取音频文件
        var get_music = serv + "/get_audio/";
        var get_chat = serv + "/get_chat/";
    
        var ws = null;  // WebSocket 对象
        var reco = null;
        // 创建AudioContext对象
        var audio_context = new AudioContext();
    
        var toy_id = null;
    
        //要获取音频和视频
        navigator.getUserMedia = (navigator.getUserMedia ||
            navigator.webkitGetUserMedia ||
            navigator.mozGetUserMedia ||
            navigator.msGetUserMedia);
    
        // 拿到媒体对象，允许音频对象
        navigator.getUserMedia({audio: true}, create_stream, function (err) {
            console.log(err)
        });
    
        //创建媒体流容器
        function create_stream(user_media) {
            var stream_input = audio_context.createMediaStreamSource(user_media);
            // 给Recoder 创建一个空间，麦克风说的话，都可以录入。是一个流
            reco = new Recorder(stream_input);
    
        }
    
        function start_reco() {  //开始录音
            reco.record();  //往里面写流
        }
    
        function stop_reco() {  //停止录音
            reco.stop();  //停止写入流
            get_audio();  //调用自定义方法
            reco.clear();  //清空容器
        }
    
        {
            #function get_audio() {  // 获取音频#}
        {
           #    reco.exportWAV(function (wav_file) {#}
        {
           #        ws.send(wav_file);  //使用websocket连接发送数据给后端#}
        {
           #    })#}
        {
           # }#}
    
        function send_reco() {
            reco.stop();
            send_audio();
            reco.clear();
        }
    
        function send_audio() {
            var to_user = document.getElementById("to_user").innerText;
            var user_type = document.getElementById("user_type").innerText;
            var send_str = {
                "to_user": to_user,
                "user_type":user_type
            };
            ws.send(JSON.stringify(send_str));
            reco.exportWAV(function (wav_file) {
                ws.send(wav_file);
            })
        }
    
        function get_audio() {
    
            var send_str = {
                "to_user": toy_id,
                "msg_type": "ai"
            };
            ws.send(JSON.stringify(send_str));
            reco.exportWAV(function (wav_file) {
                ws.send(wav_file);
            })
        }
    
    
        function start_toy() {  // 玩具开机
            // 获取输入的设备id
            var device_id = document.getElementById("device_id").value;
            // 发送post请求
            $.post(
                // 这里的地址必须是127.0.0.1,否则会有跨域问题
                "http://127.0.0.1:9527/device_toy_id",
                // 发送设备id
                {device_id: device_id},
                function (data) {
                    console.log(data);
                    toy_id = data.data.toy_id;  // 玩具id
                    // 修改audio标签的src属性
                    document.getElementById("player").src = get_music + data.data.audio;
                    if (toy_id) {  // 判断玩具id存在时
                        ws = new WebSocket(ws_serv + "/toy/" + toy_id);
                        ws.onmessage = function (data) {
                            // console.log(get_music + data.data);
                            var content = JSON.parse(data.data);  //反序列化数据
                            {
            #console.log(content);#}
                            // 判断消息类型
                            if (content.msg_type == "chat") {
                                document.getElementById("player").src = get_chat + content.data;
                                document.getElementById("to_user").innerText = content.from_user;
                                document.getElementById("user_type").innerText = content.user_type;
                                console.log(content.from_user + "给你发送了一条消息");
                            }
                            if (content.msg_type == "music") {
                                document.getElementById("player").src = get_music + content.data;
                                console.log(content.from_user + "给你点播了歌儿");
                            }
                        };
                        ws.onclose = function () {
                            window.location.reload();
                        }
                    }
                }, "json"
                // 规定预期的服务器响应的数据类型为json
            );
        }
    
        function recv_msg() {
            var to_user = document.getElementById("to_user").innerText;
            var player = document.getElementById("player");
    
            to_user = document.getElementById("to_user").innerText;
            $.post(
                serv + "/get_msg",
                {user_id: toy_id, sender: to_user},
                function (data) {
                    // shift() 方法用于把数组的第一个元素从其中删除，并返回第一个元素的值
                    var msg = data.data.shift();
                    document.getElementById("to_user").innerText = msg.sender;
                    player.src = get_chat + msg.msg;  //修改audio标签src属性
                    // onended 事件在视频/音频(audio/video)播放结束时触发
                    player.onended = function () {
                        // 如果长度大于0,也就是有1条或者多条时
                        if(data.data.length > 0){
                            //修改audio标签src属性，有多条时，会轮询触发
                           player.src = get_chat + data.data.shift().msg;
                        }else{
                           return null;
                        }
                    }
                }, "json"
            )
        }
    
    
    </script>
    </html>

重启manager.py和im\_serv.py

重新访问网页，让2个玩具开机。左边是小甜甜，右边是小豆芽

![1341090-20180926204715416-2061620487.png][]

为了保证给对方发消息的时候，不造成混乱！

修改 玩具表toys，将toy\_name和baby\_name改成一样的。

完整数据如下：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/* 1 createdAt:2018/9/19 下午5:53:08*/
    {
        "_id" : ObjectId("5ba21c84e1253229c4acbd12"),
        "device_id" : "02cc0fc7490b6ee08c31f38ac7a375eb",
        "toy_name" : "小豆芽",
        "baby_name" : "小豆芽",
        "gender" : "2",
        "avatar" : "girl.jpg",
        "bind_user" : "5b9bb768e1253281608e96eb",
        "friend_list" : [
            {
                "friend_id" : "5b9bb768e1253281608e96eb",
                "friend_name" : "xiao",
                "friend_remark" : "小鱼",
                "friend_avatar" : "boy.jpg",
                "friend_chat" : "5ba21c84e1253229c4acbd11",
                "user_type" : "user"
            },
            {
                "friend_id" : "5ba0f1f2e12532418089bf88",
                "friend_name" : "小甜甜",
                "friend_remark" : "小甜甜",
                "friend_avatar" : "girl.jpg",
                "friend_chat" : "5bab7c19e125327ffc804459",
                "user_type" : "toy"
            }
        ]
    },
    
    /* 2 createdAt:2018/9/18 下午8:39:14*/
    {
        "_id" : ObjectId("5ba0f1f2e12532418089bf88"),
        "device_id" : "01f9bf1bac93eddd8397d0455abbeddb",
        "toy_name" : "小甜甜",
        "baby_name" : "小甜甜",
        "gender" : "2",
        "avatar" : "girl.jpg",
        "bind_user" : "5b9bb768e1253281608e96eb",
        "friend_list" : [
            {
                "friend_id" : "5b9bb768e1253281608e96eb",
                "friend_name" : "xiao",
                "friend_remark" : "小鱼",
                "friend_avatar" : "boy.jpg",
                "friend_chat" : "5ba21c84e1253229c4acbd11",
                "user_type" : "user"
            },
            {
                "friend_id" : "5ba21c84e1253229c4acbd12",
                "friend_name" : "小豆芽",
                "friend_remark" : "小豆芽",
                "friend_avatar" : "girl.jpg",
                "friend_chat" : "5bab7c19e125327ffc804459",
                "user_type" : "toy"
            }
        ]
    }

修改 用户表users，也是将toy\_name和baby\_name改成一样的

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

{
        "_id" : ObjectId("5b9bb768e1253281608e96eb"),
        "username" : "xiao",
        "password" : "202cb962ac59075b964b07152d234b70",
        "age" : "20",
        "nickname" : "xiao",
        "gender" : "1",
        "phone" : "1234567",
        "avatar" : "boy.jpg",
        "bind_toy" : [
            "5ba0f1f2e12532418089bf88",
            "5ba21c84e1253229c4acbd12"
        ],
        "friend_list" : [
            {
                "friend_id" : "5ba0f1f2e12532418089bf88",
                "friend_name" : "小甜甜",
                "friend_remark" : "小甜甜",
                "friend_avatar" : "girl.jpg",
                "friend_chat" : "5ba0f1f2e12532418089bf87",
                "user_type" : "toy"
            },
            {
                "friend_id" : "5ba21c84e1253229c4acbd12",
                "friend_name" : "小豆芽",
                "friend_remark" : "小豆芽",
                "friend_avatar" : "girl.jpg",
                "friend_chat" : "5ba21c84e1253229c4acbd11",
                "user_type" : "toy"
            }
        ]
    }

修改 chat表，请确保 主人-->小甜甜-->小豆芽。**这3者之间必须要有3条记录！**

分别是:

主人--> 小甜甜

主人--> 小豆芽

小甜甜--> 小豆芽

![1341090-20180926220755412-1432562190.png][]

这样，就可以实现3者之间的聊天通信了！

chat完整记录如下：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

/* 1 createdAt:2018/9/25 下午9:05:46*/
    {
        "_id" : ObjectId("5baa32aae125320598c912f3"),
        "user_list" : [
            "5ba0f1f2e12532418089bf88",
            "5ba21c84e1253229c4acbd12"
        ]
    },
    
    /* 2 createdAt:2018/9/19 下午5:53:08*/
    {
        "_id" : ObjectId("5ba21c84e1253229c4acbd11"),
        "user_list" : [
            "5b9bb768e1253281608e96eb",
            "5ba21c84e1253229c4acbd12"
        ]
    },
    
    /* 3 createdAt:2018/9/18 下午8:39:14*/
    {
        "_id" : ObjectId("5ba0f1f2e12532418089bf87"),
        "user_list" : [
            "5b9bb768e1253281608e96eb",
            "5ba0f1f2e12532418089bf88"
        ]
    }

进入左边网页，点击 **开始废话**，说： 发消息给 小豆芽 。再点击发送语音！

**网页会说**：可以按消息键，给 小豆芽 发消息了！

这里会出现 toy，表示给玩具发消息。左边的id，就是 小豆芽的id

![1341090-20180926204857158-1477062224.png][]

点击 **录制消息**，说：你好， 我是小甜甜！

点击 **发送语音消息**

![1341090-20180926205103468-792689777.png][]

这个时候，网页会有提示： 你有来自 小甜甜 的消息

切换到第二个网页，会出现设备id，这个是 小甜甜的。

![1341090-20180926205216478-939673428.png][]

点击 **收取消息**

![1341090-20180926201157049-40864921.png][]

会播放： 你好， 我是小甜甜！

这样，就实现了，玩具之间的通信了！

# 二、基于jieba gensim  pypinyin实现的自然语言处理 #

## jieba ##

jieba分词，完全开源，有集成的python库，简单易用。

jieba分词是基于前缀词典实现高效的词图扫描，生成句子中汉字所有可能成词情况所构成的有向无环图 (DAG)，动态规划查找最大概率路径, 找出基于词频的最大切分组合

### 安装 ###

pip install gensim

由于包很大，如果安装比较慢，可以使用国内更新源安装

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple jieba

### 使用 ###

我们通常把这个库叫做 结巴分词 确实是结巴分词,而且这个词库是 made in china , 基本用一下这个结巴分词:

import jieba
    
    key_word = "我的妈妈真伟大"  # 定义一句话,基于这句话进行分词
    
    cut_word = jieba.cut(key_word)  # 使用结巴分词中的cut方法对"我的妈妈真伟大" 进行分词
    
    print(cut_word)  # <generator object Tokenizer.cut at 0x03676390> 不懂生成器的话,就忽略这里
    
    cut_word_list = list(cut_word)  # 如果不明白生成器的话,这里要记得把生成器对象做成列表
    
    print(cut_word_list)  # ['我', '的', '妈妈', '真', '伟大']

测试代码就很明显了,它很清晰的把咱们的中文字符串转为列表存储起来了

如果需要将 "真伟大" 变成一个词，需要添加词库，使用add\_word

import jieba
    
    key_word = "我的妈妈真伟大"  # 定义一句话,基于这句话进行分词
    jieba.add_word("真伟大")  # 添加词库
    cut_word = jieba.cut(key_word)  # 使用结巴分词中的cut方法对"我的妈妈真伟大" 进行分词
    
    
    cut_word_list = list(cut_word)  # 如果不明白生成器的话,这里要记得把生成器对象做成列表
    print(cut_word_list)  # ['我', '的', '妈妈', '真伟大']

## pypinyin ##

将汉字转为拼音。可以用于汉字注音、排序、检索([Russian translation][]) 。

### 特性 ###

*  根据词组智能匹配最正确的拼音。
 *  支持多音字。
 *  简单的繁体支持, 注音支持。
 *  支持多种不同拼音/注音风格。

### 安装 ###

pip install pypinyin

### 使用 ###

from pypinyin import lazy_pinyin,TONE2
    
    key_word = "我的妈妈真伟大"  # 定义一句话
    res = lazy_pinyin(key_word,style=TONE2)  # 设置拼音风格
    print(res)  # ['wo3', 'de', 'ma1', 'ma1', 'zhe1n', 'we3i', 'da4']

拼音声调是指普通话中的声调，通常叫四声，即[阴平][Link 1]（第一声），用“ˉ”表示，如lā；[阳平][Link 2]第二声，用“ˊ”表示，如lá；[上声][Link 3]（[第三声][Link 4]），用“ˇ”表示，如lǎ；[去声][Link 5]（第四声），用“ˋ”表示，如；là。

wo3 最后面的3表示声调。它是第三声！

看下面的例子，这些字也是同音

from pypinyin import lazy_pinyin,TONE2
    
    key_word = "贝贝蓓蓓背背"  # 定义一句话
    res = lazy_pinyin(key_word,style=TONE2)  # 设置拼音风格
    print(res)  # ['be4i', 'be4i', 'be4i', 'be4i', 'be4i', 'be4i']

## gensim ##

Gensim是一款开源的第三方Python工具包，用于从原始的非结构化的文本中，无监督地学习到文本隐层的主题向量表达。   
它支持包括TF-IDF，LSA，LDA，和word2vec在内的多种主题模型算法，   
支持流式训练，并提供了诸如相似度计算，信息检索等一些常用任务的API接口

### 基本概念 ###

*  语料（Corpus）：一组原始文本的集合，用于无监督地训练文本主题的隐层结构。语料中不需要人工标注的附加信息。在Gensim中，Corpus通常是一个可迭代的对象（比如列表）。每一次迭代返回一个可用于表达文本对象的稀疏向量。
 *  向量（Vector）：由一组文本特征构成的列表。是一段文本在Gensim中的内部表达。
 *  稀疏向量（SparseVector）：通常，我们可以略去向量中多余的0元素。此时，向量中的每一个元素是一个(key, value)的元组
 *  模型（Model）：是一个抽象的术语。定义了两个向量空间的变换（即从文本的一种向量表达变换为另一种向量表达）。

### 安装 ###

pip install jieba

### 使用 ###

这个训练库很厉害, 里面封装很多机器学习的算法, 是目前人工智能的主流应用库,这个不是很好理解, 需要一定的Python数据处理的功底

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

import jieba
    import gensim
    from gensim import corpora
    from gensim import models
    from gensim import similarities
    
    l1 = ["你的名字是什么", "你今年几岁了", "你有多高你心情怎么样", "你心情怎么样"]
    a = "你今年多大了"
    
    # 制作语料库
    all_doc_list = []
    for doc in l1:
        doc_list = [word for word in jieba.cut(doc)]
        all_doc_list.append(doc_list)
    
    print(all_doc_list)
    #[['你', '的', '名字', '是', '什么'],
    # 1 4 2 3 0
    #  ['你', '今年', '几岁', '了'],
    # 1 6 7 5
    
    # 将问题分词
    doc_test_list = [word for word in jieba.cut(a)]
    #['你', '今年', '多大', '了']
    # 1 6 5
    
    # 制作词袋
    dictionary = corpora.Dictionary(all_doc_list)
    # 词袋的理解
    # 词袋就是将很多很多的词,进行排列形成一个 词(key) 与一个 标志位(value) 的字典
    # 例如: {'什么': 0, '你': 1, '名字': 2, '是': 3, '的': 4, '了': 5, '今年': 6, '几岁': 7, '多': 8, '心情': 9, '怎么样': 10, '有': 11, '高': 12}
    # 至于它是做什么用的,带着问题往下看
    
    print("token2id", dictionary.token2id)
    print("dictionary", dictionary, type(dictionary))
    
    corpus = [dictionary.doc2bow(doc) for doc in all_doc_list]
    # 语料库:
    # 这里是将all_doc_list 中的每一个列表中的词语 与 dictionary 中的Key进行匹配
    # 得到一个匹配后的结果,例如['你', '今年', '几岁', '了']
    # 就可以得到 [(1, 1), (6, 1), (7, 1), (5, 1)]
    # 1代表的的是 你 1代表出现一次, 5代表的是 了  1代表出现了一次, 以此类推 6 = 今年 , 7 = 几岁
    print("corpus", corpus, type(corpus))
    
    # 将需要寻找相似度的分词列表 做成 语料库 doc_test_vec
    doc_test_vec = dictionary.doc2bow(doc_test_list)
    print("doc_test_vec", doc_test_vec, type(doc_test_vec))
    
    # 将corpus语料库(初识语料库) 使用Lsi模型进行训练
    lsi = models.LsiModel(corpus)
    # 这里的只是需要学习Lsi模型来了解的,这里不做阐述
    print("lsi", lsi, type(lsi))
    # 语料库corpus的训练结果
    print("lsi[corpus]", lsi[corpus])
    # 获得语料库doc_test_vec 在 语料库corpus的训练结果 中的 向量表示
    print("lsi[doc_test_vec]", lsi[doc_test_vec])
    
    # 文本相似度
    # 稀疏矩阵相似度 将 主 语料库corpus的训练结果 作为初始值
    index = similarities.SparseMatrixSimilarity(lsi[corpus], num_features=len(dictionary.keys()))
    print("index", index, type(index))
    
    # 将 语料库doc_test_vec 在 语料库corpus的训练结果 中的 向量表示 与 语料库corpus的 向量表示 做矩阵相似度计算
    sim = index[lsi[doc_test_vec]]
    
    print("sim", sim, type(sim))
    
    # 对下标和相似度结果进行一个排序,拿出相似度最高的结果
    # cc = sorted(enumerate(sim), key=lambda item: item[1],reverse=True)
    cc = sorted(enumerate(sim), key=lambda item: -item[1])
    print(cc)
    
    text = l1[cc[0][0]]
    
    print(a,text)

执行输出：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

[['你', '的', '名字', '是', '什么'], ['你', '今年', '几岁', '了'], ['你', '有', '多', '高', '你', '心情', '怎么样'], ['你', '心情', '怎么样']]
    
    token2id {
            '什么': 0, '你': 1, '名字': 2, '是': 3, '的': 4, '了': 5, '今年': 6, '几岁': 7, '多': 8, '心情': 9, '怎么样': 10, '有': 11, '高': 12}
    dictionary Dictionary(13 unique tokens: ['什么', '你', '名字', '是', '的']...) <class 'gensim.corpora.dictionary.Dictionary'>
    corpus [[(0, 1), (1, 1), (2, 1), (3, 1), (4, 1)], [(1, 1), (5, 1), (6, 1), (7, 1)], [(1, 2), (8, 1), (9, 1), (10, 1), (11, 1), (12, 1)], [(1, 1), (9, 1), (10, 1)]] <class 'list'>
    doc_test_vec [(1, 1), (5, 1), (6, 1)] <class 'list'>
    lsi LsiModel(num_terms=13, num_topics=200, decay=1.0, chunksize=20000) <class 'gensim.models.lsimodel.LsiModel'>
    lsi[corpus] <gensim.interfaces.TransformedCorpus object at 0x00000260DA2DAF28>
    lsi[doc_test_vec] [(0, 0.900230201263672), (1, 0.3426436202483724), (2, -1.1659919622685817)]
    index <gensim.similarities.docsim.SparseMatrixSimilarity object at 0x00000260DA2F3048> <class 'gensim.similarities.docsim.SparseMatrixSimilarity'>
    sim [0.2956978  0.99180055 0.44080025 0.38174424] <class 'numpy.ndarray'>
    [(1, 0.99180055), (2, 0.44080025), (3, 0.38174424), (0, 0.2956978)]
    你今年多大了 你今年几岁了

噼里啪啦写了这一堆代码，到底干了啥哟？看了一脸懵逼！

大概意思就是。我抛出了一个问题，就是变量a

你今年多大了

在问题库里面，有这些问题

["你的名字是什么", "你今年几岁了", "你有多高你心情怎么样", "你心情怎么样"]

经过 矩阵相似度计算之后，得到一个最优的结果

你今年几岁了

也就是说，我问：你今年多大了，机器认为我的问题是：你今天几岁了

这2句话，其实是一个意思！

## 集成到flask ##

进入flask项目，进入utils目录，**新建文件lowB\_plus.py**

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

import jieba
    import setting
    from gensim import corpora
    from gensim import models
    from gensim import similarities
    
    l1 = []
    for i in setting.MONGO_DB.sources.find({}):
        l1.append(i.get("title"))
    
    
    
    def my_nlp(text):
        # 制作语料库
        all_doc_list = []
        for doc in l1:
            doc_list = [word for word in jieba.cut(doc)]
            all_doc_list.append(doc_list)
    
        print(all_doc_list)
        # [['你', '的', '名字', '是', '什么'],
        # 1 4 2 3 0
        #  ['你', '今年', '几岁', '了'],
        # 1 6 7 5
        # ['你', '有', '多', '高', '你', '胸多大'],
        # 1 9 8 11 1 10
        #  ['你', '胸多大']]
        # 1 10
    
        # 将问题分词
        doc_test_list = [word for word in jieba.cut(text)]
        print(doc_test_list)
        # ['你', '今年', '多大', '了']
        # 1 6 5
    
    
        # 制作词袋
        dictionary = corpora.Dictionary(all_doc_list)
        # 词袋的理解
        # 词袋就是将很多很多的词,进行排列形成一个 词(key) 与一个 标志位(value) 的字典
        # 例如: {'什么': 0, '你': 1, '名字': 2, '是': 3, '的': 4, '了': 5, '今年': 6, '几岁': 7, '多': 8, '有': 9, '胸多大': 10, '高': 11}
        # 至于它是做什么用的,带着问题往下看
    
        print("token2id", dictionary.token2id)
        print("dictionary", dictionary, type(dictionary))
    
        corpus = [dictionary.doc2bow(doc) for doc in all_doc_list]
        # 语料库:
        # 这里是将all_doc_list 中的每一个列表中的词语 与 dictionary 中的Key进行匹配
        # 得到一个匹配后的结果,例如['你', '今年', '几岁', '了']
        # 就可以得到 [(1, 1), (5, 1), (6, 1), (7, 1)]
        # 1代表的的是 你 1代表出现一次, 5代表的是 了  1代表出现了一次, 以此类推 6 = 今年 , 7 = 几岁
        print("corpus", corpus, type(corpus))
    
        # 将需要寻找相似度的分词列表 做成 语料库 doc_test_vec
        doc_test_vec = dictionary.doc2bow(doc_test_list)
        print("doc_test_vec", doc_test_vec, type(doc_test_vec))
        #  [(1, 1), (5, 1), (6, 1)]
    
        # 将corpus语料库(初识语料库) 使用Lsi模型进行训练
        lsi = models.LsiModel(corpus)
        # 这里的只是需要学习Lsi模型来了解的,这里不做阐述
        print("lsi", lsi, type(lsi))
        # 语料库corpus的训练结果
        print("lsi[corpus]", lsi[corpus])
        # 获得语料库doc_test_vec 在 语料库corpus的训练结果 中的 向量表示
        print("lsi[doc_test_vec]", lsi[doc_test_vec])
    
        # 文本相似度
        # 稀疏矩阵相似度 将 主 语料库corpus的训练结果 作为初始值
        index = similarities.SparseMatrixSimilarity(lsi[corpus], num_features=len(dictionary.keys()))
        print("index", index, type(index))
        # 向量表示：
        # (0.387654321,0.84382974,0.4297589245,1.2439785,3.9867462154)
        # ((0.387654321,0.84382974,0.4297589245,1.2439786,3.9867462154),(0.387654321,0.84382974,0.4297589245,1.2439786,3.9867462154),(0.387654321,0.84382974,0.4297589245,1.2439786,3.9867462154),(0.387654321,0.84382974,0.4297589245,1.2439786,3.9867462154))
    
        # 将 语料库doc_test_vec 在 语料库corpus的训练结果 中的 向量表示 与 语料库corpus的 向量表示 做矩阵相似度计算
        sim = index[lsi[doc_test_vec]]
    
        print("sim", sim, type(sim))
    
        # 对下标和相似度结果进行一个排序,拿出相似度最高的结果
        # cc = sorted(enumerate(sim), key=lambda item: item[1],reverse=True)
        cc = sorted(enumerate(sim), key=lambda item: -item[1])
        print(cc)
    
        text = l1[cc[0][0]]
    
        return text

由于还不够智能，所以叫 lowB\_plus

**修改 utils-->baidu\_ai.py**，使用 lowB\_plus

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from aip import AipSpeech
    import os
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # 项目根目录
    
    import sys
    sys.path.append(BASE_DIR)  # 加入到系统环境变量中
    
    import setting  # 导入setting
    from uuid import uuid4
    # from setting import MONGO_DB
    # import setting
    import os
    from bson import ObjectId
    from utils import lowB_plus
    from pypinyin import lazy_pinyin, TONE2
    
    client = AipSpeech(setting.APP_ID,setting.API_KEY,setting.SECRET_KEY)
    
    def text2audio(text):
        res = client.synthesis(text, "zh", 1, setting.SPEECH)
        file_name = f"{uuid4()}.mp3"
        file_path = os.path.join(setting.CHAT_FILE, file_name)
        with open(file_path, "wb") as f:
            f.write(res)
    
        return file_name
    
    
    def get_file_content(filePath):
        os.system(f"ffmpeg -y -i {filePath}  -acodec pcm_s16le -f s16le -ac 1 -ar 16000 {filePath}.pcm")
        with open(f"{filePath}.pcm", 'rb') as fp:
            return fp.read()
    
    
    def audio2text(file_name):
        # 识别本地文件
        liu = get_file_content(file_name)
    
        res = client.asr(liu, 'pcm', 16000, {
            'dev_pid': 1536,
        })
    
        if res.get("result"):
            return res.get("result")[0]
        else:
            return res
    
    # text2audio("你好")
    
    def my_nlp(q,toy_id):
        # 1. 假设玩具说：q = 我要给爸爸发消息
        if "发消息" in q:
            q = "".join(lazy_pinyin(q, style=TONE2))
            print(q)
            toy = setting.MONGO_DB.toys.find_one({
           "_id": ObjectId(toy_id)})
            # print(toy.get("friend_list"))
            for i in toy.get("friend_list"):
                # 转换成拼音,即使同音字也能匹配
                remark_pinyin = "".join(lazy_pinyin(i.get("friend_remark"), style=TONE2))
                name_pinyin = "".join(lazy_pinyin(i.get("friend_name"), style=TONE2))
                print(name_pinyin)
                if remark_pinyin in q or name_pinyin in q:
                    res = text2audio(f"可以按消息键，给{i.get('friend_remark')}发消息了")
                    send_str = {
                        "code": 0,
                        "from_user": i.get("friend_id"),
                        "msg_type": "chat",
                        "data": res,
                        "user_type":i.get("user_type")
                    }
                    return send_str
    
        if "我要听" in q or "我想听" in q or "唱一首" in q:
            q = str(q).replace("我要听", "")
            q = str(q).replace("我想听", "")
            q = str(q).replace("唱一首", "")
            print(q)
            title = lowB_plus.my_nlp(q)
            sources = setting.MONGO_DB.sources.find_one({
           "title": title})
            for i in sources:
                if i.get("title") in q:
                    send_str = {
                        "code": 0,
                        "from_user": toy_id,
                        "msg_type": "music",
                        "data": i.get("audio")
                    }
                    return send_str
    
    
    
        res = text2audio("对不起，我没明白你的意思")
        send_str = {
            "code": 0,
            "from_user": toy_id,
            "msg_type": "chat",
            "data": res
        }
        return send_str

### 测试 ###

重启 manager.py和im\_serv.py

重新访问网页，让2个玩具开机。左边是小甜甜，右边是小豆芽

![1341090-20180927101401731-1551594748.png][]

使用 小甜甜给小豆芽发送消息。注意：说话的时候，可以使用儿化音。

比如：发消息 给 小豆芽儿

查看Pycharm控制台输出：

发消息给小豆芽儿
    fa1xia1oxi1ge3ixia3odo4uya2e2r

第二个网页，小豆芽，也可以接收消息！

#### 测试同音字 ####

打开玩具表toys，找到  小甜甜的记录，将小豆芽，改成晓逗牙

![1341090-20180927101820860-4919438.png][]

再次测试发送语音给 小豆芽

小豆芽，一样也可以收到消息！

注意：尽可能避免多音字。否则会无法匹配到！

## 接入图灵 ##

如果说别的话，比如：今天天气怎么样？网页会提示： 对不起，我没明白你的意思

这样用户体验不好，那么这种匹配不到的问题，扔给图灵来处理就可以了！

修改 setting.py，增加图灵配置

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

import pymongo
    import os
    import redis
    
    # 数据库配置
    client = pymongo.MongoClient(host="127.0.0.1", port=27017)
    MONGO_DB = client["bananabase"]
    
    
    REDIS_DB = redis.Redis(host="127.0.0.1",port=6379)
    
    RET = {
        # 0: false 2: True
        "code": 0,
        "msg": "",  # 提示信息
        "data": {}
    }
    
    XMLY_URL = "http://m.ximalaya.com/tracks/"  # 喜马拉雅链接
    CREATE_QR_URL = "http://qr.liantu.com/api.php?text="  # 生成二维码API
    
    # 文件目录
    
    
    AUDIO_FILE = os.path.join(os.path.dirname(__file__), "audio")  # 音频
    AUDIO_IMG_FILE = os.path.join(os.path.dirname(__file__), "audio_img")  # 音频图片
    
    DEVICE_CODE_PATH = os.path.join(os.path.dirname(__file__), "device_code")  # 二维码
    CHAT_FILE = os.path.join(os.path.dirname(__file__), "chat")  # 聊天
    
    # 百度AI配置
    APP_ID = '11793552'
    API_KEY = 'uA6sToQWcvYt2lT6qTW6WFrG'
    SECRET_KEY = '5rZ1XGYMV39LQBVT4Y1yLNCsmueVe8RQ'
    SPEECH = {
        "spd": 4,
        'vol': 5,
        "pit": 8,
        "per": 4
    }
    
    #图灵配置：
    TL_URL = "http://openapi.tuling123.com/openapi/api/v2"
    TL_DATA = {
        # 请求的类型 0 文本 1 图片 2 音频
        "reqType": 0,
        # // 输入信息(必要参数)
        "perception": {
            # 文本信息
            "inputText": {
                # 问题
                "text": "北京未来七天，天气怎么样"
            }
        },
        # 用户必要信息
        "userInfo": {
            # 图灵机器人的apikey
            "apiKey": "8fc493d348704ba4af5413e67e6fc90b",
            # 用户唯一标识
            "userId": "xiao"
        }
    }

进入utils目录，新建文件  tuling.py

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

import requests
    import json
    from setting import TL_URL as tuling_url
    from setting import TL_DATA as data
    
    
    def to_tuling(q,user_id):
        data["perception"]["inputText"]["text"] = q
        data["userInfo"]["userId"] = user_id
        res = requests.post(tuling_url, json=data)
        res_dic = json.loads(res.content.decode("utf8"))  # type:dict
        res_type = res_dic.get("results")[0].get("resultType")
        result = res_dic.get("results")[0].get("values").get(res_type)
        print(result)
        return result

修改 utils-->baidu\_ai.py，接入图灵

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

from aip import AipSpeech
    import os
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # 项目根目录
    
    import sys
    sys.path.append(BASE_DIR)  # 加入到系统环境变量中
    
    import setting  # 导入setting
    from uuid import uuid4
    # from setting import MONGO_DB
    # import setting
    import os
    from bson import ObjectId
    from utils import lowB_plus
    from pypinyin import lazy_pinyin, TONE2
    from utils import tuling
    
    client = AipSpeech(setting.APP_ID,setting.API_KEY,setting.SECRET_KEY)
    
    def text2audio(text):
        res = client.synthesis(text, "zh", 1, setting.SPEECH)
        file_name = f"{uuid4()}.mp3"
        file_path = os.path.join(setting.CHAT_FILE, file_name)
        with open(file_path, "wb") as f:
            f.write(res)
    
        return file_name
    
    
    def get_file_content(filePath):
        os.system(f"ffmpeg -y -i {filePath}  -acodec pcm_s16le -f s16le -ac 1 -ar 16000 {filePath}.pcm")
        with open(f"{filePath}.pcm", 'rb') as fp:
            return fp.read()
    
    
    def audio2text(file_name):
        # 识别本地文件
        liu = get_file_content(file_name)
    
        res = client.asr(liu, 'pcm', 16000, {
            'dev_pid': 1536,
        })
    
        if res.get("result"):
            return res.get("result")[0]
        else:
            return res
    
    # text2audio("你好")
    
    def my_nlp(q,toy_id):
        # 1. 假设玩具说：q = 我要给爸爸发消息
        if "发消息" in q:
            q = "".join(lazy_pinyin(q, style=TONE2))
            print(q)
            toy = setting.MONGO_DB.toys.find_one({
           "_id": ObjectId(toy_id)})
            # print(toy.get("friend_list"))
            for i in toy.get("friend_list"):
                # 转换成拼音,即使同音字也能匹配
                remark_pinyin = "".join(lazy_pinyin(i.get("friend_remark"), style=TONE2))
                name_pinyin = "".join(lazy_pinyin(i.get("friend_name"), style=TONE2))
                print(name_pinyin)
                if remark_pinyin in q or name_pinyin in q:
                    res = text2audio(f"可以按消息键，给{i.get('friend_remark')}发消息了")
                    send_str = {
                        "code": 0,
                        "from_user": i.get("friend_id"),
                        "msg_type": "chat",
                        "data": res,
                        "user_type":i.get("user_type")
                    }
                    return send_str
    
        if "我要听" in q or "我想听" in q or "唱一首" in q:
            q = str(q).replace("我要听", "")
            q = str(q).replace("我想听", "")
            q = str(q).replace("唱一首", "")
            print(q)
            title = lowB_plus.my_nlp(q)
            sources = setting.MONGO_DB.sources.find_one({
           "title": title})
            for i in sources:
                if i.get("title") in q:
                    send_str = {
                        "code": 0,
                        "from_user": toy_id,
                        "msg_type": "music",
                        "data": i.get("audio")
                    }
                    return send_str
    
        answer = tuling.to_tuling(q, toy_id)
    
        res = text2audio(answer)
        send_str = {
            "code": 0,
            "from_user": toy_id,
            "msg_type": "chat",
            "data": res
        }
        return send_str

重启 manager.py和im\_serv.py

让2个玩具开机，说一段话： 上海的天气怎么样

网页会播放： 上海:周四,多云转阴 东北风4-5级,最低气温22度，最高气温27度

查看Pycharm控制台输出：

上海的天气怎么样
    上海:周四,多云转阴 东北风4-5级,最低气温22度，最高气温27度

# 三、打包apk #

单击打原生安装包

![1341090-20180927114109353-1373253308.png][]

** 必须要登录账号才行**

![1341090-20180927114441606-2131643744.png][]

注意：默认是使用HBuilder的图标，这样不好。

![1341090-20180927114500834-908562542.png][]

点击android。因为苹果要相关证书才行，我没有。

去掉下面的广告。点击参数配置

![1341090-20180927114702341-91980271.png][]

输入应用名称

![1341090-20180927114753210-667847786.png][]

点击图标配置

![1341090-20180927114817185-633675208.png][]

** 上传一个图标图片，必须是png格式的！**

![1341090-20180927114840580-1277351308.png][]

点击自动生成并替换

![1341090-20180927114907718-899017983.png][]

点击启动图片配置，就是 app启动的时候，加载的图片

![1341090-20180927114933944-1249969932.png][]

找到android，选择1080p图片，并上传！

![1341090-20180927115015599-2037899894.png][]

这里有很多sdk，可以配置

![1341090-20180927115041174-1528026775.png][]

这里都不用sdk

点击模块权限配置

![1341090-20180927115110305-582420970.png][]

默认是这些权限，右侧可以增加

![1341090-20180927115156574-2107360452.png][]

点击代码视图

![1341090-20180927115258458-1520880319.png][]

这个，就是刚刚所有的配置， 使用Ctrl+s 进行保存

![1341090-20180927115308178-1848205121.png][]

保存就是这个文件

![1341090-20180927115342222-995847037.png][]

重新点击 打原生安装包

![1341090-20180927115406466-1478354804.png][]

点击忽略

![1341090-20180927115422321-1293913351.png][]

点击确认

![1341090-20180927115448584-284498281.png][]

它就会在云端打包，它会给你加一个壳子

![1341090-20180927115531071-943341245.png][]

如果提示报错

![1341090-20180927142623110-1122102746.png][]

点击 重新打包原生，点击参数配置，在这类，重新云端获取！

![1341090-20180927142635955-1372341072.png][]

打包成功后，查看打包状态

![1341090-20180927141907741-1131584010.png][]

这样，表示成功了！

![1341090-20180927142724658-885783748.png][]

点击手动下载，下载成功！

![1341090-20180927142815988-1645545399.png][]

直接将apk拖动过去，点击应用

![1341090-20180927142950212-561430834.png][]

效果如下：

![1341090-20180927143101272-2066173386.png][]

总结：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

1.说说你智能玩具的项目:
    目的:关爱留守儿童, 让玩具成为父母间沟通的桥梁, 让玩具成为孩子的玩伴
    
    实现无屏社交,依靠孩子的语音指令做出响应,例如我要和爸爸聊天,玩具会提示可以和爸爸聊天了并打开与app通讯的链接
    我要听世上只有妈妈好,玩具就会依照指令播放相应的内容
    
    
    2.智能玩具有什么功能:
    功能: 玩具可以语音点播朗诵诗歌,播放音乐,做游戏-成语接龙,与智能机器人聊天，玩具与玩具之间的通讯
    手机app的im通讯 ,手机app可以为玩具点播歌曲,通过手机app管理玩具
    
    
    高人：
    3.智能部分使用了什么算法:
    两种回答:
    1.使用百度ai中的语音合成和语音识别,点播功能是使用Gensim jieba 库进行训练的,聊天做游戏是用的图灵机器人+百度语音合成
    2.使用百度ai中的语音合成和语音识别 NLP自然语言处理 点播功能基于百度NLP,聊天做游戏是用的图灵机器人+百度语音合成
    
    
    4.IM通讯使用了什么机制:
    Websocket
        magicString 
    
    
    5.手机app是怎么做的(使用什么方式):
    mui + html5plus 
    
    
    6.谈谈你对人工智能的理解(说出人工智能技术的关键字至少5个):
    语音类 : 语音识别 语音合成
    图像类 : 图像识别 文字识别 人脸识别 视频审核
    语言类 : 自然语言处理 机器翻译 词法分析 依存句法分析 文本纠错 对话情绪识别 词向量表示 短文本相似度
    词义相似度 情感倾向分析
    
    
    7.mongodb相关:
        1.修改器: $push $set $pull $inc $pop
        2.说说你对 $ 的理解 : $ 我的理解就是代指符号,代指所查询到的数据或索引位置
        3.Mongodb中的数据类型 : ObjectID String Boolean Integer Double Arrays Object(Dict) Null Timestamp Date
        4.mongodb的比较符 : $lt $gt $lte $gte  ":"
    
    
    8.公司组织架构:
        1.综合人力财务行政：1个小姐姐
        2.营销部：老张
        3.产品部：老李 + UI小姐姐
        4.软件部：闫帅 + 前端小姐姐 + 我
        5.硬件部：江老师
        
    
    9.项目不做底层,只使用三方的原因:
        制作底层大量占用人力,公司资金不足以支撑底层研发
        将大量成本投入到硬件研发中
        
    10. 项目中,涉及到的技术
        智能语音识别 - 第三方百度ai
            开机提示
        自然语言处理（nlp）
            点歌 ：内容点播
            开启消息发送
        
        基于通讯录的即时通讯（IM）
            websocket
            不用第三方的原因 保护隐私
            
        管理玩具的功能：
            1.通过扫描二维码 绑定玩具
            2.玩具通讯录管理

完整终极代码，请参考github：

[https://github.com/987334176/Intelligent\_toy/archive/v1.7.zip][https_github.com_987334176_Intelligent_toy_archive_v1.7.zip]

附带项目需要的所有文件，包括音频，图片，数据库等等

posted @ 2018-09-26 15:43 [肖祥][Link 6] 阅读( ...) 评论( ...) [编辑][Link 7] 收藏

[python _Day133_jieba gensim pypinyin_apk]: https://www.cnblogs.com/xiao987334176/p/9707342.html
[https_github.com_987334176_Intelligent_toy_archive_v1.6.zip]: https://github.com/987334176/Intelligent_toy/archive/v1.6.zip
[https_www.cnblogs.com_xiao987334176_p_9647993.html_autoid-3-4-0]: https://www.cnblogs.com/xiao987334176/p/9647993.html#autoid-3-4-0
[1341090-20180926172801381-85440313.png]: /images/20220202/4ad424f7da124f31919b506faf3c79e2.png
[1341090-20180926172844805-1399396994.png]: /images/20220202/f0f0d60dca7a4dad8fb982d9a820163e.png
[1341090-20180926171427989-1216525640.png]: /images/20220202/56751f18121c471e813bf3741f6947ac.png
[1341090-20180926172201387-1176993454.png]: /images/20220202/17e9cb5c95344084a92a4ab20ce68883.png
[1341090-20180926172328405-424360074.png]: /images/20220202/1f68b0e1592647359ff5da8e5c22d441.png
[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20220202/94d0738852bf427b8ebb7a4c469feedc.png
[1341090-20180926204715416-2061620487.png]: /images/20220202/7ff95452b5e04f4e98b06cb5cfcf1fe7.png
[1341090-20180926220755412-1432562190.png]: /images/20220202/574794c553234cc9bcc15747e683e245.png
[1341090-20180926204857158-1477062224.png]: /images/20220202/60aee02ad683451b9ceff02fe95eac73.png
[1341090-20180926205103468-792689777.png]: /images/20220202/18a8f6d857b742ee8928d4af590b411e.png
[1341090-20180926205216478-939673428.png]: /images/20220202/1cfa3c528c00443ca7710baf424942ca.png
[1341090-20180926201157049-40864921.png]: /images/20220202/f81e4f83dfba4e539ff229f67fc2e7cc.png
[Russian translation]: https://github.com/mozillazg/python-pinyin/blob/master/README_ru.rst
[Link 1]: https://baike.baidu.com/item/%E9%98%B4%E5%B9%B3/10970766
[Link 2]: https://baike.baidu.com/item/%E9%98%B3%E5%B9%B3/28779
[Link 3]: https://baike.baidu.com/item/%E4%B8%8A%E5%A3%B0/7078510
[Link 4]: https://baike.baidu.com/item/%E7%AC%AC%E4%B8%89%E5%A3%B0
[Link 5]: https://baike.baidu.com/item/%E5%8E%BB%E5%A3%B0/10970779
[1341090-20180927101401731-1551594748.png]: /images/20220202/7b76f207e07041e9a1ab398a6a560fc0.png
[1341090-20180927101820860-4919438.png]: /images/20220202/be87830402134d03bd5940410a328bb0.png
[1341090-20180927114109353-1373253308.png]: /images/20220202/cc3dfca491e2415e88c4de4e0894fa10.png
[1341090-20180927114441606-2131643744.png]: /images/20220202/3646c6a7cbc34a4fa761a05fea8ea8a1.png
[1341090-20180927114500834-908562542.png]: /images/20220202/23db57ff10a548a9a76896fbec74d1d3.png
[1341090-20180927114702341-91980271.png]: /images/20220202/002e562a75e447eaa8753c3c5cd085e4.png
[1341090-20180927114753210-667847786.png]: /images/20220202/f98175e290ce4bae8c4d16a5cbdc58d1.png
[1341090-20180927114817185-633675208.png]: /images/20220202/a534cd038466444eaec21c650d03e6ea.png
[1341090-20180927114840580-1277351308.png]: /images/20220202/37bdc951bb2c4705afbb1960e3ff90c9.png
[1341090-20180927114907718-899017983.png]: /images/20220202/6fd40ff2f4c8464092a639dd5ce7c308.png
[1341090-20180927114933944-1249969932.png]: /images/20220202/a55f35e278f240e7abc2edb1f98ba84c.png
[1341090-20180927115015599-2037899894.png]: /images/20220202/8d3838580c50447983649d2f615523f1.png
[1341090-20180927115041174-1528026775.png]: /images/20220202/faf2bd7b00b64191a70e62dcb33854b9.png
[1341090-20180927115110305-582420970.png]: /images/20220202/b98097f40fe0423097989989b690326c.png
[1341090-20180927115156574-2107360452.png]: /images/20220202/968a0cd82f6548fca85ebb5c5589eb61.png
[1341090-20180927115258458-1520880319.png]: /images/20220202/628d1bfeb0bc45e5b836fdf7e0675bef.png
[1341090-20180927115308178-1848205121.png]: /images/20220202/d4a07643b9e94bb3a11ad1cd5f9ddcef.png
[1341090-20180927115342222-995847037.png]: /images/20220202/29b6fb407490414db2b27933564a65b5.png
[1341090-20180927115406466-1478354804.png]: /images/20220202/11d6bee293474fd1851e9421bb97cdef.png
[1341090-20180927115422321-1293913351.png]: /images/20220202/c3b20a015b814f738a3a31bf313f0d6b.png
[1341090-20180927115448584-284498281.png]: /images/20220202/26624fa93b38440792afc54fc3523de2.png
[1341090-20180927115531071-943341245.png]: /images/20220202/e233842b71a54e4fb72b0f57bbb1be41.png
[1341090-20180927142623110-1122102746.png]: /images/20220202/175bec6dc046470590e631700da5c8e0.png
[1341090-20180927142635955-1372341072.png]: /images/20220202/c27b00e786214115a9d940a1aced62bf.png
[1341090-20180927141907741-1131584010.png]: /images/20220202/781b1970174d46d395896180fc4841ce.png
[1341090-20180927142724658-885783748.png]: /images/20220202/016bc03473fb49619e1537e8e073e3a4.png
[1341090-20180927142815988-1645545399.png]: /images/20220202/cdc49d1734f34f77949a00271594ba32.png
[1341090-20180927142950212-561430834.png]: /images/20220202/ced8bb7128224ad8b2fda3385ab51b70.png
[1341090-20180927143101272-2066173386.png]: /images/20220202/abb145b2cb65480885f82164619f1dd8.png
[https_github.com_987334176_Intelligent_toy_archive_v1.7.zip]: https://github.com/987334176/Intelligent_toy/archive/v1.7.zip
[Link 6]: https://www.cnblogs.com/xiao987334176/
[Link 7]: https://i.cnblogs.com/EditPosts.aspx?postid=9707342