Spaces:
Running on Zero
Running on Zero
| """Bounded native adapter. No engine modifications; no network calls. | |
| The adapter validates the vanilla game network envelope before native dispatch. | |
| """ | |
| import gzip | |
| import hashlib | |
| import io | |
| import json | |
| import math | |
| import os | |
| from pathlib import Path | |
| import subprocess | |
| import struct | |
| import tempfile | |
| import time | |
| import uuid | |
| from training_config import validate_config | |
| from build_info import build_identity | |
| from analysis_result import assemble_analysis | |
| from star_check import check_ticks, needs_observations, resolve_check | |
| MODULE_DIR = Path(__file__).resolve().parent | |
| # Source checkout is nested; a hosted release is flat under /app. Deployment | |
| # supplies explicit binary/template paths, so importing must not assume depth. | |
| ROOT = MODULE_DIR.parent.parent if MODULE_DIR.name=='hf' and MODULE_DIR.parent.name=='integrations' else MODULE_DIR | |
| def read_json(data): | |
| if len(data)>1024*1024: raise ValueError('Input exceeds 1 MB') | |
| if data[:2]==b'\x1f\x8b': | |
| with gzip.GzipFile(fileobj=io.BytesIO(data)) as stream: | |
| data=stream.read(4*1024*1024+1) | |
| if len(data)>4*1024*1024: raise ValueError('Expanded input exceeds 4 MB') | |
| result=json.loads(data,parse_constant=lambda _: (_ for _ in ()).throw(ValueError('Nonfinite JSON'))) | |
| if not isinstance(result,dict): raise ValueError('Expected JSON object') | |
| return result | |
| OUTPUT_NAMES = ('Steering', 'Acceleration', 'Handbrake', 'Brake', 'Boost') | |
| VEHICLE_NAMES = ('Formula', 'Rally', 'Snowmobile', 'Truck') | |
| SCALAR_SENSORS = {'speed', 'velocityFront', 'velocitySide', 'angularVelocity', | |
| 'wheelAngle', 'boostCapacity', 'correctDirection'} | |
| def sensor_input(sensor): | |
| if not isinstance(sensor, dict): raise ValueError('Sensor object required') | |
| kind = sensor.get('$type') | |
| if not isinstance(kind, str): raise ValueError('Sensor type required') | |
| clean = {'$type': kind} | |
| def number(key, default=None, positive=False): | |
| value = sensor.get(key, default) | |
| if type(value) not in (int, float) or not math.isfinite(value) or abs(value)>1e6: | |
| raise ValueError('Invalid sensor parameter '+key) | |
| # The simulator converts descriptor values to float32 before use. | |
| if positive and (value<=0 or struct.unpack('f', struct.pack('f', value))[0]<=0): | |
| raise ValueError('Positive sensor parameter required: '+key) | |
| clean[key] = value | |
| return value | |
| if kind in SCALAR_SENSORS: return clean | |
| if kind == 'raycast': | |
| if not -360<=number('Degrees')<=360: raise ValueError('Degrees') | |
| if not 1<=number('Length')<=10000: raise ValueError('Length') | |
| elif kind in ('accelerationFront', 'accelerationSide'): | |
| number('MaxAcceleration', 10 if kind=='accelerationFront' else 12, positive=True) | |
| elif kind == 'distanceFromWall': number('MaxDistance', 150, positive=True) | |
| elif kind == 'trackCurvature': | |
| number('MinLookaheadDistance', 256) | |
| number('MaxLookaheadDistance', 512) | |
| elif kind == 'grip': | |
| offset = sensor.get('PositionOffset', {}) | |
| if isinstance(offset, dict): coords = [offset.get('X',0), offset.get('Y',0)] | |
| elif isinstance(offset, list) and len(offset)==2: coords = offset | |
| else: raise ValueError('Grip offset must have two components') | |
| if any(type(n) not in (int,float) or not math.isfinite(n) or abs(n)>1e6 for n in coords): | |
| raise ValueError('Invalid grip offset') | |
| clean['PositionOffset'] = {'X':coords[0], 'Y':coords[1]} | |
| else: raise ValueError('Unsupported sensor type') | |
| return clean | |
| def network_input(data): | |
| value=read_json(data) | |
| network=value['NeuralNetwork']; shape=network['Shape']; outputs=value.get('Outputs') | |
| vehicle_type=value.get('Type') | |
| if type(vehicle_type) is not int or not 0<=vehicle_type<len(VEHICLE_NAMES): | |
| raise ValueError('Vehicle Type must be Formula (0), Rally (1), Snowmobile (2), or Truck (3)') | |
| if (not isinstance(outputs,list) or not 1<=len(outputs)<=5 or | |
| any(type(n) is not int or not 0<=n<5 for n in outputs) or len(set(outputs))!=len(outputs)): | |
| raise ValueError('Use an ordered unique subset of the five game outputs') | |
| if vehicle_type!=0 and not {0,1}.issubset(outputs): | |
| raise ValueError('Rally, Snowmobile, and Truck networks require Steering and Acceleration outputs') | |
| if vehicle_type==2 and 2 in outputs: | |
| raise ValueError('Snowmobile Handbrake output is unavailable in the original game editor') | |
| if (not isinstance(shape,list) or not 2<=len(shape)<=12 or | |
| any(type(n) is not int or n<1 for n in shape) or shape[0]>20 or | |
| any(n>16 for n in shape[1:-1]) or shape[-1]!=len(outputs)): | |
| raise ValueError('Shape: up to 20 inputs, 10 hidden layers of 16, and 1–5 outputs') | |
| sensors=value['Sensors'] | |
| if not isinstance(sensors,list) or len(sensors)!=shape[0]: raise ValueError('Sensor count') | |
| clean_sensors=[sensor_input(sensor) for sensor in sensors] | |
| rays=sum(s['$type']=='raycast' for s in clean_sensors) | |
| if rays>13 or len(sensors)-rays>7: raise ValueError('Use up to 13 vision and 7 other sensors') | |
| weights,biases=network['Weights'],network['Biases'] | |
| if not isinstance(weights,list) or not isinstance(biases,list) or len(weights)!=len(shape)-1 or len(biases)!=len(shape)-1: | |
| raise ValueError('Layer count') | |
| for i,(a,b) in enumerate(zip(shape,shape[1:])): | |
| if (not isinstance(weights[i],list) or len(weights[i])!=a or | |
| any(not isinstance(row,list) or len(row)!=b for row in weights[i]) or | |
| not isinstance(biases[i],list) or len(biases[i])!=b): raise ValueError('Dimensions') | |
| for n in [x for row in weights[i] for x in row]+biases[i]: | |
| if type(n) not in (int,float) or not math.isfinite(n) or abs(n)>1e6: raise ValueError('Weight value') | |
| return {'Id':str(uuid.uuid4()),'Stats':{'Generations':[]},'Snapshots':[], | |
| 'Type':vehicle_type,'Outputs':outputs[:],'Sensors':clean_sensors, | |
| 'Name':'HF candidate','NeuralNetwork':{'Shape':shape,'InputShape':shape[0],'OutputShape':shape[-1], | |
| 'NeuronsCount':sum(shape),'TotalParams':sum((a+1)*b for a,b in zip(shape,shape[1:])), | |
| 'Weights':weights,'Biases':biases}} | |
| def check_freeze_shape(freeze,shape): | |
| """Resolve selection against this policy, with at least one trainable parameter.""" | |
| if any(layer>=len(shape)-1 for layer in freeze['layers']): | |
| raise ValueError('Frozen hidden layer exceeds network shape') | |
| if any(index>=shape[0] for index in freeze['inputs']): | |
| raise ValueError('Frozen input exceeds sensor count') | |
| if any(index>=shape[-1] for index in freeze['outputs']): | |
| raise ValueError('Frozen output exceeds output count') | |
| layers=set(freeze['layers']);inputs=set(freeze['inputs']);outputs=set(freeze['outputs']) | |
| trainable=0 | |
| last=len(shape)-2 | |
| for layer,(source_count,dest_count) in enumerate(zip(shape,shape[1:])): | |
| for source in range(source_count): | |
| for dest in range(dest_count): | |
| if not (layer+1 in layers or layer==0 and source in inputs or layer==last and dest in outputs): | |
| trainable+=1 | |
| for dest in range(dest_count): | |
| if not (layer+1 in layers or layer==last and dest in outputs): | |
| trainable+=1 | |
| if not trainable: | |
| raise ValueError('Freeze selection leaves no trainable parameters; use frozen evaluation') | |
| def verify_frozen_parameters(freeze,starting,trained): | |
| """Never publish a result whose native candidate violates the requested mask.""" | |
| layers=set(freeze['layers']);inputs=set(freeze['inputs']);outputs=set(freeze['outputs']) | |
| last=len(starting['Shape'])-2 | |
| for layer,matrix in enumerate(starting['Weights']): | |
| for source,row in enumerate(matrix): | |
| for dest,value in enumerate(row): | |
| if (layer+1 in layers or layer==0 and source in inputs or layer==last and dest in outputs): | |
| if value!=trained['weights'][layer][source][dest]: | |
| raise ValueError('Native trainer changed a frozen weight') | |
| for dest,value in enumerate(starting['Biases'][layer]): | |
| if layer+1 in layers or layer==last and dest in outputs: | |
| if value!=trained['biases'][layer][dest]: | |
| raise ValueError('Native trainer changed a frozen bias') | |
| def track_input(data): | |
| value=read_json(data) | |
| challenges=value.get('Challenges',[]) | |
| if not isinstance(challenges,list) or len(challenges)>64: | |
| raise ValueError('Track supports at most 64 challenge definitions') | |
| for challenge in challenges: | |
| if (not isinstance(challenge,dict) or not isinstance(challenge.get('$type'),str) | |
| or not 1<=len(challenge['$type'])<=96): | |
| raise ValueError('Invalid track challenge type') | |
| for key,limit in (('Text',2048),('Id',128)): | |
| if key in challenge and (not isinstance(challenge[key],str) or len(challenge[key])>limit): | |
| raise ValueError('Invalid track challenge label') | |
| tiles=value['Tiles'] | |
| if not isinstance(tiles,dict) or not 4<=len(tiles)<=256: raise ValueError('Track tile limit') | |
| start=value.get('StartTileConnection') | |
| if not isinstance(start,dict): raise ValueError('StartTileConnection must be an object') | |
| # Match the local runner's saved-track import: game files can omit default Type. | |
| # Normalize only this parsed copy; never rewrite the uploaded source bytes. | |
| if 'Type' not in start: start['Type']=0 | |
| elif type(start['Type']) is not int: raise ValueError('StartTileConnection.Type must be an integer') | |
| return value | |
| def native_environment(gpu_library=None): | |
| env={'PATH':'/usr/bin:/bin','LANG':'C','RUST_BACKTRACE':'0'} | |
| if gpu_library is not None: | |
| library=Path(gpu_library).resolve() | |
| if not library.is_file(): raise RuntimeError('CUDA library unavailable') | |
| # Device/loader plumbing from an active lease, never provider credentials. | |
| for key in ('LD_LIBRARY_PATH','LD_PRELOAD','CUDA_VISIBLE_DEVICES','NVIDIA_VISIBLE_DEVICES'): | |
| if key in os.environ: env[key]=os.environ[key] | |
| env['ALTD_GPU_LIB']=str(library) | |
| return env | |
| def best_run_lap(history): | |
| # Native best_lap_s is generation-local. Include the independently logged | |
| # all-time value and prior generations, never a non-finite sentinel. | |
| values = [row.get(key) for row in history for key in ('best_lap_s', 'all_time_best_lap_s')] | |
| laps = [v for v in values if type(v) in (int, float) and math.isfinite(v) and v > 0] | |
| return min(laps) if laps else None | |
| def vehicle_scene_template(scene_template, vehicle_type): | |
| if type(vehicle_type) is not int or not 0<=vehicle_type<len(VEHICLE_NAMES): | |
| raise ValueError('Unsupported vehicle Type') | |
| formula=Path(scene_template or ROOT/'assets/formula_template.json').resolve() | |
| if vehicle_type==0:return formula | |
| name=VEHICLE_NAMES[vehicle_type].lower() | |
| # Only the application-supplied Formula path determines the sibling asset | |
| # directory; uploaded JSON never supplies a template path. | |
| return (formula.parent/(name+'_template.json')).resolve() | |
| def check_current_network(work, command, env, track, template, config, result, track_bytes, backend): | |
| """One independent fixed-weight check; its failure must not lose trained weights.""" | |
| network_sha=hashlib.sha256(result).hexdigest() | |
| track_sha=hashlib.sha256(track_bytes).hexdigest() | |
| kwargs=dict(network_sha256=network_sha,track_sha256=track_sha,backend=backend) | |
| if not needs_observations(track,track_sha): | |
| return resolve_check(track,template,config,[],**kwargs) | |
| check_command=list(command) | |
| if '--freeze-spec' in check_command: | |
| index=check_command.index('--freeze-spec') | |
| del check_command[index:index+2] | |
| def option(name,value): | |
| check_command[check_command.index(name)+1]=str(value) | |
| n=template['NeuralNetwork'] | |
| policy=work/'star-policy.json' | |
| # The template contains the exported final leader after training, or the | |
| # exact input weights after evaluation. No random population is initialized. | |
| policy.write_text(json.dumps({'shape':n['Shape'],'weights':n['Weights'],'biases':n['Biases'], | |
| 'inputs':[f'sensor-{i}' for i in range(n['Shape'][0])], | |
| 'outputs':[OUTPUT_NAMES[i] for i in template['Outputs']]},allow_nan=False)) | |
| star_out=work/'star-result' | |
| for key,value in (('--network',policy),('--init-network',policy),('--out-dir',star_out), | |
| ('--population',1),('--generations',1),('--ticks',check_ticks(track,config)), | |
| ('--mutation-start',0),('--mutation-end',0)): | |
| option(key,value) | |
| if '--evaluate-frozen' not in check_command:check_command.append('--evaluate-frozen') | |
| check_command.append('--challenge-observations') | |
| try: | |
| subprocess.run(check_command,cwd=work,env=env,stdout=subprocess.DEVNULL, | |
| stderr=subprocess.DEVNULL,timeout=25,check=True) | |
| from analysis_result import bounded_read, parsed | |
| meta=parsed(bounded_read(star_out/'challenge-observations-meta.json',32*1024)) | |
| rows=bounded_read(star_out/'challenge-observations.jsonl',4*1024*1024) | |
| observations=[parsed(line) for line in rows.splitlines()] | |
| if (meta.get('schema')!='ald.challenge-observations' or meta.get('version')!=1 | |
| or meta.get('execution_backend')!=backend or meta.get('mode')!='evaluate' | |
| or meta.get('frames')!=len(observations) or len(observations)>3001 | |
| or meta.get('requested_ticks')!=check_ticks(track,config) | |
| or type(meta.get('lap_score')) not in (float,int) or not math.isfinite(meta['lap_score']) | |
| or meta['lap_score']<=0): | |
| raise ValueError('Invalid challenge observations') | |
| check_track=dict(track,LapScore=meta['lap_score']) | |
| return resolve_check(check_track,template,config,observations,**kwargs) | |
| except subprocess.TimeoutExpired: | |
| return resolve_check(track,template,config,[],error='The star check reached its time limit; trained weights are preserved.',**kwargs) | |
| except (OSError,subprocess.CalledProcessError,ValueError,KeyError,TypeError): | |
| return resolve_check(track,template,config,[],error='The star check could not obtain complete observations; trained weights are preserved.',**kwargs) | |
| def run_native(track_bytes,network_bytes,*,binary=None,importer=None,scene_template=None,with_report=False,gpu_library=None,config=None): | |
| started=time.perf_counter() | |
| config=validate_config(config, work_limit=8_000_000 if gpu_library is not None else 4_000_000) | |
| track=track_input(track_bytes); template=network_input(network_bytes) | |
| if config['mode']=='train':check_freeze_shape(config['freeze'],template['NeuralNetwork']['Shape']) | |
| # Deployment paths are supplied by trusted application configuration, never uploads. | |
| binary=Path(binary or ROOT/'target/release/altd-sim').resolve() | |
| importer=Path(importer or ROOT/'target/release/examples/extract_saved_track').resolve() | |
| scene_template=vehicle_scene_template(scene_template,template['Type']) | |
| if not all(p.is_file() for p in (binary,importer,scene_template)): | |
| raise RuntimeError('Native tools or scene template unavailable') | |
| # No inherited provider tokens, credential paths, or caller-chosen commands. | |
| env=native_environment(gpu_library) | |
| with tempfile.TemporaryDirectory(prefix='tiga-native-') as directory: | |
| work=Path(directory) | |
| env.update(HOME=directory,TMPDIR=directory) | |
| def save(name,value): | |
| path=work/name; path.write_text(json.dumps(value,allow_nan=False)); return str(path) | |
| saved=save('track.json',track) | |
| scene=work/'scene.json' | |
| subprocess.run([str(importer),saved,'User track',str(scene_template),str(scene)], | |
| cwd=work,env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=10,check=True) | |
| imported=json.loads(scene.read_text()) | |
| spawn=save('spawn.json',{'frames':[{'position':imported['reset_position'],'rotation':imported['reset_rotation']}]}) | |
| n=template['NeuralNetwork']; names=[f'sensor-{i}' for i in range(n['Shape'][0])] | |
| network=save('network.json',{'shape':n['Shape'],'weights':n['Weights'],'biases':n['Biases'],'inputs':names,'outputs':[OUTPUT_NAMES[i] for i in template['Outputs']]}) | |
| model=save('model.json',{'sensor_layout':{'names':names,'sensors':template['Sensors']}}) | |
| settings=save('settings.json',{'population':config['population'],'selection_algorithm':config['selection'],'selection_size':config['parents'], | |
| 'crossover':config['crossover'],'mutation_rate':config['mutation'],'adaptive_mutation':config['adaptive_mutation'],'weight_decay':config['decay'], | |
| 'preserve_parents':'on_custom','preserve_parents_size':config['elite'], | |
| 'rewards':config['rewards']}) | |
| out=work/'result' | |
| command=[str(binary),'--math-profile','proton','--threads',str(config['workers']),'train-scratch', | |
| '--scene',str(scene),'--spawn-trace',spawn,'--network',network,'--init-network',network, | |
| '--model',model,'--settings',settings,'--shape',','.join(map(str,n['Shape'])), | |
| '--population',str(config['population']),'--generations',str(config['generations']), | |
| '--ticks',str(config['ticks']),'--seed',str(config['seed']),'--batch-count',str(60//config['control_hz']), | |
| '--out-dir',str(out),'--mutation-start',str(config['mutation']), | |
| '--mutation-end',str(config['mutation'] if config['schedule']=='fixed' else config['mutation_end']), | |
| '--schedule','linear' if config['schedule']=='fixed' else config['schedule'],'--save-final-candidate', | |
| '--checkpoint-every','0','--analysis','--clean-min-laps',str(config['clean_min_laps']), | |
| '--eliminate-on-wall' if config['collision'] else '--no-eliminate-on-wall', | |
| '--idle-eliminate' if config['idle'] else '--no-idle-eliminate'] | |
| if config['mode']=='train' and any(config['freeze'].values()): | |
| command.extend(('--freeze-spec',save('freeze.json',config['freeze']))) | |
| if config['mode']=='evaluate':command.append('--evaluate-frozen') | |
| if gpu_library is not None: command.append('--gpu') | |
| subprocess.run(command,cwd=work,env=env,stdout=subprocess.DEVNULL,stderr=subprocess.DEVNULL,timeout=45 if gpu_library is not None else 25,check=True) | |
| if config['mode']=='train': | |
| candidate=out/'candidate.json' | |
| if candidate.stat().st_size>1024*1024: raise ValueError('Output too large') | |
| trained=json.loads(candidate.read_text()) | |
| if any(config['freeze'].values()):verify_frozen_parameters(config['freeze'],n,trained) | |
| n['Weights']=trained['weights']; n['Biases']=trained['biases'] | |
| result=(network_bytes if config['mode']=='evaluate' else gzip.compress(json.dumps(template,allow_nan=False).encode(),mtime=0)) | |
| network_input(result) | |
| history=[json.loads(line) for line in (out/'log.jsonl').read_text().splitlines() if line.strip()] | |
| last=history[-1] if history else {} | |
| files,summary,evaluation=assemble_analysis(out,template,result,network_bytes,track_bytes,config,'cuda' if gpu_library is not None else 'cpu',network_input) | |
| stars=check_current_network(work,command,env,track,template,config,result,track_bytes, | |
| 'cuda' if gpu_library is not None else 'cpu') | |
| files['stars.json']=json.dumps(stars,allow_nan=False,separators=(',',':')).encode() | |
| report={'mode':config['mode'],'analysis_summary':summary,'_analysis_files':files,'build':build_identity(),'state':'completed','elapsed_seconds':time.perf_counter()-started, | |
| 'generations_completed':len(history),'generations_requested':config['generations'],'population':config['population'], | |
| 'best_score':last.get('best_score'),'mean_score':last.get('mean_score'), | |
| 'best_lap_seconds':best_run_lap(history),'best_lap_scope':'Best completed lap observed during this run; may belong to a different car than the exported candidate','lapped_cars':last.get('lapped_cars'), | |
| 'simulated_ticks':last.get('simulated_ticks'),'requested_ticks':config['ticks'], | |
| 'candidate_validated':True,'execution_backend':'cuda' if gpu_library is not None else 'cpu', | |
| 'vehicle_type':template['Type'],'vehicle_name':VEHICLE_NAMES[template['Type']], | |
| 'inputs':{'track_sha256':hashlib.sha256(track_bytes).hexdigest(),'network_sha256':hashlib.sha256(network_bytes).hexdigest()}, | |
| 'settings':config,'history':[{'generation':i+1,'mutation':h.get('mutation_rate'), | |
| 'best_score':h.get('best_score'),'mean_score':h.get('mean_score'),'best_lap_seconds':h.get('best_lap_s'), | |
| 'lapped_cars':h.get('lapped_cars'),'simulated_ticks':h.get('simulated_ticks')} for i,h in enumerate(history)]} | |
| # The context has removed input/intermediate files before result publication. | |
| return (result,report) if with_report else result | |
| def run_reported(track_bytes,network_bytes,config=None): | |
| return run_native(track_bytes,network_bytes,with_report=True,config=config) | |