Bug#959137: lasagne: (autopkgtest) needs update for new version of numpy: 'numpy.float64' object cannot be interpreted as an integer
Stephen Sinclair
radarsat1 at gmail.com
Thu Apr 30 15:25:14 BST 2020
The package has been updated in salsa and is awaiting sponsorship.
regards,
Steve
On Wed, Apr 29, 2020 at 9:48 PM Paul Gevers <elbrus at debian.org> wrote:
>
> Source: lasagne
> Version: 0.1+git20181019.a61b76f-2
> Severity: serious
> X-Debbugs-CC: debian-ci at lists.debian.org, numpy at packages.debian.org
> Tags: sid bullseye
> User: debian-ci at 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
>
More information about the debian-science-maintainers
mailing list