User interface for machine learning model restructuring

Abstract

Described is a system for a user interface enabling restructuring of a machine learning model by accessing a machine learning model, generating a user interface depicting a graphical representation of the machine learning model, presenting the user interface to a user. The system receives a selection from the user of the user-selectable interface element, and in response to the selection from the user of the user-selectable interface element: restructures the internal architecture of the machine learning model causing a change to a number of nodes or a number of connections in the first group of nodes, generates an updated user interface depicting a graphical representation of at least the restructured portion of the machine learning model, and presents the updated user interface to the user.

Description

USER INTERFACE FOR MACHINE LEARNING MODEL RESTRUCTURINGTECHNICAL FIELD

[0001] The present disclosure relates generally to machine learning and, more particularly, to a user interface of restructuring machine learning models.BACKGROUND

[0002] Machine learning models are models performed on computer hardware and are designed to enable models to learn from data and make predictions or decisions without explicit programming. These models utilize statistical methods, mathematical optimization, and pattern recognition to identify patterns and relationships within data, allowing them to generalize and adapt to new information. Machine learning models are widely used across various domains, such as image and speech recognition, natural language processing, recommendation systems, and anomaly detection. In traditional models, the model is trained using historical and labeled information, and then, the trained model is applied to new unlabeled data to generate inferences.BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS

[0003] Some non-limiting examples are illustrated in the figures of the accompanying drawings in which:

[0004] FIG. 1 illustrates a network architecture of a machine learning model, according to some examples.

[0005] FIG. 2 illustrates a network including first node, second node, and third node, according to some examples.

[0006] FIG. 2 - FIG. 6 illustrate frames in an animation for the user interface displaying signals passed from node to node via connections, according to some examples.

[0007] FIG. 7 is a flowchart of a method for restructuring of an internal architecture of a machine learning model using a user interface, according to some examples.

[0008] FIG. 8 illustrates a user interface that displays a portion of the machine learning architecture and enables users to restructure the architecture, according to some examples.

[0009] FIG. 9 illustrates creation of a new node in a group of nodes based on asymmetrical division, according to some examples.

[0010] FIG. 10 illustrates creation of a new node in a group of nodes based on symmetrical division, according to some examples.

[0011] FIG. 11 illustrates deleting a node from the group of nodes, according to some examples.

[0012] FIG. 12 illustrates the creation of a new connection within a group of nodes, according to some examples.

[0013] FIG. 13 illustrates a machine learning model performing different functions across nodes in different groups of nodes, according to some examples.

[0014] FIG. 14 illustrates a machine learning model performing functions on an entire group of nodes, according to some examples.

[0015] FIG. 15 illustrates a machine learning model activating or deactivating an entire group of nodes, according to some examples.

[0016] FIG. 16 illustrates merging of two groups of nodes, according to some examples.

[0017] FIG. 17 illustrates splitting of one group of nodes into two groups of nodes, according to some examples.

[0018] FIG. 18 illustrates interchanging groups of nodes, according to some examples.

[0019] FIG. 19 illustrates rerouting of groups of nodes, according to some examples.

[0020] FIG. 20 illustrates a split screen user interface, according to some examples.

[0021] FIG. 21 illustrates a sequence showing restructuring of a network of a machine learning model over time, according to techniques described herein.

[0022] FIG. 22 illustrates initial values of weights of a node of a network, according to some examples.

[0023] FIG. 23 illustrates initial values of weights of the Bo submatrix, according to some examples.

[0024] FIG. 24 illustrates differentiated values of weights of the Bo submatrix, according to some examples.

[0025] FIG. 25 illustrates initial values of weights of the Bi submatrix, according to some examples.

[0026] FIG. 26 illustrates differentiated values of weights of the Bi submatrix, according to some examples.

[0027] FIG. 27 illustrates initial weight values and three different sets of differentiated values of weights of the B matrix, according to some examples.

[0028] FIG. 28 illustrates a machine-learning pipeline, providing context for examples described herein.

[0029] FIG. 29 illustrates training and use of an example machine-learning program, providing context for examples described herein.

[0030] FIG. 30 is a diagrammatic representation of a machine in the form of a computer system within which a set of instructions may be executed to cause the machine to perform any one or more of the methodologies discussed herein, according to some examples.DETAILED DESCRIPTION

[0031] Traditional machine learning models have several pitfalls that hinder the model's ability to adapt and grow. Traditional machine learning models have a fixed architecture in terms of number of layers, nodes per layer, and connections that is engineered in advance and reused across problems and environments. However, such fixed architectures arenot flexible and may not map well to the structure of the problem at hand.

[0032] Traditional models have fixed architectures that are designed manually. The number of layers, nodes per layer, and connections are predefined and do not change during training or inference. This limits the model's flexibility.

[0033] Moreover, users cannot see how data flows through the model. Even if users could, traditional systems would simply display floating-point values without giving useful information that users can apply. The lack of visibility into the internal structure makes debugging and optimization difficult. With no visibility into the layers and nodes, the model's predictions are opaque blackbox outputs. This limits explainability and interpretability.

[0034] Examples of machine learning models described herein mitigate or eliminate the pitfalls of traditional systems as described above. The Artificial Intelligence (Al) system described herein allows users to dynamically modify the architecture via a user interface, such as by adding or removing nodes and layers as needed. In some cases, such dynamic architecture changes are made without retraining the entire model from scratch. For example, the user views the machine learning model in run-time and can see data passing from node to node and can make instant architectural changes on the fly. The machine learning model continues to pass data with the modified internal architecture. The interface provides an intuitive way for users to explore different architectures.

[0035] The Al system provides internal visibility of the model by visualizing data flow through nodes and layers. This provides insight into model behavior and enables debugging by inspecting intermediate outputs.

[0036] By displaying the model topology and data flows, the Al system makes the model architecture understandable for users. Users can see how data is being transformed as it passes through various nodes andgroups of nodes (e.g., layers). The interactive visualization demystifies the internal workings of the machine learning model.

[0037] The Al system enables users to create specialized nodes with distinct roles based on connectivity and behavior. Related nodes can also be grouped or merged together, well performing nodes can be duplicated, poor performing nodes can be deleted, or the like. The user interface displays characteristics of nodes or layers, such as performance characteristics, guiding the user to make appropriate changes to the model.

[0038] The Al system enables users to define conditional routing logic that alters data flows between node groups based on real-time external data. The model becomes context-aware and adaptable. Moreover, the Al system enables rapid topology changes via the interface to determine optimal arrangements of nodes and layers. Users can actively refine the architecture in real time.NODES AND CONNECTIONS OF A MACHINE LEARNINGMODEL

[0039] FIG. 1 illustrates an example of a three-node machine learning model, according to some examples. The network includes a set of nodes, shown as node 102, second node 104, and third node 106. The nodes are connected to each other by unidirectional connections, shown as first connection 108 (from node 102 to second node 104) and second connection 110 (from second node 104 to third node 106). Each connection conveys or designates outputs of a transmitting node as inputs to a receiving node.

[0040] The connections for which a given node is a transmitting node may be referred to as outgoing connections of that node; by the same token, those connections for which a node is the receiving node may be referred to as incoming connections of that node. In network, the transmitting node of first connection 108 is node 102, and the receiving node of first connection 108 is second node 104; the transmitting node of second connection 110 is second node 104, and the receiving node of second connection 110 is third node 106.

[0041] The nodes of the network (and other networks of machine learning models described herein) may be described herein as receiving inputs, processing data, and generating outputs. Similarly, the connections of the described networks may be described as conveying, transmitting, or providing data from one node to another node. In some examples, these terms may refer to the operation of nodes or connections, which may be embodied as logical circuit components or other physical components configured to perform data processing, data communication components, or both. For example, the nodes and connections of a network of a machine learning model as described herein may be implemented as circuit components of a field programmable gate array (FPGA) or another dynamically reconfigurable logical circuit.

[0042] However, in some examples, the nodes, connections, or both are implemented as data, for example, as data structures, instructions, or any suitable combination thereof, stored in a memory and manipulated by a physical processor. The machine described herein provides an example of a computing system suitable for such an implementation. For example, a node may be implemented as a data structure associated with one or more parameters (e.g., weights, as described below), and processing the inputs of a node to generate the node's outputs may be performed by the physical processor processing the parameter values (e.g., priors) of the node and the inputs of the node to generate the outputs of the node.

[0043] A connection may be implemented as data designating or identifying a relationship between a transmitting node and a receiving node, such that the outputs of the transmitting node are treated by the physical processor as inputs to the receiving node. In some examples, the nodes, connections, or both may include instructions executed by the processor to perform these operations, whereas in other examples, the instructions are separate from the nodes and connections, and cause the processor to process the data corresponding to the nodes and connections. It will be appreciated that all references herein to a node processing data, to a connection conveying data, and so on, are all intended to encompass all suitable implementations of the nodes or connections as any combination of hardware or software.

[0044] A connection may be implemented as data designating or identifying a relationship between a transmitting node and a receiving node, such that the outputs of the transmitting node are treated by the physical processor as inputs to the receiving node. In some examples, the nodes or connections may include instructions executed by the processor to perform these operations, whereas in other examples, the instructions are separate from the nodes and connections, and cause the processor to process the data corresponding to the nodes and connections. It will be appreciated that all references herein to a node processing data, to a connection conveying data, and so on, are all intended to encompass all suitable implementations of the nodes or connections as any combination of hardware or software.

[0045] In some examples, the nodes of the network operate to process their inputs and generate their outputs at each of a sequence of time steps. In some examples, all nodes of the network operate at each time step; in other examples, some nodes may have different rates of operation such that some nodes of the network may only process their inputs and generate (or update) their outputs at some time steps, such as every n time steps or at different intervals, where n is a positive integer.

[0046] In some cases, the network operations continuously, performing continuous-time inferences. For example, the Al system operates analog machines running the algorithms which can continuously perform inferences in a floating-point time delay tefor node e.

[0047] In some examples, a node generates its outputs at a current time step t by processing its inputs at a previous or prior time step M. The inputs may be processed by applying various parameters or weights, such as matrices of weights, to the inputs, and computing one or more output values based on the weighted inputs. In some examples, a node may generate only a single output value that is conveyed as an input to all connected nodes; in other examples, a node may generate multiple outputs to be conveyed to multiple connected nodes or as multiple output values conveyed to a single node.

[0048] In some examples, a single output generated by a node may be an activation value. An activation value may include a measure of how active the node is at the current time step based on its inputs from the previous time step. In some examples, the activation value may be continuous (such as a floating point value) - such as in an artificial neural networks such as CNNs, in which a given node (e.g., an artificial neuron in an artificial neural network) generates a floating-point output activation value as part of an activation map generated by the neural network layer inhabited by the neuron.

[0049] In other examples, the activation value of a given node may be discrete, such as a binary value (e.g., 0 or 1, corresponding to inactive or active, or “not firing” and “firing” in the context of an analogy of neuronal firing). The discrete activation value may be determined by either a stochastic quantization process or a deterministic quantization process. In a stochastic quantization process, for example, a probability distribution over all possible discrete output values may be generated by processing the weighted inputs, and a random or pseudo-random value may be used to select a discrete output value (or set of output values) from the probability distribution. In a deterministic quantization process, a single discrete output value (or set of output values) may instead be selected from the probability distribution as the value or values having the highest probability.

[0050] In some examples, nodes may have connections to themselves, referred to as self-connections, in which they serve as both transmitting node and receiving node. In some such examples, a node may generate a single or multiple outputs for propagation to its connected nodes, and another output or set of outputs to itself, called self-outputs (or selfsignals, or self-inputs), via its self-connection(s). In some cases, the node has the same number of self-connections as connections with other nodes. In some examples, a node may pass through its current inputs, or a computation performed on its current inputs, as self-outputs, thereby providing a one-time-step memory of its own inputs or processed inputs. In some cases, the node performs certain computations (as further described herein) on the inputs before sending another self-signal. Thismay enable the node to evaluate the accuracy of its own previous predictions of state transitions of the observed system.

[0051] It will be appreciated that the three-node network shown in FIG. 1 is intended as a simplified example, and that actual machine learning models may include networks having much larger number of nodes, such as thousands or millions of nodes. Thus, the network may be regarded as a small section of a larger network, in which one or more of the illustrated nodes 102, 104, or 106 may have connections to or from one or more other unseen nodes of the larger network. In one such example, in the context of CNNs, the node 102 could be regarded as a neuron of a convolution layer, the second node 104 could be regarded as a neuron of a rectified linear unit (ReLU) layer receiving an activation outputs map from the convolution layer, and third node 106 could be regarded as a neuron of a pooling layer receiving the ReLU layer output.

[0052] In some cases, the network includes one or more cycles. Cycles include a plurality of unique nodes in an ordered sequence, each node of the sequence sharing a connection with a next node in the sequence, and a final node of the sequence sharing a connection with an initial node of the sequence. In some cases, the network includes a directed graph having no directed cycles, understood as a plurality of unique nodes in an ordered sequence, each node of the sequence having a connection (in this case, a directed connection) to a next node in the sequence, and a final node of the sequence having a connection to an initial node of the sequence. The output of each node is propagated in a forward direction from node 102 to second node 104 to third node 106 without any feedback to previous nodes. In some cases, the network includes a mix of directed networks and cycles.

[0053] The network includes a third connection 112 that is added from third node 106 to first node 102 to create a cycle. In some examples, the new connection (e.g., third connection 112) is added to the network after the model has been generated and at least partially trained, during a runtime period in which the machine learning model, including the network, has been deployed to repeatedly perform the inference task forwhich the machine learning model has been trained. By adding a new connection and thereby forming a new cycle during runtime, the operation of the network may be reconfigured dynamically while performing an inference task, thereby potentially enhancing the performance of the machine learning model to perform its inference task or dynamically adapting the machine learning model to new conditions, e.g., new types of input data that benefit from adding cycles to the network.

[0054] In some examples, instead of adding a new connection to the network, a connection may be removed from the network. As with adding a connection, in some examples, the previous connection (e.g., third connection 112) is removed from the network after the model has been generated and at least partially trained, during the runtime period. By removing a connection and thereby removing a cycle during runtime, the operation of the network may be reconfigured dynamically while performing the inference task, thereby potentially enhancing the performance of the machine learning model or dynamically adapting the machine learning model to new conditions. In some examples, removing even a small subset of the connections within a highly-connected network may dramatically reduce resources used by the machine learning model, such as storage, memory, processor, and power usage.

[0055] Thus, various examples described herein may add or remove connections of a network. Such addition or removal of a connection may be referred to collectively as changing presence of the connection.

[0056] In some cases, the system causes display of a user interface displaying at least a portion of the machine learning model. For example, the system displays the nodes 102, 104, and 106, and connections 108, 110, and 112. In some cases, the system displays nodes, connections, groups of nodes (further described herein), the overall network, or a subset of the network and corresponding characteristics. For example, FIG. 1 illustrates that node 106 has higher self-efficacy than node 104, and node 104 has higher self-efficacy than node 102.

[0057] The user interface of FIG. 1 displays such characteristics with bolding, where node 106 has greater thickness than node 104, and node 104 has greater thickness than node 102. In some cases, the user interface shows characteristics of nodes via color such as a color scale or gradient to encode numeric values, red and green colors for binary states, or the like.

[0058] In some cases, the user interface shows characteristics of nodes via size, such as scaling node size based on a numeric characteristic or making important nodes larger. In some cases, the user interface shows characteristics of nodes using shapes, such as making distinct node shapes for different categories.

[0059] In some cases, the user interface shows characteristics of nodes using animation, such as a pulsing animation to show an activity level, spinning speed to indicate computational load, or the like. In some cases, the user interface shows characteristics of nodes using text labels where numeric values or statistics are displayed in text. In some cases, the user interface shows characteristics of nodes using progress bars, such as linear bars to show a percentage or normalized values.

[0060] Although the application is described as showing characteristics of nodes or in some cases of groups of nodes, it is appreciated that the features described herein can be applied to nodes, layers, groups of nodes, the entire network, or another subset of the network. For example, the user interface can show a computational load characteristic for a particular node, a self-efficacy metric for a group of nodes, and a latency for the entire network.

[0061] In some cases, the machine learning model identifies the characteristic for a particular node. In some cases, the machine learning model identifies the characteristic for a subset or all of the nodes in a group of nodes. In some cases, the machine learning model identifies the characteristic for each node in the machine learning model or for an individual node.

[0062] In some cases, the machine learning model determines a characteristic for a plurality of nodes (e.g., in a group or in the entiremodel) and determines an overall characteristic, such as based on a sum, an average, or other derived metric. In some cases, the characteristic is of a specific node. In some cases, the characteristic is a relative metric of a node or group of nodes compared to another node or group of nodes.

[0063] In some cases, the machine learning model identifies that a second node is connected with the first node via a connection. The machine learning model determines a characteristic of the first node that includes an indication of self-efficacy indicative of a measure of the first node’s output to affect the second node’s output.

[0064] This characteristic involves analyzing the self-efficacy between two connected nodes. Self-efficacy refers to how much a node believes its own outputs affect the outputs of another connected node, and indicates how influential the node perceives itself to be to its neighbor. The self- efficacy metric of a first node measures the outputs of the connected nodes to the first node. This self-efficacy measure can be determined by the machine learning model based on the first node's generative model, such as the B tensor which captures its beliefs about state transitions (further described herein).

[0065] If the first node has high self-efficacy towards the second node, the first node believes its outputs significantly influence the second node. Low self-efficacy corresponds to the first node believing it has little influence on the second node. This characteristic could trigger adding or removing of nodes. For example, the machine learning model can add new nodes between the first and second nodes if their self-efficacy is low, since new nodes may improve information flow. In some cases, the machine learning model triggers removing nodes if self-efficacy is very high or if the nodes are redundant.

[0066] In some cases, the self-efficacy is a measure of the first node’s output at a previous time step T-1 to affect the second node’s output at a current time step T. The self-efficacy indicator can include metrics of the causal relationship over time between the two nodes' outputs.

