Skip to content

schedule

LinearSchedule

Bases: Schedule

Linear scheduler, adds roughly n * percent new observations at each step.

Source code in gallifrey/schedule.py 
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
83
84
85
86
87
88
89
90
91
92
93
class LinearSchedule(Schedule):
    """
    Linear scheduler, adds roughly
    `n * percent` new observations at each step.

    """

    @staticmethod
    def generate(
        num_datapoints: int,
        num_steps: int,
        start: int = 1,
    ) -> tuple[int, ...]:
        """
        Generate a linear annealing schedule.

        Parameters
        ----------
        num_datapoints : int
            The total number of datapoints.
        num_steps : int
            The number of steps in the schedule.
        start : int, optional
            The starting point of the schedule,
            by default 1 (one observation).

        Returns
        -------
        tuple[int, ...]
            A tuple of integers representing the cumulative number of
            observations at each step of the schedule. Length of the
            tuple is `num_steps`.

        """
        # if only one step, run total number of datapoints
        if num_steps == 1:
            start = num_datapoints

        return tuple(
            jnp.round(
                jnp.linspace(
                    start=start,
                    stop=num_datapoints,
                    num=num_steps,
                    endpoint=True,
                    dtype=float,
                ),
            )
            .astype(int)
            .tolist()
        )

generate(num_datapoints, num_steps, start=1) staticmethod

Generate a linear annealing schedule.

Parameters:

Name Type Description Default
num_datapoints int

The total number of datapoints.

 required
num_steps int

The number of steps in the schedule.

 required
start int

The starting point of the schedule, by default 1 (one observation).

 1

Returns:

Type Description
tuple[int, ...]

A tuple of integers representing the cumulative number of observations at each step of the schedule. Length of the tuple is num_steps.
Source code in gallifrey/schedule.py 
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
83
84
85
86
87
88
89
90
91
92
93
@staticmethod
def generate(
    num_datapoints: int,
    num_steps: int,
    start: int = 1,
) -> tuple[int, ...]:
    """
    Generate a linear annealing schedule.

    Parameters
    ----------
    num_datapoints : int
        The total number of datapoints.
    num_steps : int
        The number of steps in the schedule.
    start : int, optional
        The starting point of the schedule,
        by default 1 (one observation).

    Returns
    -------
    tuple[int, ...]
        A tuple of integers representing the cumulative number of
        observations at each step of the schedule. Length of the
        tuple is `num_steps`.

    """
    # if only one step, run total number of datapoints
    if num_steps == 1:
        start = num_datapoints

    return tuple(
        jnp.round(
            jnp.linspace(
                start=start,
                stop=num_datapoints,
                num=num_steps,
                endpoint=True,
                dtype=float,
            ),
        )
        .astype(int)
        .tolist()
    )

LogSchedule

Bases: Schedule

A logarithmic scheduler, adds observations in a logarithmic fashion.

Source code in gallifrey/schedule.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
class LogSchedule(Schedule):
    """
    A logarithmic scheduler, adds observations in a logarithmic fashion.

    """

    @staticmethod
    def generate(
        num_datapoints: int,
        num_steps: int,
        start: int = 1,
    ) -> tuple[int, ...]:
        """
        Generate a logarithmic annealing schedule.

        Parameters
        ----------
        num_datapoints : int
            The total number of datapoints.
        num_steps : int
            The number of steps in the schedule.
        start : int, optional
            The starting point of the schedule,
            by default 1 (one observation).

        Returns
        -------
        tuple[int, ...]
            A tuple of integers representing the cumulative number of
            observations at each step of the schedule. Length of the
            tuple is `num_steps`.
        """
        # if only one step, run total number of datapoints
        if num_steps == 1:
            start = num_datapoints

        return tuple(
            jnp.round(
                jnp.geomspace(
                    start=start,
                    stop=num_datapoints,
                    num=num_steps,
                    endpoint=True,
                )
            )
            .astype(int)
            .tolist()
        )

generate(num_datapoints, num_steps, start=1) staticmethod

Generate a logarithmic annealing schedule.

Parameters:

Name Type Description Default
num_datapoints int

The total number of datapoints.

 required
num_steps int

The number of steps in the schedule.

 required
start int

The starting point of the schedule, by default 1 (one observation).

 1

Returns:

Type Description
tuple[int, ...]

A tuple of integers representing the cumulative number of observations at each step of the schedule. Length of the tuple is num_steps.
Source code in gallifrey/schedule.py 
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
@staticmethod
def generate(
    num_datapoints: int,
    num_steps: int,
    start: int = 1,
) -> tuple[int, ...]:
    """
    Generate a logarithmic annealing schedule.

    Parameters
    ----------
    num_datapoints : int
        The total number of datapoints.
    num_steps : int
        The number of steps in the schedule.
    start : int, optional
        The starting point of the schedule,
        by default 1 (one observation).

    Returns
    -------
    tuple[int, ...]
        A tuple of integers representing the cumulative number of
        observations at each step of the schedule. Length of the
        tuple is `num_steps`.
    """
    # if only one step, run total number of datapoints
    if num_steps == 1:
        start = num_datapoints

    return tuple(
        jnp.round(
            jnp.geomspace(
                start=start,
                stop=num_datapoints,
                num=num_steps,
                endpoint=True,
            )
        )
        .astype(int)
        .tolist()
    )

Schedule

Bases: ABC

Abstract base class for SMC data annealing schedules.

Source code in gallifrey/schedule.py 
 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
class Schedule(ABC):
    """
    Abstract base class for SMC data annealing schedules.

    """

    @staticmethod
    @abstractmethod
    def generate(
        num_datapoints: int,
        num_steps: int,
        start: int = 1,
    ) -> tuple[int, ...]:
        """
        Generate an annealing schedule.

        Parameters
        ----------
        num_datapoints : int
            The total number of datapoints.
        num_steps : int
            The number of steps in the schedule.
        start : int, optional
            The starting point of the schedule,
            by default 1 (one observation).

        Returns
        -------
        tuple[int, ...]
            A tuple of integers representing the cumulative number of
            observations at each step of the schedule. Length of the
            tuple is `num_steps`.

        """
        pass

generate(num_datapoints, num_steps, start=1) abstractmethod staticmethod

Generate an annealing schedule.

Parameters:

Name Type Description Default
num_datapoints int

The total number of datapoints.

 required
num_steps int

The number of steps in the schedule.

 required
start int

The starting point of the schedule, by default 1 (one observation).

 1

Returns:

Type Description
tuple[int, ...]

A tuple of integers representing the cumulative number of observations at each step of the schedule. Length of the tuple is num_steps.
Source code in gallifrey/schedule.py 
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
@staticmethod
@abstractmethod
def generate(
    num_datapoints: int,
    num_steps: int,
    start: int = 1,
) -> tuple[int, ...]:
    """
    Generate an annealing schedule.

    Parameters
    ----------
    num_datapoints : int
        The total number of datapoints.
    num_steps : int
        The number of steps in the schedule.
    start : int, optional
        The starting point of the schedule,
        by default 1 (one observation).

    Returns
    -------
    tuple[int, ...]
        A tuple of integers representing the cumulative number of
        observations at each step of the schedule. Length of the
        tuple is `num_steps`.

    """
    pass