//-------------------------------------------------------------------------------------------------------------------------------------------------------
/// <summary>
/// Записывает в Data массив строк, считанных из файла filename. Каждая строка содержит не более blockSize символов
/// </summary>
/// <param name="filename">имя входного файла для чтения</param>
/// <param name="blockSize">размер буфера для чтения - 1 Гбайт по умолчанию</param>
/// <returns>Результат операции</returns>
private CalculationResult ReadFile(string filename, int blockSize = 1 << 30)
{
if (!File.Exists(filename))
{
return(new CalculationResult(this, OperationType.FileReading, ResultType.Error));
}
List <string> result = new List <string>();
using (var reader = File.OpenText(filename))
using (ProgressInformer informer = new ProgressInformer("Чтение файла:", reader.BaseStream.Length, "байт"))
{
//Считаем, что входной поток - UTF-8
int tail = reader.BaseStream.Length % blockSize == 0 ? 0 : 1;
char[] buffer = new char[blockSize];
while (reader.Read(buffer, 0, blockSize) > 0)
{
informer.Set(reader.BaseStream.Position);
result.Add(new string(buffer));
}
informer.Set(reader.BaseStream.Length);
}
Data = result;
GC.Collect();
return(new CalculationResult(this, OperationType.FileReading, ResultType.Success));
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------
private CalculationResult CalculateDistances(IEnumerable <Word> words)
{
//Stopwatch sw = new Stopwatch(); //!!!
//sw.Start(); //!!!
int maxCount = words.Count();
if (maxCount == 0)
{
return(new CalculationResult(this, OperationType.DistancesCalculation, ResultType.Error));
}
using (ProgressInformer informer = new ProgressInformer($"Матрица расстояний:", maxCount, measurment: $"слов р{words.First().Rank - 1}", barSize: 64))
{
Stopwatch sw = new Stopwatch();
int step = Math.Max(1, DISTANCES_CALC_STEP);
for (int j = 0; j <= maxCount / step; j++)
{
DB.BeginTransaction();
int from = j * step; //левый индекс диапазона
int to = Math.Min(from + step, maxCount);
informer.Set(to);
IEnumerable <Word> wordsPacket = words.Skip(from).Take(step).ToList();
sw.Restart();
//PositionsMean(wordsPacket);
ContextMatrix(wordsPacket);
sw.Stop();
Debug.WriteLine(sw.Elapsed.TotalSeconds);
DB.Commit();
}
informer.Set(maxCount);
}
Data = null;
return(new CalculationResult(this, OperationType.DistancesCalculation, ResultType.Success));
}
private CalculationResult NormilizeText(IEnumerable <string> text)
{
List <string> result = new List <string>();
using (ProgressInformer informer = new ProgressInformer("Нормализация:", text.Count(), "блоков"))
{
text.Select((s, i) =>
{
informer.Set(i);
result.Add(Parser.Normilize(s));
return(0);
}).ToList();
informer.Set(text.Count());
}
Data = result;
GC.Collect();
return(new CalculationResult(this, OperationType.TextNormalization, ResultType.Success));
}
/// <summary>
/// Записывает коллекцию узлов nodes в БД db
/// </summary>
/// <param name="db"></param>
/// <param name="nodes"></param>
/// <returns></returns>
private int AddNodesToDB(SQLiteConnection db, IEnumerable <GrammarNode> nodes)
{
int saved_rows = 0;
int count = 0;
string text = $"INSERT INTO Grammar(id, word_id, follower) VALUES (@i, @w, @f);";
using (ProgressInformer ibar = new ProgressInformer(
prompt: $"Сохранение:",
max: nodes.Count() - 1,
measurment: $"записей",
barSize: 64, fps: 10))
using (SQLiteCommand cmd = new SQLiteCommand(text, db))
{
cmd.Parameters.Add("@i", System.Data.DbType.Int32);
cmd.Parameters.Add("@w", System.Data.DbType.Int32);
cmd.Parameters.Add("@f", System.Data.DbType.Int32);
foreach (var n in nodes)
{
cmd.Parameters["@i"].Value = n.id;
cmd.Parameters["@w"].Value = n.word_id;
if (n.Followers.Count > 0)
{
n.Followers.Values.ToList().ForEach(f =>
{
cmd.Parameters["@f"].Value = f.id;
saved_rows += cmd.ExecuteNonQuery();
});
}
else
{
cmd.Parameters["@f"].Value = -1;
saved_rows += cmd.ExecuteNonQuery();
}
count++;
ibar.Set(count, false);
}
;
ibar.Set(count, true); // выведем 100% в прогесс-баре
}
return(saved_rows);
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------
private CalculationResult ExtractWords(IEnumerable <string> strings, int rank)
{
using (ProgressInformer informer = new ProgressInformer($"Слова ранга {rank}:", strings.Count(), "", 64))
{
Data = strings.SelectMany((s, i) =>
{
DB.BeginTransaction();
informer.Set(i + 1);
int[] result = ExtractWordsFromString(s, rank);
DB.Commit();
return(result);
}).ToList();
}
return(new CalculationResult(this, OperationType.WordsExtraction, ResultType.Success, Data));
}
public Grammar(IEnumerable <int[]> words)
{
_max_search_depth = -1; // означает построение грамматики без обратного поиска
int count = 0;
links_count = 0;
nodes_count = 1;
// добавляем все слова из полученного списка в грамматику
using (ProgressInformer ibar = new ProgressInformer(prompt: $"Построение:", max: words.Count() - 1, measurment: $"слов", barSize: 64, fps: 10))
{
foreach (var w in words)
{
if (w.Length > 0)
{
Add(w);
count++;
ibar.Set(count, false);
}
}
ibar.Set(count, true);
}
_nodes = null;
GC.Collect();
}
private CalculationResult SplitText(IEnumerable <string> text)
{
List <string> result = new List <string>();
using (ProgressInformer informer = new ProgressInformer("Разбиение на строки:", text.Count() - 1, "блоков"))
{
text.Select((s, i) =>
{
informer.Set(i);
result.AddRange(DB.Split(s));
return(0);
}).ToList();
}
Data = result;
GC.Collect();
return(new CalculationResult(this, OperationType.TextSplitting, ResultType.Success));
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------
private CalculationResult CalculateSimilarity(int rank, int continueFrom = 0)
{
Stopwatch stopwatch = new Stopwatch();
//Функция вычисляет попарные сходства между векторами-строками матрицы расстояний MatrixA и сохраняет результат в БД
List <Word> words = Words(rank).ToList();
Logger.WriteLine($"Вычисление матрицы корреляции для {words.Count} слов ранга {rank}");
int maxCount = words.Count();
long elementsCount = 0;
if (maxCount == 0)
{
Logger.WriteLine($"Отстутсвуют слова для расчета корреляции");
return(new CalculationResult(this, OperationType.SimilarityCalculation, ResultType.Error));
}
int maxIndex = words.Last().Id;
Control.UseBestProviders();
Control.UseMultiThreading();
//Console.WriteLine(MathNet.Numerics.Control.Describe());
int step = Math.Max(1, SIMILARITY_CALC_STEP);
int max_number = maxCount / step;
Logger.WriteLine($"Параметры: шаг={step}, количество={max_number}");
using (ProgressInformer informer = new ProgressInformer(prompt: $"Корреляция:", max: max_number *max_number, measurment: $"слов {rank}", barSize: 64, fps: 10))
{
informer.Set(0, true);
//Вычисления производятся порциями по step строк. Выбирается диапазон величиной step индексов
for (int i = continueFrom; i <= max_number; i++)
{
int startRowNumber = i * step;
int endRowNumber = Math.Min(startRowNumber + step, words.Count - 1);
Logger.WriteLine($"Чтение матрицы для строк {words[startRowNumber].Id}-{words[endRowNumber].Id}");
var asize = DB.GetAMatrixAsTuples(rank, words[startRowNumber].Id, words[endRowNumber].Id, out var rows);
if (asize.Item1 == 0 || asize.Item2 == 0)
{
continue;
}
SparseMatrix A = new SparseMatrix(rows);
//var A = Matrix<double>.Build.SparseOfIndexed(asize.Item1, maxIndex, rows);
for (int j = i; j <= max_number; j++)
{
DB.BeginTransaction();
stopwatch.Restart();
int startColumnNumber = j * step;
int endColumnNumber = Math.Min(startColumnNumber + step, words.Count - 1);
informer.Set(i * max_number + j, false);
Logger.WriteLine($"Чтение матрицы для строк {words[startColumnNumber].Id}-{words[endColumnNumber].Id}");
var bsize = DB.GetAMatrixAsTuples(rank, words[startColumnNumber].Id, words[endColumnNumber].Id, out var columns);
if (bsize.Item1 == 0 || bsize.Item2 == 0)
{
continue;
}
//Logger.WriteLine($"Построение разреженной подматрицы B");
SparseMatrix B = new SparseMatrix(columns);
//var B = Matrix<double>.Build.SparseOfIndexed(bsize.Item1, maxIndex, columns);
elementsCount += MatrixDotSquare(A, B, rank);
//elementsCount += CovariationMKL(A, B, rank);
stopwatch.Stop();
Logger.WriteLine($"[{i}/{max_number},{j}/{max_number}], всего эл-в:{elementsCount}, {stopwatch.Elapsed.TotalSeconds} сек");
DB.Commit();
}
Logger.WriteLine($"Подматрица подобия ({maxCount}x{maxCount}): {stopwatch.Elapsed.TotalSeconds} сек."); //!!!
}
informer.Set(max_number * max_number, true);
}
Data = null;
return(new CalculationResult(this, OperationType.SimilarityCalculation, ResultType.Success));
}