[0067] In some cases, the first node’s output at the previous time step T-1 is transmitted back to the first node as an input at the current time step T.The output the first node at time T-1 can also be looped back to become input to the first node at time T. This allows the first node to compare what it actually observes at time T to what it predicted it would observe at time T-1, based on the output it sent.

[0068] In some cases, the indication of self-efficacy is based on a VFE or EFE of the first node with respect to the connection with the second node. A low indication or value of the variational free energy corresponding to high self-efficacy of the connection, and vice versa. Variational free energy can include a measure of difference between one or more preferred inputs of the first node and the one or more actual inputs received by the first node.

[0069] Although examples described herein refer to applying VFE, it is appreciated that the features described herein apply also to EFE, and vice versa. For simplicity of the disclosure, some examples are described as applying VFE or EFE.

[0070] In some cases, the machine learning model determines an indication of self-efficacy for two nodes that are connected with each other. Such self-efficacy determination can be performed for all or at least a subset of the nodes that are interconnected in a pairwise manner (2 connected nodes).

[0071] In some cases, the machine learning model identifies a characteristic that includes an indication of self-efficacy for the first node with all other connected nodes. The machine learning model, in addition to measuring the self-efficacy between the first node and second node, further measures the self-efficacy between the first node and all of its other connected nodes. This provides a more holistic view of the first node's perceived influence over its local neighborhood.

[0072] In some cases, the characteristic is related to connections, and the value includes a number of connected nodes with a particular node. For example, multiple nodes are connected with the first node via connections. In some cases, the value includes a count of the total number of nodes that the first node is connected to directly. This provides information on how densely the first node is connected withinthe network. The Al system can prune nodes to reduce computational load on certain nodes with high density.

[0073] In some cases, the characteristic includes a total number of nodes in a certain group of nodes or the entire network. For example, the machine learning model can decide to prune a group of nodes once the group of nodes exceeds a certain threshold number of nodes.

[0074] In some examples, the characteristic includes a relative number of nodes in a group of nodes compared to other groups in the network. For example, the characteristic includes a group of nodes that has the largest number of nodes or the value includes a number of nodes greater than other groups of nodes (e.g., how many more nodes does the biggest group have as compared with the second biggest group).

[0075] In some cases, the value includes a count of how many computational operations the first node performs during a single inference pass through the network. This provides information on the node's computational load. The machine learning model can decide to split a node in a group of nodes or add a new node or delete one or more nodes to distribute computational load.

[0076] In some cases, the characteristic comprises a latency metric. The latency metric can include a time delay from receiving input node data and generating output node data for a particular node. Longer latency could indicate the node needs more computational resources and the machine learning model can decide to restructure the architecture accordingly.

[0077] In some cases, the characteristic includes a characteristic of the first and second node. Here the decision to restructure the architecture depends on a characteristic and value measured on a second node in addition to the first node. In some cases, the second node is part of the same group as the first node. In other cases, the first and second node are not part of the same group.

[0078] In some cases, the characteristic includes a historical metric of a node. The characteristic can include how many inferences a node has processed, how differentiated, aligned, or synchronized the node hasbeen, how long the node has been differentiated, aligned, or synchronized (as further described herein) with its neighbors, or the like. Older nodes that have become too specialized (differentiated) over time may need to become more de-differentiated to improve adaptability. This could involve adding new less-differentiated nodes or removing older differentiated nodes.

[0079] In some cases, the characteristic includes a determination on how well the network performs on new input data, such as with new or different scenarios. For example, the system determines that a node or group of nodes perform well under certain conditions but not in other conditions (such as other environments). The machine learning model can expand the group size by adding nodes to provide greater adaptability to handle new data or environments the system hasn’t seen before.

[0080] In some cases, the characteristic is how overfit the node or group of nodes are. If the group of nodes is overfit to past data, changing the number of nodes can help reduce overfitting. Overfitting occurs when a machine learning model performs very well on the data it was trained on, but fails to generalize well to new, unseen data. This often happens because the model ends up modeling noise and random fluctuations in the training or historical data, rather than just learning the true underlying patterns, or when there are too many or too few parameters in the model relative to the amount of training or historical data. Having different numbers of nodes and connections gives the network enough flexibility to memorize properties of the training or historical data that won’t generalize.

[0081] The machine learning model can delete nodes to combat overfitting because it reduces the number of parameters in the model. Fewer nodes means fewer weights and connections, which also means there is less space available for the network to pick up on spurious patterns and noise in the training data. With fewer parameters, the network is forced to learn more robust representations of the training data in order to still fit it well. The smaller network can generalize better because it can’t rely onmemorization as easily. In some cases, a network can be too small and in response, the machine learning model can add notes in response to sub- optimal fitting.

[0082] In some cases, the characteristic includes a number or pattern of connections to the node being analyzed. For example, if a node has a very high number of connections to other nodes, the machine learning model can delete some connections to reduce computational burden or delete the node itself or a neighboring node.

[0083] In some cases, the characteristic includes a sensitivity or robustness to noise. If performance degrades significantly due to noise, adding more nodes could improve robustness. Machine learning models can sometimes suffer degraded performance when their inputs contain noise or variability. For example, an image classifier can perform worse or better if the input images are grainy or blurred. In some cases, the machine learning model measures this noise sensitivity for a node or group of nodes by comparing its performance on clean data vs increasingly noisy data. The more the performance drops off, the less noise robust that group of nodes is.

[0084] In some cases, for an individual node, the machine learning model adds random noise to its inputs and assesses how much the nose perturbs the node’s output. Nodes that are highly sensitive will show large changes in output. Noise robustness is important for real-world deployment of machine learning models, such as for self-driving cars that need to handle rain, blurry footage, etc.

[0085] In some cases, the characteristic includes an indication of similarity in outputs of two nodes, such as two nodes consistently producing similar outputs. In a machine learning model, sometimes two nodes in the same group of nodes will consistently produce very similar outputs across many different inputs. This output similarity can be measured by looking at the correlation, covariance, or other statistical relationships between the two nodes’ output vectors over a set of data or over a certain period of time.

[0086] If two nodes have a very high degree of output similarity, such as a correlation coefficient over 0.95, this could indicate redundancy between the nodes. In such a case, one of the redundant nodes in the group of nodes could potentially be removed to increase efficiency and reduce computational requirements, without significantly impacting model performance. The remaining node would preserve most of the information from both original nodes. In other cases, the machine learning model connects the two nodes with a degree of output similarity, further enhancing self-efficacy and differentiation in the network. In other cases, the machine learning model combines or averages the prior parameters of the two nodes and combines them into a single node.

[0087] In some cases, the characteristic includes a system platform metric, such as a memory constraint, energy usage, available computing resource, or the like. Machine learning models can consume substantial computing resources. The demands on memory, energy, and computing can become constraints. Moreover if the machine learning model is being deployed on embedded or mobile devices, there may be strict limits on memory and power consumption. Even high-end GPUs have finite memory and energy capacities.

[0088] During runtime, the utilization of these resources by each group of nodes could be monitored, for example: a parameter size of weights / activations for a group of nodes to determine memory usage, a number of operations performed by a group of nodes to determine energy usage, the time required to complete an iteration or computation by a particular group of nodes to determine compute time, or the like.

[0089] If a certain group of nodes is consuming disproportionate amounts of resources relative to other group of nodes, this imbalance could negatively impact overall system performance. In this case, the machine learning model can reduce the size of the high-consumption group of nodes by deleting nodes to even out resource utilization across the network.

[0090] In some cases, the characteristic includes a data volume metric, such as a surge of data into a node, a group of nodes, from the environment, orthe like. In real-world deployments, the volume of data being fed into a machine learning model can fluctuate over time. For example, a spike in users could cause a surge in data flowing into a machine learning model.

[0091] If the model architecture was static, this data surge could overwhelm parts of the network. Certain groups of nodes might become under-provisioned if they suddenly have to process 2x or 3x more data points per batch. However, with the dynamic architecture described herein, the machine learning model detects when input data volume increases beyond normal levels based on metrics such as batch size, samples per second, or total records processed in a timeframe.

[0092] These metrics (such as data surge and other metrics and characteristics described herein) meeting certain thresholds can trigger architectural changes. For example, when a data volume surge is detected, the machine learning model increases a number of nodes in a group of nodes to handle the extra workload, providing the network with more parallel processing power.

[0093] This dynamic scaling allows the network to automatically adapt its computational resources to match the current demands. The model remains stable and performant even as upstream data volume fluctuates. Once the surge passes, the extra nodes can potentially be pruned away.

[0094] In some cases, the characteristic is an indication of “anxiety” or “stress” of a node. In active inference models, “anxiety” arises when a node is uncertain which of its potential actions will lead to the best outcome. This uncertainty stems from the node’s generative model not accurately reflecting the environment. “Stress” occurs when the agent didn’t get what it wanted - there is a mismatch between expectations and observations. In some cases, even with low uncertainty, not obtaining expected outcomes is stressful.

[0095] A machine learning model estimates a node’s uncertainty based on how confident it is in predicting what inputs it will receive after taking various actions. In some cases, a new node has maximum uncertainty, with a uniform probability distribution over all possible transitions between states.

[0096] As the node learns through experience and inferences, the node updates its generative model to better match the environment. This increases confidence in state transition predictions, reducing uncertainty. However, even a confident node can experience stress if its expectations don’t synchronize with actual observations. For example, if the node expects input “1” but keeps observing “0”.

[0097] The machine learning model can add more nodes in response to stress or uncertainty meeting a certain threshold. The new nodes provide extra modeling power to reduce uncertainty and synchronization expectations with observations.

[0098] In some cases, the characteristic includes a new environment connection or node. In other cases, the characteristic includes disconnecting an existing environmental node from the model, a group of nodes, or a node.

[0099] In the machine learning model, at least one node directly interfaces with the external environment to receive data. If the environment changes by introducing new data sources, such as adding a new sensor to a robot, this may require adding new input nodes to handle the extra data dimensions. For example, if a self-driving car previously had camera and Lidar data, adding radar data would require new radar input nodes to process the new signal.

[0100] Conversely, if an environmental signal becomes unavailable, like a sensor failing, the associated input nodes could be disconnected or removed entirely. For example, if the camera fails in the self-driving car, the machine learning model can restructure the network to remove the now-useless camera nodes.

[0101] These environmental changes directly alter the input data distribution being fed to the network. The machine learning model adapts to maintain modeling power and make efficient use of inputs. Further, environmental changes propagate to other nodes as well. Adding new data types may require new processing in other groups of nodes to fully utilize the new input. Moreover, removing input nodes could allow pruning redundant group of nodes that were only processing those inputs.

[0102] In some cases, the environmental input changing characteristics, which may trigger the machine learning model to dedifferentiate to relearn the new environment. In a machine learning model, the input node receives data from the external environment. This environmental input provides the raw signals that drive the model’s inferences and predictions.

[0103] Over time, the model learns correlations and patterns in the input data distribution. Groups of nodes will differentiate to detect specific features and dynamics in the inputs.

[0104] However, if the environment changes significantly, the input data characteristics may shift outside the distribution that the model originally learned on. For example, a weather prediction model may be trained on years of historical data, but new climate change effects may introduce novel weather patterns that the model has not seen before. In this situation, the model’s internal representations in the groups of nodes may no longer match the new environmental inputs. The model would become less capable of accurate inference.

[0105] To adapt, the machine learning model could trigger dedifferentiation, meaning the group of nodes shed some of their specialized representations and return to a more generic, stem-like state. This reopens the ability for those groups of nodes to relearn based on the new environmental inputs. With dedifferentiated nodes, the model can recorrelate and identify new salient features in the shifted input data distribution.

[0106] In some cases, the characteristic includes a metric of how well a group of nodes is performing relative to other group of nodes. In an example machine learning model, each group of nodes transforms and passes along data to another node or another group of nodes. Ideally, the representations passed between adjacent groups of nodes are properly synchronized. However, one group of nodes’ outputs could become mismatched with the following group of nodes’ expectations. For example, if the distribution of data passing from group A to group Bshifts significantly, group B’s nodes may need architectural changes to resynchronize with the new inputs.

[0107] The machine learning model assesses metrics such as activation statistics, weight norms, and entropy to quantify synchronization between groups of nodes. Cross-group divergence in these metrics may indicate desynchronization.

[0108] In response, the machine learning model can add or prune nodes in desynchronized group of nodes to rebalance representations across group of nodes. For example, group A could reduce dimensionality while group B increases nodes to reconstruct richer representations. This coadaptation of groups of nodes based on their relative synchronization allows the network architecture to dynamically tune itself as internal representations shift during runtime.

[0109] In some cases, the machine learning model triggers architectural changes on a fixed schedule. For example, groups of nodes are pruned or regrown periodically at every time period. Regular pruning forces redundancy, low self-efficacy, stress, or the like out of the network and rebuilding allows new representations to form. This constant architectural churn can improve generalization.

[0110] In some cases, the machine learning model triggers architectural changes on a changing schedule, such as starting with slow large changes and progressing to faster small changes.[OHl] In some cases, the function performed by a group of nodes is tied directly to the characteristic used to determine if the architecture should be restructured. For example, the first group of nodes performs a first function of the machine learning model and a value is identified for a characteristic of the nodes in the first group. This characteristic corresponds to the first function that the first group performs. If the value meets a threshold, the number of nodes in the first group is changed. When the function and characteristic are associated, the value being evaluated is a property of how well the nodes are performing their intended function.

[0112] For example, in a speech recognition model, the input audio processing group of nodes are restructured based on changing properties of the input audio data, such as background noise or accents. In another example, in a medical image diagnosis model, the group of nodes performing lesion detection are modified based on metrics about lesion identification accuracy. In yet another example, in a weather forecasting model, the atmospheric data preprocessing group of nodes are altered based on the distribution of temperatures and precipitation. The function of the group of nodes ties directly to the relevant characteristic.

[0113] In some cases, the characteristic is not directly related or not at all related to the group of nodes’ function. For example, characteristics such as measuring overall latency of the model, checking available memory or computational resources, considering new data sources or environmental inputs, enforcing diversity via random pruning / regrowth, or the like are not directly related to a collective function that the group of nodes perform.

[0114] Additional examples where the characteristic is not related to the group of nodes’ functionality are in (1) an autonomous vehicle model where the group of nodes are pruned and regrown on a fixed schedule to enforce diversity, independent of any group’s functional performance, (2) in a product recommendation model where a group of nodes are expanded to utilize additional available GPU memory for capacity not based on recommendation performance, (3) in a malware detection model where group of nodes analyzing raw byte input are restructured due to new types of malware data, unrelated to the group of nodes’ intended feature extraction role, or (4) when the Al system is pruning or expanding the network due to network latency increases or hardware failures.

[0115] Nodes or groups of nodes can perform certain functions for the machine learning model. For example, a group of nodes can perform input representation encoding raw data into a suitable format, feature extraction transforming input data to higher level features, classification or regression producing predictions based on learned features, localfeature extraction, pooling, down or up sampling, object localization, or the like.NETWORK WITH NODES CONNECTED TO THEENVIRONMENT

[0116] FIG. 2 illustrates a further example network, including first node 202, second node 204, and third node 206. In network, the connections between nodes are in bidirectional pairs: first connection 208 from first node 202 to second node 204 and first connection back 214 from second node 204 to first node 202; and second connection 210 from second node 204 to third node 206 and second connection back 216 from third node 206 to second node 204, and a third connection 212 from the third node 206 to the first node 202 and the third connection back 218 from the first node 202 to the third node 206.

[0117] The network also shows first node 202 having a bidirectional pair of connections to an environment 220: a connection 222 from environment, and a connection 224 to environment. In some examples, the environment 220 can represent an entity outside of the network, such that a node connected to the environment 220 (such as first node 202), also referred to as an environment-facing node, acts as an input node or an output node for the network. The connections to or from the environment 220 may act as connections to another node insofar as they convey inputs to, or receive outputs from, the environment-facing node.

[0118] In some cases, the node sends a self-message to itself. For example, node 206 sends a self-message 226 to itself. In some cases, the node can send multiple messages to itself, such as the same number of selfmessages as other input messages from other nodes or environments. For example, node 204 sends a self-message 228 to itself for the input message from node 202. In some cases, node 204 sends two selfmessages to itself based on the number of connected nodes, such as nodes 202 and 206.

[0119] In some examples, a network with bidirectional pairs of connections may be configured to perform inference according to the principles of active inference and the minimization of variational free energy (VFE).In some cases, inferences are performed based on Expected Free Energy (EFE), which is a measure of the free energy of the future. Active inference is a framework for modeling Bayes-optimal behavior of an agent. In some cases, an agent - such as a machine learning model, or even a node of a network driving the behavior of the machine learning model - acts to minimize the “surprise” resulting from the agent’s observations. Surprise can include pragmatic or epistemic terms (as further described herein). In some cases, surprise includes a measure of the degree to which an agent’s current observations differ from its preferred observations. In most active inference frameworks, agents seeking to minimize their surprise act on the observed system to solicit feedback that accords with the agent's desired observations: this activity of the agent is why the framework is referred to as “active” inference.

[0120] The active inference framework proposes that, even if an agent does not have the capability to directly minimize its surprise, it can at least seek to minimize a proxy for surprise, called variational free energy. The agent may minimize VFE by performing computation in response to, and in anticipation of, its observations. Implementation of active inference thus rely on the free energy principle, by which an agent reduces its surprise by generating inferences using an internal model and updating its internal model to synchronize with the observed (and acted-upon) system.

[0121] In some examples, a network may be used to implement a machine learning model operating according to an active inference framework (also referred to as an active inference model). Each node of the network may be associated with parameters or weights organized into one or more tensors (e.g., scalars, vectors, or matrices), each tensor modeling a different aspect of the node's behavior.

