morphtree 2.1.0__py3-none-win_amd64.whl

morphtree/scalable_variants.py

@@ -0,0 +1,133 @@
+"""Retained genuine model variants. Never train or fabricate absent weights.
+
+pure and tuned are verified TRAIN-stage models. selected is the default final
+model, normally refitted on all eligible input. A bundle stores each distinct
+weight packet once and the original fit history once; no dataset is embedded.
+"""
+import copy,hashlib,json
+from dataclasses import asdict,replace
+from pathlib import Path
+from .persistence import atomic_text
+
+SCHEMA='SCALABLE_PRIVATE_VARIANTS_1'
+NAMES=frozenset(('selected','pure','tuned'))
+BASE_KEYS=frozenset(('schema','model','classes','report','receipt_sha256','evidence','constructor','constructor_sha256'))
+
+
+def _role(report):
+    if report.get('status')=='PRESERVED_VERIFIED_TRAIN_ANCHOR_NOT_FINAL_REFIT':return 'TRAIN'
+    final=next((e for e in reversed(report.get('events',())) if e['event']=='FINAL_MODEL'),None)
+    return 'TRAIN_FULL' if final and final['refit_full'] else 'TRAIN' if final else 'UNKNOWN'
+
+
+def catalog(estimator):
+    if not hasattr(estimator,'model_'):raise RuntimeError('Not fitted')
+    if hasattr(estimator,'_retained_variants'):return estimator._retained_variants
+    result={'selected':dict(model=estimator.model_,origin='SELECTED_FITTED_MODEL',source_role=_role(estimator.report_))}
+    pure=getattr(estimator,'_research_structural_before_numeric',None)
+    if pure is not None:
+        result['pure']=dict(model=pure,origin='PRE_FINAL_NUMERIC_SEARCH',source_role='TRAIN')
+        tuned=getattr(estimator,'_research_selected_before_refit',None)
+        if tuned is not None and tuned is not pure:
+            result['tuned']=dict(model=tuned,origin='POST_FINAL_NUMERIC_SEARCH',source_role='TRAIN')
+    return result
+
+
+def resolve(estimator,name):
+    if type(name) is not str or name not in NAMES:raise ValueError('Variant must be selected, pure or tuned')
+    if name=='selected':name=getattr(estimator,'_variant_selection','selected')
+    variants=catalog(estimator)
+    if name not in variants:raise ValueError('Variant has no retained genuine weights; no implicit training is performed')
+    return name,variants[name]
+
+
+def active_metadata(estimator):
+    name,item=resolve(estimator,'selected')
+    return dict(name=name,origin=item['origin'],source_role=item['source_role'],additional_training=False)
+
+
+def describe(estimator):
+    from .scalable import digest
+    variants=catalog(estimator);estimator._serialization_resources('Variant inspection',families=[v['model'] for v in variants.values()])
+    selected=resolve(estimator,'selected')[0]
+    return {name:dict(origin=v['origin'],source_role=v['source_role'],params=asdict(v['model'].params),model_sha256=digest(v['model'].packet()),exportable=True,is_selected=name==selected,additional_training=False) for name,v in variants.items()}
+
+
+def view(estimator,name):
+    name,item=resolve(estimator,name);other=copy.copy(estimator)
+    other._retained_variants=catalog(estimator);other._variant_selection=name
+    other.model_=item['model'];other.best_family_=other.model_.family;other.best_params_=asdict(other.model_.params)
+    return other
+
+
+def _binding(selected,variants,models):
+    return dict(selected_variant=selected,variants=variants,models=models)
+
+
+def save_bundle(estimator,path,variant):
+    from .scalable import digest,verify_receipts
+    if type(variant) is not str or variant not in NAMES|{'all'}:raise ValueError('Variant must be all, selected, pure or tuned')
+    available=catalog(estimator)
+    if variant=='all':names=list(available);selected=resolve(estimator,'selected')[0]
+    else:selected=resolve(estimator,variant)[0];names=[selected]
+    # Preserve existing single-model formats for old objects without retained
+    # phase weights; do not relabel their final model as an unrecorded pure fit.
+    if names==['selected'] and set(available)=={'selected'}:return None
+    res=estimator._serialization_resources('Variant bundle',families=[available[n]['model'] for n in names])
+    verify_receipts(estimator.report_['events'])
+    models={};variants={}
+    for name in names:
+        res.check();item=available[name];packet=item['model'].packet();identity=digest(packet)
+        models.setdefault(identity,packet)
+        variants[name]=dict(origin=item['origin'],source_role=item['source_role'],model_sha256=identity)
+    primary=models.pop(variants[selected]['model_sha256'])
+    constructor=estimator._constructor_state()
+    packet=dict(schema=SCHEMA,model=primary,classes=estimator.classes_,report=estimator.report_,receipt_sha256=digest(estimator.report_),
+                evidence=dict(diagnostic_profiles=getattr(estimator,'diagnostic_profiles_',{})),constructor=constructor,constructor_sha256=digest(constructor),
+                selected_variant=selected,variants=variants,models=models,variants_sha256=digest(_binding(selected,variants,models)))
+    raw=json.dumps(packet,sort_keys=True,allow_nan=False)+'\n';res.reserve(len(raw.encode('utf8'))*4,'Encoded unique-weight variant bundle')
+    atomic_text(Path(path),raw);return hashlib.sha256(raw.encode('utf8')).hexdigest()
+
+
+def restore_bundle(cls,packet,res,limit,file_sha256,expected_checksum_supplied,memory_budget):
+    from .scalable import digest
+    required=BASE_KEYS|{'selected_variant','variants','models','variants_sha256'}
+    if set(packet)!=required or packet['schema']!=SCHEMA:raise ValueError('Exact variant bundle envelope required')
+    variants=packet['variants'];models=packet['models'];selected=packet['selected_variant']
+    if type(variants) is not dict or not variants or not set(variants)<=NAMES or type(models) is not dict or len(models)>2 or type(selected) is not str or selected not in variants:
+        raise ValueError('Finite named retained variants required')
+    if digest(_binding(selected,variants,models))!=packet['variants_sha256']:raise ValueError('Changed variant bundle identity')
+    for name,item in variants.items():
+        if type(item) is not dict or set(item)!={'origin','source_role','model_sha256'}:raise ValueError('Exact variant identity/role required')
+        expected='SELECTED_FITTED_MODEL' if name=='selected' else 'PRE_FINAL_NUMERIC_SEARCH' if name=='pure' else 'POST_FINAL_NUMERIC_SEARCH'
+        if item['origin']!=expected or item['source_role'] not in (('TRAIN','TRAIN_FULL','UNKNOWN') if name=='selected' else ('TRAIN',)):
+            raise ValueError('Variant origin/source role mismatch')
+        h=item['model_sha256']
+        if type(h) is not str or len(h)!=64 or any(c not in '0123456789abcdef' for c in h):raise ValueError('Variant model digest required')
+    primary=variants[selected]['model_sha256']
+    if digest(packet['model'])!=primary:raise ValueError('Changed selected variant weights')
+    if set(models)!={v['model_sha256'] for v in variants.values()}-{primary}:raise ValueError('Missing/unreferenced retained weight packet')
+    if any(type(v) is not dict or digest(v)!=h for h,v in models.items()):raise ValueError('Changed retained variant weights')
+    base={k:packet[k] for k in BASE_KEYS};base['schema']='SCALABLE_PRIVATE_MODEL_3'
+    obj=cls._restore_packet(base,res,limit,file_sha256,expected_checksum_supplied,memory_budget)
+    if 'selected' in variants and variants['selected']['source_role']!=_role(packet['report']):raise ValueError('Selected role must match original fit finalization')
+    families={primary:obj.model_}
+    for identity,model in models.items():
+        res.check();part=cls._restore_packet(dict(base,model=model),res,limit,file_sha256,expected_checksum_supplied,memory_budget)
+        if (part.task_,part.classes_,part.model_.family,part.model_.genome)!=(obj.task_,obj.classes_,obj.model_.family,obj.model_.genome):raise ValueError('Variant task/family/frozen program mismatch')
+        if part.model_.encoder.names!=obj.model_.encoder.names or [c['kind'] for c in part.model_.encoder.columns]!=[c['kind'] for c in obj.model_.encoder.columns]:raise ValueError('Variant feature schema mismatch')
+        families[identity]=part.model_
+    if 'tuned' in variants:
+        identity=variants['tuned']['model_sha256'];family=families[identity]
+        if identity!=packet['report'].get('last_verified_anchor',{}).get('model_sha256'):raise ValueError('Tuned weights must match retained TRAIN anchor')
+        if not any(e['event']=='OPTUNA_COMPLETE' and e['parameters']==asdict(family.params) for e in packet['report']['events']):raise ValueError('Tuned variant needs a completed numerical trial')
+    if 'pure' in variants:
+        identity=variants['pure']['model_sha256'];family=families[identity]
+        capacity=family.params if family.family=='boost' else replace(family.params,n_estimators=1,learning_rate=1.)
+        if not any(e['event']=='NATIVE_FIT_STARTED' and e['phase']=='SCREEN' and e['family']==family.family and e['params_sha256']==digest(asdict(capacity)) for e in packet['report']['events']):raise ValueError('Pure variant needs qualified untuned capacity')
+        history=[e for e in packet['report']['events'] if e['event']=='MUTATION']
+        if history:
+            last=history[-1];expected=last['child_sha256'] if last['decision']=='ACCEPT' else last['parent_sha256']
+            if identity!=expected:raise ValueError('Pure variant must match retained structural lineage')
+    obj._retained_variants={name:dict(model=families[v['model_sha256']],origin=v['origin'],source_role=v['source_role']) for name,v in variants.items()}
+    obj._variant_selection=selected;return obj

