En la computación científica práctica, las señales suelen estar contaminadas con ruido, lo que dificulta la extracción de características significativas. El filtrado y la detección de picos son herramientas esenciales para analizar este tipo de datos ruidosos. En este desafío, utilizarás `scipy.signal` para procesar una serie temporal eliminando el ruido y luego identificando los picos significativos, que suelen ser de interés en aplicaciones de ingeniería y científicas.


import unittest
import user_code
import ast
import re   
import unittest
import numpy as np
from scipy import signal
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.time = np.linspace(0, 10, 500)
        np.random.seed(0)
        self.clean_signal = np.sin(2 * np.pi * 1.5 * self.time)
        self.noise = np.random.normal(0, 0.5, self.time.shape)
        self.noisy_signal = self.clean_signal + self.noise

    def test_returns_indices(self):
        import user_code
        importlib.reload(user_code)
        indices = user_code.filter_and_find_peaks(self.time, self.noisy_signal)
        _dynamic_test(
            self,
            isinstance(indices, (list, np.ndarray)),
            "Function returns a list or array of indices.",
            f"Expected a list or array, got {type(indices)}."
        )
        _dynamic_test(
            self,
            all(isinstance(i, (int, np.integer)) for i in indices),
            "All returned values are integer indices.",
            "Returned indices are not all integers."
        )

    def test_filter_is_used(self):
        import user_code
        importlib.reload(user_code)
        # Get filtered signal by re-implementing expected filter
        b, a = signal.butter(N=4, Wn=0.1, btype='low')
        filtered = signal.filtfilt(b, a, self.noisy_signal)
        # Find peaks in filtered signal
        expected_peaks, _ = signal.find_peaks(filtered)
        result_peaks = user_code.filter_and_find_peaks(self.time, self.noisy_signal)
        # Test that result is not just peaks from original noisy data
        noisy_peaks, _ = signal.find_peaks(self.noisy_signal)
        # Compare overlap with expected
        overlap = len(set(result_peaks).intersection(set(expected_peaks)))
        _dynamic_test(
            self,
            overlap >= len(expected_peaks) * 0.8,
            "Detected peaks match those found after correct filtering.",
            f"Detected peaks do not match expected peaks after filtering. Overlap: {overlap} / {len(expected_peaks)}"
        )
        # Should not just return peaks from noisy data
        overlap_noisy = len(set(result_peaks).intersection(set(noisy_peaks)))
        _dynamic_test(
            self,
            overlap > overlap_noisy,
            "Peak detection is performed on filtered signal, not raw data.",
            "Peak detection appears to be performed on raw data, not filtered signal."
        )

    def test_indices_are_local_maxima(self):
        import user_code
        importlib.reload(user_code)
        b, a = signal.butter(N=4, Wn=0.1, btype='low')
        filtered = signal.filtfilt(b, a, self.noisy_signal)
        peaks = user_code.filter_and_find_peaks(self.time, self.noisy_signal)
        for idx in peaks:
            if 1 <= idx < len(filtered) - 1:
                cond = filtered[idx] > filtered[idx-1] and filtered[idx] > filtered[idx+1]
                _dynamic_test(
                    self,
                    cond,
                    f"Index {idx} is a local maximum in the filtered signal.",
                    f"Index {idx} is not a local maximum in the filtered signal."
                )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Un curso integral diseñado para estudiantes con sólidos conocimientos matemáticos y habilidades intermedias o avanzadas en Python, enfocado en aprovechar SciPy para la computación científica, optimización, integración y operaciones matemáticas avanzadas.

Explora la estructura, los módulos principales y las características esenciales de SciPy para la computación científica.

Sumérgete en las potentes capacidades de álgebra lineal de SciPy para resolver problemas matemáticos del mundo real.

Domina técnicas de optimización y algoritmos de búsqueda de raíces utilizando SciPy para problemas científicos e ingenieriles.

Explora operaciones matemáticas avanzadas, incluyendo integración, interpolación y procesamiento básico de señales con SciPy.

Desafío: Filtrado y Análisis de Señales

Solución