C++ を使用して効率的なテキスト マイニングとテキスト分析を行うにはどうすればよいですか?

C を使用して効率的なテキスト マイニングとテキスト分析を行うにはどうすればよいですか?

概要:
テキスト マイニングとテキスト分析は、最新のデータ分析と機械学習の分野における重要なタスクです。この記事では、C言語を使って効率的にテキストマイニングやテキスト分析を行う方法を紹介します。コード例とともに、テキストの前処理、特徴抽出、およびテキスト分類のテクニックに焦点を当てます。

テキストの前処理:
テキスト マイニングとテキスト分析の前に、通常、元のテキストを前処理する必要があります。前処理には、句読点、ストップワード、特殊文字の削除、小文字への変換、ステミングなどが含まれます。以下は、テキスト前処理に C を使用したサンプル コードです。

#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>

std::string preprocessText(const std::string& text) {
    std::string processedText = text;
    
    // 去掉标点符号和特殊字符
    processedText.erase(std::remove_if(processedText.begin(), processedText.end(), [](char c) {
        return !std::isalnum(c) && !std::isspace(c);
    }), processedText.end());
    
    // 转换为小写
    std::transform(processedText.begin(), processedText.end(), processedText.begin(), [](unsigned char c) {
        return std::tolower(c);
    });
    
    // 进行词干化等其他操作
    
    return processedText;
}

int main() {
    std::string text = "Hello, World! This is a sample text.";
    std::string processedText = preprocessText(text);

    std::cout << processedText << std::endl;

    return 0;
}

特徴抽出:
テキスト分析タスクを実行する場合、機械学習アルゴリズムが処理できるように、テキストを数値特徴ベクトルに変換する必要があります。それ。一般的に使用される特徴抽出方法には、バッグオブワード モデルや TF-IDF などがあります。以下は、C を使用したバッグオブワード モデルと TF-IDF 特徴抽出のコード例です。

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>

std::vector<std::string> extractWords(const std::string& text) {
    std::vector<std::string> words;
    
    // 通过空格分割字符串
    std::stringstream ss(text);
    std::string word;
    while (ss >> word) {
        words.push_back(word);
    }
    
    return words;
}

std::map<std::string, int> createWordCount(const std::vector<std::string>& words) {
    std::map<std::string, int> wordCount;
    
    for (const std::string& word : words) {
        wordCount[word]++;
    }
    
    return wordCount;
}

std::map<std::string, double> calculateTFIDF(const std::vector<std::map<std::string, int>>& documentWordCounts, const std::map<std::string, int>& wordCount) {
    std::map<std::string, double> tfidf;
    int numDocuments = documentWordCounts.size();
    
    for (const auto& wordEntry : wordCount) {
        const std::string& word = wordEntry.first;
        int wordDocumentCount = 0;
        
        // 统计包含该词的文档数
        for (const auto& documentWordCount : documentWordCounts) {
            if (documentWordCount.count(word) > 0) {
                wordDocumentCount++;
            }
        }
        
        // 计算TF-IDF值
        double tf = static_cast<double>(wordEntry.second) / wordCount.size();
        double idf = std::log(static_cast<double>(numDocuments) / (wordDocumentCount + 1));
        double tfidfValue = tf * idf;
        
        tfidf[word] = tfidfValue;
    }
    
    return tfidf;
}

int main() {
    std::string text1 = "Hello, World! This is a sample text.";
    std::string text2 = "Another sample text.";
    
    std::vector<std::string> words1 = extractWords(text1);
    std::vector<std::string> words2 = extractWords(text2);
    
    std::map<std::string, int> wordCount1 = createWordCount(words1);
    std::map<std::string, int> wordCount2 = createWordCount(words2);
    
    std::vector<std::map<std::string, int>> documentWordCounts = {wordCount1, wordCount2};
    
    std::map<std::string, double> tfidf1 = calculateTFIDF(documentWordCounts, wordCount1);
    std::map<std::string, double> tfidf2 = calculateTFIDF(documentWordCounts, wordCount2);
    
    // 打印TF-IDF特征向量
    for (const auto& tfidfEntry : tfidf1) {
        std::cout << tfidfEntry.first << ": " << tfidfEntry.second << std::endl;
    }
    
    return 0;
}

テキスト分類:
テキスト分類は、テキストをさまざまなカテゴリに分割する一般的なテキスト マイニング タスクです。一般的に使用されるテキスト分類アルゴリズムには、Naive Bayes 分類器とサポート ベクター マシン (SVM) が含まれます。以下は、テキスト分類に C を使用するサンプル コードです。

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <cmath>