[0122] In some examples, the active inference behavior of the nodes of the network may be modeled as a partially observable Markov decision process (POMDP), characterized by the equation:POMDP equation wherein:• “T” indicates the time step, from a first time step T=1 to a final (or current) time step T=T,• “ot” indicates the observations o of the node (e.g., its inputs) at a given time step i=t,• “st” indicates the actual state 5 of the observed system (e.g., a hidden state that may differ from the observations of the node) at time step i=t,• "K" indicates a policy for the node, e.g., a possible sequence of actions (e.g., outputs to generate in response to inputs) that the node can take, and• “(|)” indicates an expected reward, e.g., a similarity between inputs received by the node and the node's preferred inputs.

[0123] The active inference behavior of a node may be implemented using three to five sets of weights organized into four tensors.

[0124] Some examples described herein describe node alignment.However, it is appreciated that such features apply to synchronization, predictability, or coherence, and vice versa. For example, in an example describing node alignment between two nodes triggering restructuring of node topology, node synchronization, predictability, or coherence between the two nodes can also trigger restructuring of node topology.Generation of outputs

[0125] VFE is a computation based on a generative model (e.g., a set of priors learned by a node or other agent) and observations (e.g., inputs to a node or other agent). VFE provides an upper bound on statistical surprise. There are various mechanisms to minimize VFE, including updating the generative model to more closely align with observations, or performing a computation of expected free energy (EFE) across possible actions and selecting one of the actions which leads to the lowestexpected free energy. Operations involving the computation or minimization of EFE, as referred to herein, may be referred to as a computation or minimization of VFE.

[0126] To minimize EFE, a node may compute an expected distribution of free energy over multiple output states and select an output state that minimizes the expected free energy. The calculation of expected free energy may in some cases be affected by the node’s preferences (e.g., as represented by the C tensor), such that rows of the B tensor corresponding to preferred observations of the node are expected to result in lower free energy than non-preferred rows of the B tensor. Thus, the node will calculate EFE distributed over all possible output states, then select an output that is at or near the minimum value of the EFE distribution. When operating in a deterministic mode, the node may select the output value that directly minimizes EFE. When operating in a stochastic mode, the node may weight various output values based on their corresponding EFE, or their proximity to the minimum value of the EFE distribution, and stochastically select an output value from the weighted distribution of output values.

[0127] Thus, the node’s preferences (e.g., the values of the parameters in the C tensor) may affect the degree to which the node operates to minimize VFE, EFE, or a combination of both VFE and EFE. A node with uniform zero parameter values in the C tensor will have a close relationship between VFE and EFE, whereas a node with non-uniform parameter values in C will tend to exhibit EFE behavior that diverges from that predicted solely from VFE.Learning - Adjustment of B tensor priors

[0128] The prior values of the B tensor may be adjusted over a sequence of time steps to align the node with another node or a data source, such as the environment external to the network. After the node makes observations (e.g., inputs are accessed or received by the node) at a given time step, the priors of the node’s B tensor may be adjusted based on the currently observed input state, based on the observed input state at the previous time step, and based on the output generated by the node at theprevious time step. As described above, a columnar slice of the B tensor is selected based on the node’s inputs observed and its output generated at the last time step, and a column of priors of one of the B subtensors intersected by the columnar slice is selected based on the comparison of the priors of the various individual columns in the columnar slice. The priors of this selected column may then be adjusted in accordance with the currently observed input state, such that a higher prior is assigned to the prior in the row corresponding to the currently observed input state, and all other priors in the row are decreased accordingly.

[0129] In some examples, the degree to which the priors of the column are adjusted is in proportion to the number of observations of each input state over time: thus, for example, if the input state of row 3 has been observed at 32% of time steps, it will be assigned a prior value of 0.32. In other examples, different degrees of adjustment may be used, such as a degree of adjustment proportional to a learning rate that may vary under different conditions.

[0130] In some cases, the node’s preferences may affect the degree to which the priors of the column are adjusted. When a preferred row is observed, in addition to increasing the prior in the observed row and decreasing the other rows accordingly, all of the priors of the column may be adjusted to sharpen the distribution of prior values, such that high prior values are raised and low prior values are lowered, rendering the priors of the column less uniform. In contrast, when a non-preferred row is observed, in addition to increasing the prior in the observed row and decreasing the other rows accordingly, all of the priors of the column may be adjusted to partially flatten the distribution of prior values, such that high prior values are lowered and low prior values are raised, rendering the priors of the column more uniform. The partial flattening of the prior values may result in an increase in the effective learning rate for priors in the column in future time steps, because it is easier for a new observation to stand out relative to other observations when all older observations are relatively uniform. This increase in the effective learning rate after observing a non-preferred row may increase the likelihood or speed with which the node will reconfigure the priors of thecolumn, thereby potentially finding a more optimal set of priors that may assist in avoiding the non-preferred row in the future. By the same token, a slowed effective learning rate after observing a preferred row may reduce the likelihood or speed with which the node will reconfigure the priors of the column, thereby potentially locking the node more tightly into its current configuration.Stochastic mode vs. deterministic mode switching

[0131] In some cases, the node may switch between the stochastic mode and the deterministic mode based on the value of a stress parameter of the node that tracks the degree or frequency to which the node has predicted incorrectly over past time steps. The stress parameter may be adjusted downward on time steps when the node’s output predicts its target, and adjusted upward on time steps when the node’s output fails to predict its target. When the stress parameter value rises above a stress threshold, the node switches from the deterministic mode to the stochastic mode, and when the stress parameter value falls below the stress threshold, the node switches back from the stochastic mode to the deterministic mode. In some cases, two different stress thresholds may be used, such that a falling stress threshold for switching back to the deterministic mode is lower than a rising stress threshold for switching to the stochastic mode.

[0132] In some examples, the stress threshold (or the falling and rising stress thresholds) may be a further parameter stored by the node. In some examples, each stress threshold may be a learned parameter that is adjusted during the learning or alignment process to assist in minimizing VFE or EFE, as described herein with reference to adjustment of the priors of the B tensor.FRAMES FROM AN ANIMATION FOR A USER INTERFACE DISPLAYING SIGNALS PASSING THROUGH NODES IN THE MACHINE LEARNING MODEL

[0133] FIG. 2 - FIG. 6 illustrate frames in an animation for the user interface displaying signals passed from node to node via connections, according to some examples. FIG. 2 illustrates a user interface 234 thatis displayed to a user. The user interface displays the machine learning model whereby an external signal from the environment 220 is inputted into the model via connection 222. As shown in FIG. 2, the connection 222 is bolded to indicate a signal being passed from the environment 220 to node 202.

[0134] FIG. 3 illustrates node 202 processing the external signal received in FIG. 2, and sending outputs back to the environment 220 via connection 224, and to node 204 via connection 208 and to node 206 via connection 218, according to some examples.

[0135] FIG. 4 illustrates node 204 and node 206 receiving the signal from FIG 3. and processing the signal to output new signals. For example, node 204 sends a self-signal 228, and signals to node 202 via connection 214 and node 206 via connection 210. Node 206 also processes the signal and send a self-signal 226 and signals to node 204 via connection 216 and to node 202 via connection 212. The environment 220 also receives the signal from FIG. 3 and sends a response via connection 222.

[0136] FIG. 5 illustrates the outputs of nodes 202, 204, and 206 from the signals received from FIG. 4. FIG. 5 also illustrates a mouse icon 236 that a user can use to navigate the user interface. The user can select node 206 via the mouse icon 236 to make architectural changes to the nodes, such as by adding, deleting, merging, splitting, or the like.

[0137] FIG. 6 illustrates a user selection to add a new node 602 by splitting node 206. For example, the user can click and drag node 206 out to where the mouse icon 236 is located in FIG. 6, which can initiate the copying of the node. The new node connects with existing node 226 via connections, such as connection 604.

[0138] Although examples described herein use a click and drag user input, it is appreciated that other user inputs can apply to making such re- architecturing changes. The user can click and drag a node, such as drag it to a new location to rearrange the architecture or click and drag to connect nodes with lines representing connections. In some cases, the user can click on a node and press a button, such as a "Delete" button toremove the node or click on a "Add Node" button, then click on the canvas to add a new node.

[0139] In some cases, the user input can include a selection from a Menu. The user can right-click on a node to open a context menu with options like "Delete," "Add Connection," etc., or select a node and choose options from a menu bar at the top for actions like "Duplicate Node" or "Split Node." In some cases, the user can double-click on a node, such as to bring up a properties dialog where the user can modify parameters or connections.

[0140] In some cases, the user input can include keyboard shortcuts to perform actions, such as pressing "D" to duplicate a selected node, or "Ctrl + Z" to undo a change. In some cases, the user input can include selecting a node and in response, a contextual toolbar appears nearby, offering options for actions like "Add Connection" or "Change Node Type."

[0141] In some cases, the user input includes gesture-based interaction, such as using touch gestures on touch-enabled devices to perform actions like pinch to zoom, swipe to delete, etc. In some cases, user input includes voice commands, such as saying "Add Node" or "Delete Selected."

[0142] In some cases, the user input includes a drag and drop, such as dragging and dropping a new node from a side panel onto the canvas to add it, or dragging and dropping a connection line from one node to another to create a connection.

[0143] In some cases, the user input includes a right-click on a node to open a context-sensitive menu that offers relevant options based on the current node's state. In some cases, the user input includes a multi-select that performs actions on multiple nodes, such as "Delete Selected" or "Group Nodes."

[0144] In some cases, the user interface presents a preview mode where the system displays a preview of the new architecture and characteristics of the new architecture, such that the user can see the model's behaviorbefore finalizing changes, allowing the user to test and iterate without committing to a particular change.USER INTERFACE FOR RESTRUCTURING THE INTERNAL ARCHITECTURE OF A MACHINE LEARNING MODEL

[0145] FIG. 7 is a flowchart of a method 700 for restructuring of an internal architecture of a machine learning model using a user interface, according to some examples. Although the example method 700 depicts a particular sequence of operations, the sequence may be altered without departing from the scope of the present disclosure. For example, some of the operations depicted may be performed in parallel or in a different sequence that does not materially affect the function of the method 700. In other examples, different components of an example device or system that implements the method 700 may perform functions at substantially the same time or in a specific sequence.

[0146] FIG. 7 and other examples described herein are described as being performed by certain systems or applying certain processes, such as a particular machine learning model, but the processes described herein can be performed by one or more machine learning models.

[0147] At block 702, the Al system accesses a machine learning model, the machine learning model including a first group of nodes 704 configured to perform a corresponding first function of the machine learning model and a second group of nodes 706 configured to perform a corresponding second function of the machine learning model. The machine learning model can include one node, multiple nodes, one group of nodes, multiple groups of nodes, or the like.

[0148] FIG. 8 illustrates a machine learning architecture where a user interface displays a portion of the machine learning architecture and enables users to restructure the architecture, according to some examples. The machine learning architecture includes a number of interconnected nodes that process data to make inferences or predictions. Specifically, the machine learning architecture can include multiple groups of nodes, such as a first group of nodes 810, a second group of nodes 822, and a third group of nodes 836.

[0149] In some cases, the network begins to include only a single node. The machine learning model expands to create other nodes and clusters of nodes, such as group 810. The network can add or delete nodes and layers based on certain characteristics, as further described herein.

[0150] Initially, the external data source 802 provides input data to the first node 804 of the machine learning architecture. The external data source 802 can be any component, database, system, server, computing system, or the like, capable of providing or receiving data to the machine learning architecture. For example, the external data source 802 may be a sensor that detects real-world information, a database that stores data for processing, a transmission module that receives data from a remote system, or any other component that can supply data to the architecture.

[0151] Moreover in some cases, the machine learning model is part of or connected to another machine. As such, the output of the machine learning model changes the operation of the other machine. For example, the machine is connected to the external data source 802, whereby characteristics of the machine are transmitted to the external data source 802 and responses from the machine learning model are passed back to the external data source 802. The responses can affect the operations of the connected machine.

[0152] The improved dynamic architecture of the machine learning model described herein dynamically restructures its internal architecture during runtime based on certain characteristics, such as certain characteristics of the network, environmental influences, system performance requirements and limitations, or changes thereof over time. As such, the machine learning model dynamically modifies its internal architecture to adapt to the needs and requirements of the machine.

[0153] For example, the external data source is connected to a physical real-world machine (such as a robot) that sends sensory inputs into the machine learning model and adapts its movements and actions based on output of the machine learning model. Machine learning models can be connected to self-driving cars, enabling the machine learning model tointerpret sensor data, make real-time decisions, and send responses to self-driving cars on changing road conditions.

[0154] In some cases, the machine learning models can be connected to a wide range of Internet of Things (loT) devices including cameras, thermometers, and seismographs, enabling smart and adaptive automation in smart homes, cities, and industries.

[0155] In some cases, machine learning models can be connected to recommendation engines, providing personalized suggestions for products, content, or services. Machine learning models can be connected to computer vision applications, enabling object detection, facial recognition, and image understanding. Machine learning models can be connected to and providing instructions to gaming environments, providing adaptive gameplay, opponent Al, and personalized experiences.

[0156] The machine learning models described herein can interact with other systems and machines, and the model adapts to its new or changing environment dynamically by restructuring its internal architecture during runtime. The model can adapt its structure to better suit new data or tasks by adding / pruning nodes and layers.

[0157] In some cases, the model reduces its size and computational requirements by pruning redundant or unnecessary nodes and connections. This allows the model to run faster and on lower power budgets. The model can grow certain areas such as adding nodes to a layer to specialize on a complex task while shrinking other areas. This lets the model focus computation where more attention is needed.

[0158] In some cases, the model can route around failed nodes or layers by restructuring the internal architecture. This makes the system more robust and stable in the face of hardware and network faults or noise. In some cases, the model can rapidly adapt to new tasks by transferring and reusing previously learned features and nodes.

[0159] In some cases, the model dynamically grows areas and prunes others reflecting the demands of the current task. The model can compress unimportant nodes and connections to reduce storage footprint andmemory requirements. The model can be personalized for different users by learning unique sub-structures that specialize to each user.

[0160] When the architecture is initialized, a first node 804 serves as the entry point for data from the external source 802. The external data source 802 is configured, connected, or programmed to transmit, stream, or otherwise feed data into the first node 804.

[0161] In some cases, more than one node is connected to the same external data source, such as data source 802. In some cases, a node can be connected to more than one external data source. In some cases, the machine learning model has multiple external data sources connected to one or more nodes.

[0162] In the example of FIG. 8, node 804 is the starting node that performs initial processing on the input data received from the external data source 802. The external data source 802 provides input data to node 804. Node 804 processes the input data and generates an output. The output of node 804 is transmitted to connected nodes 806 and 808.

[0163] Nodes 804, 806, and 808 are interconnected through connections that allow the output of one node to be passed as input to another node. Together these nodes 804, 806, and 808 comprise the first group of nodes 810. The first group of nodes 810 can be determined based on one or more characteristics, as defined further herein.

[0164] In some cases, the nodes are connected unidirectionally where one node transmits output to another node. In some cases, the nodes are connected bidirectionally where each node's output is transmitted to the other node as inputs. In some cases, nodes are initially connected one way and later become connected a different way.

[0165] Node 806 processes the input data and transmits its output to nodes 804 and 808. Node 808 processes its input data and transmits the output data to nodes 804, 806, and 812, where node 812 is part of a different cluster of nodes.

[0166] Node 812 is one node in a second group of nodes 822 (such as a second group of nodes that performs a second function). Node 812 processes the output data received from node 808 and generates its ownoutput. The output of node 812 is transmitted to other nodes within the second group of nodes 822 - specifically nodes 814, 816, 818, and 820. Nodes 814, 816, 818, 820 process the output data they receive from node 812 and in turn transmit their respective outputs to other interconnected nodes of the group 822. Node 820 also transmits its output to node 824.

[0167] In some examples, the machine learning model does not define a node to be a part of a group, such as node 824. Node 824 receives the output data from node 820 and generates its own output data which is transmitted to the first node 826 of a third group of nodes 836. The third group of nodes 836 can perform a third function collectively.

[0168] Group 836 processes the output received from node 824 and transmits the corresponding output to other interconnected nodes within the group 836. This process continues, with nodes of a group passing data between themselves and to nodes external to the group of nodes. As data is passed through the machine learning model, the initial node 804 can send a response back to the external data source 802.

[0169] In some examples, the machine learning model identifies a group of nodes based on the nodes performing a common function. For example, a group of nodes can be synchronized or differentiated to perform a particular function, as further described herein.

[0170] In some examples, the machine learning model identifies a group of nodes based on an architecture of the network of nodes. For example, the machine learning model identifies a group of nodes based on how the nodes are connected. In some cases, the machine learning model identifies a group of nodes based on a cycle by determining an ordered sequence of nodes where a final node transmits the output data to another node in the sequence, or determining that nodes are or are not a directed graph.

[0171] In some cases, the machine learning model identifies a group of nodes based on how certain nodes are connected with other nodes. For example, the machine learning model can identify a portion of a group of nodes when an initial node is connected to at least three other nodes (first connected nodes). The machine learning model identifies the group ofnodes to include at least the initial node and the first connected nodes. The machine learning model identifies the nodes that the first connected nodes are further connected to (the second connected nodes) and determines whether to include the second connected nodes with the group of nodes. For example, the machine learning model identifies which nodes the second connected nodes are connected to (the third connected nodes) and determines whether to add the second connected node based on its own connected nodes (the third connected nodes).

[0172] In the example of FIG. 8, the machine learning model identifies that the initial node 804 is connected with nodes 806 and 808 (the second connected nodes) and the external data source 802. Thus, the machine learning model identifies nodes 804, 806, and 808 as a first group of nodes 810. The machine learning model identifies that the second connected nodes are connected to each other as well as node 812 (third connected node). However, the machine learning model identifies that such a node (nor any of its further connections) is reconnected back to the nodes identified in the first group of nodes. Thus, the machine learning model completes the definition of the first group of nodes as nodes 804, 806, and 808.

