xiaominfc's blog

llm一种剪枝的方式(合并LayerNorm跟Linear)

Wed, 04 Dec 2024 17:45:11 +0000

llm一种剪枝的方式(合并LayerNorm跟Linear)

前言

llm模型中经常会遇到LayerNorm跟Linear相连，通过LayerNorm中的weight跟bias作用到Linear中，进而不再依赖LayerNorm的weight跟bias来计算

测试代码

import torch
from torch import nn
import time


shape =(512,1024)


norm = nn.LayerNorm(shape[0])
linear = nn.Linear(shape[0],shape[1])

# 初始化参数
nn.init.normal_(norm.weight,std=0.1)
nn.init.normal_(norm.bias,std=0.1)
nn.init.normal_(linear.weight,std=0.1)
nn.init.normal_(linear.bias,std=0.1)




# 合并 norm 跟 linear 成一个新的linear
linear1 = nn.Linear(shape[0],shape[1])
linear1.weight = torch.nn.Parameter(torch.mul(linear.weight,norm.weight))
linear1.bias = torch.nn.Parameter(torch.add(torch.matmul(linear.weight,norm.bias),linear.bias))


norm = norm.eval()
linear = linear.eval()
linear1 = linear1.eval()
if torch.cuda.is_available():
    norm = norm.cuda()
    linear = linear.cuda()
    linear1 = linear1.cuda()




input = torch.rand(20,shape[0])
if torch.cuda.is_available():
    input = input.cuda()

out1 = linear1(torch.layer_norm(input,(shape[0],)))

out = linear(norm(input))
print("out1:",out1)
print("out:",out)


test_count = 10000
time0 = 0
time1 = 0


for i in range(test_count):
    input = torch.rand(20,shape[0])
    if torch.cuda.is_available():
        input = input.cuda()
    start = time.time()
    out = linear(norm(input))
    time0 = time0 + (time.time()-start)

for i in range(test_count):
    input = torch.rand(20,shape[0])
    if torch.cuda.is_available():
        input = input.cuda()
    start = time.time()
    out1 = linear1(torch.layer_norm(input,(shape[0],)))
    time1 = time1 + (time.time()-start)

# 比较耗时
print(time0,time1)

上述代码可以看出 out1 out的输出是一样的,time1 也比 time0小一些。原理上来说LayerNorm 没有weight跟bias 所以就可以少做一次tensor的乘法跟加法了

后记

在用ggml这种来实现llm时遇到这种情况构图时就会体现的特别明显

kaldi解码流程

Thu, 22 Apr 2021 01:16:48 +0000

kaldi 解码流程

前言

记录一下梳理大致kaldi解码流程

chain的模型(语音模型)

训练输出final.mdl 里面包含了两个模型一个是TransitionModel 另一个是nnet3(具体的chain)的模型

TransitionModel trans_model;
nnet3::AmNnetSimple am_nnet;
{
      bool binary;
      Input ki(nnet3_rxfilename, &binary);
      trans_model.Read(ki.Stream(), binary);
      am_nnet.Read(ki.Stream(), binary);
      SetBatchnormTestMode(true, &(am_nnet.GetNnet()));
      SetDropoutTestMode(true, &(am_nnet.GetNnet()));
      nnet3::CollapseModel(nnet3::CollapseModelConfig(), &(am_nnet.GetNnet()));
 }

上述代码可以看出加载了两种模型

TransitionModel

hmm-info final.mdl

通过hmm-info可以看到 final.mal中TransitionModel 的一些基本

hmm-info ./final.mdl 
number of phones 479 
number of pdfs 8024
number of transition-ids 60134
number of transition-states 30067

就是一些索引的范围

// List of the possible mappings TransitionModel can do:
//   (phone, HMM-state, forward-pdf-id, self-loop-pdf-id) -> transition-state
//                   (transition-state, transition-index) -> transition-id
//  Reverse mappings:
//                        transition-id -> transition-state
//                        transition-id -> transition-index
//                     transition-state -> phone
//                     transition-state -> HMM-state
//                     transition-state -> forward-pdf-id
//                     transition-state -> self-loop-pdf-id

可在transition-model.h找到上述注释，所以可以理解为TransitionModel里面是个map可以实现 phone transition-id HMM-state forward-pdf-id 相互映射(转化)

nnet3

nnet3-info final.mdl

会输出nnet3的模型结构可以看到最后输出的维度是和TransitionModel中的pdfs一样的可以理解nnet3的输出是每种pdfs的可能性（概率）

语言模型(HCLG.fst)

他是由4个模型通过。。。。而来的

G: 可以理解为语法模型但是实际上输入输出都一样都是词索引
L: 可以理解为词法模型是音到词的词法模型输入音索引输出词索引
C: 上下文状态到音索引的模型
H: HMM的释义到上下文状态的模型

fst::Fst<fst::StdArc> *decode_fst = ReadFstKaldiGeneric(fst_rxfilename);

特征提取器

将pcm语音数据转成nnet3所用的特征矩阵

OnlineNnet2FeaturePipeline feature_pipeline(feature_info);

像个管道一样输入音频输出特征

解码的大致过程

audio(pcm data)=>特征提取器=>语音模型=>语言模型=>词序列

特征提取

feature_pipeline.AcceptWaveform(samp_freq, wave_part);

具体实现 file:online-nnet2-feature-pipeline.cc

void OnlineNnet2FeaturePipeline::AcceptWaveform(
    BaseFloat sampling_rate,
    const VectorBase<BaseFloat> &waveform) {
  base_feature_->AcceptWaveform(sampling_rate, waveform);
  if (pitch_)
    pitch_->AcceptWaveform(sampling_rate, waveform);
}

主要有两部分 base_feature_ 跟 pitch(根据参数决定是否启用) base_feature_ 常见三种 OnlineNnet2FeaturePipeline构造时实现的

if (info_.feature_type == "mfcc") {
    base_feature_ = new OnlineMfcc(info_.mfcc_opts);
  } else if (info_.feature_type == "plp") {
    base_feature_ = new OnlinePlp(info_.plp_opts);
  } else if (info_.feature_type == "fbank") {
    base_feature_ = new OnlineFbank(info_.fbank_opts);
  } else {
    KALDI_ERR << "Code error: invalid feature type " << info_.feature_type;
  }

具体实现可以去看看src/feat/feature-{name}.c ps:ivector的特征就不说了

解码

decoder.AdvanceDecoding();

其实把语音语言模型的计算都包装了在一起

关键在两个类 decodable-online-looped.h 中的DecodableAmNnetLoopedOnline 用于语音模型的计算以及保存输出

lattice-faster-decoder.h 中的LatticeFasterDecoderTpl<FST, Token> 对于chain的模型 LatticeFasterDecoderTpl中是用了DecodableAmNnetLoopedOnline

decodable->LogLikelihood(frame, arc.ilabel)

decodable是DecodableAmNnetLoopedOnline的实例 LogLikelihood就是获取nnet3模型输出的对应帧数据的计算结果第一个参数代表帧索引第二个参数是TransitionId的索引

BaseFloat DecodableAmNnetLoopedOnline::LogLikelihood(int32 subsampled_frame,
                                                    int32 index) {
  subsampled_frame += frame_offset_;
  EnsureFrameIsComputed(subsampled_frame);
  return current_log_post_(
      subsampled_frame - current_log_post_subsampled_offset_,
      trans_model_.TransitionIdToPdfFast(index));
}

current_log_post_ 是个二维矩阵因为nnet3 输出的 pdfs的概率所以要先将TransitionId转成pdf的索引具体就是靠TransitionModel

其中EnsureFrameIsComputed(subsampled_frame); 是检查这帧数据是否被nnet3计算过的如果没有就计算，然后再取结果，计算过程在下面的函数中实现的

void DecodableNnetLoopedOnlineBase::AdvanceChunk()

配合HCLG.fst，由此计算出Lattice 具体实现可沿着

