端午节，画了两天，才画了一张带颜色的图，感觉颜色啥的，好难画，阴影的过渡有待进步~
端午啦
随便画画
好久没有练习画画了。今天总算动起手来。这张画，我是先找了个淘宝的图片，然后大致画了下姿势，之后就完全不参考了，慢慢的一点点的画。还是使用之前的 Sakimichan大大的画法，只使用了19号画笔和套索工具。
画完的时候在看最开始的草稿，完全无法想象这两个居然是同一次的产物。
肚子上的褶皱。也是参考Sakimichan大大的方式，使用高光和暗光的两种线条随意涂画，看起来效果还不错。比较遗憾的是，到现在还不会上色。还是先把黑白练好再说。
2B
昨天晚上，终于把Nier的一周目打通了。最后2B小姐姐的眼罩居然掉了。真心好看。所以今天呢，就在没有任何参考的情况下，自己练习了一下头像，感觉效果似乎还可以。难道说，我的插画生涯终于要开始了吗，嘻嘻。
TICTOC: Header Only C++ Timer
感觉最近的更新频率略高啊～哈哈～
这次的带来的是一个十分简单便利的C++计时库。
项目地址：https://github.com/miaoerduo/tictoc 欢迎Start和提MR。
项目中有详细的说明和Demo，可以很直观的体验到这个库的易用性。
先看一下效果，如果我们正确使用的话，大致会出现类似下面的信息：
|
1 2 3 4 5 6 |
demo.cpp @ main [ 8, 13] elapsed: 0.025 s 24.786 ms 24786 us demo.cpp @ main [ 8, 18] elapsed: 0.049 s 48.709 ms 48709 us demo.cpp @ main [ 8, 23] elapsed: 0.072 s 72.211 ms 72211 us demo.cpp @ main [ 8, 24] elapsed: 0.072 s 72.225 ms 72225 us demo.cpp @ main [ 30, 36] elapsed: 0.022 s 21.747 ms 21747 us demo.cpp @ main [ 36, 41] elapsed: 0.021 s 21.463 ms 21463 us |
可以显示，我们的每个区域的代码（包括行号）的消耗时间。精确到微秒。
起因是这样的，之前有很长时间的工作内容是优化一些特定的函数，保证新旧的SDK的速度的对齐。然后C++虽然有一些工具可以分析运行状态，但通常还是简单的打印时间来的方便 /* Print大法好 */ 。之后，和工程的小伙伴一起Debug的时候，就发现他写了一个头文件，然后用绝对路径的方式去include，而头文件里面就是各种常用的小工具，而最常用到的就是时间的打印。
Easy Pipeline，一种轻量级的Python Pipeline库
嗯，很久没有写博客了，最近的工作都是偏开发性质的，以至于没有时间对自己感兴趣的领域进行探索，感觉个人的成长停滞了一些。如何在枯燥的工作中，提取出有助于自己成长的养分，对于每个人来说都是不小的考验。
这次，带来的是之前编写的一下挺简单的库，用来简化流水线作业的小框架。
Github: https://github.com/miaoerduo/easy-pipeline 欢迎Star和提交MR。
起因是这样的，组内有一个需求，需要挖掘视频中的检测难样本，这样可以极大地减少标注的量，从而降低成本。难样本挖掘的策略，简单来说就是如果视频的前几帧和后几帧都能检测到目标，而就只有当前帧没有检测到，就说明当前帧很可能存在漏检（没有检测本到该检测到的目标）；反之，如果前后都没有检测到目标，而当前帧检测到了，那就很可能是误检（检测到不是目标的东西）。
vim配置
下面是我的VIM的主要配置。应该就是网上找到的一个，加了点功能。权当在这里备份一下了。
将下面的内容写入自己的~/.vimrc文件即可。
针对自动跳转到上次关闭位置的这个功能，我在Ubuntu 14这个系统上失败了一次。是由于viminfo文件的权限不对。使用ls -l ~/.viminfo。如果发现其创建用户不是当前用户的话，那么可以将其删除。下次打开vim的时候会自动新建。这样就搞定了！
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 |
"自动跳到上次的行 if has("autocmd") au BufReadPost * if line("'\"") > 1 && line("'\"") <= line("$") | exe "normal! g'\"" | endif endif "显示行号 set nu set backspace=indent,eol,start "去掉vi一致性 filetype plugin indent on " 定义F9为粘贴模式 set pastetoggle=<F9> "设置编码 set encoding=utf-8 set fencs=utf-8,ucs-bom,shift-jis,gb18030,gbk,gb2312,cp936 set fileencodings=utf-8,ucs-bom,chinese "语言设置 set langmenu=zh_CN.UTF-8 "设置语法高亮 syntax enable syntax on "设置配色方案 "colorscheme evening "高亮显示匹配的括号 set showmatch "设置缩进 set tabstop=4 set expandtab retab! set softtabstop=4 set shiftwidth=4 set autoindent set cindent if &term=="xterm" set t_Co=8 set t_Sb=^[[4%dm set t_Sf=^[[3%dm endif "打开文件类型自动检测功能 filetype on "设置taglist let Tlist_Show_One_File=0 "显示多个文件的tags let Tlist_File_Fold_Auto_Close=1 "非当前文件，函数列表折叠隐藏 let Tlist_Exit_OnlyWindow=1 "在taglist是最后一个窗口时退出vim let Tlist_Use_SingleClick=1 "单击时跳转 let Tlist_GainFocus_On_ToggleOpen=1 "打开taglist时获得输入焦点 let Tlist_Process_File_Always=1 "不管taglist窗口是否打开，始终解析文件中的tag "设置WinManager插件 let g:winManagerWindowLayout='FileExplorer|TagList' nmap wm :WMToggle<cr> map <silent> <F9> :WMToggle<cr> "将F9绑定至WinManager,即打开WimManager "设置CSCOPE set cscopequickfix=s-,c-,d-,i-,t-,e- "设定是否使用quickfix窗口显示cscope结果 "设置一键编译 map <F6> :make<CR> "设置自动补全 filetype plugin indent on "打开文件类型检测 set completeopt=longest,menu "关掉智能补全时的预览窗口 "启动vim时如果存在tags则自动加载 if exists("tags") set tags=./tags endif "设置按F12就更新tags的方法 map <F12> :call Do_CsTag()<CR> nmap <C-@>s :cs find s <C-R>=expand("<cword>")<CR><CR>:copen<CR> nmap <C-@>g :cs find g <C-R>=expand("<cword>")<CR><CR> nmap <C-@>c :cs find c <C-R>=expand("<cword>")<CR><CR>:copen<CR> nmap <C-@>t :cs find t <C-R>=expand("<cword>")<CR><CR>:copen<CR> nmap <C-@>e :cs find e <C-R>=expand("<cword>")<CR><CR>:copen<CR> nmap <C-@>f :cs find f <C-R>=expand("<cfile>")<CR><CR>:copen<CR> nmap <C-@>i :cs find i ^<C-R>=expand("<cfile>")<CR>$<CR>:copen<CR> nmap <C-@>d :cs find d <C-R>=expand("<cword>")<CR><CR>:copen<CR> function Do_CsTag() let dir = getcwd() if filereadable("tags") if(g:iswindows==1) let tagsdeleted=delete(dir."\\"."tags") else let tagsdeleted=delete("./"."tags") endif if(tagsdeleted!=0) echohl WarningMsg | echo "Fail to do tags! I cannot delete the tags" | echohl None return endif endif if has("cscope") silent! execute "cs kill -1" endif if filereadable("cscope.files") if(g:iswindows==1) let csfilesdeleted=delete(dir."\\"."cscope.files") else let csfilesdeleted=delete("./"."cscope.files") endif if(csfilesdeleted!=0) echohl WarningMsg | echo "Fail to do cscope! I cannot delete the cscope.files" | echohl None return endif endif if filereadable("cscope.out") if(g:iswindows==1) let csoutdeleted=delete(dir."\\"."cscope.out") else let csoutdeleted=delete("./"."cscope.out") endif if(csoutdeleted!=0) echohl WarningMsg | echo "Fail to do cscope! I cannot delete the cscope.out" | echohl None return endif endif if(executable('ctags')) "silent! execute "!ctags -R --c-types=+p --fields=+S *" silent! execute "!ctags -R --c++-kinds=+p --fields=+iaS --extra=+q ." endif if(executable('cscope') && has("cscope") ) if(g:iswindows!=1) silent! execute "!find . -name '*.h' -o -name '*.c' -o -name '*.cpp' -o -name '*.java' -o -name '*.cs' > cscope.files" else silent! execute "!dir /s/b *.c,*.cpp,*.h,*.java,*.cs >> cscope.files" endif silent! execute "!cscope -b" execute "normal :" if filereadable("cscope.out") execute "cs add cscope.out" endif endif endfunction "设置默认shell set shell=bash "设置VIM记录的历史数 set history=1000 "设置当文件被外部改变的时侯自动读入文件 if exists("&autoread") set autoread endif "设置ambiwidth set ambiwidth=double "设置文件类型 set ffs=unix,dos,mac "设置增量搜索模式 set incsearch "设置静音模式 set noerrorbells set novisualbell set t_vb= "不要备份文件 set nobackup set nowb |
另外，附上Ubuntu下，VIM 8升级的命令：
|
1 2 3 |
sudo add-apt-repository ppa:jonathonf/vim sudo apt update sudo apt install vim |
嗯，此刻一个非技术板块诞生了
先贴上一张昨晚的作品，这样这篇博客会自动有个插图。：P
左边的男生是想象着随便画的，右边的女生其实是参考的一个插画画的，画的和原图一点都不像就是了。
之前一直在博客里面记录一下自己学习的技术技能，最近写博客的频率已经降到了一个很可怕的数值。一方面是工作的内容过于枯燥，没有什么新技术的使用，不知道要写些什么有意思的内容，另一方面就是工作确实太忙了，写一篇博客需要至少半天的时间，平时肯定是没有的，周末又要陪女票大人出去逛街。这真是现实和生活之间的巨大的矛盾啊，果然有句话是对的：成人的世界里，没有容易二字。实在伐开心。
_rebuild_tensor_v2？pytorch版本间模型兼容性脱坑实践
最近使用Pytorch 0.4.0 进行模型训练，之后使用一个转模型的工具时，报了一个错，就是标题里面的_rebuild_tensor_v2相关的错误。最后发现是本地使用的pytorch的版本是0.3.0，和0.4.0模型上不兼容。各论坛上的解决方案都是说pytorch版本不向后兼容，建议升级pytorch。无奈我这里不方便升级pytorch版本。那么问题就来了，有没有什么不需要修改pytorch源码，或是不升级pytorch，又能让老版本的pytorch读取新版本模型的方案呢？
当然是有的，而且工作量很小。
一、Pytorch模型存储和读取的流程
首先，我们使用pytorch存储模型会使用 torch.save 这个函数，直接将模型的state_dict()保存下来。类似下面的代码：
|
1 2 3 4 5 6 |
torch.save({ 'state_dict': model.state_dict(), 'other': other_data }, 'model.pth' ) |
读取参数的代码也十分简单：
|
1 2 3 4 5 6 |
model = Model() with open('model.pth', 'rb') as fp: param = torch.load(fp) model.load_state_dict(param['state_dict']) |
而低版本的pytorch就是在load_state_dict这里报了错。
二、State Dict
我们首先要知道，model.state_dict()的返回值究竟是什么。
这里我直接给出结论：
model.state_dict()的返回值是一个collections.OrderedDict对象，它的键是一个字符串，它的值是Tensor的对象。所以造成兼容性问题的其实是Tensor对象的不兼容。
那么是不是可以将Tensor转化成一个新的非Pytorch内置的数据类型呢？这样就可以避免兼容性问题。
numpy.ndarray就是我们需要的中间态。
三、模型转换
首先，我们需要将state_dict的参数转换成numpy.ndarray保存下来。这里使用高版本的pytorch。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import torch from collections import OrderedDict import pickle with open('model.pth', 'rb') as fp: param = torch.load(fp) state_dict = param['state_dict'] numpy_state_dict = OrderedDict() for key, tensor in state_dict.items(): numpy_state_dict[key] = tensor.cpu().numpy() with open('state_dict.pic', 'wb') as fp: pickle.dump(numpy_state_dict, fp) |
之后，用低版本的pytorch载入这个numpy的state_dict。
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import pickle import torch with open('numpy_state_dict.pic', 'rb') as fp: state_dict = pickle.load(fp) # numpy.ndarray -> tensor for key, ndarr in state_dict.items(): state_dict[key] = torch.Tensor(ndarr) model = Model() model.load_state_dict(state_dict) |
四、总结
对于这个问题，还有很多的解决方案，这里是比较简单的一种。
PS. 这是目前为止，写的最快的一篇博客了。。。
转载请注明出处，谢谢！
C++ Boost JSON解析库的使用
最近在写一个C++项目的时候，有大量的配置信息，于是将这些配置信息整合进一个文本文件中，选择了JSON这种数据格式。C++在处理JSON数据的库有很多，比如Jsoncpp，Boost等，这个项目中由于本身就已经用到了Boost这个库，因此，也就选用Boost来进行JSON的解析了。
Boost的JSON解析，使用的是property_tree这个数据类型，它可以方便的解析XML和JSON。
一、Boost JSON解析库的几个注意事项
在具体介绍之前，必须要强调一下，这个库默认不是线程安全的！不是线程安全的！不是线程安全的！不做任何处理的情况下，如果直接在多线程的程序中使用Boost解析JSON，可能会在奇怪的时候报段错误。
这是由于Boost的JSON解析是基于SPIRIT语法解析的，而SPIRIT本身就不是线程安全的，我们如果需要它支持线程安全，就必须加入一个宏#define BOOST_SPIRIT_THREADSAFE，把它放在引用boost的头文件的最开始就行。理论上，在编译的时候加入宏也是可以的。
另一个需要注意的是，一般网上找的教程中，property_tree都是不支持unicode编码的，如果想要支持unicode，需要一些额外的操作。这个从网上可以查到，我尝试了一下，最终还是放弃了。取而代之的一个方案就是把中文的各种路径啥的，用软链接替换成英文和数字。之后世界就美好了。
二、boost::property_tree::ptree 类型
对于JSON或者XML，boost将他们解析之后都会生成一个ptree的数据结构。类似于下面的结构。
|
1 2 3 4 5 6 |
struct ptree { data_type data; // data associated with the node list< pair<key_type, ptree> > children; // ordered list of named children }; |
可以看出，这是一个很标准的树的结构。对于树中的每一个节点，都有自己的数值和子节点，每个子节点都有一个唯一的名字。data_type和key_type通常是std::string或std::wstring。如果希望处理unicode的字符串的话，就需要用到std::wstring了。下面的例子中，使用的全部都是std::string。
三、JSON文件的解析
首先，我们用一个小栗子，来介绍一下Boost是如何读取JSON数据的。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
#include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> #include <sstream> #include <iostream> int main() { std::string s = "{ \"a\": 100, \"b\": [1, 2, 3, 4] }"; std::stringstream ss(s); boost::property_tree::ptree ptree; // 读取JSON数据 boost::property_tree::read_json(ss, ptree); std::cout << ptree.get_child("a").data() << std::endl; // 写回JSON数据 boost::property_tree::write_json("./tmp.json", ptree); } |
这里首先我们需要定义一个boost::property_tree::ptree类型的对象，之后通过boost::property_tree::read_json函数进行数据的读取，之后就可以使用各种ptree的接口进行数据的操作了。
在boost/property_tree/json_parser.hpp文件中我们可以看到读写JSON的一些接口。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
namespace boost { namespace property_tree { namespace json_parser { template<typename Ptree> void read_json(std::basic_istream< typename Ptree::key_type::value_type > &, Ptree &); template<typename Ptree> void read_json(const std::string &, Ptree &, const std::locale & = std::locale()); template<typename Ptree> void write_json(std::basic_ostream< typename Ptree::key_type::value_type > &, const Ptree &, bool = true); template<typename Ptree> void write_json(const std::string &, const Ptree &, const std::locale & = std::locale(), bool = true); } } } |
它支持读写JSON，对于读取操作，它支持直接根据文件名称来加载JSON或者通过输入流来加载。输出也是相同。所以我们上面的Demo中，需要将字符串s转换成字符串流对象ss，之后才能进行加载。写文件支持写入到文件或者输出流中，最后一个bool值表示是否格式化输出json。
四、JSON对象的读取
我们知道JSON对象主要有两种格式：键值对和数组。JSON灵活就在于键值对的值还可以键值对或者数组，数组的每个元素也是。
那么我们分别介绍键值对和数组的数据获取方式。
1）键值对的解析
ptree支持一个操作叫做get_child，可以根据键的名字，来获取子节点。而且这个名字还可以是累加的。什么叫可以累加呢？我们看一下下面的代码：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> #include <sstream> #include <iostream> int main() { std::string s = "{ \"a\": { \"b\":1, \"c\":2 }, \"d\":3 }"; std::stringstream ss(s); boost::property_tree::ptree ptree; boost::property_tree::read_json(ss, ptree); std::cout << "input text:" << std::endl; boost::property_tree::write_json(std::cout, ptree); std::cout << "-------------------------" << std::endl; std::cout << "parse result: " << std::endl; std::cout << "a->b: " << ptree.get_child("a").get_child("b").get_value<int>() << std::endl; std::cout << "a->b: " << ptree.get_child("a.b").get_value<int>() << std::endl; std::cout << "a->c: " << ptree.get_child("a.c").get_value<int>() << std::endl; std::cout << "d: " << ptree.get_child("d").get_value<int>() << std::endl; } |
输出的结果为：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
input text: { "a": { "b": "1", "c": "2" }, "d": "3" } ------------------------- parse result: a->b: 1 a->b: 1 a->c: 2 d: 3 |
get_child这个函数，可以根据节点的名字，获取到子节点的ptree对象。这个节点的名字可以使用.连接各个层级的名称。get_value<Type>方法，可以获取节点的值，并且转换成期望的数据类型。如果我们就是想获取节点的值。不期望有任何转换，可以使用data这个函数。
get_child要求输入的名称路径必须是存在的，否则会抛异常。如果我们不知道某个名称路径是否存在的话，可以使用get_child_optional这个函数，如果路径不存在，该函数会返回boost::null。get_child_optional返回的类似于指针的结构，如果需要获取值，可以用这样的写法：pt.get_child_optional("some_key")->get_value<int>()。
我们可以向现在这样通过各种树的操作，选择到我们的需要的节点，再通过get_value<Type>函数获取到数据值。但这样的操作有时候会有点繁琐。boost支持更简化的一些操作。下面是同样功能的一个例子：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
#include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> #include <sstream> #include <iostream> int main() { std::string s = "{ \"a\": { \"b\":1, \"c\":2 }, \"d\":3 }"; std::stringstream ss(s); boost::property_tree::ptree ptree; boost::property_tree::read_json(ss, ptree); std::cout << "input text:" << std::endl; boost::property_tree::write_json(std::cout, ptree); std::cout << "-------------------------" << std::endl; std::cout << "parse result: " << std::endl; std::cout << "a->b: " << ptree.get<int>("a.b") << std::endl; std::cout << "a->c: " << ptree.get<int>("a.c") << std::endl; std::cout << "d: " << ptree.get<int>("d") << std::endl; } |
get这个函数相当于先get_child得到要找的节点，之后再调用get_value<Type>这个函数。get_value<Type>这个函数可以获取节点的值，同时把它转换成Type格式。即ptree.get<int>("a.b")等价于ptree.get_child("a.b").get_value<int>()。
通过get函数，我们可以很方便的获取某个节点的数据，而且还能顺便完成类型的转换，真的不能更方便了！
2）数组的解析
为什么数组的解析要单独来说呢？因为，数组格式中，没有键，所以我们不能根据名字来获取节点了，所以读取的方式有了些许的不同。
Boost针对数组，给我们提供了遍历子节点的迭代器接口。可以十分方便的遍历某节点的所有的子节点（当然在键值对的解析中也可以使用）。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
#include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> #include <sstream> #include <iostream> int main() { std::string s = "[1, 2, 3, 4]"; std::stringstream ss(s); boost::property_tree::ptree ptree; boost::property_tree::read_json(ss, ptree); boost::property_tree::write_json(std::cout, ptree); // visit array data for (boost::property_tree::ptree::iterator it = ptree.begin(); it != ptree.end(); ++ it) { std::cout << it->second.get_value<int>() << " "; } std::cout << std::endl; // simpler in c++11 for (auto it: ptree) { std::cout << it.second.get_value<int>() << " "; } } |
打印的结果：
|
1 2 3 4 5 6 7 8 9 |
{ "": "1", "": "2", "": "3", "": "4" } 1 2 3 4 1 2 3 4 |
可以看出，Boost中将JSON数组也是按照键值对的方式去存储，只是键的内容是一个空的字符串。迭代器的first是键的结果，数组中就是空字符串。second就是我们的值。
3） 其他的实用接口
bool empty(): 返回该节点是否含有子节点。比如当一个节点已经是叶子节点的时候，可以用这个函数来判断。
assoc_iterator find(const key_type &key): 给定一个名字路径，返回指向该节点的迭代器或者boost::property_tree::ptree::not_found。
size_type count(const key_type &key): 返回指定名称路径的节点的子节点的数目。
五、JSON对象的编辑
Boost支持很多的对JSON对象的写的操作，但是我在项目中没有用到，所以在这里暂时就没有动力整理下去了~~ 这里附上Boost ptree的文档，方便大家查阅：
https://www.boost.org/doc/libs/1_65_1/boost/property_tree/ptree.hpp
六、疑难杂症
1.怎么判断某个键是否存在？
使用get_child_optional，再判断返回是否为boost::null，这个对象直接相当于false。
|
1 2 3 4 5 |
auto node = ptree.get_child_optional("somekey"); if (!node) { // node not exists } |
2.怎么方便的遍历数组？
这个功能，我还专门查过。其实懂了之前的迭代器的使用，就能方便的遍历了。下面是我用的一个代码。
|
1 2 3 4 5 6 7 8 9 |
template <typename T> std::vector<T> as_vector(boost::property_tree::ptree const &pt, boost::property_tree::ptree::key_type const& key) { std::vector<T> r; for (auto &item: pt.get_child(key)) { r.push_back(item.second.get_value<T>()); } return r; } |
使用的话就这样：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
#include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> #include <sstream> #include <iostream> #include <vector> template <typename T> std::vector<T> as_vector(boost::property_tree::ptree const &pt, boost::property_tree::ptree::key_type const& key) { std::vector<T> r; for (auto &item: pt.get_child(key)) { r.push_back(item.second.get_value<T>()); } return r; } int main() { std::string s = "{\"arr\": [1, 2, 3, 4]}"; std::stringstream ss(s); boost::property_tree::ptree ptree; boost::property_tree::read_json(ss, ptree); boost::property_tree::write_json(std::cout, ptree); auto result = as_vector<int>(ptree, "arr"); for (auto d: result) { std::cout << d << " "; } } |
不过这个解决方案有个问题，就是如果根节点就是数组的话，似乎就不能很好的work了。
3.怎么解析中文
/(ㄒoㄒ)/~~
转载请注明出处，谢谢！
C++ 并发队列的原理简介与开源库concurrentqueue安利
由于最近在做一个项目，但是框架本身有个不合理的设计。其中的代码是单线程的，数据的读取和计算都在一个线程里面完成。也就是说，我们的程序有很大的一部分时间在读取文件数据，导致最终的运行速度很慢。这里就可以使用多线程来优化。
Knock-your-socks-off blazing fast performance.
Single-header implementation. Just drop it in your project.
Fully thread-safe lock-free queue. Use concurrently from any number of threads.
C++11 implementation — elements are moved (instead of copied) where possible.
Templated, obviating the need to deal exclusively with pointers — memory is managed for you.
No artificial limitations on element types or maximum count.
Memory can be allocated once up-front, or dynamically as needed.
Fully portable (no assembly; all is done through standard C++11 primitives).
Supports super-fast bulk operations.
Includes a low-overhead blocking version (BlockingConcurrentQueue).
Exception safe.
这里需要使用最基本的生产者消费者模式。
使用若干个线程作为生产者，负责数据的读取和预处理，这部分任务是IO密集型的，也就是不太占CPU，但是比较占带宽，而且有延时。在处理完数据之后，将数据放到一个队列中。
同时，使用若干个线程充当消费者，从这个队列里面获取数据，然后进行计算。计算的部分是CPU密集型的（其实我这里计算是GPU做的，就只有一个消费者），计算完成之后输出结果。
那么贯穿这一整套方案的，就是我们的队列。
在并发任务中，通常都需要一个队列机制，将并行的任务转化成串行的任务，或者将串行的任务提供给并行工作的线程。这个队列会同时被多个线程读写，因此也必须是线程安全的。
一、线程安全的实现策略
对于线程安全的队列的实现，似乎经常成为企业的面试题，常见的实现方法就是互斥量和条件变量，本质上就是锁的机制。同一时间只有一个线程具有读写的权限。锁的机制在并发量不大情况下，十分的清晰有效。在并发量较大的时候，会因为对锁的竞争而越发不高效。同时，锁本身也需要维护一定的资源，也需要消耗性能。
这时候，大家肯定会想问，不使用锁机制，还可以处理这种并发的情况吗？
答案是肯定的，首先我们知道锁主要有两种，悲观锁和乐观锁。对于悲观锁，它永远会假定最糟糕的情况，就像我们上面说到的互斥机制，每次我们都假定会有其他的线程和我们竞争资源，因此必须要先拿到锁，之后才放心的进行我们的操作，这就使得争夺锁成为了我们每次操作的第一步。乐观锁则不同，乐观锁假定在很多情况下，资源都不需要竞争，因此可以直接进行读写，但是如果碰巧出现了多线程同时操控数据的情况，那么就多试几次，直到成功（也可以设置重试的次数）。
我们生活的时候，总会碰到很多的不顺心的事情，比如模型训练崩了，被某些库搞得头大，或者女票又生气了什么的，不妨学习一下乐观锁的精神，再训一次？再编译一次？大不了再哄一次。一次不行就两次。
回到乐观锁上，乐观锁中，每次读写都不考虑锁的存在，那么他是如何知道自己这次操作和其他线程是冲突的呢？这就是Lock-free队列的关键——原子操作。原子操作可以保证一次操作在执行的过程中不会被其他线程打断，因此在多线程程序中也不需要同步操作。在C++的STL中其实也提供了atomic这个库，可以保证多线程在操控同一个变量的时候，即使不加锁也能保证起最终结果的正确性。而我们乐观锁需要的一个原子操作就是CAS（Compare And Swap），绝大多数的CPU都支持这个操作。
CAS操作的定义如下(STL中的一个)：
|
1 |
bool atomic_compare_exchange_weak (atomic<T>* obj, T* expected, T val); |
首先函数会将obj与expected的内容作比较：
- 如果相等，那么将交换obj和val的值，并返回true。
- 如果不相等，则什么也不做，之后返回false。
那么使用这个奇怪的操作，为什么就可以实现乐观锁了呢？这里我们看一个例子。这也是我学习的时候看的例子。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
struct list { std::atomic<node*> head; }; ... void append(list* s, node* n) { node* head; do { head = s->head; n->next = head; } while (!std::atomic_compare_exchange_weak(&(s->head), &head, n)); // or while (!s->head.compare_exchange_weak(head, n)); } |
在我们向list中插入元素的时候，首先获取到当前的头指针的值head，然后我们在写数据的时候，首先和此刻的头指针值作对比，如果相同，那么就把新的节点插入。如果不相同，说明有线程先我们一步成功了，那么我们就多尝试一次，直到写入成功。
以上就是使用CAS操作实现的乐观锁。上面的这个append就是最简单的Lock-free且线程安全的操作。
二、concurrentqueue
最近在做这个项目的时候，就被安利了一个header only的C++并发队列库 concurrentqueue。本着不重复造轮子的原则，我在项目中用了这个库，由于它只是两个头文件，特别方便的就加入到了项目中。关于这个库的特点，项目的github上写了很多。这里直接照搬下来，不做解释。