Dependancies and numpy versions

multimodal/boosting/combo.py

@@ -193,7 +193,7 @@ class MuComboClassifier(BaseEnsemble, ClassifierMixin, UBoosting):
         # n_yi = np.unique(y, return_inverse=True)
         cost = np.ones((n_views, n_samples, n_classes))
         score_function = np.zeros((n_views, n_samples, n_classes))
-        n_yi_s = np.zeros(n_classes, dtype=np.int)
+        n_yi_s = np.zeros(n_classes, dtype=int)
         for indice_class in range(n_classes):
             # n_yi number of examples of the class y_i
             n_yi = np.where(y==indice_class)[0].shape[0]
@@ -224,14 +224,14 @@ class MuComboClassifier(BaseEnsemble, ClassifierMixin, UBoosting):
 
     def _indicatrice(self, predicted_classes, y_i):
         n_samples = y_i.shape[0]
-        indicate_ones = np.zeros((self.n_views_, n_samples, self.n_classes_), dtype=np.int)
-        indicatrice_one_yi = np.zeros((self.n_views_, n_samples, self.n_classes_), dtype=np.int)
+        indicate_ones = np.zeros((self.n_views_, n_samples, self.n_classes_), dtype=int)
+        indicatrice_one_yi = np.zeros((self.n_views_, n_samples, self.n_classes_), dtype=int)
         indicate_ones[np.arange(self.n_views_)[:, np.newaxis],
                     np.arange(n_samples)[np.newaxis, :],
                     predicted_classes[np.arange(self.n_views_), :]] = 1
         indicate_ones[:, np.arange(n_samples), y_i] = 0
         indicatrice_one_yi[:, np.arange(n_samples), y_i] = 1
-        delta = np.ones((self.n_views_, n_samples, self.n_classes_), dtype=np.int)
+        delta = np.ones((self.n_views_, n_samples, self.n_classes_), dtype=int)
         delta[:, np.arange(n_samples), y_i] = -1
         return indicate_ones, indicatrice_one_yi, delta
 
@@ -451,12 +451,12 @@ class MuComboClassifier(BaseEnsemble, ClassifierMixin, UBoosting):
             # there is only one single class in the data).
             self.estimators_ = []
             self.estimator_weights_alpha_ = np.array([], dtype=np.float64)
-            self.estimator_weights_beta_ = np.zeros((self.n_iterations_, n_views), dtype=np.float)
+            self.estimator_weights_beta_ = np.zeros((self.n_iterations_, n_views), dtype=float)
             self.estimator_errors_ = np.array([], dtype=np.float64)
             return
         self.estimators_ = []
         self.estimator_weights_alpha_ = np.zeros((self.n_iterations_, n_views), dtype=np.float64)
-        self.estimator_weights_beta_ = np.zeros((self.n_iterations_, n_views, self.n_classes_), dtype=np.float)
+        self.estimator_weights_beta_ = np.zeros((self.n_iterations_, n_views, self.n_classes_), dtype=float)
         self.estimator_errors_ = np.zeros((n_views, self.n_iterations_), dtype=np.float64)
 
         random_state = check_random_state(self.random_state)

multimodal/datasets/data_sample.py

@@ -83,6 +83,7 @@ import numpy as np
 import numpy.ma as ma
 import scipy.sparse as sp
 
+
 class MultiModalData(metaclass=ABCMeta):
 
     @staticmethod
@@ -99,7 +100,7 @@ class MultiModalData(metaclass=ABCMeta):
             n_views = views_ind.shape[0]-1
         else:
             if views_ind.ndim == 1:
-                if not views_ind.dtype == np.object:
+                if not views_ind.dtype == object:
                     raise ValueError("The format of views_ind is not "
                                      + "supported.")
                 for ind, val in enumerate(views_ind):
@@ -143,7 +144,7 @@ class MultiModalData(metaclass=ABCMeta):
             n_views = views_ind.shape[0]-1
         else:
             if views_ind.ndim == 1:
