Å tilpasse modeller til eksperimentelle data er en grunnleggende oppgave innen vitenskapelig databehandling, og gjør det mulig å trekke ut meningsfulle trender fra støyende målinger. I tidligere kapitler har du utforsket optimaliserings- og rotfinningsmetoder, samt lært om kurvetilpasning og minste kvadraters metode. Nå skal du anvende disse konseptene i praksis ved å bruke `scipy.optimize.curve_fit` for å tilpasse en polynommodell til et sett med støyende datapunkter. Denne praktiske utfordringen vil hjelpe deg å styrke forståelsen av datatilpasning og utvinning av modellparametere.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import numpy as np

class TestTask(unittest.TestCase):
    def test_coefficients_tuple_length_and_type(self):
        import user_code
        importlib.reload(user_code)
        coeffs = getattr(user_code, 'coefficients', None)
        _dynamic_test(
            self,
            isinstance(coeffs, tuple) and len(coeffs) == 3 and all(isinstance(x, (int, float, np.floating, np.integer)) for x in coeffs),
            "Returned coefficients are a tuple of three numeric values.",
            f"Expected a tuple of three numbers, got: {coeffs}",
        )

    def test_coefficients_approximate_true_values(self):
        import user_code
        importlib.reload(user_code)
        coeffs = getattr(user_code, 'coefficients', None)
        expected = [2.5, -1.3, 0.5]
        tolerance = [0.4, 0.6, 0.7]
        _dynamic_test(
            self,
            coeffs is not None and all(abs(c - e) < t for c, e, t in zip(coeffs, expected, tolerance)),
            "Fitted coefficients are within acceptable tolerance of true values.",
            f"Fitted coefficients {coeffs} are not close to true values {expected}",
        )

    def test_function_works_for_different_data(self):
        import user_code
        import importlib
        import numpy as np
        importlib.reload(user_code)
        fit_func = getattr(user_code, 'fit_noisy_data', None)
        _dynamic_test(
            self,
            callable(fit_func),
            "fit_noisy_data function exists and is callable.",
            "fit_noisy_data function is not defined.",
        )
        np.random.seed(42)
        x = np.linspace(-3, 3, 20)
        y = 1.8 * x**2 + 0.7 * x - 2.2 + np.random.normal(scale=2.0, size=x.shape)
        coeffs = fit_func(x, y)
        expected = [1.8, 0.7, -2.2]
        tolerance = [0.15, 0.7, 0.7]  # Adjusted tolerance for b and c due to noise
        _dynamic_test(
            self,
            isinstance(coeffs, tuple) and len(coeffs) == 3 and all(abs(c - e) < t for c, e, t in zip(coeffs, expected, tolerance)),
            "fit_noisy_data works correctly for new data arrays.",
            f"Returned coefficients {coeffs} are not close to expected {expected} for new data.",
        )

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

Et omfattende kurs utviklet for studenter med solid matematisk bakgrunn og middels til avanserte Python-ferdigheter, med fokus på å utnytte SciPy for vitenskapelig databehandling, optimalisering, integrasjon og avanserte matematiske operasjoner.

Utforsk strukturen, kjernemodulene og essensielle funksjoner i SciPy for vitenskapelig databehandling.

Fordyp deg i SciPys kraftige lineær algebra-funksjoner for å løse matematiske problemer fra virkeligheten.

Bli ekspert på optimaliseringsteknikker og rotfinningsalgoritmer ved bruk av SciPy for vitenskapelige og tekniske problemer.

Utforsk avanserte matematiske operasjoner inkludert integrasjon, interpolasjon og grunnleggende signalbehandling med SciPy.

Challenge: Datafitting i Praksis

Løsning