Продам сайты

Реализация алгоритма анализа текста (TF-IDF, BOW)

Анализ текстов — это важный компонент многих систем обработки естественного языка (NLP). Одни из самых популярных методов анализа текста — модели Bag of Words (BOW) и Term Frequency-Inverse Document Frequency (TF-IDF), которые используются для преобразования текстовых данных в числовой формат. В этой статье мы рассмотрим, как можно реализовать эти методы на языке программирования C#. Мы охватим основные концепции, обсудим архитектуру решения и предоставим подробный код для демонстрации.

Модель Bag of Words представляет собой один из самых простых способов нахождения частоты слов в тексте. Она создает плоский словарь всех уникальных слов в наборе документов и подсчитывает, сколько раз каждое слово встречается в каждом документе.

Преимущества BOW:

  • Простота реализации.
  • Хорошо работает для задач классификации текстов на основе частоты слов.

Недостатки BOW:

  • Нет учета порядка слов, что может привести к потере смысловой информации.
  • Все слова рассматриваются как независимые, хотя контекст и синтаксис важны для понимания.

TF-IDF (Term Frequency-Inverse Document Frequency) — это метод, который улучшает модель BOW за счет введения меры значимости слова для набора документов. Он состоит из двух компонентов: частота термина (TF) и обратная документная частота (IDF).

  • Частота термина (TF) показывает, сколько раз слово встречается в конкретном документе.

    [
    TF(t, d) = \frac{\text{Количество раз t в документе } d}{\text{Общее количество терминов в документе } d}
    ]

  • Обратная документная частота (IDF) измеряет уникальность слова по отношению ко всему корпусу документов.

    [
    IDF(t, D) = \log \left(\frac{\text{Количество документов } D}{1 + \text{Количество документов содержащих } t}\right)
    ]

  • TF-IDF — это произведение TF и IDF для слова (t) в документе (d).

    [
    TFIDF(t, d, D) = TF(t, d) \times IDF(t, D)
    ]

Перед тем как приступить к реализации алгоритмов BOW и TF-IDF, необходимо подготовить данные. Для упрощения работы с текстами создадим класс Document, который будет хранить оригинальный текст и его предобработанную версию.

public class Document
{
    public string OriginalText { get; set; }
    public List<string> Tokens { get; set; }

    public Document(string text)
    {
        OriginalText = text;
        Tokens = Tokenize(text);
    }

    private List<string> Tokenize(string text)
    {
        // Простейшая токенизация: разделение по пробелам и удаление знаков пунктуации
        return text.ToLower()
                    .Split(new char[] { ' ', '.', ',', ';', ':', '!', '?' }, StringSplitOptions.RemoveEmptyEntries)
                    .ToList();
    }
}

Для реализации модели Bag of Words создадим класс BOWModel, который будет отвечать за подсчет частотности слов в каждом документе.

public class BOWModel
{
    private Dictionary<string, int> _dictionary;
    private List<Dictionary<string, int>> _documentVectors;

    public BOWModel(List<Document> documents)
    {
        BuildVocabulary(documents);
        CreateDocumentVectors(documents);
    }

    private void BuildVocabulary(List<Document> documents)
    {
        _dictionary = new Dictionary<string, int>();
        foreach (var doc in documents)
        {
            foreach (var token in doc.Tokens.Distinct())
            {
                if (!_dictionary.ContainsKey(token))
                    _dictionary[token] = 0;
                _dictionary[token]++;
            }
        }
    }

    private void CreateDocumentVectors(List<Document> documents)
    {
        _documentVectors = new List<Dictionary<string, int>>();

        foreach (var doc in documents)
        {
            var vector = new Dictionary<string, int>();
            foreach (var token in doc.Tokens.Distinct())
            {
                if (_dictionary.ContainsKey(token))
                    vector[token] = doc.Tokens.Count(t => t == token);
            }
            _documentVectors.Add(vector);
        }
    }

    public Dictionary<string, int> GetVocabulary() => _dictionary;
    public List<Dictionary<string, int>> GetDocumentVectors() => _documentVectors;
}