-                if not views_ind.dtype == np.object:
+                if not views_ind.dtype == object:
                     raise ValueError("The format of views_ind is not "
                                      + "supported.")
                 for ind, val in enumerate(views_ind):
@@ -428,7 +429,7 @@ class MultiModalArray(np.ndarray, MultiModalData):
                 hasattr(new_data, "shape") and len(new_data.shape) > 0:
                 obj = np.asarray(new_data.data).view(cls)
         else:
-            obj = np.recarray.__new__(cls, shape=(0, 0), dtype=np.float)
+            obj = np.recarray.__new__(cls, shape=(0, 0), dtype=float)
         obj.view_mode_ = view_mode
         obj.views_ind = views_ind
         obj.shapes_int = shapes_int
@@ -439,7 +440,7 @@ class MultiModalArray(np.ndarray, MultiModalData):
     def _for_data(cls, data):
         n_views = data.shape[0]
         index = 0
-        views_ind = np.empty(n_views + 1, dtype=np.int)
+        views_ind = np.empty(n_views + 1, dtype=int)
         views_ind[0] = 0
         shapes_int = []
         new_data = np.ndarray([])

multimodal/tests/test_combo.py

@@ -268,7 +268,7 @@ class TestMuComboClassifier(unittest.TestCase):
                                          cost_Tminus1_vue, A, b, G, h, l))
             self.assertEqual(solver.shape, (9,1))
             s_r = np.sum(solver.reshape(3,3), axis=1)
-            np.testing.assert_almost_equal(s_r, np.ones(3, dtype=np.float), 9)
+            np.testing.assert_almost_equal(s_r, np.ones(3, dtype=float), 9)
 
     def test_solver_compute_betas(self):
         clf = MuComboClassifier()
@@ -289,13 +289,13 @@ class TestMuComboClassifier(unittest.TestCase):
           [ 5.45938775e+01,  4.03397223e+02, -4.57991101e+02],
           [ 1.48401545e+02, -1.48426438e+02,  2.48935342e-02],
           [ 1.09663316e+03,  2.71828184e+00, -1.09935144e+03]]])
-        score_function_Tminus1 =10 *np.ones((3,4,3), dtype =np.float)
+        score_function_Tminus1 =10 *np.ones((3,4,3), dtype =float)
         alphas = np.array([0.5, 1., 2.])
         predicted_classes = np.array([[0, 0, 1, 1], [0, 1, 0, 2], [2, 2, 0, 0]])
         y = np.array([0, 1, 2, 0])
         betas = clf._compute_betas(alphas, y, score_function_Tminus1, predicted_classes)
         self.assertEqual(betas.shape, (3,3))
-        np.testing.assert_almost_equal(np.sum(betas, axis =1), np.ones(3, dtype=np.float), 9)
+        np.testing.assert_almost_equal(np.sum(betas, axis =1), np.ones(3, dtype=float), 9)
         self.assertTrue(np.all(betas <= 1) )
         self.assertTrue(np.all(betas >= 0) )
 
@@ -336,7 +336,7 @@ class TestMuComboClassifier(unittest.TestCase):
                  [[-2, 1, 0.5], [1, 1, -1], [1, -2, 0.5], [1, 1, -1]],
                  [[-2, 1, 0.5], [1, 1, -1], [1, -2, 0.5], [1, 1, -1]]],
                 dtype=np.float64)
-        score_function_Tminus1 =10 *np.ones((3,4,3), dtype=np.float)
+        score_function_Tminus1 =10 *np.ones((3,4,3), dtype=float)
         clf = MuComboClassifier()
         clf.n_views_ = 3
         clf.n_classes_ = 3

multimodal/tests/test_mumbo.py

@@ -74,7 +74,7 @@ class TestMumboClassifier(unittest.TestCase):
         X[X < .8] = 0
         X_csr = csr_matrix(X)
         clf = MumboClassifier()
-        y = (4 * rng.rand(40)).astype(np.int)
+        y = (4 * rng.rand(40)).astype(int)
         clf.fit(X_csr, y)
 
     def test_init_var(self):
@@ -450,15 +450,15 @@ class TestMumboClassifier(unittest.TestCase):
         clf = MumboClassifier()
         self.assertRaises(ValueError, clf.fit, X, y, views_ind)
 
-        views_ind = np.array([[-1], [1, 2]])
+        views_ind = np.array([np.array([-1]), np.array([1, 2])])
         clf = MumboClassifier()
         self.assertRaises(ValueError, clf.fit, X, y, views_ind)
 
-        views_ind = np.array([[3], [1, 2]])
+        views_ind = np.array([np.array([3]), np.array([1, 2])])
         clf = MumboClassifier()
         self.assertRaises(ValueError, clf.fit, X, y, views_ind)
 
-        views_ind = np.array([[0.5], [1, 2]])
+        views_ind = np.array([np.array([0.5]), np.array([1, 2])])
         clf = MumboClassifier()
         self.assertRaises(ValueError, clf.fit, X, y, views_ind)
 
@@ -520,7 +520,7 @@ class TestMumboClassifier(unittest.TestCase):
 
         X = np.array([[0., 0.5, 0.7], [1., 1.5, 1.7], [2., 2.5, 2.7]])
         y = np.array([1, 1, 1])
-        views_ind = np.array([[0, 2], [1]])
+        views_ind = np.array([np.array([0, 2]), np.array([1])])
         clf = MumboClassifier()
         clf.fit(X, y, views_ind)
         np.testing.assert_equal(clf.predict(X), y)
@@ -573,7 +573,7 @@ class TestMumboClassifier(unittest.TestCase):
                            np.array([0, 1]))
         self.assertEqual(clf.decision_function(X).shape, y.shape)
 
-        views_ind = np.array([[2, 0], [1]])
+        views_ind = np.array([np.array([2, 0]), np.array([1])])
         clf = MumboClassifier()
         clf.fit(X, y, views_ind)
         np.testing.assert_equal(clf.predict(X), y)
@@ -598,7 +598,7 @@ class TestMumboClassifier(unittest.TestCase):
         np.testing.assert_equal(clf.predict(data), np.array([0, 1]))
         self.assertEqual(clf.decision_function(X).shape, y.shape)
 
-        views_ind = np.array([[2, 0], [1], [3, 4]])
+        views_ind = np.array([np.array([2, 0]), np.array([1]), np.array([3, 4])])
         clf = MumboClassifier()
         clf.fit(X, y, views_ind)
         np.testing.assert_equal(clf.predict(X), y)
@@ -626,7 +626,7 @@ class TestMumboClassifier(unittest.TestCase):
         np.testing.assert_equal(clf.predict(data), np.array([0, 1, 2]))
         self.assertEqual(clf.decision_function(X).shape, (X.shape[0], 3))
 
-        views_ind = np.array([[1, 0], [2], [3, 4]])
+        views_ind = np.array([np.array([1, 0]), np.array([2]), np.array([3, 4])])
         clf = MumboClassifier()
         clf.fit(X, y, views_ind)
         np.testing.assert_equal(clf.predict(X), y)

multimodal/tests/test_mvml.py

@@ -270,7 +270,7 @@ class MVMLTest(unittest.TestCase):
 
     def test_classifier(self):
         pass
-        # return check_estimator(MVML)
+        # return check_estimator(MVML())
 
     def test_check_kernel(self):
         clf = MVML()

setup.py

@@ -176,7 +176,7 @@ def setup_package():
     keywords = ('machine learning, supervised learning, classification, '
                 'ensemble methods, boosting, kernel')
     packages = find_packages(exclude=['*.tests'])
-    install_requires = ['scikit-learn==0.24.2', 'numpy', 'scipy', 'cvxopt' ]
+    install_requires = ['scikit-learn>=0.24.2', 'numpy', 'scipy', 'cvxopt' ]
     python_requires = '>=3.6'
     extras_require = {
         'dev': ['pytest', 'pytest-cov'],