code: def beam_q_estimate(
      beam: List[Tuple[Linearizer, float]]
  ) -> List[Tuple[Linearizer, float]]:
      global _net
      if _net is None:
          from tinygrad.nn.state import load_state_dict, safe_load
          from extra.optimization.pretrain_valuenet import ValueNet
  
          _net = ValueNet(1021 + len(actions), 2)
          load_state_dict(
              _net, safe_load("/tmp/qnet.safetensors"), verbose=False
          )
      from tinygrad.tensor import Tensor
      from tinygrad.helpers import Context
      from extra.optimization.helpers import lin_to_feats
      import numpy as np
  
      feats = []
      lins = []
      base_tms = []
      for lin, tm in beam:
          lin_feats = lin_to_feats(lin)
          for a, v in get_linearizer_actions(
              lin, include_0=False
          ).items():
              acts = np.zeros(len(actions))
              acts[a - 1] = 1.0
              feats.append(np.concatenate([lin_feats, acts]))
              lins.append(v)
              base_tms.append(tm)
      with Context(BEAM=0):
          with Tensor.train(False):
              preds = _net(Tensor(feats)).numpy()
      pred_time = np.array(base_tms) / np.exp(preds[:, 0])
      return sorted(zip(lins, pred_time), key=lambda x: x[1])
  
imports: from typing import List, Tuple
  from tinygrad.codegen.linearizer import Linearizer
  from tinygrad.features.search import get_linearizer_actions, actions
label_desc: Use image node_id 1 for calling a global function with example usage: beam_q_estimate(beam) and returns: sorted