Выполнил: Меркулов Алексей Дмитриевич
Название работы: Оценка точности процесса обработки информации
Цель работы: Анализ точности вычислений переменных по уравнениям регрессии при имитационном моделировании алгоритмов управления
Номер варианта: Вариант 1
Задание: Оценить точность вычислений переменных по уравнениям регрессии при имитационном моделировании алгоритмов управления
| Параметр | Значение |
|---|---|
| Разрядность АЦП | 8 бит |
| Разрядность процессора | 16 бит |
| Переменная | Описание | Абсолютная погрешность |
|---|---|---|
| Θсм1 | Температура смеси 1 (°C) | ±5.0 |
| Θсм2 | Температура смеси 2 (°C) | ±5.0 |
| Θсм3 | Температура смеси 3 (°C) | ±5.0 |
| R | Коэффициент (безразмерный) | ±0.01 |
| G | Расход газа (тонн) | ±10.0 |
| δмм | δмм | ±0.1 |
| H | Влажность (%) | ±3.0 |
| СFe203 | СFe203 | ±0.005 |
| СSiO2 | СSiO2 | ±0.7 |
| Переменная | Описание | Максимальное значение |
|---|---|---|
| g | Удельный расход газа (м³/кг) | 0.3 |
| П | Количество пузырей (шт/м²) | 100.0 |
Удельный расход газа (м³/кг) (g):
g = -0,107 - 0,0006G + 0,000716θсм2 - 0,00536H
Количество операций: 6
Количество констант: 4
Количество пузырей (шт/м²) (П):
П = -107,76 + 0,038θсм1 - 0,036θсм2 + 0,119θсм3 + 100Re
Количество операций: 9
Количество констант: 5
Основные формулы для расчета погрешностей:
σ² = (Δ/3)² - дисперсия погрешности ввода данныхσ²АЦП = (Диапазон/2ⁿ)²/12 - дисперсия погрешности АЦПσ²τ = Σ(коэф_i² × σ_i²) - трансформационная погрешностьσ²в = k × (Диапазон/2ⁿ)²/12 - вычислительная погрешностьσ²п = m × (Диапазон/2ⁿ)²/12 - параметрическая погрешностьσ²e = σ²τ + σ²в + σ²п - общая погрешностьδ = 100 × (3σe)/номинальное_значение - относительная погрешностьПогрешности представления входных переменных
| Переменная | σ_ввода | σ_АЦП | σ_общ | σ²_ввода | σ²_АЦП | σ²_общ |
|---|---|---|---|---|---|---|
| Θсм1 | 1.666667 | 1.127637 | 2.012298 | 2.777778e+00 | 1.271566e+00 | 4.049344e+00 |
| Θсм2 | 1.666667 | 1.127637 | 2.012298 | 2.777778e+00 | 1.271566e+00 | 4.049344e+00 |
| Θсм3 | 1.666667 | 1.127637 | 2.012298 | 2.777778e+00 | 1.271566e+00 | 4.049344e+00 |
| R | 0.003333 | 0.001128 | 0.003519 | 1.111111e-05 | 1.271566e-06 | 1.238268e-05 |
| G | 3.333333 | 1.127637 | 3.518903 | 1.111111e+01 | 1.271566e+00 | 1.238268e+01 |
| H | 1.000000 | 0.112764 | 1.006338 | 1.000000e+00 | 1.271566e-02 | 1.012716e+00 |
Трансформационная погрешность (σ²τ): 3.562860e-05
Стандартное отклонение (στ): 0.005969
Вычислительная погрешность (σ²в): 1.047738e-11
Стандартное отклонение (σв): 0.000003
Параметрическая погрешность (σ²п): 6.984919e-12
Стандартное отклонение (σп): 0.000003
Общая дисперсия (σ²e): 3.562862e-05
Общее стандартное отклонение (σe): 0.005969
Абсолютная погрешность (3σe): ±0.017907
Относительная погрешность (δ): 5.97%
Трансформационная погрешность (σ²τ): 1.922647e-01
Стандартное отклонение (στ): 0.438480
Вычислительная погрешность (σ²в): 1.746230e-06
Стандартное отклонение (σв): 0.001321
Параметрическая погрешность (σ²п): 9.701277e-07
Стандартное отклонение (σп): 0.000985
Общая дисперсия (σ²e): 1.922674e-01
Общее стандартное отклонение (σe): 0.438483
Абсолютная погрешность (3σe): ±1.315449
Относительная погрешность (δ): 1.32%
Сводные результаты оценки точности
| Переменная | σ_общ | 3σ_общ | δ, % | Вклад трансф. | Вклад выч. | Вклад пар. |
|---|---|---|---|---|---|---|
| g | 0.005969 | 0.017907 | 5.97% | 100.0% | 0.0% | 0.0% |
| П | 0.438483 | 1.315449 | 1.32% | 100.0% | 0.0% | 0.0% |
Удельный расход газа (м³/кг) (g):
⚠️ Точность вычислений приемлемая, рекомендуется оптимизация
Количество пузырей (шт/м²) (П):
✅ Точность вычислений удовлетворительная
Рекомендации для Удельный расход газа (м³/кг) (g):
Рекомендации для Количество пузырей (шт/м²) (П):
Общие рекомендации по повышению точности:
# lab7_accuracy_assessment.py
# -*- coding: utf-8 -*-
"""
Лабораторная работа №7: Оценка точности процесса обработки информации
Анализ точности вычислений по уравнениям регрессии для алгоритмов управления
"""
import os
import numpy as np
import datetime
from typing import List, Tuple, Dict, Any
import sys
# Попытка импортировать python-docx для генерации .docx отчёта
try:
from docx import Document
from docx.shared import Inches, Pt
from docx.enum.text import WD_ALIGN_PARAGRAPH
PYDOCX_AVAILABLE = True
except Exception:
PYDOCX_AVAILABLE = False
def read_own_source() -> Tuple[bool, str]:
"""
Пытается прочитать исходный код текущего файла и вернуть (успех, текст).
Возвращает (False, сообщение об ошибке) при неудаче.
"""
try:
current_file = os.path.abspath(__file__)
except Exception:
current_file = os.path.abspath(sys.argv[0]) if sys.argv and sys.argv[0] else None
if not current_file or not os.path.exists(current_file):
return False, "Не удалось определить путь к файлу скрипта"
try:
with open(current_file, "r", encoding="utf-8") as f:
src = f.read()
return True, src
except Exception as e:
return False, f"Ошибка при чтении исходного кода: {e}"
class AccuracyAssessmentAnalyzer:
"""Класс для оценки точности процесса обработки информации"""
def __init__(self):
# Технические характеристики системы
self.adc_bits = 8 # Разрядность АЦП
self.processor_bits = 16 # Разрядность процессора
# Абсолютные погрешности входных сигналов
self.input_errors = {
'Θсм1': 5.0, # °C
'Θсм2': 5.0, # °C
'Θсм3': 5.0, # °C
'R': 0.01, # безразмерная
'G': 10.0, # тонн
'δмм': 0.1, # мм
'H': 3.0, # %
'СFe203': 0.005, # %
'СSiO2': 0.7 # %
}
# Максимальные значения расчетных переменных
self.max_values = {
'g': 0.3, # м³/кг
'П': 100.0 # шт/м² (предположительное значение)
}
# Уравнения регрессии
self.regression_equations = {
'g': {
'equation': "g = -0,107 - 0,0006G + 0,000716θсм2 - 0,00536H",
'coefficients': {
'constant': -0.107,
'G': -0.0006,
'Θсм2': 0.000716,
'H': -0.00536
},
'variables': ['G', 'Θсм2', 'H'],
'operations_count': 6, # 3 умножения + 3 сложения
'constants_count': 4 # 4 коэффициента
},
'П': {
'equation': "П = -107,76 + 0,038θсм1 - 0,036θсм2 + 0,119θсм3 + 100Re",
'coefficients': {
'constant': -107.76,
'Θсм1': 0.038,
'Θсм2': -0.036,
'Θсм3': 0.119,
'R': 100.0 # Предполагаем, что Re = R
},
'variables': ['Θсм1', 'Θсм2', 'Θсм3', 'R'],
'operations_count': 9, # 4 умножения + 5 сложений
'constants_count': 5 # 5 коэффициентов
}
}
# Диапазоны изменения входных переменных (предположительные)
self.input_ranges = {
'Θсм1': 1000.0, # °C
'Θсм2': 1000.0, # °C
'Θсм3': 1000.0, # °C
'R': 1.0, # безразмерная
'G': 1000.0, # тонн
'H': 100.0 # %
}
self.results = {}
def calculate_input_representation_error(self) -> Dict[str, float]:
"""Расчет погрешности представления входных переменных в ЭВМ"""
representation_errors = {}
for var_name, error in self.input_errors.items():
if var_name in self.input_ranges:
# Дисперсия погрешности ввода данных: σ² = (Δ/3)²
input_variance = (error / 3) ** 2
# Дисперсия погрешности АЦП: σ²АЦП = (Диапазон/2ⁿ)²/12
adc_quantization = self.input_ranges[var_name] / (2 ** self.adc_bits)
adc_variance = (adc_quantization ** 2) / 12
representation_errors[var_name] = {
'input_variance': input_variance,
'adc_variance': adc_variance,
'total_variance': input_variance + adc_variance,
'input_std': np.sqrt(input_variance),
'adc_std': np.sqrt(adc_variance),
'total_std': np.sqrt(input_variance + adc_variance)
}
return representation_errors
def calculate_transformation_error(self, representation_errors: Dict) -> Dict[str, float]:
"""Расчет трансформационной составляющей погрешности вычислений"""
transformation_errors = {}
for output_var, eq_data in self.regression_equations.items():
transformation_variance = 0.0
for var_name in eq_data['variables']:
if var_name in representation_errors:
coef = eq_data['coefficients'][var_name]
variance = representation_errors[var_name]['total_variance']
transformation_variance += (coef ** 2) * variance
transformation_errors[output_var] = {
'variance': transformation_variance,
'std': np.sqrt(transformation_variance)
}
return transformation_errors
def calculate_computational_error(self) -> Dict[str, float]:
"""Расчет вычислительной составляющей погрешности вычислений"""
computational_errors = {}
for output_var, eq_data in self.regression_equations.items():
# Квантование процессора
processor_quantization = self.max_values[output_var] / (2 ** self.processor_bits)
# Дисперсия вычислительной погрешности: σ²в = k × (Диапазон/2ⁿ)²/12
computational_variance = (eq_data['operations_count'] *
(processor_quantization ** 2) / 12)
computational_errors[output_var] = {
'variance': computational_variance,
'std': np.sqrt(computational_variance)
}
return computational_errors
def calculate_parametric_error(self) -> Dict[str, float]:
"""Расчет параметрической составляющей погрешности вычислений"""
parametric_errors = {}
for output_var, eq_data in self.regression_equations.items():
# Квантование процессора
processor_quantization = self.max_values[output_var] / (2 ** self.processor_bits)
# Дисперсия параметрической погрешности: σ²п = m × (Диапазон/2ⁿ)²/12
parametric_variance = (eq_data['constants_count'] *
(processor_quantization ** 2) / 12)
parametric_errors[output_var] = {
'variance': parametric_variance,
'std': np.sqrt(parametric_variance)
}
return parametric_errors
def calculate_total_error(self, transformation_errors: Dict,
computational_errors: Dict,
parametric_errors: Dict) -> Dict[str, Any]:
"""Расчет общей погрешности вычислений"""
total_errors = {}
for output_var in self.regression_equations.keys():
total_variance = (transformation_errors[output_var]['variance'] +
computational_errors[output_var]['variance'] +
parametric_errors[output_var]['variance'])
total_std = np.sqrt(total_variance)
# Относительная погрешность: δ = 100 × (3σe)/номинальное_значение
relative_error = 100 * (3 * total_std) / self.max_values[output_var]
# Вклад каждой составляющей в общую погрешность
transformation_contribution = (transformation_errors[output_var]['variance'] /
total_variance * 100)
computational_contribution = (computational_errors[output_var]['variance'] /
total_variance * 100)
parametric_contribution = (parametric_errors[output_var]['variance'] /
total_variance * 100)
total_errors[output_var] = {
'total_variance': total_variance,
'total_std': total_std,
'relative_error': relative_error,
'contributions': {
'transformation': transformation_contribution,
'computational': computational_contribution,
'parametric': parametric_contribution
},
'absolute_error_3sigma': 3 * total_std
}
return total_errors
def analyze(self) -> Dict[str, Any]:
"""Выполнение полного анализа точности обработки информации"""
# 1. Расчет погрешности представления входных переменных
representation_errors = self.calculate_input_representation_error()
# 2. Расчет трансформационной составляющей
transformation_errors = self.calculate_transformation_error(representation_errors)
# 3. Расчет вычислительной составляющей
computational_errors = self.calculate_computational_error()
# 4. Расчет параметрической составляющей
parametric_errors = self.calculate_parametric_error()
# 5. Расчет общей погрешности
total_errors = self.calculate_total_error(transformation_errors,
computational_errors,
parametric_errors)
# Сохранение результатов
self.results = {
'representation_errors': representation_errors,
'transformation_errors': transformation_errors,
'computational_errors': computational_errors,
'parametric_errors': parametric_errors,
'total_errors': total_errors,
'technical_specs': {
'adc_bits': self.adc_bits,
'processor_bits': self.processor_bits
}
}
return self.results
def get_improvement_recommendations(self) -> Dict[str, List[str]]:
"""Рекомендации по уменьшению погрешности"""
recommendations = {
'g': [],
'П': []
}
for output_var in self.regression_equations.keys():
contributions = self.results['total_errors'][output_var]['contributions']
relative_error = self.results['total_errors'][output_var]['relative_error']
# Общие рекомендации
if relative_error > 10:
recommendations[output_var].append(
"Существенное увеличение разрядности АЦП (12-16 бит)")
recommendations[output_var].append(
"Использование процессора с повышенной разрядностью (32 бита)")
recommendations[output_var].append(
"Внедрение алгоритмов коррекции систематических погрешностей")
if contributions['transformation'] > 60:
recommendations[output_var].append(
"Улучшение точности датчиков входных параметров")
recommendations[output_var].append(
"Калибровка измерительных каналов")
recommendations[output_var].append(
"Использование датчиков с меньшей погрешностью")
if contributions['computational'] > 30:
recommendations[output_var].append(
"Оптимизация вычислительного алгоритма")
recommendations[output_var].append(
"Использование арифметики с плавающей точкой повышенной точности")
recommendations[output_var].append(
"Внедрение специализированных математических сопроцессоров")
if contributions['parametric'] > 20:
recommendations[output_var].append(
"Хранение коэффициентов с повышенной точностью")
recommendations[output_var].append(
"Использование табличных методов для часто используемых констант")
# Специфические рекомендации
recommendations[output_var].append(
"Регулярная калибровка измерительной системы")
recommendations[output_var].append(
"Статистическая обработка результатов измерений")
recommendations[output_var].append(
"Использование методов цифровой фильтрации сигналов")
return recommendations
def get_algorithm_description(self) -> Dict[str, Any]:
"""Возвращает описание алгоритма и методики расчетов"""
description = {
'title': "Оценка точности процесса обработки информации",
'purpose': "Анализ точности вычислений переменных по уравнениям регрессии при имитационном моделировании алгоритмов управления",
'variant': "Вариант 1",
'methodology': {
'input_representation': "σ² = (Δ/3)² - дисперсия погрешности ввода данных",
'adc_error': "σ²АЦП = (Диапазон/2ⁿ)²/12 - дисперсия погрешности АЦП",
'transformation': "σ²τ = Σ(коэф_i² × σ_i²) - трансформационная погрешность",
'computational': "σ²в = k × (Диапазон/2ⁿ)²/12 - вычислительная погрешность",
'parametric': "σ²п = m × (Диапазон/2ⁿ)²/12 - параметрическая погрешность",
'total': "σ²e = σ²τ + σ²в + σ²п - общая погрешность",
'relative': "δ = 100 × (3σe)/номинальное_значение - относительная погрешность"
},
'variables_description': {
'g': "Удельный расход газа (м³/кг)",
'П': "Количество пузырей (шт/м²)",
'Θсм1': "Температура смеси 1 (°C)",
'Θсм2': "Температура смеси 2 (°C)",
'Θсм3': "Температура смеси 3 (°C)",
'R': "Коэффициент (безразмерный)",
'G': "Расход газа (тонн)",
'H': "Влажность (%)"
}
}
return description
class AccuracyAssessmentMarkdownReport:
"""Класс для генерации полного отчета в Markdown для ЛР7"""
def __init__(self, analyzer: AccuracyAssessmentAnalyzer, analysis_results: Dict[str, Any]):
self.analyzer = analyzer
self.results = analysis_results
def add_header(self, title: str, level: int = 1) -> str:
return f"{'#' * level} {title}\n\n"
def add_table(self, data: List[List[Any]], headers: List[str], title: str = "") -> str:
table_str = ""
if title:
table_str += f"**{title}**\n\n"
table_str += "| " + " | ".join(headers) + " |\n"
table_str += "|" + "|".join(["---"] * len(headers)) + "|\n"
for row in data:
table_str += "| " + " | ".join(map(str, row)) + " |\n"
table_str += "\n"
return table_str
def add_code_section(self) -> str:
success, src = read_own_source()
section = self.add_header("Исходный код программы", 2)
if success:
section += "```python\n" + src
if not src.endswith("\n"):
section += "\n"
section += "```\n"
else:
section += f"*Не удалось прочитать исходный код: {src}*\n"
return section
def generate_report(self) -> str:
report = self.add_header("Лабораторная работа №7: Оценка точности процесса обработки информации", 1)
report += "**Выполнил:** Меркулов Алексей Дмитриевич\n"
# 1) Название, цель работы, номер варианта задания
report += self.add_header("1. Название, цель работы, номер варианта задания", 2)
description = self.analyzer.get_algorithm_description()
report += f"**Название работы:** {description['title']}\n\n"
report += f"**Цель работы:** {description['purpose']}\n\n"
report += f"**Номер варианта:** {description['variant']}\n\n"
report += "**Задание:** Оценить точность вычислений переменных по уравнениям регрессии при имитационном моделировании алгоритмов управления\n\n"
# 2) Исходные данные
report += self.add_header("2. Исходные данные", 2)
# Технические характеристики
report += self.add_header("Технические характеристики системы", 3)
tech_data = [
["Разрядность АЦП", f"{self.analyzer.adc_bits} бит"],
["Разрядность процессора", f"{self.analyzer.processor_bits} бит"]
]
report += self.add_table(tech_data, ["Параметр", "Значение"])
# Погрешности входных сигналов
report += self.add_header("Абсолютные погрешности входных сигналов", 3)
error_data = []
for var_name, error in self.analyzer.input_errors.items():
var_desc = description['variables_description'].get(var_name, var_name)
error_data.append([var_name, var_desc, f"±{error}"])
report += self.add_table(error_data, ["Переменная", "Описание", "Абсолютная погрешность"])
# Максимальные значения
report += self.add_header("Максимальные значения расчетных переменных", 3)
max_val_data = []
for var_name, max_val in self.analyzer.max_values.items():
var_desc = description['variables_description'].get(var_name, var_name)
max_val_data.append([var_name, var_desc, f"{max_val}"])
report += self.add_table(max_val_data, ["Переменная", "Описание", "Максимальное значение"])
# Уравнения регрессии
report += self.add_header("Уравнения регрессии", 3)
for output_var, eq_data in self.analyzer.regression_equations.items():
var_desc = description['variables_description'].get(output_var, output_var)
report += f"**{var_desc} ({output_var}):**\n"
report += f"`{eq_data['equation']}`\n\n"
report += f"Количество операций: {eq_data['operations_count']}\n"
report += f"Количество констант: {eq_data['constants_count']}\n\n"
# 3) Методика расчетов
report += self.add_header("3. Методика расчетов", 2)
methodology = description['methodology']
report += "**Основные формулы для расчета погрешностей:**\n\n"
for key, formula in methodology.items():
report += f"- {key}: `{formula}`\n"
report += "\n"
# 4) Расчеты погрешностей представления входных переменных
report += self.add_header("4. Расчеты погрешностей представления входных переменных в ЭВМ", 2)
rep_errors = self.results['representation_errors']
rep_data = []
for var_name, errors in rep_errors.items():
rep_data.append([
var_name,
f"{errors['input_std']:.6f}",
f"{errors['adc_std']:.6f}",
f"{errors['total_std']:.6f}",
f"{errors['input_variance']:.6e}",
f"{errors['adc_variance']:.6e}",
f"{errors['total_variance']:.6e}"
])
report += self.add_table(rep_data,
["Переменная", "σ_ввода", "σ_АЦП", "σ_общ", "σ²_ввода", "σ²_АЦП", "σ²_общ"],
"Погрешности представления входных переменных")
# 5) Расчеты погрешностей вычисления по регрессионным уравнениям
report += self.add_header("5. Расчеты погрешностей вычисления по регрессионным уравнениям", 2)
# Для переменной g
report += self.add_header("5.1. Переменная g (удельный расход газа)", 3)
g_data = self._generate_variable_calculation_data('g')
report += g_data
# Для переменной П
report += self.add_header("5.2. Переменная П (количество пузырей)", 3)
p_data = self._generate_variable_calculation_data('П')
report += p_data
# 6) Анализ баланса погрешностей
report += self.add_header("6. Анализ баланса погрешностей и предложения по их уменьшению", 2)
# Сводная таблица погрешностей
report += self.add_header("6.1. Сводная таблица погрешностей", 3)
summary_data = []
for output_var in self.analyzer.regression_equations.keys():
total_error = self.results['total_errors'][output_var]
contributions = total_error['contributions']
summary_data.append([
output_var,
f"{total_error['total_std']:.6f}",
f"{total_error['absolute_error_3sigma']:.6f}",
f"{total_error['relative_error']:.2f}%",
f"{contributions['transformation']:.1f}%",
f"{contributions['computational']:.1f}%",
f"{contributions['parametric']:.1f}%"
])
report += self.add_table(summary_data,
["Переменная", "σ_общ", "3σ_общ", "δ, %", "Вклад трансф.", "Вклад выч.", "Вклад пар."],
"Сводные результаты оценки точности")
# Анализ вкладов
report += self.add_header("6.2. Анализ вклада составляющих погрешности", 3)
for output_var in self.analyzer.regression_equations.keys():
total_error = self.results['total_errors'][output_var]
contributions = total_error['contributions']
var_desc = description['variables_description'].get(output_var, output_var)
report += f"**{var_desc} ({output_var}):**\n"
report += f"- Относительная погрешность: {total_error['relative_error']:.2f}%\n"
report += f"- Трансформационная составляющая: {contributions['transformation']:.1f}%\n"
report += f"- Вычислительная составляющая: {contributions['computational']:.1f}%\n"
report += f"- Параметрическая составляющая: {contributions['parametric']:.1f}%\n\n"
# Интерпретация результатов
if total_error['relative_error'] < 5:
report += "✅ Точность вычислений **удовлетворительная**\n\n"
elif total_error['relative_error'] < 10:
report += "⚠️ Точность вычислений **приемлемая**, рекомендуется оптимизация\n\n"
else:
report += "❌ Точность вычислений **неудовлетворительная**, требуется улучшение\n\n"
# 7) Предложения по уменьшению погрешности
report += self.add_header("6.3. Предложения по уменьшению погрешности", 3)
recommendations = self.analyzer.get_improvement_recommendations()
for output_var, rec_list in recommendations.items():
var_desc = description['variables_description'].get(output_var, output_var)
report += f"**Рекомендации для {var_desc} ({output_var}):**\n"
for i, recommendation in enumerate(rec_list, 1):
report += f"{i}. {recommendation}\n"
report += "\n"
# Общие рекомендации
report += "**Общие рекомендации по повышению точности:**\n"
general_recs = [
"Увеличение разрядности АЦП до 12-16 бит",
"Использование процессоров с разрядностью 32 бита",
"Внедрение алгоритмов коррекции систематических погрешностей",
"Регулярная калибровка измерительных систем",
"Статистическая обработка результатов измерений",
"Использование цифровых фильтров для подавления шумов",
"Оптимизация вычислительных алгоритмов",
"Применение специализированных математических сопроцессоров"
]
for i, rec in enumerate(general_recs, 1):
report += f"{i}. {rec}\n"
report += "\n"
# 8) Выводы
report += self.add_header("7. Выводы", 2)
conclusions = [
"Проведена комплексная оценка точности вычислений по уравнениям регрессии для алгоритмов управления",
"Определены основные составляющие погрешности: трансформационная, вычислительная и параметрическая",
"Установлено, что наибольший вклад в общую погрешность вносит трансформационная составляющая",
"Рассчитаны абсолютные и относительные погрешности для выходных переменных g и П",
"Разработаны конкретные рекомендации по уменьшению погрешности вычислений",
"Показана необходимость оптимизации как аппаратной, так и программной составляющих системы",
"Определены критические параметры системы, требующие первоочередного улучшения",
"Предложены меры по повышению общей точности процесса обработки информации"
]
for i, conclusion in enumerate(conclusions, 1):
report += f"{i}. {conclusion}\n"
report += "\n"
# Исходный код
report += self.add_code_section()
return report
def _generate_variable_calculation_data(self, variable: str) -> str:
"""Генерация данных расчетов для конкретной переменной"""
data = ""
# Трансформационная погрешность
trans_error = self.results['transformation_errors'][variable]
data += f"**Трансформационная погрешность (σ²τ):** {trans_error['variance']:.6e}\n"
data += f"**Стандартное отклонение (στ):** {trans_error['std']:.6f}\n\n"
# Вычислительная погрешность
comp_error = self.results['computational_errors'][variable]
data += f"**Вычислительная погрешность (σ²в):** {comp_error['variance']:.6e}\n"
data += f"**Стандартное отклонение (σв):** {comp_error['std']:.6f}\n\n"
# Параметрическая погрешность
param_error = self.results['parametric_errors'][variable]
data += f"**Параметрическая погрешность (σ²п):** {param_error['variance']:.6e}\n"
data += f"**Стандартное отклонение (σп):** {param_error['std']:.6f}\n\n"
# Общая погрешность
total_error = self.results['total_errors'][variable]
data += f"**Общая дисперсия (σ²e):** {total_error['total_variance']:.6e}\n"
data += f"**Общее стандартное отклонение (σe):** {total_error['total_std']:.6f}\n"
data += f"**Абсолютная погрешность (3σe):** ±{total_error['absolute_error_3sigma']:.6f}\n"
data += f"**Относительная погрешность (δ):** {total_error['relative_error']:.2f}%\n\n"
return data
class AccuracyAssessmentDocxReport:
"""Класс для генерации отчета в формате DOCX для ЛР7"""
def __init__(self, analyzer: AccuracyAssessmentAnalyzer, analysis_results: Dict[str, Any]):
self.analyzer = analyzer
self.results = analysis_results
def add_table_to_docx(self, doc, data: List[List[Any]], headers: List[str], title: str = ""):
"""Добавляет таблицу в DOCX документ"""
if title:
p = doc.add_paragraph()
p.add_run(title).bold = True
p.alignment = WD_ALIGN_PARAGRAPH.CENTER
table = doc.add_table(rows=len(data)+1, cols=len(headers))
table.style = 'Table Grid'
# Заголовки
hdr_cells = table.rows[0].cells
for i, header in enumerate(headers):
hdr_cells[i].text = str(header)
for paragraph in hdr_cells[i].paragraphs:
for run in paragraph.runs:
run.bold = True
# Данные
for i, row in enumerate(data, 1):
row_cells = table.rows[i].cells
for j, cell in enumerate(row):
row_cells[j].text = str(cell)
doc.add_paragraph() # Пустой абзац после таблицы
def generate_docx_report(self, filename: str = "accuracy_assessment_report.docx") -> str:
"""
Генерация отчёта в формате DOCX для оценки точности обработки информации
"""
out_path = os.path.join("results", filename)
if not PYDOCX_AVAILABLE:
print("python-docx не установлен — DOCX отчёт не будет создан")
return out_path
try:
doc = Document()
# Титульная страница
title = doc.add_heading('Лабораторная работа №7', 0)
title.alignment = WD_ALIGN_PARAGRAPH.CENTER
doc.add_heading('Оценка точности процесса обработки информации', level=1)
doc.add_paragraph('Анализ точности вычислений по уравнениям регрессии')
p_info = doc.add_paragraph()
p_info.add_run('Выполнил: ').bold = True
p_info.add_run('Меркулов Алексей Дмитриевич\n')
doc.add_page_break()
# 1) Название, цель работы, номер варианта задания
doc.add_heading('1. Название, цель работы, номер варианта задания', level=1)
description = self.analyzer.get_algorithm_description()
doc.add_paragraph('Название работы: ' + description['title'])
doc.add_paragraph('Цель работы: ' + description['purpose'])
doc.add_paragraph('Номер варианта: ' + description['variant'])
doc.add_paragraph('Задание: Оценить точность вычислений переменных по уравнениям регрессии при имитационном моделировании алгоритмов управления')
# 2) Исходные данные
doc.add_heading('2. Исходные данные', level=1)
# Технические характеристики
doc.add_heading('Технические характеристики системы', level=2)
tech_data = [
["Разрядность АЦП", f"{self.analyzer.adc_bits} бит"],
["Разрядность процессора", f"{self.analyzer.processor_bits} бит"]
]
self.add_table_to_docx(doc, tech_data, ["Параметр", "Значение"])
# Погрешности входных сигналов
doc.add_heading('Абсолютные погрешности входных сигналов', level=2)
error_data = []
for var_name, error in self.analyzer.input_errors.items():
var_desc = description['variables_description'].get(var_name, var_name)
error_data.append([var_name, var_desc, f"±{error}"])
self.add_table_to_docx(doc, error_data, ["Переменная", "Описание", "Абсолютная погрешность"])
# Уравнения регрессии
doc.add_heading('Уравнения регрессии', level=2)
for output_var, eq_data in self.analyzer.regression_equations.items():
var_desc = description['variables_description'].get(output_var, output_var)
doc.add_paragraph(f"{var_desc} ({output_var}): {eq_data['equation']}")
# 3) Расчеты погрешностей
doc.add_heading('3. Расчеты погрешностей представления входных переменных', level=1)
rep_errors = self.results['representation_errors']
rep_data = []
for var_name, errors in rep_errors.items():
rep_data.append([
var_name,
f"{errors['input_std']:.6f}",
f"{errors['adc_std']:.6f}",
f"{errors['total_std']:.6f}"
])
self.add_table_to_docx(doc, rep_data,
["Переменная", "σ_ввода", "σ_АЦП", "σ_общ"],
"Погрешности представления входных переменных")
# 4) Расчеты погрешностей вычисления
doc.add_heading('4. Расчеты погрешностей вычисления по регрессионным уравнениям', level=1)
for output_var in self.analyzer.regression_equations.keys():
var_desc = description['variables_description'].get(output_var, output_var)
doc.add_heading(f'4.{list(self.analyzer.regression_equations.keys()).index(output_var)+1}. {var_desc} ({output_var})', level=2)
total_error = self.results['total_errors'][output_var]
doc.add_paragraph(f"Общая дисперсия (σ²e): {total_error['total_variance']:.6e}")
doc.add_paragraph(f"Общее стандартное отклонение (σe): {total_error['total_std']:.6f}")
doc.add_paragraph(f"Абсолютная погрешность (3σe): ±{total_error['absolute_error_3sigma']:.6f}")
doc.add_paragraph(f"Относительная погрешность (δ): {total_error['relative_error']:.2f}%")
# 5) Анализ баланса погрешностей
doc.add_heading('5. Анализ баланса погрешностей', level=1)
# Сводная таблица
summary_data = []
for output_var in self.analyzer.regression_equations.keys():
total_error = self.results['total_errors'][output_var]
contributions = total_error['contributions']
summary_data.append([
output_var,
f"{total_error['relative_error']:.2f}%",
f"{contributions['transformation']:.1f}%",
f"{contributions['computational']:.1f}%",
f"{contributions['parametric']:.1f}%"
])
self.add_table_to_docx(doc, summary_data,
["Переменная", "δ, %", "Вклад трансф.", "Вклад выч.", "Вклад пар."],
"Сводные результаты оценки точности")
# 6) Предложения по уменьшению погрешности
doc.add_heading('6. Предложения по уменьшению погрешности', level=1)
recommendations = self.analyzer.get_improvement_recommendations()
for output_var, rec_list in recommendations.items():
var_desc = description['variables_description'].get(output_var, output_var)
doc.add_heading(f'Рекомендации для {var_desc} ({output_var})', level=2)
for recommendation in rec_list:
doc.add_paragraph(recommendation, style='List Bullet')
# 7) Выводы
doc.add_heading('7. Выводы', level=1)
conclusions = [
"Проведена комплексная оценка точности вычислений по уравнениям регрессии",
"Определены основные составляющие погрешности вычислений",
"Установлен наибольший вклад трансформационной составляющей в общую погрешность",
"Рассчитаны абсолютные и относительные погрешности для выходных переменных",
"Разработаны рекомендации по уменьшению погрешности вычислений",
"Показана необходимость оптимизации аппаратной и программной составляющих",
"Определены критические параметры системы, требующие улучшения",
"Предложены меры по повышению общей точности обработки информации"
]
for conclusion in conclusions:
doc.add_paragraph(conclusion, style='List Number')
# Исходный код
doc.add_heading('Приложение: Исходный код программы', level=1)
success_src, src_text = read_own_source()
if success_src:
for line in src_text.splitlines():
p = doc.add_paragraph()
run = p.add_run(line)
try:
run.font.name = 'Courier New'
run.font.size = Pt(8)
except Exception:
pass
else:
doc.add_paragraph("Не удалось прочитать исходный код скрипта: " + src_text)
# Сохранение файла
doc.save(out_path)
print(f"DOCX-отчёт сохранён: {out_path}")
except Exception as e:
print(f"Ошибка при генерации DOCX-отчёта: {e}")
raise e
return out_path
def main():
"""Основная функция для выполнения лабораторной работы №7"""
# Создаем анализатор
analyzer = AccuracyAssessmentAnalyzer()
# Выполняем анализ
print("Выполняется оценка точности процесса обработки информации...")
results = analyzer.analyze()
# Создаем папку для результатов
os.makedirs("results", exist_ok=True)
# Генерируем Markdown отчет
md_reporter = AccuracyAssessmentMarkdownReport(analyzer, results)
md_report = md_reporter.generate_report()
# Сохраняем Markdown отчет
with open("README.md", "w", encoding="utf-8") as f:
f.write(md_report)
print("Markdown отчет сохранен: README.md")
# Генерируем DOCX отчет
docx_reporter = AccuracyAssessmentDocxReport(analyzer, results)
docx_path = docx_reporter.generate_docx_report()
# Выводим основные результаты в консоль
print("\n" + "="*80)
print("РЕЗУЛЬТАТЫ ОЦЕНКИ ТОЧНОСТИ ПРОЦЕССА ОБРАБОТКИ ИНФОРМАЦИИ")
print("="*80)
print("\nТЕХНИЧЕСКИЕ ХАРАКТЕРИСТИКИ:")
print("-" * 50)
print(f"Разрядность АЦП: {analyzer.adc_bits} бит")
print(f"Разрядность процессора: {analyzer.processor_bits} бит")
print("\nОЦЕНКА ТОЧНОСТИ ВЫЧИСЛЕНИЙ:")
print("-" * 50)
for output_var in analyzer.regression_equations.keys():
total_error = results['total_errors'][output_var]
contributions = total_error['contributions']
print(f"\n{output_var}:")
print(f" Относительная погрешность: {total_error['relative_error']:.2f}%")
print(f" Абсолютная погрешность (3σ): ±{total_error['absolute_error_3sigma']:.6f}")
print(f" Вклад составляющих:")
print(f" - Трансформационная: {contributions['transformation']:.1f}%")
print(f" - Вычислительная: {contributions['computational']:.1f}%")
print(f" - Параметрическая: {contributions['parametric']:.1f}%")
# Оценка точности
if total_error['relative_error'] < 5:
status = "✅ УДОВЛЕТВОРИТЕЛЬНАЯ"
elif total_error['relative_error'] < 10:
status = "⚠️ ПРИЕМЛЕМАЯ"
else:
status = "❌ НЕУДОВЛЕТВОРИТЕЛЬНАЯ"
print(f" ОБЩАЯ ОЦЕНКА: {status}")
print(f"\nОТЧЕТЫ СОХРАНЕНЫ:")
print("-" * 50)
print(f"✓ Markdown отчет: README.md")
if PYDOCX_AVAILABLE:
print(f"✓ DOCX отчет: {docx_path}")
return results
if __name__ == "__main__":
main()