void LatticeFasterDecoderTpl<FST, Token>::AdvanceDecoding(DecodableInterface *decodable,
                                                int32 max_num_frames)

看进去

后续

通过Lattice找出最优解，然后转成词索引数组，接着配合词典得到句子

kaldi解码工具的使用

Tue, 13 Oct 2020 14:16:48 +0000

kaldi解码工具的使用

前言：

简单的介绍kaldi解码工具online2-wav-nnet3-latgen-faster以及online2-tcp-nnet3-decode-faster的使用
以其他人训练好的模型来测试:0011_multi_cn_chain_sp_online_v2.tar.gz

默认

{kaldi_dir} 表示你的kaldi路径

准备工作

##准备好一个编译好的kaldi环境

cd {kaldi_dir}/egs

#创建测试目录
mkdir -p test_model/s5
cd test_model/s5

#下载模型
wget http://kaldi-asr.org/models/11/0011_multi_cn_chain_sp_online_v2.tar.gz

#....等待模型下载完毕

#解压模型
tar -xf ./0011_multi_cn_chain_sp_online_v2.tar.gz

#复制一份path.sh
cp ../../multi_cn/s5/path.sh ./

#令kaldi的环境在当前shell有效
. ./path.sh

# 执行完上述后你就可以愉快在shell中使用kaldi的工具链了

看看0011_multi_cn_chain_sp_online_v2有啥

tree ./multi_cn_chain_sp_online

如下输出

