import unittest
import numpy as np
import user_code  # ÐºÐ¾Ð´ ÑÑÑÐ´ÐµÐ½ÑÐ°

def _dynamic(tc, ok, ok_msg, fail_msg):
    tc._testMethodName = ok_msg if ok else fail_msg
    (tc.assertTrue if ok else tc.fail)(tc._testMethodName)

ATOL = 1e-10
RTOL = 1e-9

class TestQualityControlProb(unittest.TestCase):

    def test_variables_exist_and_types(self):
        reasons = []

        # Scalars & counts
        total_rods = getattr(user_code, "total_rods", None)
        defective = getattr(user_code, "defective", None)
        long_ = getattr(user_code, "long", None)
        defective_and_long = getattr(user_code, "defective_and_long", None)

        # Probabilities
        P_D_or_L = getattr(user_code, "P_D_or_L", None)
        P_D_given_L = getattr(user_code, "P_D_given_L", None)

        # Sampling params & outputs
        population_mean = getattr(user_code, "population_mean", None)
        population_std = getattr(user_code, "population_std", None)
        sample_size = getattr(user_code, "sample_size", None)
        sample_lengths = getattr(user_code, "sample_lengths", None)
        sample_mean = getattr(user_code, "sample_mean", None)
        sample_variance = getattr(user_code, "sample_variance", None)
        sample_std = getattr(user_code, "sample_std", None)

        # Basic presence & type checks
        if not isinstance(total_rods, (int, np.integer)):
            reasons.append("total_rods must be int")
        if not isinstance(defective, (int, np.integer)):
            reasons.append("defective must be int")
        if not isinstance(long_, (int, np.integer)):
            reasons.append("long must be int")
        if not isinstance(defective_and_long, (int, np.integer)):
            reasons.append("defective_and_long must be int")

        if not isinstance(P_D_or_L, (float, np.floating)):
            reasons.append("P_D_or_L must be float")
        if not isinstance(P_D_given_L, (float, np.floating)):
            reasons.append("P_D_given_L must be float")

        if not isinstance(population_mean, (int, float, np.integer, np.floating)):
            reasons.append("population_mean must be numeric")
        if not isinstance(population_std, (int, float, np.integer, np.floating)):
            reasons.append("population_std must be numeric")
        if not isinstance(sample_size, (int, np.integer)):
            reasons.append("sample_size must be int")

        if not (isinstance(sample_lengths, np.ndarray) and sample_lengths.shape == (sample_size,)):
            reasons.append(f"sample_lengths must be ndarray of shape ({sample_size},)")
        if not isinstance(sample_mean, (float, np.floating)):
            reasons.append("sample_mean must be float")
        if not isinstance(sample_variance, (float, np.floating)):
            reasons.append("sample_variance must be float")
        if not isinstance(sample_std, (float, np.floating)):
            reasons.append("sample_std must be float")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: variables exist with correct types/shapes",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")

    def test_probabilities_correct(self):
        reasons = []

        total_rods = user_code.total_rods
        defective = user_code.defective
        long_ = user_code.long
        defective_and_long = user_code.defective_and_long

        expected_union = (defective/total_rods) + (long_/total_rods) - (defective_and_long/total_rods)
        expected_cond = (defective_and_long/total_rods) / (long_/total_rods)

        if not np.isclose(user_code.P_D_or_L, expected_union, atol=ATOL, rtol=RTOL):
            reasons.append(f"P(D âª L) incorrect: expected {expected_union}, got {user_code.P_D_or_L}")
        if not np.isclose(user_code.P_D_given_L, expected_cond, atol=ATOL, rtol=RTOL):
            reasons.append(f"P(D|L) incorrect: expected {expected_cond}, got {user_code.P_D_given_L}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: probabilities (union & conditional) are correct",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")

    def test_sampling_reproducible_and_stats(self):
        reasons = []

        # Recompute expected sample deterministically with the same seed & params
        population_mean = user_code.population_mean
        population_std = user_code.population_std
        sample_size = user_code.sample_size

        np.random.seed(0)
        expected_sample = np.random.normal(loc=population_mean, scale=population_std, size=sample_size)
        expected_mean = np.mean(expected_sample)
        expected_var = np.var(expected_sample, ddof=1)
        expected_std = np.std(expected_sample, ddof=1)

        # Compare arrays & stats
        if not (isinstance(user_code.sample_lengths, np.ndarray) and user_code.sample_lengths.shape == expected_sample.shape):
            reasons.append("sample_lengths shape mismatch")
        else:
            if not np.allclose(user_code.sample_lengths, expected_sample, atol=1e-12, rtol=1e-12):
                reasons.append("sample_lengths not reproducible with seed=0 and given parameters")

        if not np.isclose(user_code.sample_mean, expected_mean, atol=ATOL, rtol=RTOL):
            reasons.append(f"sample_mean incorrect: expected {expected_mean}, got {user_code.sample_mean}")
        if not np.isclose(user_code.sample_variance, expected_var, atol=ATOL, rtol=RTOL):
            reasons.append(f"sample_variance incorrect (use ddof=1): expected {expected_var}, got {user_code.sample_variance}")
        if not np.isclose(user_code.sample_std, expected_std, atol=ATOL, rtol=RTOL):
            reasons.append(f"sample_std incorrect (use ddof=1): expected {expected_std}, got {user_code.sample_std}")

        _dynamic(self,
                 len(reasons) == 0,
                 "PASS: sampling is reproducible & stats (mean/var/std) correct",
                 "FAIL: " + " | ".join(reasons) if reasons else "FAIL")


test_code.py

Hallitse data-analytiikan kannalta olennaiset matemaattiset perusteet. Syvenny funktioiden, analyysin, lineaarialgebran, todennäköisyyden ja ulottuvuuden vähentämisen ydinkäsitteisiin. Rakenna sekä teoreettista ymmärrystä että käytännön ohjelmointitaitoja vahvistaaksesi kykyäsi analysoida dataa, mallintaa monimutkaisia järjestelmiä ja soveltaa edistyneitä koneoppimismenetelmiä.

Tutustu matemaattisten funktioiden perusteisiin. Opiskele erilaisia algebrallisia ja transsendenttisia funktioita, niiden ominaisuuksia sekä niiden toteuttamista Pythonilla reaalimaailman ongelmien ratkaisemiseksi.

Hallitse joukkojen ja sarjojen käsitteet perusoperaatioista käytännön sovelluksiin. Saat käytännön kokemusta joukko-operaatioiden toteuttamisesta sekä aritmeettisten ja geometristen sarjojen käsittelystä Pythonilla.

Perusteellinen ymmärrys rajoista, derivaatasta, integraaleista ja osittaisderivaatasta. Teorian ja käytännön yhdistäminen toteuttamalla nämä käsitteet Pythonilla ja soveltamalla niitä optimointiin gradienttimenetelmän avulla.

Vahvista osaamista vektoreista, matriiseista ja muunnoksista. Opiskele hajotelmamenetelmiä ja ominaisarvoanalyysiä, ja syvennä käsitteitä Python-ohjelmointitehtävien sekä käytännön data-analytiikkasovellusten avulla.

Syvenny todennäköisyysteoriaan ja tilastotieteeseen. Tarkastele ehdollista todennäköisyyttä, Bayesin kaavaa ja tilastollisia tunnuslukuja. Toteuta keskeisiä käsitteitä Pythonilla, simuloi jakaumia ja vahvista osaamistasi haasteiden ja tietovisojen avulla.

Haaste: Laadunvalvonnan Todennäköisyysanalyysi

Ratkaisu

Awesome!

Haaste: Laadunvalvonnan Todennäköisyysanalyysi

Ratkaisu