def __init__(
self,
server_0: Optional[Player] = None,
server_1: Optional[Player] = None,
server_2: Optional[Player] = None,
tensor_factory: Optional[AbstractFactory] = None,
prime_factory: Optional[AbstractFactory] = None,
odd_factory: Optional[AbstractFactory] = None,
**kwargs,
) -> None:
server_0 = server_0 or get_config().get_player("server0")
server_1 = server_1 or get_config().get_player("server1")
server_2 = (server_2 or get_config().get_player("server2")
or get_config().get_player("crypto-producer"))
assert server_0 is not None
assert server_1 is not None
assert server_2 is not None
super(SecureNN, self).__init__(
server_0=server_0,
server_1=server_1,
triple_source=server_2,
tensor_factory=tensor_factory,
**kwargs,
)
self.server_2 = server_2
if odd_factory is None:
if self.tensor_factory is int64factory:
odd_factory = oddint64_factory
else:
odd_factory = self.tensor_factory
if prime_factory is None:
prime = 107
assert prime > math.ceil(math.log2(self.tensor_factory.modulus))
prime_factory = native_factory(self.tensor_factory.native_type,
prime)
self.prime_factory = prime_factory
self.odd_factory = odd_factory
assert self.prime_factory.native_type == self.tensor_factory.native_type
assert self.odd_factory.native_type == self.tensor_factory.native_type
def convert(
self,
graph_def: Any,
input_player: Union[str, Player],
inputter_fn: Optional[Union[TFEInputter, List[TFEInputter]]] = None,
) -> Any:
"""Convert a frozen GraphDef to a TFE Graph."""
if not graph_def.node:
raise ValueError("An empty model was passed to the converter.")
if isinstance(input_player, str):
input_player = get_config().get_player("input-provider")
assert isinstance(input_player, Player)
if inputter_fn is None:
inputs = []
elif isinstance(inputter_fn, (list, tuple)):
inputs = inputter_fn
else:
inputs = [inputter_fn]
inputs_iterable = enumerate(inputs)
# Identify if there are special ops in pb file,
# e.g. required_space_to_batch_paddings
# If yes, identify the inputs and outputs of these special ops.
output_name = graph_def.node[-1].name # Assume output is last node.
specop_dict, specop_inputs, specop_outputs = find_specops(
graph_def, output_name
)
# Create a dictionary excluding all the sub ops related to
# required_space_to_batch_paddings. Except the sub ops related to the input
# or output of this special ops.
pb_trimmed, graph_def = select_relevant_ops(
specop_inputs, specop_outputs, graph_def
)
node_list = pb_trimmed.values()
# If the ops are not related to the special ops, use the existing approach
# to register them. Otherwise for the special ops replace the output from
# the sub ops by the output from the high level operation then register.
for node in node_list:
if node.name not in specop_outputs:
self._register_op(node, inputs_iterable, input_player, graph_def)
else:
# Register high level special operations
for s in specop_dict:
# If this node is the output of the current specop, register it
if match_numbered_scope(
s, node.name, return_group=False, numbered=False
):
self._register_specop(node, specop_dict[s])
return self.outputs[output_name]
def __init__(self,
config: Optional[Config] = None,
protocol: Optional[Protocol] = None,
player: Optional[Union[str, Player]] = None) -> None:
self.config = config if config is not None else get_config()
self.protocol = protocol if protocol is not None else get_protocol()
if player is None:
self.model_provider = self.config.get_player('model-provider')
elif isinstance(player, str):
self.model_provider = self.config.get_player(player)
else:
self.model_provider = player
self.outputs = {}
def __init__(
self,
registry,
config: Optional[Config] = None,
protocol: Optional[Protocol] = None,
model_provider: Optional[Union[str, Player]] = None,
) -> None:
self.config = config if config is not None else get_config()
if protocol is not None:
tfe.set_protocol(protocol)
if model_provider is None:
self.model_provider = self.config.get_player("model-provider")
elif isinstance(model_provider, str):
self.model_provider = self.config.get_player(model_provider)
else:
self.model_provider = model_provider
self.registry = registry
self.outputs = {}
def convert(
self,
graph_def: Any,
register: Dict[str, Any],
input_player: Union[str, Player],
inputter_fn: Optional[Union[TFEInputter, List[TFEInputter]]] = None
) -> Any:
"""Convert a frozen GraphDef to a TFE Graph."""
if isinstance(input_player, str):
input_player = get_config().get_player('input-provider')
assert isinstance(input_player, Player)
if inputter_fn is None:
inputs = []
elif isinstance(inputter_fn, list):
inputs = inputter_fn
else:
inputs = [inputter_fn]
inputs_iterable = enumerate(inputs)
# Identify if there are special ops in pb file,
# e.g. required_space_to_batch_paddings
# If yes, identify the inputs and outputs of these special ops.
output_name = graph_def.node[-1].name # Assume output is last node.
specop_dict, specop_inputs, specop_outputs = find_specops(
graph_def, output_name)
# Create a dictionary excluding all the sub ops related to required_space_to_batch_paddings
# Except the sub ops related to the input or output of this special ops.
pb_trimmed = select_relevant_ops(specop_inputs, specop_outputs,
graph_def)
node_list = pb_trimmed.values()
# If the ops are not related to the special ops, use the existing approach to register them.
# Otherwise for the special ops replace the output from the sub ops by the output from the
# high level operation then register.
for node in node_list:
if node.name not in specop_outputs:
output = strip_tensor_info(node.name)
inputs = [strip_tensor_info(x) for x in node.input]
if node.op == "Placeholder":
try:
_, item = inputs_iterable.__next__()
except StopIteration:
raise InvalidArgumentError(
"Not enough placeholders supplied")
x = self.protocol.define_private_input(input_player, item)
self.outputs[output] = x
continue
self.outputs[output] = register[node.op](self, node, inputs)
else:
# Register high level special operations
for s in specop_dict:
input_list = specop_dict[s]['inputs']
output_list = specop_dict[s]['outputs']
# Handle edge cases if the ops return multiple outputs
op_handler = register[specop_dict[s]['op']]
nodes = specop_dict[s]['interiors']
if not nodes:
nodes = node
outs = op_handler(self, nodes, input_list)
if isinstance(outs, (list, tuple)):
for i, x in enumerate(outs):
self.outputs[output_list[i]] = x
else:
self.outputs[output_list[0]] = outs
return self.outputs[graph_def.node[-1].name]