./multi_cn_chain_sp_online
|-- HCLG.fst
|-- conf
|   |-- ivector_extractor.conf
|   |-- mfcc.conf
|   |-- online.conf
|   |-- online_cmvn.conf
|   `-- splice.conf
|-- final.mdl
|-- frame_subsampling_factor
|-- ivector_extractor
|   |-- final.dubm
|   |-- final.ie
|   |-- final.mat
|   |-- global_cmvn.stats
|   |-- online_cmvn.conf
|   `-- splice_opts
|-- phones.txt
|-- tree
`-- words.txt

2 directories, 17 files

重点看两个文件并改之

cat ./multi_cn_chain_sp_online/conf/online.conf

如下内容（路径对不上了）

--feature-type=mfcc
--mfcc-config=multi_cn/s5/exp/chain_cleaned/tdnn_cnn_1a_sp_online/conf/mfcc.conf
--ivector-extraction-config=multi_cn/s5/exp/chain_cleaned/tdnn_cnn_1a_sp_online/conf/ivector_extractor.conf
--endpoint.silence-phones=1:2:3:4:5:6:7:8:9:10:11:12:13:14:15

换成现在用的相对路径

file:./multi_cn_chain_sp_online/conf/online.conf

--feature-type=mfcc
--mfcc-config=multi_cn_chain_sp_online/conf/mfcc.conf
--ivector-extraction-config=multi_cn_chain_sp_online/conf/ivector_extractor.conf
--endpoint.silence-phones=1:2:3:4:5:6:7:8:9:10:11:12:13:14:15

file: ./multi_cn_chain_sp_online/conf/ivector_extractor.conf

--splice-config=./multi_cn_chain_sp_online/conf/splice.conf
--cmvn-config=./multi_cn_chain_sp_online/conf/online_cmvn.conf
--lda-matrix=./multi_cn_chain_sp_online/ivector_extractor/final.mat
--global-cmvn-stats=./multi_cn_chain_sp_online/ivector_extractor/global_cmvn.stats
--diag-ubm=./multi_cn_chain_sp_online/ivector_extractor/final.dubm
--ivector-extractor=./multi_cn_chain_sp_online/ivector_extractor/final.ie
--num-gselect=5
--min-post=0.025
--posterior-scale=0.1
--max-remembered-frames=1000
--max-count=100
--ivector-period=10

online2-wav-nnet3-latgen-faster的使用

写个脚本来测试单个wav的音频

file:test_a_wav.sh

#! /bin/sh
#
# test_a_wav.sh
# Copyright (C) 2020 xiaominfc(武汉鸣鸾信息科技有限公司) <xiaominfc@gmail.com>
#
# Distributed under terms of the MIT license.
#
if [ $# != 1 ];then
	echo "enter:"$0" <wav_file>"
	exit 1

fi
wav_file=$1
if [ ! -f ${wav_file} ];then
	echo "not such  file:"${wav_file}
	exit 1
fi

. path.sh
#模型路径
model_dir=./multi_cn_chain_sp_online

online2-wav-nnet3-latgen-faster --config=${model_dir}/conf/online.conf \
	--max-active=7000 --beam=15.0 --lattice-beam=8.0  --word-symbol-table=${model_dir}/words.txt \
	${model_dir}/final.mdl ${model_dir}/HCLG.fst "ark:echo utt1 utt1|" "scp:echo utt1 "${wav_file}"|" "ark,t:/dev/null"

# 赋权限
chmod +x ./test_a_wav.sh
# 带上一个音频文件路径执行之
./test_a_wav.sh <wav_file_path>
# 等等 就可以看到结果了

测试指定路径下的所有wav文件 file:test_dir.sh

#! /bin/sh
#
# test_dir.sh
# Copyright (C) 2020 xiaominfc(武汉鸣鸾信息科技有限公司) <xiaominfc@gmail.com>
#
# Distributed under terms of the MIT license.
#


if [ $# != 1 ];then
	echo "enter:"$0" <wavs_dir>"
	exit 1

fi
wavs_dir=$1

if [ ! -d ${wavs_dir} ];then
	echo "not such dir:"${wavs_dir}
	exit 1
fi

input_ark=./tmp_input.ark
if [ -f ${input_ark} ];then
	rm -f ${input_ark}
fi
input_wavs_scp=./tmp_wavs.scp
if [ -f ${input_wavs_scp} ];then
	rm -f ${input_wavs_scp}
fi
ls ${wavs_dir}/*.wav | while read line;
do
	name=$(basename ${line})
	name=${name%.*}
	echo ${name}" "${name} >> ${input_ark}
	echo ${name}" "${line} >> ${input_wavs_scp}
done

. path.sh
#模型路径
model_dir=./multi_cn_chain_sp_online
online2-wav-nnet3-latgen-faster --config=${model_dir}/conf/online.conf \
	--max-active=7000 --beam=15.0 --lattice-beam=8.0  --word-symbol-table=${model_dir}/words.txt \
	${model_dir}/final.mdl ${model_dir}/HCLG.fst "ark:"${input_ark} "scp:"${input_wavs_scp} "ark,t:/dev/null"

同理

# 赋权限
chmod +x ./test_dir.sh
# 带上含有音频文件路径执行之
./test_a_wav.sh <wavs_dir>
# 等等 就可以看到结果了

本身来说online2-wav-nnet3-latgen-faster是测试多个音频的我为了简化操作就写入脚本中，可以适当的修改解码参数也许会有更好的效果
参数中会带入两个输入即脚本中对应的${input_ark}以及${input_wavs_scp} 以及一个输出默认我们输出到/dev/null（你换个路径就能看到对应的输出）
${input_ark}的格式是spk2utt 就是每一行的内容为 “<说话者> <音频ID>"
${input_wavs_scp}格式对应的每一行内容为 “<音频ID> <音频路径>"
说白了就是遍历${input_ark} 得到<音频ID> 再从${input_wavs_scp}获取对应<音频路径>进而进行解码
${model_dir}/final.mdl 对应的是声音模型就是平时用kaldi进行机器学习出来的那个模型
${model_dir}/HCLG.fst 对应的是语言模型是通过大量文本统计配合词典音素表以及kaldi中定义的一种状态表通过openfst的工具链生成的一个文件
–word-symbol-table=${model_dir}/words.txt 这个是词索引表解码出来的结果是索引数组对应这样表进而得到可读性文本
其他参数可以慢慢研究

online2-tcp-nnet3-decode-faster的使用

依旧用个简单的脚本启动

file:test_server_run.sh

#! /bin/sh
#
# test_server_run.sh
# Copyright (C) 2020 xiaominfc(武汉鸣鸾信息科技有限公司) <xiaominfc@gmail.com>
#
# Distributed under terms of the MIT license.
#

#模型路径
model_dir=./multi_cn_chain_sp_online
online2-tcp-nnet3-decode-faster --config=${model_dir}/conf/online.conf \
	--max-active=7000 --beam=15.0 --lattice-beam=8.0 \
	${model_dir}/final.mdl ${model_dir}/HCLG.fst ${model_dir}/words.txt

chmod +x test_server_run.sh
#运行启动之
test_server_run.sh

新开一个终端

# <wav_file> 为音频的路径
cat <wav_file> | nc 127.0.0.1 5050

# 接着就会看到识别返回

online2-tcp-nnet3-decode-faster 提供了一个简单的TCP服务允许我们建立socket连接后，向socket写入音频流并在服务端进行识别并实时反馈回来，进而达到一个实时识别并返回的效果
上述测试对于识别过程会而外输入wav的文件头影响到真实数据的识别，实际应用只需要传输数据体，即所用测试音频文件必须是16000采样的16bit int型的单声道的pcm数据

ps:

所用测试音频文件必须是16000采样的16bit int型单声道的wav音频
若没有nc这个程序可以自行装之

2019年总结

Tue, 31 Dec 2019 08:16:48 +0000

2019年总结

2019年马上过去了，写个总结证明自己活过

工作

还是在原来的公司还是跟着原来人创业还是一样。。。。。
还是在胡搞瞎搞各种乱七八糟的项目
这一年重心在机器学习相关的认识了很多也成长了一点就算是没白过了
感觉公司的方向错了自己在瞎忙估计又是瞎忙的一年

能力

人又要老一岁，心不服老，还是在让自己多看点乱七八糟的技术书籍
比较深入的接触了kaldi 深究源码一探究竟
搞了各种乱七八糟的深度学习的模型
继续维护自己fork出来的teamtalk 加了些许功能
闲暇用dart实现teamtalk的客户端API 用flutter实现了个测试客户端
搞了个TTS 感觉公司没啥实际应用的地方然后就算了吧
接触了很多人帮他们答疑了很多
无聊的时候还是会练习各种编程语言
逼着自己尽量用vim

个人

缺钱
缺钱
缺钱
缺钱
要多努力要多加油要多学习

结语

2020年加油！

teamtalk实现给指定用户或者群发送消息的http接口

Thu, 19 Dec 2019 10:26:48 +0000

teamtalk实现给指定用户或者群发送消息的http接口

应用场景

后台推送消息
第三方对接接口
系统消息

基本流程

只是说个大概可以继续改进以便支持更好用起来更方便

http_msg_server => db_proxy_server
db_proxy_server => http_msg_server
http_msg_server => route_server
route_server => msg_server

原理很简单 只是把原来msg_server的角色换成了 http_msg_server 
过程一样 包装一个IMMsgData

实现(最简实现)

1 http_msg_server复用加密操作

httpmsgserver.conf

# add aes_key
aesKey=12345678901234567890123456789012

http 请求数据体通常是明文字符串或者其他我们都得格式化成msg_server类似的格式所以发送的消息内容是要加密的所以上面我们饮用了类似的方式配置加密密钥

2 加密实例

file:http_msg_server.cpp

char* str_aes_key = config_file.GetConfigName("aesKey");
if (!str_aes_key || strlen(str_aes_key)!=32) {
	log("aes key is invalied");
	return -1;
}
pAes = new CAes(str_aes_key);

3 声明

file:HttpQuery.h

// add private methods to class CHttpQuery
	static void _SendMessage(const string& strAppKey,Json::Value& post_json_obj, CHttpConn* pHttpConn,int msg_type);
		static void _SendSingleMessage(const string& strAppKey,Json::Value& post_json_obj, CHttpConn* pHttpConn);
		static void _SendGroupMessage(const string& strAppKey,Json::Value& post_json_obj, CHttpConn* pHttpConn);

// add end

4 实现

file:HttpQuery.cpp

void CHttpQuery::_SendMessage(const string& strAppKey,Json::Value& post_json_obj, CHttpConn* pHttpConn,int msg_type)
{
	HTTP::CDBServConn *pConn = HTTP::get_db_serv_conn();
	if (!pConn) {
		log("no connection to MsgServConn ");
		char* response_buf = PackSendResult(HTTP_ERROR_SERVER_EXCEPTION, HTTP_ERROR_MSG[9].c_str());
		pHttpConn->Send(response_buf, (uint32_t)strlen(response_buf));
		pHttpConn->Close();
		return;
	}

	if(checkValueIsNullForJson(post_json_obj, "from_user_id") ||
			checkValueIsNullForJson(post_json_obj, "session_id")   ||
			//checkValueIsNullForJson(post_json_obj, "create_time")  ||
			checkValueIsNullForJson(post_json_obj, "msg") ) {
		char* response_buf = PackSendResult(HTTP_ERROR_PARMENT, HTTP_ERROR_MSG[1].c_str());
		pHttpConn->Send(response_buf, (uint32_t)strlen(response_buf));
		pHttpConn->Close();
		return;
	}

	try
	{
		uint32_t user_id = post_json_obj["from_user_id"].asUInt();
		uint32_t to_id = post_json_obj["to_user_id"].asUInt();
		uint32_t create_time = time(NULL);
		string msgContent;
		if(post_json_obj["msg"].isString())
		{
			msgContent = post_json_obj["msg"].asString();
		}else if(post_json_obj["msg"].isObject())
		{
			msgContent = post_json_obj["msg"].toStyledString();
		}   
		char* msg_out = NULL;
		uint32_t msg_out_len = 0;
		if(pAes->Encrypt(msgContent.c_str(),msgContent.length(),&msg_out,msg_out_len) == 0)
		{
			msgContent = string(msg_out, msg_out_len);
		}
		pAes->Free(msg_out);

		CDbAttachData attach_data(ATTACH_TYPE_HANDLE, pHttpConn->GetConnHandle());
		IM::Message::IMMsgData msg;
		msg.set_from_user_id(user_id);
		msg.set_to_session_id(to_id);
		msg.set_msg_data(msgContent);
		msg.set_msg_id(1);
		msg.set_msg_type((IM::BaseDefine::MsgType)msg_type);
		msg.set_create_time(create_time);
		msg.set_attach_data(attach_data.GetBuffer(), attach_data.GetLength());
		CImPdu pdu;
		pdu.SetPBMsg(&msg);
		pdu.SetSeqNum(pHttpConn->GetConnHandle());
		pdu.SetServiceId(IM::BaseDefine::SID_MSG);
		pdu.SetCommandId(IM::BaseDefine::CID_MSG_DATA);
		pConn->SendPdu(&pdu);
	}
	catch (std::runtime_error msg)
	{
		log("parse json data failed.");
		char* response_buf = PackSendResult(HTTP_ERROR_PARMENT, HTTP_ERROR_MSG[1].c_str());
		pHttpConn->Send(response_buf, (uint32_t)strlen(response_buf));
		pHttpConn->Close();
	} 

}

void CHttpQuery::_SendSingleMessage(const string& strAppKey,Json::Value& post_json_obj, CHttpConn* pHttpConn)
{
	_SendMessage(strAppKey,post_json_obj,pHttpConn,IM::BaseDefine::MSG_TYPE_SINGLE_TEXT);
}



void CHttpQuery::_SendGroupMessage(const string& strAppKey,Json::Value& post_json_obj, CHttpConn* pHttpConn)
{
	_SendMessage(strAppKey,post_json_obj,pHttpConn,IM::BaseDefine::MSG_TYPE_GROUP_TEXT);
}

db写入成功后转发route_server 让route_server分发到msg_server进而发到客户端

class:DBServConn

// new method

void CDBServConn::_HandleMsgClient(CImPdu *pPdu)
{

    IM::Message::IMMsgData msg;
    CHECK_PB_PARSE_MSG(msg.ParseFromArray(pPdu->GetBodyData(), pPdu->GetBodyLength()));
    CRouteServConn* pRouteConn = get_route_serv_conn();
    if (pRouteConn) {
        pRouteConn->SendPdu(pPdu);
    }

    uint32_t msg_id = 0;
    if(msg.has_msg_id())
    {
       msg_id = msg.msg_id();
    }

    CDbAttachData attach_data((uchar_t*)msg.attach_data().c_str(), msg.attach_data().length());
    uint32_t http_handle = attach_data.GetHandle();
    CHttpConn* pHttpConn = FindHttpConnByHandle(http_handle);
    if(!pHttpConn)
    {
        log("no http connection");
        return;
    }

    const int bufferSize = 4096;
    char response_buf[bufferSize] = {0};
    uint32_t outSize = PackSendResult(HTTP_ERROR_SUCCESS, HTTP_ERROR_MSG[0].c_str(),msg_id, response_buf , bufferSize);

    pHttpConn->Send(response_buf, outSize);
    pHttpConn->Close();
}

结语：具体实现可以看我github上维护的分支

https://github.com/xiaominfc/TeamTalk

C/C++实现Python音频处理库librosa中melspectrogram的计算

Wed, 30 Oct 2019 02:26:48 +0000

C/C++实现Python音频处理库librosa中melspectrogram的计算

前言

为何这般无聊！

神经网络模型用了python实现 需移植到C/C++上
不想引入python的依赖库来运行python代码
C/C++没找到相关实现
生活不易

探索

阅读了librosa.feature.melspectrogram的源码发现其实这一整个过程都是用python的numpy计算库完成的于是提取于是进行了整理归总如下：

file:melspectrogram_util.py

import numpy as np
from numpy.lib.stride_tricks import as_strided
MAX_MEM_BLOCK = 2**8 * 2**10

### hann window

def _len_guards(M):
    if int(M) != M or M < 0:
        raise ValueError('Window length M must be a non-negative integer')
    return M <= 1


def _extend(M, sym):
    if not sym:
        return M + 1, True
    else:
        return M, False


def _truncate(w, needed):
    if needed:
        return w[:-1]
    else:
        return w



def general_cosine(M, a, sym=True):
    if _len_guards(M):
        return np.ones(M)
    M, needs_trunc = _extend(M, sym)
    fac = np.linspace(-np.pi, np.pi, M)
    w = np.zeros(M)
    for k in range(len(a)):
        w += a[k] * np.cos(k * fac)

    return _truncate(w, needs_trunc)


def general_hamming(M, alpha, sym=True):
    return general_cosine(M, [alpha, 1. - alpha], sym)


def hann(M, sym=True):
    return general_cosine(M, [0.5, 0.5], sym)
    #return general_hamming(M, 0.5, sym)


#### end window



#### filters
def fft_frequencies(sr=22050, n_fft=2048):

    return np.linspace(0,
                       float(sr) / 2,
                       int(1 + n_fft//2),
                       endpoint=True)

def hz_to_mel(frequencies, htk=False):
    frequencies = np.asanyarray(frequencies)
    if htk:
        return 2595.0 * np.log10(1.0 + frequencies / 700.0)

    # Fill in the linear part
    f_min = 0.0
    f_sp = 200.0 / 3

    mels = (frequencies - f_min) / f_sp

    # Fill in the log-scale part

    min_log_hz = 1000.0                         # beginning of log region (Hz)
    min_log_mel = (min_log_hz - f_min) / f_sp   # same (Mels)
    logstep = np.log(6.4) / 27.0                # step size for log region

    if frequencies.ndim:
        # If we have array data, vectorize
        log_t = (frequencies >= min_log_hz)
        mels[log_t] = min_log_mel + np.log(frequencies[log_t]/min_log_hz) / logstep
    elif frequencies >= min_log_hz:
        # If we have scalar data, heck directly
        mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep

    return mels

def mel_to_hz(mels, htk=False):
    mels = np.asanyarray(mels)
    if htk:
        return 700.0 * (10.0**(mels / 2595.0) - 1.0)

    # Fill in the linear scale
    f_min = 0.0
    f_sp = 200.0 / 3
    freqs = f_min + f_sp * mels
    min_log_hz = 1000.0                         # beginning of log region (Hz)
    min_log_mel = (min_log_hz - f_min) / f_sp   # same (Mels)
    logstep = np.log(6.4) / 27.0                # step size for log region

    if mels.ndim:
        # If we have vector data, vectorize
        log_t = (mels >= min_log_mel)
        freqs[log_t] = min_log_hz * np.exp(logstep * (mels[log_t] - min_log_mel))
    elif mels >= min_log_mel:
        # If we have scalar data, check directly
        freqs = min_log_hz * np.exp(logstep * (mels - min_log_mel))

    return freqs

def mel_frequencies(n_mels=128, fmin=0.0, fmax=11025.0, htk=False):
    min_mel = hz_to_mel(fmin, htk=htk)
    max_mel = hz_to_mel(fmax, htk=htk)
    mels = np.linspace(min_mel, max_mel, n_mels)
    return mel_to_hz(mels, htk=htk)


def filters_mel(sr, n_fft, n_mels=128, fmin=0.0, fmax=None, htk=False,
        norm=1):
    if fmax is None:
        fmax = float(sr) / 2

    if norm is not None and norm != 1 and norm != np.inf:
        raise ParameterError('Unsupported norm: {}'.format(repr(norm)))

    # Initialize the weights
    n_mels = int(n_mels)
    weights = np.zeros((n_mels, int(1 + n_fft // 2)))
    fftfreqs = fft_frequencies(sr=sr, n_fft=n_fft)
    mel_f = mel_frequencies(n_mels + 2, fmin=fmin, fmax=fmax, htk=htk)
    fdiff = np.diff(mel_f)
    ramps = np.subtract.outer(mel_f, fftfreqs)
    
    for i in range(n_mels):
        lower = -ramps[i] / fdiff[i]
        upper = ramps[i+2] / fdiff[i+1]
        weights[i] = np.maximum(0, np.minimum(lower, upper))

    if norm == 1:
        # Slaney-style mel is scaled to be approx constant energy per channel
        enorm = 2.0 / (mel_f[2:n_mels+2] - mel_f[:n_mels])
        weights *= enorm[:, np.newaxis]

    return weights

#### end filters


def frame(x, frame_length=2048, hop_length=512, axis=-1):
    n_frames = 1 + (x.shape[axis] - frame_length) // hop_length
    strides = np.asarray(x.strides)
    new_stride = np.prod(strides[strides > 0] // x.itemsize) * x.itemsize
    shape = list(x.shape)[:-1] + [frame_length, n_frames]
    strides = list(strides) + [hop_length * new_stride]
    result = as_strided(x, shape=shape, strides=strides)
    return result



def pad_center(data, size, axis=-1, **kwargs):
    kwargs.setdefault('mode', 'constant')

    n = data.shape[axis]
    lpad = int((size - n) // 2)
    lengths = [(0, 0)] * data.ndim
    lengths[axis] = (lpad, int(size - n - lpad))

    if lpad < 0:
        raise ParameterError(('Target size ({:d}) must be '
                              'at least input size ({:d})').format(size, n))

    return np.pad(data, lengths, **kwargs)




# fft

def stft(y, n_fft=2048, hop_length=None, win_length=None, window='hann',
         center=True, dtype=np.complex64, pad_mode='reflect'):
    if win_length is None:
        win_length = n_fft
    if hop_length is None:
        hop_length = int(win_length // 4)
    fft_window = hann(win_length,sym=False)
    fft_window = pad_center(fft_window, n_fft)
    fft_window = fft_window.reshape((-1, 1))
    if center:
        y = np.pad(y, int(n_fft // 2), mode=pad_mode) # 两边各补n_fft的一半 对称

    
    y_frames = frame(y, frame_length=n_fft, hop_length=hop_length) 
    stft_matrix = np.empty((int(1 + n_fft // 2), y_frames.shape[1]),
                           dtype=dtype,
                           order='F')
    fft = np.fft
    n_columns = int(MAX_MEM_BLOCK / (stft_matrix.shape[0] *
                                          stft_matrix.itemsize))
    for bl_s in range(0, stft_matrix.shape[1], n_columns):
        bl_t = min(bl_s + n_columns, stft_matrix.shape[1])
        data = y_frames[:, bl_s:bl_t] *fft_window
        stft_matrix[:, bl_s:bl_t] = fft.rfft(fft_window *
                                             y_frames[:, bl_s:bl_t],
                                             axis=0)
    return stft_matrix


def melspectrogram(y=None, sr=22050, S=None, n_fft=2048, hop_length=512,power=2.0, **kwargs):
    S = stft(y,n_fft=1024,hop_length=hop_length)
    S = np.abs(S)**power
    mel_basis = filters_mel(sr,n_fft=n_fft,**kwargs)
    return np.dot(mel_basis, S)


if __name__ == '__main__':
    import librosa
    #y, sr = librosa.load('./5016672465406.wav',sr=None)
    y, sr = librosa.load('./6983123609037.wav',sr=None)
    n_fft = 1024
    mels = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=80,fmax=8000,n_fft=n_fft)
    print(mels.T)
    print("=============")
    print(melspectrogram(y,sr=sr,n_fft=n_fft,n_mels=80,fmax=8000).T)

这里面有些我用默认的所以去掉了些多余代码
写到这里以后python计算melspectrogram 以后就不再依赖librosa 而只依赖numpy了
大致可以看到它的实现 window=>frame=>fft=>mel_basis

C/C++的实现

1. window(加窗)

//hanning窗
void hanning_w(int frame_length,Vector<double64>& window) {
	window.Resize(frame_length);
	double PI = 3.141592653589793;
	double PI_2 = PI * 2.0;
	double a = PI_2 / (frame_length);
	//printf("a:%.10lf\n",a);
	for (int32 i = 0; i < frame_length; i++) {
		double i_fl = static_cast<double>(i);
		window(i) = 0.5  - 0.5*cos(a * i_fl);
	}
}

// 指定长度用等步长就能求了

2.数据分帧

//数据分帧
void frame_data(Vector<double64> &data,int frame_length,int hop_length, Matrix<double64> &frames){
	int n_frames = (data.Dim() - frame_length ) / hop_length + 1;
	frames.Resize(frame_length,n_frames);
	for(int i=0; i < frame_length; i ++) {
		for(int j = 0; j < n_frames; j ++) {
			int index = i + j * hop_length;
			if(index < data.Dim()) {
				frames(i,j) = data.Data()[index]; 
			}else {
				printf("index to large:%d\n",index);
			}
		}
	}
}

// 帧长 步长 数据长度 就能计算 帧总数 按步长取值填入

3.fft

进行fft之前先要对frames跟window做乘法运算在进行快速傅立叶变换

frames.MulRowsVec(window);
Matrix<double64> fft_result;
fft_result.Resize(half_n_fft + 1,frames.NumCols());
complex *pSignal = new complex[frames.NumRows()];
for(int i = 0; i < frames.NumCols(); i ++) {
	for(int j = 0; j < frames.NumRows();j++) {
		pSignal[j] = frames(j,i);
	}
	CFFT::Forward(pSignal,n_fft);
	for(int j = 0; j < fft_result.NumRows(); j ++) {
		double v = sqrt(pSignal[j].re()*pSignal[j].re()+pSignal[j].im()*pSignal[j].im());
		fft_result(j,i) = pow(v,2.0);//power的值 默认2.0 用在这个地方 其实直接前面一步不开方就是结果了
	}
}
//在numpy中 用的是rfft 这样的结果就是 正常fft结果的一半+1个数据

4. 计算mel_basis

double hz_to_mel(double frequencies){
	double mels = (frequencies - MIN_F) / FSP;
	if(frequencies >= MIN_LOG_HZ) {
	  mels = (MIN_LOG_HZ - MIN_F)/FSP + log(frequencies / MIN_LOG_HZ) / LOG_STEP;
	}
	return mels;
}

double mel_to_hz(double mels) {
	double freqs = MIN_F + FSP * mels;
	if(mels >= MIN_LOG_MEL) {
		freqs = MIN_LOG_HZ * exp(LOG_STEP * (mels - MIN_LOG_MEL));
	}
	return freqs;
}

//mel 单元
void filters_mel(float sr,uint n_fft,uint n_mels,float fmin,float fmax, Matrix<double64> &mel_basis) {
	if(fmax == 0.0) {
		fmax = sr / 2.0;
	}
	uint rows = 1+n_fft/2;
	mel_basis.Resize(n_mels,rows);
	// gen mel_frequencies
	double min_mel = hz_to_mel(fmin);
	double max_mel = hz_to_mel(fmax);
	Vector<double64> mels;
	mels.Resize(n_mels + 2);
	double offset_mel = (max_mel - min_mel)/(n_mels + 1);
	double offset_hz = sr/n_fft; 
	mels(0) = mel_to_hz(min_mel);
	mels(1) = mel_to_hz(min_mel + offset_mel);
	mels(mels.Dim() - 1) = mel_to_hz(max_mel);
	for(int i = 2; i < mels.Dim(); i ++) {
		double down_hz= mels(i - 2);
		double up_hz = mel_to_hz(min_mel + offset_mel*i);
		mels(i) = up_hz;
		for(int j = 0; j < rows; j++ ) {
			double lower = -1.0 * (down_hz - offset_hz*j) / (mels(i-1)-down_hz);
			double upper = (up_hz -offset_hz*j) / (up_hz - mels(i-1));
			double min  = lower < upper? lower:upper;
			min = min > 0?min:0.0;
      		mel_basis(i-2,j) = min*2.0/ (up_hz-down_hz);
		}
	}
}

/*
前两个函数是辅助计算 频率跟梅谱之间的转换
filters_mel 生成结构
*/

5. 计算结果

result.Resize(fft_result.NumCols(),mel_basis.NumRows());
for(int i = 0; i < result.NumRows(); i ++) {
	for(int j = 0; j < result.NumCols(); j ++) {
		double sum = 0;
		for(int index = 0; index < half_n_fft + 1; index++ ){
			sum += fft_result(index,i)*mel_basis(j,index);
		}
		result(i,j) = sum;
	}
}
// 就是做一次矩阵相乘

以上就是计算过程

尾声

按照上述过程还能类似实现librosa的一些别的特征求值过程如：librosa.feature.mfcc 其实就是在此基础上实现的

代码上传到了github上

docker mysql 主从同步（一主多备）

Fri, 18 Oct 2019 02:26:48 +0000

docker mysql 主从同步（一主多备）

获取mysql的docker镜像

镜像地址:[https://hub.docker.com//mysql](https://hub.docker.com//mysql)

docker pull mysql:tag
#docker pull mysql:5.7

主库的建立启动脚本(master)

#! /bin/sh

cur_dir=$(pwd)

name=master
port=13306

data_dir=data_${name}

if [ ! -d ${data_dir} ] ; then
  mkdir -p ./${data_dir}
fi

conf_dir=${name}_mysql_conf

if [ ! -d ${conf_dir} ] ; then
  mkdir -p ./${conf_dir}
fi


mount_data_dir=${cur_dir}/${data_dir}
config_data_dir=${cur_dir}/${conf_dir}

docker run --name ${name}-mysql -v ${mount_data_dir}:/var/lib/mysql -v ${config_data_dir}:/etc/mysql/conf.d  -p ${port}:3306  -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7

启动之

进入容器连上mysql

docker exec -it master-mysql /bin/bash 
mysql -uroot -p123456

添加从库操作用户

GRANT REPLICATION SLAVE,REPLICATION CLIENT ON *.* TO repl@'172.17.0.%' IDENTIFIED BY '123456';

#退出mysql
ctrl+D
#退出容器
exit

记下这里的操作用户名:repl 以及密码:123456

编辑 mysql-master 配置

vi ./master_mysql_conf/master.cnf

[master.cnf]

[mysqld]
log_bin = mysql-bin
server_id = 10

重启master-mysql

docker restart master-mysql

ps 查看状态（进入master mysql用下列语句查看）

SHOW MASTER STATUS;

备库的建立启动脚本(slave)

类似master的脚本(换个name跟port)

#! /bin/sh

cur_dir=$(pwd)

name=slave
port=13308

data_dir=data_${name}

if [ ! -d ${data_dir} ] ; then
  mkdir -p ./${data_dir}
fi

conf_dir=${name}_mysql_conf

if [ ! -d ${conf_dir} ] ; then
  mkdir -p ./${conf_dir}
fi


mount_data_dir=${cur_dir}/${data_dir}
config_data_dir=${cur_dir}/${conf_dir}

docker run --name ${name}-mysql -v ${mount_data_dir}:/var/lib/mysql -v ${config_data_dir}:/etc/mysql/conf.d  -p ${port}:3306  -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7

启动之

添加从库配置

vi ./slave_mysql_conf/slave.cnf

slave.cnf

[mysqld]
log_bin   = mysql-bin
server_id = 2
relay_log = /var/lib/mysql/mysql-relay-bin
log_slave_updates = 1
#只读模式 只从master读数据过来
read_only = 1

重启slave 连接mysql

docker restart slave-mysql
docker exec -it slave-mysql /bin/bash 
mysql -uroot -p123456

启动同步

CHANGE MASTER TO MASTER_HOST='172.17.0.2',
MASTER_USER='repl',
MASTER_PASSWORD='123456',
MASTER_LOG_FILE='mysql-bin.000001',
MASTER_LOG_POS=0;


#开始同步
START SLAVE;

MASTER_USER:前面写的操作用户 repl
MASTER_PASSWORD:前面写的操作用户的密码 123456
MASTER_LOG_FILE: 默认尾缀应该是000001
MASTER_LOG_POS: 写0 就是从头开始 写master的status显示的值就是从此刻开始

ps

MASTER_HOST 可以通过docker 查看 master-mysql的docker ip 我的是172.17.0.2 故而写172.17.0.2

可以尝试在主库里写入看看效果了哦

重复上述slave相关的步骤即可生成多个备份

基于Tacotron模型实现中文语音合成

Tue, 23 Apr 2019 02:26:48 +0000

#基于Tacotron模型实现中文语音合成

1.数据准备

1.1 单个女生语音数据10000句

# https://www.data-baker.com/open_source.html
mkdir tts_tacotron
cd tts_tacotron
wget "https://weixinxcxdb.oss-cn-beijing.aliyuncs.com/gwYinPinKu/BZNSYP.rar"
# 解压之

./BZNSYP
├── PhoneLabeling
├── ProsodyLabeling
└── Wave

1.1.1 标注(ProsodyLabeling/000001-010000.txt)

head ProsodyLabeling/000001-010000.txt

000001	卡尔普#2陪外孙#1玩滑梯#4。
	ka2 er2 pu3 pei2 wai4 sun1 wan2 hua2 ti1
000002	假语村言#2别再#1拥抱我#4。
	jia2 yu3 cun1 yan2 bie2 zai4 yong1 bao4 wo3
000003	宝马#1配挂#1跛骡鞍#3，貂蝉#1怨枕#2董翁榻#4。
	bao2 ma3 pei4 gua4 bo3 luo2 an1 diao1 chan2 yuan4 zhen3 dong3 weng1 ta4
000004	邓小平#2与#1撒切尔#2会晤#4。
	deng4 xiao3 ping2 yu3 sa4 qie4 er3 hui4 wu4
000005	老虎#1幼崽#2与#1宠物犬#1玩耍#4。
	lao2 hu3 you4 zai3 yu2 chong3 wu4 quan3 wan2 shua3

1.1.2 语音(Wave/*.wav)

ls Wave | head
000001.wav
000002.wav
000003.wav
000004.wav
000005.wav
000006.wav
000007.wav
000008.wav
000009.wav
000010.wav

1.2 中文字典素材的准备

# DaCiDian (https://github.com/aishell-foundation/DaCiDian)
这是我在kaldi项目接触到的 一个比较不错的词典 用于分词以及拼音的标注
这里不说准备的过程了 到时候直接用转化好的

2 模型的准备

# tocotron模型的实现(https://github.com/keithito/tacotron)
git clone https://github.com/keithito/tacotron.git

# 这是个默认合成英文的模型，有空可以试试，效果还行作者也提供了训练好的模型测试

2.1 关于中文合成的相关修改

2.1.1 输入特征的相关准备

我们这里的思路是把一个句子 用拼音标注好以后 再通过拼音转声母韵母的字典转成声母韵母的序列

# file: text/symbols.py 追加

_phones_f = open(os.path.split(os.path.realpath(__file__))[0] + '/zh_lang/phones','r');
_phones = []

_line = _phones_f.readline()
while _line:
    _line = _line.strip();
    _phones.append(_line)
    _line = _phones_f.readline()

_phones_f.close();
pinyin_symbols = [_pad, _eos] + _phones;
symbols=pinyin_symbols

# 上述文件会在我上传的代码中 这样符号表就建立好了

多写了个文件把分词的语句转拼音做合成的时候要用

# file: text/pinyinconvert.py

"""

"""

import os

wordsDict = {}
_align_f = open(os.path.split(os.path.realpath(__file__))[0] + '/zh_lang/align_lexicon.txt','r')
_line = _align_f.readline()
while _line:
    _line = _line.strip();
    _parts = _line.split('\t')
    if len(_parts) == 2 and _parts[0] not in wordsDict:
        wordsDict[_parts[0]] = _parts[1]
    _line = _align_f.readline()


def sentence_to_pinyin(sentence):
    parts = sentence.split(' ')
    text = ""
    for i in range(0, len(parts)):
        word = parts[i]
        if word in wordsDict:
            if len(text) > 0:
                text = text + ' '
            text = text + wordsDict[word]
    return text

2.2.2 数据集的预处理

在dataset中多加入一种新的数据集处理方式

# file: datasets/bznsyp.py

from concurrent.futures import ProcessPoolExecutor
from functools import partial
import numpy as np
import os
from util import audio
from text.pinyinconvert import sentence_to_pinyin
from text.symbols import pinyin_dict


# 声母韵母化bznsyp中的拼音 对一些做特殊处理
def _format_pinyin(value):
    if len(value) == 1:
        return value.lower()

    if value == 'IY1':
        return 'i_1'
    key = value[:-1]
    end = value[-1]
    if key in pinyin_dict:
        fpinyin = pinyin_dict[key]
        if end == '5':
            end = '0'
        fpinyin = fpinyin + '_' + end
        return fpinyin
    elif key[-1] == 'r':
        return _format_pinyin(key[:-1] + end) + ' er_0'
    else :
        print('not',value)





# 声母韵母化拼音
def _convet_pinyin(label):
    parts = label.split(' ')
    #print(parts)
    text = ''
    for value in parts:
        if len(text) > 0:
            text = text + ' '
        text = text + _format_pinyin(value)
    return text


def build_from_path(in_dir, out_dir, num_workers=1, tqdm=lambda x: x):
    executor = ProcessPoolExecutor(max_workers=num_workers)
    futures = []
    #text_dict = _load_dict(os.path.join(in_dir,'text'))
    f = open(os.path.join(in_dir,'ProsodyLabeling/000001-010000.txt'), encoding='utf-8')
    line = f.readline()
    while line:
        parts = line.strip('\n').split('\t')
        line = f.readline()
        name = parts[0]
        label = line.strip()
        text = _convet_pinyin(label)
        wav_path = os.path.join(in_dir,'Wave/' + name + '.wav')
        #print(name,"  ",wav_path);
        futures.append(executor.submit(partial(_process_utterance, out_dir, name, wav_path, text)))
        line = f.readline()
    f.close()
    return [future.result() for future in tqdm(futures)]




def _process_utterance(out_dir, name, wav_path, text):
    wav = audio.load_wav(wav_path)
    spectrogram = audio.spectrogram(wav).astype(np.float32)
    n_frames = spectrogram.shape[1]
    mel_spectrogram = audio.melspectrogram(wav).astype(np.float32)
    spectrogram_filename = 'bznsyp-spec-%s.npy' % name
    mel_filename = 'bznsyp-mel-%s.npy' % name
    np.save(os.path.join(out_dir, spectrogram_filename), spectrogram.T, allow_pickle=False)
    np.save(os.path.join(out_dir, mel_filename), mel_spectrogram.T, allow_pickle=False)
    #text = sentence_to_pinyin(text)
    return (spectrogram_filename, mel_filename, n_frames, text)

file: preprocess.py

# 添加处理函数
def preprocess_bznsyp(args):
  in_dir = '/mnt/ml_data/download/BZNSYP' #数据所在路径 写死省事 记得改成你自己的
  out_dir = os.path.join(args.base_dir, args.output)
  os.makedirs(out_dir, exist_ok=True)
  metadata = bznsyp.build_from_path(in_dir, out_dir, args.num_workers, tqdm=tqdm)
  write_metadata(metadata, out_dir)


# 类似ljspeech 添加相应的到main函数 使之生效

这个样子代码基本就准备完成了然后参考README 执行相应的过程来训练

# 数据预处理

python3 preprocess.py --dataset bznsyp 
# 等进度完成

python3 train.py

# 等!!!!!!

# 或者

nohup  python3 train.py &

# 等!!!!!
# 默认~/tacotron/logs-tacotron 每1000步就会保存一次训练的模型

python3 demo_server.py --checkpoint {model_path}

# 1. 访问http://127.0.0.1:9000 
# 2. 先输入 分好词的中文语句 点击convert 转成声母韵母序列 
# 3. 点击 Speak 等一下 就有结果了(有点麻烦不过是为了有再次矫正拼音的机会)
# 4. 可以听到声音了

感谢你的阅读下面是我改的源码

https://github.com/xiaominfc/tacotron

aishell2 几点说明

Tue, 25 Sep 2018 02:26:48 +0000

数据的准备

1.语音数据文件的结构

三个文件夹 train dev test
每个文件下都含有trans.txt 与 wav.scp 以及音频文件(具体音频的上级路径至少是根基不同的录制者区分的)
tran.txt 是"filename" + tab + "标注的文本(不用分词)"
wav.scp 是"音频文件名(无后缀)" + tab + "音频相对路径"

2.字典的生成

1.克隆代码:https://github.com/aishell-foundation/DaCiDian.git
2.word_to_pinyin.txt pinyin_to_phone.txt 生成 word_to_phone(lexicon.txt) 就是词到音素的字典

3.分词

1. 安装jieba分词
2. 以lexicon.txt里的词生成jieba分词用的词典(vocab.txt)

语言模型

基于分好词的文本 就可以训练出来

gmm 训练

1.提取train dev test数据集的mfcc特征
2.会把train的数据分出两部分出来，100k（10万条语句）以及 300k(30万条语句)

1 mono train

1. 这里会用前面分出来的100k条语句训练
2. 训练出的mono会用来对齐300k的数据集

2 tri1 train

1. 这里用300k条语句的train集来训练
2. 训练出来的结果用来对齐所用的train数据集

3 tri2 train

在tri1对齐后的结果上调整参数训练

4 tri3 train

同tri2理

tdnn train

配置

num_jobs_initial num_jobs_final 根据 GPU的个数决定 都不能超过GPU的个数
GPU 个数不多的情况下steps/nnet3/chain/train.py 带上--use-gpu=wait的参数进行训练
conf下会缺个online_cmvn.conf文件要补充 即使没内容也可以

补充

1. 可以根据我前面的说格式添加训练的数据集
2. 如果训练的数据集条数小于300k时 需要修改local/run_gmm.sh

修改./local/word_segmentation.py

按字典的词来分词不要生成新的词，这样训练出来的模型错误率可以减少0.5%

#words = jieba.cut(trans)
words = jieba.cut(trans, HMM=False)

初步分析：

对于未在字典里词 会处理成UNK,用不生成新词方式话，可以减少UNK的出现。训练的文本模型会更好些，同时转成音素时也会更加完整。

chain的识别

1.生成识别用的配置文件

./steps/online/nnet3/prepare_online_decoding.sh data/lang_chain exp/chain/extractor_all exp/chain/tdnn_1b_all_sp exp/chain/nnet_online

编辑exp/chain/nnet_online/conf/mfcc.conf 追加

--num-mel-bins=40        # similar to Google's setup.
--num-ceps=40            # there is no dimensionality reduction.
--low-freq=20            # low cutoff frequency for mel bins
--high-freq=-400         # high cutoff frequency, relative to Nyquist of 8000 (=7600)

编辑exp/chain/nnet_online/conf/online.conf 追加

--add-pitch=true

2.写个方便识别的脚本

#! /bin/sh
#
# test_online_decode.sh
# Copyright (C) 2018 xiaominfc <xiaominfc@xiaominfc-MBP.local>
#
# Distributed under terms of the MIT license.
#


. ./path.sh
. ./cmd.sh


exp_dir={tdnn_1b_all_sp path}

audio_dir=./audios
decode_dir="./work"
mkdir -p $decode_dir



> $decode_dir/input.scp_t
> $decode_dir/usp.scp_t

config_file=exp/chain/nnet_online/conf/online.conf



verbose=1

for f in $audio_dir/*.wav; do
    bf=`basename $f`
    bf=${bf%.wav}
    echo $bf $f >> $decode_dir/input.scp_t
    echo $bf $bf >> $decode_dir/usp.scp_t
done


cat $decode_dir/input.scp_t | sort -n > $decode_dir/input.scp
cat $decode_dir/usp.scp_t | sort -n  > $decode_dir/usp.scp

#ivconfig=exp/nnet3/ivectors_train_sp/conf/ivector_extractor.conf

online2-wav-nnet3-latgen-faster --verbose=$verbose  --config=$config_file  --frames-per-chunk=20 --extra-left-context-initial=0 \
    --min-active=1000 --frame-subsampling-factor=3 --do-endpointing=true  --max-active=7000 --beam=15.0 --lattice-beam=8.0 \
    --online=false --acoustic-scale=1.4  \
    --word-symbol-table=$exp_dir/graph/words.txt \
    $exp_dir/final.mdl $exp_dir/graph/HCLG.fst "ark:$decode_dir/usp.scp" "scp:$decode_dir/input.scp" "ark:/dev/null"

修改exp_dir成你的
mkdir audios
放入你的音频文件到audios里
执行脚本就可以识别了

aishell 拓展数据训练

Sun, 02 Sep 2018 02:26:48 +0000

aishell 拓展数据训练

kaldi 上的aishell s5的例子 有含178小时的训练数据，作出相应的修改是可以运行出模型来的，但是识别效果不是那么好，
所以做了些工作来拓展训练的数据 

aishell需要的数据格式

1 音频

根据说话者建目录同一个录音的人士把他的音频文件都是放在同一个目录下的

2 标注

aishell 的标注比较简单都写在transcript/aishell_transcript_v0.8.txt里了格式 filename(不含后缀)空格加上分好词的句子

其他数据源

也是来自openslr

Free ST Chinese Mandarin CorpusSLR38

Primewords Chinese Corpus Set 1SLR47

准备

1 分词代码:

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2018 xiaominfc <xiaominfc@xiaominfc-MBP.local>
#
# Distributed under terms of the MIT license.

"""
convert sentece to wrods and mark pingyin
"""


import os
import os.path


class LexiconDict:
    def __init__(self,path):
        self.dict = {}
        with open(path,'r') as f:
            for line in f:
                line = line.replace('\n','')
                words = line.split(' ')
                self.dict[words[0]] = ' '.join(words[1:])

    def findKey(self, key):
        return key in self.dict

    def markerForKey(self,key):
        return self.dict[key]





class SentenceToken:

    def __init__(self, lexicon):
        self.lexicon = lexicon

    def cut(self, sentence,result):
        offset = 1
        max_len = len(sentence)
        while(self.lexicon.findKey(sentence[:offset])):
            offset = offset + 1
            if offset > max_len:
                break;
        sub = sentence[:offset-1]
        if len(sub) > 0:
            result['words'].append(sub)
            result['phones'].append(self.lexicon.markerForKey(sub))
        else:
            return
        #print(sentence[:offset-1])
        if offset > max_len:
            return
        self.cut(sentence[offset-1:],result)

    def parse(self,sentence):
        result = {};
        result['words'] = []
        result['phones'] = []        
        self.cut(sentence,result)
        result['words'] = ' '.join(result['words'])
        result['phones'] = ' '.join(result['phones'])
        return result
        

if(__name__=='__main__'):
    lexiconpath = '{aishell_data}/lexicon.txt'
    work_path = './ST-CMDS-20170001_1-OS'
    lexicon = LexiconDict(lexiconpath)
    tokener = SentenceToken(lexicon)
    #result = tokener.parse('除了 北京 上海 广州 深圳 四 个 一 线 城市 和 三亚 之外'.replace(' ','',100))
    #print(result)
    for parent,dirnames,filenames in os.walk(work_path):
        for filename in filenames:
            if filename.endswith('.txt'):
                txt_path = os.path.join(parent, filename)
                f = open(txt_path,'r')
                line = f.readline()
                result = tokener.parse(line)
                out_path = txt_path.replace('.txt','.wav.trn')
                out_f = open(out_path,'w')
                out_f.write(result['words'] + '\n')
                out_f.write(result['phones'] + '\n')
                out_f.write(result['phones'])
                #print(result)
                f.close()
                out_f.close()

这是个基本的代码采用了字典加最大长度匹配的分词模式同时支持标准音素

2.同步数据

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2018 xiaominfc <xiaominfc@xiaominfc-MBP.local>
#
# Distributed under terms of the MIT license.

"""
将ST-CMDS-20170001_1-OS生成 aishell 训练所需要的数据格式
"""

import os
import os.path
import shutil
workpath='./ST-CMDS-20170001_1-OS'
targetpath='{aishell_data}/wav/train'
sentence_f = open('./sentence.txt','w')
for parent,dirs,files in os.walk(workpath):
    for filename in files:
        if filename.endswith('.wav'):
            item = {}
            key = filename.replace('.wav','')
            path = os.path.join(parent,filename)
            item['key'] = key
            item['path'] = path
            labelpath = os.path.join(parent,filename.replace('.wav','.wav.trn'))
            f = open(labelpath,'r')
            item['sentence'] = f.readline().replace("\n",'')
            item['pinyin'] = f.readline().replace("\n",'')
            f.close()
            sentence_f.write(key + " " + item['sentence'] + '\n')
            item['spk'] = filename[7:14] 
            if not os.path.exists(targetpath+"/" + item['spk']):
                os.makedirs(targetpath+"/" + item['spk'])
            shutil.copy(path, targetpath+"/" + item['spk'] + '/'+ filename)



sentence_f.close()

说白了就是复制文件生成标注文本

3.另一个数据源的同步

import json
import os
import os.path
import shutil

from sentence_mark import LexiconDict,SentenceToken 



lexiconpath='{aishell_datapath}/resource_aishell/lexicon.txt'

lexicon = LexiconDict(lexiconpath)
tokener = SentenceToken(lexicon)


source_dir='./primewords_md_2018_set1'
targetpath='{aishell_datapath}/data_aishell/wav/train'
sentence_f = open('{aishell_datapath}/data_aishell/transcript/sentence_primeword.txt','w')
json_f=open(source_dir + '/set1_transcript.json','r')
sentence_list=json.load(json_f)

count = 0;
for item in sentence_list:
    filename = item['file']
    userid = item['user_id']
    fileId = 'PW' + ("%06d" % int(userid)) +   "%08d" % int(item['id'])
    text = item['text']
    result = tokener.parse(text.replace(' ','',100)) 
    print(result['words'])  
    audio_path=source_dir + '/audio_files/' + filename[0:1] + '/' + filename[0:2] + '/' + filename;
    print(fileId)
    count = count + 1
    sentence_f.write(fileId + " " + result['words'] + '\n')
    p_path = targetpath+"/TPW" +  ("%06d" % int(userid))
    if not os.path.exists(p_path):
        os.makedirs(p_path)
    shutil.copy(audio_path, p_path  + "/" +  fileId+'.wav')

4. 合并标注的文本跟aishell_transcript_v0.8.txt

追加上面生成的标注

结语

不想说太多就贴代码了哈哈哈数据集有近400个小时的了训练看看

xiaominfc's blog

llm一种剪枝的方式(合并LayerNorm跟Linear)

llm一种剪枝的方式(合并LayerNorm跟Linear)

前言

测试代码

后记

kaldi解码流程

kaldi 解码流程

前言

chain的模型(语音模型)

TransitionModel

nnet3

语言模型(HCLG.fst)

特征提取器

解码的大致过程

特征提取

解码

后续

kaldi解码工具的使用

kaldi解码工具的使用

前言：

默认

准备工作

看看0011_multi_cn_chain_sp_online_v2有啥

online2-wav-nnet3-latgen-faster的使用

online2-tcp-nnet3-decode-faster的使用

ps:

2019年总结

2019年总结

工作

能力

个人

结语

teamtalk实现给指定用户或者群发送消息的http接口

teamtalk实现给指定用户或者群发送消息的http接口

应用场景

基本流程

实现(最简实现)

1 http_msg_server复用加密操作

2 加密实例

3 声明

4 实现

db写入成功后 转发route_server 让route_server分发到msg_server进而发到客户端

结语：具体实现可以看我github上维护的分支

C/C++实现Python音频处理库librosa中melspectrogram的计算

C/C++实现Python音频处理库librosa中melspectrogram的计算

前言

探索

C/C++的实现

1. window(加窗)

2.数据分帧

3.fft

4. 计算mel_basis

5. 计算结果

尾声

docker mysql 主从同步（一主多备）

docker mysql 主从同步（一主多备）

获取mysql的docker镜像

主库的建立 启动脚本(master)

进入容器 连上mysql

添加从库操作用户

编辑 mysql-master 配置

重启master-mysql

ps 查看状态（进入master mysql用下列语句查看）

备库的建立 启动脚本(slave)

添加从库配置

重启slave 连接mysql

启动同步

ps

可以尝试在主库里写入看看效果了哦

重复上述slave相关的步骤即可生成多个备份

基于Tacotron模型实现中文语音合成

1.数据准备

1.1 单个女生语音数据10000句

1.1.1 标注(ProsodyLabeling/000001-010000.txt)

1.1.2 语音(Wave/*.wav)

1.2 中文字典素材的准备

2 模型的准备

2.1 关于中文合成的相关修改

2.1.1 输入特征的相关准备

db写入成功后转发route_server 让route_server分发到msg_server进而发到客户端

主库的建立启动脚本(master)

进入容器连上mysql

备库的建立启动脚本(slave)

感谢你的阅读下面是我改的源码

ps 效果出来了比之前的错误率少了0.5% 好吧不太明显有待加大语音数据训练