How to use the tianshou.data.to_torch function in tianshou

assert data_list_2_torch.shape == (2, 3, 3)
    assert np.allclose(to_numpy(to_torch(data_list_2)), data_list_2)
    data_list_3 = [np.zeros((3, 2)), np.zeros((3, 3))]
    data_list_3_torch = to_torch(data_list_3)
    assert isinstance(data_list_3_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_3_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_3)), data_list_3)))
    data_list_4 = [np.zeros((2, 3)), np.zeros((3, 3))]
    data_list_4_torch = to_torch(data_list_4)
    assert isinstance(data_list_4_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_4_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_4)), data_list_4)))
    data_list_5 = [np.zeros(2), np.zeros((3, 3))]
    data_list_5_torch = to_torch(data_list_5)
    assert isinstance(data_list_5_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_5_torch)
    data_array = np.random.rand(3, 2, 2)
    data_empty_tensor = to_torch(data_array[[]])
    assert isinstance(data_empty_tensor, torch.Tensor)
    assert data_empty_tensor.shape == (0, 2, 2)
    data_empty_array = to_numpy(data_empty_tensor)
    assert isinstance(data_empty_array, np.ndarray)
    assert data_empty_array.shape == (0, 2, 2)
    assert np.allclose(to_numpy(to_torch(data_array)), data_array)

assert isinstance(data_list_3_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_3_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_3)), data_list_3)))
    data_list_4 = [np.zeros((2, 3)), np.zeros((3, 3))]
    data_list_4_torch = to_torch(data_list_4)
    assert isinstance(data_list_4_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_4_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_4)), data_list_4)))
    data_list_5 = [np.zeros(2), np.zeros((3, 3))]
    data_list_5_torch = to_torch(data_list_5)
    assert isinstance(data_list_5_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_5_torch)
    data_array = np.random.rand(3, 2, 2)
    data_empty_tensor = to_torch(data_array[[]])
    assert isinstance(data_empty_tensor, torch.Tensor)
    assert data_empty_tensor.shape == (0, 2, 2)
    data_empty_array = to_numpy(data_empty_tensor)
    assert isinstance(data_empty_array, np.ndarray)
    assert data_empty_array.shape == (0, 2, 2)
    assert np.allclose(to_numpy(to_torch(data_array)), data_array)

def test_utils_to_torch_numpy():
    batch = Batch(
        a=np.float64(1.0),
        b=Batch(
            c=np.ones((1,), dtype=np.float32),
            d=torch.ones((1,), dtype=torch.float64)
        )
    )
    a_torch_float = to_torch(batch.a, dtype=torch.float32)
    assert a_torch_float.dtype == torch.float32
    a_torch_double = to_torch(batch.a, dtype=torch.float64)
    assert a_torch_double.dtype == torch.float64
    batch_torch_float = to_torch(batch, dtype=torch.float32)
    assert batch_torch_float.a.dtype == torch.float32
    assert batch_torch_float.b.c.dtype == torch.float32
    assert batch_torch_float.b.d.dtype == torch.float32
    data_list = [float('nan'), 1]
    data_list_torch = to_torch(data_list)
    assert data_list_torch.dtype == torch.float64
    data_list_2 = [np.random.rand(3, 3), np.random.rand(3, 3)]
    data_list_2_torch = to_torch(data_list_2)
    assert data_list_2_torch.shape == (2, 3, 3)
    assert np.allclose(to_numpy(to_torch(data_list_2)), data_list_2)
    data_list_3 = [np.zeros((3, 2)), np.zeros((3, 3))]
    data_list_3_torch = to_torch(data_list_3)

