Added Julia Files

julia/truth.jl

@@ -0,0 +1,77 @@
+# *** Custom Functions
+##################################################################################################################################
+# *** Will somewhere need to define a list TRUTHS of all valid auxliary truths
+struct Transformation
+    type::Integer # 1 is symmetry, 2 is zero, 3 is equality
+    params::Array{Int32}
+    Transformation(type::Integer, params::Array{Int32}) = new(type, params)
+    Transformation(type::Integer, params::Array{Int64}) = new(type, params)
+
+end
+struct Truth
+    transformation::Transformation
+    weights::Array{Float32}
+    Truth(transformation::Transformation, weights::Array{Float32}) = new(transformation, weights)
+    Truth(type::Int64, params::Array{Int64}, weights::Array{Float32}) = new(Transformation(type, params), weights)
+    Truth(transformation::Transformation, weights::Array{Float64}) = new(transformation, weights)
+    Truth(type::Int64, params::Array{Int64}, weights::Array{Float64}) = new(Transformation(type, params), weights)
+end
+# Returns a linear combination when given X of shape nxd, y of shape nx1 is f(x) and w of shape d+2x1, result is shape nx1
+function LinearPrediction(cX::Array{Float32}, cy::Array{Float32}, w::Array{Float32})::Array{Float32}
+     preds = 0
+     for i in 1:ndims(cX)
+       preds = preds .+ cX[:,i].*w[i]
+       end
+     preds = preds .+ cy.*w[ndims(cX)+1]
+     return preds .+ w[ndims(cX)+2]
+end
+
+# Returns a copy of the data with the two specified columns swapped
+function swapColumns(cX::Array{Float32, 2}, a::Integer, b::Integer)::Array{Float32, 2}
+    X1 = copy(cX)
+    X1[:, a] = cX[:, b]
+    X1[:, b] = cX[:, a]
+    return X1
+end
+
+# Returns a copy of the data with the specified integers in the list set to value given
+function setVal(cX::Array{Float32, 2}, a::Array{Int32, 1}, val::Float32)::Array{Float32, 2}
+    X1 = copy(cX)
+    for i in 1:size(a)[1]
+        X1[:, a[i]] = fill!(cX[:, a[i]], val)
+    end
+    return X1
+end
+
+# Returns a copy of the data with the specified integer indices in the list set to the first item of that list
+function setEq(cX::Array{Float32, 2}, a::Array{Int32, 1})::Array{Float32, 2}
+    X1 = copy(cX)
+    val = X1[:, a[1]]
+    for i in 1:size(a)[1]
+        X1[:, a[i]] = val
+    end
+    return X1
+end
+
+# Takes in a dataset and returns the transformed version of it as per the specified type and parameters
+function transform(cX::Array{Float32, 2}, transformation::Transformation)::Array{Float32, 2}
+    if transformation.type==1 # then symmetry
+        a = transformation.params[1]
+        b = transformation.params[2]
+        return swapColumns(cX, a, b)
+    elseif transformation.type==2 # then zero condition
+        return setVal(cX, transformation.params, Float32(0))
+    elseif transformation.type == 3 # then equality condition
+        return setEq(cX, transformation.params)
+    else # Then error return X
+        return cX
+    end
+end
+function transform(cX::Array{Float32, 2}, truth::Truth)::Array{Float32, 2}
+    return transform(cX, truth.transformation)
+end
+
+# Takes in X that has been transformed and returns what the Truth projects the target values should be
+function truthPrediction(X_transformed::Array{Float32, 2}, cy::Array{Float32}, truth::Truth)::Array{Float32}
+    return LinearPrediction(X_transformed, cy, truth.weights)
+end

julia/truthPops.jl

