Comment utiliser C++ pour une exploration et une analyse de texte efficaces ?

Comment utiliser le C++ pour une exploration et une analyse de texte efficaces ?

Vue d'ensemble :
L'exploration de texte et l'analyse de texte sont des tâches importantes dans le domaine de l'analyse de données moderne et de l'apprentissage automatique. Dans cet article, nous présenterons comment utiliser le langage C++ pour une exploration et une analyse de texte efficaces. Nous nous concentrerons sur les techniques de prétraitement de texte, d'extraction de fonctionnalités et de classification de texte, accompagnées d'exemples de code.

Prétraitement du texte :
Avant l'exploration de texte et l'analyse de texte, le texte original doit généralement être prétraité. Le prétraitement comprend la suppression de la ponctuation, des mots vides et des caractères spéciaux, la conversion en lettres minuscules et la radicalisation. Voici un exemple de code pour le prétraitement de texte à l'aide de 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;
}

Extraction de fonctionnalités :
Lors de l'exécution de tâches d'analyse de texte, le texte doit être converti en vecteurs de caractéristiques numériques afin que les algorithmes d'apprentissage automatique puissent le traiter. Les méthodes d'extraction de fonctionnalités couramment utilisées incluent les modèles de sac de mots et TF-IDF. Voici un exemple de code pour le modèle de sac de mots et l'extraction de fonctionnalités TF-IDF à l'aide de C++ :

#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;
}

Classification de texte :
La classification de texte est une tâche courante d'exploration de texte qui divise le texte en différentes catégories. Les algorithmes de classification de texte couramment utilisés incluent le classificateur Naive Bayes et la machine à vecteurs de support (SVM). Voici un exemple de code utilisant C++ pour la classification de texte :

#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;
}

Résumé :
Cet article explique comment utiliser C++ pour une exploration et une analyse de texte efficaces, y compris le prétraitement du texte, l'extraction de fonctionnalités et la classification de texte. Nous montrons comment implémenter ces fonctions à travers des exemples de code, dans l'espoir de vous aider dans des applications pratiques. Grâce à ces technologies et outils, vous pouvez traiter et analyser plus efficacement de grandes quantités de données textuelles.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!