assert a_torch_float.dtype == torch.float32
    a_torch_double = to_torch(batch.a, dtype=torch.float64)
    assert a_torch_double.dtype == torch.float64
    batch_torch_float = to_torch(batch, dtype=torch.float32)
    assert batch_torch_float.a.dtype == torch.float32
    assert batch_torch_float.b.c.dtype == torch.float32
    assert batch_torch_float.b.d.dtype == torch.float32
    data_list = [float('nan'), 1]
    data_list_torch = to_torch(data_list)
    assert data_list_torch.dtype == torch.float64
    data_list_2 = [np.random.rand(3, 3), np.random.rand(3, 3)]
    data_list_2_torch = to_torch(data_list_2)
    assert data_list_2_torch.shape == (2, 3, 3)
    assert np.allclose(to_numpy(to_torch(data_list_2)), data_list_2)
    data_list_3 = [np.zeros((3, 2)), np.zeros((3, 3))]
    data_list_3_torch = to_torch(data_list_3)
    assert isinstance(data_list_3_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_3_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_3)), data_list_3)))
    data_list_4 = [np.zeros((2, 3)), np.zeros((3, 3))]
    data_list_4_torch = to_torch(data_list_4)
    assert isinstance(data_list_4_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_4_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_4)), data_list_4)))
    data_list_5 = [np.zeros(2), np.zeros((3, 3))]
    data_list_5_torch = to_torch(data_list_5)
    assert isinstance(data_list_5_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_5_torch)
    data_array = np.random.rand(3, 2, 2)
    data_empty_tensor = to_torch(data_array[[]])

def test_utils_to_torch_numpy():
    batch = Batch(
        a=np.float64(1.0),
        b=Batch(
            c=np.ones((1,), dtype=np.float32),
            d=torch.ones((1,), dtype=torch.float64)
        )
    )
    a_torch_float = to_torch(batch.a, dtype=torch.float32)
    assert a_torch_float.dtype == torch.float32
    a_torch_double = to_torch(batch.a, dtype=torch.float64)
    assert a_torch_double.dtype == torch.float64
    batch_torch_float = to_torch(batch, dtype=torch.float32)
    assert batch_torch_float.a.dtype == torch.float32
    assert batch_torch_float.b.c.dtype == torch.float32
    assert batch_torch_float.b.d.dtype == torch.float32
    data_list = [float('nan'), 1]
    data_list_torch = to_torch(data_list)
    assert data_list_torch.dtype == torch.float64
    data_list_2 = [np.random.rand(3, 3), np.random.rand(3, 3)]
    data_list_2_torch = to_torch(data_list_2)
    assert data_list_2_torch.shape == (2, 3, 3)
    assert np.allclose(to_numpy(to_torch(data_list_2)), data_list_2)
    data_list_3 = [np.zeros((3, 2)), np.zeros((3, 3))]
    data_list_3_torch = to_torch(data_list_3)
    assert isinstance(data_list_3_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_3_torch)

assert batch_torch_float.b.d.dtype == torch.float32
    data_list = [float('nan'), 1]
    data_list_torch = to_torch(data_list)
    assert data_list_torch.dtype == torch.float64
    data_list_2 = [np.random.rand(3, 3), np.random.rand(3, 3)]
    data_list_2_torch = to_torch(data_list_2)
    assert data_list_2_torch.shape == (2, 3, 3)
    assert np.allclose(to_numpy(to_torch(data_list_2)), data_list_2)
    data_list_3 = [np.zeros((3, 2)), np.zeros((3, 3))]
    data_list_3_torch = to_torch(data_list_3)
    assert isinstance(data_list_3_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_3_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_3)), data_list_3)))
    data_list_4 = [np.zeros((2, 3)), np.zeros((3, 3))]
    data_list_4_torch = to_torch(data_list_4)
    assert isinstance(data_list_4_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_4_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_4)), data_list_4)))
    data_list_5 = [np.zeros(2), np.zeros((3, 3))]
    data_list_5_torch = to_torch(data_list_5)
    assert isinstance(data_list_5_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_5_torch)
    data_array = np.random.rand(3, 2, 2)
    data_empty_tensor = to_torch(data_array[[]])
    assert isinstance(data_empty_tensor, torch.Tensor)
    assert data_empty_tensor.shape == (0, 2, 2)
    data_empty_array = to_numpy(data_empty_tensor)
    assert isinstance(data_empty_array, np.ndarray)
    assert data_empty_array.shape == (0, 2, 2)
    assert np.allclose(to_numpy(to_torch(data_array)), data_array)

