Пример #1
0
    def test_Pipegraph__example_1_no_connections(self):
        import numpy as np
        from sklearn.preprocessing import MinMaxScaler
        from sklearn.linear_model import LinearRegression
        from pipegraph import PipeGraph

        X = np.random.rand(100, 1)
        y = 4 * X + 0.5 * np.random.randn(100, 1)

        scaler = MinMaxScaler()
        linear_model = LinearRegression()
        steps = [('scaler', scaler), ('linear_model', linear_model)]

        pgraph = PipeGraph(steps=steps)
        self.assertTrue(pgraph.fit_connections is None)
        self.assertTrue(pgraph.predict_connections is None)
        pgraph.fit(X, y)
        y_pred = pgraph.predict(X)
        self.assertEqual(y_pred.shape[0], y.shape[0])
        self.assertEqual(
            pgraph.fit_connections,
            dict(scaler={'X': 'X'},
                 linear_model={
                     'X': ('scaler', 'predict'),
                     'y': 'y'
                 }))
        self.assertEqual(
            pgraph.predict_connections,
            dict(scaler={'X': 'X'},
                 linear_model={
                     'X': ('scaler', 'predict'),
                     'y': 'y'
                 }))
Пример #2
0
    def test_compositable__isinstance(self):
        X = self.X
        y = self.y
        new_graph = PipeGraph(steps=[('pgraph', self.pgraph)])
        self.assertEqual(new_graph.named_steps, {'pgraph': self.pgraph})

        new_graph.fit(X, y)
        result = new_graph.predict(X)['predict']
        expected = self.pgraph.predict(X)['predict']
        self.assertEqual(result.shape[0], expected.shape[0])
Пример #3
0
class TestPipeGraphCompositable(unittest.TestCase):
    def setUp(self):
        self.size = 100
        self.X = np.random.rand(self.size, 1)
        self.y = 2 * self.X
        lm = LinearRegression()
        steps = [('linear_model', lm)]
        self.lm = lm
        self.steps = steps
        self.pgraph = PipeGraph(steps=steps)

    def test_compositable__isinstance(self):
        X = self.X
        y = self.y
        new_graph = PipeGraph(steps=[('pgraph', self.pgraph)])
        self.assertEqual(new_graph.named_steps, {'pgraph': self.pgraph})

        new_graph.fit(X, y)
        result = new_graph.predict(X)['predict']
        expected = self.pgraph.predict(X)['predict']
        self.assertEqual(result.shape[0], expected.shape[0])
        'X': 'scaler',
        'y': 'y',
        'selection': 'classifier'
    },
    'lm_0': {
        'X': ('demux', 'X_0'),
        'y': ('demux', 'y_0')
    },
    'lm_1': {
        'X': ('demux', 'X_1'),
        'y': ('demux', 'y_1')
    },
    'lm_2': {
        'X': ('demux', 'X_2'),
        'y': ('demux', 'y_2')
    },
    'mux': {
        '0': 'lm_0',
        '1': 'lm_1',
        '2': 'lm_2',
        'selection': 'classifier'
    }
}

pgraph = PipeGraph(steps=steps, fit_connections=connections)
pgraph.fit(X, y)
#%%
y_pred = pgraph.predict(X)
plt.scatter(X, y)
plt.scatter(X, y_pred)