def T(self, T):
if not isinstance(T, (float, int)):
raise e.TypeError('`T` should be a float or integer')
if T < 0 or T > 1:
raise e.ValueError('`T` should be between 0 and 1')
self._T = T
def p(self, p):
if not isinstance(p, (float, int)):
raise e.TypeError('`p` should be a float or integer')
if p < 0 or p > 1:
raise e.ValueError('`p` should be between 0 and 1')
self._p = p
def n_hidden(self, n_hidden):
if not isinstance(n_hidden, int):
raise e.TypeError('`n_hidden` should be an integer')
if n_hidden <= 0:
raise e.ValueError('`n_hidden` should be > 0')
self._n_hidden = n_hidden
def alpha(self, alpha):
if not isinstance(alpha, (float, int)):
raise e.TypeError('`alpha` should be a float or integer')
if alpha < 0:
raise e.ValueError('`alpha` should be >= 0')
self._alpha = alpha
def n_classes(self, n_classes):
if not isinstance(n_classes, int):
raise e.TypeError('`n_classes` should be an integer')
if n_classes <= 0:
raise e.ValueError('`n_classes` should be > 0')
self._n_classes = n_classes
def n_layers(self, n_layers):
if not isinstance(n_layers, int):
raise e.TypeError('`n_layers` should be an integer')
if n_layers <= 0:
raise e.ValueError('`n_layers` should be > 0')
self._n_layers = n_layers
def n_channels(self, n_channels):
if not isinstance(n_channels, int):
raise e.TypeError('`n_channels` should be an integer')
if n_channels <= 0:
raise e.ValueError('`n_channels` should be > 0')
self._n_channels = n_channels
def decay(self, decay):
if not isinstance(decay, (float, int)):
raise e.TypeError('`decay` should be a float or integer')
if decay < 0:
raise e.ValueError('`decay` should be >= 0')
self._decay = decay
def n_visible(self, n_visible):
if not isinstance(n_visible, int):
raise e.TypeError('`n_visible` should be an integer')
if n_visible <= 0:
raise e.ValueError('`n_visible` should be > 0')
self._n_visible = n_visible
def momentum(self, momentum):
if not isinstance(momentum, (float, int)):
raise e.TypeError('`momentum` should be a float or integer')
if momentum < 0:
raise e.ValueError('`momentum` should be >= 0')
self._momentum = momentum
def lr(self, lr):
if not isinstance(lr, (float, int)):
raise e.TypeError('`lr` should be a float or integer')
if lr < 0:
raise e.ValueError('`lr` should be >= 0')
self._lr = lr
def steps(self, steps):
if not isinstance(steps, int):
raise e.TypeError('`steps` should be an integer')
if steps <= 0:
raise e.ValueError('`steps` should be > 0')
self._steps = steps
def zetta2(self, zetta2):
if not isinstance(zetta2, (float, int)):
raise e.TypeError('`zetta2` should be a float or integer')
if zetta2 < 0:
raise e.ValueError('`zetta2` should be >= 0')
self._zetta2 = zetta2
def test_value_error():
new_exception = exception.ValueError("error")
try:
raise new_exception
except exception.ValueError:
pass
def filter_shape(self, filter_shape):
if not isinstance(filter_shape, tuple):
raise e.TypeError('`filter_shape` should be a tuple')
if (filter_shape[0] >= self.visible_shape[0]) or (
filter_shape[1] >= self.visible_shape[1]):
raise e.ValueError(
'`filter_shape` should be smaller than `visible_shape`')
self._filter_shape = filter_shape
def steps(self, steps: int) -> None:
if steps <= 0:
raise e.ValueError("`steps` should be > 0")
self._steps = steps
def n_visible(self, n_visible: int) -> None:
if n_visible <= 0:
raise e.ValueError("`n_visible` should be > 0")
self._n_visible = n_visible
def n_hidden(self, n_hidden: int) -> None:
if n_hidden <= 0:
raise e.ValueError("`n_hidden` should be > 0")
self._n_hidden = n_hidden
def n_channels(self, n_channels: int) -> None:
if n_channels <= 0:
raise e.ValueError("`n_channels` should be > 0")
self._n_channels = n_channels
def n_layers(self, n_layers: int) -> None:
if n_layers <= 0:
raise e.ValueError("`n_layers` should be > 0")
self._n_layers = n_layers
def zetta2(self, zetta2: float) -> None:
if zetta2 < 0:
raise e.ValueError("`zetta2` should be >= 0")
self._zetta2 = zetta2
def zetta1(self, zetta1: float) -> None:
if zetta1 < 0:
raise e.ValueError("`zetta1` should be >= 0")
self._zetta1 = zetta1
def alpha(self, alpha: float) -> None:
if alpha < 0:
raise e.ValueError("`alpha` should be >= 0")
self._alpha = alpha
def decay(self, decay: float) -> None:
if decay < 0:
raise e.ValueError("`decay` should be >= 0")
self._decay = decay
def lr(self, lr: float) -> None:
if lr < 0:
raise e.ValueError("`lr` should be >= 0")
self._lr = lr
def momentum(self, momentum: float) -> None:
if momentum < 0:
raise e.ValueError("`momentum` should be >= 0")
self._momentum = momentum
def n_classes(self, n_classes: int) -> None:
if n_classes <= 0:
raise e.ValueError("`n_classes` should be > 0")
self._n_classes = n_classes
def T(self, T: float) -> None:
if T <= 0 or T > 1:
raise e.ValueError("`T` should be between 0 and 1")
self._T = T
def p(self, p: float) -> None:
if p < 0 or p > 1:
raise e.ValueError("`p` should be between 0 and 1")
self._p = p
