Анализ тональности текстов на основе ДСМ-метода

BuildHashSet(dict, "NormalizedTexts\\PlusSamples", out plusSamples, '+');

BuildHashSet(dict, "NormalizedTexts\\MinusSamples", out minusSamples, '-');

BuildHashSet(dict, "NormalizedTexts\\TauSamples", out tauSamples, 't');

// Проверка необходимости проведения процедуры кросс-валидации

if (!error && index < args.Length && args[index][0] == '-' && args[index][1] == 'c')

{

// Запускаем таймер

timer.Start();

string[] str = args[index].Split('/');

int numBlocks = 5;

if (str.Length > 2)

{

error = true;

Console.WriteLine("Ошибка! Неверно задан параметр перекресной проверки");

}

else if (str.Length == 2)

{

try

{

numBlocks = int.Parse(str[1]);

if (numBlocks < 2 || numBlocks > Math.Min(plusSamples.Length, minusSamples.Length))

{

error = true;

Console.WriteLine("Ошибка! Количество блоков должно быть в диапазоне от {0} до {1}", "2",

Math.Min(plusSamples.Length, minusSamples.Length));

}

}

catch

{

error = true;

Console.WriteLine("Ошибка! Неверно задано количество блоков");

}

}

if (!error)

{

// Средние показатели эффективности

EffectMeasure averAffectMeasure = new EffectMeasure();

RandomSort(plusSamples);

RandomSort(minusSamples);

CrossValidator cv = new CrossValidator();

cv.ProcessTexts(plusSamples, minusSamples, ref averAffectMeasure, numBlocks,

imbalance, typeFuncResolution);

timer.Stop();

PrintResultCrossValidation("Average value on " + numBlocks.ToString() + " tests:",

averAffectMeasure, timer.ElapsedMilliseconds);

timer.Reset();

index++;

}

}

// Проверка необходимости классификации тау-текстов

if (!error && index < args.Length && args[index] == "-t")

{

timer.Start();

JsmProcessor jp = new JsmProcessor();

// Список гипотез

List<Hypothesis> plusHypotheses = new List<Hypothesis>();

List<Hypothesis> minusHypotheses = new List<Hypothesis>();

// Индукция

jp.Induction(plusHypotheses, plusSamples);

jp.Induction(minusHypotheses, minusSamples);

List<Hypothesis>[] coincidedHyp;

// Аналогия

jp.Analogy(plusHypotheses, minusHypotheses, tauSamples, out coincidedHyp);

char[] resClassification = new char[tauSamples.Length];

// Классификация тау-текстов

jp.Classification(resClassification, coincidedHyp, imbalance, typeFuncResolution);

timer.Stop();

PrintResultClassification(resClassification, tauSamples, timer.ElapsedMilliseconds);

index++;

}

if (!error && index < args.Length)

{

Console.WriteLine("Ошибка! Команда содержит неизвестные параметры или последовательность параметров задана неверно");

error = true;

}

}

else

{

Console.WriteLine("Ошибка! Неверное количество параметров");

error = true;

}

if (error)

{

Console.WriteLine("Синтаксис команды:");

Console.WriteLine("JSM_VS [-n] [f] [k] [-c/b] [-t] [-help]");

Console.WriteLine("\t-n\tвыполнить нормализацию текстов");

Console.WriteLine("\tf\tтип функции разрешения конфликтов (по умолчанию 1)");

Console.WriteLine("\t\t1\tна основе суммарного кол-ва гипотез");

Console.WriteLine("\t\t2\tна основе суммарного кол-ва характеристик");

Console.WriteLine("\t\t3\tна основе суммарного кол-ва родителей");

Console.WriteLine("\t\t4\tпроизведение кол-ва характеристик на кол-во родителей");

Console.WriteLine("\t\t5\tвзвешенное среднее арифметическое числа характеристик");

Console.WriteLine("\t\t6\tвзвешенное среднее арифметическое числа родителей");

Console.WriteLine("\tk\tкоэффициент дисбаланса (+) и (-) текстов (по умолчанию 1)");

Console.WriteLine("\t-с\tвыполнить перекрестную проверку");

Console.WriteLine("\t\tb\tколичество блоков (по умолчанию 5)");

Console.WriteLine("\t-t\tвыполнить распознавание t-текстов");

Console.WriteLine("\t-help\tвызвать справку по команде");

}