[0173] In some examples, the machine learning model identifies a group of nodes at least based on the historical information related to the node. For example, the node can be created symmetrically or asymmetrically from a parent node. In some cases, a node is symmetrically created from another node by inheriting at least a subset or at least two or all of the connections the parent node has with other nodes. In some cases, a node is symmetrically created from another node by inheriting the node's type, weighting, or the like.

[0174] In some cases, a node is asymmetrically created from another node by only being connected with the parent node initially or including a connection with a node that the parent node is not connected with. In some cases, a node is asymmetrically created from another node by having a different node parameter from the parent node, such as node type, weighting, or the like.

[0175] The machine learning model can identify a start or end of a group based on whether a node was symmetrically or asymmetrically created. For example, a node that is symmetrically created can be added to the group of nodes that is associated with the parent node or start a new group of nodes with the parent node. A node that is asymmetrically created can be determined to not be included in to the group of nodes of the parent and initiate the start of a group. In some cases, a child node is born either symmetrically or asymmetrically and becomes associated with a parent’s group of nodes. In some cases, a network or group can be split into sub-groups by clustering cells based on similar self-efficacy, similar VFE, correlated outputs, or the like.

[0176] In some cases, the machine learning model identifies a group of nodes based on depth that indicates a position of the node within the model. The position can be relative to a reference point, such as an external data source, such as external data source 802. For example, node 804 is in one depth value, nodes 806 and 808 are of two depth value. As such, nodes 804, 806, and 808 are grouped as one cluster of nodes.

[0177] In some cases, the machine learning model identifies a group of nodes based on an indication of self-efficacy between nodes, wherein an indication of self-efficacy is indicative of a measurement of, an extent to which, or a degree to which one node’s output affects the input it receives from another node. The machine learning model identifies the group of nodes based on a self-efficacy indicator of a node meeting a certain threshold or certain nodes having a higher self-efficacy indicator among each other in the group than other connected nodes. In some cases, the self-efficacy indicator is a measurement metric or identified value (as further described herein).

[0178] In some cases, the machine learning model identifies a group of nodes based on the layer that the node is in. In multi-layer neural networks and other layered machine learning models, the layers provide a natural way to group nodes. Nodes within the same layer have similar roles and connectivity patterns. For example, in a feedforward neuralnetwork, the input layer nodes may process and normalize the raw input data. The hidden layer nodes identify features and patterns in the data. The output layer nodes make predictions and inferences.

[0179] At block 708, the Al system generates a user interface depicting a graphical representation of at least a portion of the machine learning model. In some cases, the portion comprises at least some of the first group of nodes.

[0180] The Al system generates a user interface by creating a user interface that shows a graphical visualization of some part of the machine learning model. In some cases, the Al system generates a graphical representation of the machine learning model from an object oriented code. The machine learning model is coded where each node is an object, with fields containing information like the node's connections, weights, parameters, etc.

[0181] The Al system analyzes this code to identify all the node objects and extract key attributes. The Al system can build a graph data structure representing the network architecture, with edges between nodes for connections. Each node has properties attached based on the code fields.

[0182] The Al system renders nodes as shapes (like circles, rectangles) at the x,y positions. The Al system can size nodes, color nodes, or otherwise display nodes to show corresponding characteristics (as further described herein).

[0183] The Al system generates connections between nodes as lines between the node positions. The Al system can render different thickness, such as reflecting the connection weight. The Al system could dynamically update the visualization as the model changes, re-analyzing the objects to update the graph structure. User interactions such as dragging nodes to generate new nodes could be propagated back to the code which thus updates the user interface.

[0184] At block 710, the Al system presents the user interface to a user. The Al system can present the user interface that includes audio, image, video, haptic, or other types of information presented to the user.

[0185] The user interface can include one or more user-selectable interface elements configured to restructure an internal architecture of the machine learning model. The user-selectable interface element can include a zoom function, such as to zoom in on a particular group of layers 822 to display in the user interface 234 of FIG. 8.

[0186] At block 712, the Al system receives a selection from the user of the user-selectable interface element. In some cases, the user-selectable interface element includes a button or menu to access certain options to restructure the internal architecture of the model. In some cases, the user-selectable interface element includes a particular node, connection, group of nodes, other subset of nodes of the model, or the like. The user can click and drag a node to generate a new node, or perform other actions in a user input (as further described herein). For example, the user has selected node 820 via a mouse icon 236 in FIG. 8 in order to restructure the internal architecture of the model.

[0187] At block 714, the Al system, in response to the selection from the user of the user-selectable interface element, performs certain steps, such as blocks 716, 718, and 720. At block 716, the Al system restructures the internal architecture of the machine learning model causing a change to a number of nodes or a number of connections in the first group of nodes.

[0188] The machine learning model restructures the internal architecture of the machine learning model by changing a number of nodes in the first group of nodes corresponding to the first function. The number of nodes in the first group of nodes can be changed by adding a node or group of nodes, deleting a node or group of nodes, merging a node or group of nodes, interchanging a node or group of nodes, or the like. FIG. 9 - FIG. 19 illustrate examples of how the machine learning model changes the number of nodes in a group of nodes.

[0189] At block 718, the Al system generates an updated user interface depicting a graphical representation of at least the restructured portion of the machine learning model. After the Al system has modified the internal architecture of the machine learning model in block 716, the Alsystem then regenerates the user interface to reflect those changes. In particular, the Al system updates the graphical visualization of the portion of the model that was restructured. For example, if the user added a new node, the visualization would now include the new node. If the user created a new connection, the UI would show that new link between nodes.

[0190] In some cases, the Al system does not necessarily have to regenerate the entire user interface from scratch. The Al system can incrementally update the visualization to add, remove, or alter the specific nodes and connections that changed. This allows the user to immediately see how their requested restructuring altered the model architecture.

[0191] The key idea is that the Al system refreshes the UI to visually represent the changes made to the structure of the machine learning model after the user's requested reconfiguration. This feedback loop allows iterative adjustments to the model.

[0192] At block 720, the Al system presents the updated user interface to the user. For example, the Al system presents updates to the user interface as shown in FIG. 9 - FIG. 19.

[0193] In some cases, the machine learning model applies new input data to the machine learning model with the restructured internal architecture to generate an inference output. As such, the restructuring of the model and generating an inference output occurs entirely on the fly during restructuring of the model. The model can be performing inferences while the user interface is being displayed and users are initiating changes of the model, such that the restructuring of the model is occurring on the fly during inference via the user interface. The model is simultaneously adapting its architecture while also performing its inference task and displaying architectural changes to the user. In the cases, the restructuring of the model occurs at specific times, such as a particular designated times or time intervals.

[0194] The Al system uses a combined order of specific procedures that dynamically alters the structure of the machine learning model using a user interface, in real time, or during inference (as further describedherein). Not only do some examples and features of the Al system described herein eliminate the need for a separate training process from the inference process, the dynamic nature of the Al system is different than the nature for traditional systems. The Al system does not simply automate traditional systems and concepts. By leveraging dynamic architectural restructuring, the Al system naturally grows and prunes by displaying certain characteristics to a user, such as certain characteristics of the network, environmental influences, system performance requirements and limitations, or changes thereof over time, and the users can immediately make changes to the architecture via user-selectable elements displayed on the user interface.

[0195] In some cases, the characteristic or value is an expected value at a later time step. The system can apply a prediction algorithm or prediction machine learning model to predict which of the characteristics or values may change over time. For example, the Al system applies a historical log of the machine learning model (such as inputs and outputs across past time steps, architectures and changes thereof across past time steps, or the like) into a prediction machine learning model. The prediction machine learning model identifies that a certain node that is currently performing well (self-predicting well) is likely not going to be performing well in 10 time steps (starting to desynchronize). The Al system can provide such an indication on the user interface, and the user can decide to modify the internal architecture of the machine learning model based on the output of the prediction machine learning model.

[0196] Although examples described herein explain how certain values or characteristics can be displayed and the user can initiate a particular architectural change (such as deleting or adding a node), it is appreciated that the user can initiate other architectural changes in response to identifying the values or characteristics of nodes or groups of nodes, and apply such architectural changes in response to other values or characteristics of nodes or groups of nodes. For example, any of the characteristics or values thereof of nodes or groups of nodes can be displayed and the user can trigger the change in the internal architecture described in FIG. 9 - FIG. 19.

[0197] Although examples described herein describe one type of model, such as a machine learning model, it is appreciated that such features apply to other types of models, such as an artificial intelligence model or a graphical machine learning model, and vice versa. For example, types of artificial intelligence models include a graphical machine learning model and a machine learning model. An artificial intelligence model includes models used to simulate human intelligence in machines, such as understanding natural language, recognizing patterns in data, making decisions, and solving complex problems. A machine learning model is a subset of artificial intelligence models that includes using algorithms and statistical techniques to enable computers to improve performance on a task through learning from data. A graphical machine learning model is a type of machine learning model that uses graphical representations to model dependencies between variables.

[0198] Although examples described herein describe one type of a collection of nodes, such as a group of nodes, it is appreciated that such features apply to other types of nodes, such as a cluster of nodes or a group of interconnected nodes, and vice versa. For example, a group of nodes includes a collection of nodes that share a common purpose or are organized together within the machine learning model. A cluster of nodes includes a localized or cohesive set of nodes that work together to perform a specific function within the machine learning model. A group of interconnected nodes includes nodes that are linked or connected to each other.

[0199] Although examples described herein describe the restructuring an in internal architecture of the machine learning model, it is appreciated that such features apply to other types of changes, such as modifying a network or reconfiguring a topology, and vice versa. For example, modifying a network includes changes made to the network by changing its group of nodes, nodes, parameters, or structure. Restructuring internal architecture includes making changes to the organization and composition of the model's components. Reconfiguring topology includes changing the arrangement or connections between groups of nodes or nodes within the model.SYMMETRICAL AND ASYMMETRICAL DIVISION

[0200] FIG. 9 illustrates creation of a new node in a group of nodes based on asymmetrical division, according to some examples. Asymmetric division creates a child node with different connectivity or initialization than its parent node. For example, node 902 is created with different weighting parameters as the parent node 820, such as initial weightings (such as all weights set to an initial value, e.g., 0.5) of an undifferentiated node. Node 902 is initialized without inheriting node 820 parameters. Instead, node 902 starts with default parameter values, such as random small weights or set weights. This allows node 902 to start fresh with a blank slate and form new representations, rather than duplicating node 820 behavior.

[0201] In some cases, if node 820 divides asymmetrically, the new child node 902 will only have a connection to its parent node 820. Node 902 does not inherit any of node A's other connections. Over time, node 902 may develop connections to other nodes, such as nodes 812, 814, or 816 identifying similar or useful complementary signals. In some cases, the computational environment that is running the network adds such connections on behalf of the nodes. Node 902 may also differentiate to perform a different computation than node 820.

[0202] Asymmetric division allows lower computation exploratory growth of the network compared to symmetric division. Asymmetric division also expands the network's functional repertoire, creating nodes with the potential for novel parameters.

[0203] The user can select node 820 as the user-selectable interface element. Upon selection, the user interface can display a menu of actions to be performed including the addition of a new node, the user can click and drag node 820 to where the new node 902 is in FIG. 9, or other user input as further described herein. In response to the user input, the model can generate a new node, such as 902, based on asymmetric division and the user interface 234 is updated to show the new node 902 and the newly created connection 904 between node 820 and node 902.

[0204] FIG. 10 illustrates creation of a new node in a group of nodes based on symmetrical division, according to some examples. In symmetric division, the child node inherits at least some or the exact same structure or parameters as the parent node. For example, consider again node 820, which has connections to nodes 812 and 818.

[0205] If node 820 symmetrically divides, the new child node 1002 has the same incoming connections from nodes 812 and 818. In some cases, node 1002 inherits copies of node 820's weights - so that the child node 1002 has identical weights wl, w2, w3 associated with the connections to nodes 812 and 818.

[0206] In some cases, node 1002 inherits all other parameters from node 820, like biases, activation functions, tensor weightings, etc. So node 1002 is functionally identical to node 820 after symmetric division.

[0207] This allows node 1002 to immediately replicate the representation and computation of node 820 without any training or adaptation. The network's overall capacity is increased since two identical nodes now process the data instead of just node 820 alone.

[0208] Over time, node 1002 may diverge from node 820 by tweaking its inherited weights and parameters. But the key point is that symmetric division quickly replicates existing structure and behavior. It provides an efficient way to rapidly increase model capacity and redundancy compared to creating nodes from scratch.

[0209] The user can select node 820, with node 820 being a user-selectable interface element. The user interface displays possible user actions to be taken or the user can provide certain inputs corresponding to certain actions (such as adding a new node symmetrically), as further described herein. In response to the user input, the model generates new node 1002 based on asymmetric division and the user interface 234 is updated to show the new node 1002. The new node includes the same weightings as node 820.

[0210] The new node 1002 is also connected to the same nodes as node 820. Node 1002 is connected to node 820 via connection 1008, to node812 via connection 1004, node 818 via connection 1010, and to an external node of the group of nodes via connection 1006.

[0211] In some cases, the user interface provides different features of the creation of new nodes, as described below. For example, a node divides in a hybrid process that combines both asymmetric and symmetric elements. For example, for node 820 with connections to nodes 812 and 818, along with associated weights wl, w2, and w3, the child node 1002, in a hybrid division, inherits some of the parent's connections symmetrically while forming other connections asymmetrically. For example, node 1002 symmetrically inherits the connection and weight wl to node 812, directly replicating that portion of node 820's structure. However, node 1002 asymmetrically forms novel connections to nodes 814 and 816, with randomly initialized or uniform weights w4 and w5.

[0212] Furthermore, (child) node 1002 inherits only a subset of (parent) node 820's weights in a partially symmetric fashion. For instance, node 1002 inherits w2 but initialize its own value for w3.

[0213] Thus, node 1002 partially mirrors node 820's connectivity and parameters, while also exploring some new areas of the architecture space of the machine learning model.

[0214] The hybrid division allows both exploitation of existing structure through symmetry and exploration of new structure through asymmetry. The relative amounts of symmetry and asymmetry could be dynamically tuned or learned based on the model's current needs, such as balancing plasticity and stability.

[0215] When a node connected to the environment or a node external to the group of nodes divides symmetrically, the child node can also replicate its environmental and external connectivity. In some cases, a child node never takes the environmental connections or external connections of its parent.

[0216] In some cases, new nodes are directly created by the machine learning model's architecture search methods. The machine learning model can create new nodes and connections from scratch, without originating from any existing nodes.

[0217] In some cases, the connections to and from the new nodes are formed randomly or based on some programmed heuristics. For example, each new node could connect to a random subset of nodes in the adjacent layers. The parameters (weights, biases) of the new nodes can be initialized randomly or using pre-defined schemes.

[0218] In some cases, a machine learning model creates nodes that are taken from another model. Nodes could be copied over or transferred from another pre-trained model, leveraging prior learned representations. For example, a machine learning model identifies a desired function (e.g., a newly desired function based on changing environmental data). The machine learning model identifies another machine learning model that has been trained to perform such a function and copies nodes over to the architecture.DELETING A NODE

[0219] FIG. 11 illustrates deleting node 820 from the group of nodes 822, according to some examples. In some cases, the user interface provides an option for a user to delete a node. A user can select node 820 and select a user interface element that deletes node 820. FIG. 11 illustrates a user interface 234 where node 820 has been deleted.

[0220] In some cases, all incoming and outgoing connections to the deleted node are removed. For example, if node 820 was connected to nodes 812 and 818, those connections are eliminated.

[0221] Any weight parameters associated specifically with the connections to and from the deleted node are removed. For example, the weights on the connections between 820 and 812 and between 820 and 818 are deleted along with the connections.

[0222] In some cases, new connections are formed between the remaining nodes. For example, node 820 was connected to a node external to the group of nodes 822. After node 820 is deleted, new connections 1102 and 1104 are created that connect to the external node that node 820 was connected to.

[0223] In some cases, a deletion of a node fragments a group of nodes into sub-groups. For example, the deleted node could have been the connecting node between the sub-groups, and with the node being deleted, the two sub-groups can remain unconnected. In some cases, the Al system automatically removes one of the two sub-groups from the machine learning model.

[0224] Any parameters associated just with the deleted node, such as bias terms, can be removed from the model. Parameters associated with connections (e.g. weights) or other nodes can remain unchanged. In some cases, the data associated with the node from the network is deleted. In some cases, the model retains memory of the deleted node, which can be used to re-add the node or apply the data to another node at a later time and not use such memory for current inferences.CREATING A NEW CONNECTION WITHIN A GROUP OFNODES

[0225] FIG. 12 illustrates the creation of a new connection within a group of nodes, according to some examples. The user interface 234 shows a graphical representation of a portion of the machine learning model, including nodes and connections between them.

[0226] To create a new connection, the user can first select a node, such as node 820, by clicking on it using the mouse icon 236. The interface can display an option to generate a new connection with another node. For example, the user interface can display a connection-drawing mode, where the user can click and drag from the selected node to another node, such as to node 814.

[0227] As the user drags the cursor, a dotted line is rendered to depict the potential new connection. Releasing the cursor on a target node can finalize the connection generation, at which point the interface renders a solid line between the nodes to indicate the new permanent linkage, such as connection 1202 displayed in the user interface 234. The interface sends this user input to the underlying model architecture, updating the model definition to insert a new weighted connection between those nodes. The updated model can then be retrained or deployed, with theuser able to observe the impact of their architectural modification via the visualization. This interactive process allows intuitive refinement of the model topology.

[0228] A new directed connection 1202 is formed between two nodes 820 and 814. For example, if node 820 forms a new connection to node 814, this creates a new connection 1202. The new connection provides an additional pathway for information to flow between the nodes. This can improve signal propagation through the group.

[0229] In some cases, the new connection has its weight parameter randomly initialized, such as in a normal or uniform distribution with a mean of 0. In some cases, the new connection is initialized with a weight parameter that is based on one or more prior existing connections of nodes 820 or 814.

