Towards Regulated Deep Learning
First step in a Roadmap towards Collaborative Knowledge Evolution

Regulation of Multi-Agent Systems (MAS) and Declarative Electronic Institutions (DEIs) [1][2][3] was a multidisciplinary research topic of the past decade involving (Physical and Software) Agents and Law since the beginning, but recently evolved towards News-claimed Robot Lawyer since 2016. One of these first proposals of restricting the behaviour of Software Agents was Electronic Institutions [4] [5] [6].

However, with the recent reformulation of Artificial Neural Networks (ANNs) as Deep Learning (DL) [7], Security, Privacy, Ethical and Legal issues regarding the use of DL has raised concerns in the Artificial Intelligence (AI) Community [8].

Now that the Regulation of MAS is almost correctly addressed, we propose the Regulation of Artificial Neural Networks as Agent-based Training of a special type of regulated Artificial Neural Network that we call Institutional Neural Network (INN).

The main purpose of this paper is to bring attention to Artificial Teaching (AT) and to give a tentative answer showing a proof-of-concept implementation of Regulated Deep Learning (RDL).

This paper introduces the former concept and provides $\mathcal{I}$ [2], a language previously used to model and extend Electronic Institutions[6], as a means to regulate the execution of Artificial Neural Networks and their interactions with Artificial Teachers (ATs).

The structure of this position article is as follows, in section 2 the need of Agent-based Training for DL (ABT4DL) is introduced. In Section 3 the fore-mentioned language is introduced and, Section 3.1 presents some preliminary definitions for this work. The normative language that includes the tentative answer is presented in section 4. Section 5 presents the Semantics of the language and section 6 its Operational Semantics. Some examples of Artificial Neural Network modeling are presented in section 7. And finally, sections 9 and 10 presents some conclusions and possible future work to continue this research, respectively.

Current ANNs, and subsequently Deep Learning, proposals are Data-driven: they model an a priori unknown function by processing large amounts of data [7] without automatically controlling the source of this data, neither how one could certify the proper use of the data.

We introduce Agent-based Training for Deep Learning (ABT4DL) as a new paradigm for Automated training of Artificial Neural Networks. However, we envisage that such training should be regulated and mediated, thus, as we propose agents as artificial data providers with an intuitive role of Artificial Teacher (AT), using a Regulated MAS as follows in order to regulate and mediate the behaviour of these Artificial Teachers interacting with Artificial Neural Networks residing in the state-of-affairs of a Declarative Electronic Institution [3].

The proposed language in this work is based in Event-Condition-Action (ECA) rules, that perform the specified institutional actions when the given agent events occur and when the prespecified conditions hold. The performance of actions add or remove atomic formulae thus triggering another type of rule: the if-rules, that are standard production rules as usually found in Expert Sytems [9]. Above these two types of rules a new types of rules are placed: ignore-rules, that ignore a set of simultaneous events, force-rules, that generate a set of events on the occurrence of a given set of events satisfying certain conditions, and prevent-rules, that ignore the execution of ECA or if-then rules if certain formulae hold in the current state and another given set of formulae hold in the calculation of the next state.

This section introduces a rule language for the regulation and management of concurrent events generated by a population of agents.

Figure 1 depicts the computational model used: n initial state of affairs $\Delta_{0}$ (possibly empty) is offered (represented by “$\Rrightarrow$”) to a set of agents ($ag_{1},\cdots,ag_{n}$). These agents can add their speech acts ($\Xi^{0}_{1},\cdots,\Xi^{0}_{n}$) to the state of affairs (via “$\updownarrow$”). $\Xi^{t}_{i}$ is the (possibly empty) set of speech acts added by agent $i$ at state of affairs $\Delta_{t}$. After an established amount of time, an exhaustive application of rules is performed(denoted by “$\stackrel{{\scriptstyle*}}{{\rightsquigarrow}}$”) to the modified state, yielding a new state of affairs $\Delta_{1}$. This new state will, in its turn, be offered to the agents for them to add their utterances, and the same process will go on.

One goal of the $\mathcal{I}$ language is to specify the effects of concurrent events and this is achieved with Event-Condition-Action (ECA) rules. Intuitively, an ECA-rule means that whenever the events occur and the conditions hold then the actions are applied. These actions consist of the addition and removal of atomic formulae from the state of affairs. ECA-rules are checked in parallel and they are executed only once without chaining.

If-rules are similar to rules in standard production systems, if the conditions hold then the actions are applied. They are implemented with a forward chaining mechanism: they are executed sequentially until no new formula is added or removed.

