Skip to content

Functions

Provides functions for the ATHENA project used by evolved networks.

Functions used by GE for evolving neural networks

PA(inputs)

Additive node

Parameters:

Name Type Description Default
inputs list

np.ndarrays where each value is added

 required

Returns:

Type Description
ndarray

np.ndarray containing the result modified by sigmoid function
Source code in src/athenage/genn/functions.py 
34
35
36
37
38
39
40
41
42
43
44
def PA(inputs:list) -> np.ndarray:
    """ Additive node 

    Args:
        inputs: np.ndarrays where each value is added

    Returns:
        np.ndarray containing the result modified by sigmoid function    
    """

    return activate(sum(inputs))

PAND(inputs)

Boolean AND operator. Returns 1.0 if all inputs are > 0 and 0 otherwise. Ignores np.nan inputs

Parameters:

Name Type Description Default
inputs list

np.ndarrays containing floats or np.nan

 required

Returns:

Type Description
ndarray

numpy array
Source code in src/athenage/genn/functions.py 
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
def PAND(inputs: list) -> np.ndarray:
    """
    Boolean AND operator. Returns 1.0 if all inputs are > 0 and 0 otherwise.
    Ignores np.nan inputs

    Args:
        inputs: np.ndarrays containing floats or np.nan

    Returns:
        numpy array 
    """
    stacked_arrays = np.stack(inputs, axis=0)

    valid_mask = ~np.isnan(stacked_arrays)
    all_nan_mask = np.all(np.isnan(stacked_arrays), axis=0)

    result = np.all((stacked_arrays > 0) | ~valid_mask, axis=0)    
    result = np.where(all_nan_mask, np.nan, result)

    return result.astype(float)

PD(inputs)

function to match ATHENA handling of division node in network. Uses protected dividision

Parameters:

Name Type Description Default
inputs list

np.ndarrays where first is numerator and all the rest are denominators

 required

Returns:

Type Description
ndarray

np.ndarray containing the dividend modified by sigmoid function
Source code in src/athenage/genn/functions.py 
 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
def PD(inputs:list) -> np.ndarray:
    """ function to match ATHENA handling of division node in network. Uses 
     protected dividision

    Args:
        inputs: np.ndarrays where first is numerator and all the rest are
            denominators

    Returns:
        np.ndarray containing the dividend modified by sigmoid function

    """

    result = inputs[0]
    anyzeroed = np.full_like(result,False).astype(bool)
    for divisor in inputs[1:]:
        try:
            zeroed = (divisor == 0)
            anyzeroed[zeroed]=True
            with np.errstate(divide='ignore', invalid='ignore'):
                result = np.where(divisor == 0, np.ones_like(result), result / divisor)
#                 result = np.where(divisor == 0, np.ones_like(divisor), result / divisor)

        except ZeroDivisionError:
            return 1.0

    result[anyzeroed]=1000
    return activate(result)

PM(inputs)

Multiplicative node

Parameters:

Name Type Description Default
inputs list

np.ndarrays where each value is multiplied

 required

Returns:

Type Description
ndarray

np.ndarray containing the result modified by sigmoid function
Source code in src/athenage/genn/functions.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
def PM(inputs:list) -> np.ndarray:
    """ Multiplicative node 

    Args:
        inputs: np.ndarrays where each value is multiplied

    Returns:
        np.ndarray containing the result modified by sigmoid function    
    """

    result = inputs[0]
    for val in inputs[1:]:
        result = result * val
    return activate(result)

PNAND(inputs)

Boolean NAND operator. Returns 0.0 if all inputs are > 0 and 1 otherwise. Ignores np.nan inputs

Parameters:

Name Type Description Default
inputs list

np.ndarrays containing floats or np.nan

 required

Returns:

Type Description
ndarray