morphtree/sklearn_view.py

@@ -0,0 +1,79 @@
+"""Optional sklearn parameter-routing adapter for the native public estimator.
+
+The underlying facade already returns NumPy arrays.
+This view delegates fitting to that same facade and adds no training, tuning,
+sampling or preprocessing. sklearn is optional; NumPy is used only for arrays.
+"""
+from .scalable import _Scalable
+from .scalable_data import Input
+
+
+def _labels(values):
+    from .prediction_output import prediction_array
+    return prediction_array(values)
+
+
+class _ClassifierMethod:
+    """Keep the public response-method name while hiding it for regression."""
+    def __init__(self,function):self.function=function
+    def __get__(self,instance,owner):
+        if instance is None:return self.function
+        if instance.estimator.task!='classification':raise AttributeError('Regression has no probabilities')
+        return self.function.__get__(instance,owner)
+
+
+class SklearnView:
+    """Explicit array-output adapter with estimator__parameter configuration.
+
+    Qualify external tools separately; sample weights, sparse data, metadata
+    routing and all estimator-check contracts are not implied by this view.
+    Saving via estimator.save() persists the native model; restore it and call
+    as_sklearn() again. Cloning always produces an unfitted native estimator.
+    """
+    def __init__(self,estimator):
+        if not isinstance(estimator,_Scalable) or estimator.task not in ('classification','regression'):
+            raise TypeError('A native MorphTree task facade is required')
+        self.estimator=estimator
+    def get_params(self,deep=True):
+        params={'estimator':self.estimator}
+        if deep:params.update({'estimator__'+k:v for k,v in self.estimator.get_params(deep=True).items()})
+        return params
+    def set_params(self,**values):
+        if not values:return self
+        candidate=values.get('estimator',self.estimator)
+        type(self)(candidate)
+        unknown=[k for k in values if k!='estimator' and not k.startswith('estimator__')]
+        if unknown:raise ValueError('Unknown view parameter: '+', '.join(sorted(unknown)))
+        nested={k[len('estimator__'):]:v for k,v in values.items() if k!='estimator'}
+        if nested:candidate.set_params(**nested)
+        self.estimator=candidate
+        return self
+    @property
+    def _estimator_type(self):return self.estimator._estimator_type
+    def __sklearn_tags__(self):return self.estimator.__sklearn_tags__()
+    def __sklearn_is_fitted__(self):return self.estimator.__sklearn_is_fitted__()
+    @property
+    def classes_(self):
+        if self.estimator.task!='classification':raise AttributeError('Regression has no classes')
+        self.estimator._resources().reserve(len(self.estimator.classes_)*64,'Sklearn class-label array')
+        return _labels(self.estimator.classes_)
+    @property
+    def n_features_in_(self):return self.estimator.n_features_in_
+    def fit(self,X,y):
+        self.estimator.fit(X,y)
+        return self
+    def predict(self,X):
+        if not self.estimator.__sklearn_is_fitted__():raise RuntimeError('Not fitted')
+        resources=self.estimator._resources()
+        resources.reserve(Input(X).n*64,'Native prediction list plus sklearn output array')
+        values=self.estimator.predict(X);resources.check()
+        return values
+    @_ClassifierMethod
+    def predict_proba(self,X):
+        import numpy as np
+        if not self.estimator.__sklearn_is_fitted__():raise RuntimeError('Not fitted')
+        resources=self.estimator._resources()
+        resources.reserve(Input(X).n*(len(self.estimator.classes_)*48+64),'Native probability rows plus sklearn output array')
+        values=self.estimator.predict_proba(X);resources.check()
+        return values
+    def score(self,X,y):return self.estimator.score(X,y)

