-
Notifications
You must be signed in to change notification settings - Fork 29
/
RegressionDataset.py
82 lines (63 loc) · 2.68 KB
/
RegressionDataset.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
import torch
import typing
class SineDataset(torch.utils.data.Dataset):
"""generate data of a random sinusoidal task
y = A sin(x + phi) + epsilon,
where: epsilon is sampled from N(0, s^2)
"""
def __init__(
self,
amplitude_range: typing.Tuple[float],
phase_range: typing.Tuple[float],
noise_std: float,
x_range: typing.Tuple[float],
num_samples: int
) -> None:
"""
Args:
amplitudes: a tuple consisting the range of A
phase: a tuple consisting the range of phase
noise_variance: the variance of the noise
"""
super().__init__()
self.amplitude_range = [a for a in amplitude_range]
self.phase_range = [phi for phi in phase_range]
self.noise_std = noise_std
self.x = torch.linspace(start=x_range[0], end=x_range[1], steps=num_samples)
def __len__(self) -> int:
return 100000
def __getitem__(self, index) -> typing.List[torch.Tensor]:
"""generate data of a task
"""
y = self.generate_label()
y = y + torch.randn_like(input=y) * self.noise_std
return [self.x, y]
def generate_label(self) -> torch.Tensor:
"""
"""
# sample parameters randomly
amplitude = torch.rand(size=(1,)) * (self.amplitude_range[1] - self.amplitude_range[0]) + self.amplitude_range[0]
phase = torch.rand(size=(1,)) * (self.phase_range[1] - self.phase_range[0]) + self.phase_range[0]
y = amplitude * torch.sin(input=self.x + phase)
return y
class LineDataset(torch.utils.data.Dataset):
"""generate a data for a task following the formula:
y = ax + b
"""
def __init__(self, slope_range: typing.Tuple[float], intercept_range: typing.Tuple[float], x_range: typing.Tuple[float], num_samples: int, noise_std: float) -> None:
super().__init__()
self.slope_range = [a for a in slope_range]
self.intercept_range = [b for b in intercept_range]
self.noise_std = noise_std
self.x = torch.linspace(start=x_range[0], end=x_range[1], steps=num_samples)
def __getitem__(self, index) -> typing.List[torch.Tensor]:
y = self.generate_label()
y = y + torch.randn_like(input=y) * self.noise_std
return [self.x, y]
def __len__(self) -> int:
return 100000
def generate_label(self) -> torch.Tensor:
slope = torch.rand(size=(1,)) * (self.slope_range[1] - self.slope_range[0]) + self.slope_range[0]
intercept = torch.rand(size=(1,)) * (self.intercept_range[1] - self.intercept_range[0]) + self.intercept_range[0]
y = slope * self.x + intercept
return y