[0230] In some cases, the neighboring nodes are not directly affected by the new connection. In the example, none of node 814's or 816's existing connections are altered.

[0231] The new connection may strengthen or alter the overall connectivity structure of the group (e.g., new cycles may form). Connecting two nodes allows the nodes to develop a joint representation of data, potentially increasing the group's overall representation power. The new connection may strengthen ties between clusters of nodes or create new cycles within the group structure. Such new connections can create shortcuts between distant nodes. A direct connection allows two nodes to integrate information without needing intermediate nodes, improving information flow.

[0232] Furthermore, the new connection gives an extra pathway for gradients to flow during training. This can help combat vanishing / exploding gradients. Moreover, the newly connected nodes can now directly influence each other during inference and training.REPLACING, INTERCHANGING, SPLITTING, FUSING, AND MERGING NODES

[0233] FIG. 13 illustrates a machine learning model performing different functions across nodes in different groups of nodes, according to some examples. The user interface 234 shows nodes of a first group 822, and the user can move the view to user interface 1304 that shows nodes of a second group 836.

[0234] To replace a node, the user drags a node, node 820 in the first group 822, onto another node, such as node 834 in the second group 836, using the mouse icon 236. Likewise for the other functions, a user can select from a menu option, click and drag, click one node then click another node, or perform other user inputs (as further described herein) to perform node replacement, node swapping, node splitting, node fusing, node merging, or the like. For these changes, the Al system updates the model definition accordingly and the updated architecture is displayed.This allows intuitive topological rearrangements and alterations to model structure. The user can iteratively adjust the architecture while observing the effects on model behavior and performance.

[0235] The user can submit user inputs to initiate changes to the architecture. For example, an individual node, such as node 820 in group 822, can be removed and replaced with a different node, such as node 834 in group 836. For example, node 820 is found to be consistently underperforming based on its loss, accuracy, or other metrics. Node 820 is removed from the network and replaced with node 834.

[0236] Node 820 can inherit some or all of the weightings of node 834. In some cases, node 820 is randomly initialized. In some cases, the weightings for node 820 are selectively set, such as copying the input weights from node 834 but randomly initializing the outputs.

[0237] In some cases, node 820 inherits some or all the input and output connections that node 834 had. In some cases, such as in FIG. 13, node 820 inherits none of the connections of 834.

[0238] In some cases, rather than replacing a single node, groups of poorly performing nodes can be replaced together. For example, an entire group of nodes can be removed and replaced with a new layer initialized from scratch, copied, or transferred from another part of the network.

[0239] In some cases, a single node is replaced with a group of nodes or a group of nodes is replaced with a single node.

[0240] In some cases, two nodes are interchanged between different groups of nodes. For example, node 820 was originally in group 836 and node 834 was originally in group 822. After the interchange, node 820 is now in group 822 and node 834 is now in group 836.

[0241] The machine learning model or a user selects two nodes from different groups. These nodes can be selected randomly or chosen as a result of the nodes misaligning (alignment described further herein). Node 834 is disconnected from all its input and output connections in group 822. Similarly, node 820 is disconnected from all its connections in group 836. Node 834 is moved to group 836 and node 820 is moved to group 822. In group 822, node 820 is connected to all the inputs and outputs that originally belonged to node 834, and the same for node 834.

[0242] In some cases, the nodes are not disconnected and reconnected. Instead, the machine learning model interchanges the internal parameters and weightings of each node, effectively interchanging the functionality of the nodes.

[0243] In some cases, an existing node is split into two nodes. For example, node 834 is split into nodes 834 and 820. In some cases, the connections and parameters are also divided between the child nodes. Original node 834 could have been connected to nodes 826, 828, 832, 818, and 812. After splitting, node 834 is now connected to nodes 826, 828, and 832, and node 820 is connected to 818 and 812.

[0244] In some cases, the weights, biases, or other parameters of original node 834 are split and assigned to the nodes 834 and 820. For example, the weight matrix of node 834 could be vertically split, with the top half going to 834 and bottom half to 820.

[0245] In some cases, multiple existing nodes are merged into a single new node, such as nodes 820 and 834. In some cases, the connections from all the merged nodes are included with the combined new node. For example, the combined new node is connected to nodes 812, 818, 826, 828, and 832.

[0246] In some cases, parameter matrices, such as weights, biases, or activations, of the existing nodes are concatenated or summed element- wise into larger parameter matrices for the merged node. The larger matrices can include columns for each input and output for each cell. The merged cell can then perform combined reasoning by considering all parameters of both preexisting cells.

[0247] In some cases, the merged node takes on an integrated representation by combining the functionalities of the preexisting nodes. In some cases, redundant connections from the merged nodes are pruned to improve efficiency.

[0248] In some cases, two nodes are fused together, such as nodes 820 and 834. The new fused nodes can incorporate derived parameters of the two nodes, such as an average, a mean, a max, a min, a weighted average, or the like. In some cases, the nodes are fused into a new node through vector addition or averaging. For example, fusing nodes 820 and 834 create a new node that averages the weights from 820 and 834 or inherits a combined set of connections.

[0249] In some cases, when nodes are fused, the original nodes lose their distinct identities and are transformed into the new node. In some cases, fusing changes the network topology more drastically than merging, since multiple nodes disappear, whereas a merge preserves nodes and adds connections.PERFORMING CHANGES ON AN ENTIRE GROUP OFNODES

[0250] FIG. 14 illustrates a machine learning model performing changes on an entire group of nodes, according to some examples. The user interface depicts groups of nodes where a user can make changes to entire groups of nodes. The user can select an existing connection, such as connections 1402 and 1404 and delete such connections. The user can then create new connection 1406 such that node group 822 is now skipped over during inference.

[0251] In some cases, the user selects an "Add Connection" from a menu, drawing a new edge between groups, such as connections 1402 and 1404.The user then selects "Delete" and connection 1406 to delete the connection, effectively adding group 822 for processing data from the external data source 802.

[0252] In some cases, the user selects an entire group, such as node group 822, and selects a function to perform on the entire group, such as adding a group, copying the group, deleting the group, or the like. The Al system can recommend changes to facilitate such changes, such as new connections to be created or existing connections to be deleted. The user can select from such suggestions and accept, reject, or modify the recommended architectural changes.

[0253] The machine learning model can restructure its architecture based on user input. In some examples, the machine learning model skips over an entire group of nodes. The machine learning model can disconnect all connections to the node group (input connections or output connections), such as connections 1402 and 1404 of the group of nodes 822 from the nodes external to the group.

[0254] In some cases, the machine learning model creates a new connection that connects the nodes or node groups that are external to the group of nodes being skipped. For example, the machine learning model identifies that the group of nodes 810 and the node 824 is connected to the group of nodes 822, and creates a new connection 1406 that connects node 808 of the group of nodes 810 and the node 824. The new connection 1406 is a bypass connection that bypasses the group of nodes 822 so that the output of node 808 is directly sent to node 824, instead of first being processed by the nodes in the group of nodes 822.

[0255] In some cases, all preexisting connections to the group of nodes 822 are severed and the nodes that the preexisting connections were connected to are reconnected with each other. For example, nodes 808 and 824 were connected to a different node in the group of nodes 822. The machine learning model reconnects these nodes 808 and 824 together. In some cases, only a subset of nodes that the preexisting connections were connected to are reconnected.

[0256] In some cases, the machine learning model deletes the group of nodes 822. The machine learning model first severs all connections going into and out of that group, such as connections 1402 and 1404.

[0257] Severing connection 1402 disconnects node 808 in group 810 from sending its output to node 812 in group 822 or vice versa. Severing connection 1404 disconnects node 820 in group 822 from sending its output to node 824 or vice versa.

[0258] With group 822 now disconnected, the machine learning model removes all nodes in group 822 entirely. This deletes all the nodes and their associated parameters like weights and biases. To maintain connectivity in the network, the machine learning model creates a new direct connection 1406 between the nodes that were originally connected via the now deleted group 822. Specifically, node 808 in group 810 is connected directly to node 824 with new connection 1406. This bypasses the deleted group 822.

[0259] In some cases, upon deletion of the group of nodes, if a node is no longer connected to anything, the node is also deleted. In some cases, upon deletion of the group of nodes, if another group of nodes is no longer connected to anything and is also not connected to an external data source, the group of nodes can be deleted or reconnected to a group of nodes that is connected to the external data source. For example, the machine learning model identifies that certain nodes transmit similar signals over a certain time period and determines to connect such groups together.

[0260] In some cases, the machine learning model adds a new group of nodes. For example, to add a new group between existing group 810 and node 824, the model severs connection 1406 between node 808 and 824. A new group of nodes 822 is added to the network. This group 822 includes a set of new nodes, such as nodes 812, 814, 816, 818, and 820. The new nodes in 822 can be initialized with random weights and biases, or otherwise as further described herein.

[0261] To connect the new group 822, the machine learning model generates connections between nodes, such as connection 1402 fromnode 808 in group 810 to node 812 in group 822, and connection 1404 from node 820 in group 822 to node 824.

[0262] In some cases, the machine learning model applies the characteristics described herein, such as in the application description for FIG. 8, to determine which group of nodes to add, skip, or delete, which groups or nodes to connect or reconnect, which groups or nodes to merge, fuse, interchange, replace, split, or the like.

[0263] For example, the machine learning model assesses node groups based on their contribution to the overall performance of the model on a particular task or dataset, the density of connections between a group and the rest of the network, activation patterns of nodes in a group (e.g., groups with consistently low activation can potentially be pruned), determining if multiple node groups have high correlation and redundancy in their activations (e.g., deleting redundant groups), groups that are particularly expensive in terms of memory, compute, or energy usage, or the like.ACTIVATING OR DEACTIVATING AN ENTIRE GROUP OF NODES

[0264] FIG. 15 illustrates a machine learning model activating or deactivating an entire group of nodes, according to some examples. The user can select a node or a group of nodes to activate or deactivate. The user interface allows users to toggle nodes or node groups on and off. To deactivate a node, the user can click on a node and provide user input selecting an option to is temporarily switch off the node. To reactivate, the user can click the node again and select an option to switch the node back on.

[0265] As shown in FIG. 15, deactivated nodes and connections can be shown using visual indicators, such as nodes 812, 814, 816, 818, and 820 in group 822 are deactivated and are shown with a lighter outline. The connections between such nodes are also lighter. The visual indicators can be shown in other forms, such as color, size, or the like (further described herein).

[0266] In some cases, the user interface allows scheduled activation. The user right-clicks a node or a group of nodes, and selects "Activate Conditionally". The user can specify conditions such as "Activate every Tuesday from 9-1 lam" or "Activate when input data contains keyword X". This user input changes the architecture of the model with programmatic rules that toggle the node or group of nodes based on time or external input data.

[0267] Deactivated nodes cannot pass data across connections, allowing users to selectively disable model components. In some cases, deactivated nodes simply pass the data through without internal processing. Conditional activation allows the model to dynamically switch parts of the model on and off based on real -world conditions. The interface thus facilitates debugging or specializing models by selectively enabling or disabling subsets of nodes. The user can find optimal topological configurations for given scenarios by scheduling targeted activation profiles.MERGING GROUPS OF NODES

[0268] FIG. 16 illustrates merging of two groups of nodes, according to some examples. Groups 822 and 836 shown in FIG. 8 are merged into new group 1616 in FIG. 16. In some cases, the model severs any existing connections between the two existing groups. In some cases, the model leverages the existing connections during the merging process.

[0269] In some cases, to merge two groups, the user selects two different groups of nodes by shift-clicking an enclosing box or boundary for the individual group of nodes. Upon selection of two groups of nodes, a "Merge Groups" option appears. Clicking this user-selectable element combines the groups into one larger group.

[0270] The user interface then shows all connections between the groups, and recommends which ones to keep or discard based on characteristics as described herein, such as latency, load balancing, or the like. In some cases, the Al system suggests new connections to be generated between the two groups. The user can review these suggestions, clicking to retain or remove each connection.

[0271] Once done, the user can click “Confirm Merge”, whereby the two groups are merged into one, with only the selected connections between them. The machine learning model updates its model definition to reflect the merged group and connections. The model can then be applied to data and generate inferences using the merged topology.

[0272] As shown in FIG. 16, the user can submit user inputs to merge two layers. In the case of FIG. 16, the machine leaning model generates new connections, such as connections 1602, 1604, 1606, 1608, 1610, 1612, and 1614 between nodes in groups 822 and 836 shown in FIG. 8. For example, connection 1602 is made between node 834 and node 820.

[0273] In some cases, one or only a subset of the nodes are connected with the other group. In some cases, the same number of nodes in one group is connected with the number of nodes in the other group. In some cases, all of the nodes in one group are connected to at least a subset of the nodes in another group. In some cases, all of the nodes in one group are connected in all of the nodes in another group.

[0274] This merged architecture allows signals to propagate between the nodes in the combined group 1616 more directly instead of signals of the nodes in group 822 being pruned down to one signal going to node 824 and then introduced into group 836.

[0275] In some cases, merging groups reduces the total number of parameters, which can improve computational and statistical efficiency. A merged group with more nodes and connections can represent more complex functions than separate groups. Merging creates new connections between nodes that allow signals to flow between the groups. This can help spread information across more of the model.

[0276] In some cases, merged groups can specialize on common features or tasks, dividing up labor. Merging groups can serve as a form of compressing information from multiple groups into a consolidated representation. A merged group with redundant nodes can increase robustness to noise or failure of individual nodes. Merging allows adaptation to new tasks or data distributions by re-purposing multiple groups.SPLITTING GROUPS OF NODES

[0277] FIG. 17 illustrates splitting of one group of nodes into two groups of nodes, according to some examples. To split a group, the user selects a group and clicks "Split Group". The user interface then analyzes the connectivity within the group and suggests possible ways to divide the group into two subgroups.

[0278] The suggestions highlight which nodes should be assigned to each subgroup, and which inter-group connections to retain or discard. The user reviews these recommendations, clicking to reassign nodes or toggle connections. In some cases, the user manually selects nodes or connections for the two subgroups.

[0279] Once the split configuration is approved by the user, the group is then divided into two new subgroups with the chosen node assignments and inter-connections. The new groups can adopt distinct visual schemes (such as color) to indicate the split. The machine learning model updates its model definition to reflect the two new groups and the preserved connections between them.

[0280] This allows users to rapidly divide model components into specialized sub-modules. The user interface provides splitting suggestions to guide the process. Users can manually override the suggestions to explore alternate groupings. This facilitates dividing models into more targeted components by splitting nodes based on connectivity and function.

[0281] Group 836 of FIG. 8 initially contains interconnected nodes 826, 828, 830, 832, and 834. To split this group, the model or the user can disconnect the nodes between group 1704 and 1706.

[0282] The nodes are then divided into two new groups. Nodes 826, 834, and 832 are assigned to new group 1704, and nodes 828 and 830 are assigned to new group 1706. These two new groups 1704 and 1706 include a subset of the original nodes from group 836.

[0283] In some cases, the nodes within each new group remain interconnected. For example, in group 1704, node 826 remains connected to both 834 and 832.

[0284] The two groups 1704 and 1706 are then connected to one or more surrounding nodes in the network. For example, node 826 of group 1704 connects to node 828 of group 1706 via connection 1702. In some cases, the node 826 maintains the connections external to the group, such as to node 824.

[0285] This split architecture allows the model to divide the computation and representation of the original group across two separate new groups.

[0286] In summary, to split a group, the model or the user divides its nodes into subsets, disconnects the subsets from each other into new groups, and connects the new groups to the surrounding network.

[0287] If a group of nodes is split into smaller groups, the machine learning model can reduce the overall computational load and power consumption of the model. In some cases, splitting a group into smaller groups with fewer connections may allow the model to find a more optimal architecture by performing iterative computations faster.

[0288] Splitting nodes into smaller groups with some redundancy can make the system more robust to random hardware errors or node failures. Moreover, splitting nodes can potentially help avoid overfitting to a particular structure by reducing the number of nodes in individual groups.INTERCHANGING GROUPS OF NODES

[0289] FIG. 18 illustrates interchanging groups of nodes, according to some examples. For example, the machine learning model can interchange the nodes in group 822 with the node group 836 in the network architecture. The user interface depicts groups of nodes in different enclosures.

[0290] To swap two groups, the user can select one group by clicking its enclosing boundary, select another group by clicking its enclosing boundary, and click an "Interchange" button. The two highlighted groups swap positions on the user interface. All connections are updated to reflect the new positions.

[0291] In some cases, the connections internal to each corresponding group is maintained with the swap. In some cases, the user creates theconnections external to each group. In some cases, the machine learning model recommends new connections or deletions of certain connections, such as connections that were between a node within the group and a node external to the group.

[0292] The user can input commands to cause the swapping of the group of nodes. Initially, group 822 is positioned between group 810 and group 836. To interchange their positions, the model or the user first disconnects group 822 from external connections. Similarly, the model or the user disconnects external connections for group 836. With the groups disconnected, the model or the user then reconnects group 822 to the former connections of group 836, and vice versa.

[0293] After this rewiring, group 836 is now positioned between group 822 and group 810. The two groups have effectively interchanged positions in the network architecture, by disconnecting them, then reconnecting them to each other's former surrounding connections. This allows the model to interchange their order and analyze the impact on information flow and model performance.

[0294] Transferring functionality between a group of nodes in the network could allow different layers to take on new roles dynamically. Moreover if one group of nodes is computationally overloaded while another is underutilized, interchanging the groups could help distribute the load more evenly. Moreover, if a particular group of nodes fails, interchanging in a backup group could increase robustness.REROUTING GROUPS OF NODES

[0295] FIG. 19 illustrates rerouting of groups of nodes, according to some examples. The machine learning model can reroute signals among node groups by connecting and disconnecting certain connections. In some cases, the machine learning model activates and deactivates certain connections to reroute signals.

