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

{
"_id" : ObjectId("5b9bb768e1253281608e96eb"),
"username" : "xiao",
"password" : "202cb962ac59075b964b07152d234b70",
"age" : "",
"nickname" : "xiao",
"gender" : "",
"phone" : "",
"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"
}
]
}

from flask import Blueprint, request, jsonify
from setting import MONGO_DB
from setting import RET
from bson import ObjectIdfri = 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)

from flask import Blueprint, request, jsonify
from setting import MONGO_DB
from setting import RET
from bson import ObjectIddevs = 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)

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 ObjectIdclient = 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_namedef 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

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 timeapp = 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 resif __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 # 歌曲名
}
'''

<!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 onclick="start_toy()">玩具开机键</button>
<br>
<button onclick="start_reco()">开始废话</button>
<br>
<button onclick="stop_reco()">发送语音</button>
<br>
<button onclick="start_reco()">录制消息</button>
<span id="to_user"></span>
<span id="user_type"></span>
<br>
<button onclick="send_reco()">发送语音消息</button>
<br>
<button onclick="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>

/* 1 createdAt:2018/9/19 下午5:53:08*/
{
"_id" : ObjectId("5ba21c84e1253229c4acbd12"),
"device_id" : "02cc0fc7490b6ee08c31f38ac7a375eb",
"toy_name" : "小豆芽",
"baby_name" : "小豆芽",
"gender" : "",
"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" : "",
"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"
}
]
}

{
"_id" : ObjectId("5b9bb768e1253281608e96eb"),
"username" : "xiao",
"password" : "202cb962ac59075b964b07152d234b70",
"age" : "",
"nickname" : "xiao",
"gender" : "",
"phone" : "",
"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"
}
]
}

/* 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"
]
}

import jieba
import gensim
from gensim import corpora
from gensim import models
from gensim import similaritiesl1 = ["你的名字是什么", "你今年几岁了", "你有多高你心情怎么样", "你心情怎么样"]
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)

[['你', '的', '名字', '是', '什么'], ['你', '今年', '几岁', '了'], ['你', '有', '多', '高', '你', '心情', '怎么样'], ['你', '心情', '怎么样']]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)]
你今年多大了 你今年几岁了

import jieba
import setting
from gensim import corpora
from gensim import models
from gensim import similaritiesl1 = []
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

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, TONE2client = 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_namedef 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

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 = ''
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"
}
}

import requests
import json
from setting import TL_URL as tuling_url
from setting import TL_DATA as datadef 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

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 tulingclient = 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_namedef 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

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.玩具通讯录管理