Question

我正在尝试编写解析器来解析此数据集：http://research.microsoft.com/en-us/projects/mslr/

我编写了代码（如下）..然而它太慢了......解析几百兆字节的数据需要几乎整整一分钟。

我运行了一个分析器，它说大部分时间花在了boost :: split（30％）和boost :: lexical_cast（40％）......有关如何加速代码的任何建议吗？

感谢。

  std::ifstream train("letor/Fold1/train.txt", std::ifstream::in | std::ifstream::binary);

  m_train.clear();

  for (std::size_t i = 0; i < 10000 && train.good(); i++) {
    std::size_t query;
    boost::numeric::ublas::vector<double> features;
    double label;

    features.resize(get_feature_size(), false);

    // 2 qid:1 1:3 2:3 3:0 4:0 5:3 6:1 7:1 8:0 9:0 10:1 11:156 12:4 13:0 14:7 15:167 16:6.931275 17:22.076928 18:19.673353 19:22.255383 20:6.926551 21:3 22:3 23:0 24:0 25:6 26:1 27:1 28:0 29:0 30:2 31:1 32:1 33:0 34:0 35:2 36:1 37:1 38:0 39:0 40:2 41:0 42:0 43:0 44:0 45:0 46:0.019231 47:0.75000 48:0 49:0 50:0.035928 51:0.00641 52:0.25000 53:0 54:0 55:0.011976 56:0.00641 57:0.25000 58:0 59:0 60:0.011976 61:0.00641 62:0.25000 63:0 64:0 65:0.011976 66:0 67:0 68:0 69:0 70:0 71:6.931275 72:22.076928 73:0 74:0 75:13.853103 76:1.152128 77:5.99246 78:0 79:0 80:2.297197 81:3.078917 82:8.517343 83:0 84:0 85:6.156595 86:2.310425 87:7.358976 88:0 89:0 90:4.617701 91:0.694726 92:1.084169 93:0 94:0 95:2.78795 96:1 97:1 98:0 99:0 100:1 101:1 102:1 103:0 104:0 105:1 106:12.941469 107:20.59276 108:0 109:0 110:16.766961 111:-18.567793 112:-7.760072 113:-20.838749 114:-25.436074 115:-14.518523 116:-21.710022 117:-21.339609 118:-24.497864 119:-27.690319 120:-20.203779 121:-15.449379 122:-4.474452 123:-23.634899 124:-28.119826 125:-13.581932 126:3 127:62 128:11089534 129:2 130:116 131:64034 132:13 133:3 134:0 135:0 136:0
    std::string line;
    getline(train, line);

    boost::algorithm::trim(line);
    std::vector<std::string> tokens;
    boost::split(tokens, line, boost::is_any_of(" "));

    assert(tokens.size() == 138);

    label = boost::lexical_cast<double>(tokens[0]);
    query = boost::lexical_cast<std::size_t>(tokens[1].substr(tokens[1].find(":") + 1, tokens[1].size()));

    for (std::size_t i = 2; i < tokens.size(); i++) {
      features[i - 2] = boost::lexical_cast<double>(tokens[i].substr(tokens[i].find(":") + 1, tokens[i].size()));
    }

    m_train.push_back(query, features, label);

    train.peek();
  }

Answer 1

如果我正确理解您的格式，每行都以数字开头，后跟冒号分隔对。每行的第一对具有特殊含义，由std::string和size_t组成，而所有其他对由索引（被忽略）和double组成。根本没有理由使用Boost：直接使用IOStream：

std::streamsize    max(std::numeric_limits<std::streamsize>::max());
std::string        line;
std::istringstream in;
for (std::size_t i(0); i < 1000 && std::getline(train, line); ++i) {
    double label;
    size_t query;
    in.clear();
    in.str(line)
    if ((in >> label).ignore(max, ':') >> query) {
         boost::numeric::ublas::vector<double> features;
         while (in.ignore(max, ':') >> feature) {
              features.push_back(feature);
         }
         assert(features.size() == 136);
         m_train.push_back(query, features, label);
    }
}