std::map<std::string, double> trainNaiveBayes(const std::vector<std::map<std::string, int>>& documentWordCounts, const std::vector<int>& labels) {
    std::map<std::string, double> classPriors;
    std::map<std::string, std::map<std::string, double>> featureProbabilities;
    
    int numDocuments = documentWordCounts.size();
    int numFeatures = documentWordCounts[0].size();
    
    std::vector<int> classCounts(numFeatures, 0);
    
    // 统计每个类别的先验概率和特征的条件概率
    for (int i = 0; i < numDocuments; i++) {
        std::string label = std::to_string(labels[i]);
        
        classCounts[labels[i]]++;
        
        for (const auto& wordCount : documentWordCounts[i]) {
            const std::string& word = wordCount.first;
            
            featureProbabilities[label][word] += wordCount.second;
        }
    }
    
    // 计算每个类别的先验概率
    for (int i = 0; i < numFeatures; i++) {
        double classPrior = static_cast<double>(classCounts[i]) / numDocuments;
        classPriors[std::to_string(i)] = classPrior;
    }
    
    // 计算每个特征的条件概率
    for (auto& classEntry : featureProbabilities) {
        std::string label = classEntry.first;
        std::map<std::string, double>& wordProbabilities = classEntry.second;
        
        double totalWords = 0.0;
        for (auto& wordEntry : wordProbabilities) {
            totalWords += wordEntry.second;
        }
        
        for (auto& wordEntry : wordProbabilities) {
            std::string& word = wordEntry.first;
            double& wordCount = wordEntry.second;
            
            wordCount = (wordCount + 1) / (totalWords + numFeatures);  // 拉普拉斯平滑
        }
    }
    
    return classPriors;
}

int predictNaiveBayes(const std::string& text, const std::map<std::string, double>& classPriors, const std::map<std::string, std::map<std::string, double>>& featureProbabilities) {
    std::vector<std::string> words = extractWords(text);
    std::map<std::string, int> wordCount = createWordCount(words);
    
    std::map<std::string, double> logProbabilities;
    
    // 计算每个类别的对数概率
    for (const auto& classEntry : classPriors) {
        std::string label = classEntry.first;
        double classPrior = classEntry.second;
        double logProbability = std::log(classPrior);
        
        for (const auto& wordEntry : wordCount) {
            const std::string& word = wordEntry.first;
            int wordCount = wordEntry.second;
            
            if (featureProbabilities.count(label) > 0 && featureProbabilities.at(label).count(word) > 0) {
                const std::map<std::string, double>& wordProbabilities = featureProbabilities.at(label);
                logProbability += std::log(wordProbabilities.at(word)) * wordCount;
            }
        }
        
        logProbabilities[label] = logProbability;
    }
    
    // 返回概率最大的类别作为预测结果
    int predictedLabel = 0;
    double maxLogProbability = -std::numeric_limits<double>::infinity();
    
    for (const auto& logProbabilityEntry : logProbabilities) {
        std::string label = logProbabilityEntry.first;
        double logProbability = logProbabilityEntry.second;
        
        if (logProbability > maxLogProbability) {
            maxLogProbability = logProbability;
            predictedLabel = std::stoi(label);
        }
    }
    
    return predictedLabel;
}

int main() {
    std::vector<std::string> documents = {
        "This is a positive document.",
        "This is a negative document."
    };
    
    std::vector<int> labels = {
        1, 0
    };
    
    std::vector<std::map<std::string, int>> documentWordCounts;
    for (const std::string& document : documents) {
        std::vector<std::string> words = extractWords(document);
        std::map<std::string, int> wordCount = createWordCount(words);
        documentWordCounts.push_back(wordCount);
    }
    
    std::map<std::string, double> classPriors = trainNaiveBayes(documentWordCounts, labels);
    int predictedLabel = predictNaiveBayes("This is a positive test document.", classPriors, featureProbabilities);
    
    std::cout << "Predicted Label: " << predictedLabel << std::endl;
    
    return 0;
}

概要:
この記事では、C を使用して、テキストの前処理、特徴抽出、テキスト分類などの効率的なテキスト マイニングとテキスト分析を行う方法を紹介します。実際のアプリケーションで役立つことを期待して、コード例を通じてこれらの関数を実装する方法を示します。これらのテクノロジーとツールを通じて、大量のテキスト データをより効率的に処理および分析できます。

以上がC++ を使用して効率的なテキスト マイニングとテキスト分析を行うにはどうすればよいですか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。