Skip to content

Arithmetictransformer

This file is part of the TPOT library.

The current version of TPOT was developed at Cedars-Sinai by: - Pedro Henrique Ribeiro (https://github.com/perib, https://www.linkedin.com/in/pedro-ribeiro/) - Anil Saini (anil.saini@cshs.org) - Jose Hernandez (jgh9094@gmail.com) - Jay Moran (jay.moran@cshs.org) - Nicholas Matsumoto (nicholas.matsumoto@cshs.org) - Hyunjun Choi (hyunjun.choi@cshs.org) - Gabriel Ketron (gabriel.ketron@cshs.org) - Miguel E. Hernandez (miguel.e.hernandez@cshs.org) - Jason Moore (moorejh28@gmail.com)

The original version of TPOT was primarily developed at the University of Pennsylvania by: - Randal S. Olson (rso@randalolson.com) - Weixuan Fu (weixuanf@upenn.edu) - Daniel Angell (dpa34@drexel.edu) - Jason Moore (moorejh28@gmail.com) - and many more generous open-source contributors

TPOT is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

TPOT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with TPOT. If not, see http://www.gnu.org/licenses/.

AddTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
class AddTransformer(TransformerMixin, BaseEstimator):
    def __init__(self):
          """
          A transformer that adds all elements along axis 1.
          """
          pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.expand_dims(np.sum(X,1),1)

__init__()

A transformer that adds all elements along axis 1.

Source code in tpot/builtin_modules/arithmetictransformer.py 
144
145
146
147
148
def __init__(self):
      """
      A transformer that adds all elements along axis 1.
      """
      pass

ArithmeticTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
class ArithmeticTransformer(TransformerMixin, BaseEstimator):

    #functions = ["add", "mul_neg_1", "mul", "safe_reciprocal", "eq","ne","ge","gt","le","lt", "min","max","0","1"]
    def __init__(self, function,):
        """
        A transformer that applies a function to the input array along axis 1.
        Parameters
        ----------

        function : str
            The function to apply to the input array. The following functions are supported:
            - 'add' : Add all elements along axis 1
            - 'mul_neg_1' : Multiply all elements along axis 1 by -1
            - 'mul' : Multiply all elements along axis 1
            - 'safe_reciprocal' : Take the reciprocal of all elements along axis 1, with a safe division by zero
            - 'eq' : Check if all elements along axis 1 are equal
            - 'ne' : Check if all elements along axis 1 are not equal
            - 'ge' : Check if all elements along axis 1 are greater than or equal to 0
            - 'gt' : Check if all elements along axis 1 are greater than 0
            - 'le' : Check if all elements along axis 1 are less than or equal to 0
            - 'lt' : Check if all elements along axis 1 are less than 0
            - 'min' : Take the minimum of all elements along axis 1
            - 'max' : Take the maximum of all elements along axis 1
            - '0' : Return an array of zeros
            - '1' : Return an array of ones
        """
        self.function = function

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        if self.function == "add":
                return np.expand_dims(np.sum(X,1),1)
        elif self.function == "mul_neg_1":
                return X*-1
        elif self.function == "mul":
                return np.expand_dims(np.prod(X,1),1)

        elif self.function == "safe_reciprocal":
                results = np.divide(1.0, X.astype(float), out=np.zeros_like(X).astype(float), where=X!=0) #TODO remove astypefloat?
                return results

        elif self.function == "eq":
                return np.expand_dims(np.all(X == X[0,:], axis = 1),1).astype(float)

        elif self.function == "ne":
                return 1- np.expand_dims(np.all(X == X[0,:], axis = 1),1).astype(float)

        #TODO these could be "sorted order"
        elif self.function == "ge":
                result = X >= 0
                return  result.astype(float)

        elif self.function == "gt":
                result = X > 0
                return  result.astype(float)
        elif self.function ==  "le":
                result = X <= 0
                return  result.astype(float)
        elif self.function ==  "lt":
                result = X < 0
                return  result.astype(float)


        elif self.function ==   "min":
                return np.expand_dims(np.amin(X,1),1)
        elif self.function ==  "max":
                return np.expand_dims(np.amax(X,1),1)

        elif self.function ==  "0":
                return np.zeros((X.shape[0],1))
        elif self.function ==  "1":
                return np.ones((X.shape[0],1))

__init__(function)

A transformer that applies a function to the input array along axis 1.

Parameters:

Name Type Description Default
function str

The function to apply to the input array. The following functions are supported: - 'add' : Add all elements along axis 1 - 'mul_neg_1' : Multiply all elements along axis 1 by -1 - 'mul' : Multiply all elements along axis 1 - 'safe_reciprocal' : Take the reciprocal of all elements along axis 1, with a safe division by zero - 'eq' : Check if all elements along axis 1 are equal - 'ne' : Check if all elements along axis 1 are not equal - 'ge' : Check if all elements along axis 1 are greater than or equal to 0 - 'gt' : Check if all elements along axis 1 are greater than 0 - 'le' : Check if all elements along axis 1 are less than or equal to 0 - 'lt' : Check if all elements along axis 1 are less than 0 - 'min' : Take the minimum of all elements along axis 1 - 'max' : Take the maximum of all elements along axis 1 - '0' : Return an array of zeros - '1' : Return an array of ones

 required
Source code in tpot/builtin_modules/arithmetictransformer.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
def __init__(self, function,):
    """
    A transformer that applies a function to the input array along axis 1.
    Parameters
    ----------

    function : str
        The function to apply to the input array. The following functions are supported:
        - 'add' : Add all elements along axis 1
        - 'mul_neg_1' : Multiply all elements along axis 1 by -1
        - 'mul' : Multiply all elements along axis 1
        - 'safe_reciprocal' : Take the reciprocal of all elements along axis 1, with a safe division by zero
        - 'eq' : Check if all elements along axis 1 are equal
        - 'ne' : Check if all elements along axis 1 are not equal
        - 'ge' : Check if all elements along axis 1 are greater than or equal to 0
        - 'gt' : Check if all elements along axis 1 are greater than 0
        - 'le' : Check if all elements along axis 1 are less than or equal to 0
        - 'lt' : Check if all elements along axis 1 are less than 0
        - 'min' : Take the minimum of all elements along axis 1
        - 'max' : Take the maximum of all elements along axis 1
        - '0' : Return an array of zeros
        - '1' : Return an array of ones
    """
    self.function = function

EQTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
class EQTransformer(TransformerMixin, BaseEstimator):

    def __init__(self):
        """
        A transformer that takes checks if all elements in a row are equal.
        """
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.expand_dims(np.all(X == X[0,:], axis = 1),1).astype(float)

__init__()

A transformer that takes checks if all elements in a row are equal.

Source code in tpot/builtin_modules/arithmetictransformer.py 
239
240
241
242
243
def __init__(self):
    """
    A transformer that takes checks if all elements in a row are equal.
    """
    pass

GETransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
class GETransformer(TransformerMixin, BaseEstimator):

    def __init__(self):
        """
        A transformer that takes checks if all elements in a row are greater than or equal to 0.
        """
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        result = X >= 0
        return  result.astype(float)

__init__()

A transformer that takes checks if all elements in a row are greater than or equal to 0.

Source code in tpot/builtin_modules/arithmetictransformer.py 
289
290
291
292
293
def __init__(self):
    """
    A transformer that takes checks if all elements in a row are greater than or equal to 0.
    """
    pass

GTTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
class GTTransformer(TransformerMixin, BaseEstimator):
    def __init__(self):
          """
          A transformer that takes checks if all elements in a row are greater than 0.
          """
          pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        result = X > 0
        return  result.astype(float)

__init__()

A transformer that takes checks if all elements in a row are greater than 0.

Source code in tpot/builtin_modules/arithmetictransformer.py 
314
315
316
317
318
def __init__(self):
      """
      A transformer that takes checks if all elements in a row are greater than 0.
      """
      pass

LETransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
class LETransformer(TransformerMixin, BaseEstimator):
    def __init__(self):
        """
        A transformer that takes checks if all elements in a row are less than or equal to 0.
        """
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        result = X <= 0
        return  result.astype(float)

__init__()

A transformer that takes checks if all elements in a row are less than or equal to 0.

Source code in tpot/builtin_modules/arithmetictransformer.py 
339
340
341
342
343
def __init__(self):
    """
    A transformer that takes checks if all elements in a row are less than or equal to 0.
    """
    pass

LTTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
class LTTransformer(TransformerMixin, BaseEstimator):
    def __init__(self):
        """
        A transformer that takes checks if all elements in a row are less than 0.
        """
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        result = X < 0
        return  result.astype(float)

__init__()

A transformer that takes checks if all elements in a row are less than 0.

Source code in tpot/builtin_modules/arithmetictransformer.py 
364
365
366
367
368
def __init__(self):
    """
    A transformer that takes checks if all elements in a row are less than 0.
    """
    pass

MaxTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
class MaxTransformer(TransformerMixin, BaseEstimator):

    def __init__(self):
          """
          A transformer that takes the maximum of all elements in a row.
          """
          pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.expand_dims(np.amax(X,1),1)

__init__()

A transformer that takes the maximum of all elements in a row.

Source code in tpot/builtin_modules/arithmetictransformer.py 
415
416
417
418
419
def __init__(self):
      """
      A transformer that takes the maximum of all elements in a row.
      """
      pass

MinTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
class MinTransformer(TransformerMixin, BaseEstimator):
    def __init__(self):
        """
        A transformer that takes the minimum of all elements in a row.
        """
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.expand_dims(np.amin(X,1),1)

__init__()

A transformer that takes the minimum of all elements in a row.

Source code in tpot/builtin_modules/arithmetictransformer.py 
389
390
391
392
393
def __init__(self):
    """
    A transformer that takes the minimum of all elements in a row.
    """
    pass

MulTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
class MulTransformer(TransformerMixin, BaseEstimator):

    def __init__(self):
        """
        A transformer that multiplies all elements along axis 1.
        """
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.expand_dims(np.prod(X,1),1)

__init__()

A transformer that multiplies all elements along axis 1.

Source code in tpot/builtin_modules/arithmetictransformer.py 
191
192
193
194
195
def __init__(self):
    """
    A transformer that multiplies all elements along axis 1.
    """
    pass

NETransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
class NETransformer(TransformerMixin, BaseEstimator):

    def __init__(self):
        """
        A transformer that takes checks if all elements in a row are not equal.
        """  
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return 1- np.expand_dims(np.all(X == X[0,:], axis = 1),1).astype(float)

__init__()

A transformer that takes checks if all elements in a row are not equal.

Source code in tpot/builtin_modules/arithmetictransformer.py 
263
264
265
266
267
def __init__(self):
    """
    A transformer that takes checks if all elements in a row are not equal.
    """  
    pass

NTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
class NTransformer(TransformerMixin, BaseEstimator):

    def __init__(self, n):
        """
        A transformer that returns an array of n.
        """
        self.n = n

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.ones((X.shape[0],1))*self.n

__init__(n)

A transformer that returns an array of n.

Source code in tpot/builtin_modules/arithmetictransformer.py 
489
490
491
492
493
def __init__(self, n):
    """
    A transformer that returns an array of n.
    """
    self.n = n

OneTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
class OneTransformer(TransformerMixin, BaseEstimator):
    def __init__(self):
          """
          A transformer that returns an array of ones.
          """
          pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.ones((X.shape[0],1))

__init__()

A transformer that returns an array of ones.

Source code in tpot/builtin_modules/arithmetictransformer.py 
464
465
466
467
468
def __init__(self):
      """
      A transformer that returns an array of ones.
      """
      pass

SafeReciprocalTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
class SafeReciprocalTransformer(TransformerMixin, BaseEstimator):

    def __init__(self):
        """
        A transformer that takes the reciprocal of all elements, with a safe division by zero.
        """
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.divide(1.0, X.astype(float), out=np.zeros_like(X).astype(float), where=X!=0) #TODO remove astypefloat?

__init__()

A transformer that takes the reciprocal of all elements, with a safe division by zero.

Source code in tpot/builtin_modules/arithmetictransformer.py 
215
216
217
218
219
def __init__(self):
    """
    A transformer that takes the reciprocal of all elements, with a safe division by zero.
    """
    pass

ZeroTransformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
class ZeroTransformer(TransformerMixin, BaseEstimator):

    def __init__(self):
          """
        A transformer that returns an array of zeros.
          """
          pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return np.zeros((X.shape[0],1))

__init__()

A transformer that returns an array of zeros.

Source code in tpot/builtin_modules/arithmetictransformer.py 
440
441
442
443
444
def __init__(self):
      """
    A transformer that returns an array of zeros.
      """
      pass

mul_neg_1_Transformer

Bases: TransformerMixin, BaseEstimator

Source code in tpot/builtin_modules/arithmetictransformer.py 
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
class mul_neg_1_Transformer(TransformerMixin, BaseEstimator):
    def __init__(self):
        """
        A transformer that multiplies all elements by -1.
        """
        pass

    def fit(self, X, y=None):
        return self

    def transform(self, X):
        transformed_X = np.array(self.transform_helper(np.array(X)))
        if transformed_X.dtype != float:
            transformed_X = transformed_X.astype(float)

        return transformed_X

    def transform_helper(self, X):
        X = np.array(X)
        if len(X.shape) == 1:
            X = np.expand_dims(X,0)
        return X*-1

__init__()

A transformer that multiplies all elements by -1.

Source code in tpot/builtin_modules/arithmetictransformer.py 
167
168
169
170
171
def __init__(self):
    """
    A transformer that multiplies all elements by -1.
    """
    pass