请注意，此代码会仔细检查读取是否实际成功。如果读取成功但您的代码不能可靠地运行，则提前检查您的代码。例如，如果您的最后一行仅包含虚假空间，则assert()会触发，这几乎不是您想要的。

Answer 2

多次砍掉字符串需要内存分配和解除分配。您可以使用旧的strtod和char指针来避免拆分字符串。这将需要一些30％的字符串标记化花费。至于40％将蜇转换为双打，这可能无法显着改善。

如果你想要快速，肮脏，令人惊讶的丑陋，但可能是最快的C-only解决方案，试试这个。该测试在E8300 2.83 GHz CPU上完成约35秒。假设所有字符串都具有完全相同的格式。

#include "stdio.h"

void main ()
{
    const char* test_str = "2 qid:1 1:3 2:3 3:0 4:0 5:3 6:1 7:1 8:0 9:0 10:1 11:156 12:4 13:0 14:7 15:167 16:6.931275 17:22.076928 18:19.673353 19:22.255383 20:6.926551 21:3 22:3 23:0 24:0 25:6 26:1 27:1 28:0 29:0 30:2 31:1 32:1 33:0 34:0 35:2 36:1 37:1 38:0 39:0 40:2 41:0 42:0 43:0 44:0 45:0 46:0.019231 47:0.75000 48:0 49:0 50:0.035928 51:0.00641 52:0.25000 53:0 54:0 55:0.011976 56:0.00641 57:0.25000 58:0 59:0 60:0.011976 61:0.00641 62:0.25000 63:0 64:0 65:0.011976 66:0 67:0 68:0 69:0 70:0 71:6.931275 72:22.076928 73:0 74:0 75:13.853103 76:1.152128 77:5.99246 78:0 79:0 80:2.297197 81:3.078917 82:8.517343 83:0 84:0 85:6.156595 86:2.310425 87:7.358976 88:0 89:0 90:4.617701 91:0.694726 92:1.084169 93:0 94:0 95:2.78795 96:1 97:1 98:0 99:0 100:1 101:1 102:1 103:0 104:0 105:1 106:12.941469 107:20.59276 108:0 109:0 110:16.766961 111:-18.567793 112:-7.760072 113:-20.838749 114:-25.436074 115:-14.518523 116:-21.710022 117:-21.339609 118:-24.497864 119:-27.690319 120:-20.203779 121:-15.449379 122:-4.474452 123:-23.634899 124:-28.119826 125:-13.581932 126:3 127:62 128:11089534 129:2 130:116 131:64034 132:13 133:3 134:0 135:0 136:0";

    const char* format = "%lf qid:%lf 1:%lf 2:%lf 3:%lf 4:%lf 5:%lf 6:%lf 7:%lf 8:%lf 9:%lf 10:%lf 11:%lf 12:%lf 13:%lf 14:%lf 15:%lf 16:%lf 17:%lf 18:%lf 19:%lf 20:%lf 21:%lf 22:%lf 23:%lf 24:%lf 25:%lf 26:%lf 27:%lf 28:%lf 29:%lf 30:%lf 31:%lf 32:%lf 33:%lf 34:%lf 35:%lf 36:%lf 37:%lf 38:%lf 39:%lf 40:%lf 41:%lf 42:%lf 43:%lf 44:%lf 45:%lf 46:%lf 47:%lf 48:%lf 49:%lf 50:%lf 51:%lf 52:%lf 53:%lf 54:%lf 55:%lf 56:%lf 57:%lf 58:%lf 59:%lf 60:%lf 61:%lf 62:%lf 63:%lf 64:%lf 65:%lf 66:%lf 67:%lf 68:%lf 69:%lf 70:%lf 71:%lf 72:%lf 73:%lf 74:%lf 75:%lf 76:%lf 77:%lf 78:%lf 79:%lf 80:%lf 81:%lf 82:%lf 83:%lf 84:%lf 85:%lf 86:%lf 87:%lf 88:%lf 89:%lf 90:%lf 91:%lf 92:%lf 93:%lf 94:%lf 95:%lf 96:%lf 97:%lf 98:%lf 99:%lf 100:%lf 101:%lf 102:%lf 103:%lf 104:%lf 105:%lf 106:%lf 107:%lf 108:%lf 109:%lf 110:%lf 111:%lf 112:%lf 113:%lf 114:%lf 115:%lf 116:%lf 117:%lf 118:%lf 119:%lf 120:%lf 121:%lf 122:%lf 123:%lf 124:%lf 125:%lf 126:%lf 127:%lf 128:%lf 129:%lf 130:%lf 131:%lf 132:%lf 133:%lf 134:%lf 135:%lf 136:%lf";

    double data[138];

    for (int i = 0; i < 500000; i++)
    {
        sscanf(test_str, format, 
            data+0, data+1, data+2, data+3, data+4, data+5, 
            data+6, data+7, data+8, data+9, data+10, data+11, 
            data+12, data+13, data+14, data+15, data+16, data+17, 
            data+18, data+19, data+20, data+21, data+22, data+23, 
            data+24, data+25, data+26, data+27, data+28, data+29, 
            data+30, data+31, data+32, data+33, data+34, data+35, 
            data+36, data+37, data+38, data+39, data+40, data+41, 
            data+42, data+43, data+44, data+45, data+46, data+47, 
            data+48, data+49, data+50, data+51, data+52, data+53, 
            data+54, data+55, data+56, data+57, data+58, data+59, 
            data+60, data+61, data+62, data+63, data+64, data+65, 
            data+66, data+67, data+68, data+69, data+70, data+71, 
            data+72, data+73, data+74, data+75, data+76, data+77, 
            data+78, data+79, data+80, data+81, data+82, data+83, 
            data+84, data+85, data+86, data+87, data+88, data+89, 
            data+90, data+91, data+92, data+93, data+94, data+95, 
            data+96, data+97, data+98, data+99, data+100, data+101, 
            data+102, data+103, data+104, data+105, data+106, data+107, 
            data+108, data+109, data+110, data+111, data+112, data+113, 
            data+114, data+115, data+116, data+117, data+118, data+119, 
            data+120, data+121, data+122, data+123, data+124, data+125, 
            data+126, data+127, data+128, data+129, data+130, data+131, 
            data+132, data+133, data+134, data+135, data+136, data+137);
    }
}