d=torch.ones((1,), dtype=torch.float64)
        )
    )
    a_torch_float = to_torch(batch.a, dtype=torch.float32)
    assert a_torch_float.dtype == torch.float32
    a_torch_double = to_torch(batch.a, dtype=torch.float64)
    assert a_torch_double.dtype == torch.float64
    batch_torch_float = to_torch(batch, dtype=torch.float32)
    assert batch_torch_float.a.dtype == torch.float32
    assert batch_torch_float.b.c.dtype == torch.float32
    assert batch_torch_float.b.d.dtype == torch.float32
    data_list = [float('nan'), 1]
    data_list_torch = to_torch(data_list)
    assert data_list_torch.dtype == torch.float64
    data_list_2 = [np.random.rand(3, 3), np.random.rand(3, 3)]
    data_list_2_torch = to_torch(data_list_2)
    assert data_list_2_torch.shape == (2, 3, 3)
    assert np.allclose(to_numpy(to_torch(data_list_2)), data_list_2)
    data_list_3 = [np.zeros((3, 2)), np.zeros((3, 3))]
    data_list_3_torch = to_torch(data_list_3)
    assert isinstance(data_list_3_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_3_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_3)), data_list_3)))
    data_list_4 = [np.zeros((2, 3)), np.zeros((3, 3))]
    data_list_4_torch = to_torch(data_list_4)
    assert isinstance(data_list_4_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_4_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_4)), data_list_4)))
    data_list_5 = [np.zeros(2), np.zeros((3, 3))]
    data_list_5_torch = to_torch(data_list_5)

def test_utils_to_torch_numpy():
    batch = Batch(
        a=np.float64(1.0),
        b=Batch(
            c=np.ones((1,), dtype=np.float32),
            d=torch.ones((1,), dtype=torch.float64)
        )
    )
    a_torch_float = to_torch(batch.a, dtype=torch.float32)
    assert a_torch_float.dtype == torch.float32
    a_torch_double = to_torch(batch.a, dtype=torch.float64)
    assert a_torch_double.dtype == torch.float64
    batch_torch_float = to_torch(batch, dtype=torch.float32)
    assert batch_torch_float.a.dtype == torch.float32
    assert batch_torch_float.b.c.dtype == torch.float32
    assert batch_torch_float.b.d.dtype == torch.float32
    data_list = [float('nan'), 1]
    data_list_torch = to_torch(data_list)
    assert data_list_torch.dtype == torch.float64
    data_list_2 = [np.random.rand(3, 3), np.random.rand(3, 3)]
    data_list_2_torch = to_torch(data_list_2)
    assert data_list_2_torch.shape == (2, 3, 3)
    assert np.allclose(to_numpy(to_torch(data_list_2)), data_list_2)
    data_list_3 = [np.zeros((3, 2)), np.zeros((3, 3))]
    data_list_3_torch = to_torch(data_list_3)
    assert isinstance(data_list_3_torch, list)
    assert all(isinstance(e, torch.Tensor) for e in data_list_3_torch)
    assert all(starmap(np.allclose,
               zip(to_numpy(to_torch(data_list_3)), data_list_3)))

def forward(self, s, a=None):
        """Almost the same as :class:`~tianshou.utils.net.common.Recurrent`."""
        s = to_torch(s, device=self.device, dtype=torch.float32)
        # s [bsz, len, dim] (training) or [bsz, dim] (evaluation)
        # In short, the tensor's shape in training phase is longer than which
        # in evaluation phase.
        assert len(s.shape) == 3
        self.nn.flatten_parameters()
        s, (h, c) = self.nn(s)
        s = s[:, -1]
        if a is not None:
            if not isinstance(a, torch.Tensor):
                a = torch.tensor(a, device=self.device, dtype=torch.float32)
            s = torch.cat([s, a], dim=1)
        s = self.fc2(s)
        return s

def forward(self, s, a=None, **kwargs):
        """(s, a) -> logits -> Q(s, a)"""
        s = to_torch(s, device=self.device, dtype=torch.float32)
        s = s.flatten(1)
        if a is not None:
            a = to_torch(a, device=self.device, dtype=torch.float32)
            a = a.flatten(1)
            s = torch.cat([s, a], dim=1)
        logits, h = self.preprocess(s)
        logits = self.last(logits)
        return logits