morphtree/source_markers.py

@@ -0,0 +1,25 @@
+"""Explicit/dynamic source metadata is distinct from pandas column/index data.
+
+Only genuine inherited pandas attribute handlers qualify for the data-forwarding
+exception. Static descriptors/instance/class markers and custom attribute
+interceptors remain fail-closed. No optional dependency is imported here.
+"""
+import inspect,sys
+MARKERS=('_morphtree_source_role','_morphtree_scientific_source','_morphtree_sealed')
+ABSENT=object()
+
+def controlled_source(obj):
+    for name in MARKERS:
+        if inspect.getattr_static(obj,name,ABSENT) is not ABSENT:return True
+        value=getattr(obj,name,ABSENT)
+        if value is ABSENT:continue
+        pd=sys.modules.get('pandas');base=None
+        if pd is not None:
+            if isinstance(obj,pd.DataFrame):base=pd.DataFrame;axis='columns'
+            elif isinstance(obj,pd.Series):base=pd.Series;axis='index'
+        if base is not None:
+            handlers=('__getattr__','__getattribute__')
+            original=all(inspect.getattr_static(type(obj),method,ABSENT) is inspect.getattr_static(base,method,ABSENT) for method in handlers)
+            if original and name in getattr(obj,axis):continue
+        return True
+    return False

