Тестирование Edge AI: Валидация ИИ на Устройствах с Ограниченными Ресурсами

import tensorflow as tf
import numpy as np

class ТестерОптимизацииМодели:
    def __init__(self, оригинальная_модель, тестовые_данные):
        self.оригинальная_модель = оригинальная_модель
        self.тестовые_данные = тестовые_данные

    def тестировать_квантизацию(self):
        """Тестировать воздействие квантизации INT8"""
        # Конвертировать в TFLite с квантизацией
        конвертер = tf.lite.TFLiteConverter.from_keras_model(self.оригинальная_модель)
        конвертер.optimizations = [tf.lite.Optimize.DEFAULT]

        def представительный_датасет():
            for данные in self.тестовые_данные.take(100):
                yield [tf.dtypes.cast(данные, tf.float32)]

        конвертер.representative_dataset = представительный_датасет
        конвертер.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]

        квантизованная_модель = конвертер.convert()

        # Оценить точность
        интерпретатор = tf.lite.Interpreter(model_content=квантизованная_модель)
        интерпретатор.allocate_tensors()

        детали_входа = интерпретатор.get_input_details()
 (как обсуждается в [AI Copilot for Test Automation: GitHub Copilot, Amazon CodeWhisperer and the Future of QA](/blog/ai-copilot-testing))        детали_выхода = интерпретатор.get_output_details()

        правильных = 0
        всего = 0

        for изображения, метки in self.тестовые_данные:
            масштаб, нулевая_точка = детали_входа[0]['quantization']
            квантизованный_вход = (изображения / масштаб + нулевая_точка).astype(np.int8)

            интерпретатор.set_tensor(детали_входа[0]['index'], квантизованный_вход)
            интерпретатор.invoke()

            выход = интерпретатор.get_tensor(детали_выхода[0]['index'])

            масштаб, нулевая_точка = детали_выхода[0]['quantization']
            деквантизованный_выход = (выход.astype(np.float32) - нулевая_точка) * масштаб

            предсказания = np.argmax(деквантизованный_выход, axis=1)
            правильных += np.sum(предсказания == метки.numpy())
            всего += len(метки)

        квантизованная_точность = правильных / всего
        _, оригинальная_точность = self.оригинальная_модель.evaluate(self.тестовые_данные)

        return {
            'оригинальная_точность': оригинальная_точность,
            'квантизованная_точность': квантизованная_точность,
            'падение_точности': оригинальная_точность - квантизованная_точность,
            'приемлемо': (оригинальная_точность - квантизованная_точность) < 0.02
        }

import time
import psutil

class ТестерПроизводительностиНаУстройстве:
    def __init__(self, путь_модели):
        self.интерпретатор = tf.lite.Interpreter(model_path=путь_модели)
        self.интерпретатор.allocate_tensors()

    def бенчмарк_инференса(self, тестовые_входы, количество_запусков=100):
        """Бенчмарк инференса на устройстве"""
        детали_входа = self.интерпретатор.get_input_details()

        # Прогрев
        for _ in range(10):
            self.интерпретатор.set_tensor(детали_входа[0]['index'], тестовые_входы[0])
            self.интерпретатор.invoke()

        # Бенчмарк
        латентности = []

        for i in range(количество_запусков):
            начало = time.perf_counter()
            self.интерпретатор.set_tensor(детали_входа[0]['index'], тестовые_входы[i % len(тестовые_входы)])
            self.интерпретатор.invoke()
            конец = time.perf_counter()

            латентность_мс = (конец - начало) * 1000
            латентности.append(латентность_мс)

        return {
            'латентность_мс': {
                'среднее': np.mean(латентности),
                'p50': np.percentile(латентности, 50),
                'p95': np.percentile(латентности, 95),
                'p99': np.percentile(латентности, 99)
            },
            'пропускная_способность_fps': 1000 / np.mean(латентности),
            'соответствует_требованию_реального_времени': np.percentile(латентности, 95) < 50
        }

class ТестерВоздействияБатареи:
    def измерить_потребление_энергии(self, длительность_секунды=60):
        """Измерить разряд батареи во время инференса"""
        import subprocess

        # Сбросить статистику батареи
        subprocess.run(['adb', 'shell', 'dumpsys', 'batterystats', '--reset'])

        # Запустить модель непрерывно
        время_начала = time.time()
        счет_инференса = 0

        while time.time() - время_начала < длительность_секунды:
            интерпретатор = tf.lite.Interpreter(model_path=self.путь_модели)
            интерпретатор.allocate_tensors()
            интерпретатор.invoke()
            счет_инференса += 1

        # Получить статистику батареи
        результат = subprocess.run(
            ['adb', 'shell', 'dumpsys', 'batterystats'],
            capture_output=True,
            text=True
        )

        return {
            'счет_инференса': счет_инференса,
            'инференсов_на_1000мач': 1000 / мощность_на_инференс_мач if мощность_на_инференс_мач > 0 else float('inf')
        }

class КроссУстройственныйТестер:
    def __init__(self, путь_модели):
        self.путь_модели = путь_модели
        self.устройства = []

    def добавить_устройство(self, ид_устройства, спецификации):
        """Зарегистрировать устройство для тестирования"""
        self.устройства.append({
            'ид': ид_устройства,
            'спецификации': спецификации,
            'результаты': None
        })

    def тестировать_все_устройства(self, тестовые_данные):
        """Запустить тесты на всех зарегистрированных устройствах"""
        for устройство in self.устройства:
            print(f"Тестирование на {устройство['спецификации']['название']}...")

            self.развернуть_на_устройство(устройство['ид'], self.путь_модели)

            результаты_производительности = self.запустить_бенчмарк_устройства(устройство['ид'], тестовые_данные)
            точность = self.запустить_тест_точности(устройство['ид'], тестовые_данные)

            устройство['результаты'] = {
                'производительность': результаты_производительности,
                'точность': точность
            }

        return self.анализировать_кросс_устройственные_результаты()

    def анализировать_кросс_устройственные_результаты(self):
        """Анализировать вариацию результатов между устройствами"""
        латентности = [у['результаты']['производительность']['латентность_мс']['p95'] for у in self.устройства]
        точности = [у['результаты']['точность'] for у in self.устройства]

        return {
            'вариация_латентности': {
                'мин': min(латентности),
                'макс': max(латентности),
                'консистентно': (max(латентности) - min(латентности)) / min(латентности) < 0.3
            },
            'вариация_точности': {
                'мин': min(точности),
                'макс': max(точности),
                'консистентно': (max(точности) - min(точности)) < 0.02
            }
        }

class ЭкологическийТестер:
    def тестировать_воздействие_температуры(self, модель, температуры=[0, 25, 45, 60]):
        """Тестировать производительность модели при разных температурах"""
        результаты = {}

        for темп in температуры:
            print(f"Тестирование при {темп}°C...")

            производительность = self.запустить_тест_производительности(модель)
            точность = self.запустить_тест_точности(модель)

            результаты[f'{темп}C'] = {
                'латентность_мс': производительность['латентность_мс']['p95'],
                'точность': точность,
                'термо_троттлинг': производительность['частота_cpu'] < производительность['макс_частота_cpu'] * 0.8
            }

        return результаты