def test_basic4(self):
"""
Test that a dispatcher object can be used as input to another
function with signature as part of a tuple
"""
a = 1
@njit
def foo1(x):
return x + 1
@njit
def foo2(x):
return x + 2
tup = (foo1, foo2)
int_int_fc = types.FunctionType(types.int64(types.int64, ))
@njit(types.int64(types.UniTuple(int_int_fc, 2)))
def bar(fcs):
x = 0
for i in range(2):
x += fcs[i](a)
return x
self.assertEqual(bar(tup), foo1(a) + foo2(a))
def test_basic5(self):
a = 1
@njit
def foo1(x):
return x + 1
@njit
def foo2(x):
return x + 2
@njit
def bar1(x):
return x / 10
@njit
def bar2(x):
return x / 1000
tup = (foo1, foo2)
tup_bar = (bar1, bar2)
int_int_fc = types.FunctionType(types.int64(types.int64, ))
flt_flt_fc = types.FunctionType(types.float64(types.float64, ))
@njit((types.UniTuple(int_int_fc, 2), types.UniTuple(flt_flt_fc, 2)))
def bar(fcs, ffs):
x = 0
for i in range(2):
x += fcs[i](a)
for fn in ffs:
x += fn(a)
return x
got = bar(tup, tup_bar)
expected = foo1(a) + foo2(a) + bar1(a) + bar2(a)
self.assertEqual(got, expected)
def test_apply_function_in_function(self):
def foo(f, f_inner):
return f(f_inner)
@cfunc('int64(float64)')
def f_inner(i):
return int64(i * 3)
@cfunc(int64(types.FunctionType(f_inner._sig)))
def f(f_inner):
return f_inner(123.4)
self.assertEqual(
jit(nopython=True)(foo)(f, f_inner), foo(f._pyfunc,
f_inner._pyfunc))
def make_neural_network(layer_sizes,
layer_activations,
recurrent_layers,
learning_rate=0.01,
low=-2,
high=2):
for size in layer_sizes:
assert size > 0
# Initialize typed layer sizes list.
typed_layer_sizes = typed.List()
for size in layer_sizes:
typed_layer_sizes.append(size)
# Initialie typed layer activation method strings list.
prototype = types.FunctionType(types.float64[:, ::1](types.float64[:, ::1],
types.boolean))
typed_layer_activations = typed.List.empty_list(prototype)
for activation in layer_activations:
typed_layer_activations.append(activation)
# Initialize typed recurrent layers.
typed_recurrent_layers = typed.List()
for val in recurrent_layers:
typed_recurrent_layers.append(val)
# Initialize weights between every neuron in all adjacent layers.
typed_weights = typed.List()
for i in range(1, len(layer_sizes)):
typed_weights.append(
np.random.uniform(low, high, (layer_sizes[i - 1], layer_sizes[i])))
# Initialize biases for every neuron in all layers
typed_biases = typed.List()
for i in range(1, len(layer_sizes)):
typed_biases.append(np.random.uniform(low, high, (layer_sizes[i], 1)))
# Initialize empty list of output of every neuron in all layers.
typed_layer_outputs = typed.List()
for i in range(len(layer_sizes)):
typed_layer_outputs.append(np.zeros((layer_sizes[i], 1)))
typed_learning_rate = learning_rate
return NeuralNetwork(typed_layer_sizes, typed_layer_activations,
typed_recurrent_layers, typed_weights, typed_biases,
typed_layer_outputs, typed_learning_rate)
def test_basic2(self):
"""
Test that a dispatcher object *without* a pre-compiled overload
can be used as input to another function with locked-down signature
"""
a = 1
@njit
def foo(x):
return x + 1
int_int_fc = types.FunctionType(types.int64(types.int64, ))
@njit(types.int64(int_int_fc))
def bar(fc):
return fc(a)
self.assertEqual(bar(foo), foo(a))
def test_basic3(self):
"""
Test that a dispatcher object *without* a pre-compiled overload
can be used as input to another function with locked-down signature and
that it behaves as a truly generic function (foo1 does not get locked)
"""
a = 1
@njit
def foo1(x):
return x + 1
@njit
def foo2(x):
return x + 2
int_int_fc = types.FunctionType(types.int64(types.int64, ))
@njit(types.int64(int_int_fc))
def bar(fc):
return fc(a)
self.assertEqual(bar(foo1) + 1, bar(foo2))
import numpy as np
from numba.experimental import jitclass
from numba import njit, types, typed, prange
import z_helper as h
import time
from numba.core.errors import NumbaTypeSafetyWarning
import warnings
warnings.simplefilter('ignore', category=NumbaTypeSafetyWarning)
spec = [
("layer_sizes", types.ListType(types.int64)),
("layer_activations",
types.ListType(
types.FunctionType(types.float64[:, ::1](types.float64[:, ::1],
types.boolean)))),
("weights", types.ListType(types.float64[:, ::1])),
("biases", types.ListType(types.float64[:, ::1])),
("layer_outputs", types.ListType(types.float64[:, ::1])),
("learning_rate", types.float64),
]
@jitclass(spec)
class NeuralNetwork:
def __init__(self, layer_sizes, layer_activations, weights, biases,
layer_outputs, learning_rate):
self.layer_sizes = layer_sizes
self.layer_activations = layer_activations
self.weights = weights
self.biases = biases
# new_pn = _cast_structref(BasePredicateNodeType, new_a)
# else:
# b = _cast_structref(GenericBetaPredicateNodeType, pn)
# new_b = new(GenericBetaPredicateNodeType)
# new_b.filter_func = b.filter_func
# new_b.right_t_id = b.right_t_id
# new_b.right_facts = b.right_facts
# new_pn = _cast_structref(BasePredicateNodeType, new_b)
return link_data
meminfo_type = types.MemInfoPointer(types.voidptr)
alpha_filter_func_type = types.FunctionType(i8[::1](meminfo_type, PredicateNodeLinkDataType, i8[::1], u1))
beta_filter_func_type = types.FunctionType(i8[:,::1](meminfo_type, PredicateNodeLinkDataType, i8[::1], i8[::1], u1))
#### Struct Definitions ####
base_predicate_node_field_dict = {
#### Attributes filled in at definition time ###
"id_str" : unicode_type,
"is_alpha" : u1,
"left_fact_type_name" : unicode_type,
"right_fact_type_name" : unicode_type,
"left_attr_offsets" : i8[::1],#types.Any,
@njit(cache=True, fastmath=checks.fastmath, nogil=True)
def _find_edge_idx(node_edge_map: Dict, edge_data: np.ndarray,
start_nd_idx: int, end_nd_idx: int) -> int:
"""
Finds an edge from start and end nodes
"""
# iterate the start node's edges
for edge_idx in node_edge_map[start_nd_idx]:
# check whether the edge's out node matches the target node
if edge_data[edge_idx, 1] == end_nd_idx:
return edge_idx
node_close_func_proto = types.FunctionType(
types.float64(types.float64, types.float64, types.float64, types.float64))
# node density
@njit(cache=True, fastmath=checks.fastmath, nogil=True)
def node_density(to_short_dist, to_simpl_dist, beta, cycles):
return 1.0 # return float explicitly
# node farness
@njit(cache=True, fastmath=checks.fastmath, nogil=True)
def node_farness(to_short_dist, to_simpl_dist, beta, cycles):
return to_short_dist
# node cycles
#upstream BaseSubscribers' meminfos that need to be updated before this can be.
("upstream", ListType(meminfo_type)),
#The subscribers immediately downstream of this one.
("children", ListType(meminfo_type)),
("change_head", i8),
("grow_head", i8),
("change_queue", VectorType), #ListType(u8)),
("grow_queue", VectorType), #ListType(u8)),
# #Indicies or idrecs of things that have changed in the subscriber's parent (i.e. last
# # upstream). The parent is responsible for filling this.
# ("change_queue", VectorType),#ListType(u8)),
# #Same as change_queue but for when the something has been added upstream
# ("grow_queue", VectorType),#ListType(u8)),
#An update function that updates state of the subscriber and pushes changes to all children.
("update_func", types.FunctionType(void(meminfo_type))),
# #The t_id corresponding to the type to which this subscriber subscribes
# ("t_id", i8)
#
]
BASE_SUBSCRIBER_QUEUE_SIZE = 8
BaseSubscriber, BaseSubscriberType = define_structref("BaseSubscriber",
base_subscriber_fields)
@njit(cache=True)
def init_base_subscriber(bs):
bs.kb_meminfo = None #_meminfo_from_struct(kb)
bs.upstream = List.empty_list(meminfo_type)