numpy array
Source code in src/athenage/genn/functions.py 
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
def PNAND(inputs: list) -> np.ndarray:
    """
    Boolean NAND operator. Returns 0.0 if all inputs are > 0 and 1 otherwise.
    Ignores np.nan inputs

    Args:
        inputs: np.ndarrays containing floats or np.nan

    Returns:
        numpy array 
    """
    stacked_arrays = np.stack(inputs, axis=0)

    valid_mask = ~np.isnan(stacked_arrays)    
    all_nan_mask = np.all(np.isnan(stacked_arrays), axis=0)
    result = np.all((stacked_arrays <= 0) | ~valid_mask, axis=0)    
    result = np.where(all_nan_mask, np.nan, result)

    return result.astype(float)

PNOR(inputs)

Boolean NOR operator. Returns 0.0 if any inputs are > 0 and 1.0 otherwise. Ignores np.nan inputs

Parameters:

Name Type Description Default
inputs list

np.ndarrays containing floats or np.nan

 required

Returns:

Type Description
ndarray

numpy array
Source code in src/athenage/genn/functions.py 
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
def PNOR(inputs: list) -> np.ndarray:
    """
    Boolean NOR operator. Returns 0.0 if any inputs are > 0 and 1.0 otherwise.
    Ignores np.nan inputs

    Args:
        inputs: np.ndarrays containing floats or np.nan

    Returns:
        numpy array 
    """
    stacked_arrays = np.stack(inputs, axis=0)

    valid_mask = ~np.isnan(stacked_arrays)    
    all_nan_mask = np.all(np.isnan(stacked_arrays), axis=0)

    any_positive_mask = np.any((stacked_arrays > 0) & valid_mask, axis=0)    
    all_non_positive_mask = np.all((stacked_arrays <= 0) | np.isnan(stacked_arrays), axis=0)

    result = np.full(stacked_arrays.shape[1:], np.nan, dtype=float)
    result[any_positive_mask] = 0.0    
    result[all_non_positive_mask] = 1.0

    final_result = np.where(all_nan_mask, np.nan, result)

    return final_result

POR(inputs)

Boolean OR operator. Returns 1.0 if any inputs are > 0 and 1 otherwise. Ignores np.nan inputs

Parameters:

Name Type Description Default
inputs list

np.ndarrays containing floats or np.nan

 required

Returns:

Type Description
ndarray

numpy array
Source code in src/athenage/genn/functions.py 
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
def POR(inputs: list) -> np.ndarray:
    """
    Boolean OR operator. Returns 1.0 if any inputs are > 0 and 1 otherwise.
    Ignores np.nan inputs

    Args:
        inputs: np.ndarrays containing floats or np.nan

    Returns:
        numpy array 
    """
    stacked_arrays = np.stack(inputs, axis=0)

    valid_mask = ~np.isnan(stacked_arrays)    
    all_nan_mask = np.all(np.isnan(stacked_arrays), axis=0)

    result = np.any((stacked_arrays > 0) & valid_mask, axis=0)  
    result = np.where(all_nan_mask, np.nan, result)

    return result.astype(float)

PS(inputs)

Subtraction node

Parameters:

Name Type Description Default
inputs list

np.ndarrays where first is minuend and all the rest are subtrahends

 required

Returns:

Type Description
ndarray

np.ndarray containing the difference modified by sigmoid function
Source code in src/athenage/genn/functions.py 
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
def PS(inputs: list) -> np.ndarray:
    """ Subtraction node

    Args:
        inputs: np.ndarrays where first is minuend and all the rest are
            subtrahends

    Returns:
        np.ndarray containing the difference modified by sigmoid function    
    """

    diff = inputs[0]
    for num in inputs[1:]:
        diff = diff - num
    return activate(diff)

PXOR(inputs)

Boolean XOR operator. Returns 1.0 if if inputs alternate >0 and <=0. Returns 1.0 if they do not. Ignores np.nan inputs

Parameters:

Name Type Description Default
inputs list

np.ndarrays containing floats or np.nan

 required

Returns:

Type Description
ndarray

