def a():
base = 5
stair_length = 9
stair = [to_tensor(range(i + base)) for i in range(stair_length)]
pad = [min_length_pad(s, stair_length + base) for s in stair]
print(to_tensor(pad))
def stest_many_versus_many(model, data_dir, img_size, threshold=0.5):
""" """
data_iterator = iter(
DataLoader(
PairDataset(
data_dir,
transform=transforms.Compose([
transforms.Grayscale(),
transforms.Resize(img_size),
transforms.ToTensor(),
]),
),
num_workers=0,
batch_size=1,
shuffle=True,
))
for i in range(10):
x0, x1, is_diff = next(data_iterator)
distance = (torch.pairwise_distance(*model(
to_tensor(x0, device=global_torch_device()),
to_tensor(x1, device=global_torch_device()),
)).cpu().item())
boxed_text_overlay_plot(
torchvision.utils.make_grid(torch.cat((x0, x1), 0)),
f"Truth: {'Different' if is_diff.cpu().item() else 'Alike'},"
f" Dissimilarity: {distance:.2f},"
f" Verdict: {'Different' if distance > threshold else 'Alike'}",
)
def test_multi_dim():
pos_size = (2, 3, 2)
a_size = (2, 4, 5)
model = MLP(input_shape=pos_size, output_shape=a_size)
pos_1 = to_tensor(numpy.random.rand(64, numpy.prod(pos_size[1:])), device="cpu")
pos_2 = to_tensor(numpy.random.rand(64, numpy.prod(pos_size[1:])), device="cpu")
print(model(pos_1, pos_2))
def single_cat():
s = (1, 2)
a = (2, )
model = CategoricalMLP(input_shape=s, output_shape=a)
inp = to_tensor(numpy.random.rand(64, s[0]), device="cpu")
inp2 = to_tensor(numpy.random.rand(64, s[1]), device="cpu")
print(model(inp, inp2).sample())
def gasdasa():
""" """
from draugr.torch_utilities import to_tensor
base = 5
stair_length = 9
stair = [to_tensor(range(i + base)) for i in range(stair_length)]
trunc = [last_dim_truncate(s, base) for s in stair]
print(to_tensor(trunc))
def __build__(
self,
observation_space: ObservationSpace,
action_space: ActionSpace,
signal_space: SignalSpace,
metric_writer: Writer = MockWriter(),
print_model_repr: bool = True,
) -> None:
"""
@param observation_space:
@param action_space:
@param signal_space:
@param metric_writer:
@param print_model_repr:
@return:
"""
if action_space.is_discrete:
raise ActionSpaceNotSupported(
"discrete action space not supported in this implementation"
)
self._critic_arch_spec.kwargs["input_shape"] = (
self._input_shape + self._output_shape
)
self._critic_arch_spec.kwargs["output_shape"] = 1
self.critic_1 = self._critic_arch_spec().to(self._device)
self.critic_1_target = copy.deepcopy(self.critic_1).to(self._device)
freeze_model(self.critic_1_target, True, True)
self.critic_2 = self._critic_arch_spec().to(self._device)
self.critic_2_target = copy.deepcopy(self.critic_2).to(self._device)
freeze_model(self.critic_2_target, True, True)
self.critic_optimiser = self._critic_optimiser_spec(
itertools.chain(self.critic_1.parameters(), self.critic_2.parameters())
)
self._actor_arch_spec.kwargs["input_shape"] = self._input_shape
self._actor_arch_spec.kwargs["output_shape"] = self._output_shape
self.actor = self._actor_arch_spec().to(self._device)
self.actor_optimiser = self._actor_optimiser_spec(self.actor.parameters())
if self._auto_tune_sac_alpha:
self._target_entropy = -torch.prod(
to_tensor(self._output_shape, device=self._device)
).item()
self._log_sac_alpha = nn.Parameter(
torch.log(to_tensor(self._sac_alpha, device=self._device)),
requires_grad=True,
)
self.sac_alpha_optimiser = self._auto_tune_sac_alpha_optimiser_spec(
[self._log_sac_alpha]
)
def _update(self, *, metric_writer=MockWriter()) -> float:
"""
:param metric_writer:
:returns:
"""
if not len(self._memory_buffer) > 0:
raise NoTrajectoryException
trajectory = self._memory_buffer.retrieve_trajectory()
self._memory_buffer.clear()
log_probs = to_tensor(
[
self.get_log_prob(d, a)
for d, a in zip(trajectory.distribution, trajectory.action)
],
device=self._device,
)
signal = to_tensor(trajectory.signal, device=self._device)
non_terminal = to_tensor(non_terminal_numerical_mask(
trajectory.terminated),
device=self._device)
discounted_signal = discount_rollout_signal_torch(
signal,
self._discount_factor,
device=self._device,
non_terminal=non_terminal,
)
loss = -(log_probs * discounted_signal).mean()
self._optimiser.zero_grad()
loss.backward()
self.post_process_gradients(self.distributional_regressor.parameters())
self._optimiser.step()
if self._scheduler:
self._scheduler.step()
if metric_writer:
for i, param_group in enumerate(self._optimiser.param_groups):
metric_writer.scalar(f"lr{i}", param_group["lr"])
loss_cpu = loss.detach().to("cpu").numpy()
if metric_writer:
metric_writer.scalar("Loss", loss_cpu)
return loss_cpu.item()
def stest_multi_dim_normal2321412121():
"""
"""
s = (19,)
s1 = (4,)
batch_size = (100,)
output_shape = 2
model = LateConcatInputMLP(input_shape=s + s1, output_shape=output_shape)
inp = to_tensor(numpy.random.random((*batch_size, *s)), device="cpu")
late_input = to_tensor(numpy.random.random((*batch_size, *s1)), device="cpu")
print(model.forward(inp, late_input))
def asadsa2():
""" """
from draugr.torch_utilities import to_tensor
from neodroidaudition.data.recognition.libri_speech import LibriSpeech
from neodroidaudition.noise_generation.gaussian_noise import white_noise
import torchaudio
from pathlib import Path
libri_speech = LibriSpeech(path=Path.home() / "Data" / "Audio" /
"Speech" / "LibriSpeech")
files, sr = zip(*[(v[0].numpy(), v[1])
for _, v in zip(range(1), libri_speech)])
assert all([sr[0] == s for s in sr[1:]])
normed = files[0]
mixed = mix_ratio(normed, normed, 0)
mixed2 = mix_ratio(mixed, mixed, 0)
print(normed, mixed)
print(mixed2, mixed)
print(root_mean_square(normed))
print(root_mean_square(mixed))
print(root_mean_square(mixed2))
assert numpy.allclose(normed, mixed)
assert numpy.allclose(mixed2, mixed)
torchaudio.save(
str(ensure_existence(Path.cwd() / "exclude") / "mixed_same.wav"),
to_tensor(mixed),
int(sr[0]),
)
def multi_cat():
s = (2, 2)
a = (2, 2)
model = MultipleCategoricalMLP(input_shape=s, output_shape=a)
inp = to_tensor(numpy.random.rand(64, s[0]), device="cpu")
print(model.sample(model(inp, inp)))
def test_multi_dim_normal():
s = (10, 2, 3)
a = (2, 10)
model = PreConcatInputMLP(input_shape=s, output_shape=a)
inp = [to_tensor(range(s_), device="cpu") for s_ in s]
print(model.forward(*inp))
def test_normal():
s = (10, )
a = (10, )
model = PreConcatInputMLP(input_shape=s, output_shape=a)
inp = to_tensor(range(s[0]), device="cpu")
print(model.forward(inp))
def get_instanced(self, idx):
"""
Return a separate channel target for each instance in image
:param idx:
:type idx:
:return:
:rtype:"""
img = numpy.array(
Image.open(self._img_path / self.imgs[idx]).convert("RGB"))
mask = numpy.array(Image.open(self._ped_path / self.masks[idx]))
img = cv2_resize(img, self.image_size_T)
mask = cv2_resize(mask, self.image_size_T, InterpolationEnum.nearest)
obj_ids = numpy.unique(
mask) # instances are encoded as different colors
obj_ids = obj_ids[1:] # first id is the background, so remove it
# split the color-encoded mask into a set of binary masks
masks = mask == obj_ids[:, None, None]
zero_mask_clone = self.zero_mask.copy()
zero_mask_clone[:masks.shape[0]] = masks
return (
uint_hwc_to_chw_float_tensor(to_tensor(img, dtype=torch.uint8)),
torch.as_tensor(zero_mask_clone, dtype=torch.uint8),
)
def predictor_shape(self) -> Tuple[int, ...]:
"""
:return:
:rtype:
"""
return to_tensor(self.__getitem__(0)[0]).shape
def test_single_dim():
pos_size = (4,)
a_size = (1,)
model = MLP(input_shape=pos_size, output_shape=a_size)
pos_1 = to_tensor(numpy.random.rand(64, pos_size[0]), device="cpu")
print(model(pos_1))
def test_hidden_dim():
pos_size = (4,)
hidden_size = (2, 3)
a_size = (2,)
model = MLP(input_shape=pos_size, hidden_layers=hidden_size, output_shape=a_size)
pos_1 = to_tensor(numpy.random.rand(64, pos_size[0]), device="cpu")
print(model(pos_1))
def sample_from(self, *encoding) -> torch.Tensor:
sample = to_tensor(*encoding).to(device=next(self.parameters()).device)
assert sample.shape[-1] == self._latent_size, (
f"sample.shape[-1]:{sample.shape[-1]} !="
f" self._encoding_size:{self._latent_size}"
)
sample = self.decode(*sample).to("cpu")
return sample
def asdasidoj():
""" """
X = to_tensor([torch.diag(torch.arange(i, i + 2)) for i in range(200)])
x_train = TensorDataset(X[:100])
x_val = TensorDataset(X[100:])
for train, val in cross_validation_generator(x_train, x_val):
print(len(train), len(val))
print(train[0], val[0])
def generate_babble_noise(samples: Iterable[Iterable[Sequence]],
sampling_rate,
*,
export_path: Path = None) -> Iterable:
samples = numpy.array(min_length_truncate_batch(samples))
mixed = numpy.sum(samples / numpy.max(numpy.abs(samples)), 0)
if export_path:
torchaudio.save(str(export_path), to_tensor(mixed), sampling_rate)
return mixed
def get_instanced(self, idx):
"""
:param idx:
:type idx:
:return:
:rtype:
"""
img = to_tensor(Image.open(self._img_path / self.imgs[idx]).convert("RGB"))
mask = to_tensor(Image.open(self._ped_path / self.masks[idx]))
obj_ids = torch.unique(mask) # instances are encoded as different colors
obj_ids = obj_ids[1:] # first id is the background, so remove it
# split the color-encoded mask into a set of binary masks
masks = mask == obj_ids[:, None, None]
masks = torch.as_tensor(masks, dtype=torch.uint8)
return img, masks
def s():
numpy.random.seed(23)
size = (10, 3, 1)
a_size = (size[0] + 1, *size[1:])
signal = numpy.zeros(size)
non_terminal = numpy.ones(size)
value_estimate = numpy.random.random(a_size)
non_terminal[3, 0] = 0
non_terminal[8, 1] = 0
signal[-5:, :] = -1
signals = to_tensor(signal, device="cpu")
non_terminals = to_tensor(non_terminal, device="cpu")
value_estimates = to_tensor(value_estimate, device="cpu")
r, a = torch_compute_gae(signals, non_terminals, value_estimates)
print(r, a)
print(size, r.shape, a.shape)
def _sample_model(self, state: Any) -> numpy.ndarray:
"""
@param state:
@return:
"""
with torch.no_grad():
max_q_action = self.value_model(
to_tensor(state, device=self._device, dtype=self._state_type))
return max_q_action.max(-1)[-1].unsqueeze(-1).detach().to(
"cpu").numpy()
def stest_single_dim_cat():
pos_size = (4,)
a_size = (2,)
batch_size = 64
model = CategoricalActorCriticMLP(input_shape=pos_size, output_shape=a_size)
print(
torch.mean(
to_tensor(
[
model(
to_tensor(
numpy.random.rand(batch_size, pos_size[0]), device="cpu"
)
)[0].sample()
for _ in range(1000)
]
)
)
)
def distinct_real():
from draugr.visualisation import ltass_plot
from neodroidaudition.data.recognition.libri_speech import LibriSpeech
samples = 6
d_male = iter(
LibriSpeech(path=Path.home() / "Data" / "Audio" / "Speech" /
"LibriSpeech",
custom_subset=LibriSpeech.CustomSubsets.male))
d_female = iter(
LibriSpeech(path=Path.home() / "Data" / "Audio" / "Speech" /
"LibriSpeech",
custom_subset=LibriSpeech.CustomSubsets.female))
male_unique = {}
while len(male_unique) < samples // 2:
s = next(d_male)
speaker_id = s[-3]
if speaker_id not in male_unique:
male_unique[speaker_id] = s
female_unique = {}
while len(female_unique) < samples // 2:
s = next(d_female)
speaker_id = s[-3]
if speaker_id not in female_unique:
female_unique[speaker_id] = s
unique = (*male_unique.values(), *female_unique.values())
files, sr = zip(*[(v[0].numpy(), v[1])
for _, v in zip(range(samples), unique)])
assert all([sr[0] == s for s in sr[1:]])
sr = sr[0]
noise_welch = generate_speech_shaped_noise(
files,
sr,
long_term_avg=True,
export_path=Path('exclude') / 'ssn_welch.wav')[0]
noise_fft = generate_speech_shaped_noise(files,
sr,
long_term_avg=False,
export_path=Path('exclude') /
'ssn_fft.wav')[0]
files = numpy.concatenate(files, -1)[0]
torchaudio.save(str(Path('exclude') / 'ssn_signal.wav'),
to_tensor(files), sr)
ltass_plot(files, sr, label='signal')
ltass_plot(noise_welch, sr, label='noise_welch')
ltass_plot(noise_fft, sr, label='noise_fft')
pyplot.legend()
pyplot.show()
def generate_noise(
length: int,
*,
seed: int = None,
noise_type: GaussianNoiseTypeEnum = GaussianNoiseTypeEnum.white,
export_path: Path = None,
sampling_rate: int = 16000) -> numpy.ndarray:
normalised = noise_type(length, seed)
if export_path:
torchaudio.save(str(export_path), to_tensor(normalised), sampling_rate)
return normalised
def get_binary(self, idx):
"""
:param idx:
:type idx:
:return:
:rtype:
"""
img = numpy.array(Image.open(self._img_path / self.imgs[idx]).convert("RGB"))
mask = numpy.array(Image.open(self._ped_path / self.masks[idx]))
mask[mask != 0] = 1.0
img = cv2_resize(img, self.image_size_T)
mask = cv2_resize(mask, self.image_size_T)
return (
uint_hwc_to_chw_float_tensor(to_tensor(img, dtype=torch.uint8)),
to_tensor(mask).unsqueeze(0),
)
def _sample(self, state: Sequence) -> Any:
"""
@param state:
@param deterministic:
@return:
"""
with torch.no_grad():
action_out = self._actor(to_tensor(state,
device=self._device)).detach()
deterministic = False
if not deterministic:
# Add action space noise for exploration, alternative is parameter space noise
noise = self._random_process.sample(action_out.shape)
action_out += to_tensor(noise * self._noise_factor,
device=self.device)
return action_out
def stest_many_versus_many2(model: Module,
data_dir: Path,
img_size: Tuple[int, int],
threshold=0.5):
"""
:param model:
:type model:
:param data_dir:
:type data_dir:
:param img_size:
:type img_size:
:param threshold:
:type threshold:
"""
dataiter = iter(
DataLoader(
PairDataset(
data_dir,
transform=transforms.Compose([
transforms.Grayscale(),
transforms.Resize(img_size),
transforms.ToTensor(),
]),
),
num_workers=4,
batch_size=1,
shuffle=True,
))
for i in range(10):
x0, x1, is_diff = next(dataiter)
distance = (model(
to_tensor(x0, device=global_torch_device()),
to_tensor(x1, device=global_torch_device()),
).cpu().item())
boxed_text_overlay_plot(
torchvision.utils.make_grid(torch.cat((x0, x1), 0)),
f"Truth: {'Different' if is_diff.cpu().item() else 'Alike'},"
f" Dissimilarity: {distance:.2f},"
f" Verdict: {'Different' if distance > threshold else 'Alike'}",
)