def make_data_loaders(train_filename, val_filename, feature_set, num_workers, batch_size, filtered, random_fen_skipping, main_device): # Epoch and validation sizes are arbitrary epoch_size = 100000000 val_size = 1000000 features_name = feature_set.name train_infinite = nnue_dataset.SparseBatchDataset( features_name, train_filename, batch_size, num_workers=num_workers, filtered=filtered, random_fen_skipping=random_fen_skipping, device=main_device) val_infinite = nnue_dataset.SparseBatchDataset( features_name, val_filename, batch_size, filtered=filtered, random_fen_skipping=random_fen_skipping, device=main_device) # num_workers has to be 0 for sparse, and 1 for dense # it currently cannot work in parallel mode but it shouldn't need to train = DataLoader(nnue_dataset.FixedNumBatchesDataset( train_infinite, (epoch_size + batch_size - 1) // batch_size), batch_size=None, batch_sampler=None) val = DataLoader(nnue_dataset.FixedNumBatchesDataset( val_infinite, (val_size + batch_size - 1) // batch_size), batch_size=None, batch_sampler=None) return train, val
def data_loader_cc(train_filename, val_filename, num_workers, batch_size, filtered, random_fen_skipping, main_device): # Epoch and validation sizes are arbitrary epoch_size = 100000000 val_size = 2000000 train_infinite = nnue_dataset.SparseBatchDataset( train_filename, batch_size, num_workers=num_workers, filtered=filtered, random_fen_skipping=random_fen_skipping, device=main_device) val_infinite = nnue_dataset.SparseBatchDataset( val_filename, batch_size, filtered=filtered, random_fen_skipping=random_fen_skipping, device=main_device) train = DataLoader(nnue_dataset.FixedNumBatchesDataset( train_infinite, (epoch_size + batch_size - 1) // batch_size), batch_size=None, batch_sampler=None) val = DataLoader(nnue_dataset.FixedNumBatchesDataset( val_infinite, (val_size + batch_size - 1) // batch_size), batch_size=None, batch_sampler=None) return train, val
def data_loader_cc(train_filename, val_filename, data_name, num_workers, batch_size, filtered): # Epoch and validation sizes are arbitrary epoch_size = int(3e7) val_size = epoch_size // 20 train_infinite = nnue_dataset.SparseBatchDataset(data_name, train_filename, batch_size, num_workers=num_workers, filtered=filtered) val_infinite = nnue_dataset.SparseBatchDataset(data_name, val_filename, batch_size, filtered=filtered) # num_workers has to be 0 for sparse, and 1 for dense # it currently cannot work in parallel mode but it shouldn't need to train = DataLoader(nnue_dataset.FixedNumBatchesDataset(train_infinite, (epoch_size + batch_size - 1) // batch_size), batch_size=None, batch_sampler=None) val = DataLoader(nnue_dataset.FixedNumBatchesDataset(val_infinite, (val_size + batch_size - 1) // batch_size), batch_size=None, batch_sampler=None) return train, val
def create_data_loaders(train_filename, val_filename, epoch_size, val_size, batch_size, use_factorizer, main_device): train_dataset = nnue_dataset.SparseBatchDataset( train_filename, epoch_size, batch_size, use_factorizer, (epoch_size + batch_size - 1) // batch_size, device=main_device) val_dataset = nnue_dataset.SparseBatchDataset( val_filename, val_size, batch_size, use_factorizer, (val_size + batch_size - 1) // batch_size, device=main_device) train = DataLoader(train_dataset, batch_size=None, batch_sampler=None) val = DataLoader(val_dataset, batch_size=None, batch_sampler=None) return train, val
def gather_statistics_from_data(filename, count, bucket_size): ''' Takes a .bin or .binpack file and produces perf% statistics The result is a dictionary of the form { eval : (perf%, count) } ''' batch_size = 8192 cyclic = True smart_fen_skipping = True # we pass whatever feature set because we have to pass something # it doesn't actually matter, all we care about are the scores and outcomes # this is just the easiest way to do it dataset = nnue_dataset.SparseBatchDataset('HalfKP', filename, batch_size, cyclic, smart_fen_skipping) batches = iter(dataset) num_batches = (count + batch_size - 1) // batch_size data = gather_statistics_from_batches((next(batches) for i in range(num_batches)), bucket_size) return data
def test(model): import nnue_dataset dataset = 'd8_100000.bin' stream_cpp = nnue_dataset.SparseBatchDataset(halfkp.NAME, dataset, 1) stream_cpp_iter = iter(stream_cpp) tensors_cpp = next(stream_cpp_iter)[:4] print('cpp:', tensors_cpp[3]) print(model(*tensors_cpp)) stream_py = nnue_bin_dataset.NNUEBinData(dataset) stream_py_iter = iter(stream_py) tensors_py = next(stream_py_iter) print('python:', torch.nonzero(tensors_py[3]).squeeze()) tensors_py = [v.reshape((1, -1)) for v in tensors_py[:4]] weights = coalesce_weights(model.input.weight.data) model.input.weight = torch.nn.Parameter(weights) print(model(*tensors_py))
def main(): parser = argparse.ArgumentParser( description="Runs evaluation for a model.") parser.add_argument("model", help="Source file (can be .ckpt, .pt or .nnue)") parser.add_argument("--dataset", default="d8_128000_21865.binpack", help="Dataset to evaluate on (.bin)") args = parser.parse_args() if args.model.endswith(".pt"): nnue = torch.load(args.model, map_location=torch.device('cpu')) else: nnue = M.NNUE.load_from_checkpoint(args.model) val_infinite = nnue_dataset.SparseBatchDataset(halfkp.NAME, args.dataset, 8000) data = nnue_dataset.FixedNumBatchesDataset(val_infinite, 16) trainer = pl.Trainer(progress_bar_refresh_rate=0) for i in range(21): nnue.lambda_ = i / 20.0 loss = trainer.test(nnue, data, verbose=False) print(nnue.lambda_, ",", loss[0]['test_loss'])
if batch_size: stream = stream_type(halfkp.NAME, 'd8_100000.bin', batch_size) else: stream = stream_type(halfkp.NAME, 'd8_100000.bin') start_time = time.time() for i in range(4096 // (batch_size if batch_size else 1)): tensors = next(stream) end_time = time.time() print('{:6.3f} seconds'.format(end_time - start_time)) del stream test_stream(nnue_dataset.SparseBatchProvider, 256) stream_py = nnue_bin_dataset.NNUEBinData('d8_100000.bin') stream_cpp = nnue_dataset.SparseBatchDataset(halfkp.NAME, 'd8_100000.bin', 256) stream_py_iter = iter(stream_py) stream_cpp_iter = iter(stream_cpp) diff = 0.0 for i in range(10): # Gather a batch tensors_cpp = next(stream_cpp_iter) for j in range(256): tensors_py = next(stream_py_iter) diff += sum((a - b[j]).norm() for a, b in zip(tensors_py, tensors_cpp)) print('Diff: {}'.format(diff))