numpy array
Source code in src/athenage/genn/functions.py 
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
def PXOR(inputs: list) -> np.ndarray:
    """
    Boolean XOR operator. Returns 1.0 if if inputs alternate >0 and <=0.
    Returns 1.0 if they do not.
    Ignores np.nan inputs

    Args:
        inputs: np.ndarrays containing floats or np.nan

    Returns:
        numpy array 
    """
    stacked_arrays = np.stack(inputs, axis=0)
    valid_mask = ~np.isnan(stacked_arrays)
    all_nan_mask = np.all(np.isnan(stacked_arrays), axis=0)

    result = np.zeros(stacked_arrays.shape[1:], dtype=float)

    # Iterate over each position and check for alternating behavior
    for idx in np.ndindex(stacked_arrays.shape[1:]):
        # Get the values for this index across all arrays
        values = stacked_arrays[:, idx]

        # Ignore NaN values and get the valid (non-NaN) values
        valid_values = values[valid_mask[:, idx]]

        if len(valid_values) > 1:
            # Check if the values alternate between > 0 and <= 0
            # We want a sequence of values like: [>0, <=0, >0, <=0] or the reverse
            alternating = True
            for i in range(1, len(valid_values)):
                if valid_values[i] > 0 and valid_values[i-1] > 0:
                    alternating = False
                    break
                if valid_values[i] <= 0 and valid_values[i-1] <= 0:
                    alternating = False
                    break

            if alternating:
                result[idx] = 1.0
        elif len(valid_values) == 1:
            # If only one valid value exists and it's > 0, set result to 0
            result[idx] = 0.0

    # Apply np.nan where all values were np.nan at the position
    result = np.where(all_nan_mask, np.nan, result)

    return result

activate(a)

Sigmoid activation functioning matches behavior of original ATHENA code

Parameters:

Name Type Description Default
a ndarray

contains values to modify

 required

Returns:

Type Description
ndarray

np.ndarray containing modified values
Source code in src/athenage/genn/functions.py 
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def activate(a: np.ndarray) -> np.ndarray:
    """ Sigmoid activation functioning matches behavior of original ATHENA code

    Args:
        a: contains values to modify

    Returns:
        np.ndarray containing modified values

    """

    if isinstance(a, np.ndarray):
        a = np.where(a <= -709, -708, a)
        a = np.where(a >= 709, 708, a)
#         a = 1.0 / (1.0 + np.exp(np.negative(a)))
        a = 1.0 / (1.0 + np.exp(-a))
    else:
        if a >= -709 and a <= 709:
            a = 1.0 / (1.0 + np.exp(-a))
        else:
            a = np.float64(0.0) if a < -709 else np.float64(1.0)

    return a

add(a, b)

addition operator

Source code in src/athenage/genn/functions.py 
107
108
109
def add(a:np.ndarray,b:np.ndarray) -> np.ndarray:
    """ addition operator """
    return a+b

div(a, b)

division operator

Source code in src/athenage/genn/functions.py 
119
120
121
def div(a:np.ndarray,b:np.ndarray) -> np.ndarray:
    """ division operator """
    return a/b if b != 0 else 1.0

mult(a, b)

multiplication operator

Source code in src/athenage/genn/functions.py 
115
116
117
def mult(a:np.ndarray,b:np.ndarray) -> np.ndarray:
    """ multiplication operator """
    return a*b

pdiv(a, b)

Koza's protected division modified to work with numpy arrays as used in PonyGE2. Returns 1 when denominator is zero

Parameters:

Name Type Description Default
a ndarray

numerator

 required
b ndarray

denominator

 required

Returns:

Type Description
ndarray

numpy array with a/b or 1 when denominator is 0
Source code in src/athenage/genn/functions.py 
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
def pdiv(a: np.ndarray, b: np.ndarray) -> np.ndarray:
    """
    Koza's protected division modified to work with numpy arrays as used in PonyGE2.
    Returns 1 when denominator is zero

    Args:
        a: numerator
        b: denominator

    Returns:
        numpy array with a/b or 1 when denominator is 0
    """

    try:
        with np.errstate(divide='ignore', invalid='ignore'):
            return np.where(b == 0, np.ones_like(a), a / b)
    except ZeroDivisionError:
        # In this case we are trying to divide two constants, one of which is 0
        # Return a constant.
        return 1.0

sub(a, b)

subtraction operator

Source code in src/athenage/genn/functions.py 
111
112
113
def sub(a:np.ndarray,b:np.ndarray) -> np.ndarray:
    """ subtraction operator """
    return a-b