C99有vsscanf可以让它看起来更好。然后，可以在循环之前动态预生成格式字符串，具体取决于数据集格式。确保在此示例中检查sscanf的返回值为138。

编辑：DietmarKühl的解决方案看起来很干净，如果速度慢于单个sscanf，则一定不能显着。最好只使用上面的代码作为基准参考。

Answer 3

没有一些实验就很难说，但是......

我首先放弃boost::split。它正在制作一个 std::vector<std::string>，这又涉及很多动态分配和复制。你可能想要做的是写一些对于++前进到下一个标记的字符串的迭代器，以及 *返回一对定义当前标记的迭代器。这避免了中间数据结构。

然后，您可以在此对上定义<<运算符，例如：

std::ostream&
operator<<( std::ostream& dest, TextRange const& token )
{
    std::copy( token.begin(), token.end(),
               std::ostream_iterator<char>( dest ) );
    return dest;
}

减少boost::lexical_cast使用的时间会更加困难。基本上，boost::lexical_cast正在使用<<将源插入一个std::stringstream和>>来提取它。你可以写点东西类似，但使用自己的streambuf，基于迭代器对（非常简单），所以给定一对迭代器，1）你不必使用完全<<，因为这对迭代器变成了istream，并且2）你完全避免创建任何中间std::string。（你做不希望重新实现std::istream中的转化例程。）

C ++更快的字符串解析？

3 个答案: