Esempio n. 1
0
    def testIrisMomentum(self):
        random.seed(42)

        iris = datasets.load_iris()
        x_train, x_test, y_train, y_test = train_test_split(iris.data,
                                                            iris.target,
                                                            test_size=0.2,
                                                            random_state=42)

        def custom_optimizer():
            return momentum_lib.MomentumOptimizer(learning_rate=0.01,
                                                  momentum=0.9)

        classifier = learn.DNNClassifier(
            hidden_units=[10, 20, 10],
            feature_columns=learn.infer_real_valued_columns_from_input(
                x_train),
            n_classes=3,
            optimizer=custom_optimizer,
            config=learn.RunConfig(tf_random_seed=1))
        classifier.fit(x_train, y_train, steps=400)
        predictions = np.array(list(classifier.predict_classes(x_test)))
        score = accuracy_score(y_test, predictions)

        self.assertGreater(score, 0.65,
                           "Failed with score = {0}".format(score))
Esempio n. 2
0
 def test_pandas_series(self):
     if HAS_PANDAS:
         import pandas as pd  # pylint: disable=g-import-not-at-top
         random.seed(42)
         iris = datasets.load_iris()
         data = pd.DataFrame(iris.data)
         labels = pd.Series(iris.target)
         classifier = learn.LinearClassifier(
             feature_columns=learn.infer_real_valued_columns_from_input(
                 data),
             n_classes=3)
         classifier.fit(data, labels, steps=100)
         score = accuracy_score(labels,
                                list(classifier.predict_classes(data)))
         self.assertGreater(score, 0.5,
                            "Failed with score = {0}".format(score))
Esempio n. 3
0
 def test_dask_iris_classification(self):
     if HAS_DASK and HAS_PANDAS:
         import pandas as pd  # pylint: disable=g-import-not-at-top
         import dask.dataframe as dd  # pylint: disable=g-import-not-at-top
         random.seed(42)
         iris = datasets.load_iris()
         data = pd.DataFrame(iris.data)
         data = dd.from_pandas(data, npartitions=2)
         labels = pd.DataFrame(iris.target)
         labels = dd.from_pandas(labels, npartitions=2)
         classifier = learn.LinearClassifier(
             feature_columns=learn.infer_real_valued_columns_from_input(
                 data),
             n_classes=3)
         classifier.fit(data, labels, steps=100)
         predictions = data.map_partitions(classifier.predict).compute()
         score = accuracy_score(labels.compute(), predictions)
         self.assertGreater(score, 0.5,
                            "Failed with score = {0}".format(score))
 def testIris(self):
     iris = datasets.load_iris()
     self.assertTupleEqual(iris.data.shape, (150, 4))
     self.assertTupleEqual(iris.target.shape, (150, ))