else

Console.WriteLine("Программа успешно выполнена!");

}

}

}

Файл TextNormalizer.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.IO;

using System.Runtime.InteropServices;

namespace JSM_VS

{

class TextNormalizer

{

private struct PROCESS_INFORMATION

{

public IntPtr hProcess;

public IntPtr hThread;

public uint dwProcessId;

public uint dwThreadId;

}

private struct STARTUPINFO

{

public uint cb;

public string lpReserved;

public string lpDesktop;

public string lpTitle;

public uint dwX;

public uint dwY;

public uint dwXSize;

public uint dwYSize;

public uint dwXCountChars;

public uint dwYCountChars;

public uint dwFillAttribute;

public uint dwFlags;

public short wShowWindow;

public short cbReserved2;

public IntPtr lpReserved2;

public IntPtr hStdInput;

public IntPtr hStdOutput;

public IntPtr hStdError;

}

[DllImport("kernel32.dll")]

static extern bool CreateProcess(string lpApplicationName, string lpCommandLine, IntPtr lpProcessAttributes, IntPtr lpThreadAttributes,

bool bInheritHandles, uint dwCreationFlags, IntPtr lpEnvironment,

string lpCurrentDirectory, ref STARTUPINFO lpStartupInfo, out PROCESS_INFORMATION lpProcessInformation);

/// <summary>

/// Процедура нормализации текстов

/// </summary>

/// <param name="source"></param>

/// <param name="destination"></param>

public void Normalize(string source, string destination)

{

DirectoryInfo diSource = new DirectoryInfo(source);

DirectoryInfo diDestination = new DirectoryInfo(destination);

FileInfo[] fiSource = diSource.GetFiles();

for (int i = 0; i < fiSource.Length; i++)

STARTUPINFO si = new STARTUPINFO();

PROCESS_INFORMATION pi = new PROCESS_INFORMATION();

string fileInPath = source + "\\" + fiSource[i].Name;

// Опции программы mystem

// n - построчный режим; каждое слово печатается на новой строке

// l - не печатать исходные словоформы, только леммы и граммемы

// i - печатать грамматическую информацию

string options = " -nli ";

string fileOutPath = destination + "\\" + "norm_" + fiSource[i].Name;

CreateProcess("mystem.exe", "mystem.exe " + fileInPath + options + fileOutPath,

IntPtr.Zero, IntPtr.Zero, false, 0, IntPtr.Zero, null, ref si, out pi);

}

}

}

}

Файл CrossValidation.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace JSM_VS