Ignore-rules are used for ignoring events when the conditions hold in order to avoid unwanted behaviour. Similarly, prevent-rules are used for preventing some conditions to hold in the given situations. In order to prevent unwanted states, events causing such unwanted states are ignored. Force-rules generate events and execute actions as consequence of other events and conditions.

Sanctions over unwanted events can be carried out with ECA-rules. For instance, they can decrease the credit of one agent by 10 if she generates a certain event.

Figure 2 shows the grammar for $\mathcal{I}$, i.e. the syntax of the five type of rules proposed: ECA-rules, if-rules, ignore-rules, prevent-rules and force-rules.

ECA rules specify the effect of a set of events, i.e. a set of atomic formulae, if the conditions hold. This effect is specified by means of a sequence of actions namely addition and removal of constrained formulae. A constrained formulae is an atomic formula that may be followed by a set of arithmetical constraints using the syntax presented in Def. 3. Furthermore, by $conditions$ is meant one or more possibly negated conditions. Then, a condition may be a constrained formula, the $\mathtt{sat}$ predicate that checks that a set of constraints is satisfiable, the seteq predicate that checks if two sets are equal, the ${\tt time}$ predicate that checks current time or the true constant that always hold.

If-rules specify the logical consequence if the conditions hold by means of a sequence of actions. Ignore-rules specify the set of events that should be ignored if the conditions hold. Similarly, prevent-rules specify the conditions that should not hold if some conditions hold. Finally, force-rules specify a set of new events that are generated on the occurrence of a set of events and the satisfaction of a sequence of conditions. Furthermore, it also specifies a sequence of actions to perform if the rule is triggered.

An extra kind of rule, called expectation-rules, and shown in Fig. 3, that generate and remove expectations of events might be added. If the expectation fails to be fulfilled then some sanctioning or corrective actions are performed.

However, each expectation rule are equivalent to the following rules:

In Fig. 4, Rule 1 and 2 respectively adds and removes an expectation whenever the events have occurred and the conditions hold. Rule 3 cancels the unfulfilled expectation and sanctions an agent for the unfulfilled expectation by executing the given $actions$ whenever some $conditions$ hold.

Instead of basing the $\mathcal{I}$ language on the standard deontic notions, two types of prohibitions and two types of obligations are included. In the language, ECA-rules determine what is possible to perform, i.e. they establish the effects (including sanctions) in the institution after performing certain (possibly concurrent) events. ECA-rules can be seen as conditional count-as rules: the given events count as the execution of the actions in the ECA-rule if the conditions hold and the event is not explicitly prohibited. As for the notion of permission, all the events are permitted if not explicitly prohibited. The notion of an event being prohibited may be expressed depending on whether that event has to be ignored or not. If not otherwise expressed, events are not ignored. Likewise, the notion of a state being prohibited may be specified depending on whether that state has to be prevented or not. By default, states are not prevented. Obligations are differentiated in two types: expectations, which an agent may not fulfill, and forced (or obligatory) events, which the system takes as institutional events even they are not actually performed by the agents.

Each set of ECA-rules generates a labelled transition system $\langle\mathcal{S},\mathcal{E},\mathcal{R}\rangle$ where $\mathcal{S}$ is a set of states, each state in $\mathcal{S}$ is a set of atomic formulae, $\mathcal{E}$ is a set of events, and $\mathcal{R}$ is a $\mathcal{S}\times 2^{\mathcal{E}}\times\mathcal{S}$ relationship indicating that whenever a set of events occur in the former state, then there is a transition to the subsequent state.

Ignore-rules avoid executing any transition that contains in its labelling the events that appear in any ignore-rule. For instance, having a rule $\mbox{$\mathsf{\mathbf{ignore}}$ }\alpha_{1}\allowbreak\mbox{ $\mathsf{\mathbf{if}}$ }true$ would avoid executing the transitions labelled as $\{\alpha_{1}\}$, $\{\alpha_{1},\alpha_{2}\}$ and $\{\alpha_{1},\alpha_{2},\alpha_{3}\}$. However, having a rule $\mbox{$\mathsf{\mathbf{ignore}}$ }\alpha_{1},\alpha_{2}\mbox{ $\mathsf{\mathbf{if}}$ }true$ would avoid executing $\{\alpha_{1},\alpha_{2}\}$ and $\{\alpha_{1},\alpha_{2},\alpha_{3}\}$ but not $\{\alpha_{1}\}$.