@@ -0,0 +1,170 @@
+# Returns the MSE between the predictions and the truth provided targets for the given dataset
+function truthScore(member::PopMember, cX::Array{Float32, 2}, cy::Array{Float32}, truth::Truth)::Float32
+    transformed = transform(cX, truth)
+    targets = truthPrediction(transformed, cy, truth)
+    preds = evalTreeArray(member.tree, transformed)
+    return MSE(preds, targets)
+end
+
+# Assumes a dataset X, y for a given truth
+function truthScore(member::PopMember, truth::Truth)::Float32
+    return truthScore(member, X, y, truth)
+end
+
+# Assumes a list of Truths TRUTHS is defined. Performs the truthScore function for each of them and returns the average
+function truthScore(member::PopMember, cX::Array{Float32, 2}, cy::Array{Float32})::Float32
+    s = 0
+    for truth in TRUTHS
+        s += (truthScore(member, cX, cy, truth))/size(TRUTHS)[1]
+    end
+    return s
+end
+
+# Assumes list of Truths TRUTHS and dataset X, y are defined
+function truthScore(member::PopMember)::Float32
+    return truthScore(member, X, y)
+end
+# Returns the MSE between the predictions and the truth provided targets for the given dataset
+function truthScore(tree::Node, cX::Array{Float32, 2}, cy::Array{Float32}, truth::Truth)::Float32
+    transformed = transform(cX, truth)
+    targets = truthPrediction(transformed, cy, truth)
+    preds = evalTreeArray(tree, transformed)
+    return MSE(preds, targets)
+end
+
+# Assumes a dataset X, y for a given truth
+function truthScore(tree::Node, truth::Truth)::Float32
+    return truthScore(tree, X, y, truth)
+end
+
+# Assumes a list of Truths TRUTHS is defined. Performs the truthScore function for each of them and returns the average
+function truthScore(tree::Node, cX::Array{Float32, 2}, cy::Array{Float32})::Float32
+    s = 0
+    for truth in TRUTHS
+        s += (truthScore(tree, cX, cy, truth))/size(TRUTHS)[1]
+    end
+    return s
+end
+
+# Assumes list of Truths TRUTHS and dataset X, y are defined
+function truthScore(tree::Node)::Float32
+    return truthScore(tree, X, y)
+end
+
+# Returns true iff Truth Score is below a given threshold i.e truth is satisfied
+function testTruth(member::PopMember, truth::Truth, threshold::Float32=Float32(1.0e-8))::Bool
+    truthError = truthScore(member, truth)
+    #print(stringTree(member.tree), "\n")
+    #print(truth, ": ")
+    #print(truthError, "\n")
+    if truthError > threshold
+        #print("Returns False \n ----\n")
+        return false
+    else
+        #print("Returns True \n ----\n")
+        return true
+    end
+end
+
+# Returns a list of violating functions from assumed list TRUTHS
+function violatingTruths(member::PopMember)::Array{Truth}
+    return violatingTruths(member.tree)
+end
+
+# Returns true iff Truth Score is below a given threshold i.e truth is satisfied
+function testTruth(tree::Node, truth::Truth, threshold::Float32=Float32(1.0e-3))::Bool
+    truthError = truthScore(tree, truth)
+    if truthError > threshold
+        return false
+    else
+        return true
+    end
+end
+
+# Returns a list of violating functions from assumed list TRUTHS
+function violatingTruths(tree::Node)::Array{Truth}
+    toReturn = []
+    #print("\n Checking Equation ", stringTree(tree), "\n")
+    for truth in TRUTHS
+        test_truth = testTruth(tree, truth)
+        #print("Truth: ", truth, ": " , test_truth, "\n-----\n")
+        if !test_truth
+            append!(toReturn, [truth])
+        end
+    end
+    return toReturn
+end
+
+function randomIndex(cX::Array{Float32, 2}, k::Integer=10)::Array{Int32, 1}
+    indxs = sample([Int32(i) for i in 1:size(cX)[1]], k)
+    return indxs
+end
+
+function randomIndex(leng::Integer, k::Integer=10)::Array{Int32, 1}
+    indxs = sample([Int32(i) for i in 1:leng], k)
+    return indxs
+end
+
+function extendedX(cX::Array{Float32, 2}, truth::Truth, indx::Array{Int32, 1})::Array{Float32, 2}
+    workingcX = copy(cX)
+    X_slice = workingcX[indx, :]
+    X_transformed = transform(X_slice, truth)
+    return X_transformed
+end
+function extendedX(truth::Truth, indx::Array{Int32, 1})::Union{Array{Float32, 2}, Nothing}
+    return extendedX(OGX, truth, indx)
+end
+function extendedX(cX::Array{Float32, 2}, violatedTruths::Array{Truth}, indx::Array{Int32, 1})::Union{Array{Float32, 2}, Nothing}
+    if length(violatedTruths) == 0
+        return nothing
+    end
+    workingX = extendedX(cX, violatedTruths[1], indx)
+    for truth in violatedTruths[2:length(violatedTruths)]
+        workingX = vcat(workingX, extendedX(cX, truth, indx))
+    end
+    return workingX
+end
+function extendedX(violatedTruths::Array{Truth}, indx::Array{Int32, 1})::Union{Array{Float32, 2}, Nothing}
+    return extendedX(OGX, violatedTruths, indx)
+end
+function extendedX(tree::Node, indx::Array{Int32, 1})::Union{Array{Float32, 2}, Nothing}
+    violatedTruths = violatingTruths(tree)
+    return extendedX(violatedTruths, indx)
+end
+function extendedX(member::PopMember, indx::Array{Int32, 1})::Union{Array{Float32, 2}, Nothing}
+    return extendedX(member.tree, indx)
+end
+
+
+function extendedy(cX::Array{Float32, 2}, cy::Array{Float32}, truth::Truth, indx::Array{Int32, 1})::Union{Array{Float32}, Nothing}
+    cy = copy(cy)
+    cX = copy(cX)
+    X_slice = cX[indx, :]
+    y_slice = cy[indx]
+    X_transformed = transform(X_slice, truth)
+    y_transformed = truthPrediction(X_transformed, y_slice, truth)
+    return y_transformed
+end
+function extendedy(truth::Truth, indx::Array{Int32, 1})::Union{Array{Float32}, Nothing}
+    return extendedy(OGX, OGy, truth, indx)
+end
+function extendedy(cX::Array{Float32, 2}, cy::Array{Float32}, violatedTruths::Array{Truth}, indx::Array{Int32, 1})::Union{Array{Float32}, Nothing}
+    if length(violatedTruths) == 0
+        return nothing
+    end
+    workingy = extendedy(cX, cy, violatedTruths[1], indx)
+    for truth in violatedTruths[2:length(violatedTruths)]
+        workingy = vcat(workingy, extendedy(cX, cy, truth, indx))
+    end
+    return workingy
+end
+function extendedy(violatedTruths::Array{Truth}, indx::Array{Int32, 1})::Union{Array{Float32}, Nothing}
+    return extendedy(OGX,OGy, violatedTruths, indx)
+end
+function extendedy(tree::Node, indx::Array{Int32, 1})::Union{Array{Float32}, Nothing}
+    violatedTruths = violatingTruths(tree)
+    return extendedy(violatedTruths, indx)
+end
+function extendedy(member::PopMember, indx::Array{Int32, 1})::Union{Array{Float32}, Nothing}
+    return extendedy(member.tree, indx)
+end