Copy sparse attribute when creating new variables

Author: nikicc

Orange/preprocess/continuize.py

@@ -25,14 +25,19 @@ def transform_discrete(var):
                 return []
             if treat == Continuize.AsOrdinal:
                 new_var = ContinuousVariable(var.name,
-                                             compute_value=Identity(var))
+                                             compute_value=Identity(var),
+                                             sparse=var.sparse)
                 return [new_var]
             if treat == Continuize.AsNormalizedOrdinal:
                 n_values = max(1, len(var.values))
                 if self.zero_based:
-                    return [ContinuousVariable(var.name, compute_value=Normalizer(var, 0, 1 / (n_values - 1)))]
+                    return [ContinuousVariable(var.name,
+                                               compute_value=Normalizer(var, 0, 1 / (n_values - 1)),
+                                               sparse=var.sparse)]
                 else:
-                    return [ContinuousVariable(var.name, compute_value=Normalizer(var, (n_values - 1) / 2, 2 / (n_values - 1)))]
+                    return [ContinuousVariable(var.name,
+                                               compute_value=Normalizer(var, (n_values - 1) / 2, 2 / (n_values - 1)),
+                                               sparse=var.sparse)]
 
             new_vars = []
             if treat == Continuize.Indicators:
@@ -48,7 +53,8 @@ def transform_discrete(var):
                     continue
                 new_var = ContinuousVariable(
                     "{}={}".format(var.name, val),
-                    compute_value=ind_class(var, i))
+                    compute_value=ind_class(var, i),
+                    sparse=var.sparse)
                 new_vars.append(new_var)
             return new_vars
 

Orange/preprocess/discretize.py

@@ -73,7 +73,8 @@ def create_discretized_var(cls, var, points):
             to_sql = SingleValueSql(values[0])
 
         dvar = DiscreteVariable(name=var.name, values=values,
-                                compute_value=cls(var, points))
+                                compute_value=cls(var, points),
+                                sparse=var.sparse)
         dvar.source_variable = var
         dvar.to_sql = to_sql
         return dvar

Orange/preprocess/impute.py

@@ -246,7 +246,8 @@ def __call__(self, data, variable):
                 compute_value=Lookup(
                     variable,
                     np.arange(len(variable.values), dtype=int),
-                    unknown=len(variable.values))
+                    unknown=len(variable.values)),
+                sparse=variable.sparse,
                 )
             return var
 
@@ -255,7 +256,9 @@ def __call__(self, data, variable):
             indicator_var = Orange.data.DiscreteVariable(
                 fmt.format(var=variable),
                 values=("undef", "def"),
-                compute_value=IsDefined(variable))
+                compute_value=IsDefined(variable),
+                sparse=variable.sparse,
+            )
             stats = basic_stats.BasicStats(data, variable)
             return (variable.copy(compute_value=ReplaceUnknowns(variable,
                                                                 stats.mean)),

Orange/preprocess/normalize.py

@@ -41,14 +41,14 @@ def normalize_by_sd(self, dist, var):
         avg, sd = (dist.mean(), dist.standard_deviation()) if dist.size else (0, 1)
         if sd == 0:
             sd = 1
-        return ContinuousVariable(var.name, compute_value=Norm(var, avg, 1 / sd))
+        return ContinuousVariable(var.name, compute_value=Norm(var, avg, 1 / sd), sparse=var.sparse)
 
     def normalize_by_span(self, dist, var):
         dma, dmi = dist.max(), dist.min()
         diff = dma - dmi
         if diff < 1e-15:
             diff = 1
         if self.zero_based:
-            return ContinuousVariable(var.name, compute_value=Norm(var, dmi, 1 / diff))
+            return ContinuousVariable(var.name, compute_value=Norm(var, dmi, 1 / diff), sparse=var.sparse)
         else:
-            return ContinuousVariable(var.name, compute_value=Norm(var, (dma + dmi) / 2, 2 / diff))
+            return ContinuousVariable(var.name, compute_value=Norm(var, (dma + dmi) / 2, 2 / diff), sparse=var.sparse)

Orange/preprocess/remove.py

@@ -170,7 +170,9 @@ def merge_transforms(exp):
                 exp.var.name,
                 values=exp.var.values,
                 ordered=exp.var.ordered,
-                compute_value=merge_lookup(A, B))
+                compute_value=merge_lookup(A, B),
+                sparse=exp.var.sparse,
+            )
             assert isinstance(prev.sub, Var)
             return Transformed(prev.sub, new_var)
         else:
@@ -253,7 +255,8 @@ def remove_unused_values(var, data):
     return DiscreteVariable("{}".format(var.name),
                             values=used_values,
                             base_value=base_value,
-                            compute_value=Lookup(var, translation_table)
+                            compute_value=Lookup(var, translation_table),
+                            sparse=var.sparse,
                             )
 
 
@@ -268,7 +271,8 @@ def sort_var_values(var):
     )
 
     return DiscreteVariable(var.name, values=newvalues,
-                            compute_value=Lookup(var, translation_table))
+                            compute_value=Lookup(var, translation_table),
+                            sparse=var.sparse)
 
 
 def merge_lookup(A, B):