Prevent-rules ignore all the actions in an ECA-rule if it brings the given formulae about. For example, suppose that we have

along with ECA-rules 4, 5 and 6 below. After the occurrence of events $\alpha_{1}$ and $\alpha_{2}$ and since $q_{1}$ is an effect of event $\alpha_{2}$, all the actions in ECA-rule 5 would be ignored obtaining a new state where $p$ and $r$ hold but neither $q_{1}$ nor $q_{2}$.

Force-rules generate events during the execution of the transition system. However, the effects of such events are still specified by ECA-rules and subject to prevent and ignore-rules.

As shown in figure 1, the semantics of rules are presented as a relationship between states of affairs: rules map an existing state of affairs to a new state of affairs. This section defines this relationship. The definitions below rely on the concept of substitution, that is, the set of values for variables in a computation [10, 11]:

The semantics of the conditions are now defined, that is, when a condition holds:

Case 1 depicts the semantics of atomic formulae and how their individual substitutions are combined to provide the semantics for a conjunction. Case 2 introduces negation by failure. Case 3 compares if two lists have the same elements possibly in different order. Case 4 checks if a set of constraints is satisfiable. Case 5 checks if a constraint belongs to a set of constraints. Case 6 checks if $T$ is current time. Case 7 gives semantics to the keyword true. Case 8 holds when an possibly constrained, atomic formulae $constr\_formula$ is part of the state of affairs.

The semantics of the actions of a rule are now defined:

Case 1 decomposes a conjunction and builds the new state by merging the partial states of each update. Case 2 and 3 cater respectively for the insertion and removal of atomic formulae $\alpha$.

Relation $check_{prv}$ checks if there is no prevent-rule that has been violated, i.e., it is not the case that all the conditions of any prevent-rule hold in the state of affairs $\Delta^{\prime}$. It checks whether $\Delta^{\prime}$ contain all the conditions of each prevent-rule or not, if $\Delta$ also contain the given conditions.

Relation $can\_fire$ checks whether the conditions of a given if-rule hold and the rule after applying substitution $\sigma$ has not been already fired.

Relation $resolve$ determines the rule that will be fired by selecting the first rule in the list.

Relation $select\_rule$ determines the rule that will be fired by selecting all the rules that can fire and resolving the conflict with relation $resolve$.

Relation $\mathbf{s}_{if}$ determines the new state of affairs after applying a set of if-rules to a initial state of affairs taking into account a set of prevent-rules.

Relation $ignored$ determines that a set of events which occurred have to be ignored taking into account a list of ignore-rules.

Relation $\mathbf{s}^{\prime}_{r}$ uses $\mathbf{s}_{r}$ first and then $\mathbf{s}_{if}$ in order to activate the forward chaining.

Relation $\mathbf{s}_{eca}$ calculates the new state of affairs $\Delta^{\prime}$ from an initial state $\Delta$ and a set $\Xi$ of events that occurred applying a list of ECA-rules, if-rules, ignore-rules and prevent-rules.

Relation $\mathbf{s}_{force}$ calculates the new state of affairs $\Delta^{\prime}$ and the new set $\Xi^{\prime}$ of occurred events from an initial state $\Delta$ and a set $\Xi$ of events that occurred applying a list of if-rules, ignore-rules, prevent-rules and force-rules.

Relation $\mathbf{s}^{*}$ calculates the new state of affairs $\Delta^{\prime}$ from an initial state $\Delta$ and a set $\Xi$ of events that occurred applying a list of ECA-rules, if-rules, ignore-rules, prevent-rules and force-rules.

In this section we introduce how to use $\mathcal{I}$ rule-language for modelling Artificial Neural Networks. We start with the more simpler unit of processing in Artificial Neural Networks, i.e. Perceptrons.

We will rely on two special type of events, inputs specified as $i(x_{i},l_{j})$, with the intuitive meaning that an agent provided $x_{i}$ as the input for layer $l_{j}$; and outputs specified as $o(x_{i},l_{j})$ with the intuitive meaning that $x_{i}$ is an output for $l_{j}$.

Continuing the work from [3], an extension that easily could pop up, when analysing the language and the problems one might want to solve, is the online rule-management, i.e. the possibility of adding and removing rules on runtime. Thus, agents by means of events, and if they are accepted as valid actions, could trigger the institutional rule actions declared previously.

As for the implementation of the extension, rules are defined as $dynamic$ Prolog clauses, as with the $\tt fired/1$ clause declared as $\tt dynamic$ after the initial comments of the code in the Appendix.