morphtree 2.1.0__py3-none-win_amd64.whl

morphtree/_experimental/learning.py

@@ -0,0 +1,418 @@
+from .execution_v2 import SearchBudgetExhausted
+import copy, importlib, importlib.util, json, math, random, tempfile, time
+from ..temporary import OwnedTemporaryDirectory
+from pathlib import Path
+from dataclasses import asdict, replace
+from morphtree.config import AlgorithmGenome, HyperParams
+from morphtree.persistence import read_json, write_json, LoadLimits
+from .runtime_io import artifact_path, configure_temp, reference
+from .admission import digest, sha
+from .support import FamilyChoice, TaskFinalizer, risk
+from .parameter_contract import admit_space
+from .base import Base as Previous, PARAMS, _payloads
+from .preprocessing import TrainEncoder, _m26_rows
+from .training import NativeExecutor, TrainingNotAdmitted
+from .target import detect_target, _split, _NamedRows
+
+class BudgetExhausted(RuntimeError):
+    """Finite opportunity cap; never convergence or a fresh budget."""
+
+class StopRequested(RuntimeError):
+    """Explicit STOP; never a recoverable timeout."""
+
+class VariantUnavailable(ValueError):
+    pass
+
+def stop_reason(*, event, completed_proposals=0, improved=False, full_neighborhood_verified=False):
+    """Typed operational semantics, not a fitted stagnation detector."""
+    direct = {'planned': 'PLANNED_SEARCH_COMPLETE', 'no_actions': 'NO_ADMISSIBLE_CORRECTIVE_ACTION', 'budget': 'BUDGET_EXHAUSTED', 'timeout': 'TIMEOUT', 'stop': 'STOP_REQUESTED', 'error': 'ERROR_OR_INTERRUPTION', 'not_admitted': 'EXECUTION_NOT_ADMITTED'}
+    if event in direct:
+        return direct[event]
+    if type(completed_proposals) is not int or completed_proposals < 1 or type(improved) is not bool:
+        raise ValueError('A completed comparison is required before a stall claim')
+    if event == 'structural' and (not improved):
+        return 'STRUCTURAL_NO_IMPROVEMENT'
+    if event == 'family' and (not improved) and (full_neighborhood_verified is True):
+        return 'FAMILY_SEARCH_STALLED'
+    raise ValueError('No evidence of the requested stall')
+
+def mutation_admission(mode):
+    """Reuse negative knowledge: no scientifically admitted automatic operator.
+
+    This admission decision is not a diagnostic measurement. No labels, OOF,
+    SEARCH or final GUARD are accepted by this function.
+    """
+    if mode not in ('none', 'auto'):
+        raise ValueError('Only none/auto morphing admitted')
+    return {'requested': mode, 'diagnosis_executed': False, 'diagnosis_status': 'OMITTED_DISABLED' if mode == 'none' else 'OMITTED_NO_ADMITTED_CORRECTION', 'information_acquisition': {'new_OOF': 0, 'new_fits': 0, 'measured_seconds': None}, 'eligible_operators': [], 'excluded_operators': [{'id': 'MORPH-013-atomic-trigger', 'reason': 'FAILED_STRONG_CONTROLS'}, {'id': 'MORPH-014-015-simple-mean', 'reason': 'FAILED_BEST_PARENT_CONTROLS'}, {'id': 'historical-lookahead', 'reason': 'NO_INDEPENDENT_DEFAULT_UTILITY'}], 'attempted': [], 'accepted': [], 'rollback': [], 'decision': 'DISABLED' if mode == 'none' else 'RETAIN_CURRENT_NO_ADMITTED_OPERATOR', 'rediagnosis': 'NOT_EXECUTED', 'utility': 'NOT_DEMONSTRATED'}
+
+class LearningControl(Previous):
+    """Private three-task automatic facade, not a production estimator.
+
+    balanced resolves to serial, 30s, boost8/bag8, and at most four numeric
+    trials ONLY with a separately qualified executor. Without such admission,
+    auto skips tuning and explicit optuna refuses before learning. No automatic
+    OOF, structural mutation, composition, refit or final GUARD is enabled.
+    """
+
+    def __init__(self, *, task='auto', families='auto', morphing='auto', tuning='auto', preset='balanced', metric='auto', time_budget='auto', n_trials='auto', n_jobs='auto', random_state=None, verbose=0, capacity=None):
+        self.capacity = copy.deepcopy(capacity)
+        super().__init__(task=task, families=families, morphing=morphing, tuning=tuning, preset=preset, metric=metric, time_budget=time_budget, n_trials=n_trials, n_jobs=n_jobs, random_state=random_state, verbose=verbose)
+
+    def _validate(self):
+        super()._validate()
+        if self.capacity is not None:
+            if type(self.capacity) is not dict or not set(self.capacity) <= {'max_leaves', 'max_depth'}:
+                raise ValueError('capacity supports only max_leaves/max_depth; no inactive options')
+            for name, value in self.capacity.items():
+                if type(value) is not int or not 1 <= value <= {'max_leaves': 16, 'max_depth': 8}[name]:
+                    raise ValueError('Finite integer structural capacity required')
+
+    def get_params(self, deep=True):
+        return copy.deepcopy({k: getattr(self, k) for k in (*PARAMS, 'capacity')})
+
+    def set_params(self, **values):
+        if set(values) - set(self.get_params()):
+            raise ValueError('Unknown estimator parameter')
+        new = type(self)(**self.get_params() | values)
+        self.__dict__ = new.__dict__
+        return self
+
+    def _make_executor(self):
+        return NativeExecutor()
+
+    def _numeric_admitted(self, executor):
+        return False
+
+    def _optional_optuna(self):
+        return importlib.util.find_spec('optuna') is not None
+
+    def _load_optuna(self):
+        return importlib.import_module('optuna')
+
+    def _numeric_plan(self, executor):
+        if self.tuning == 'none':
+            return (None, 'DISABLED', 0)
+        if not self._optional_optuna():
+            if self.tuning == 'optuna':
+                raise ImportError('tuning="optuna" requires optional Optuna before any learning')
+            return (None, 'AUTO_SKIPPED_DEPENDENCY', 0)
+        if not self._numeric_admitted(executor):
+            if self.tuning == 'optuna':
+                raise TrainingNotAdmitted('Explicit numeric execution needs new source-bound fit/trial admission')
+            return (None, 'AUTO_SKIPPED_NUMERIC_ADMISSION', 0)
+        return (self._load_optuna(), 'ADMITTED', 2 if self.n_trials == 'auto' else self.n_trials)
+
+    def _log(self, events, start, operation, **values):
+        event = {'operation': operation, 'seconds_since_start': time.monotonic() - start, **values}
+        self._record_event(copy.deepcopy(event))
+        events.append(event)
+
+    def fit(self, X, y):
+        self._validate()
+        start = time.monotonic()
+        cpu = time.process_time()
+        events = []
+        attempt = {'status': 'INTENT', 'events': events, 'logical_family_requests': 0, 'numeric_callback_requests': 0, 'physical_fits': 'UNKNOWN_AT_UNADMITTED_BOUNDARY', 'best_verified_anchor': None, 'stop_reason': None}
+        self.last_attempt_ = attempt
+
+        def log(operation, **values):
+            self._log(events, start, operation, **values)
+
+        def check():
+            self._execution_check()
+            if time.monotonic() - start >= (150.0 if self.time_budget == 'auto' else self.time_budget):
+                raise TimeoutError('Finite operational deadline, not an algorithmic stall')
+        try:
+            executor = self._make_executor()
+            optuna, tuning_status, trial_cap = self._numeric_plan(executor)
+            check()
+            rows, names = _m26_rows(X)
+            task, targets, classes = detect_target(y, self.task)
+            if len(rows) != len(targets):
+                raise ValueError('Aligned X/y required')
+            metric = 'mse' if task == 'regression' else 'logloss'
+            if self.metric not in ('auto', metric):
+                raise ValueError('Metric is inconsistent with task')
+            seed = self.random_state if self.random_state is not None else random.SystemRandom().randrange(2 ** 31)
+            ti, si = _split(targets, task, seed)
+            log('split', TRAIN=ti, SEARCH=si, GUARD_used=False)
+            encoder = TrainEncoder().fit([rows[i] for i in ti])
+            encoder.state_['names'] = names
+            if encoder.width_ * len(rows) > 2000000:
+                raise ValueError('Expanded input exceeds finite 2000000-cell cap')
+            trainX = encoder.transform(_NamedRows([rows[i] for i in ti], names))
+            searchX = encoder.transform(_NamedRows([rows[i] for i in si], names))
+            ty = [targets[i] for i in ti]
+            sy = [targets[i] for i in si]
+            selection = {'role': 'SEARCH', 'ids': ['SEARCH:' + str(i) for i in si], 'X': searchX, 'y': sy}
+            identity = {'TRAIN': digest({'X': trainX, 'y': ty, 'ids': ti}), 'SEARCH': digest(selection)}
+            params = HyperParams(n_estimators=2, max_leaves=8, max_depth=4, max_bins=15, min_samples_leaf=2, row_fraction=1.0)
+            if self.capacity:
+                params = replace(params, **self.capacity)
+            params = self._parameters(params)
+            families = ['boost', 'bag'] if self.families == 'auto' else [self.families]
+            models = {}
+            packets = {}
+            completed = []
+            trials = []
+
+            def acquire(name, family, p, genome=None):
+                genome = AlgorithmGenome() if genome is None else genome
+                check()
+                if attempt['logical_family_requests'] >= len(families) + trial_cap + self._extra_opportunities():
+                    raise BudgetExhausted('Finite family/trial opportunities exhausted')
+                self._admit_learning_batch(task, family, p, 'COMPLETE_FAMILY_REQUEST')
+                attempt['logical_family_requests'] += 1
+                log('learning_request', id=name, family=family, params=asdict(p))
+                model = executor.fit_family(task, family, trainX, ty, seed=seed, params=p, check=check, genome=genome, identity={**identity, 'preprocessing': encoder.to_dict(), 'seed': seed, 'task': task, 'family': family, 'TRAIN_ids': ['ROW:' + str(i) for i in ti], 'actual_TRAIN_X': trainX, 'actual_TRAIN_y': ty})
+                check()
+                payload = _payloads(model)
+                packet = {'id': name, 'task': task, 'family': family, 'recipe': self._structure_packet(genome, classes, len(model.components), encoder), 'learning_identity': identity, 'params': asdict(p), 'artifact_sha256': digest(payload)}
+                models[name] = model
+                packets[name] = packet
+                completed.append(name)
+                self._capture_report_packet(packet, model, selection, {'X': trainX, 'y': ty})
+                log('learning_completed', id=name, boundary=executor.evidence_level, packet=copy.deepcopy(packet))
+                return packet
+
+            def verify(packet, search):
+                check()
+                name = packet['id']
+                if packet != packets[name] or search != selection or digest(_payloads(models[name])) != packet['artifact_sha256']:
+                    raise ValueError('Changed completed native model, frozen form or SEARCH')
+                return models[name].probabilities_or_values(search['X'])
+            anchor = acquire(families[0], families[0], params)
+            chooser = FamilyChoice(anchor, selection, checkpoint=lambda e: log('family_selection', **e), verify=verify)
+            attempt['best_verified_anchor'] = copy.deepcopy(chooser.best['packet'])
+            try:
+                result = chooser.run(acquire(families[1], families[1], params)) if len(families) > 1 else chooser.best
+            except SearchBudgetExhausted as budget_error:
+                self._budget_stopped('FAMILY', attempt['best_verified_anchor'], attempt, log, budget_error)
+                result = chooser.best
+            selected = result['packet']
+            attempt['best_verified_anchor'] = copy.deepcopy(selected)
+            morph = self._diagnose({'OOF': None, 'admitted_operators': []})
+            log('mutation_admission', **morph)
+            selected, result = self._structural_stage(selected, result, acquire, verify, selection, params, log, attempt)
+            pure = copy.deepcopy(selected)
+            pure_prediction = copy.deepcopy(result['prediction'])
+            frozen_result = TaskFinalizer(selected, selection, numeric_fields=[], max_trials=0, verify=verify, checkpoint=lambda e: log('finalization', **e)).run(None)
+            log('structure_frozen', sha256=digest(selected['recipe']), packet=copy.deepcopy(selected), numeric_budget=trial_cap)
+            self._begin_numeric_window()
+            try:
+                if trial_cap and self._search_budget_open():
+                    space = {'l2': [0.1, 10.0], 'min_samples_leaf': [1, 8]}
+                    if selected['family'] == 'boost':
+                        space['learning_rate'] = [0.03, 0.3]
+                    space = admit_space(space, family=selected['family'], task=task, genome=AlgorithmGenome(**selected['recipe']['genome']))['space']
+
+                    def numeric_checkpoint(e):
+                        log('numeric_selection', **e)
+                        if e['status'] == 'COMPLETED':
+                            attempt['best_verified_anchor'] = copy.deepcopy(packets[e['retained']])
+                    finalizer = TaskFinalizer(selected, selection, numeric_fields=list(space), max_trials=trial_cap, verify=verify, checkpoint=numeric_checkpoint)
+                    study = optuna.create_study(direction='minimize', sampler=optuna.samplers.TPESampler(seed=seed, n_startup_trials=2))
+                    frozen = digest({'family': selected['family'], 'recipe': selected['recipe'], 'fixed_params': {k: v for k, v in selected['params'].items() if k not in space}})
+                    log('structure_frozen', sha256=frozen, space=space)
+
+                    def propose(i, frozen_anchor):
+                        check()
+                        attempt['numeric_callback_requests'] += 1
+                        self._admit_learning_batch(task, frozen_anchor['family'], HyperParams(**frozen_anchor['params']), 'NUMERIC_BEFORE_ASK')
+                        trial = study.ask()
+                        try:
+                            values = {n: trial.suggest_int(n, *b) if n == 'min_samples_leaf' else trial.suggest_float(n, *b, log=True) for n, b in space.items()}
+                            p = replace(HyperParams(**frozen_anchor['params']), **values)
+                            candidate = acquire('trial:' + str(i), frozen_anchor['family'], p, AlgorithmGenome(**frozen_anchor['recipe']['genome']))
+                            loss = finalizer._verified(candidate)['loss']
+                            study.tell(trial, loss)
+                            trials.append({'number': trial.number, 'state': 'COMPLETE', 'params': values, 'SEARCH_primary': loss})
+                            return candidate
+                        except BaseException as primary_error:
+                            if isinstance(primary_error, SearchBudgetExhausted):
+                                self._close_search_budget('NUMERIC_SEARCH_WINDOW_EXHAUSTED')
+                            try:
+                                study.tell(trial, state=optuna.trial.TrialState.FAIL)
+                            except BaseException as cleanup_error:
+                                log('numeric_trial_cleanup_failed', number=trial.number, error=type(cleanup_error).__name__, original_error=type(primary_error).__name__, state='UNRESOLVED')
+                            raise
+                    selected = finalizer.run(propose)['packet']
+                    attempt['best_verified_anchor'] = copy.deepcopy(selected)
+                    tuning_status = 'OPTUNA_CALLBACKS_COMPLETE'
+                elif trial_cap:
+                    tuning_status = 'SKIPPED_SEARCH_BUDGET'
+                    log('numeric_budget_skipped', retained=selected['id'])
+            except SearchBudgetExhausted as budget_error:
+                self._budget_stopped('NUMERIC', attempt['best_verified_anchor'], attempt, log, budget_error)
+                selected = copy.deepcopy(attempt['best_verified_anchor'])
+                tuning_status = 'OPTUNA_STOPPED_SEARCH_BUDGET'
+                log('numeric_search_stopped', retained=selected['id'], reason=tuning_status)
+            self._finish_search_if_public('SEARCH_COMPLETE')
+            check()
+            prediction = verify(selected, selection)
+            primary = risk(task, sy, prediction, list(range(len(classes))))
+            if risk(task, sy, pure_prediction, list(range(len(classes)))) < primary:
+                raise ValueError('Lost verified untuned anchor')
+
+            def recipe(p):
+                return {'schema': 'morph026-frozen-form-v1', 'task': task, 'family': p['family'], 'structure': copy.deepcopy(p['recipe']), 'params': copy.deepcopy(p['params']), 'seed': seed, 'training_identity': copy.deepcopy(identity), 'preprocessing': encoder.to_dict(), 'mutations': []}
+            mock = 'MOCK' in executor.evidence_level
+            report = {'schema': 'morph027-research-report-v1', 'task': task, 'metric': metric, 'classes': classes, 'seed': seed, 'best_family': selected['family'], 'SEARCH_primary': primary, 'selection': 'BEST_VERIFIED_SEARCH_NOT_GENERALIZATION_GUARANTEE', 'families': {'evaluated': [packets[n]['family'] for n in completed if n in families], 'not_evaluated': [f for f in ['boost', 'bag'] if f not in [packets[n]['family'] for n in completed if n in families]], 'exclusion_reason': 'USER_FAMILY_LIMIT_OR_SEARCH_BUDGET'}, 'tuning': tuning_status, 'trials': trials, 'trial_evidence': 'MOCK_DRIVER_NOT_REAL_TRIALS' if mock else 'EXECUTOR_BOUND_NUMERIC_CALLBACKS', 'morphing': morph, 'stop_reason': stop_reason(event='planned'), 'stop_details': {'family': 'FINITE_PREDECLARED_CANDIDATES_COMPLETE_NOT_STALL', 'structural': stop_reason(event='no_actions') if self.morphing == 'auto' else 'DISABLED', 'numeric': 'PLANNED_TRIALS_COMPLETE' if trial_cap else tuning_status, 'global_optimum_claim': False}, 'budget': {'seconds': 150.0 if self.time_budget == 'auto' else self.time_budget, 'processes': 1, 'n_jobs': 1, 'max_family_requests': len(families) + trial_cap + self._extra_opportunities(), 'max_numeric_callbacks': trial_cap, 'model_bytes': 32 * 1024 ** 2, 'expanded_cells': 2000000, 'peak_RAM_limit_qualified': False, 'external_v2_learning_admission_required': True}, 'accounting': {k: attempt[k] for k in ('logical_family_requests', 'numeric_callback_requests', 'physical_fits')}, 'worker_admission': executor.evidence_level, 'events': events, 'refit_performed': False, 'GUARD_used': False, 'final_model_role': 'TRAIN_FITTED_SEARCH_SELECTED', 'wall_seconds': time.monotonic() - start, 'process_cpu_seconds': time.process_time() - cpu, 'descendant_cpu': 'UNKNOWN', 'peak_RSS': 'UNKNOWN', 'cost_scope': 'OPERATIONAL_ONLY_NOT_PERFORMANCE', 'stop_recovery': 'ERROR_OR_STOP_LEAVES_PRIOR_FITTED_OBJECT_UNCHANGED', 'limitations': ['Research import only', 'No new native E2E evidence from software replay', 'No admitted automatic mutation or OOF', 'No independent utility/performance/platform/sklearn qualification', 'No retrainable exported procedure']}
+            variants = {'pure': {'model': models[pure['id']], 'recipe': recipe(pure), 'origin': 'PRE_FINAL_NUMERIC_SEARCH', 'exportable': not mock, 'evidence': executor.evidence_level, 'SEARCH_primary': risk(task, sy, pure_prediction, list(range(len(classes))))}}
+            chosen = 'pure'
+            if trial_cap:
+                variants['tuned'] = {'model': models[selected['id']], 'recipe': recipe(selected), 'origin': 'POST_FINAL_NUMERIC_SEARCH', 'exportable': not mock, 'evidence': executor.evidence_level, 'SEARCH_primary': primary}
+                chosen = 'tuned'
+            learned = {'model_': models[selected['id']], 'encoder_': encoder, 'task_': task, 'n_features_in_': len(rows[0]), 'best_family_': selected['family'], 'best_recipe_': recipe(selected), 'best_params_': copy.deepcopy(selected['params']), 'structure_': copy.deepcopy(selected['recipe']), 'stop_reason_': report['stop_reason'], 'report_': report, '_variants': variants, '_selected_variant': chosen}
+            if task != 'regression':
+                learned['classes_'] = tuple(classes)
+            if names is not None:
+                learned['feature_names_in_'] = tuple(names)
+            for k in list(self.__dict__):
+                if k.endswith('_') and k != 'last_attempt_' or k in ('_variants', '_selected_variant', '_untuned_model', '_untuned_recipe'):
+                    del self.__dict__[k]
+            self.__dict__.update(learned)
+            attempt.update(status='PASS', stop_reason=report['stop_reason'])
+            return self
+        except BaseException as exc:
+            event = 'timeout' if isinstance(exc, TimeoutError) else 'stop' if isinstance(exc, StopRequested) else 'budget' if isinstance(exc, BudgetExhausted) else 'not_admitted' if isinstance(exc, TrainingNotAdmitted) else 'error'
+            attempt.update(status='BLOCKED' if event == 'not_admitted' else 'STOP' if event in ('timeout', 'stop', 'budget') else 'FAIL', stop_reason=stop_reason(event=event), error=type(exc).__name__, message=str(exc))
+            raise
+
+    def _diagnose(self, context):
+        if context != {'OOF': None, 'admitted_operators': []}:
+            raise ValueError('No trained diagnostic producer admitted; GUARD and caller-provided evidence forbidden')
+        return mutation_admission(self.morphing)
+
+    def report(self):
+        value = super().report()
+        value['variants'] = self.available_variants()
+        return value
+
+    def _evaluate_mutation(self, proposal):
+        raise TrainingNotAdmitted('No default structural operator or mutation budget admitted')
+
+    def available_variants(self):
+        self._fitted()
+        return {k: {'origin': v['origin'], 'params': copy.deepcopy(v['recipe']['params']), 'exportable': v['exportable'], 'evidence': v['evidence'], 'SEARCH_primary': v.get('SEARCH_primary')} for k, v in self._variants.items()}
+
+    def _variant(self, name):
+        self._fitted()
+        name = self._selected_variant if name == 'selected' else name
+        if name not in self._variants:
+            raise VariantUnavailable('Requested variant has no retained, verified weights; a separately budgeted fit may be needed')
+        v = self._variants[name]
+        if not v['exportable']:
+            raise VariantUnavailable('Software replay cannot be exported as a newly trained pure/tuned variant')
+        obj = Previous(**{k: v for k, v in self.get_params().items() if k != 'capacity'})
+        for k in ('encoder_', 'task_', 'n_features_in_', 'classes_', 'feature_names_in_'):
+            if hasattr(self, k):
+                setattr(obj, k, copy.deepcopy(getattr(self, k)))
+        obj.model_ = v['model']
+        obj.best_recipe_ = copy.deepcopy(v['recipe'])
+        obj.best_family_ = v['recipe']['family']
+        obj.best_params_ = copy.deepcopy(v['recipe']['params'])
+        obj.report_ = self.report()
+        obj.report_.update(exported_variant=name, SEARCH_primary=v.get('SEARCH_primary'), best_family=obj.best_family_)
+        obj.stop_reason_ = self.stop_reason_
+        return obj
+
+    def export_python(self, path, *, variant='selected'):
+        self._variant(variant).export_python(path)
+
+    def save_recipe(self, path, *, variant='selected'):
+        self._variant(variant).save_recipe(path)
+
+    def save(self, path, *, variant='all'):
+        self._fitted()
+        configure_temp()
+        names = list(self._variants) if variant == 'all' else [self._selected_variant if variant == 'selected' else variant]
+        packed = {}
+        origins = {}
+        with OwnedTemporaryDirectory() as tmp:
+            for name in names:
+                obj = self._variant(name)
+                p = artifact_path(Path(tmp) / (name + '.json'))
+                obj.save(p)
+                packed[name] = read_json(p, LoadLimits(max_bytes=32 * 1024 ** 2))
+                origins[name] = {'origin': self._variants[name]['origin'], 'evidence': self._variants[name]['evidence']}
+        body = {'schema': 'morph027-native-control-v1', 'constructor': self.get_params(), 'selected_variant': self._selected_variant if self._selected_variant in names else names[0], 'variants': packed, 'origins': origins}
+        if len(json.dumps(body, allow_nan=False).encode('utf8')) > 32 * 1024 ** 2:
+            raise ValueError('Bounded total variant payload required')
+        path = artifact_path(path)
+        if path.exists():
+            raise FileExistsError('Never overwrite research model evidence')
+        write_json(path, body)
+
+    @classmethod
+    def load(cls, path):
+        data = read_json(artifact_path(path), LoadLimits(max_bytes=32 * 1024 ** 2))
+        if set(data) != {'schema', 'constructor', 'selected_variant', 'variants', 'origins'} or data['schema'] != 'morph027-native-control-v1':
+            raise ValueError('Exact bounded private control schema required')
+        vs = data['variants']
+        origins = data['origins']
+        if type(vs) is not dict or not vs or (not set(vs) <= {'pure', 'tuned'}) or (set(origins) != set(vs)) or (data['selected_variant'] not in vs):
+            raise ValueError('Bounded named variants required')
+        obj = cls(**data['constructor'])
+        configure_temp()
+        loaded = {}
+        with OwnedTemporaryDirectory() as tmp:
+            for name, body in vs.items():
+                o = origins[name]
+                if set(o) != {'origin', 'evidence'} or o['origin'] not in ('PRE_FINAL_NUMERIC_SEARCH', 'VERIFIED_B0_UNTUNED', 'POST_FINAL_NUMERIC_SEARCH') or (not isinstance(o['evidence'], str)) or ('MOCK' in o['evidence']):
+                    raise ValueError('Explicit genuine variant provenance required')
+                if name == 'pure' and o['origin'] == 'POST_FINAL_NUMERIC_SEARCH' or (name == 'tuned' and o['origin'] != 'POST_FINAL_NUMERIC_SEARCH'):
+                    raise ValueError('Never relabel tuned weights as pure')
+                p = artifact_path(Path(tmp) / (name + '.json'))
+                write_json(p, body)
+                v = Previous.load(p)
+                if v.task_ != body['recipe']['task']:
+                    raise ValueError('Changed task')
+                expected = HyperParams(**v.best_params_)
+                for m in v.model_.components:
+                    actual = asdict(m.params_)
+                    want = asdict(expected if v.best_family_ == 'boost' else replace(expected, n_estimators=1, learning_rate=1.0, row_fraction=1.0))
+                    if actual != want:
+                        raise ValueError('Recipe parameters do not describe the actual weights')
+                if name == 'tuned' and (not v.report_.get('trials') or v.report_.get('trial_evidence') not in ('EXECUTOR_BOUND_NUMERIC_CALLBACKS', 'AUTHENTICATED_HISTORICAL_REAL_TPE4')):
+                    raise ValueError('No executed numeric trajectory for tuned variant')
+                loaded[name] = v
+        v = loaded[data['selected_variant']]
+        for other in loaded.values():
+            if (other.task_, other.classes_ if hasattr(other, 'classes_') else (), other.best_recipe_['structure'], other.best_recipe_['training_identity']) != (v.task_, v.classes_ if hasattr(v, 'classes_') else (), v.best_recipe_['structure'], v.best_recipe_['training_identity']):
+                raise ValueError('Variants must share the same frozen structure/data/map')
+        for k in ('model_', 'encoder_', 'task_', 'n_features_in_', 'classes_', 'feature_names_in_', 'best_family_', 'best_recipe_', 'best_params_', 'stop_reason_', 'report_'):
+            if hasattr(v, k):
+                setattr(obj, k, getattr(v, k))
+        obj.structure_ = copy.deepcopy(v.best_recipe_['structure'])
+        obj._selected_variant = data['selected_variant']
+        obj._variants = {k: {'model': v.model_, 'recipe': copy.deepcopy(v.best_recipe_), **origins[k], 'exportable': True, 'SEARCH_primary': v.report_.get('SEARCH_primary')} for k, v in loaded.items()}
+        return obj
+
+    def export_bundle(self, directory, *, variants=('pure',)):
+        if type(variants) is not tuple or not variants or len(set(variants)) != len(variants):
+            raise ValueError('Distinct variant tuple required')
+        for name in variants:
+            self._variant(name)
+        directory = artifact_path(directory)
+        if directory.exists():
+            raise FileExistsError('New export directory required')
+        directory.mkdir(parents=True)
+        out = []
+        for name in variants:
+            p = directory / (name + '.json')
+            self.save(p, variant=name)
+            out.append(reference(p))
+            p = directory / (name + '-recipe.json')
+            self.save_recipe(p, variant=name)
+            out.append(reference(p))
+            p = directory / (name + '-predictor.py')
+            self.export_python(p, variant=name)
+            out.append(reference(p))
+        p = directory / 'EXPORT.json'
+        write_json(p, {'schema': 'morph027-inference-export-v1', 'status': 'COMPLETE', 'artifacts': out, 'retraining_procedure': 'NOT_SUPPORTED', 'new_fits': 0, 'report': self.report()})
+        return reference(p)
+
+    def export_retrainable(self, path):
+        raise NotImplementedError('Only inference standalone and declarative recipe are qualified; generic retraining admission is missing')

