Bug#959137: lasagne: (autopkgtest) needs update for new version of numpy: 'numpy.float64' object cannot be interpreted as an integer
Paul Gevers
elbrus at debian.org
Wed Apr 29 20:43:59 BST 2020
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
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 488 bytes
Desc: OpenPGP digital signature
URL: <http://alioth-lists.debian.net/pipermail/debian-science-maintainers/attachments/20200429/b9eb93a2/attachment-0001.sig>
More information about the debian-science-maintainers
mailing list