{

class CrossValidator

{

/// <summary>

/// Вычисление метрик эффективности анализа

/// </summary>

/// <param name="resForPlusTestCollect"></param>

/// <param name="resForMinusTestCollect"></param>

/// <param name="koeff"></param>

static void CalcKoeff(char[] resForPlusTestCollect, char[] resForMinusTestCollect, ref EffectMeasure koeff)

{

int TP = 0, FP = 0, TN = 0, FN = 0;

for (int i = 0; i < resForPlusTestCollect.Length; i++)

{

if (resForPlusTestCollect[i] == '+')

TP++;

else if (resForPlusTestCollect[i] == '-')

FP++;

}

for (int i = 0; i < resForMinusTestCollect.Length; i++)

{

if (resForMinusTestCollect[i] == '-')

TN++;

else if (resForMinusTestCollect[i] == '+')

FN++;

}

koeff.precission = (double)TP / (double)(TP + FP);

koeff.recall = (double)TP / (double)(TP + FN);

koeff.accuracy = (double)(TP + TN) / (double)(TP + TN + FN + FP);

koeff.f1_measure = 2 * koeff.precission * koeff.recall / (koeff.precission + koeff.recall);

}

/// <summary>

/// Запуск процедуры кросс-валидации

/// </summary>

/// <param name="plusSamples"></param>

/// <param name="minusSamples"></param>

/// <param name="averAffectMeasure"></param>

/// <param name="n"></param>

/// <param name="imbalance"></param>

public void ProcessTexts(TextInfo[] plusSamples, TextInfo[] minusSamples,

ref EffectMeasure averAffectMeasure, int n, double imbalance, int typeFuncResolution)

{

for (int i = 0; i < n; i++)

{

// Тестовая коллекция

TextInfo[] plusTestCollection = null;

TextInfo[] minusTestCollection = null;

// Обучающая коллекция

TextInfo[] plusTrainingCollection = null;

TextInfo[] minusTrainingCollection = null;

int sizePlusBlock = plusSamples.Length / n;

int sizeMinusBlock = minusSamples.Length / n;

if (plusSamples.Length - (i + 1) * sizePlusBlock >= sizePlusBlock &&

minusSamples.Length - (i + 1) * sizeMinusBlock >= sizeMinusBlock)

{

// Инициализация тестовой коллекции

plusTestCollection = new TextInfo[sizePlusBlock];

minusTestCollection = new TextInfo[sizeMinusBlock];

for (int j = 0; j < sizePlusBlock; j++)

plusTestCollection[j] = plusSamples[i * sizePlusBlock + j];

for (int j = 0; j < sizeMinusBlock; j++)

minusTestCollection[j] = minusSamples[i * sizeMinusBlock + j];

// Инициализация обучающей коллекции

plusTrainingCollection = new TextInfo[plusSamples.Length - sizePlusBlock];

minusTrainingCollection = new TextInfo[minusSamples.Length - sizeMinusBlock];

for (int j = 0; j < i * sizePlusBlock; j++)

plusTrainingCollection[j] = plusSamples[j];

for (int j = (i + 1) * sizePlusBlock; j < plusSamples.Length; j++)

plusTrainingCollection[j - sizePlusBlock] = plusSamples[j];

for (int j = 0; j < i * sizeMinusBlock; j++)

minusTrainingCollection[j] = minusSamples[j];

for (int j = (i + 1) * sizeMinusBlock; j < minusSamples.Length; j++)

minusTrainingCollection[j - sizeMinusBlock] = minusSamples[j];

}

else

{

// Инициализация тестовой коллекции

plusTestCollection = new TextInfo[plusSamples.Length - i * sizePlusBlock];

minusTestCollection = new TextInfo[minusSamples.Length - i * sizeMinusBlock];

for (int j = 0; j < plusSamples.Length - i * sizePlusBlock; j++)

plusTestCollection[j] = plusSamples[i * sizePlusBlock + j];

for (int j = 0; j < minusSamples.Length - i * sizeMinusBlock; j++)

minusTestCollection[j] = minusSamples[i * sizeMinusBlock + j];

// Инициализация обучающей коллекции

plusTrainingCollection = new TextInfo[i * sizePlusBlock];

minusTrainingCollection = new TextInfo[i * sizeMinusBlock];

for (int j = 0; j < i * sizePlusBlock; j++)

plusTrainingCollection[j] = plusSamples[j];

for (int j = 0; j < i * sizeMinusBlock; j++)

minusTrainingCollection[j] = minusSamples[j];

// Список гипотез

List<Hypothesis> plusHypotheses = new List<Hypothesis>();

List<Hypothesis> minusHypotheses = new List<Hypothesis>();

JsmProcessor jp = new JsmProcessor();

// Индукция

jp.Induction(plusHypotheses, plusTrainingCollection);

jp.Induction(minusHypotheses, minusTrainingCollection);

List<Hypothesis>[] coincidedHypForPlusSamples;

List<Hypothesis>[] coincidedHypForMinusSamples;

// Аналогия

jp.Analogy(plusHypotheses, minusHypotheses, plusTestCollection, out coincidedHypForPlusSamples);

jp.Analogy(plusHypotheses, minusHypotheses, minusTestCollection, out coincidedHypForMinusSamples);

// Обработка примеров классификатором

// '+' - пример положительный

// '-' - пример отрицательный

// 'n' - класс примера не определен

char[] resForPlusTestCollection = new char[plusTestCollection.Length];

char[] resForMinusTestCollection = new char[minusTestCollection.Length];

jp.Classification(resForPlusTestCollection, coincidedHypForPlusSamples, imbalance, typeFuncResolution);

jp.Classification(resForMinusTestCollection, coincidedHypForMinusSamples, imbalance, typeFuncResolution);

EffectMeasure koeff = new EffectMeasure();

CalcKoeff(resForPlusTestCollection, resForMinusTestCollection, ref koeff);

if (i < n)

{

averAffectMeasure.precission += koeff.precission;

averAffectMeasure.recall += koeff.recall;

averAffectMeasure.f1_measure += koeff.f1_measure;

averAffectMeasure.accuracy += koeff.accuracy;

}

if (i == n - 1)

{

averAffectMeasure.precission = averAffectMeasure.precission / n;

averAffectMeasure.recall = averAffectMeasure.recall / n;

averAffectMeasure.f1_measure = averAffectMeasure.f1_measure / n;

averAffectMeasure.accuracy = averAffectMeasure.accuracy / n;

}

}

}

}

}

Файл JsmProcessor.cs

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace JSM_VS

{

class JsmProcessor

{

/// <summary>

/// Функция разрешения конфликтов гипотез (количество гипотез)

/// </summary>

/// <param name="coincidedHyp"></param>

/// <param name="k"></param>

/// <returns></returns>

static char ConflictResolution(List<Hypothesis> coincidedHyp, double k)

{

int countPlusHyp = 0, countMinusHyp = 0;

for (int i = 0; i < coincidedHyp.Count; i++)

if (coincidedHyp[i].type == '+')

countPlusHyp++;

else

countMinusHyp++;

double res = (double)countPlusHyp - k * (double)countMinusHyp;

if (res > 0)

return '+';

else if (res < 0)

return '-';

else

return 'n';

}

/// <summary>

/// Функция разрешения конфликтов гипотез (суммарное количество характеристик во всех гипотезах)

/// </summary>

/// <param name="coincidedHyp"></param>

/// <param name="k"></param>

/// <returns></returns>

static char ConflictResolution2(List<Hypothesis> coincidedHyp, double k)

{

int countPlusValue = 0, countMinusValue = 0;

for (int i = 0; i < coincidedHyp.Count; i++)

if (coincidedHyp[i].type == '+')

countPlusValue += coincidedHyp[i].setValues.Count;

else

countMinusValue += coincidedHyp[i].setValues.Count;

double res = countPlusValue - k * countMinusValue;

if (res > 0)

return '+';

else if (res < 0)

return '-';

else

return 'n';

}

/// <summary>

/// Функция разрешения конфликтов гипотез (суммарное количество родителей всех гипотез)

/// </summary>

/// <param name="coincidedHyp"></param>

/// <param name="k"></param>

/// <returns></returns>

static char ConflictResolution3(List<Hypothesis> coincidedHyp, double k)

{

int countPlusParent = 0, countMinusParent = 0;

for (int i = 0; i < coincidedHyp.Count; i++)

if (coincidedHyp[i].type == '+')

countPlusParent += coincidedHyp[i].setParents.Count;

else

countMinusParent += coincidedHyp[i].setParents.Count;

double res = countPlusParent - k * countMinusParent;

if (res > 0)

return '+';

else if (res < 0)

return '-';

else

return 'n';

}

/// <summary>

/// Функция разрешения конфликтов гипотез (произведение количества характеристик на количество родителей)

/// </summary>

/// <param name="coincidedHyp"></param>

/// <param name="k"></param>

/// <returns></returns>

static char ConflictResolution4(List<Hypothesis> coincidedHyp, double k)

{

int countPlusHyp = 0, countMinusHyp = 0;

for (int i = 0; i < coincidedHyp.Count; i++)

if (coincidedHyp[i].type == '+')

countPlusHyp += coincidedHyp[i].setValues.Count * coincidedHyp[i].setParents.Count;

else

countMinusHyp += coincidedHyp[i].setValues.Count * coincidedHyp[i].setParents.Count;

double res = countPlusHyp - k * countMinusHyp;

if (res > 0)

return '+';

else if (res < 0)

return '-';

else

return 'n';

}

/// <summary>

/// Функция разрешения конфликтов гипотез (отношение произведения количества характеристик на количество родителей

/// к общему количеству характеристик в совпавших с текстом гипотезах одного класса)

/// </summary>

/// <param name="coincidedHyp"></param>

/// <param name="k"></param>

/// <returns></returns>

static char ConflictResolution5(List<Hypothesis> coincidedHyp, double k)

{

int commonNumValuesPlusHyp = 0, commonNumValuesMinusHyp = 0;

for (int i = 0; i < coincidedHyp.Count; i++)

if (coincidedHyp[i].type == '+')

commonNumValuesPlusHyp += coincidedHyp[i].setValues.Count;

else

commonNumValuesMinusHyp += coincidedHyp[i].setValues.Count;

int countPlusHyp = 0, countMinusHyp = 0;

for (int i = 0; i < coincidedHyp.Count; i++)

if (coincidedHyp[i].type == '+')

countPlusHyp += coincidedHyp[i].setValues.Count * coincidedHyp[i].setParents.Count;

else

countMinusHyp += coincidedHyp[i].setValues.Count * coincidedHyp[i].setParents.Count;

double res = (double)countPlusHyp / (double)commonNumValuesPlusHyp -

k * (double)countMinusHyp / (double)commonNumValuesMinusHyp;

if (res > 0)

return '+';

else if (res < 0)

return '-';

else

return 'n';

}

/// <summary>

/// Функция разрешения конфликтов гипотез (отношение произведения количества характеристик на количество родителей

/// к общему количеству родителей в совпавших с текстом гипотезах одного класса)

/// </summary>

/// <param name="coincidedHyp"></param>

/// <param name="k"></param>

/// <returns></returns>

static char ConflictResolution6(List<Hypothesis> coincidedHyp, double k)

{

int commonNumParentsPlusHyp = 0, commonNumParentsMinusHyp = 0;

for (int i = 0; i < coincidedHyp.Count; i++)

if (coincidedHyp[i].type == '+')

commonNumParentsPlusHyp += coincidedHyp[i].setParents.Count;

else

commonNumParentsMinusHyp += coincidedHyp[i].setParents.Count;

int countPlusHyp = 0, countMinusHyp = 0;

for (int i = 0; i < coincidedHyp.Count; i++)

if (coincidedHyp[i].type == '+')

countPlusHyp += coincidedHyp[i].setValues.Count * coincidedHyp[i].setParents.Count;

else

countMinusHyp += coincidedHyp[i].setValues.Count * coincidedHyp[i].setParents.Count;

double res = (double)countPlusHyp / (double)commonNumParentsPlusHyp

k * (double)countMinusHyp / (double)commonNumParentsMinusHyp;

if (res > 0)

return '+';

else if (res < 0)

return '-';

else

return 'n';

/// <summary>

/// Функция классификации текстов

/// </summary>

/// <param name="res"></param>

/// <param name="coincidedHyp"></param>

/// <param name="k"></param>

/// <param name="typeFuncResolution"></param>

public void Classification(char[] res, List<Hypothesis>[] coincidedHyp, double k, int typeFuncResolution)

{

for (int i = 0; i < coincidedHyp.Length; i++)

switch (typeFuncResolution)

{

case 1:

ConflictResolution(coincidedHyp[i], k);

res[i] = ConflictResolution(coincidedHyp[i], k);

break;

case 2:

ConflictResolution2(coincidedHyp[i], k);

res[i] = ConflictResolution(coincidedHyp[i], k);

break;

case 3:

ConflictResolution3(coincidedHyp[i], k);

res[i] = ConflictResolution(coincidedHyp[i], k);

break;

case 4:

ConflictResolution(coincidedHyp[i], k);

res[i] = ConflictResolution(coincidedHyp[i], k);

break;

case 5:

ConflictResolution(coincidedHyp[i], k);

res[i] = ConflictResolution(coincidedHyp[i], k);

break;

case 6:

ConflictResolution(coincidedHyp[i], k);

res[i] = ConflictResolution(coincidedHyp[i], k);

break;

}

}

/// <summary>

/// Процедура индукции

/// </summary>

/// <param name="hypotheses"></param>

/// <param name="setSamples"></param>

public void Induction(List<Hypothesis> hypotheses, TextInfo[] setSamples)

{

for (int i = 0; i < setSamples.Length; i++)

{

int hypCount1 = hypotheses.Count;

for (int j = 0; j < hypCount1; j++)

{

// Находим пересечение очередного объекта с текущей гипотезой

HashSet<int> newIntersection = new HashSet<int>();

newIntersection.UnionWith(setSamples[i].setValues);

newIntersection.IntersectWith(hypotheses[j].setValues);

// Если пересечение совпадает с текущей гипотезой,

// то добавляем объект в список родителей гипотезы

if (hypotheses[j].setValues.Count == newIntersection.Count &&

hypotheses[j].setValues.SetEquals(newIntersection))

{

hypotheses[j].setParents.Add(i);

}

// иначе проверяем в какие ещё гипотезы входит найденное пересечение// для определения всех родителей новой гипотезы

else

{

Hypothesis newHyp = new Hypothesis();

newHyp.setValues = new HashSet<int>();

newHyp.setValues.UnionWith(newIntersection);

newHyp.setParents = new HashSet<int>();

newHyp.setParents.UnionWith(hypotheses[j].setParents);

newHyp.setParents.Add(i);

newHyp.type = hypotheses[j].type;

int hypCount2 = hypotheses.Count;

int k = 0;

while (k < hypCount2)

{

if (hypotheses[k].setValues.Count == newHyp.setValues.Count &&

hypotheses[k].setValues.SetEquals(newHyp.setValues))

{

hypotheses[k].setParents.UnionWith(newHyp.setParents);

break;

}

else

{

if (hypotheses[k].setValues.SetEquals(newHyp.setValues))

newHyp.setParents.UnionWith(hypotheses[k].setParents);

}

k++;

}

if (k == hypCount2)

hypotheses.Add(newHyp);

}

}

int q = 0;

while (q < i)

{

HashSet<int> newIntersection = new HashSet<int>();

newIntersection.UnionWith(setSamples[i].setValues);

newIntersection.IntersectWith(setSamples[q].setValues);

if (newIntersection.Count == setSamples[i].setValues.Count &&

setSamples[i].setValues.SetEquals(newIntersection))

{

break;

}

q++;

}

if (q == i)

{

Hypothesis newHyp = new Hypothesis();

newHyp.setValues = new HashSet<int>();

newHyp.setValues.UnionWith(setSamples[i].setValues);

newHyp.setParents = new HashSet<int>();

newHyp.setParents.Add(i);

newHyp.type = setSamples[i].type;

hypotheses.Add(newHyp);

}

}

}

/// <summary>

/// Процедура аналогии

/// </summary>

/// <param name="plusHypotheses"></param>

/// <param name="minusHypotheses"></param>

/// <param name="setSamples"></param>

/// <param name="coincidedHyp"></param>

public void Analogy(List<Hypothesis> plusHypotheses, List<Hypothesis> minusHypotheses,

TextInfo[] setSamples, out List<Hypothesis>[] coincidedHyp)

{

coincidedHyp = new List<Hypothesis>[setSamples.Length];

for (int i = 0; i < coincidedHyp.Length; i++)

coincidedHyp[i] = new List<Hypothesis>();

for (int i = 0; i < setSamples.Length; i++)

{

// Поиск совпадений с положительными гипотезами

for (int j = 0; j < plusHypotheses.Count; j++)

{

HashSet<int> intersection = new HashSet<int>();

intersection.UnionWith(setSamples[i].setValues);

intersection.IntersectWith(plusHypotheses[j].setValues);

if (intersection.SetEquals(plusHypotheses[j].setValues))

coincidedHyp[i].Add(plusHypotheses[j]);

}

// Поиск совпадений с отрицательными гипотезами

for (int j = 0; j < minusHypotheses.Count; j++)

{

HashSet<int> intersection = new HashSet<int>();

intersection.UnionWith(setSamples[i].setValues);

intersection.IntersectWith(minusHypotheses[j].setValues);

if (intersection.SetEquals(minusHypotheses[j].setValues))

coincidedHyp[i].Add(minusHypotheses[j]);

}

Размещено на Allbest.ru