Теперь перейдем к реализации алгоритма TF-IDF. Мы создадим класс TFIDFModel, который будет строиться на основе уже подготовленной модели BOW.

public class TFIDFModel
{
    private List<Dictionary<string, double>> _tfidfVectors;
    private Dictionary<string, int> _vocabulary;
    private int _totalDocuments;

    public TFIDFModel(BOWModel bowModel)
    {
        _vocabulary = bowModel.GetVocabulary();
        _totalDocuments = bowModel.GetDocumentVectors().Count;
        CalculateTFIDF(bowModel.GetDocumentVectors());
    }

    private void CalculateTFIDF(List<Dictionary<string, int>> documentVectors)
    {
        _tfidfVectors = new List<Dictionary<string, double>>();

        foreach (var docVector in documentVectors)
        {
            var tfidfVector = new Dictionary<string, double>();
            int totalTermsInDoc = 0;

            foreach (var term in docVector.Keys)
            {
                double tf = (double)docVector[term] / _vocabulary.Sum(kvp => kvp.Value);
                double idf = Math.Log((double)_totalDocuments / 
                                      documentVectors.Count(doc => doc.ContainsKey(term)));

                tfidfVector[term] = tf * idf;
                totalTermsInDoc += docVector[term];
            }

            foreach (var term in tfidfVector.Keys)
            {
                // Нормализация по длине документа
                tfidfVector[term] /= Math.Sqrt(totalTermsInDoc);
            }

            _tfidfVectors.Add(tfidfVector);
        }
    }

    public List<Dictionary<string, double>> GetTFIDFVectors() => _tfidfVectors;
}

Теперь, когда у нас есть реализованные модели BOW и TF-IDF, можно создать небольшой демонстрационный скрипт для их интеграции.

public class Program
{
    public static void Main(string[] args)
    {
        List<Document> documents = new List<Document>
        {
            new Document("The cat sat on the mat."),
            new Document("Dogs are amazing pets."),
            new Document("Cats and dogs can be friends.")
        };

        BOWModel bowModel = new BOWModel(documents);
        TFIDFModel tfidfModel = new TFIDFModel(bowModel);

        Console.WriteLine("BOW Vocabulary:");
        foreach (var term in bowModel.GetVocabulary())
        {
            Console.WriteLine($"{term.Key}: {term.Value}");
        }

        Console.WriteLine("\nTF-IDF Vectors:");
        var vectors = tfidfModel.GetTFIDFVectors();

        for (int i = 0; i < documents.Count; i++)
        {
            Console.WriteLine($"Document {i + 1}:");
            foreach (var term in vectors[i])
            {
                Console.WriteLine($"{term.Key}: {term.Value:F3}");
            }
        }
    }
}

В этой статье мы рассмотрели, как можно реализовать модели Bag of Words и TF-IDF на языке программирования C#. Мы начали с подготовки данных для анализа текста, создали класс Document, который выполняет токенизацию. Затем разработали модель BOW для простого посчитывания частотности слов в документе и улучшили её за счёт введения значимости слова через TF-IDF.

Использование этих методов является не только основой для задач классификации текстов, но и предоставляет гибкий подход к анализу больших коллекций данных. Эффективность этих моделей зависит от правильной настройки параметров, а также от того, как они интегрируются с более сложными системами обработки естественного языка.

Разумеется, в реальных приложениях может потребоваться дополнительная предобработка текста: улучшенная токенизация, лемматизация, удаление стоп-слов и другие методы NLP. Однако базовые знания о BOW и TF-IDF могут значительно расширить возможности для работы с текстовой информацией.

После освоения приведенного материала вы можете продолжить изучение более сложных методов NLP, таких как:

  • Нахождение семантического значения слов через Word Embeddings.
  • Использование алгоритмов машинного обучения для классификации и кластеризации текстов.
  • Реализация методов предобработки, включая стемминг и лемматизацию.

Также полезно будет изучить библиотеки для обработки естественного языка на C#, такие как ML.NET, которые могут значительно упростить реализацию сложных алгоритмов.

Оцените статью
Все о языке программирования C#