morphtree/species.py

@@ -0,0 +1,47 @@
+"""Reusable algorithm specification, independent of trained tree weights."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import copy
+
+from .config import AlgorithmGenome, HyperParams
+from .persistence import decode_species, read_json, species_payload, write_json
+from .public import public_metadata, learning_fingerprint
+
+
+@dataclass(frozen=True)
+class AlgorithmSpecies:
+    genome: AlgorithmGenome = field(default_factory=AlgorithmGenome)
+    parameters: HyperParams = field(default_factory=HyperParams)
+    metadata: dict = field(default_factory=dict, compare=False)
+
+    def __post_init__(self):
+        if not isinstance(self.genome, AlgorithmGenome) or not isinstance(self.parameters, HyperParams):
+            raise ValueError("Species needs an AlgorithmGenome and HyperParams")
+        if not isinstance(self.metadata, dict):
+            raise ValueError("Species metadata must be a dict")
+        object.__setattr__(self, "metadata", public_metadata(self.metadata))
+
+    @property
+    def learning_fingerprint(self):
+        recipe = self.metadata.get('learning_recipe')
+        return learning_fingerprint(self.genome, self.parameters, recipe) if recipe else None
+
+    @property
+    def structural_fingerprint(self):
+        return self.genome.fingerprint()
+
+    def to_dict(self):
+        return species_payload(self.genome, self.parameters, copy.deepcopy(self.metadata))
+
+    def save(self, path):
+        write_json(path, self.to_dict())
+
+    @classmethod
+    def load(cls, path, *, limits=None):
+        genome, params, metadata = decode_species(read_json(path, limits))
+        return cls(genome, params, metadata)
+
+    def export_python(self, path):
+        from .exporting import export_algorithm
+        export_algorithm(self, path)

morphtree/temporary.py

@@ -0,0 +1,65 @@
+"""One-attempt private temporary directories and ownership-checked cleanup.
+
+No global tempfile configuration or retry loop is changed. Names have the same
+eight-character random suffix length as the previous stdlib directories, using
+48 fresh cryptographic bits per name. Creation is exclusive; a collision or
+permission failure propagates without retry. These are OS resource helpers,
+not learner code or a guarantee against arbitrary filesystem latency.
+"""
+import os
+from pathlib import Path
+import secrets
+import shutil
+import stat
+import tempfile
+import weakref
+
+
+def directory(*,prefix='tmp',dir=None):
+    if type(prefix) is not str or not prefix or any(c in prefix for c in ('/','\\','\0',':')) or Path(prefix).name!=prefix or prefix in ('.','..'):
+        raise ValueError('A single temporary-name prefix is required')
+    parent=Path(tempfile.gettempdir() if dir is None else dir).resolve(strict=True)
+    if not parent.is_dir():raise NotADirectoryError(parent)
+    path=parent/(prefix+secrets.token_urlsafe(6))
+    os.mkdir(path,0o700)
+    return path
+
+
+def _remove_owned(name,parent,identity):
+    path=Path(name);parent=Path(parent)
+    try:current=path.lstat()
+    except FileNotFoundError:return
+    if stat.S_ISLNK(current.st_mode) or getattr(path,'is_junction',lambda:False)():
+        raise ValueError('Owned temporary cleanup refuses a link')
+    if not stat.S_ISDIR(current.st_mode) or (current.st_dev,current.st_ino)!=identity:
+        raise ValueError('Owned temporary directory identity changed')
+    if path.parent.resolve()!=parent or not path.resolve().is_relative_to(parent):
+        raise ValueError('Owned temporary cleanup escaped its original parent')
+    shutil.rmtree(path)
+
+
+class OwnedTemporaryDirectory:
+    """Private name/context/cleanup/finalizer surface needed by existing code."""
+    def __init__(self,*,prefix='tmp',dir=None):
+        path=directory(prefix=prefix,dir=dir)
+        self.name=str(path);self.parent=str(path.parent)
+        current=path.lstat();self.identity=(current.st_dev,current.st_ino)
+        self._cleanup_attempted=False
+        self._finalizer=weakref.finalize(self,_remove_owned,self.name,self.parent,self.identity)
+
+    def __enter__(self):return self.name
+
+    def cleanup(self):
+        if self._cleanup_attempted:return
+        self._cleanup_attempted=True
+        self._finalizer.detach()
+        _remove_owned(self.name,self.parent,self.identity)
+
+    def __exit__(self,kind,error,traceback):
+        if error is None:
+            self.cleanup()
+        else:
+            try:self.cleanup()
+            except BaseException as cleanup_error:
+                BaseException.add_note(error,'Owned temporary cleanup also failed: '+type(cleanup_error).__name__)
+        return False

morphtree/training_fragment.py

@@ -0,0 +1,130 @@
+"""Frozen native family training, never a substitute for evolutionary search.
+
+The 2.0 public exporter provided an executor-bound train_encoded fragment.
+This module supplies the scalable equivalent, with explicit TRAIN provenance,
+finite resource guards, the same native booster and unchanged bootstrap/order.
+Exporting never fits; calling the generated trainer is a new training operation.
+"""
+from array import array
+from dataclasses import asdict,replace
+import hashlib,json,time
+from pathlib import Path
+
+
+def _validate(spec):
+    from .scalable import digest,verify_source_identity,_ENGINE_SHA256
+    from .config import AlgorithmGenome,HyperParams,validate_task_genome
+    verify_source_identity()
+    fields={'schema','task','family','genome','parameters','encoder','classes','seed','runtime_manifest_sha256','scope'}
+    if type(spec) is not dict or set(spec)!=fields or spec['schema']!='SCALABLE_FROZEN_TRAINING_1' or spec['scope']!='FROZEN_FAMILY_NOT_END_TO_END_SEARCH':raise ValueError('Exact frozen training fragment required')
+    if spec['runtime_manifest_sha256']!=_ENGINE_SHA256:raise ValueError('Training fragment requires its exact source runtime')
+    if spec['task'] not in ('binary','multiclass','regression') or spec['family'] not in ('boost','bag') or type(spec['seed']) is not int:raise ValueError('Known native task/family and resolved seed required')
+    genome=AlgorithmGenome(**spec['genome']);params=HyperParams(**spec['parameters'])
+    validate_task_genome(spec['task'],genome)
+    return genome,params
+
+
+def export_algorithm(estimator,path):
+    from .scalable import digest,verify_source_identity,_ENGINE_SHA256
+    from .persistence import atomic_text
+    verify_source_identity()
+    if not hasattr(estimator,'model_'):raise RuntimeError('Not fitted')
+    res=estimator._serialization_resources('Frozen training program')
+    seeds=[e['seed'] for e in estimator.report_.get('events',()) if e['event']=='NATIVE_FIT_STARTED']
+    seed=estimator.report_.get('effective_seed',seeds[0] if seeds else estimator.random_state)
+    spec=dict(schema='SCALABLE_FROZEN_TRAINING_1',task=estimator.task_,family=estimator.model_.family,
+        genome=estimator.model_.genome.to_dict(),parameters=asdict(estimator.model_.params),
+        encoder=estimator.model_.encoder.state(),classes=list(estimator.classes_),seed=seed,
+        runtime_manifest_sha256=_ENGINE_SHA256,scope='FROZEN_FAMILY_NOT_END_TO_END_SEARCH')
+    _validate(spec)
+    text='''# MorphTree frozen native family training fragment; requires exact installed runtime.
+# No family search, OOF, evolution, Optuna, holdout metric or inference weights.
+from morphtree.training_fragment import train_encoded_fragment
+SPEC = %r
+SPEC_SHA256 = %r
+EXPORT_SCOPE = 'FROZEN_FAMILY_NOT_END_TO_END_SEARCH'
+
+def train_encoded(X, y, *, identity, memory_budget='auto', time_budget='auto', check=None):
+    return train_encoded_fragment(SPEC, SPEC_SHA256, X, y, identity=identity,
+        memory_budget=memory_budget, time_budget=time_budget, check=check)
+''' % (spec,digest(spec))
+    res.reserve(len(text.encode('utf8'))*4,'Frozen training source')
+    atomic_text(Path(path),text);return hashlib.sha256(text.encode('utf8')).hexdigest()
+
+
+def train_encoded_fragment(spec,expected_sha256,X,y,*,identity,memory_budget='auto',time_budget='auto',check=None):
+    """Train exactly the frozen family on explicitly encoded TRAIN observations.
+
+    X must be Encoder.transform(Table) from this runtime. identity is exactly
+    {data: data_identity(X.source, compact_labels, 'TRAIN'),
+     preprocessing_sha256: encoder_digest(exported_encoder)}.
+    Targets are compact internal numeric labels, not raw class names. No rows
+    are dropped; bag members use the original declared bootstrap procedure.
+    """
+    from .scalable import (digest,Family,MorphTreeClassifier,MorphTreeRegressor,
+        managed_resources,_ENGINE_SHA256)
+    from .scalable_data import Encoded,Encoder
+    from .scalable_receipts import data_identity,encoder_digest,verify
+    from .native_lab_backend import bind_backend
+    from .booster import BinaryHistogramBooster
+    from .prepared_bins import BinCache
+    from ._experimental.sampling import bootstrap
+    # Admission/context checks precede input traversal or a native component.
+    if type(spec) is not dict or check is not None and not callable(check):raise ValueError('Typed fragment and optional resource callback required')
+    obj=(MorphTreeRegressor if spec.get('task')=='regression' else MorphTreeClassifier)(
+        random_state=spec.get('seed'),memory_budget=memory_budget,time_budget=time_budget,
+        use_optuna=False,n_trials=0,max_mutations=0,refit_full=False,checkpoint_dir=None)
+    obj._ordinary_context_guard()
+    backend_factory=bind_backend()
+    if digest(spec)!=expected_sha256:raise ValueError('Changed exported training program')
+    genome,params=_validate(spec)
+    if not isinstance(X,Encoded):raise ValueError('Explicit compact encoded TRAIN required')
+    from .source_markers import controlled_source
+    if controlled_source(X) or controlled_source(X.source) or controlled_source(y):raise ValueError('Controlled data require their original context')
+    res=managed_resources(memory_budget,150 if time_budget=='auto' else time_budget,check)
+    res.reserve(len(X)*(64+X.width*32),'Frozen native TRAIN workspace')
+    target_codes=('d',) if spec['task']=='regression' else ('I','Q','q')
+    if not isinstance(y,array) or y.typecode not in target_codes or not len(X) or len(X)!=len(y):raise ValueError('Aligned task-compatible native compact TRAIN labels required')
+    enc=Encoder.from_state(spec['encoder'],res)
+    wanted=dict(data=data_identity(X.source,y,'TRAIN'),preprocessing_sha256=encoder_digest(enc))
+    if type(identity) is not dict or identity!=wanted:raise ValueError('Exact TRAIN/preprocessing identity required')
+    transformed=enc.transform(X.source)
+    if X.order!=transformed.order or X.maps!=transformed.maps or X._nominal_sizes!=transformed._nominal_sizes:raise ValueError('Encoded TRAIN differs from exported preprocessing')
+    k=len(spec['classes']) if spec['task']!='regression' else 1
+    if spec['task']=='regression':
+        import math
+        if spec['classes'] or any(not math.isfinite(v) for v in y):raise ValueError('Finite regression TRAIN targets')
+    elif k<2 or spec['task']=='binary' and k!=2 or any(v!=int(v) or not 0<=v<k for v in y):raise ValueError('Task-compatible internal class indices required')
+    # The same bound as normal training: output model + row workspace + histograms.
+    from .resource_plan import fit_plan
+    plan=fit_plan(len(X),X.width,k,params,0,0,False,res.available_bytes_snapshot,time_budget,res.bytes_limit)
+    res.configure_time(plan['seconds']);res.reserve(plan['estimated_workspace_bytes'],'Frozen native family workspace')
+    start=time.perf_counter();obj.last_attempt_=dict(status='IN_PROGRESS',native_fits=0,OOF_fits=0,scalar_trees=0,Optuna_trials=0,cache_hits=0,events=[],effective_seed=spec['seed'],training_scope=spec['scope'])
+    from .scalable_receipts import Ledger
+    obj._ledger=Ledger();obj._event('CALL_STARTED',engine_sha256=_ENGINE_SHA256,scope=spec['scope'],requested_task=spec['task'])
+    obj._event('PROGRAM_FROZEN',genome_sha256=digest(genome.to_dict()))
+    prepared=BinCache(min(32*1024**2,res.bytes_limit//8),res.check);models=[]
+    try:
+        for member in range(1 if spec['family']=='boost' else params.n_estimators):
+            res.check();seed=spec['seed'];actual=params if spec['family']=='boost' else replace(params,n_estimators=1,learning_rate=1.)
+            if spec['family']=='bag':
+                ids=bootstrap(y,spec['task'],seed+member+1);table=X.source.take(ids);yy=array(y.typecode,(y[i] for i in ids));xx=enc.transform(table)
+            else:table=X.source;xx=X;yy=y
+            data=data_identity(X.source,y,'TRAIN');preprocessing=encoder_digest(enc)
+            key=digest(dict(data=data,preprocessing_sha256=preprocessing,task=spec['task'],family=spec['family'],genome=genome.to_dict(),params=asdict(params),seed=seed,engine_sha256=_ENGINE_SHA256))
+            rows=hashlib.sha256(memoryview(table.indices)).hexdigest() if table.indices is not None else digest(dict(range_start=0,range_stop=len(table)))
+            labels=hashlib.sha256(memoryview(yy)).hexdigest();component=digest(dict(request=key,member=member,effective_rows=rows,effective_labels=labels,seed=seed+member,params=asdict(actual)))
+            count=actual.n_estimators*(k if spec['task']=='multiclass' else 1)
+            obj.last_attempt_['native_fits']+=1;obj.last_attempt_['scalar_trees']+=count
+            obj._event('NATIVE_FIT_STARTED',ordinal=member+1,phase='FROZEN_TRAIN',rows=len(yy),source_rows=len(X),family=spec['family'],cache_key=key,component_key=component,effective_rows_sha256=rows,effective_labels_sha256=labels,seed=seed+member,params_sha256=digest(asdict(actual)),preprocessing_sha256=preprocessing,program_sha256=digest(genome.to_dict()),role='TRAIN',reserved_scalar_trees=count)
+            model=BinaryHistogramBooster(genome,actual,seed+member,backend_factory(xx._nominal_sizes),memory_enabled=False,objective='softmax' if spec['task']=='multiclass' else 'squared_error' if spec['task']=='regression' else 'binary_logloss',n_classes=k if spec['task']=='multiclass' else None)
+            token=prepared.bind(xx,dict(source_sha256=data['source_sha256'],schema_sha256=data['schema_sha256'],effective_rows_sha256=rows,effective_labels_sha256=labels,preprocessing_sha256=preprocessing,engine_sha256=_ENGINE_SHA256),'TRAIN')
+            tick=time.perf_counter();model.fit(xx,yy,callback=lambda *_:res.check() or True,prepared_data=token)
+            if len(model.trees)!=count:raise ValueError('Incomplete frozen native component')
+            obj._event('NATIVE_FIT_COMPLETED',ordinal=member+1,phase='FROZEN_TRAIN',seconds=time.perf_counter()-tick,component_key=component,actual_scalar_trees=len(model.trees));models.append(model)
+        obj.model_=Family(spec['task'],genome,params,enc,models,spec['family']);obj.classes_=list(spec['classes']);obj.task_=spec['task'];obj.n_features_in_=X.width;obj.best_family_=spec['family'];obj.best_params_=asdict(params)
+        obj._event('FINAL_MODEL',input_rows=len(X),selection_TRAIN_rows=len(X),SEARCH_rows=0,final_fit_source_rows=len(X),refit_full=False,SEARCH_primary_before_refit=None,selection_metric_is_independent=False,nominal_columns=len(X._nominal_sizes),source_storage_bytes=X.source.storage_bytes,all_rows_accounted=True)
+        obj.last_attempt_.update(status='COMPLETED',seconds=time.perf_counter()-start,stop_reason='FROZEN_PROGRAM_TRAINING_COMPLETE')
+        obj.last_attempt_['receipt_verification']=verify(obj.last_attempt_['events']);obj.report_=obj.last_attempt_
+        return obj
+    finally:prepared.clear()