[0296] The user interface allows users to define conditional logic that alters the topology based on real-time data feeds. Using a visual programming workflow, the user drags "If-Then" blocks onto a canvas. They specify conditions like "If input data contains keyword X" or "If currenttemperature > 90F". The user then defines rerouted data flows for each condition, such as "Route data from group 810 to group 822 to group 836" and for another condition "Route data from Group 810 to Group 836 to Group 822".

[0297] When deployed, the model analyzes real-time data feeds. If a defined condition is met, the corresponding rerouting logic is dynamically applied. This alters the model's internal data flow to match the user-specified topology. The interface visualizes the active topology and data routing in real-time, showing how it adapts to external conditions. Users can refine the model logic to optimize dynamic rerouting behaviors.

[0298] This allows the model architecture itself to become conditional and respond intelligently based on real-world inputs. The user customizes dynamic topology rerouting without coding via simple visual programming. This enables context-aware models that automatically adapt their internal wiring in response to external data.

[0299] The model can control the order in which the external data source signal is processed by groups 810, 822, and 836. In the default configuration, the signal flows from the external data source 802 through group 810, then group 822 using connection 1902, and finally group 836 using connection 1904 and 1906.

[0300] To change the processing order to group 810, then group 836, and finally group 822, the machine learning model disconnects or deactivates connections 1902, 1904, and 1906, and instead uses connections 1908 to connect from group 810 to group 836, and connection 1910 to connect group 836 to group 822.

[0301] By dynamically connecting and disconnecting different connections between the groups, the model can reroute the flow of signals and control the sequence in which groups process the data. This allows the model to analyze how different processing orders impact the performance and output.

[0302] Rerouting allows the model to perform different sequences of operations for each inference which provides more flexibility to adapt thecomputation to the specific inputs. Rerouting makes it possible to skip certain layers or nodes that may not be needed for some inferences, reducing unnecessary computation. Moreover, if layers are rerouted in different orders, each layer can specialize on the inputs it receives rather than needing to handle all input types.

[0303] Furthermore in some cases, if certain layers fail, rerouting can allow the model to use alternative paths through remaining functional layers. Layers can be selectively applied only when their specialized capability is required for a particular inference.SPLIT SCREEN INTERFACE

[0304] FIG. 20 illustrates a split screen user interface, according to some examples. The Al system can present a user interface that splits the screen into two user interfaces, a first user interface 2016 and a second user interface 2018. The first user interface 2016 can show the original portion of the machine learning model. For example, the original machine learning model includes nodes 812, 814, 816, 818 and 820.

[0305] The second user interface 2018 illustrates a working zone for the user to make architectural changes to the machine learning model. In the example of FIG. 20, the user selects node 820 and deletes the node using the user interface element delete node 2008. The user interface can display a plurality of different user interface elements to choose from in order to cause a change in the restructuring of the machine learning model. For example, the user interface displays an undo button 2004, an add node button 2006, a delete node button 2008, a delete group button 2010, a new connect (e.g., add new connection) button 2012, a swap nodes button 2014, or the like.

[0306] In some cases, the user interface shows certain characteristics of the change or certain performance metrics. For example, the user interface displays a history of the change made so far (such as that node 820 was removed). The user can select individual changes and decide to undo individual changes made. In some cases, the user interface displays performance metrics such as how the architectural change improves or degrades performance. The user interface can show that the self-efficacyimproved by 50%, the computational load was reduced by 35%, and that latency improved by 100 ms.

