Apple Minions：闲置 Mac 能接走哪些推理任务，先算模型副本与传输预算

#!/usr/bin/env python3
"""Byte and memory budget only. No network, model execution or speedup estimate."""
import argparse
import json
import sys
from decimal import Decimal, DecimalException

FIELDS = {'available_memory_bytes', 'model_download_bytes', 'model_resident_bytes',
          'extra_memory_bytes', 'cached_workers', 'records', 'input_bytes_per_record',
          'vector_dimensions', 'bytes_per_component', 'shared_bytes_per_second'}

def integer(v, name, minimum=0):
    if type(v) is not int or v < minimum:
        raise ValueError(f'{name} must be an integer >= {minimum}')
    return v

def calculate(d):
    if not isinstance(d, dict) or set(d) != FIELDS:
        raise ValueError('input must contain exactly these fields: ' + ', '.join(sorted(FIELDS)))
    memory = d['available_memory_bytes']
    if not isinstance(memory, list) or not memory:
        raise ValueError('available_memory_bytes must be a nonempty list')
    for i, value in enumerate(memory):
        integer(value, f'available_memory_bytes[{i}]', 1)
    n = len(memory)
    positive = ['model_download_bytes', 'model_resident_bytes', 'records',
                'vector_dimensions', 'bytes_per_component']
    for key in positive:
        integer(d[key], key, 1)
    for key in ['extra_memory_bytes', 'cached_workers', 'input_bytes_per_record']:
        integer(d[key], key)
    if d['cached_workers'] > n:
        raise ValueError('cached_workers cannot exceed worker count')
    rate_value = d['shared_bytes_per_second']
    if isinstance(rate_value, bool) or not isinstance(rate_value, (str, int, float)):
        raise ValueError('shared_bytes_per_second must be a positive finite number')
    try:
        rate = Decimal(str(rate_value))
    except DecimalException:
        raise ValueError('shared_bytes_per_second must be a positive finite number')
    if not rate.is_finite() or rate <= 0:
        raise ValueError('shared_bytes_per_second must be a positive finite number')
    required = d['model_resident_bytes'] + d['extra_memory_bytes']
    bad = [i + 1 for i, m in enumerate(memory) if m < required]
    if bad:
        raise ValueError(f'insufficient memory budget on workers {bad}; each needs {required} bytes')
    model_transfer = (n - d['cached_workers']) * d['model_download_bytes']
    incoming = d['records'] * d['input_bytes_per_record']
    outgoing = d['records'] * d['vector_dimensions'] * d['bytes_per_component']
    dataset = incoming + outgoing
    try:
        lower_bound = str(Decimal(dataset + model_transfer) / rate)
    except DecimalException:
        raise ValueError('shared_bytes_per_second is outside the supported calculation range')
    return {
        'workers': n, 'replicas_per_worker': 1,
        'required_memory_bytes_per_worker': required,
        'memory_headroom_bytes_per_worker': [m - required for m in memory],
        'model_cache_bytes_per_worker': d['model_download_bytes'],
        'model_transfer_bytes': model_transfer,
        'input_bytes': incoming, 'raw_output_bytes': outgoing,
        'dataset_transfer_bytes': dataset, 'total_transfer_bytes': dataset + model_transfer,
        'shared_transfer_lower_bound_seconds': lower_bound,
        'assumptions': 'One model replica per worker; each record processed once; all counted bytes traverse one shared bottleneck; payload only; no timing or speedup prediction.'
    }

def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('input_json')
    args = parser.parse_args()
    try:
        with open(args.input_json, encoding='utf-8') as f:
            data = json.load(f)
        result = calculate(data)
    except (OSError, ValueError) as exc:
        print(f'error: {exc}', file=sys.stderr)
        return 2
    print(json.dumps(result, ensure_ascii=False, indent=2))
    return 0

if __name__ == '__main__':
    sys.exit(main())

{
  "available_memory_bytes": [8000000000, 8000000000, 8000000000, 8000000000],
  "model_download_bytes": 4000000000,
  "model_resident_bytes": 4000000000,
  "extra_memory_bytes": 2000000000,
  "cached_workers": 0,
  "records": 1000000,
  "input_bytes_per_record": 2000,
  "vector_dimensions": 768,
  "bytes_per_component": 4,
  "shared_bytes_per_second": 100000000
}

{
  "workers": 4,
  "replicas_per_worker": 1,
  "required_memory_bytes_per_worker": 6000000000,
  "memory_headroom_bytes_per_worker": [
    2000000000,
    2000000000,
    2000000000,
    2000000000
  ],
  "model_cache_bytes_per_worker": 4000000000,
  "model_transfer_bytes": 16000000000,
  "input_bytes": 2000000000,
  "raw_output_bytes": 3072000000,
  "dataset_transfer_bytes": 5072000000,
  "total_transfer_bytes": 21072000000,
  "shared_transfer_lower_bound_seconds": "210.72",
  "assumptions": "One model replica per worker; each record processed once; all counted bytes traverse one shared bottleneck; payload only; no timing or speedup prediction."
}