morphtree/_experimental/manifest.json

@@ -0,0 +1,204 @@
+{
+  "Linux_wheel_audit": {
+    "extra_shared_libraries_bundled": 0,
+    "native_ELF_changed": false,
+    "requested_platform": "manylinux_2_17_x86_64",
+    "tool": "auditwheel6.8.2",
+    "versioned_symbols": [
+      "GLIBC_2.2.5"
+    ],
+    "whole_pipeline_on_older_glibc_tested": false
+  },
+  "backend": "automatic-native",
+  "capacity_profile": {
+    "default_estimators": 2,
+    "explicit_verified_estimators": 8,
+    "independent_real_test_confirmed": false,
+    "new_default_adopted": false
+  },
+  "files": {
+    "__init__.py": "a3d4e3364b56f0a2f952a81113f8bc3159f7b5a44d285300ccb6a2dcccd53cb7",
+    "__main__.py": "935a1c1166b0c1ea35a82256345000bf2c73ded718d77773bc27a71ecce28f7d",
+    "_experimental/__init__.py": "af368cce8e8a71327fdf5a8b61c81d6d6fdef62f924800408d7f2b2ca1d82e52",
+    "_experimental/admission.py": "7afaad7937655739b9e6c4f469d337c9ecaeeecbfbe4f435f669d07e8af5022c",
+    "_experimental/base.py": "3b24242af5bdde79eeba086354f23446cbf911f570c0b63246d491abd74316e5",
+    "_experimental/component_cache_v2.py": "8bcdf575213ed71a68fbc79cc86e58d2007e1539dd0e5e22ca80273696c3b78f",
+    "_experimental/evolution_report.py": "0496feeb84cfdde473679713a9432caa581a017db3dfb114fd30da6296bab642",
+    "_experimental/execution_v2.py": "596318d9e55faf9b94ba8430fd78b6152750d299c9ac7778769efd7e4e838c58",
+    "_experimental/facade.py": "0408181efdb8139470a8356a48231bdf357c06c0358c835c89729e8f2833e884",
+    "_experimental/integrated.py": "ccaa9ac5441897492d55ce94b47ead55338274ae1b9127ef9a78e23711311e37",
+    "_experimental/learning.py": "e2e7b68cc27a94451bcc4efa57f9c78d0b8dc3104088a26007a112c255e505c6",
+    "_experimental/numeric_fixture.py": "f05fb8cb1757ebb841863f3a32eb331999bd4c4fc2a51bc1f11cc8a52d6508d9",
+    "_experimental/parameter_contract.py": "261ee3edece961d78ec0bccc0c5c7edc77d0797620d93f916b8fb96bff81fea6",
+    "_experimental/postfit.py": "493ee24a0c8f5eb6374bf0afbf1f1c083de7d96e9750cad4c7fdc1c759d8d9f4",
+    "_experimental/preprocessing.py": "1136e69d814124a90e999a9f5701fdbda716ab623998529ea042c8fb35c1e682",
+    "_experimental/processes.py": "577394affa54f66c0bf0bc55ce1619b0e10a7e4f3177c1af0256196f7347e6b7",
+    "_experimental/producer.py": "07d07410b8e85efbe9e38ed4761f4495f5e909b3f56f8ff1b52abb639e3afebf",
+    "_experimental/product.py": "568b02f61e5f772ab165b72ccf37217c6e48a9d5455480cd1ecbf236893002c4",
+    "_experimental/product_cli.py": "2fdfddfc573a5f5fee5ebd14bdd8aca3e5fbe7e746f169c47347fa9da0247509",
+    "_experimental/roundtrip_v3.py": "fb2999bee513f40e076543323da81385d1ceb7cf68850054f921b3c2c2a37d39",
+    "_experimental/runtime_io.py": "605c37ccf425d48de4ed52456b58414c4577b2018d2932e1aa7e7d30fa06e29c",
+    "_experimental/sampling.py": "a4aeb4536f5cf8280f4166ba7051ca2fb76aad8619958114a799b89afa773975",
+    "_experimental/support.py": "e6108af84a75a39813a3a665d266a913e104168c8a3cfc334cd6293e07101cfc",
+    "_experimental/target.py": "d2da94f69f7a4cf59b8d62bec69cd82f6a8f300827553900e6cba587ce7f1f9c",
+    "_experimental/training.py": "af9e2cc7ebfc7418cad90c3133993990b196fe94be1670f988f0cd8e3cfb70d3",
+    "_experimental/worker.py": "acb03be1dfaef5aac0ebfc5e050d90184d2154e74206fe0fb6c445e705608fc3",
+    "_installed.py": "1346e28b929f4103b2203192fcb9a6949320e232927bc312843390df8e9efcfd",
+    "_native/__init__.py": "f7f1f59f08aba5c94c66779ff4ebeca960675e3350a7fe9613f64dc65c6cea67",
+    "_native/bin/win_amd64/morphtree_kernels.dll": "1c577f636a74d873942d31ab81a1278eda8096252531c52520d00db2471d2a14",
+    "_native/buffers.py": "f51313cf910123eb1729e9f73270f15548691d2be7f9dae5479572828d3541c5",
+    "_native/loader.py": "a099872a1e7341075f9526cc75840bd38aa2908d8999310e885d1859a17068cb",
+    "_native/manifest.json": "0e5ba02d5a565b1fa424b1c1c5fac891bb7082e535d2dceeae65c36df2eec4f3",
+    "_native/runtime.py": "304c82cd811c769a74148580ffcbe4b15e5ffd28ae6fbef1e74af4f2aee8123e",
+    "_native/src/histogram.c": "4b05c05dab1de35c2b8c7cee69cf743b51f746e1d0a14b782df73d3ce959bf39",
+    "_native/src/traversal.c": "487d8ca46c96faded18d99dcda0abcb3c8a0fa783070a7da23dd5692a7a69406",
+    "api.py": "3c333b859bc43bedd8067ae9e6ad297d755a43dc289890c14f876a175301abb9",
+    "api_compat.py": "ba72b57232bda81e0f6392119f662e2e6d1fec9e7fc3571bb0e9ef10e4d89a8b",
+    "backend.py": "881d6025e72cd5675cd6da7b5b2e950d6ade97d63a25735321e5a739c27ef26c",
+    "booster.py": "92040ddb5ec9dec32dc14c3dbb160398ac764f440e3018bff5e99cf374ad066e",
+    "cli.py": "e8b9c79e67e876716b22f1ce86142b24d789d15ec3115d1ad9505d25e08f21f3",
+    "config.py": "d47be3b353ebcd619fb2844beb1e9e5f0b6dea5ff642c579a10c127d57af7ac1",
+    "control.py": "2f1c20f9fdaf426ed02500404874445895a022fa2a00fda65e3f195e651ee3cd",
+    "data.py": "3123850c2f2b8bfa1c7d599697c8cf5f02c162f30f2691d018600d6231cc0451",
+    "diagnostics.py": "4bef87e037d16e58cb03d4d129ebd42db9eac880342c520aef073daca687adbc",
+    "estimators.py": "d387432935d564a357ffa3ea1b6b804583c2d135b93310528273dc1221aff58b",
+    "examples.py": "5b1deccceb772346e3fd5f6d2a9756477d99e458713fa015f125f4d7bef2a635",
+    "exporting.py": "161bebaee9728da105446e937b14ff50dcbefcd6a3ef63b197f357dcf24917f8",
+    "legacy_artifacts.py": "cd70250ffacb20085e32c31f29e4b728caa06ea1cf8ec060b4e455b889e5b309",
+    "metrics.py": "785f2a7d2c0338aca950107699721adea15d61fa7a6b103e471c99b308b4d6c5",
+    "model.py": "389ad29547ddd5eaca0bfdc325627f91f9d4b4734ac44d9aa69296918678dd38",
+    "mutations.py": "4d98f5d9a9b4f786d8d640f478356a3a034a78740a286ea2a0b121cd7a647cb5",
+    "native_lab_backend.py": "871774e0fc08ae448b60725f122df437ba6cf188eb8a3f7681a12bae972c52b5",
+    "numpy_backend.py": "71669be1bf84a96dfcc63fc5b89ecc0f9cf03463313953e573c0d162ccd48152",
+    "optuna_tuner.py": "969ee92fed53955b12de903034caff324714cdcdc1347591dd8d0d1250aa9d90",
+    "persistence.py": "e4c52f6c4dbc227adfa39e362ce5274306d7f320eb4b68f3a3f41a92d1446436",
+    "prediction_output.py": "f36e550b898fb9225b82c0ba0799daa517129debd09b10f346018b8c6d33d964",
+    "prepared_bins.py": "178f9c73744dcaeb6e91943deb23e8f410ef85ec97743f8802f4c3317622abbf",
+    "public.py": "775ef54dd1576f4f0bba15162cd3547e086a9245be4d9cc50c0af0f4a1c3b9db",
+    "resource_plan.py": "bebb6a781627cc1a3494a35747df7f4ffe1350480cf3ec0eb752b92e3558c5b2",
+    "scalable.py": "bed96c724ca3be9c10973f307b98eae3fb33866abc5b38fb72ca2e406b03333d",
+    "scalable_backend.py": "04221e17b552cc30ce600857be62785f55c4e7958b5b90728ceeb20c075effcc",
+    "scalable_checkpoint.py": "24fd03a2f41e5b157b7e1cbd53f2fa0a94977f3d3ee0affd63a3ff9af07212af",
+    "scalable_data.py": "e9a85f44cae2736594b5c76d37fcd36d40f47211b5f7ade9b7a0e62d22de1885",
+    "scalable_receipts.py": "15090c5d9019f21b2f04dbec9a5266a8bf7eb26d4f34320b47ed79cd05530f0d",
+    "scalable_target.py": "7ac25a34f753109756fda9a0e7d80ec57f4dd0186761c1c2ea16fe6760c4de06",
+    "scalable_variants.py": "c35cf11448f3c9f0d58a3fb1c0188c22ba83ccc4e1f0fb4c1527f9488acd75ff",
+    "sklearn_view.py": "5f5aebaca51ff78596ce842cb0d3b500365d42cf087954120fcaa8a6025260e8",
+    "source_markers.py": "0d44fe9364cb4902c16ee0d480dc2a5b843ddaa0ce179791b2d746e158ae6ddd",
+    "species.py": "2b8669426374cdee1eac5c14eac7f7c42b9438c70fc3b0a3af9e191bb40992bf",
+    "temporary.py": "29fc30a9644508d8d5f1f5254eb48e590b48f585947655952424f984edeead15",
+    "training_fragment.py": "3fbe4f25ca3fc3c23a781b2c1a955bb2e05b84f29c422ff92512b003e573848e",
+    "tree.py": "875f93a47b005ad362be77730af6bdb0cd82c39e369ffc525913aab2a2c1f4a5",
+    "tuning.py": "0765b39a34d5825028bb91c6c6af2b68a51164c622895d735722096597e60b66"
+  },
+  "historical_provenance": {
+    "frozen_engine_manifest_sha256": "cd090c6739f9ca4a6463616cff05383d6a200f76e41b50248713f8bb7b077685",
+    "learning_mathematics_changed": false,
+    "original_python_reference_version": "2.1.0",
+    "previous_native_reference_version": "2.1.0"
+  },
+  "native_lab": {
+    "default_backend": "Verified C histograms and cached traversal; equivalent Python traversal below 128 rows",
+    "evidence_campaigns": [
+      "VERSION121",
+      "VERSION122"
+    ],
+    "fresh_RC_profiles": [
+      "WindowsPython3.12.10",
+      "Ubuntu24.04WSL2Python3.12.3"
+    ],
+    "historical_evidence_campaigns": [
+      "RC116",
+      "RC117"
+    ],
+    "historical_training_distribution_version": "3.0.0rc1",
+    "public_release": false,
+    "publication_approved": false,
+    "qualification_labels_only_successor": true,
+    "qualification_scope": "Fresh2.1.0 full installed pipelines VERSION121Windows312 andVERSION122UbuntuWSL2312;3.13/3.14 retained source-lineage training plus fresh installed/inference checks;other platforms not claimed",
+    "qualified_profiles": [
+      {
+        "features": 7,
+        "os": "Windows 11 build 26300 x64",
+        "python": [
+          "3.12.10",
+          "3.13.17",
+          "3.14.9"
+        ],
+        "rows": 25003,
+        "tasks": [
+          "binary",
+          "multiclass",
+          "regression"
+        ]
+      },
+      {
+        "features": 7,
+        "os": "Ubuntu 24.04.4 WSL2 x86_64 glibc 2.39",
+        "python": [
+          "3.12.3",
+          "3.13.17",
+          "3.14.9"
+        ],
+        "rows": 25003,
+        "tasks": [
+          "binary",
+          "multiclass",
+          "regression"
+        ]
+      },
+      {
+        "features": 15,
+        "os": "Windows 11 build 26300 x64",
+        "python": [
+          "3.12.10"
+        ],
+        "rows": [
+          10003,
+          200003
+        ],
+        "tasks": [
+          "binary",
+          "multiclass",
+          "regression"
+        ]
+      }
+    ],
+    "training_distribution_version": "2.1.0",
+    "unqualified": [
+      "Linux small/large training",
+      "million-row training",
+      "Python 3.15 ordinary install",
+      "authentic macOS",
+      "other Linux distributions full pipeline",
+      "hosted Kaggle"
+    ],
+    "version_approved": true,
+    "whole_pipeline_native_qualified": true
+  },
+  "prediction_output_contract": {
+    "class_order": "classes_",
+    "default_standalone": "stdlib Python lists",
+    "new_training": false,
+    "numeric_values_changed": false,
+    "numpy_standalone": "output_format='numpy'",
+    "predict": "numpy.ndarray(n_samples,)",
+    "predict_proba": "numpy.float64(n_samples,n_classes)"
+  },
+  "private_research": false,
+  "public_description": {
+    "README_modified_by_agent": true,
+    "README_sha256": "0c567465e0db8cf91112fef749f83f31d78e5aa48f7088817a3617c91154d9f4",
+    "authorization_sha256": "da902c3c4bc4ca321a2e94e5e4513dc1f714935fa17c1d602c9e08e2d059f0b3",
+    "content_type": "text/markdown",
+    "normalized_description_sha256": "0c567465e0db8cf91112fef749f83f31d78e5aa48f7088817a3617c91154d9f4",
+    "source": "README.md",
+    "source_owner_review_pending": true,
+    "source_revision_authorization": "EXPLICIT_OWNER_DIRECTIVE"
+  },
+  "schema": "morph030-installed-payload-v1",
+  "scientific_training_authority": 0,
+  "scope": "LOCAL_RC_WITH_RETAINED_QUALIFIED_ENGINE",
+  "version": "2.1.0",
+  "workspace_sources_required": false
+}