The package has been updated in salsa and is awaiting sponsorship. regards, Steve
On Wed, Apr 29, 2020 at 9:48 PM Paul Gevers <elb...@debian.org> wrote: > > Source: lasagne > Version: 0.1+git20181019.a61b76f-2 > Severity: serious > X-Debbugs-CC: debian...@lists.debian.org, nu...@packages.debian.org > Tags: sid bullseye > User: debian...@lists.debian.org > Usertags: needs-update > Control: affects -1 src:numpy > > Dear maintainer(s), > > With a recent upload of numpy the autopkgtest of lasagne fails in > testing when that autopkgtest is run with the binary packages of numpy > from unstable. It passes when run with only packages from testing. In > tabular form: > > pass fail > numpy from testing 1:1.18.3-1 > lasagne from testing 0.1+git20181019.a61b76f-2 > all others from testing from testing > > I copied some of the output at the bottom of this report. > > Currently this regression is blocking the migration of numpy to testing > [1]. Of course, numpy shouldn't just break your autopkgtest (or even > worse, your package), but it seems to me that the change in numpy was > intended and your package needs to update to the new situation. > > If this is a real problem in your package (and not only in your > autopkgtest), the right binary package(s) from numpy should really add a > versioned Breaks on the unfixed version of (one of your) package(s). > Note: the Breaks is nice even if the issue is only in the autopkgtest as > it helps the migration software to figure out the right versions to > combine in the tests. > > More information about this bug and the reason for filing it can be found on > https://wiki.debian.org/ContinuousIntegration/RegressionEmailInformation > > Paul > > [1] https://qa.debian.org/excuses.php?package=numpy > > https://ci.debian.net/data/autopkgtest/testing/amd64/l/lasagne/5197094/log.gz > > =================================== FAILURES > =================================== > ____ > TestTPSTransformLayer.test_transform_thin_plate_spline_variable_input _____ > > start = -1, stop = 1, num = 4.0, endpoint = True, retstep = False, dtype > = None > axis = 0 > > @array_function_dispatch(_linspace_dispatcher) > def linspace(start, stop, num=50, endpoint=True, retstep=False, > dtype=None, > axis=0): > """ > Return evenly spaced numbers over a specified interval. > > Returns `num` evenly spaced samples, calculated over the > interval [`start`, `stop`]. > > The endpoint of the interval can optionally be excluded. > > .. versionchanged:: 1.16.0 > Non-scalar `start` and `stop` are now supported. > > Parameters > ---------- > start : array_like > The starting value of the sequence. > stop : array_like > The end value of the sequence, unless `endpoint` is set to > False. > In that case, the sequence consists of all but the last of > ``num + 1`` > evenly spaced samples, so that `stop` is excluded. Note > that the step > size changes when `endpoint` is False. > num : int, optional > Number of samples to generate. Default is 50. Must be > non-negative. > endpoint : bool, optional > If True, `stop` is the last sample. Otherwise, it is not > included. > Default is True. > retstep : bool, optional > If True, return (`samples`, `step`), where `step` is the spacing > between samples. > dtype : dtype, optional > The type of the output array. If `dtype` is not given, > infer the data > type from the other input arguments. > > .. versionadded:: 1.9.0 > > axis : int, optional > The axis in the result to store the samples. Relevant only > if start > or stop are array-like. By default (0), the samples will be > along a > new axis inserted at the beginning. Use -1 to get an axis at > the end. > > .. versionadded:: 1.16.0 > > Returns > ------- > samples : ndarray > There are `num` equally spaced samples in the closed interval > ``[start, stop]`` or the half-open interval ``[start, stop)`` > (depending on whether `endpoint` is True or False). > step : float, optional > Only returned if `retstep` is True > > Size of spacing between samples. > > > See Also > -------- > arange : Similar to `linspace`, but uses a step size (instead of the > number of samples). > geomspace : Similar to `linspace`, but with numbers spaced > evenly on a log > scale (a geometric progression). > logspace : Similar to `geomspace`, but with the end points > specified as > logarithms. > > Examples > -------- > >>> np.linspace(2.0, 3.0, num=5) > array([2. , 2.25, 2.5 , 2.75, 3. ]) > >>> np.linspace(2.0, 3.0, num=5, endpoint=False) > array([2. , 2.2, 2.4, 2.6, 2.8]) > >>> np.linspace(2.0, 3.0, num=5, retstep=True) > (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) > > Graphical illustration: > > >>> import matplotlib.pyplot as plt > >>> N = 8 > >>> y = np.zeros(N) > >>> x1 = np.linspace(0, 10, N, endpoint=True) > >>> x2 = np.linspace(0, 10, N, endpoint=False) > >>> plt.plot(x1, y, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.plot(x2, y + 0.5, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.ylim([-0.5, 1]) > (-0.5, 1) > >>> plt.show() > > """ > try: > > num = operator.index(num) > E TypeError: 'numpy.float64' object cannot be interpreted as > an integer > > /usr/lib/python3/dist-packages/numpy/core/function_base.py:117: TypeError > > During handling of the above exception, another exception occurred: > > self = <test_special.TestTPSTransformLayer object at 0x7f878739e850> > > def test_transform_thin_plate_spline_variable_input(self): > import lasagne > from lasagne.utils import floatX > from theano.tensor import constant > > x = np.random.random((10, 3, 28, 28)).astype('float32') > x_sym = theano.tensor.tensor4() > > l_in = lasagne.layers.InputLayer((None, 3, None, 28)) > l_loc = lasagne.layers.DenseLayer( > lasagne.layers.ReshapeLayer(l_in, ([0], 3*28*28)), > num_units=32) > > l_trans = lasagne.layers.TPSTransformerLayer( > l_in, l_loc, precompute_grid='auto') > > layers/test_special.py:522: > _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ > _ _ _ _ > ../layers/special.py:702: in __init__ > self.out_width = _initialize_tps( > ../layers/special.py:865: in _initialize_tps > np.linspace(-1, 1, grid_size), > <__array_function__ internals>:5: in linspace > ??? > _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ > _ _ _ _ > > start = -1, stop = 1, num = 4.0, endpoint = True, retstep = False, dtype > = None > axis = 0 > > @array_function_dispatch(_linspace_dispatcher) > def linspace(start, stop, num=50, endpoint=True, retstep=False, > dtype=None, > axis=0): > """ > Return evenly spaced numbers over a specified interval. > > Returns `num` evenly spaced samples, calculated over the > interval [`start`, `stop`]. > > The endpoint of the interval can optionally be excluded. > > .. versionchanged:: 1.16.0 > Non-scalar `start` and `stop` are now supported. > > Parameters > ---------- > start : array_like > The starting value of the sequence. > stop : array_like > The end value of the sequence, unless `endpoint` is set to > False. > In that case, the sequence consists of all but the last of > ``num + 1`` > evenly spaced samples, so that `stop` is excluded. Note > that the step > size changes when `endpoint` is False. > num : int, optional > Number of samples to generate. Default is 50. Must be > non-negative. > endpoint : bool, optional > If True, `stop` is the last sample. Otherwise, it is not > included. > Default is True. > retstep : bool, optional > If True, return (`samples`, `step`), where `step` is the spacing > between samples. > dtype : dtype, optional > The type of the output array. If `dtype` is not given, > infer the data > type from the other input arguments. > > .. versionadded:: 1.9.0 > > axis : int, optional > The axis in the result to store the samples. Relevant only > if start > or stop are array-like. By default (0), the samples will be > along a > new axis inserted at the beginning. Use -1 to get an axis at > the end. > > .. versionadded:: 1.16.0 > > Returns > ------- > samples : ndarray > There are `num` equally spaced samples in the closed interval > ``[start, stop]`` or the half-open interval ``[start, stop)`` > (depending on whether `endpoint` is True or False). > step : float, optional > Only returned if `retstep` is True > > Size of spacing between samples. > > > See Also > -------- > arange : Similar to `linspace`, but uses a step size (instead of the > number of samples). > geomspace : Similar to `linspace`, but with numbers spaced > evenly on a log > scale (a geometric progression). > logspace : Similar to `geomspace`, but with the end points > specified as > logarithms. > > Examples > -------- > >>> np.linspace(2.0, 3.0, num=5) > array([2. , 2.25, 2.5 , 2.75, 3. ]) > >>> np.linspace(2.0, 3.0, num=5, endpoint=False) > array([2. , 2.2, 2.4, 2.6, 2.8]) > >>> np.linspace(2.0, 3.0, num=5, retstep=True) > (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) > > Graphical illustration: > > >>> import matplotlib.pyplot as plt > >>> N = 8 > >>> y = np.zeros(N) > >>> x1 = np.linspace(0, 10, N, endpoint=True) > >>> x2 = np.linspace(0, 10, N, endpoint=False) > >>> plt.plot(x1, y, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.plot(x2, y + 0.5, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.ylim([-0.5, 1]) > (-0.5, 1) > >>> plt.show() > > """ > try: > num = operator.index(num) > except TypeError: > > raise TypeError( > "object of type {} cannot be safely interpreted as an > integer." > .format(type(num))) > E TypeError: object of type <class 'numpy.float64'> cannot be > safely interpreted as an integer. > > /usr/lib/python3/dist-packages/numpy/core/function_base.py:119: TypeError > ______ TestTPSTransformLayer.test_transform_thin_plate_spline_downsample > _______ > > start = -1, stop = 1, num = 4.0, endpoint = True, retstep = False, dtype > = None > axis = 0 > > @array_function_dispatch(_linspace_dispatcher) > def linspace(start, stop, num=50, endpoint=True, retstep=False, > dtype=None, > axis=0): > """ > Return evenly spaced numbers over a specified interval. > > Returns `num` evenly spaced samples, calculated over the > interval [`start`, `stop`]. > > The endpoint of the interval can optionally be excluded. > > .. versionchanged:: 1.16.0 > Non-scalar `start` and `stop` are now supported. > > Parameters > ---------- > start : array_like > The starting value of the sequence. > stop : array_like > The end value of the sequence, unless `endpoint` is set to > False. > In that case, the sequence consists of all but the last of > ``num + 1`` > evenly spaced samples, so that `stop` is excluded. Note > that the step > size changes when `endpoint` is False. > num : int, optional > Number of samples to generate. Default is 50. Must be > non-negative. > endpoint : bool, optional > If True, `stop` is the last sample. Otherwise, it is not > included. > Default is True. > retstep : bool, optional > If True, return (`samples`, `step`), where `step` is the spacing > between samples. > dtype : dtype, optional > The type of the output array. If `dtype` is not given, > infer the data > type from the other input arguments. > > .. versionadded:: 1.9.0 > > axis : int, optional > The axis in the result to store the samples. Relevant only > if start > or stop are array-like. By default (0), the samples will be > along a > new axis inserted at the beginning. Use -1 to get an axis at > the end. > > .. versionadded:: 1.16.0 > > Returns > ------- > samples : ndarray > There are `num` equally spaced samples in the closed interval > ``[start, stop]`` or the half-open interval ``[start, stop)`` > (depending on whether `endpoint` is True or False). > step : float, optional > Only returned if `retstep` is True > > Size of spacing between samples. > > > See Also > -------- > arange : Similar to `linspace`, but uses a step size (instead of the > number of samples). > geomspace : Similar to `linspace`, but with numbers spaced > evenly on a log > scale (a geometric progression). > logspace : Similar to `geomspace`, but with the end points > specified as > logarithms. > > Examples > -------- > >>> np.linspace(2.0, 3.0, num=5) > array([2. , 2.25, 2.5 , 2.75, 3. ]) > >>> np.linspace(2.0, 3.0, num=5, endpoint=False) > array([2. , 2.2, 2.4, 2.6, 2.8]) > >>> np.linspace(2.0, 3.0, num=5, retstep=True) > (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) > > Graphical illustration: > > >>> import matplotlib.pyplot as plt > >>> N = 8 > >>> y = np.zeros(N) > >>> x1 = np.linspace(0, 10, N, endpoint=True) > >>> x2 = np.linspace(0, 10, N, endpoint=False) > >>> plt.plot(x1, y, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.plot(x2, y + 0.5, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.ylim([-0.5, 1]) > (-0.5, 1) > >>> plt.show() > > """ > try: > > num = operator.index(num) > E TypeError: 'numpy.float64' object cannot be interpreted as > an integer > > /usr/lib/python3/dist-packages/numpy/core/function_base.py:117: TypeError > > During handling of the above exception, another exception occurred: > > self = <test_special.TestTPSTransformLayer object at 0x7f8786b1b940> > > def test_transform_thin_plate_spline_downsample(self): > import lasagne > downsample = (0.7, 2.3) > x = np.random.random((10, 3, 28, 28)).astype('float32') > x_sym = theano.tensor.tensor4() > > # create transformer with fixed input size > l_in = lasagne.layers.InputLayer((None, 3, 28, 28)) > l_loc = lasagne.layers.DenseLayer(l_in, num_units=32) > > l_trans = lasagne.layers.TPSTransformerLayer( > l_in, l_loc, downsample_factor=downsample, > precompute_grid=False > ) > > layers/test_special.py:547: > _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ > _ _ _ _ > ../layers/special.py:702: in __init__ > self.out_width = _initialize_tps( > ../layers/special.py:865: in _initialize_tps > np.linspace(-1, 1, grid_size), > <__array_function__ internals>:5: in linspace > ??? > _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ > _ _ _ _ > > start = -1, stop = 1, num = 4.0, endpoint = True, retstep = False, dtype > = None > axis = 0 > > @array_function_dispatch(_linspace_dispatcher) > def linspace(start, stop, num=50, endpoint=True, retstep=False, > dtype=None, > axis=0): > """ > Return evenly spaced numbers over a specified interval. > > Returns `num` evenly spaced samples, calculated over the > interval [`start`, `stop`]. > > The endpoint of the interval can optionally be excluded. > > .. versionchanged:: 1.16.0 > Non-scalar `start` and `stop` are now supported. > > Parameters > ---------- > start : array_like > The starting value of the sequence. > stop : array_like > The end value of the sequence, unless `endpoint` is set to > False. > In that case, the sequence consists of all but the last of > ``num + 1`` > evenly spaced samples, so that `stop` is excluded. Note > that the step > size changes when `endpoint` is False. > num : int, optional > Number of samples to generate. Default is 50. Must be > non-negative. > endpoint : bool, optional > If True, `stop` is the last sample. Otherwise, it is not > included. > Default is True. > retstep : bool, optional > If True, return (`samples`, `step`), where `step` is the spacing > between samples. > dtype : dtype, optional > The type of the output array. If `dtype` is not given, > infer the data > type from the other input arguments. > > .. versionadded:: 1.9.0 > > axis : int, optional > The axis in the result to store the samples. Relevant only > if start > or stop are array-like. By default (0), the samples will be > along a > new axis inserted at the beginning. Use -1 to get an axis at > the end. > > .. versionadded:: 1.16.0 > > Returns > ------- > samples : ndarray > There are `num` equally spaced samples in the closed interval > ``[start, stop]`` or the half-open interval ``[start, stop)`` > (depending on whether `endpoint` is True or False). > step : float, optional > Only returned if `retstep` is True > > Size of spacing between samples. > > > See Also > -------- > arange : Similar to `linspace`, but uses a step size (instead of the > number of samples). > geomspace : Similar to `linspace`, but with numbers spaced > evenly on a log > scale (a geometric progression). > logspace : Similar to `geomspace`, but with the end points > specified as > logarithms. > > Examples > -------- > >>> np.linspace(2.0, 3.0, num=5) > array([2. , 2.25, 2.5 , 2.75, 3. ]) > >>> np.linspace(2.0, 3.0, num=5, endpoint=False) > array([2. , 2.2, 2.4, 2.6, 2.8]) > >>> np.linspace(2.0, 3.0, num=5, retstep=True) > (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) > > Graphical illustration: > > >>> import matplotlib.pyplot as plt > >>> N = 8 > >>> y = np.zeros(N) > >>> x1 = np.linspace(0, 10, N, endpoint=True) > >>> x2 = np.linspace(0, 10, N, endpoint=False) > >>> plt.plot(x1, y, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.plot(x2, y + 0.5, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.ylim([-0.5, 1]) > (-0.5, 1) > >>> plt.show() > > """ > try: > num = operator.index(num) > except TypeError: > > raise TypeError( > "object of type {} cannot be safely interpreted as an > integer." > .format(type(num))) > E TypeError: object of type <class 'numpy.float64'> cannot be > safely interpreted as an integer. > > /usr/lib/python3/dist-packages/numpy/core/function_base.py:119: TypeError > _______ TestTPSTransformLayer.test_transform_thin_plate_spline_identity > ________ > > start = -1, stop = 1, num = 4.0, endpoint = True, retstep = False, dtype > = None > axis = 0 > > @array_function_dispatch(_linspace_dispatcher) > def linspace(start, stop, num=50, endpoint=True, retstep=False, > dtype=None, > axis=0): > """ > Return evenly spaced numbers over a specified interval. > > Returns `num` evenly spaced samples, calculated over the > interval [`start`, `stop`]. > > The endpoint of the interval can optionally be excluded. > > .. versionchanged:: 1.16.0 > Non-scalar `start` and `stop` are now supported. > > Parameters > ---------- > start : array_like > The starting value of the sequence. > stop : array_like > The end value of the sequence, unless `endpoint` is set to > False. > In that case, the sequence consists of all but the last of > ``num + 1`` > evenly spaced samples, so that `stop` is excluded. Note > that the step > size changes when `endpoint` is False. > num : int, optional > Number of samples to generate. Default is 50. Must be > non-negative. > endpoint : bool, optional > If True, `stop` is the last sample. Otherwise, it is not > included. > Default is True. > retstep : bool, optional > If True, return (`samples`, `step`), where `step` is the spacing > between samples. > dtype : dtype, optional > The type of the output array. If `dtype` is not given, > infer the data > type from the other input arguments. > > .. versionadded:: 1.9.0 > > axis : int, optional > The axis in the result to store the samples. Relevant only > if start > or stop are array-like. By default (0), the samples will be > along a > new axis inserted at the beginning. Use -1 to get an axis at > the end. > > .. versionadded:: 1.16.0 > > Returns > ------- > samples : ndarray > There are `num` equally spaced samples in the closed interval > ``[start, stop]`` or the half-open interval ``[start, stop)`` > (depending on whether `endpoint` is True or False). > step : float, optional > Only returned if `retstep` is True > > Size of spacing between samples. > > > See Also > -------- > arange : Similar to `linspace`, but uses a step size (instead of the > number of samples). > geomspace : Similar to `linspace`, but with numbers spaced > evenly on a log > scale (a geometric progression). > logspace : Similar to `geomspace`, but with the end points > specified as > logarithms. > > Examples > -------- > >>> np.linspace(2.0, 3.0, num=5) > array([2. , 2.25, 2.5 , 2.75, 3. ]) > >>> np.linspace(2.0, 3.0, num=5, endpoint=False) > array([2. , 2.2, 2.4, 2.6, 2.8]) > >>> np.linspace(2.0, 3.0, num=5, retstep=True) > (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) > > Graphical illustration: > > >>> import matplotlib.pyplot as plt > >>> N = 8 > >>> y = np.zeros(N) > >>> x1 = np.linspace(0, 10, N, endpoint=True) > >>> x2 = np.linspace(0, 10, N, endpoint=False) > >>> plt.plot(x1, y, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.plot(x2, y + 0.5, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.ylim([-0.5, 1]) > (-0.5, 1) > >>> plt.show() > > """ > try: > > num = operator.index(num) > E TypeError: 'numpy.float64' object cannot be interpreted as > an integer > > /usr/lib/python3/dist-packages/numpy/core/function_base.py:117: TypeError > > During handling of the above exception, another exception occurred: > > self = <test_special.TestTPSTransformLayer object at 0x7f87875bc070> > > def test_transform_thin_plate_spline_identity(self): > from lasagne.layers import InputLayer, TPSTransformerLayer > from lasagne.utils import floatX > from theano.tensor import constant > batchsize = 5 > num_control_points = 16 > dest_offset = np.zeros(shape=(batchsize, 2*num_control_points)) > l_in = InputLayer((batchsize, 3, 28, 28)) > l_loc = InputLayer((batchsize, 2*num_control_points)) > > layer = TPSTransformerLayer( > l_in, l_loc, control_points=num_control_points > ) > > layers/test_special.py:593: > _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ > _ _ _ _ > ../layers/special.py:702: in __init__ > self.out_width = _initialize_tps( > ../layers/special.py:865: in _initialize_tps > np.linspace(-1, 1, grid_size), > <__array_function__ internals>:5: in linspace > ??? > _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ > _ _ _ _ > > start = -1, stop = 1, num = 4.0, endpoint = True, retstep = False, dtype > = None > axis = 0 > > @array_function_dispatch(_linspace_dispatcher) > def linspace(start, stop, num=50, endpoint=True, retstep=False, > dtype=None, > axis=0): > """ > Return evenly spaced numbers over a specified interval. > > Returns `num` evenly spaced samples, calculated over the > interval [`start`, `stop`]. > > The endpoint of the interval can optionally be excluded. > > .. versionchanged:: 1.16.0 > Non-scalar `start` and `stop` are now supported. > > Parameters > ---------- > start : array_like > The starting value of the sequence. > stop : array_like > The end value of the sequence, unless `endpoint` is set to > False. > In that case, the sequence consists of all but the last of > ``num + 1`` > evenly spaced samples, so that `stop` is excluded. Note > that the step > size changes when `endpoint` is False. > num : int, optional > Number of samples to generate. Default is 50. Must be > non-negative. > endpoint : bool, optional > If True, `stop` is the last sample. Otherwise, it is not > included. > Default is True. > retstep : bool, optional > If True, return (`samples`, `step`), where `step` is the spacing > between samples. > dtype : dtype, optional > The type of the output array. If `dtype` is not given, > infer the data > type from the other input arguments. > > .. versionadded:: 1.9.0 > > axis : int, optional > The axis in the result to store the samples. Relevant only > if start > or stop are array-like. By default (0), the samples will be > along a > new axis inserted at the beginning. Use -1 to get an axis at > the end. > > .. versionadded:: 1.16.0 > > Returns > ------- > samples : ndarray > There are `num` equally spaced samples in the closed interval > ``[start, stop]`` or the half-open interval ``[start, stop)`` > (depending on whether `endpoint` is True or False). > step : float, optional > Only returned if `retstep` is True > > Size of spacing between samples. > > > See Also > -------- > arange : Similar to `linspace`, but uses a step size (instead of the > number of samples). > geomspace : Similar to `linspace`, but with numbers spaced > evenly on a log > scale (a geometric progression). > logspace : Similar to `geomspace`, but with the end points > specified as > logarithms. > > Examples > -------- > >>> np.linspace(2.0, 3.0, num=5) > array([2. , 2.25, 2.5 , 2.75, 3. ]) > >>> np.linspace(2.0, 3.0, num=5, endpoint=False) > array([2. , 2.2, 2.4, 2.6, 2.8]) > >>> np.linspace(2.0, 3.0, num=5, retstep=True) > (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) > > Graphical illustration: > > >>> import matplotlib.pyplot as plt > >>> N = 8 > >>> y = np.zeros(N) > >>> x1 = np.linspace(0, 10, N, endpoint=True) > >>> x2 = np.linspace(0, 10, N, endpoint=False) > >>> plt.plot(x1, y, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.plot(x2, y + 0.5, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.ylim([-0.5, 1]) > (-0.5, 1) > >>> plt.show() > > """ > try: > num = operator.index(num) > except TypeError: > > raise TypeError( > "object of type {} cannot be safely interpreted as an > integer." > .format(type(num))) > E TypeError: object of type <class 'numpy.float64'> cannot be > safely interpreted as an integer. > > /usr/lib/python3/dist-packages/numpy/core/function_base.py:119: TypeError > _________ TestTPSTransformLayer.test_transform_thin_plate_spline_shift > _________ > > start = -1, stop = 1, num = 4.0, endpoint = True, retstep = False, dtype > = None > axis = 0 > > @array_function_dispatch(_linspace_dispatcher) > def linspace(start, stop, num=50, endpoint=True, retstep=False, > dtype=None, > axis=0): > """ > Return evenly spaced numbers over a specified interval. > > Returns `num` evenly spaced samples, calculated over the > interval [`start`, `stop`]. > > The endpoint of the interval can optionally be excluded. > > .. versionchanged:: 1.16.0 > Non-scalar `start` and `stop` are now supported. > > Parameters > ---------- > start : array_like > The starting value of the sequence. > stop : array_like > The end value of the sequence, unless `endpoint` is set to > False. > In that case, the sequence consists of all but the last of > ``num + 1`` > evenly spaced samples, so that `stop` is excluded. Note > that the step > size changes when `endpoint` is False. > num : int, optional > Number of samples to generate. Default is 50. Must be > non-negative. > endpoint : bool, optional > If True, `stop` is the last sample. Otherwise, it is not > included. > Default is True. > retstep : bool, optional > If True, return (`samples`, `step`), where `step` is the spacing > between samples. > dtype : dtype, optional > The type of the output array. If `dtype` is not given, > infer the data > type from the other input arguments. > > .. versionadded:: 1.9.0 > > axis : int, optional > The axis in the result to store the samples. Relevant only > if start > or stop are array-like. By default (0), the samples will be > along a > new axis inserted at the beginning. Use -1 to get an axis at > the end. > > .. versionadded:: 1.16.0 > > Returns > ------- > samples : ndarray > There are `num` equally spaced samples in the closed interval > ``[start, stop]`` or the half-open interval ``[start, stop)`` > (depending on whether `endpoint` is True or False). > step : float, optional > Only returned if `retstep` is True > > Size of spacing between samples. > > > See Also > -------- > arange : Similar to `linspace`, but uses a step size (instead of the > number of samples). > geomspace : Similar to `linspace`, but with numbers spaced > evenly on a log > scale (a geometric progression). > logspace : Similar to `geomspace`, but with the end points > specified as > logarithms. > > Examples > -------- > >>> np.linspace(2.0, 3.0, num=5) > array([2. , 2.25, 2.5 , 2.75, 3. ]) > >>> np.linspace(2.0, 3.0, num=5, endpoint=False) > array([2. , 2.2, 2.4, 2.6, 2.8]) > >>> np.linspace(2.0, 3.0, num=5, retstep=True) > (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) > > Graphical illustration: > > >>> import matplotlib.pyplot as plt > >>> N = 8 > >>> y = np.zeros(N) > >>> x1 = np.linspace(0, 10, N, endpoint=True) > >>> x2 = np.linspace(0, 10, N, endpoint=False) > >>> plt.plot(x1, y, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.plot(x2, y + 0.5, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.ylim([-0.5, 1]) > (-0.5, 1) > >>> plt.show() > > """ > try: > > num = operator.index(num) > E TypeError: 'numpy.float64' object cannot be interpreted as > an integer > > /usr/lib/python3/dist-packages/numpy/core/function_base.py:117: TypeError > > During handling of the above exception, another exception occurred: > > self = <test_special.TestTPSTransformLayer object at 0x7f878754d2e0> > > def test_transform_thin_plate_spline_shift(self): > from lasagne.layers import InputLayer, TPSTransformerLayer > from theano.tensor import constant > batchsize = 5 > num_control_points = 16 > dest_offset = np.ones(shape=(batchsize, 2*num_control_points)) > l_in = InputLayer((batchsize, 3, 28, 28)) > l_loc = InputLayer((batchsize, 2*num_control_points)) > > layer = TPSTransformerLayer( > l_in, l_loc, control_points=num_control_points > ) > > layers/test_special.py:609: > _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ > _ _ _ _ > ../layers/special.py:702: in __init__ > self.out_width = _initialize_tps( > ../layers/special.py:865: in _initialize_tps > np.linspace(-1, 1, grid_size), > <__array_function__ internals>:5: in linspace > ??? > _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ > _ _ _ _ > > start = -1, stop = 1, num = 4.0, endpoint = True, retstep = False, dtype > = None > axis = 0 > > @array_function_dispatch(_linspace_dispatcher) > def linspace(start, stop, num=50, endpoint=True, retstep=False, > dtype=None, > axis=0): > """ > Return evenly spaced numbers over a specified interval. > > Returns `num` evenly spaced samples, calculated over the > interval [`start`, `stop`]. > > The endpoint of the interval can optionally be excluded. > > .. versionchanged:: 1.16.0 > Non-scalar `start` and `stop` are now supported. > > Parameters > ---------- > start : array_like > The starting value of the sequence. > stop : array_like > The end value of the sequence, unless `endpoint` is set to > False. > In that case, the sequence consists of all but the last of > ``num + 1`` > evenly spaced samples, so that `stop` is excluded. Note > that the step > size changes when `endpoint` is False. > num : int, optional > Number of samples to generate. Default is 50. Must be > non-negative. > endpoint : bool, optional > If True, `stop` is the last sample. Otherwise, it is not > included. > Default is True. > retstep : bool, optional > If True, return (`samples`, `step`), where `step` is the spacing > between samples. > dtype : dtype, optional > The type of the output array. If `dtype` is not given, > infer the data > type from the other input arguments. > > .. versionadded:: 1.9.0 > > axis : int, optional > The axis in the result to store the samples. Relevant only > if start > or stop are array-like. By default (0), the samples will be > along a > new axis inserted at the beginning. Use -1 to get an axis at > the end. > > .. versionadded:: 1.16.0 > > Returns > ------- > samples : ndarray > There are `num` equally spaced samples in the closed interval > ``[start, stop]`` or the half-open interval ``[start, stop)`` > (depending on whether `endpoint` is True or False). > step : float, optional > Only returned if `retstep` is True > > Size of spacing between samples. > > > See Also > -------- > arange : Similar to `linspace`, but uses a step size (instead of the > number of samples). > geomspace : Similar to `linspace`, but with numbers spaced > evenly on a log > scale (a geometric progression). > logspace : Similar to `geomspace`, but with the end points > specified as > logarithms. > > Examples > -------- > >>> np.linspace(2.0, 3.0, num=5) > array([2. , 2.25, 2.5 , 2.75, 3. ]) > >>> np.linspace(2.0, 3.0, num=5, endpoint=False) > array([2. , 2.2, 2.4, 2.6, 2.8]) > >>> np.linspace(2.0, 3.0, num=5, retstep=True) > (array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25) > > Graphical illustration: > > >>> import matplotlib.pyplot as plt > >>> N = 8 > >>> y = np.zeros(N) > >>> x1 = np.linspace(0, 10, N, endpoint=True) > >>> x2 = np.linspace(0, 10, N, endpoint=False) > >>> plt.plot(x1, y, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.plot(x2, y + 0.5, 'o') > [<matplotlib.lines.Line2D object at 0x...>] > >>> plt.ylim([-0.5, 1]) > (-0.5, 1) > >>> plt.show() > > """ > try: > num = operator.index(num) > except TypeError: > > raise TypeError( > "object of type {} cannot be safely interpreted as an > integer." > .format(type(num))) > E TypeError: object of type <class 'numpy.float64'> cannot be > safely interpreted as an integer. > > /usr/lib/python3/dist-packages/numpy/core/function_base.py:119: TypeError >
