In de praktische wetenschappelijke computing zijn signalen vaak vervuild met ruis, waardoor het lastig is om betekenisvolle kenmerken te extraheren. Filtering en piekdetectie zijn essentiële hulpmiddelen voor het analyseren van dergelijke ruisgevoelige gegevens. In deze uitdaging gebruik je `scipy.signal` om een tijdreeks te verwerken door ruis te verwijderen en vervolgens significante pieken te identificeren, die vaak van belang zijn in technische en wetenschappelijke toepassingen.


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

Een uitgebreide cursus ontworpen voor studenten met een sterke wiskundige achtergrond en gemiddelde tot gevorderde Python-vaardigheden, gericht op het benutten van SciPy voor wetenschappelijk rekenen, optimalisatie, integratie en geavanceerde wiskundige bewerkingen.

Verken de structuur, kernmodules en essentiële functies van SciPy voor wetenschappelijk rekenen.

Duik in de krachtige lineaire algebra mogelijkheden van SciPy voor het oplossen van wiskundige problemen uit de praktijk.

Beheers optimalisatietechnieken en algoritmen voor het vinden van nulpunten met behulp van SciPy voor wetenschappelijke en technische vraagstukken.

Verken geavanceerde wiskundige bewerkingen, waaronder integratie, interpolatie en basis signaalverwerking met SciPy.

Challenge: Signaalfiltering en Analyse

Oplossing