[0307] In some cases, the second user interface itself can show improvements or degradations. For example, once node 820 was removed, the self efficacy of all nodes improved, especially node 812 (as shown in bolded lines in the second user interface), the other nodes also improved, but less than node 812 (as shown in lesser increase in bold from the first user interface 2016 to the second user interface 2018.DYNAMIC GROWTH OF THE MACHINE LEARNING MODEL

[0308] FIG. 21 illustrates a sequence showing restructuring of a network of a machine learning model over time, according to techniques described herein. The network shown in FIG. 21 not only adds and removes connections, but also adds and removes nodes, over time. The connections shown in FIG. 21 may represent a pair of bidirectional connections.

[0309] The top row of FIG. 21, spanning from time to on the left to time ti on the right, begins on the left with a simple network at time to. A single node 804 is connected with the environment 802. As time progresses, and in response to processing of inputs to generate outputs and inferences during the runtime period, the network is restructured by adding two nodes 806 and 808, both having connections to each other and to the initial node 804. The three nodes 804, 806, and 808 thereby form a first cluster or group of nodes 810.

[0310] As time progresses further, just before time ti on the right side of the top row, the network is further restructured to add another set of nodes and connections to form a second group of nodes 822. The node 808 of the first group of nodes 810 has a connection to a node 812 of the second group of nodes 822. In each case of a new connection, the connections may be added through the mechanisms described herein for adding connections (e.g., in response to determination of the similarity of the two connected nodes' outputs over time) or through addition of new nodes having connections to existing nodes.

[0311] The bottom row of FIG. 21 spans from time ti on the left to time t2 on the right. On the left side of the bottom row, after time ti, the second group of nodes 822 of the network is restructured to remove one of its nodes (e.g., node 818) and the removed node's connections.

[0312] On the right side of the bottom row, just before time t2, the second group of nodes 822 is restructured again to add a further node (e.g., node 1002). It will be noted that, although the second group of nodes 822 just before time ti and the second group of nodes 822 just before time t2 each have five nodes, the pattern of interconnection of the nodes of the second group of nodes 822 is different at the two different times. Furthermore, it may be the case that the parameters (e.g., the weights of the various tensors) of each node may be different over time.TENSORS

[0313] FIG. 22 shows four tensors used by a POMDP of a node. The A tensor 2202, B matrix 2212 (consisting of the Bo submatrix 2204 and Bi submatrix 2206), C vector 2208, and D vector 2210 indicate four sets of weights maintained by the node. Each of these sets of weights is used to contribute to the performance of an active inference task by the network (e.g., network). The values of the weights shown in the example of FIG. 22 are initial weight values that may be assigned to a newly-initialized node of the network (e.g., network), also referred to as an undifferentiated node or a stem node. The node may be deployed within the network to contribute to an inference task during a runtime period, during which the node may differentiate itself by adjusting its weight values to diverge from their initial values in response to interactions with other nodes of the network. A node that has undergone at least partial differentiation may be referred to as a differentiated node.

[0314] In some examples, the inference task performed by the network is an active inference task. In active inference, as described herein, a machine learning model acts upon a system and observes the system.

[0315] In some examples, the A tensor 2202 may be regarded as modeling a probabilistic mapping of the node's observations (e.g., its inputs at a given time step) to an inferred hidden state of the observed system (e.g.,a node or set of nodes). This mapping may be referred to as an observational model, denoted as:Observational Model

[0316] In the example shown in FIG. 22, the A tensor 2202 is initialized as an identity matrix mapping observed inputs to exactly equivalent hidden states. In some examples, the inputs received by a node are equivalent to the state of the observed system; thus, there are no hidden states, and the A tensor 2202 may remain unchanged during differentiation.

[0317] In some examples, the B matrix 2212 may be regarded as modeling a probabilistic mapping of the node's observations (e.g., its inputs) at a given time step T-1 to a predicted set of observations at a subsequent time step T. This mapping may be referred to as a transition model, denoted as:Transition Model

[0318] In some examples, the B matrix 2212 includes a separate submatrix for each set of outputs of the node at the first time step. Thus, the predicted inputs at the second time step are conditioned on the outputs of the node at the first time step. In the example shown in FIG. 22, the node has only a single output (e.g., a binary activation value) having only two possible states, 1 or 0. The B matrix 2212 therefore consists of two submatrices: a Bo submatrix 2204 corresponding to output 0, and a Bi submatrix 2206 corresponding to output 1.

[0319] In the example shown in FIG. 22, Bo submatrix 2204 and Bi submatrix 2206 are both initialized as homogeneous matrices (e.g., all matrix elements set to a value of 0.5) mapping all observed inputs at thefirst time step with equal probabilities to predicted inputs at the second time step.

[0320] In some examples, the C vector 2208 may be regarded as modeling a prior probability distribution (also referred to simply as a prior) over the node's observations (e.g., its inputs). This prior over observations may be referred to as the node's preferences or prior preferences, and is denoted as:PipPrior Over Observations

[0321] In the example shown in FIG. 22, the C vector 2208 is initialized as a zero vector mapping all observations to a zero reward. Thus, a node initialized according to the initial values shown in FIG. 22 has no preferred values for its inputs.

[0322] In some examples, the D vector 2210 may be regarded as modeling a prior over an initial hidden state at initial time step T=1. This prior over the initial hidden state is denoted as:Prior Over Initial Hidden State

[0323] In the example shown in FIG. 22, the D vector 2210 is initialized as a homogeneous vector (e.g., all vector components set to a value of 0.5) weighting all initial state values equally. Thus, a node initialized according to the initial values shown in FIG. 22 has no a priori beliefs about an initial state of the observed system.

[0324] In some examples, the B matrix 2212 may be the primary or the only set of weights to be adjusted during differentiation of the node: in other words, each of the other sets of weights (the A tensor 2202, Cvector 2208, and D vector 2210) remains constant, whereas the transition model (implemented by the B matrix 2212) is adjusted to attempt to predict state transitions by the observed system (e.g., other connected nodes), conditioned on the actions (e.g., outputs) of the node. However, in some examples, one or more of the other sets of weights may also be adjusted during differentiation.

[0325] In some cases, the C vector 2208 is used to guide the system's determination of variable free energy. Variable free energy can be determined based on a pragmatic term ("does the node get what is expected") or an epistemic term ("does the node learn?"). The C vector can be used to adjust the balance between the pragmatic and epistemic term. For example, the C vector can be set to 0 whereby the node is maximizing epistemic gain.

[0326] In some cases, the system applies a pragmatic term that focuses on the practical use or application of a concept, emphasizing its utility in real-world scenarios. The system can prioritize pragmatic terms to enable the machine learning model to focus on action, decision-making, and achieving specific outcomes. For example, the system increases the pragmatic term in the C vector 2208 such that the model focuses more on improving accuracy, efficiency, performance, or the like.

[0327] In some cases, the system applies an epistemic term that pertains to knowledge, understanding, and information. The system can prioritize epistemic terms such that the machine learning model focuses on gaining insight on the functions performed by the machine learning model and updating the model to learn from current inferences. For instance, the system increases the epistemic terms in the C vector 2208 such that the model focuses on certainty, uncertainty, and knowledge of the machine learning model.

[0328] FIG. 23 through FIG. 27 illustrate examples of how the weights of the B matrix 2212 of a node may change during differentiation to adapt to different systems exhibiting different behaviors in response to the node's own actions.

[0329] FIG. 23 shows an initial Bo submatrix 1702, equivalent to the initial state of the Bo submatrix 2204 shown in FIG. 22. The initial Bo submatrix 1702 is the matrix of predictions for a future observation on the state of a system. In the illustrated example, the observed system is a single other node connected to the node associated with the initial Bo submatrix 1702, and the observed node generates a single binary output of one bit value at each time step.

[0330] The initial Bo submatrix 1702 includes two columns of weights corresponding to two first time step inputs 1706. The first time step inputs 1706 are observation of two different states of the system at a previous time step T-1 (also referred to herein as the first time step). The weights for 0 input at first time step 1708 are in the left column, and the weights for 1 input at first time step 1710 are in the right column.

[0331] These columns are split into two rows, the second time step inputs 1704, corresponding to observation of two different states of the system at a current time step T (also referred to herein as the second time step). The weights for 0 input at second time step 1712 are in the top row, and the weights for 1 input at second time step 1714 are in the bottom row.

[0332] It will be appreciated that, for nodes observing systems with more complex outputs (e.g., multiple connected nodes or nodes generating outputs more complex than a single bit per time step), the initial Bo submatrix 1702 would include more columns and rows. For example, a node connected to three other nodes, each outputting a single bit at each time step, would need an initial Bo submatrix 1702 with 23= 8 columns and 8 rows to map all previously observed system states to all predicted current systems states.

[0333] As described above, the initial Bo submatrix 1702 is a probabilistic mapping of previous observations to predicted current observations, conditioned on the output of the node at time step T-1 having been the binary value 0. The Bi submatrix 2206, by contrast, stores the weight values mapping previous observations to predicted current observations conditioned on the output of the node at time step T-1 having been the binary value 1. It will be appreciated that, for nodes having a morecomplex output than a single bit at each time step, a greater number of B submatrices would be required, equal to the number of possible output states (e.g., 8 submatrices for a 3 -bit binary output).

[0334] Because the nodes of the network generate their outputs for a given time step T prior to receiving their neighboring nodes' outputs for time step T, the computations informed by the weights of the initial Bo submatrix 1702 are performed after time step T-1 and before time step T. Thus, time step T may either be referred to as the “current” time step (meaning the time step for which the current outputs are being computed) or as the “next” or “future” time step (because the observations at time step T are not yet known).

[0335] During the runtime period, the node uses the weight values of initial Bo submatrix 1702 to perform active inference, in which the initial Bo submatrix 1702 predicts the state of the observed system, conditioned on the previous observed state of the system and conditioned on the node's own previous output. To the extent that observations diverge from the predicted observations of the second time step inputs 1704, the node may adjust the weights of the B submatrices in an attempt to minimize future VFE resulting from the uncertainty of the predictions. In this way, the initial Bo submatrix 1702 may have its weights adjusted over time to align with the observed system, and thereby differentiate itself from its initial neutral or naive state.

[0336] FIG. 24 shows the initial Bo submatrix 1702 after having undergone differentiation to align itself with an observed system - in this example, another node - that is configured to employ a “tit for tat” strategy in an iterated prisoner's dilemma task. The tit for tat strategy is one in which an agent will defect (in this example, output a “1”) immediately after an opponent defects, and will cooperate (in this example, output a “0”) immediately after an opponent cooperates. Thus, the output of the observed node is a deterministic function of this node's own previous action: in this example, if the node output a “1” at time step T-1, then the observed node will output a “1” at time step T, and if the node output a“0” at time step T-1, then the observed node will output a “0” at time step T.

[0337] Thus, after the node has undergone differentiation to align with the observed node employing the tit for tat strategy, the node will adjust the weights of its initial Bo submatrix 1702 to the values shown in the differentiated Bo submatrix 2402: the weights for 0 input at second time step 1712 are all 1, indicating a 100% probability that a previous output of “0” will result in a current observation of a “0”, and the weights for 1 input at second time step 1714 are all 0, indicating a 0% probability that a previous output of “0” will result in a current observation of a “1”. These weight values are set across both columns, indicating that they apply regardless of the previous observed state of the system.

[0338] By differentiating nodes to align them with their observed systems, some examples described herein may train the nodes of the network to generate inferences about the behavior of the rest of the system including (for environment-facing nodes) the environment outside of the machine learning model.

[0339] FIG. 25 and FIG. 26 show the same process of differentiation to align with a “tit for tat” observed node as the differentiation adjusts the weight values of the Bi submatrix 2206. Initial Bi submatrix 1802 has the same values as initial Bo submatrix 1702. The first time step inputs 1806 are mapped to the second time step inputs 1804 using weights split into two columns (weights for 0 input at first time step 1808 and weights for 1 input at first time step 1810) and two rows (weights for 0 input at second time step 1812 and weights for 1 input at second time step 1814). The mapping of initial Bi submatrix 1802 is conditioned on the output of the node at time step T-1 being “1”.

[0340] As the node differentiates to align with the observed tit for tat strategy of its neighboring node, the initial Bi submatrix 1802 adjusts its weight values to those shown in the differentiated Bi submatrix 2602: the weights for 0 input at second time step 1812 are all 0, indicating a 0% probability that a previous output of “1” will result in a current observation of a “0”, and the weights for 1 input at second time step 1814are all 1, indicating a 100% probability that a previous output of “1” will result in a current observation of a “1”. These weight values are set across both columns, indicating that they apply regardless of the previous observed state of the system.

[0341] FIG. 27 shows an initial B matrix 2702 (equivalent to B matrix 2212 shown in FIG. 22), and its potential to differentiate into multiple possible differentiated values depending on the behavior of the observed system. In this example, the observed system is a single node playing an iterated prisoner's dilemma task, as in the examples of FIG. 23 through FIG. 26.

[0342] If the observed node employs a tit for tat strategy, the initial B matrix 2702 will differentiate over time into the tit-for-tat differentiated B matrix 2704, whose Bo and Bi submatrices are equivalent to differentiated Bo submatrix 2402 and differentiated Bi submatrix 2602 shown in FIG. 24 and FIG. 26. The tit-for-tat differentiated B matrix 2704 exhibits absolute certainty in its predictions: the previous action of the node is determinative of the next observed state of the system, due to the nature of the tit for tat strategy.

[0343] If the observed node employs an “always defect” strategy, the initial B matrix 2702 will differentiate over time into the defector differentiated B matrix 2706. In an always defect strategy, the observed node always outputs “1”, irrespective of previous outputs and irrespective of inputs. As a result, the node observing the defector node will have complete certainty (weights 0 and 1) about the next observed state: it can predict with 100% confidence that the next observed state will always be “1”. Notably, this prediction is premised on the previous observed state being “1” as well: the 1 and 0 weight values are only in the right column of the Bo submatrix 2204 and Bi submatrix 2206. Because the node has never observed a system state of “0”, the weights in the left columns are completely undifferentiated from their initial values of 0.5.

[0344] In the final illustrated example, if the observed node employs a “random” strategy, the initial B matrix 2702 will differentiate over time into a form resembling the random differentiated B matrix 2708. In a random strategy, the observed node outputs “0” or “1” randomly,irrespective of previous outputs and irrespective of inputs. As a result, the node observing the random node will remain largely undifferentiated (weights all at approximately 0.5) about the next observed state: it cannot predict the next observed state with any confidence.

[0345] Each of these differentiated states in the matrices 2704, 2706, or 2708 of the B matrix 2212 of a node presents an example of a different degree of two capabilities of the node: predictive certainty and self- efficacy. Predictive certainty refers to the degree of certainty in the node's predictions: the tit-for-tat differentiated B matrix 2704 exhibits perfect predictive certainty, the defector differentiated B matrix 2706 exhibits perfect predictive certainty only under some conditions (it is certain as long as the observed state is “1”, but would be completely uncertain at the next time step if it ever observed a “0”), and the random differentiated B matrix 2708 has no predictive certainty.

[0346] The second capability of the node, self-efficacy, refers to a measure of the ability of the output of the node at the previous time step T-1 to affect the observations of the node at the current time step T. The self- efficacy of a node is high if the state of its previous outputs result in highly certain current observations. Thus, the tit-for-tat differentiated B matrix 2704 has very high self-efficacy, because its own action is completely determinative of the next observation, which will always be exactly equal to the node's own previous output. The self-efficacy of the defector differentiated B matrix 2706, by contrast, is very low, even though its predictive certainty is perfect for half of the possible observed previous states; the previous output of the node has no effect on its next observation. Finally, the self-efficacy of the random differentiated B matrix 2708 is also very low, because its outputs also have no effect on later observations.

[0347] Thus, predictive certainty may be regarded as a precondition for self-efficacy, but insufficient in itself to secure high self-efficacy.

[0348] In nodes having no preferences, such as the initial POMDP tensors described with reference to FIG. 22 above having zero values for the C vector 2208, high self-efficacy maps directly to low VFE. However, inexamples having preferences, minimizing VFE may require preferences to be satisfied, which requires not only self-efficacy but specifically self- efficacy with respect to soliciting preferred observations. For example, a node with preference (e.g., with non-zero values for the weights of the C vector 2208) may learn how to reliably solicit a current “1” observation under certain previous output and observation states; however, if the node prefers to observe “0” states of the observed system, and has not learned a way to reliably solicit “0” observations, the self-efficacy of the node will be very low.

[0349] In some examples, predictive certainty or self-efficacy may be measured with respect to individual connections of a node. The certainty with which a node can predict inputs received via a given connection may be regarded as the node's predictive certainty with respect to that connection. Similarly, the extent to which a node's outputs via a given connection affect the state of one or more inputs subsequently observed may be regarded as the self-efficacy of that connection. In some examples, self-efficacy is computed for pairs of connections, such that the self-efficacy of a bidirectional pair of connections between a first node and a second node measures the degree to which the first node's output(s) to the second node affect the first node's subsequent observation of the second node's output(s). In some examples, the self- efficacy of a connection from the first node to the second node may instead be a measure of the degree to which the first node's output(s) to the second node affect all observations of the first node with respect to all of its connected nodes.

[0350] In some examples, the self-efficacy of each of a node's connections can be combined to generate a nodal self-efficacy measure. In some examples, the nodal self-efficacy of a node is computed as the sum of the self-efficacy of each of its outbound connections. In other examples, the nodal self-efficacy of a node is computed as an average (such as an arithmetic or geometric mean, a median, or another averaging function), or as some other combination of the self-efficacy measures of each of its outbound connections.

[0351] In some examples, the self-efficacy of a connection can be computed as the mean of the absolute difference between the submatrices conditioned on each action, e.g., Bo submatrix 2204 and Bi submatrix 2206. (For nodes having multiple connections, self-efficacy for a given connection may be computed by isolating the observations and predictions of the B matrix 2212 for the connection being measured.) Thus, the self-efficacy for tit-for-tat differentiated B matrix 2704 is the maximum value of 1 :Self-efficacy (S) for tit-for-tat differentiated B matrix 2704

[0352] In contrast, the self-efficacy for defector differentiated B matrix 2706 is the minimum value of 0:Self-efficacy (S) for defector differentiated B matrix 2706MACHINE-LEARNING PIPELINE

[0353] FIG. 28 is a flowchart depicting a machine-learning pipeline 2900, and FIG. 29 is a schematic diagram illustrating the training and use of an example machine-learning program. FIG. 28 and FIG. 29 provide context for examples described herein by describing various techniques and approaches to structuring, training, validating, and or deploying a machine learning model. One or more features of the machine learning models described in FIG. 28 and FIG. 29 are example features can be applied to the examples described herein, where applicable. In somecases, the features described herein can be applied to one or more machine learning models described in FIG. 28 and FIG. 29.

[0354] The machine-learning pipeline 2900 may be used to generate a trained machine learning model, for example the trained machinelearning program 2902 of FIG. 29, to perform operations associated with searches and query responses.Overview

[0355] Broadly, machine learning may involve using computer algorithms to automatically learn patterns and relationships in data, potentially without the need for explicit programming. Machine learning algorithms can be divided into three main categories: supervised learning, unsupervised learning, and reinforcement learning.• Supervised learning involves training a model using labeled data to predict an output for new, unseen inputs. Examples of supervised learning algorithms include linear regression, decision trees, and neural networks.• Unsupervised learning involves training a model on unlabeled data to find hidden patterns and relationships in the data. Examples of unsupervised learning algorithms include clustering, principal component analysis, and generative models like autoencoders.• Reinforcement learning involves training a model to make decisions in a dynamic environment by receiving feedback in the form of rewards or penalties. Examples of reinforcement learning algorithms include Q- learning and policy gradient methods.

[0349] Examples of specific machine learning algorithms that may be deployed, according to some examples, include logistic regression, which is a type of supervised learning algorithm used for binary classification tasks. Logistic regression models the probability of a binary response variable based on one or more predictor variables. Another example type of machine learning algorithm is Naive Bayes, which is another supervised learning algorithm used for classification tasks. Naive Bayes is based on Bayes' theorem and assumes that the predictor variables are independent of each other. Random Forest is another type of supervisedlearning algorithm used for classification, regression, and other tasks. Random Forest builds a collection of decision trees and combines their outputs to make predictions. Further examples include neural networks, which consist of interconnected layers of nodes (or neurons) that process information and make predictions based on the input data. Matrix factorization is another type of machine learning algorithm used for recommender systems and other tasks. Matrix factorization decomposes a matrix into two or more matrices to uncover hidden patterns or relationships in the data. Support Vector Machines (SVM) are a type of supervised learning algorithm used for classification, regression, and other tasks. SVM finds a hyperplane that separates the different classes in the data. Other types of machine learning algorithms include decision trees, k-nearest neighbors, clustering algorithms, and deep learning algorithms such as convolutional neural networks (CNN), recurrent neural networks (RNN), and transformer models. The choice of algorithm depends on the nature of the data, the complexity of the problem, and the performance requirements of the application.

[0350] The performance of machine learning models is typically evaluated on a separate test set of data that was not used during training to ensure that the model can generalize to new, unseen data.

[0351] Although several specific examples of machine learning algorithms are discussed herein, the principles discussed herein can be applied to other machine learning algorithms as well. Deep learning algorithms such as convolutional neural networks, recurrent neural networks, and transformers, as well as more traditional machine learning algorithms like decision trees, random forests, and gradient boosting may be used in various machine learning applications.

[0352] Machine learning models are trained to perform specific types of inference tasks. Two example types of inference tasks in machine learning are classification tasks and regression tasks. Classification tasks, also referred to as categorization tasks, aim at classifying items into one of several category values (for example, is this object an apple or an orange?). Regression algorithms aim at quantifying some items (forexample, by providing a value that is a real number) to perform a regression task.

[0353] Generating a trained machine-learning program 2902 may include multiple phases that form part of the machine-learning pipeline 2900, including for example the following phases illustrated in FIG. 28:• Data collection and preprocessing 2802: This phase may include acquiring and cleaning data to ensure that it is suitable for use in the machine learning model. This phase may also include removing duplicates, handling missing values, and converting data into a suitable format.• Feature engineering 2804: This phase may include selecting and transforming the training data 2906 to create features that are useful for predicting the target variable. Feature engineering may include (1) receiving features 2908 (e.g., as structured or labeled data in supervised learning) or (2) identifying features 2908 (e.g., unstructured or unlabeled data for unsupervised learning) in training data 2906.• Model selection and training 2806: This phase may include selecting an appropriate machine learning algorithm and training it on the preprocessed data. This phase may further involve splitting the data into training and testing sets, using cross-validation to evaluate the model, and tuning hyperparameters to improve performance.• Model evaluation 2808: This phase may include evaluating the performance of a trained model (e.g., the trained machine-learning program 2902) on a separate testing dataset. This phase can help determine if the model is overfitting or underfitting and determine whether the model is suitable for deployment.• Prediction 2810: This phase involves using a trained model (e.g., trained machine-learning program 2902) to generate predictions on new, unseen data.• Validation, refinement or retraining 2812: This phase may include updating a model based on feedback generated from the prediction phase, such as new data or user feedback.• Deployment 2814: This phase may include integrating the trained model (e.g., the trained machine-learning program 2902) into a more extensive system or application, such as a web service, mobile app, or loT device. This phase can involve setting up APIs, building a user interface, and ensuring that the model is scalable and can handle large volumes of data.

[0354] FIG. 29 illustrates further details of two example phases, namely a training phase 2904 (e.g., part of the model selection and trainings model selection and training 2806) and a prediction phase 2910 (part of prediction 2810). Prior to the training phase 2904, feature engineering 2804 is used to identify features 2908. This may include identifying informative, discriminating, and independent features for effectively operating the trained machine-learning program 2902 in pattern recognition, classification, and regression. In some examples, the training data 2906 includes labeled data, known for pre-identified features 2908 and one or more outcomes. Each of the features 2908 may be a variable or attribute, such as an individual measurable property of a process, article, system, or phenomenon represented by a data set (e.g., the training data 2906). Features 2908 may also be of different types, such as numeric features, strings, and graphs, and may include one or more of content 2912, concepts 2914, attributes 2916, historical data 2918, or user data 2920, merely for example.

[0355] In training phase 2904, also referred to herein as a training period, the machine-learning pipeline 2900 uses the training data 2906 to find correlations among the features 2908 that affect a predicted outcome or prediction / inference data 2922. The training data may also be referred to herein as reference data, because it is used as a reference for setting the trained parameter values of the model.

[0356] With the training data 2906 and the identified features 2908, the trained machine-learning program 2902 is trained during the training phase 2904 during machine-learning program training 2924. The machine-learning program training 2924 appraises values of the features 2908 as they correlate to the training data 2906. The result of the trainingis the trained machine-learning program 2902 (e.g., a trained or learned model).

[0357] Further, the training phase 2904 may involve machine learning, in which the training data 2906 is structured (e.g., labeled during preprocessing operations). The trained machine-learning program 2902 implements a neural network 2926 capable of performing, for example, classification and clustering operations. In other examples, the training phase 2904 may involve deep learning, in which the training data 2906 is unstructured, and the trained machine-learning program 2902 implements a deep neural network 2926 that can perform both feature extraction and classification / clustering operations.

[0358] In some examples, a neural network may be generated during the training phase 2904, and implemented within the trained machinelearning program 2902. The neural network 2926 includes a hierarchical (e.g., layered) organization of neurons, with each layer consisting of multiple neurons or nodes. Neurons in the input layer receive the input data, while neurons in the output layer produce the final output of the network. Between the input and output layers, there may be one or more hidden layers, each consisting of multiple neurons.

[0359] Each neuron in the neural network 2926 operationally computes a function, such as an activation function, which takes as input the weighted sum of the outputs of the neurons in the previous layer, as well as a bias term. The output of this function is then passed as input to the neurons in the next layer. If the output of the activation function exceeds a certain threshold, an output is communicated from that neuron (e.g., transmitting neuron) to a connected neuron (e.g., receiving neuron) in successive layers. The connections between neurons have associated weights, which define the influence of the input from a transmitting neuron to a receiving neuron. During the training phase, these weights are adjusted by the learning algorithm to optimize the performance of the network. Different types of neural networks may use different activation functions and learning algorithms, affecting their performance on different tasks. The layered organization of neurons and the use ofactivation functions and weights enable neural networks to model complex relationships between inputs and outputs, and to generalize to new inputs that were not seen during training.

[0360] In some examples, the neural network 2926 may also be one of several different types of neural networks, such as a single-layer feedforward network, a Multilayer Perceptron (MLP), an Artificial Neural Network (ANN), a Recurrent Neural Network (RNN), a Long Short- Term Memory Network (LSTM), a Bidirectional Neural Network, a symmetrically connected neural network, a Deep Belief Network (DBN), a Convolutional Neural Network (CNN), a Generative Adversarial Network (GAN), an Autoencoder Neural Network (AE), a Restricted Boltzmann Machine (RBM), a Hopfield Network, a Self-Organizing Map (SOM), a Radial Basis Function Network (RBFN), a Spiking Neural Network (SNN), a Liquid State Machine (LSM), an Echo State Network (ESN), a Neural Turing Machine (NTM), or a Transformer Network, merely for example.

[0361] In addition to the training phase 2904, a validation phase may be performed on a separate dataset known as the validation dataset. The validation dataset is used to tune the hyperparameters of a model, such as the learning rate and the regularization parameter. The hyperparameters are adjusted to improve the model's performance on the validation dataset.

[0362] Once a model is fully trained and validated, in a testing phase, the model may be tested on a new dataset. The testing dataset is used to evaluate the model's performance and ensure that the model has not overfitted the training data.

[0363] In prediction phase 2910, also referred to herein as a runtime period, the trained machine-learning program 2902 uses the features 2908 for analyzing query data 2928 to generate inferences, outcomes, or predictions, as examples of a prediction / inference data 2922. For example, during prediction phase 2910, the trained machine-learning program 2902 generates an output. Query data 2928 is provided as an input to the trained machine-learning program 2902, and the trainedmachine-learning program 2902 generates the prediction / inference data 2922 as output, responsive to receipt of the query data 2928. Query data processed by the model during the runtime phase may also be referred to herein as candidate data, because it is data that is a priori not associated with any particular inference output.

[0364] In some examples, the trained machine-learning program 2902 may be a generative Al model. Generative Al is a term that may refer to any type of artificial intelligence that can create new content from training data 2906. For example, generative Al can produce text, images, video, audio, code, or synthetic data similar to the original data but not identical.

[0365] Some of the techniques that may be used in generative Al are:• Convolutional Neural Networks (CNNs): CNNs may be used for image recognition and computer vision tasks. CNNs may, for example, be designed to extract features from images by using filters or kernels that scan the input image and highlight important patterns.• Recurrent Neural Networks (RNNs): RNNs may be used for processing sequential data, such as speech, text, and time series data, for example. RNNs employ feedback loops that allow them to capture temporal dependencies and remember past inputs. The feedback loops of an RNN can be considered a cycle within its network.• Generative adversarial networks (GANs): GNNs may include two neural networks: a generator and a discriminator. The generator network attempts to create realistic content that can “fool” the discriminator network, while the discriminator network attempts to distinguish between real and fake content. The generator and discriminator networks compete with each other and improve over time.• Variational autoencoders (VAEs): VAEs may encode input data into a latent space (e.g., a compressed representation) and then decode it back into output data. The latent space can be manipulated to generate new variations of the output data. VAEs may use self-attention mechanisms to process input data, allowing them to handle long text sequences and capture complex dependencies.• Transformer models: Transformer models may use attention mechanisms to learn the relationships between different parts of input data (such as words or pixels) and generate output data based on these relationships. Transformer models can handle sequential data, such as text or speech, as well as non-sequential data, such as images or code.

[0366] In generative Al examples, the output prediction / inference data 2922 include predictions, translations, summaries or media content.MACHINE ARCHITECTURE

[0367] FIG. 30 is a diagrammatic representation of the machine 3000 within which instructions 3002 (e.g., software, a program, an application, an applet, an app, or other executable code) for causing the machine 3000 to perform any one or more of the methodologies discussed herein may be executed. For example, the instructions 3002 may cause the machine 3000 to execute any one or more of the methods described herein. The instructions 3002 transform the general, non-programmed machine 3000 into a particular machine 3000 programmed to carry out the described and illustrated functions in the manner described. The machine 3000 may operate as a standalone device or may be coupled (e.g., networked) to other machines. In a networked deployment, the machine 3000 may operate in the capacity of a server machine or a client machine in a server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine 3000 may comprise, but not be limited to, a server computer, a client computer, a personal computer (PC), a tablet computer, a laptop computer, a netbook, a set-top box (STB), a personal digital assistant (PDA), an entertainment media system, a cellular telephone, a smartphone, a mobile device, a wearable device (e.g., a smartwatch), a smart home device (e.g., a smart appliance), other smart devices, a web appliance, a network router, a network switch, a network bridge, or any machine capable of executing the instructions 3002, sequentially or otherwise, that specify actions to be taken by the machine 3000. Further, while a single machine 3000 is illustrated, the term “machine" shall also be taken to include a collection of machines that individually or jointly execute the instructions 3002 toperform any one or more of the methodologies discussed herein. In some examples, the machine 3000 may comprise both client and server systems, with certain operations of a particular method or algorithm being performed on the server-side and with certain operations of the particular method or algorithm being performed on the client-side.

[0368] The machine 3000 may include processors 3004, memory 3006, and input / output I / O components 3008, which may be configured to communicate with each other via a bus 3010. In an example, the processors 3004 (e.g., a Central Processing Unit (CPU), a Reduced Instruction Set Computing (RISC) Processor, a Complex Instruction Set Computing (CISC) Processor, a Graphics Processing Unit (GPU), a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Radio-Frequency Integrated Circuit (RFIC), another processor, or any suitable combination thereof) may include, for example, a processor 3012 and a processor 3014 that execute the instructions 3002. The term "processor" is intended to include multi-core processors that may comprise two or more independent processors (sometimes referred to as “cores”) that may execute instructions contemporaneously. Although FIG. 30 shows multiple processors 3004, the machine 3000 may include a single processor with a single-core, a single processor with multiple cores (e.g., a multi-core processor), multiple processors with a single core, multiple processors with multiples cores, or any combination thereof.

[0369] The memory 3006 includes a main memory 3016, a static memory 3018, and a storage unit 3020, both accessible to the processors 3004 via the bus 3010. The main memory 3006, the static memory 3018, and storage unit 3020 store the instructions 3002 embodying any one or more of the methodologies or functions described herein. The instructions 3002 may also reside, completely or partially, within the main memory 3016, within the static memory 3018, within machine-readable medium 3022 within the storage unit 3020, within at least one of the processors 3004 (e.g., within the processor’s cache memory), or any suitable combination thereof, during execution thereof by the machine 3000.

[0370] The I / O components 3008 may include a wide variety of components to receive input, provide output, produce output, transmit information, exchange information, capture measurements, and so on. The specific I / O components 3008 that are included in a particular machine will depend on the type of machine. For example, portable machines such as mobile phones may include a touch input device or other such input mechanisms, while a headless server machine will likely not include such a touch input device. It will be appreciated that the I / O components 3008 may include many other components that are not shown in FIG. 30. In various examples, the VO components 3008 may include user output components 3024 and user input components 3026. The user output components 3024 may include visual components (e.g., a display such as a plasma display panel (PDP), a light-emitting diode (LED) display, a liquid crystal display (LCD), a projector, or a cathode ray tube (CRT)), acoustic components (e.g., speakers), haptic components (e.g., a vibratory motor, resistance mechanisms), other signal generators, and so forth. The user input components 3026 may include alphanumeric input components (e.g., a keyboard, a touch screen configured to receive alphanumeric input, a photo-optical keyboard, or other alphanumeric input components), point-based input components (e.g., a mouse, a touchpad, a trackball, a joystick, a motion sensor, or another pointing instrument), tactile input components (e.g., a physical button, a touch screen that provides location and force of touches or touch gestures, or other tactile input components), audio input components (e.g., a microphone), and the like.

[0371] Communication may be implemented using a wide variety of technologies. The I / O components 3008 further include communication components 3028 operable to couple the machine 3000 to a network 3030 or devices 3032 via respective coupling or connections. For example, the communication components 3028 may include a network interface component or another suitable device to interface with the network 3030. In further examples, the communication components 3028 may include wired communication components, wireless communication components, cellular communication components, Near Field Communication (NFC)components, Bluetooth® components (e.g., Bluetooth® Low Energy), WiFi® components, and other communication components to provide communication via other modalities. The devices 3032 may be another machine or any of a wide variety of peripheral devices (e.g., a peripheral device coupled via a USB).

[0372] Moreover, the communication components 3028 may detect identifiers or include components operable to detect identifiers. For example, the communication components 3028 may include Radio Frequency Identification (RFID) tag reader components, NFC smart tag detection components, optical reader components (e.g., an optical sensor to detect one-dimensional bar codes such as Universal Product Code (UPC) bar code, multi-dimensional bar codes such as Quick Response (QR) code, Aztec code, Data Matrix, Dataglyph™, MaxiCode, PDF417, Ultra Code, UCC RSS-2D bar code, and other optical codes), or acoustic detection components (e.g., microphones to identify tagged audio signals). In addition, a variety of information may be derived via the communication components 3028, such as location via Internet Protocol (IP) geolocation, location via Wi-Fi® signal triangulation, location via detecting an NFC beacon signal that may indicate a particular location, and so forth.

[0373] The various memories (e.g., main memory 3016, static memory 3018, and memory of the processors 3004) and storage unit 3020 may store one or more sets of instructions and data structures (e.g., software) embodying or used by any one or more of the methodologies or functions described herein. These instructions (e.g., the instructions 3002), when executed by processors 3004, cause various operations to implement the disclosed examples.

[0374] The instructions 3002 may be transmitted or received over the network 3030, using a transmission medium, via a network interface device (e.g., a network interface component included in the communication components 3028) and using any one of several well- known transfer protocols (e.g., hypertext transfer protocol (HTTP)). Similarly, the instructions 3002 may be transmitted or received using atransmission medium via a coupling (e.g., a peer-to-peer coupling) to the devices 3032.EXAMPLES

[0375] In view of the above-described implementations of subject matter this application discloses the following list of examples, wherein one feature of an example in isolation or more than one feature of an example, taken in combination and, optionally, in combination with one or more features of one or more further examples are further examples also falling within the disclosure of this application.

[0376] Example 1 is a system comprising: a processor; and a memory component storing instructions that, when executed by the processor, cause the processor to perform operations comprising: accessing a machine learning model, the machine learning model includes: a first group of nodes configured to perform a corresponding first function of the machine learning model; and a second group of nodes configured to perform a corresponding second function of the machine learning model; generating a user interface depicting a graphical representation of at least a portion of the machine learning model, the portion comprising at least some of the first group of nodes; presenting the user interface, the user interface including a user-selectable interface element configured to restructure an internal architecture of the machine learning model; receiving a selection from the user of the user-selectable interface element; and in response to the selection from the user of the user- selectable interface element: restructuring the internal architecture of the machine learning model by causing a change to at least one of a number of nodes in the first group of nodes or a number of connections in the first group of nodes; generating an updated user interface by modifying the graphical representation based on the restructuring of the internal architecture; and presenting the updated user interface to the user.

[0377] In Example 2, the subject matter of Example 1 includes, wherein the restructuring of the internal architecture causes the change in the number of nodes in the first group of nodes.

[0378] In Example 3, the subject matter of Example 2 includes, wherein the changing of the number of nodes in the first group of nodes comprises removing a first node in the first group of nodes.

[0379] In Example 4, the subject matter of Example 3 includes, wherein the removing of the first node comprises removing a first connection between the first node and a second node, removing a second connection between the first node and a third node, and creating a third connection between the second node and the third node.

[0380] In Example 5, the subject matter of Examples 3-4 includes, wherein the removing of the first node comprises identifying a second node that is no longer connected to other nodes as a result of removing the first node and removing the second node from the machine learning model.

[0381] In Example 6, the subject matter of Examples 2-5 includes, wherein the changing of the number of nodes in the first group of nodes comprises adding a new node to the first group of nodes and a new connection connecting the new node and a first node in the first group of nodes.

[0382] In Example 7, the subject matter of Example 6 includes, wherein the adding of the new node comprises adding the new node with at least one of weighting having identical values to weightings of the first node or the same connections as the first node with other nodes.

[0383] In Example 8, the subject matter of Examples 6-7 includes, wherein the adding of the new node comprises adding the new node with at least one of different weightings than the first node or different connections than the first node with other nodes.

[0384] In Example 9, the subject matter of Examples 2-8 includes, wherein the changing of the number of nodes in the first group of nodes comprises connecting an existing node external to the first group of nodes to the first group of nodes.

[0385] In Example 10, the subject matter of Examples 1-9 includes, wherein the restructuring of the internal architecture causes the change in the number of connections in the first group of nodes.

[0386] In Example 11, the subject matter of Examples 1-10 includes, wherein the selection of the user-selectable interface element comprises a user selection of the first group of nodes or an individual node in the first group of nodes.

[0387] In Example 12, the subject matter of Examples 1-11 includes, wherein the selection of the user-selectable interface element comprises a click and drag of the first group of nodes or an individual node in the first group of nodes from one location to another within the user interface.

[0388] In Example 13, the subject matter of Examples 1-12 includes, wherein the user interface depicts the machine learning model at runtime, wherein the user interface displays visual indicators indicative of data being passed between nodes of the machine learning model over a plurality of time steps.

[0389] In Example 14, the subject matter of Examples 1-13 includes, wherein the user interface further includes a visual indicator of a characteristic for the first group of nodes.

[0390] In Example 15, the subject matter of Example 14 includes, wherein a first node is connected with a second node in the first group of nodes, wherein the characteristic indicates a self-efficacy indicator of an output of the first node affecting an output of the second node.

[0391] In Example 16, the subject matter of Example 15 includes, wherein the self-efficacy indicator indicates an extent to which the output of the first node at a previous time step affects the output of the second node at a current time step, wherein the machine learning model is configured to transmit the output of the first node at the previous time step back to the first node as an input at the current time step.

[0392] In Example 17, the subject matter of Examples 14-16 includes, wherein a first node is connected with a second node in the first group of nodes, wherein the characteristic indicates a self-efficacy indicator of an output of the first node affecting an input from all other connected nodes.

[0393] In Example 18, the subject matter of Examples 14-17 includes, wherein a first node is connected with a second node in the first group ofnodes, wherein the characteristic indicates a variational free energy of the first node with respect to the second node that is connected to the first node, wherein variational free energy is based on one or more expected inputs of the first node and one or more actual inputs received by the first node.

[0394] Example 19 is a method comprising: accessing a machine learning model, the machine learning model includes: a first group of nodes configured to perform a corresponding first function of the machine learning model; and a second group of nodes configured to perform a corresponding second function of the machine learning model; generating a user interface depicting a graphical representation of at least a portion of the machine learning model, the portion comprising at least some of the first group of nodes; presenting the user interface, the user interface including a user-selectable interface element configured to restructure an internal architecture of the machine learning model; receiving a selection from the user of the user-selectable interface element; and in response to the selection from the user of the user- selectable interface element: restructuring the internal architecture of the machine learning model by causing a change to at least one of a number of nodes in the first group of nodes or a number of connections in the first group of nodes; generating an updated user interface by modifying the graphical representation based on the restructuring of the internal architecture; and presenting the updated user interface to the user.

[0395] Example 20 is a non-transitory computer-readable storage medium storing instructions that, when executed by at least one processor, cause the at least one processor to perform operations comprising: accessing a machine learning model, the machine learning model includes: a first group of nodes configured to perform a corresponding first function of the machine learning model; and a second group of nodes configured to perform a corresponding second function of the machine learning model; generating a user interface depicting a graphical representation of at least a portion of the machine learning model, the portion comprising at least some of the first group of nodes; presenting the user interface, the user interface including a user-selectable interface element configured torestructure an internal architecture of the machine learning model; receiving a selection from the user of the user-selectable interface element; and in response to the selection from the user of the user- selectable interface element: restructuring the internal architecture of the machine learning model by causing a change to at least one of a number of nodes in the first group of nodes or a number of connections in the first group of nodes; generating an updated user interface by modifying the graphical representation based on the restructuring of the internal architecture; and presenting the updated user interface to the user.

[0396] Example 21 is at least one machine-readable medium including instructions that, when executed by processing circuitry, cause the processing circuitry to perform operations to implement any of Examples 1-20.

[0397] Example 22 is an apparatus comprising means to implement any of Examples 1-20.

[0398] Example 23 is a system to implement any of Examples 1-20.

[0399] Example 24 is a method to implement any of Examples 1-20.CONCLUSION

[0400] Unless the context clearly requires otherwise, throughout the description and the claims, the words “comprise,” “comprising,” and the like are to be construed in an inclusive sense, as opposed to an exclusive or exhaustive sense, i.e., in the sense of “including, but not limited to.” As used herein, the terms “connected,” “coupled,” or any variant thereof means any connection or coupling, either direct or indirect, between two or more elements; the coupling or connection between the elements can be physical, logical, or a combination thereof. Additionally, the words “herein,” “above,” “below,” and words of similar import, when used in this application, refer to this application as a whole and not to any particular portions of this application. Where the context permits, words using the singular or plural number may also include the plural or singular number respectively. The word “or” in reference to a list of two or more items, covers all of the following interpretations of the word: any one of the items in the list, all of the items in the list, and anycombination of the items in the list. Likewise, the term “or” in reference to a list of two or more items, covers all of the following interpretations of the word: any one of the items in the list, all of the items in the list, and any combination of the items in the list.

[0401] Although some examples, e.g., those depicted in the drawings, include a particular sequence of operations, the sequence may be altered without departing from the scope of the present disclosure. For example, some of the operations depicted may be performed in parallel or in a different sequence that does not materially affect the functions as described in the examples. In other examples, different components of an example device or system that implements an example method may perform functions at substantially the same time or in a specific sequence.

[0402] The various features, steps, and processes described herein may be used independently of one another or may be combined in various ways. All possible combinations and subcombinations are intended to fall within the scope of this disclosure. In addition, certain method or process blocks may be omitted in some implementations.

[0403] A “non-transitory” machine-readable medium, as used herein, specifically excludes propagating signals per se. According to various example embodiments, the instructions for execution by a machine or processor can be communicated via a carrier medium (e.g., a machine- readable carrier medium). Examples of such a carrier medium include a non-transient carrier medium (e.g., a non-transitory machine-readable storage medium, such as a solid-state memory that is physically movable from one place to another place) and a transient carrier medium (e.g., a carrier wave or other propagating signal that communicates the instructions to the machine or processor).

Claims

CLAIMSWhat is claimed is:

1. A system comprising: a processor; and a memory component storing instructions that, when executed by the processor, cause the processor to perform operations comprising: accessing a machine learning model, the machine learning model includes: a first group of nodes configured to perform a corresponding first function of the machine learning model; and a second group of nodes configured to perform a corresponding second function of the machine learning model; generating a user interface depicting a graphical representation of at least a portion of the machine learning model, the portion comprising at least some of the first group of nodes; presenting the user interface, the user interface including a user- selectable interface element configured to restructure an internal architecture of the machine learning model; receiving a selection from the user of the user-selectable interface element; and in response to the selection from the user of the user-selectable interface element: restructuring the internal architecture of the machine learning model by causing a change to a number of nodes in the first group of nodes or a number of connections in the first group of nodes; generating an updated user interface by modifying the graphical representation based on the restructuring of the internal architecture; and presenting the updated user interface to the user.

2. The system of claim 1, wherein the restructuring of the internal architecture causes the change in the number of nodes in the first group of nodes.

3. The system of claim 2, wherein the changing of the number of nodes in the first group of nodes comprises removing a first node in the first group of nodes.

4. The system of claim 3, wherein the removing of the first node comprises removing a first connection between the first node and a second node, removing a second connection between the first node and a third node, and creating a third connection between the second node and the third node.

5. The system of claim 3, wherein the removing of the first node comprises identifying a second node that is no longer connected to other nodes as a result of removing the first node and removing the second node from the machine learning model.

6. The system of claim 2, wherein the changing of the number of nodes in the first group of nodes comprises adding a new node to the first group of nodes and a new connection connecting the new node and a first node in the first group of nodes.

7. The system of claim 6, wherein the adding of the new node comprises adding the new node with weighting having identical values to weightings of the first node or the same connections as the first node with other nodes.

8. The system of claim 6, wherein the adding of the new node comprises adding the new node with different weightings than the first node or different connections than the first node with other nodes.

9. The system of claim 2, wherein the changing of the number of nodes in the first group of nodes comprises connecting an existing node external to the first group of nodes to the first group of nodes.

10. The system of claim 1, wherein the restructuring of the internal architecture causes the change in the number of connections in the first group of nodes.

11. The system of claim 1, wherein the selection of the user-selectable interface element comprises a user selection of the first group of nodes or an individual node in the first group of nodes.

12. The system of claim 1, wherein the selection of the user-selectable interface element comprises a click and drag of the first group of nodes or an individual node in the first group of nodes from one location to another within the user interface.

13. The system of claim 1, wherein the user interface depicts the machine learning model at run-time, wherein the user interface displays visual indicators indicative of data being passed between nodes of the machine learning model over a plurality of time steps.

14. The system of claim 1, wherein the user interface further includes a visual indicator of a characteristic for the first group of nodes.

15. The system of claim 14, wherein a first node is connected with a second node in the first group of nodes, wherein the characteristic indicates a self- efficacy indicator of an output of the first node affecting an output of the second node.

16. The system of claim 15, wherein the self-efficacy indicator indicates an extent to which the output of the first node at a previous time step affects the output of the second node at a current time step, wherein the machine learning model is configured to transmit the output of the first node at the previous time step back to the first node as an input at the current time step.

17. The system of claim 14, wherein a first node is connected with a second node in the first group of nodes, wherein the characteristic indicates a self- efficacy indicator of an output of the first node affecting an input from all other connected nodes.

18. The system of claim 14, wherein a first node is connected with a second node in the first group of nodes, wherein the characteristic indicates a variational free energy of the first node with respect to the second node thatis connected to the first node, wherein variational free energy is based on one or more expected inputs of the first node and one or more actual inputs received by the first node.

19. A method comprising: accessing a machine learning model, the machine learning model includes: a first group of nodes configured to perform a corresponding first function of the machine learning model; and a second group of nodes configured to perform a corresponding second function of the machine learning model; generating a user interface depicting a graphical representation of at least a portion of the machine learning model, the portion comprising at least some of the first group of nodes; presenting the user interface, the user interface including a user- selectable interface element configured to restructure an internal architecture of the machine learning model; receiving a selection from the user of the user-selectable interface element; and in response to the selection from the user of the user-selectable interface element: restructuring the internal architecture of the machine learning model by causing a change to a number of nodes in the first group of nodes or a number of connections in the first group of nodes; generating an updated user interface by modifying the graphical representation based on the restructuring of the internal architecture; and presenting the updated user interface to the user.

20. A non-transitory computer-readable storage medium storing instructions that, when executed by at least one processor, cause the at least one processor to perform operations comprising: accessing a machine learning model, the machine learning model includes:a first group of nodes configured to perform a corresponding first function of the machine learning model; and a second group of nodes configured to perform a corresponding second function of the machine learning model; generating a user interface depicting a graphical representation of at least a portion of the machine learning model, the portion comprising at least some of the first group of nodes; presenting the user interface, the user interface including a user- selectable interface element configured to restructure an internal architecture of the machine learning model; receiving a selection from the user of the user-selectable interface element; and in response to the selection from the user of the user-selectable interface element: restructuring the internal architecture of the machine learning model by causing a change to a number of nodes in the first group of nodes or a number of connections in the first group of nodes; generating an updated user interface by modifying the graphical representation based on the restructuring of the internal architecture; and presenting the updated user interface to the user.

Images