This is documentation for Orange 2.7. For the latest documentation, see Orange 3.

Utilities (utils)

Value transformers

Value transformers take care of simple transformations of values. Discretization, for instance, creates a transformer that converts continuous values into discrete, while continuizers do the opposite. Classification trees use transformers for binarization where values of discrete attributes are converted into binary.

These objects are most often constructed by other classes and only seldom manually. See information on Data discretization (discretization) and Continuization (continuization).

class TransformValue

The abstract root of the hierarchy of transformers, which provides the call operator and chaining of transformers.


The transformation that takes place prior to this. This way, transformations can be chained.

class Ordinal2Continuous

Converts ordinal values to continuous. For example, variable values values small, medium, large, extra large (if given in that order) would be, by default, converted to 0.0, 1.0, 2.0 and 3.0. It is possible to add a factor by which the values are multiplied. If the factor for the above case were 0.3333, the value would be converted to 0, 0.3333, 0.6666 and 0.9999.


The factor by which the values are multiplied.

import Orange.feature

lenses ="lenses")
age = lenses.domain["age"]

age_c = Orange.feature.Continuous("age_c")
age_c.getValueFrom = Orange.classification.ClassifierFromVar(whichVar = age)
age_c.getValueFrom.transformer =

age_cn = Orange.feature.Continuous("age_cn")
age_cn.getValueFrom = Orange.classification.ClassifierFromVar(whichVar = age)
age_cn.getValueFrom.transformer =
age_cn.getValueFrom.transformer.factor = 0.5

newDomain =[age, age_c, age_cn], lenses.domain.classVar)
newData =, lenses)

The values of attribute age (young, pre-presbyopic and presbyopic) are transformed to 0.0, 1.0 and 2.0 in age_c and to 0, 0.5 and 1 in age_cn.

class Discrete2Continuous

Converts a discrete value to a continuous so that some chosen value is converted to 1.0 and all others to 0.0 or -1.0, depending on the settings.


The value that is converted to 1.0; others are converted to 0.0 or -1.0, depending on zero_based. Value needs to be specified by an integer index.


Decides whether the other values will be transformed to 0.0 (True, default) or -1.0 (False). When False, undefined values are transformed to 0.0; otherwise, undefined values yield an error.


If True (default is False), the transformations are reversed - the selected value becomes 0.0 (or -1.0) and others 1.0.

The following script loads the Monks 1 data set and constructs a new attribute e1 that will indicate whether e is 1 or not.


monks ="monks-1")

e1 = Orange.feature.Continuous("e=1")
e1.getValueFrom = Orange.classification.ClassifierFromVar(whichVar=monks.domain["e"])
e1.getValueFrom.transformer =
class NormalizeContinuous

Normalizes continuous values by subtracting the average and dividing the difference by half of the span.


The value that is subtracted from the original.



The following script “normalizes” all attribute in the Iris dataset by subtracting the average value and dividing by the half of deviation.

for attr in iris.domain.features:
    attr_c = Orange.feature.Continuous( + "_n")
    attr_c.getValueFrom = Orange.classification.ClassifierFromVar(whichVar=attr)
    transformer =
    attr_c.getValueFrom.transformer = transformer
    transformer.average = domstat[attr].avg
    transformer.span = domstat[attr].dev

newDomain =, iris.domain.classVar)
newData =, iris)
for ex in newData[:5]:
    print ex
class MapIntValue

A discrete-to-discrete transformer that changes values according to the given mapping. MapIntValue is used for binarization in decision trees.


A mapping that determines the new value: v = mapping[v]. Undefined values remain undefined. Elements of the mapping are contains integer indices of values.

The following script transforms the value of age in dataset lenses from ‘young’ to ‘young’, and from ‘pre-presbyopic’ and ‘presbyopic’ to ‘old’.

import Orange

lenses ="lenses")
age = lenses.domain["age"]

age_b = Orange.feature.Discrete("age_c", values = ['young', 'old'])
age_b.getValueFrom = Orange.classification.ClassifierFromVar(whichVar = age)
age_b.getValueFrom.transformer =
age_b.getValueFrom.transformer.mapping = [0, 1, 1]

newDomain =[age_b, age], lenses.domain.classVar)
newData =, lenses)

The mapping tells that the 0th value of age maps to the 0th of age_b, and the 1st and 2nd value go to the 1st value of age_b.